diff --git a/.claude/launch.json b/.claude/launch.json
new file mode 100644
index 000000000..1ef1d0f2b
--- /dev/null
+++ b/.claude/launch.json
@@ -0,0 +1,11 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "code",
+      "runtimeExecutable": "pnpm",
+      "runtimeArgs": ["--filter", "code", "dev"],
+      "port": 5173
+    }
+  ]
+}
diff --git a/.claude/worktrees/gifted-haibt b/.claude/worktrees/gifted-haibt
new file mode 160000
index 000000000..53ed7f4e2
--- /dev/null
+++ b/.claude/worktrees/gifted-haibt
@@ -0,0 +1 @@
+Subproject commit 53ed7f4e23ebe2afb197fb2e9adfdb26afb25afb
diff --git a/apps/code/src/main/db/migrations/0003_bumpy_morgan_stark.sql b/apps/code/src/main/db/migrations/0003_bumpy_morgan_stark.sql
new file mode 100644
index 000000000..ccde634f2
--- /dev/null
+++ b/apps/code/src/main/db/migrations/0003_bumpy_morgan_stark.sql
@@ -0,0 +1,32 @@
+CREATE TABLE `automation_runs` (
+	`id` text PRIMARY KEY NOT NULL,
+	`automation_id` text NOT NULL,
+	`status` text NOT NULL,
+	`output` text,
+	`error` text,
+	`started_at` text NOT NULL,
+	`completed_at` text,
+	`created_at` text DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
+	FOREIGN KEY (`automation_id`) REFERENCES `automations`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE INDEX `automation_runs_automation_id_idx` ON `automation_runs` (`automation_id`);--> statement-breakpoint
+CREATE TABLE `automations` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL,
+	`prompt` text NOT NULL,
+	`repo_path` text NOT NULL,
+	`repository` text,
+	`github_integration_id` integer,
+	`schedule_time` text NOT NULL,
+	`timezone` text NOT NULL,
+	`enabled` integer DEFAULT true NOT NULL,
+	`template_id` text,
+	`last_run_at` text,
+	`last_run_status` text,
+	`last_task_id` text,
+	`last_error` text,
+	`next_run_at` text,
+	`created_at` text DEFAULT (CURRENT_TIMESTAMP) NOT NULL,
+	`updated_at` text DEFAULT (CURRENT_TIMESTAMP) NOT NULL
+);
diff --git a/apps/code/src/main/db/migrations/meta/0003_snapshot.json b/apps/code/src/main/db/migrations/meta/0003_snapshot.json
new file mode 100644
index 000000000..c5d0919f6
--- /dev/null
+++ b/apps/code/src/main/db/migrations/meta/0003_snapshot.json
@@ -0,0 +1,654 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "b2235e08-596a-4baa-b107-d676f1882b17",
+  "prevId": "f5d77788-5c4e-4bfa-a114-096b8d377332",
+  "tables": {
+    "archives": {
+      "name": "archives",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "branch_name": {
+          "name": "branch_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "checkpoint_id": {
+          "name": "checkpoint_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {
+        "archives_workspaceId_unique": {
+          "name": "archives_workspaceId_unique",
+          "columns": [
+            "workspace_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "archives_workspace_id_workspaces_id_fk": {
+          "name": "archives_workspace_id_workspaces_id_fk",
+          "tableFrom": "archives",
+          "tableTo": "workspaces",
+          "columnsFrom": [
+            "workspace_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "automation_runs": {
+      "name": "automation_runs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "automation_id": {
+          "name": "automation_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "output": {
+          "name": "output",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {
+        "automation_runs_automation_id_idx": {
+          "name": "automation_runs_automation_id_idx",
+          "columns": [
+            "automation_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "automation_runs_automation_id_automations_id_fk": {
+          "name": "automation_runs_automation_id_automations_id_fk",
+          "tableFrom": "automation_runs",
+          "tableTo": "automations",
+          "columnsFrom": [
+            "automation_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "automations": {
+      "name": "automations",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "prompt": {
+          "name": "prompt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "repo_path": {
+          "name": "repo_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "repository": {
+          "name": "repository",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "github_integration_id": {
+          "name": "github_integration_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "schedule_time": {
+          "name": "schedule_time",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "template_id": {
+          "name": "template_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_run_status": {
+          "name": "last_run_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_task_id": {
+          "name": "last_task_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "next_run_at": {
+          "name": "next_run_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "repositories": {
+      "name": "repositories",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "remote_url": {
+          "name": "remote_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_accessed_at": {
+          "name": "last_accessed_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {
+        "repositories_path_unique": {
+          "name": "repositories_path_unique",
+          "columns": [
+            "path"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "suspensions": {
+      "name": "suspensions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "branch_name": {
+          "name": "branch_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "checkpoint_id": {
+          "name": "checkpoint_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "suspended_at": {
+          "name": "suspended_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {
+        "suspensions_workspaceId_unique": {
+          "name": "suspensions_workspaceId_unique",
+          "columns": [
+            "workspace_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "suspensions_workspace_id_workspaces_id_fk": {
+          "name": "suspensions_workspace_id_workspaces_id_fk",
+          "tableFrom": "suspensions",
+          "tableTo": "workspaces",
+          "columnsFrom": [
+            "workspace_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "workspaces": {
+      "name": "workspaces",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "task_id": {
+          "name": "task_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "repository_id": {
+          "name": "repository_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "mode": {
+          "name": "mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "pinned_at": {
+          "name": "pinned_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_viewed_at": {
+          "name": "last_viewed_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_activity_at": {
+          "name": "last_activity_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {
+        "workspaces_taskId_unique": {
+          "name": "workspaces_taskId_unique",
+          "columns": [
+            "task_id"
+          ],
+          "isUnique": true
+        },
+        "workspaces_repository_id_idx": {
+          "name": "workspaces_repository_id_idx",
+          "columns": [
+            "repository_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "workspaces_repository_id_repositories_id_fk": {
+          "name": "workspaces_repository_id_repositories_id_fk",
+          "tableFrom": "workspaces",
+          "tableTo": "repositories",
+          "columnsFrom": [
+            "repository_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "worktrees": {
+      "name": "worktrees",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "workspace_id": {
+          "name": "workspace_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "(CURRENT_TIMESTAMP)"
+        }
+      },
+      "indexes": {
+        "worktrees_workspaceId_unique": {
+          "name": "worktrees_workspaceId_unique",
+          "columns": [
+            "workspace_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "worktrees_workspace_id_workspaces_id_fk": {
+          "name": "worktrees_workspace_id_workspaces_id_fk",
+          "tableFrom": "worktrees",
+          "tableTo": "workspaces",
+          "columnsFrom": [
+            "workspace_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/apps/code/src/main/db/migrations/meta/_journal.json b/apps/code/src/main/db/migrations/meta/_journal.json
index 3583bdfb3..2fe891dc4 100644
--- a/apps/code/src/main/db/migrations/meta/_journal.json
+++ b/apps/code/src/main/db/migrations/meta/_journal.json
@@ -22,6 +22,13 @@
       "when": 1773335630838,
       "tag": "0002_massive_bishop",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1774459077084,
+      "tag": "0003_bumpy_morgan_stark",
+      "breakpoints": true
     }
   ]
-}
+}
\ No newline at end of file
diff --git a/apps/code/src/main/db/schema.ts b/apps/code/src/main/db/schema.ts
index 677932b39..387038594 100644
--- a/apps/code/src/main/db/schema.ts
+++ b/apps/code/src/main/db/schema.ts
@@ -1,5 +1,5 @@
 import { sql } from "drizzle-orm";
-import { index, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { index, integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
 
 const id = () =>
   text()
@@ -76,3 +76,42 @@ export const suspensions = sqliteTable("suspensions", {
   createdAt: createdAt(),
   updatedAt: updatedAt(),
 });
+
+export const automations = sqliteTable("automations", {
+  id: id(),
+  name: text().notNull(),
+  prompt: text().notNull(),
+  repoPath: text().notNull(),
+  repository: text(),
+  githubIntegrationId: integer(),
+  scheduleTime: text().notNull(),
+  timezone: text().notNull(),
+  enabled: integer({ mode: "boolean" }).notNull().default(true),
+  templateId: text(),
+  lastRunAt: text(),
+  lastRunStatus: text({ enum: ["success", "failed", "skipped", "running"] }),
+  lastTaskId: text(),
+  lastError: text(),
+  nextRunAt: text(),
+  createdAt: createdAt(),
+  updatedAt: updatedAt(),
+});
+
+export const automationRuns = sqliteTable(
+  "automation_runs",
+  {
+    id: id(),
+    automationId: text()
+      .notNull()
+      .references(() => automations.id, { onDelete: "cascade" }),
+    status: text({
+      enum: ["running", "success", "failed", "skipped"],
+    }).notNull(),
+    output: text(),
+    error: text(),
+    startedAt: text().notNull(),
+    completedAt: text(),
+    createdAt: createdAt(),
+  },
+  (t) => [index("automation_runs_automation_id_idx").on(t.automationId)],
+);
diff --git a/apps/code/src/renderer/api/fetcher.ts b/apps/code/src/renderer/api/fetcher.ts
index 14a69051b..9fb1242c4 100644
--- a/apps/code/src/renderer/api/fetcher.ts
+++ b/apps/code/src/renderer/api/fetcher.ts
@@ -8,6 +8,22 @@ export const buildApiFetcher: (config: {
 }) => Parameters<typeof createApiClient>[0] = (config) => {
   let currentToken = config.apiToken;
 
+  const formatErrorResponse = async (response: Response): Promise<string> => {
+    const contentType = response.headers.get("content-type") ?? "";
+
+    if (contentType.includes("application/json")) {
+      const errorResponse = await response.json().catch(() => ({}));
+      return `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`;
+    }
+
+    const bodyText = await response.text().catch(() => "");
+    const preview = bodyText.replace(/\s+/g, " ").trim().slice(0, 200);
+
+    return `Failed request: [${response.status}] ${response.statusText}${
+      preview ? ` ${preview}` : ""
+    }`;
+  };
+
   const makeRequest = async (
     input: Parameters<Parameters<typeof createApiClient>[0]["fetch"]>[0],
     token: string,
@@ -66,18 +82,12 @@ export const buildApiFetcher: (config: {
           response = await makeRequest(input, currentToken);
         } catch {
           // Token refresh failed - throw the original 401 error
-          const errorResponse = await response.json();
-          throw new Error(
-            `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`,
-          );
+          throw new Error(await formatErrorResponse(response));
         }
       }
 
       if (!response.ok) {
-        const errorResponse = await response.json();
-        throw new Error(
-          `Failed request: [${response.status}] ${JSON.stringify(errorResponse)}`,
-        );
+        throw new Error(await formatErrorResponse(response));
       }
 
       return response;
diff --git a/apps/code/src/renderer/api/posthogClient.ts b/apps/code/src/renderer/api/posthogClient.ts
index c7eef4a64..fb8ea5caa 100644
--- a/apps/code/src/renderer/api/posthogClient.ts
+++ b/apps/code/src/renderer/api/posthogClient.ts
@@ -50,6 +50,25 @@ export interface ExternalDataSource {
   schemas?: ExternalDataSourceSchema[] | string;
 }
 
+export interface TaskAutomationApi {
+  id: string;
+  name: string;
+  prompt: string;
+  repository: string;
+  github_integration?: number | null;
+  schedule_time: string;
+  timezone: string;
+  template_id?: string | null;
+  enabled: boolean;
+  last_run_at?: string | null;
+  last_run_status?: "success" | "failed" | "running" | null;
+  last_task_id?: string | null;
+  last_task_run_id?: string | null;
+  last_error?: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
 function isObjectRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
@@ -382,6 +401,139 @@ export class PostHogAPIClient {
     return data.results ?? [];
   }
 
+  async listTaskAutomations(): Promise<TaskAutomationApi[]> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/task_automations/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "get",
+      url,
+      path: urlPath,
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch task automations: ${response.statusText}`,
+      );
+    }
+    const data = (await response.json()) as
+      | { results?: TaskAutomationApi[] }
+      | TaskAutomationApi[];
+
+    return Array.isArray(data) ? data : (data.results ?? []);
+  }
+
+  async createTaskAutomation(input: {
+    name: string;
+    prompt: string;
+    repository: string;
+    github_integration?: number | null;
+    schedule_time: string;
+    timezone: string;
+    template_id?: string | null;
+    enabled?: boolean;
+  }): Promise<TaskAutomationApi> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/task_automations/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "post",
+      url,
+      path: urlPath,
+      overrides: {
+        body: JSON.stringify(input),
+      },
+    });
+    if (!response.ok) {
+      const errorData = (await response.json().catch(() => ({}))) as {
+        detail?: string;
+      };
+      throw new Error(
+        errorData.detail ??
+          `Failed to create task automation: ${response.statusText}`,
+      );
+    }
+
+    return (await response.json()) as TaskAutomationApi;
+  }
+
+  async updateTaskAutomation(
+    automationId: string,
+    input: Partial<{
+      name: string;
+      prompt: string;
+      repository: string;
+      github_integration: number | null;
+      schedule_time: string;
+      timezone: string;
+      template_id: string | null;
+      enabled: boolean;
+    }>,
+  ): Promise<TaskAutomationApi> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/task_automations/${automationId}/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "patch",
+      url,
+      path: urlPath,
+      overrides: {
+        body: JSON.stringify(input),
+      },
+    });
+    if (!response.ok) {
+      const errorData = (await response.json().catch(() => ({}))) as {
+        detail?: string;
+      };
+      throw new Error(
+        errorData.detail ??
+          `Failed to update task automation: ${response.statusText}`,
+      );
+    }
+
+    return (await response.json()) as TaskAutomationApi;
+  }
+
+  async deleteTaskAutomation(automationId: string): Promise<void> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/task_automations/${automationId}/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "delete",
+      url,
+      path: urlPath,
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to delete task automation: ${response.statusText}`,
+      );
+    }
+  }
+
+  async runTaskAutomationNow(automationId: string): Promise<TaskAutomationApi> {
+    const teamId = await this.getTeamId();
+    const urlPath = `/api/projects/${teamId}/task_automations/${automationId}/run_now/`;
+    const url = new URL(`${this.api.baseUrl}${urlPath}`);
+    const response = await this.api.fetcher.fetch({
+      method: "post",
+      url,
+      path: urlPath,
+      overrides: {
+        body: JSON.stringify({}),
+      },
+    });
+    if (!response.ok) {
+      const errorData = (await response.json().catch(() => ({}))) as {
+        detail?: string;
+      };
+      throw new Error(
+        errorData.detail ??
+          `Failed to run task automation: ${response.statusText}`,
+      );
+    }
+
+    return (await response.json()) as TaskAutomationApi;
+  }
+
   async getTask(taskId: string) {
     const teamId = await this.getTeamId();
     const data = await this.api.get(`/api/projects/{project_id}/tasks/{id}/`, {
@@ -700,12 +852,12 @@ export class PostHogAPIClient {
 
   async getIntegrationsForProject(projectId: number) {
     const url = new URL(
-      `${this.api.baseUrl}/api/environments/${projectId}/integrations/`,
+      `${this.api.baseUrl}/api/projects/${projectId}/integrations/`,
     );
     const response = await this.api.fetcher.fetch({
       method: "get",
       url,
-      path: `/api/environments/${projectId}/integrations/`,
+      path: `/api/projects/${projectId}/integrations/`,
     });
 
     if (!response.ok) {
@@ -722,13 +874,13 @@ export class PostHogAPIClient {
   ): Promise<{ branches: string[]; defaultBranch: string | null }> {
     const teamId = await this.getTeamId();
     const url = new URL(
-      `${this.api.baseUrl}/api/environments/${teamId}/integrations/${integrationId}/github_branches/`,
+      `${this.api.baseUrl}/api/projects/${teamId}/integrations/${integrationId}/github_branches/`,
     );
     url.searchParams.set("repo", repo);
     const response = await this.api.fetcher.fetch({
       method: "get",
       url,
-      path: `/api/environments/${teamId}/integrations/${integrationId}/github_branches/`,
+      path: `/api/projects/${teamId}/integrations/${integrationId}/github_branches/`,
     });
 
     if (!response.ok) {
@@ -749,12 +901,12 @@ export class PostHogAPIClient {
   ): Promise<string[]> {
     const teamId = await this.getTeamId();
     const url = new URL(
-      `${this.api.baseUrl}/api/environments/${teamId}/integrations/${integrationId}/github_repos/`,
+      `${this.api.baseUrl}/api/projects/${teamId}/integrations/${integrationId}/github_repos/`,
     );
     const response = await this.api.fetcher.fetch({
       method: "get",
       url,
-      path: `/api/environments/${teamId}/integrations/${integrationId}/github_repos/`,
+      path: `/api/projects/${teamId}/integrations/${integrationId}/github_repos/`,
     });
 
     if (!response.ok) {
diff --git a/apps/code/src/renderer/components/MainLayout.tsx b/apps/code/src/renderer/components/MainLayout.tsx
index 698574438..9bb563ea6 100644
--- a/apps/code/src/renderer/components/MainLayout.tsx
+++ b/apps/code/src/renderer/components/MainLayout.tsx
@@ -4,6 +4,7 @@ import { HedgehogMode } from "@components/HedgehogMode";
 import { KeyboardShortcutsSheet } from "@components/KeyboardShortcutsSheet";
 
 import { ArchivedTasksView } from "@features/archive/components/ArchivedTasksView";
+import { AutomationsView } from "@features/automations/components/AutomationsView";
 import { CommandMenu } from "@features/command/components/CommandMenu";
 import { CommandCenterView } from "@features/command-center/components/CommandCenterView";
 import { InboxView } from "@features/inbox/components/InboxView";
@@ -80,6 +81,8 @@ export function MainLayout() {
 
           {view.type === "command-center" && <CommandCenterView />}
 
+          {view.type === "automations" && <AutomationsView />}
+
           {view.type === "skills" && <SkillsView />}
         </Box>
 
diff --git a/apps/code/src/renderer/features/automations/components/AutomationsView.tsx b/apps/code/src/renderer/features/automations/components/AutomationsView.tsx
new file mode 100644
index 000000000..53865586d
--- /dev/null
+++ b/apps/code/src/renderer/features/automations/components/AutomationsView.tsx
@@ -0,0 +1,733 @@
+import { GitHubRepoPicker } from "@features/folder-picker/components/GitHubRepoPicker";
+import { useRepositoryIntegration } from "@hooks/useIntegrations";
+import { useSetHeaderContent } from "@hooks/useSetHeaderContent";
+import {
+  ClockCounterClockwise,
+  FloppyDisk,
+  Play,
+  Plus,
+  Robot,
+  Trash,
+} from "@phosphor-icons/react";
+import {
+  Badge,
+  Box,
+  Button,
+  Flex,
+  ScrollArea,
+  Separator,
+  Switch,
+  Text,
+  TextArea,
+  TextField,
+} from "@radix-ui/themes";
+import type { Automation } from "@shared/types/automations";
+import { useEffect, useMemo, useState } from "react";
+import {
+  useAutomations,
+  useCreateAutomation,
+  useDeleteAutomation,
+  useRunAutomationNow,
+  useUpdateAutomation,
+} from "../hooks/useAutomations";
+import { AUTOMATION_TEMPLATES } from "../templates";
+import { formatAutomationDateTime, getLocalTimezone } from "../utils/schedule";
+
+interface AutomationDraft {
+  name: string;
+  prompt: string;
+  repository: string | null;
+  githubIntegrationId: number | null;
+  scheduleTime: string;
+  templateId: string | null;
+}
+
+function toDraft(
+  automation?: Automation | null,
+  githubIntegrationId?: number | null,
+): AutomationDraft {
+  if (!automation) {
+    return {
+      name: "",
+      prompt: "",
+      repository: null,
+      githubIntegrationId: githubIntegrationId ?? null,
+      scheduleTime: "09:00",
+      templateId: null,
+    };
+  }
+
+  return {
+    name: automation.name,
+    prompt: automation.prompt,
+    repository: automation.repository ?? automation.repoPath ?? null,
+    githubIntegrationId:
+      automation.githubIntegrationId ?? githubIntegrationId ?? null,
+    scheduleTime: automation.scheduleTime,
+    templateId: automation.templateId ?? null,
+  };
+}
+
+function AutomationStatusBadge({ automation }: { automation: Automation }) {
+  if (!automation.enabled) {
+    return (
+      <Badge size="1" variant="soft" color="gray">
+        Paused
+      </Badge>
+    );
+  }
+
+  if (automation.lastRunStatus === "failed") {
+    return (
+      <Badge size="1" variant="soft" color="red">
+        Failed
+      </Badge>
+    );
+  }
+
+  if (automation.lastRunStatus === "success") {
+    return (
+      <Badge size="1" variant="soft" color="green">
+        Healthy
+      </Badge>
+    );
+  }
+
+  if (automation.lastRunStatus === "running") {
+    return (
+      <Badge size="1" variant="soft" color="blue">
+        Running
+      </Badge>
+    );
+  }
+
+  return (
+    <Badge size="1" variant="soft" color="blue">
+      Active
+    </Badge>
+  );
+}
+
+export function AutomationsView() {
+  const { automations, isLoading } = useAutomations();
+  const createAutomation = useCreateAutomation();
+  const updateAutomation = useUpdateAutomation();
+  const deleteAutomation = useDeleteAutomation();
+  const runAutomationNow = useRunAutomationNow();
+  const { githubIntegration, repositories, isLoadingRepos } =
+    useRepositoryIntegration();
+
+  const [selectedAutomationId, setSelectedAutomationId] = useState<
+    string | null
+  >(null);
+  const [isCreating, setIsCreating] = useState(true);
+  const [draft, setDraft] = useState<AutomationDraft>(() =>
+    toDraft(null, githubIntegration?.id),
+  );
+  const [pendingRunAutomationId, setPendingRunAutomationId] = useState<
+    string | null
+  >(null);
+  const [pendingToggleAutomationId, setPendingToggleAutomationId] = useState<
+    string | null
+  >(null);
+  const [formError, setFormError] = useState<string | null>(null);
+
+  const selectedAutomation = useMemo(
+    () =>
+      automations.find(
+        (automation) => automation.id === selectedAutomationId,
+      ) ?? null,
+    [automations, selectedAutomationId],
+  );
+
+  useEffect(() => {
+    if (isLoading) {
+      return;
+    }
+
+    if (automations.length === 0) {
+      setIsCreating(true);
+      setSelectedAutomationId(null);
+      return;
+    }
+
+    if (isCreating) {
+      return;
+    }
+
+    if (!selectedAutomationId) {
+      setSelectedAutomationId(automations[0]?.id ?? null);
+      return;
+    }
+
+    const stillExists = automations.some(
+      (automation) => automation.id === selectedAutomationId,
+    );
+    if (!stillExists) {
+      setSelectedAutomationId(automations[0]?.id ?? null);
+    }
+  }, [automations, isCreating, isLoading, selectedAutomationId]);
+
+  useEffect(() => {
+    if (isCreating) {
+      setDraft(toDraft(null, githubIntegration?.id));
+      return;
+    }
+
+    if (selectedAutomation) {
+      setDraft(toDraft(selectedAutomation, githubIntegration?.id));
+    }
+  }, [isCreating, selectedAutomation, githubIntegration?.id]);
+
+  const headerContent = useMemo(
+    () => (
+      <Flex align="center" gap="2" className="w-full min-w-0">
+        <ClockCounterClockwise size={12} className="shrink-0 text-gray-10" />
+        <Text
+          size="1"
+          weight="medium"
+          className="truncate whitespace-nowrap font-mono text-[12px]"
+          title="Automations"
+        >
+          Automations
+        </Text>
+      </Flex>
+    ),
+    [],
+  );
+
+  useSetHeaderContent(headerContent);
+
+  const timezone = getLocalTimezone();
+  const enabledCount = automations.filter(
+    (automation) => automation.enabled,
+  ).length;
+  const hasGitHubIntegration =
+    Boolean(githubIntegration) && repositories.length > 0;
+
+  const openCreate = () => {
+    setFormError(null);
+    setIsCreating(true);
+    setSelectedAutomationId(null);
+  };
+
+  const openExisting = (automation: Automation) => {
+    setFormError(null);
+    setIsCreating(false);
+    setSelectedAutomationId(automation.id);
+  };
+
+  const applyTemplate = (templateId: string) => {
+    const template = AUTOMATION_TEMPLATES.find(
+      (item) => item.id === templateId,
+    );
+    if (!template) {
+      return;
+    }
+
+    setDraft((current) => ({
+      ...current,
+      name: current.name || template.name,
+      prompt: template.prompt,
+      templateId: template.id,
+    }));
+  };
+
+  const handleSave = async () => {
+    if (!draft.name.trim() || !draft.prompt.trim() || !draft.repository) {
+      return;
+    }
+
+    setFormError(null);
+
+    try {
+      if (isCreating || !selectedAutomation) {
+        const created = await createAutomation.mutateAsync({
+          name: draft.name.trim(),
+          prompt: draft.prompt.trim(),
+          repository: draft.repository,
+          github_integration: draft.githubIntegrationId,
+          schedule_time: draft.scheduleTime,
+          timezone,
+          template_id: draft.templateId,
+          enabled: true,
+        });
+        setIsCreating(false);
+        setSelectedAutomationId(created.id);
+        return;
+      }
+
+      await updateAutomation.mutateAsync({
+        automationId: selectedAutomation.id,
+        updates: {
+          name: draft.name.trim(),
+          prompt: draft.prompt.trim(),
+          repository: draft.repository,
+          github_integration: draft.githubIntegrationId,
+          schedule_time: draft.scheduleTime,
+          timezone,
+          template_id: draft.templateId,
+        },
+      });
+    } catch (error) {
+      setFormError(
+        error instanceof Error ? error.message : "Failed to save automation.",
+      );
+    }
+  };
+
+  const handleDelete = async () => {
+    if (!selectedAutomation) {
+      return;
+    }
+
+    await deleteAutomation.mutateAsync(selectedAutomation.id);
+    openCreate();
+  };
+
+  const handleToggleEnabled = async (enabled: boolean) => {
+    if (!selectedAutomation) {
+      return;
+    }
+
+    setPendingToggleAutomationId(selectedAutomation.id);
+    setFormError(null);
+    try {
+      await updateAutomation.mutateAsync({
+        automationId: selectedAutomation.id,
+        updates: { enabled },
+      });
+    } catch (error) {
+      setFormError(
+        error instanceof Error
+          ? error.message
+          : "Failed to update automation state.",
+      );
+    } finally {
+      setPendingToggleAutomationId(null);
+    }
+  };
+
+  const handleRunNow = async () => {
+    if (!selectedAutomation) {
+      return;
+    }
+
+    setPendingRunAutomationId(selectedAutomation.id);
+    setFormError(null);
+    try {
+      await runAutomationNow.mutateAsync(selectedAutomation.id);
+    } catch (error) {
+      setFormError(
+        error instanceof Error ? error.message : "Failed to run automation.",
+      );
+    } finally {
+      setPendingRunAutomationId(null);
+    }
+  };
+
+  const isSaving = createAutomation.isPending || updateAutomation.isPending;
+  const isDeleting = deleteAutomation.isPending;
+
+  return (
+    <Flex direction="column" height="100%" className="overflow-hidden">
+      <Flex
+        align="center"
+        gap="3"
+        px="3"
+        py="2"
+        className="shrink-0 border-gray-6 border-b"
+      >
+        <Text size="1" className="font-mono text-[11px] text-gray-10">
+          {automations.length} automation{automations.length === 1 ? "" : "s"}
+        </Text>
+        <Text size="1" className="font-mono text-[11px] text-gray-10">
+          {enabledCount} enabled
+        </Text>
+        <div className="flex-1" />
+        <Button size="1" variant="soft" onClick={openCreate}>
+          <Plus size={12} />
+          New automation
+        </Button>
+      </Flex>
+
+      <Flex style={{ minHeight: 0 }} className="flex-1">
+        <Box width="360px" className="border-gray-6 border-r">
+          <ScrollArea type="auto" style={{ height: "100%" }}>
+            <Flex direction="column" gap="2" p="3">
+              {isLoading ? (
+                <Flex
+                  direction="column"
+                  align="center"
+                  justify="center"
+                  gap="3"
+                  className="rounded-lg border border-gray-6 border-dashed p-6"
+                >
+                  <Text size="2" className="font-mono text-[12px] text-gray-10">
+                    Loading automations...
+                  </Text>
+                </Flex>
+              ) : automations.length === 0 ? (
+                <Flex
+                  direction="column"
+                  align="center"
+                  justify="center"
+                  gap="3"
+                  className="rounded-lg border border-gray-6 border-dashed p-6"
+                >
+                  <Robot size={28} className="text-gray-8" />
+                  <Text size="2" className="font-mono text-[12px] text-gray-10">
+                    No automations yet
+                  </Text>
+                </Flex>
+              ) : (
+                automations.map((automation) => {
+                  const isSelected =
+                    !isCreating && selectedAutomation?.id === automation.id;
+
+                  return (
+                    <button
+                      key={automation.id}
+                      type="button"
+                      onClick={() => openExisting(automation)}
+                      className={`rounded-lg border p-3 text-left transition-colors ${
+                        isSelected
+                          ? "border-accent-8 bg-accent-2"
+                          : "border-gray-5 bg-gray-1 hover:border-gray-7 hover:bg-gray-2"
+                      }`}
+                    >
+                      <Flex direction="column" gap="2">
+                        <Flex align="center" justify="between" gap="2">
+                          <Text
+                            size="2"
+                            weight="medium"
+                            className="min-w-0 flex-1 truncate font-mono text-[12px]"
+                          >
+                            {automation.name}
+                          </Text>
+                          <AutomationStatusBadge automation={automation} />
+                        </Flex>
+                        <Text
+                          size="1"
+                          className="font-mono text-[11px] text-gray-10"
+                        >
+                          Next run{" "}
+                          {automation.enabled
+                            ? formatAutomationDateTime(
+                                automation.nextRunAt,
+                                automation.timezone,
+                              )
+                            : "paused"}
+                        </Text>
+                        <Text
+                          size="1"
+                          className="truncate font-mono text-[11px] text-gray-10"
+                        >
+                          {automation.repository ?? automation.repoPath}
+                        </Text>
+                      </Flex>
+                    </button>
+                  );
+                })
+              )}
+            </Flex>
+          </ScrollArea>
+        </Box>
+
+        <Box flexGrow="1" style={{ minWidth: 0 }}>
+          <ScrollArea type="auto" style={{ height: "100%" }}>
+            <Flex direction="column" gap="5" p="4" style={{ maxWidth: 900 }}>
+              <Flex direction="column" gap="2">
+                <Text size="2" weight="medium">
+                  {isCreating
+                    ? "New automation"
+                    : (selectedAutomation?.name ?? "Automation")}
+                </Text>
+                <Text size="1" className="font-mono text-[11px] text-gray-10">
+                  Runs in the cloud sandbox on schedule, even while Twig is
+                  closed.
+                </Text>
+              </Flex>
+
+              <Flex direction="column" gap="3">
+                <Text
+                  size="1"
+                  weight="medium"
+                  className="font-mono text-[11px]"
+                >
+                  Template library
+                </Text>
+                <Flex gap="3" wrap="wrap">
+                  {AUTOMATION_TEMPLATES.map((template) => (
+                    <Box
+                      key={template.id}
+                      className="min-w-[220px] flex-1 rounded-lg border border-gray-5 bg-gray-1 p-3"
+                    >
+                      <Flex direction="column" gap="2">
+                        <Flex align="center" justify="between" gap="2">
+                          <Text size="2" weight="medium">
+                            {template.name}
+                          </Text>
+                          <Badge size="1" variant="soft">
+                            {template.category}
+                          </Badge>
+                        </Flex>
+                        <Text size="1" className="text-gray-10">
+                          {template.description}
+                        </Text>
+                        <Button
+                          size="1"
+                          variant="soft"
+                          onClick={() => applyTemplate(template.id)}
+                        >
+                          Use template
+                        </Button>
+                      </Flex>
+                    </Box>
+                  ))}
+                </Flex>
+              </Flex>
+
+              <Separator size="4" />
+
+              <Flex direction="column" gap="4">
+                <Flex direction="column" gap="2">
+                  <Text
+                    size="1"
+                    weight="medium"
+                    className="font-mono text-[11px]"
+                  >
+                    Name
+                  </Text>
+                  <TextField.Root
+                    value={draft.name}
+                    onChange={(event) =>
+                      setDraft((current) => ({
+                        ...current,
+                        name: event.target.value,
+                      }))
+                    }
+                    placeholder="Morning repo check"
+                  />
+                </Flex>
+
+                <Flex direction="column" gap="2">
+                  <Text
+                    size="1"
+                    weight="medium"
+                    className="font-mono text-[11px]"
+                  >
+                    Prompt
+                  </Text>
+                  <TextArea
+                    value={draft.prompt}
+                    onChange={(event) =>
+                      setDraft((current) => ({
+                        ...current,
+                        prompt: event.target.value,
+                      }))
+                    }
+                    placeholder="Tell the agent what to review and summarize."
+                    rows={10}
+                  />
+                </Flex>
+
+                <Flex direction="column" gap="2">
+                  <Text
+                    size="1"
+                    weight="medium"
+                    className="font-mono text-[11px]"
+                  >
+                    GitHub repository
+                  </Text>
+                  {hasGitHubIntegration ? (
+                    <GitHubRepoPicker
+                      value={draft.repository}
+                      onChange={(repository) =>
+                        setDraft((current) => ({
+                          ...current,
+                          repository,
+                          githubIntegrationId: githubIntegration?.id ?? null,
+                        }))
+                      }
+                      repositories={repositories}
+                      isLoading={isLoadingRepos}
+                      placeholder="Select repository..."
+                      size="2"
+                    />
+                  ) : (
+                    <TextField.Root
+                      value={draft.repository ?? ""}
+                      onChange={(event) =>
+                        setDraft((current) => ({
+                          ...current,
+                          repository: event.target.value.trim() || null,
+                          githubIntegrationId: null,
+                        }))
+                      }
+                      placeholder="posthog/posthog"
+                    />
+                  )}
+                  <Text size="1" className="font-mono text-[11px] text-gray-10">
+                    {hasGitHubIntegration
+                      ? "Each automation runs against a single GitHub repository in the cloud sandbox."
+                      : "No GitHub integration is connected. You can still enter org/repo for local testing, but the sandbox will not clone the repository until GitHub is connected."}
+                  </Text>
+                </Flex>
+
+                <Flex gap="4" wrap="wrap">
+                  <Flex direction="column" gap="2">
+                    <Text
+                      size="1"
+                      weight="medium"
+                      className="font-mono text-[11px]"
+                    >
+                      Daily time
+                    </Text>
+                    <TextField.Root
+                      type="time"
+                      value={draft.scheduleTime}
+                      onChange={(event) =>
+                        setDraft((current) => ({
+                          ...current,
+                          scheduleTime: event.target.value,
+                        }))
+                      }
+                    />
+                  </Flex>
+
+                  <Flex direction="column" gap="2">
+                    <Text
+                      size="1"
+                      weight="medium"
+                      className="font-mono text-[11px]"
+                    >
+                      Timezone
+                    </Text>
+                    <Box className="rounded border border-gray-6 bg-gray-2 px-3 py-2">
+                      <Text
+                        size="1"
+                        className="font-mono text-[11px] text-gray-10"
+                      >
+                        {timezone}
+                      </Text>
+                    </Box>
+                  </Flex>
+                </Flex>
+
+                {!isCreating && selectedAutomation ? (
+                  <Flex direction="column" gap="2">
+                    <Text
+                      size="1"
+                      weight="medium"
+                      className="font-mono text-[11px]"
+                    >
+                      Run status
+                    </Text>
+                    <Flex direction="column" gap="1">
+                      <Text
+                        size="1"
+                        className="font-mono text-[11px] text-gray-10"
+                      >
+                        Next run:{" "}
+                        {selectedAutomation.enabled
+                          ? formatAutomationDateTime(
+                              selectedAutomation.nextRunAt,
+                              selectedAutomation.timezone,
+                            )
+                          : "Paused"}
+                      </Text>
+                      <Text
+                        size="1"
+                        className="font-mono text-[11px] text-gray-10"
+                      >
+                        Last run:{" "}
+                        {formatAutomationDateTime(
+                          selectedAutomation.lastRunAt,
+                          selectedAutomation.timezone,
+                        )}
+                      </Text>
+                      {selectedAutomation.lastError ? (
+                        <Text
+                          size="1"
+                          className="font-mono text-[11px] text-red-10"
+                        >
+                          {selectedAutomation.lastError}
+                        </Text>
+                      ) : null}
+                    </Flex>
+                  </Flex>
+                ) : null}
+              </Flex>
+
+              {formError ? (
+                <Box className="rounded-lg border border-red-6 bg-red-2 px-3 py-2">
+                  <Text size="1" className="font-mono text-[11px] text-red-11">
+                    {formError}
+                  </Text>
+                </Box>
+              ) : null}
+
+              <Flex align="center" gap="3" wrap="wrap">
+                {!isCreating && selectedAutomation ? (
+                  <>
+                    <Switch
+                      checked={selectedAutomation.enabled}
+                      disabled={
+                        pendingToggleAutomationId === selectedAutomation.id
+                      }
+                      onCheckedChange={(enabled) =>
+                        void handleToggleEnabled(enabled)
+                      }
+                    />
+                    <Text
+                      size="1"
+                      className="font-mono text-[11px] text-gray-10"
+                    >
+                      {selectedAutomation.enabled ? "Enabled" : "Paused"}
+                    </Text>
+                  </>
+                ) : null}
+                <div className="flex-1" />
+                {!isCreating && selectedAutomation ? (
+                  <Button
+                    color="gray"
+                    variant="soft"
+                    disabled={pendingRunAutomationId === selectedAutomation.id}
+                    onClick={() => void handleRunNow()}
+                  >
+                    <Play size={12} />
+                    Run now
+                  </Button>
+                ) : null}
+                {!isCreating && selectedAutomation ? (
+                  <Button
+                    color="red"
+                    variant="soft"
+                    disabled={isDeleting}
+                    onClick={() => void handleDelete()}
+                  >
+                    <Trash size={12} />
+                    Delete
+                  </Button>
+                ) : null}
+                <Button
+                  onClick={() => void handleSave()}
+                  disabled={
+                    !draft.name.trim() ||
+                    !draft.prompt.trim() ||
+                    !draft.repository ||
+                    isSaving
+                  }
+                >
+                  <FloppyDisk size={12} />
+                  {isCreating ? "Create automation" : "Save changes"}
+                </Button>
+              </Flex>
+            </Flex>
+          </ScrollArea>
+        </Box>
+      </Flex>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/automations/hooks/useAutomations.ts b/apps/code/src/renderer/features/automations/hooks/useAutomations.ts
new file mode 100644
index 000000000..5283d63de
--- /dev/null
+++ b/apps/code/src/renderer/features/automations/hooks/useAutomations.ts
@@ -0,0 +1,136 @@
+import { useAuthenticatedMutation } from "@hooks/useAuthenticatedMutation";
+import { useAuthenticatedQuery } from "@hooks/useAuthenticatedQuery";
+import type { Automation } from "@shared/types/automations";
+import { queryClient } from "@utils/queryClient";
+import { useMemo } from "react";
+import { computeNextRunAt } from "../utils/schedule";
+
+interface AutomationApi {
+  id: string;
+  name: string;
+  prompt: string;
+  repository: string;
+  github_integration?: number | null;
+  schedule_time: string;
+  timezone: string;
+  template_id?: string | null;
+  enabled: boolean;
+  last_run_at?: string | null;
+  last_run_status?: "success" | "failed" | "running" | null;
+  last_task_id?: string | null;
+  last_error?: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface SaveAutomationInput {
+  name: string;
+  prompt: string;
+  repository: string;
+  github_integration?: number | null;
+  schedule_time: string;
+  timezone: string;
+  template_id?: string | null;
+  enabled?: boolean;
+}
+
+const automationKeys = {
+  all: ["automations"] as const,
+  list: () => [...automationKeys.all, "list"] as const,
+};
+
+const AUTOMATION_LIST_POLL_INTERVAL_MS = 30_000;
+
+function mapAutomation(api: AutomationApi): Automation {
+  return {
+    id: api.id,
+    name: api.name,
+    prompt: api.prompt,
+    repoPath: api.repository,
+    repository: api.repository,
+    githubIntegrationId: api.github_integration ?? null,
+    scheduleTime: api.schedule_time,
+    timezone: api.timezone,
+    enabled: api.enabled,
+    templateId: api.template_id ?? null,
+    createdAt: api.created_at,
+    updatedAt: api.updated_at,
+    nextRunAt: api.enabled
+      ? computeNextRunAt(api.schedule_time, api.timezone)
+      : null,
+    lastRunAt: api.last_run_at ?? null,
+    lastRunStatus: api.last_run_status ?? null,
+    lastTaskId: api.last_task_id ?? null,
+    lastError: api.last_error ?? null,
+  };
+}
+
+export function useAutomations() {
+  const query = useAuthenticatedQuery<Automation[]>(
+    automationKeys.list(),
+    async (client) => {
+      const automations = await client.listTaskAutomations();
+      return automations.map((automation) =>
+        mapAutomation(automation as AutomationApi),
+      );
+    },
+    { refetchInterval: AUTOMATION_LIST_POLL_INTERVAL_MS },
+  );
+
+  const automations = useMemo(() => query.data ?? [], [query.data]);
+
+  return { ...query, automations };
+}
+
+export function useCreateAutomation() {
+  return useAuthenticatedMutation(
+    (client, input: SaveAutomationInput) => client.createTaskAutomation(input),
+    {
+      onSuccess: () => {
+        void queryClient.invalidateQueries({ queryKey: automationKeys.list() });
+      },
+    },
+  );
+}
+
+export function useUpdateAutomation() {
+  return useAuthenticatedMutation(
+    (
+      client,
+      variables: {
+        automationId: string;
+        updates: Partial<SaveAutomationInput>;
+      },
+    ) => client.updateTaskAutomation(variables.automationId, variables.updates),
+    {
+      onSuccess: () => {
+        void queryClient.invalidateQueries({ queryKey: automationKeys.list() });
+      },
+    },
+  );
+}
+
+export function useDeleteAutomation() {
+  return useAuthenticatedMutation(
+    (client, automationId: string) => client.deleteTaskAutomation(automationId),
+    {
+      onSuccess: () => {
+        void queryClient.invalidateQueries({ queryKey: automationKeys.list() });
+      },
+    },
+  );
+}
+
+export function useRunAutomationNow() {
+  return useAuthenticatedMutation(
+    (client, automationId: string) => client.runTaskAutomationNow(automationId),
+    {
+      onSuccess: () => {
+        void Promise.all([
+          queryClient.invalidateQueries({ queryKey: automationKeys.list() }),
+          queryClient.invalidateQueries({ queryKey: ["tasks"] }),
+        ]);
+      },
+    },
+  );
+}
diff --git a/apps/code/src/renderer/features/automations/templates.ts b/apps/code/src/renderer/features/automations/templates.ts
new file mode 100644
index 000000000..05cb8967c
--- /dev/null
+++ b/apps/code/src/renderer/features/automations/templates.ts
@@ -0,0 +1,34 @@
+import type { AutomationTemplate } from "@shared/types/automations";
+
+export const AUTOMATION_TEMPLATES: AutomationTemplate[] = [
+  {
+    id: "check-metrics",
+    name: "Check My Metrics",
+    description:
+      "Review key product metrics, flag unusual movement, and summarize what needs attention.",
+    category: "Product",
+    tags: ["metrics", "product", "summary"],
+    prompt:
+      "Review the most important product and growth metrics for this codebase and surrounding context. Summarize meaningful changes, highlight anything that looks off, and suggest the highest-leverage next actions.",
+  },
+  {
+    id: "check-github-prs",
+    name: "Check My GitHub PRs",
+    description:
+      "Look through recent pull requests and summarize what needs review or follow-up.",
+    category: "Engineering",
+    tags: ["github", "prs", "review"],
+    prompt:
+      "Check the current GitHub pull requests relevant to this repository and summarize what needs my attention. Call out stalled PRs, merge blockers, risky changes, and any follow-up actions I should take today.",
+  },
+  {
+    id: "product-issues",
+    name: "Summarize Product Issues",
+    description:
+      "Scan recent issue signals and produce a concise action-oriented update.",
+    category: "Support",
+    tags: ["issues", "triage", "summary"],
+    prompt:
+      "Review the recent product issues and signals associated with this repository. Group related problems, identify anything urgent, and recommend the best next actions for the team.",
+  },
+];
diff --git a/apps/code/src/renderer/features/automations/utils/schedule.ts b/apps/code/src/renderer/features/automations/utils/schedule.ts
new file mode 100644
index 000000000..f6a887edd
--- /dev/null
+++ b/apps/code/src/renderer/features/automations/utils/schedule.ts
@@ -0,0 +1,156 @@
+import type { Automation } from "@shared/types/automations";
+
+function getFormatter(timezone: string): Intl.DateTimeFormat {
+  return new Intl.DateTimeFormat("en-GB", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+}
+
+function getZonedParts(
+  date: Date,
+  timezone: string,
+): {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+} {
+  const parts = getFormatter(timezone).formatToParts(date);
+  const get = (type: string) =>
+    Number(parts.find((part) => part.type === type)?.value ?? 0);
+
+  return {
+    year: get("year"),
+    month: get("month"),
+    day: get("day"),
+    hour: get("hour"),
+    minute: get("minute"),
+  };
+}
+
+function zonedDateTimeToUtc(
+  year: number,
+  month: number,
+  day: number,
+  hour: number,
+  minute: number,
+  timezone: string,
+): Date {
+  let guess = new Date(Date.UTC(year, month - 1, day, hour, minute, 0, 0));
+
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const actual = getZonedParts(guess, timezone);
+    const actualMs = Date.UTC(
+      actual.year,
+      actual.month - 1,
+      actual.day,
+      actual.hour,
+      actual.minute,
+      0,
+      0,
+    );
+    const intendedMs = Date.UTC(year, month - 1, day, hour, minute, 0, 0);
+    const diffMinutes = Math.round((actualMs - intendedMs) / 60_000);
+
+    if (diffMinutes === 0) {
+      return guess;
+    }
+
+    guess = new Date(guess.getTime() - diffMinutes * 60_000);
+  }
+
+  return guess;
+}
+
+function parseScheduleTime(scheduleTime: string): {
+  hour: number;
+  minute: number;
+} {
+  const [hourText, minuteText] = scheduleTime.split(":");
+  return {
+    hour: Number(hourText ?? 0),
+    minute: Number(minuteText ?? 0),
+  };
+}
+
+export function computeNextRunAt(
+  scheduleTime: string,
+  timezone: string,
+  fromDate = new Date(),
+): string {
+  const today = getZonedParts(fromDate, timezone);
+  const { hour, minute } = parseScheduleTime(scheduleTime);
+
+  const todayTarget = zonedDateTimeToUtc(
+    today.year,
+    today.month,
+    today.day,
+    hour,
+    minute,
+    timezone,
+  );
+
+  if (todayTarget.getTime() > fromDate.getTime()) {
+    return todayTarget.toISOString();
+  }
+
+  const tomorrow = new Date(
+    Date.UTC(today.year, today.month - 1, today.day + 1),
+  );
+
+  return zonedDateTimeToUtc(
+    tomorrow.getUTCFullYear(),
+    tomorrow.getUTCMonth() + 1,
+    tomorrow.getUTCDate(),
+    hour,
+    minute,
+    timezone,
+  ).toISOString();
+}
+
+export function formatAutomationDateTime(
+  isoString: string | null | undefined,
+  timezone: string,
+): string {
+  if (!isoString) {
+    return "Not scheduled";
+  }
+
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    return "Invalid date";
+  }
+
+  return new Intl.DateTimeFormat(undefined, {
+    timeZone: timezone,
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  }).format(date);
+}
+
+export function getLocalTimezone(): string {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+
+export function normalizeAutomationSchedule(
+  automation: Automation,
+  now = new Date(),
+): Automation {
+  return {
+    ...automation,
+    nextRunAt: computeNextRunAt(
+      automation.scheduleTime,
+      automation.timezone,
+      now,
+    ),
+  };
+}
diff --git a/apps/code/src/renderer/features/command-center/hooks/useAvailableTasks.ts b/apps/code/src/renderer/features/command-center/hooks/useAvailableTasks.ts
index a08339b9b..0364aab7e 100644
--- a/apps/code/src/renderer/features/command-center/hooks/useAvailableTasks.ts
+++ b/apps/code/src/renderer/features/command-center/hooks/useAvailableTasks.ts
@@ -17,7 +17,8 @@ export function useAvailableTasks(): Task[] {
       (task) =>
         !assignedIds.has(task.id) &&
         !archivedTaskIds.has(task.id) &&
-        workspaces?.[task.id],
+        (Boolean(workspaces?.[task.id]) ||
+          task.latest_run?.environment === "cloud"),
     );
   }, [tasks, cells, archivedTaskIds, workspaces]);
 }
diff --git a/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx b/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
index a26b1eaf6..4427b0cc2 100644
--- a/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
+++ b/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
@@ -1,4 +1,5 @@
 import { DotsCircleSpinner } from "@components/DotsCircleSpinner";
+import { useAutomations } from "@features/automations/hooks/useAutomations";
 import { useCommandCenterStore } from "@features/command-center/stores/commandCenterStore";
 import { useInboxReports } from "@features/inbox/hooks/useInboxReports";
 import {
@@ -20,6 +21,7 @@ import { memo, useCallback, useEffect, useRef } from "react";
 import { usePinnedTasks } from "../hooks/usePinnedTasks";
 import { useSidebarData } from "../hooks/useSidebarData";
 import { useTaskViewed } from "../hooks/useTaskViewed";
+import { AutomationsItem } from "./items/AutomationsItem";
 import { CommandCenterItem } from "./items/CommandCenterItem";
 import { InboxItem, NewTaskItem } from "./items/HomeItem";
 import { SkillsItem } from "./items/SkillsItem";
@@ -34,6 +36,7 @@ function SidebarMenuComponent() {
     navigateToInbox,
     navigateToCommandCenter,
     navigateToSkills,
+    navigateToAutomations,
   } = useNavigationStore();
 
   const { data: allTasks = [] } = useTasks();
@@ -67,6 +70,10 @@ function SidebarMenuComponent() {
   const commandCenterActiveCount = commandCenterCells.filter(
     (taskId) => taskId != null,
   ).length;
+  const { automations = [] } = useAutomations();
+  const automationEnabledCount = automations.filter(
+    (automation) => automation.enabled,
+  ).length;
 
   const previousTaskIdRef = useRef<string | null>(null);
 
@@ -109,6 +116,10 @@ function SidebarMenuComponent() {
     navigateToSkills();
   };
 
+  const handleAutomationsClick = () => {
+    navigateToAutomations();
+  };
+
   const handleTaskClick = (taskId: string) => {
     const task = taskMap.get(taskId);
     if (task) {
@@ -217,6 +228,14 @@ function SidebarMenuComponent() {
             />
           </Box>
 
+          <Box mb="2">
+            <AutomationsItem
+              isActive={sidebarData.isAutomationsActive}
+              onClick={handleAutomationsClick}
+              activeCount={automationEnabledCount}
+            />
+          </Box>
+
           <Box mb="2">
             <SkillsItem
               isActive={sidebarData.isSkillsActive}
diff --git a/apps/code/src/renderer/features/sidebar/components/items/AutomationsItem.tsx b/apps/code/src/renderer/features/sidebar/components/items/AutomationsItem.tsx
new file mode 100644
index 000000000..dc45fcfd2
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/items/AutomationsItem.tsx
@@ -0,0 +1,40 @@
+import { ClockCounterClockwise } from "@phosphor-icons/react";
+import { SidebarItem } from "../SidebarItem";
+
+interface AutomationsItemProps {
+  isActive: boolean;
+  onClick: () => void;
+  activeCount?: number;
+}
+
+export function AutomationsItem({
+  isActive,
+  onClick,
+  activeCount = 0,
+}: AutomationsItemProps) {
+  return (
+    <SidebarItem
+      depth={0}
+      icon={
+        <ClockCounterClockwise
+          size={16}
+          weight={isActive ? "fill" : "regular"}
+        />
+      }
+      label="Automations"
+      isActive={isActive}
+      onClick={onClick}
+      endContent={
+        activeCount > 0 ? (
+          <span
+            className="inline-flex min-w-[16px] items-center justify-center rounded-full px-1 text-[10px] text-gray-11 leading-none"
+            style={{ height: "16px" }}
+            title={`${activeCount} enabled automations`}
+          >
+            {activeCount > 99 ? "99+" : String(activeCount)}
+          </span>
+        ) : undefined
+      }
+    />
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts b/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts
index 2a774265a..7d65dac4b 100644
--- a/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts
+++ b/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts
@@ -48,6 +48,7 @@ export interface SidebarData {
   isInboxActive: boolean;
   isCommandCenterActive: boolean;
   isSkillsActive: boolean;
+  isAutomationsActive: boolean;
   isLoading: boolean;
   activeTaskId: string | null;
   pinnedTasks: TaskData[];
@@ -66,7 +67,8 @@ interface ViewState {
     | "inbox"
     | "archived"
     | "command-center"
-    | "skills";
+    | "skills"
+    | "automations";
   data?: Task;
 }
 
@@ -153,7 +155,10 @@ export function useSidebarData({
   const allTasks = useMemo(
     () =>
       rawTasks.filter(
-        (task) => !archivedTaskIds.has(task.id) && !!workspaces?.[task.id],
+        (task) =>
+          !archivedTaskIds.has(task.id) &&
+          (Boolean(workspaces?.[task.id]) ||
+            task.latest_run?.environment === "cloud"),
       ),
     [rawTasks, archivedTaskIds, workspaces],
   );
@@ -171,6 +176,7 @@ export function useSidebarData({
   const isInboxActive = activeView.type === "inbox";
   const isCommandCenterActive = activeView.type === "command-center";
   const isSkillsActive = activeView.type === "skills";
+  const isAutomationsActive = activeView.type === "automations";
 
   const activeTaskId =
     activeView.type === "task-detail" && activeView.data
@@ -280,6 +286,7 @@ export function useSidebarData({
     isInboxActive,
     isCommandCenterActive,
     isSkillsActive,
+    isAutomationsActive,
     isLoading,
     activeTaskId,
     pinnedTasks,
diff --git a/apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx b/apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx
index a6af0726b..7f215a246 100644
--- a/apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx
+++ b/apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx
@@ -15,12 +15,14 @@ import { useSessionViewState } from "@features/sessions/hooks/useSessionViewStat
 import { useRestoreTask } from "@features/suspension/hooks/useRestoreTask";
 import { useSuspendedTaskIds } from "@features/suspension/hooks/useSuspendedTaskIds";
 import { WorkspaceSetupPrompt } from "@features/task-detail/components/WorkspaceSetupPrompt";
+import { useCloudRunState } from "@features/task-detail/hooks/useCloudRunState";
 import {
   useCreateWorkspace,
   useWorkspaceLoaded,
 } from "@features/workspace/hooks/useWorkspace";
 import { Box, Button, Flex, Spinner, Text } from "@radix-ui/themes";
 import type { Task } from "@shared/types";
+import type { AcpMessage } from "@shared/types/session-events";
 import { getTaskRepository } from "@utils/repository";
 import { useCallback, useEffect, useMemo } from "react";
 
@@ -30,9 +32,11 @@ interface TaskLogsPanelProps {
 }
 
 export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
+  const { freshTask } = useCloudRunState(taskId, task);
+  const effectiveTask = freshTask;
   const isWorkspaceLoaded = useWorkspaceLoaded();
   const { isPending: isCreatingWorkspace } = useCreateWorkspace();
-  const repoKey = getTaskRepository(task);
+  const repoKey = getTaskRepository(effectiveTask);
   const { folders } = useFolders();
   const hasDirectoryMapping = repoKey
     ? folders.some((f) => f.remoteUrl === repoKey)
@@ -61,11 +65,11 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     cloudBranch,
     errorTitle,
     errorMessage,
-  } = useSessionViewState(taskId, task);
+  } = useSessionViewState(taskId, effectiveTask);
 
   useSessionConnection({
     taskId,
-    task,
+    task: effectiveTask,
     session,
     repoPath,
     isCloud,
@@ -78,19 +82,24 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     handleRetry,
     handleNewSession,
     handleBashCommand,
-  } = useSessionCallbacks({ taskId, task, session, repoPath });
+  } = useSessionCallbacks({ taskId, task: effectiveTask, session, repoPath });
 
-  const cloudStage = session?.cloudStage ?? null;
-  const cloudOutput = session?.cloudOutput ?? null;
-  const cloudErrorMessage = session?.cloudErrorMessage ?? null;
+  const cloudStage =
+    session?.cloudStage ?? effectiveTask.latest_run?.stage ?? null;
+  const cloudOutput =
+    session?.cloudOutput ?? effectiveTask.latest_run?.output ?? null;
+  const cloudErrorMessage =
+    session?.cloudErrorMessage ??
+    effectiveTask.latest_run?.error_message ??
+    null;
   const prUrl =
     isCloud && cloudOutput?.pr_url ? (cloudOutput.pr_url as string) : null;
   const slackThreadUrl =
-    typeof task.latest_run?.state?.slack_thread_url === "string"
-      ? task.latest_run.state.slack_thread_url
+    typeof effectiveTask.latest_run?.state?.slack_thread_url === "string"
+      ? effectiveTask.latest_run.state.slack_thread_url
       : undefined;
 
-  const cloudRepo = isCloud ? (task.repository ?? null) : null;
+  const cloudRepo = isCloud ? (effectiveTask.repository ?? null) : null;
   const { data: prFiles } = useCloudPrChangedFiles(prUrl);
   const { data: branchFiles } = useCloudBranchChangedFiles(
     !prUrl ? cloudRepo : null,
@@ -107,6 +116,57 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     };
   }, [isCloud, prUrl, prFiles, branchFiles]);
 
+  const displayEvents = useMemo(() => {
+    if (events.length > 0) return events;
+    if (!isCloud || isCloudRunNotTerminal) return events;
+
+    const fallbackMarkdown = buildCloudFallbackMarkdown({
+      prompt: effectiveTask.description,
+      repository: effectiveTask.repository ?? null,
+      branch: effectiveTask.latest_run?.branch ?? cloudBranch ?? null,
+      stage: cloudStage,
+      status: cloudStatus ?? effectiveTask.latest_run?.status ?? null,
+      output: cloudOutput,
+      errorMessage: cloudErrorMessage,
+    });
+
+    if (!fallbackMarkdown) return events;
+
+    const startedAt = effectiveTask.latest_run?.created_at
+      ? new Date(effectiveTask.latest_run.created_at).getTime()
+      : Date.now();
+    const syntheticEvents: AcpMessage[] = [];
+
+    if (effectiveTask.description?.trim()) {
+      syntheticEvents.push(
+        createSyntheticUserPromptEvent(
+          effectiveTask.description.trim(),
+          startedAt - 1,
+        ),
+      );
+    }
+
+    syntheticEvents.push(
+      createSyntheticAgentMessageEvent(fallbackMarkdown, startedAt),
+    );
+
+    return syntheticEvents;
+  }, [
+    events,
+    isCloud,
+    isCloudRunNotTerminal,
+    effectiveTask.description,
+    effectiveTask.repository,
+    effectiveTask.latest_run?.branch,
+    effectiveTask.latest_run?.created_at,
+    effectiveTask.latest_run?.status,
+    cloudBranch,
+    cloudStage,
+    cloudStatus,
+    cloudOutput,
+    cloudErrorMessage,
+  ]);
+
   useEffect(() => {
     requestFocus(taskId);
   }, [taskId, requestFocus]);
@@ -130,7 +190,7 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     return (
       <BackgroundWrapper>
         <Box height="100%" width="100%">
-          <WorkspaceSetupPrompt taskId={taskId} task={task} />
+          <WorkspaceSetupPrompt taskId={taskId} task={effectiveTask} />
         </Box>
       </BackgroundWrapper>
     );
@@ -142,7 +202,7 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
         <Box style={{ flex: 1, minHeight: 0 }}>
           <ErrorBoundary name="SessionView">
             <SessionView
-              events={events}
+              events={displayEvents}
               taskId={taskId}
               isRunning={isRunning}
               isSuspended={isSuspended}
@@ -216,3 +276,168 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     </BackgroundWrapper>
   );
 }
+
+function createSyntheticUserPromptEvent(text: string, ts: number): AcpMessage {
+  return {
+    type: "acp_message",
+    ts,
+    message: {
+      jsonrpc: "2.0",
+      id: ts,
+      method: "session/prompt",
+      params: {
+        prompt: [{ type: "text", text }],
+      },
+    },
+  };
+}
+
+function createSyntheticAgentMessageEvent(
+  text: string,
+  ts: number,
+): AcpMessage {
+  return {
+    type: "acp_message",
+    ts,
+    message: {
+      jsonrpc: "2.0",
+      method: "session/update",
+      params: {
+        update: {
+          sessionUpdate: "agent_message",
+          content: { type: "text", text },
+        },
+      },
+    },
+  };
+}
+
+function buildCloudFallbackMarkdown({
+  prompt,
+  repository,
+  branch,
+  stage,
+  status,
+  output,
+  errorMessage,
+}: {
+  prompt?: string | null;
+  repository?: string | null;
+  branch?: string | null;
+  stage?: string | null;
+  status?: string | null;
+  output?: Record<string, unknown> | null;
+  errorMessage?: string | null;
+}): string | null {
+  const sections: string[] = [
+    "No transcript was recorded for this cloud run, so this view is showing the persisted run output instead.",
+  ];
+
+  const naturalLanguageOutput = findNaturalLanguageOutput(output);
+  if (naturalLanguageOutput) {
+    sections.push(naturalLanguageOutput);
+  }
+
+  if (errorMessage) {
+    sections.push(`**Run error**\n\n${errorMessage}`);
+  }
+
+  const metadata = [
+    status ? `- Status: \`${status}\`` : null,
+    stage ? `- Stage: \`${stage}\`` : null,
+    repository ? `- Repository: \`${repository}\`` : null,
+    branch ? `- Branch: \`${branch}\`` : null,
+    readString(output, "pr_url")
+      ? `- Pull request: ${readString(output, "pr_url")}`
+      : null,
+    readString(output, "commit_sha")
+      ? `- Commit: \`${readString(output, "commit_sha")}\``
+      : null,
+  ].filter(Boolean);
+
+  if (metadata.length > 0) {
+    sections.push(`**Run metadata**\n\n${metadata.join("\n")}`);
+  }
+
+  const structuredOutput = buildStructuredOutputBlock(
+    output,
+    naturalLanguageOutput,
+  );
+  if (structuredOutput) {
+    sections.push(structuredOutput);
+  }
+
+  if (sections.length === 1 && prompt?.trim()) {
+    return null;
+  }
+
+  return sections.join("\n\n");
+}
+
+function findNaturalLanguageOutput(
+  output: Record<string, unknown> | null | undefined,
+): string | null {
+  if (!output) return null;
+
+  const candidateKeys = [
+    "summary",
+    "message",
+    "result",
+    "response",
+    "content",
+    "text",
+    "final_output",
+  ] as const;
+
+  for (const key of candidateKeys) {
+    const value = output[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+
+  return null;
+}
+
+function buildStructuredOutputBlock(
+  output: Record<string, unknown> | null | undefined,
+  naturalLanguageOutput: string | null,
+): string | null {
+  if (!output || Object.keys(output).length === 0) return null;
+
+  const filteredEntries = Object.entries(output).filter(([key, value]) => {
+    if (value == null) return false;
+    if (
+      naturalLanguageOutput &&
+      [
+        "summary",
+        "message",
+        "result",
+        "response",
+        "content",
+        "text",
+        "final_output",
+      ].includes(key) &&
+      value === naturalLanguageOutput
+    ) {
+      return false;
+    }
+    return !["pr_url", "commit_sha"].includes(key);
+  });
+
+  if (filteredEntries.length === 0) return null;
+
+  return `**Structured output**\n\n\`\`\`json\n${JSON.stringify(
+    Object.fromEntries(filteredEntries),
+    null,
+    2,
+  )}\n\`\`\``;
+}
+
+function readString(
+  output: Record<string, unknown> | null | undefined,
+  key: string,
+): string | null {
+  const value = output?.[key];
+  return typeof value === "string" && value.trim() ? value : null;
+}
diff --git a/apps/code/src/renderer/stores/navigationStore.ts b/apps/code/src/renderer/stores/navigationStore.ts
index 336c77a2b..f11629b6c 100644
--- a/apps/code/src/renderer/stores/navigationStore.ts
+++ b/apps/code/src/renderer/stores/navigationStore.ts
@@ -19,7 +19,8 @@ type ViewType =
   | "inbox"
   | "archived"
   | "command-center"
-  | "skills";
+  | "skills"
+  | "automations";
 
 interface ViewState {
   type: ViewType;
@@ -39,6 +40,7 @@ interface NavigationStore {
   navigateToArchived: () => void;
   navigateToCommandCenter: () => void;
   navigateToSkills: () => void;
+  navigateToAutomations: () => void;
   goBack: () => void;
   goForward: () => void;
   canGoBack: () => boolean;
@@ -69,6 +71,9 @@ const isSameView = (view1: ViewState, view2: ViewState): boolean => {
   if (view1.type === "skills" && view2.type === "skills") {
     return true;
   }
+  if (view1.type === "automations" && view2.type === "automations") {
+    return true;
+  }
   return false;
 };
 
@@ -183,6 +188,10 @@ export const useNavigationStore = create<NavigationStore>()(
           navigate({ type: "skills" });
         },
 
+        navigateToAutomations: () => {
+          navigate({ type: "automations" });
+        },
+
         goBack: () => {
           const { history, historyIndex } = get();
           if (historyIndex > 0) {
diff --git a/apps/code/src/shared/types/automations.ts b/apps/code/src/shared/types/automations.ts
new file mode 100644
index 000000000..b6c222b04
--- /dev/null
+++ b/apps/code/src/shared/types/automations.ts
@@ -0,0 +1,55 @@
+import { z } from "zod";
+
+export const automationRunStatusSchema = z.enum([
+  "success",
+  "failed",
+  "skipped",
+  "running",
+]);
+
+export type AutomationRunStatus = z.infer<typeof automationRunStatusSchema>;
+
+export const automationTemplateSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  prompt: z.string(),
+  category: z.string(),
+  tags: z.array(z.string()).default([]),
+});
+
+export type AutomationTemplate = z.infer<typeof automationTemplateSchema>;
+
+export const automationSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  prompt: z.string(),
+  repoPath: z.string(),
+  repository: z.string().nullable().optional(),
+  githubIntegrationId: z.number().nullable().optional(),
+  scheduleTime: z.string(),
+  timezone: z.string(),
+  enabled: z.boolean(),
+  templateId: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  nextRunAt: z.string().nullable().optional(),
+  lastRunAt: z.string().nullable().optional(),
+  lastRunStatus: automationRunStatusSchema.nullable().optional(),
+  lastTaskId: z.string().nullable().optional(),
+  lastError: z.string().nullable().optional(),
+});
+
+export type Automation = z.infer<typeof automationSchema>;
+
+export const automationRunInfoSchema = z.object({
+  id: z.string(),
+  automationId: z.string(),
+  status: automationRunStatusSchema,
+  output: z.string().nullable().optional(),
+  error: z.string().nullable().optional(),
+  startedAt: z.string(),
+  completedAt: z.string().nullable().optional(),
+});
+
+export type AutomationRunInfo = z.infer<typeof automationRunInfoSchema>;