diff --git a/.gitignore b/.gitignore
index 0d718003e2..adebb9f1f3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,8 @@ out/
 storybook-static
 bin/
 
+# tsup bundled config artifacts (temporary files left behind when bundling TS configs)
+*.config.bundled_*.mjs
 
 # Environment
 .env
diff --git a/apps/code/src/main/di/container.ts b/apps/code/src/main/di/container.ts
index b2e2379419..cb633ee78c 100644
--- a/apps/code/src/main/di/container.ts
+++ b/apps/code/src/main/di/container.ts
@@ -46,6 +46,7 @@ import { FsService } from "../services/fs/service";
 import { GitService } from "../services/git/service";
 import { GitHubIntegrationService } from "../services/github-integration/service";
 import { HandoffService } from "../services/handoff/service";
+import { HomeService } from "../services/home/service";
 import { InboxLinkService } from "../services/inbox-link/service";
 import { LinearIntegrationService } from "../services/linear-integration/service";
 import { LlmGatewayService } from "../services/llm-gateway/service";
@@ -69,6 +70,7 @@ import { UIService } from "../services/ui/service";
 import { UpdatesService } from "../services/updates/service";
 import { UsageMonitorService } from "../services/usage-monitor/service";
 import { WatcherRegistryService } from "../services/watcher-registry/service";
+import { WorkflowService } from "../services/workflow/service";
 import { WorkspaceService } from "../services/workspace/service";
 import { MAIN_TOKENS } from "./tokens";
 
@@ -153,6 +155,8 @@ container.bind(MAIN_TOKENS.TaskLinkService).to(TaskLinkService);
 container.bind(MAIN_TOKENS.InboxLinkService).to(InboxLinkService);
 container.bind(MAIN_TOKENS.NewTaskLinkService).to(NewTaskLinkService);
 container.bind(MAIN_TOKENS.WatcherRegistryService).to(WatcherRegistryService);
+container.bind(MAIN_TOKENS.WorkflowService).to(WorkflowService);
+container.bind(MAIN_TOKENS.HomeService).to(HomeService);
 container.bind(MAIN_TOKENS.WorkspaceService).to(WorkspaceService);
 
 container.bind(MAIN_TOKENS.SettingsStore).toConstantValue(settingsStore);
diff --git a/apps/code/src/main/di/tokens.ts b/apps/code/src/main/di/tokens.ts
index 69ea894b37..94851e469f 100644
--- a/apps/code/src/main/di/tokens.ts
+++ b/apps/code/src/main/di/tokens.ts
@@ -84,4 +84,6 @@ export const MAIN_TOKENS = Object.freeze({
   WorkspaceService: Symbol.for("Main.WorkspaceService"),
   EnrichmentService: Symbol.for("Main.EnrichmentService"),
   UsageMonitorService: Symbol.for("Main.UsageMonitorService"),
+  WorkflowService: Symbol.for("Main.WorkflowService"),
+  HomeService: Symbol.for("Main.HomeService"),
 });
diff --git a/apps/code/src/main/services/auth/service.ts b/apps/code/src/main/services/auth/service.ts
index 4749898e09..18ba3d1f21 100644
--- a/apps/code/src/main/services/auth/service.ts
+++ b/apps/code/src/main/services/auth/service.ts
@@ -226,6 +226,27 @@ export class AuthService extends TypedEventEmitter<AuthServiceEvents> {
 
     return response;
   }
+
+  /**
+   * Authenticated fetch against a project-scoped PostHog endpoint
+   * (`/api/projects/:projectId/<path>`). Throws if no project is selected.
+   */
+  async authenticatedProjectFetch(
+    path: string,
+    init: RequestInit = {},
+  ): Promise<Response> {
+    const { currentProjectId, cloudRegion } = this.getState();
+    if (currentProjectId == null) {
+      throw new Error("No PostHog project selected");
+    }
+    const apiHost = getCloudUrlFromRegion(cloudRegion ?? "us");
+    return this.authenticatedFetch(
+      fetch,
+      `${apiHost}/api/projects/${currentProjectId}/${path}`,
+      init,
+    );
+  }
+
   async redeemInviteCode(code: string): Promise<AuthState> {
     const { apiHost } = await this.getValidAccessToken();
     const response = await this.authenticatedFetch(
diff --git a/apps/code/src/main/services/home/service.test.ts b/apps/code/src/main/services/home/service.test.ts
new file mode 100644
index 0000000000..328b548613
--- /dev/null
+++ b/apps/code/src/main/services/home/service.test.ts
@@ -0,0 +1,169 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../utils/logger", () => ({
+  logger: {
+    scope: () => ({
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    }),
+  },
+}));
+
+import {
+  EMPTY_HOME_SNAPSHOT,
+  HomeEvent,
+  type HomeSnapshot,
+} from "@shared/types/home-snapshot";
+import type { AuthService } from "../auth/service";
+import { HomeService } from "./service";
+
+const POLL_INTERVAL_MS = 120_000;
+
+const SNAP_WITH: HomeSnapshot = {
+  activeAgents: [
+    {
+      taskId: "t1",
+      title: "Fix bug",
+      repoName: null,
+      branch: null,
+      status: "in_progress",
+      lastActivityAt: 1,
+      needsPermission: false,
+      cloudPrUrl: null,
+    },
+  ],
+  needsAttention: [],
+  inProgress: [],
+};
+
+function res(status: number, body: unknown): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  } as Response;
+}
+
+const fetchMock = vi.fn();
+let projectId: string | null;
+const authService = {
+  getState: () => ({ currentProjectId: projectId }),
+  authenticatedProjectFetch: fetchMock,
+} as unknown as AuthService;
+
+let service: HomeService;
+let events: HomeSnapshot[];
+
+beforeEach(() => {
+  fetchMock.mockReset();
+  projectId = "proj_1";
+  events = [];
+  service = new HomeService(authService);
+  service.on(HomeEvent.SnapshotUpdated, (s) => events.push(s));
+});
+
+describe("HomeService.getSnapshot", () => {
+  it("returns EMPTY_HOME_SNAPSHOT without fetching when no project is selected", async () => {
+    projectId = null;
+    await expect(service.getSnapshot()).resolves.toEqual(EMPTY_HOME_SNAPSHOT);
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("returns the parsed snapshot on a successful response", async () => {
+    fetchMock.mockResolvedValue(res(200, SNAP_WITH));
+    await expect(service.getSnapshot()).resolves.toEqual(SNAP_WITH);
+    expect(fetchMock).toHaveBeenCalledWith("code_home/", { method: "GET" });
+  });
+
+  it("returns EMPTY_HOME_SNAPSHOT on a non-ok response", async () => {
+    fetchMock.mockResolvedValue(res(503, {}));
+    await expect(service.getSnapshot()).resolves.toEqual(EMPTY_HOME_SNAPSHOT);
+  });
+
+  it("returns EMPTY_HOME_SNAPSHOT when the body fails schema validation", async () => {
+    fetchMock.mockResolvedValue(res(200, { bogus: true }));
+    await expect(service.getSnapshot()).resolves.toEqual(EMPTY_HOME_SNAPSHOT);
+  });
+
+  it("returns EMPTY_HOME_SNAPSHOT when the fetch throws", async () => {
+    fetchMock.mockRejectedValue(new Error("network down"));
+    await expect(service.getSnapshot()).resolves.toEqual(EMPTY_HOME_SNAPSHOT);
+  });
+});
+
+describe("HomeService.refresh", () => {
+  it("POSTs the refresh endpoint then returns the latest snapshot", async () => {
+    fetchMock
+      .mockResolvedValueOnce(res(200, {}))
+      .mockResolvedValueOnce(res(200, SNAP_WITH));
+    await expect(service.refresh()).resolves.toEqual(SNAP_WITH);
+    expect(fetchMock).toHaveBeenNthCalledWith(1, "code_home/refresh/", {
+      method: "POST",
+    });
+    expect(fetchMock).toHaveBeenNthCalledWith(2, "code_home/", {
+      method: "GET",
+    });
+  });
+
+  it("still returns a snapshot when the refresh POST fails", async () => {
+    fetchMock
+      .mockRejectedValueOnce(new Error("refresh failed"))
+      .mockResolvedValueOnce(res(200, SNAP_WITH));
+    await expect(service.refresh()).resolves.toEqual(SNAP_WITH);
+  });
+});
+
+describe("HomeService poll loop", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    service.dispose();
+    vi.useRealTimers();
+  });
+
+  it("emits SnapshotUpdated when the snapshot changes between polls", async () => {
+    fetchMock
+      .mockResolvedValueOnce(res(200, SNAP_WITH))
+      .mockResolvedValueOnce(res(200, EMPTY_HOME_SNAPSHOT));
+    service.init();
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    expect(events).toEqual([SNAP_WITH, EMPTY_HOME_SNAPSHOT]);
+  });
+
+  it("does not re-emit an unchanged snapshot", async () => {
+    fetchMock.mockResolvedValue(res(200, SNAP_WITH));
+    service.init();
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    expect(events).toEqual([SNAP_WITH]);
+  });
+
+  it("does not emit when a poll fails", async () => {
+    fetchMock.mockResolvedValue(res(500, {}));
+    service.init();
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    expect(events).toEqual([]);
+  });
+
+  it("getSnapshot seeds the dedup state so a matching first poll does not emit", async () => {
+    fetchMock.mockResolvedValue(res(200, SNAP_WITH));
+    await service.getSnapshot();
+    service.init();
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS);
+    expect(events).toEqual([]);
+  });
+
+  it("dispose stops the timer", async () => {
+    fetchMock.mockResolvedValue(res(200, SNAP_WITH));
+    service.init();
+    service.dispose();
+    await vi.advanceTimersByTimeAsync(POLL_INTERVAL_MS * 3);
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(events).toEqual([]);
+  });
+});
diff --git a/apps/code/src/main/services/home/service.ts b/apps/code/src/main/services/home/service.ts
new file mode 100644
index 0000000000..cb14a54847
--- /dev/null
+++ b/apps/code/src/main/services/home/service.ts
@@ -0,0 +1,109 @@
+import {
+  EMPTY_HOME_SNAPSHOT,
+  HomeEvent,
+  type HomeEvents,
+  type HomeSnapshot,
+  homeSnapshot,
+} from "@shared/types/home-snapshot";
+import { inject, injectable, postConstruct } from "inversify";
+import { MAIN_TOKENS } from "../../di/tokens";
+import { logger } from "../../utils/logger";
+import { TypedEventEmitter } from "../../utils/typed-event-emitter";
+import type { AuthService } from "../auth/service";
+
+const log = logger.scope("home");
+
+const POLL_INTERVAL_MS = 120_000;
+
+/**
+ * Reads the per-user Home snapshot from PostHog. All grouping, PR polling, and
+ * classification happen server-side in the `evaluate-code-workstreams` Temporal
+ * worker; this service is a thin authenticated client + poll loop that emits
+ * {@link HomeEvent.SnapshotUpdated} when the snapshot changes.
+ */
+@injectable()
+export class HomeService extends TypedEventEmitter<HomeEvents> {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastSerialized: string | null = null;
+
+  constructor(
+    @inject(MAIN_TOKENS.AuthService)
+    private readonly authService: AuthService,
+  ) {
+    super();
+  }
+
+  @postConstruct()
+  init(): void {
+    this.timer = setInterval(() => {
+      void this.poll();
+    }, POLL_INTERVAL_MS);
+  }
+
+  dispose(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async getSnapshot(): Promise<HomeSnapshot> {
+    const snapshot = (await this.fetchSnapshot()) ?? EMPTY_HOME_SNAPSHOT;
+    this.lastSerialized = JSON.stringify(snapshot);
+    return snapshot;
+  }
+
+  async refresh(): Promise<HomeSnapshot> {
+    await this.requestServerRefresh();
+    return this.getSnapshot();
+  }
+
+  private async poll(): Promise<void> {
+    const snapshot = await this.fetchSnapshot();
+    if (!snapshot) return;
+    const serialized = JSON.stringify(snapshot);
+    if (serialized === this.lastSerialized) return;
+    this.lastSerialized = serialized;
+    this.emit(HomeEvent.SnapshotUpdated, snapshot);
+  }
+
+  private async fetchSnapshot(): Promise<HomeSnapshot | null> {
+    if (this.authService.getState().currentProjectId == null) return null;
+    try {
+      const res = await this.authService.authenticatedProjectFetch(
+        "code_home/",
+        { method: "GET" },
+      );
+      if (!res.ok) {
+        log.warn("Failed to fetch home snapshot", { status: res.status });
+        return null;
+      }
+      const parsed = homeSnapshot.safeParse(await res.json());
+      if (!parsed.success) {
+        log.warn("Home snapshot failed schema validation", {
+          error: parsed.error.message,
+        });
+        return null;
+      }
+      return parsed.data;
+    } catch (err) {
+      log.warn("Error fetching home snapshot", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+      return null;
+    }
+  }
+
+  private async requestServerRefresh(): Promise<void> {
+    if (this.authService.getState().currentProjectId == null) return;
+    try {
+      await this.authService.authenticatedProjectFetch("code_home/refresh/", {
+        method: "POST",
+      });
+    } catch (err) {
+      log.warn("Error requesting home refresh", {
+        error: err instanceof Error ? err.message : String(err),
+      });
+    }
+  }
+}
diff --git a/apps/code/src/main/services/workflow/service.test.ts b/apps/code/src/main/services/workflow/service.test.ts
new file mode 100644
index 0000000000..e2c3e7ce59
--- /dev/null
+++ b/apps/code/src/main/services/workflow/service.test.ts
@@ -0,0 +1,141 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../../utils/logger", () => ({
+  logger: {
+    scope: () => ({
+      info: vi.fn(),
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    }),
+  },
+}));
+
+import {
+  type SaveInput,
+  type WorkflowConfig,
+  WorkflowEvent,
+} from "@shared/types/workflow";
+import type { AuthService } from "../auth/service";
+import { WorkflowService } from "./service";
+
+const BINDINGS = {
+  working: [],
+  in_review: [],
+  ci_failing: [],
+  changes_requested: [],
+  comments_waiting: [],
+  ready_to_merge: [],
+  stale: [],
+  done: [],
+};
+
+const CONFIG: WorkflowConfig = {
+  id: "wf_1",
+  version: 2,
+  updatedAt: "2026-01-01T00:00:00Z",
+  bindings: BINDINGS,
+};
+
+const SAVE_INPUT: SaveInput = {
+  config: { id: "wf_1", version: 2, bindings: BINDINGS },
+  expectedVersion: 2,
+};
+
+function res(status: number, body: unknown): Response {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+  } as Response;
+}
+
+const fetchMock = vi.fn();
+const authService = {
+  authenticatedProjectFetch: fetchMock,
+} as unknown as AuthService;
+
+let service: WorkflowService;
+let changed: WorkflowConfig[];
+
+beforeEach(() => {
+  fetchMock.mockReset();
+  changed = [];
+  service = new WorkflowService(authService);
+  service.on(WorkflowEvent.Changed, (c) => changed.push(c));
+});
+
+describe("WorkflowService.get", () => {
+  it("returns the parsed config", async () => {
+    fetchMock.mockResolvedValue(res(200, CONFIG));
+    await expect(service.get()).resolves.toEqual(CONFIG);
+    expect(fetchMock).toHaveBeenCalledWith("code_workflow/", { method: "GET" });
+  });
+
+  it("throws on a 500 response", async () => {
+    fetchMock.mockResolvedValue(res(500, {}));
+    await expect(service.get()).rejects.toThrow("Workflow request failed: 500");
+  });
+});
+
+describe("WorkflowService.save", () => {
+  it("emits Changed and returns the config on a saved result", async () => {
+    fetchMock.mockResolvedValue(res(200, { status: "saved", config: CONFIG }));
+    await expect(service.save(SAVE_INPUT)).resolves.toEqual({
+      status: "saved",
+      config: CONFIG,
+    });
+    expect(changed).toEqual([CONFIG]);
+  });
+
+  it("sends the config and expectedVersion as a JSON POST body", async () => {
+    fetchMock.mockResolvedValue(res(200, { status: "saved", config: CONFIG }));
+    await service.save(SAVE_INPUT);
+    expect(fetchMock).toHaveBeenCalledWith("code_workflow/save/", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        config: SAVE_INPUT.config,
+        expectedVersion: SAVE_INPUT.expectedVersion,
+      }),
+    });
+  });
+
+  it("does not emit on a 409 conflict that omits config", async () => {
+    fetchMock.mockResolvedValue(res(409, { status: "conflict" }));
+    await expect(service.save(SAVE_INPUT)).resolves.toEqual({
+      status: "conflict",
+    });
+    expect(changed).toEqual([]);
+  });
+
+  it("does not emit on a 422 invalid result and surfaces diagnostics", async () => {
+    const diagnostics = [
+      { severity: "error", code: "action_empty_prompt", message: "empty" },
+    ];
+    fetchMock.mockResolvedValue(res(422, { status: "invalid", diagnostics }));
+    await expect(service.save(SAVE_INPUT)).resolves.toEqual({
+      status: "invalid",
+      diagnostics,
+    });
+    expect(changed).toEqual([]);
+  });
+});
+
+describe("WorkflowService.resetToDefault", () => {
+  it("emits Changed and returns the config", async () => {
+    fetchMock.mockResolvedValue(res(200, CONFIG));
+    await expect(service.resetToDefault()).resolves.toEqual(CONFIG);
+    expect(changed).toEqual([CONFIG]);
+    expect(fetchMock).toHaveBeenCalledWith("code_workflow/reset/", {
+      method: "POST",
+    });
+  });
+
+  it("throws on a non-ok response", async () => {
+    fetchMock.mockResolvedValue(res(500, {}));
+    await expect(service.resetToDefault()).rejects.toThrow(
+      "Workflow request failed: 500",
+    );
+  });
+});
diff --git a/apps/code/src/main/services/workflow/service.ts b/apps/code/src/main/services/workflow/service.ts
new file mode 100644
index 0000000000..b9ba520de4
--- /dev/null
+++ b/apps/code/src/main/services/workflow/service.ts
@@ -0,0 +1,77 @@
+import {
+  type SaveInput,
+  type SaveResult,
+  saveResult,
+  type WorkflowConfig,
+  WorkflowEvent,
+  type WorkflowEvents,
+  workflowConfig,
+} from "@shared/types/workflow";
+import { inject, injectable } from "inversify";
+import { MAIN_TOKENS } from "../../di/tokens";
+import { logger } from "../../utils/logger";
+import { TypedEventEmitter } from "../../utils/typed-event-emitter";
+import type { AuthService } from "../auth/service";
+
+const log = logger.scope("workflow");
+
+/**
+ * Reads and writes the user's Home workflow config from PostHog
+ * (`/api/projects/:id/code_workflow/`). The server owns persistence, the
+ * monotonic `version`, optimistic concurrency, validation, and the default
+ * seed; this service is a thin authenticated client that emits
+ * {@link WorkflowEvent.Changed} on save/reset.
+ */
+@injectable()
+export class WorkflowService extends TypedEventEmitter<WorkflowEvents> {
+  constructor(
+    @inject(MAIN_TOKENS.AuthService)
+    private readonly authService: AuthService,
+  ) {
+    super();
+  }
+
+  async get(): Promise<WorkflowConfig> {
+    const json = await this.request("GET", "code_workflow/");
+    return workflowConfig.parse(json);
+  }
+
+  async save(input: SaveInput): Promise<SaveResult> {
+    const json = await this.request("POST", "code_workflow/save/", {
+      config: input.config,
+      expectedVersion: input.expectedVersion,
+    });
+    const parsed = saveResult.parse(json);
+    if (parsed.status === "saved") {
+      this.emit(WorkflowEvent.Changed, parsed.config);
+      log.info("Workflow saved", { version: parsed.config.version });
+    }
+    return parsed;
+  }
+
+  async resetToDefault(): Promise<WorkflowConfig> {
+    const json = await this.request("POST", "code_workflow/reset/");
+    const config = workflowConfig.parse(json);
+    this.emit(WorkflowEvent.Changed, config);
+    log.info("Workflow reset to default", { version: config.version });
+    return config;
+  }
+
+  private async request(
+    method: "GET" | "POST",
+    path: string,
+    body?: unknown,
+  ): Promise<unknown> {
+    const init: RequestInit = { method };
+    if (body !== undefined) {
+      init.headers = { "Content-Type": "application/json" };
+      init.body = JSON.stringify(body);
+    }
+    const res = await this.authService.authenticatedProjectFetch(path, init);
+    // 409/422 carry a structured SaveResult body the caller validates.
+    if (!res.ok && res.status !== 409 && res.status !== 422) {
+      throw new Error(`Workflow request failed: ${res.status}`);
+    }
+    return res.json();
+  }
+}
diff --git a/apps/code/src/main/trpc/router.ts b/apps/code/src/main/trpc/router.ts
index f0f8dd9eb5..75c3acdd0a 100644
--- a/apps/code/src/main/trpc/router.ts
+++ b/apps/code/src/main/trpc/router.ts
@@ -18,6 +18,7 @@ import { fsRouter } from "./routers/fs";
 import { gitRouter } from "./routers/git";
 import { githubIntegrationRouter } from "./routers/github-integration";
 import { handoffRouter } from "./routers/handoff";
+import { homeRouter } from "./routers/home";
 import { linearIntegrationRouter } from "./routers/linear-integration.js";
 import { llmGatewayRouter } from "./routers/llm-gateway";
 import { logsRouter } from "./routers/logs";
@@ -37,6 +38,7 @@ import { suspensionRouter } from "./routers/suspension.js";
 import { uiRouter } from "./routers/ui";
 import { updatesRouter } from "./routers/updates";
 import { usageMonitorRouter } from "./routers/usage-monitor";
+import { workflowRouter } from "./routers/workflow";
 import { workspaceRouter } from "./routers/workspace";
 import { router } from "./trpc";
 
@@ -61,6 +63,7 @@ export const trpcRouter = router({
   git: gitRouter,
   githubIntegration: githubIntegrationRouter,
   handoff: handoffRouter,
+  home: homeRouter,
   linearIntegration: linearIntegrationRouter,
   llmGateway: llmGatewayRouter,
   mcpApps: mcpAppsRouter,
@@ -81,6 +84,7 @@ export const trpcRouter = router({
   updates: updatesRouter,
   usageMonitor: usageMonitorRouter,
   deepLink: deepLinkRouter,
+  workflow: workflowRouter,
   workspace: workspaceRouter,
 });
 
diff --git a/apps/code/src/main/trpc/routers/home.ts b/apps/code/src/main/trpc/routers/home.ts
new file mode 100644
index 0000000000..a6e9990c64
--- /dev/null
+++ b/apps/code/src/main/trpc/routers/home.ts
@@ -0,0 +1,31 @@
+import {
+  HomeEvent,
+  type HomeEvents,
+  homeSnapshot,
+} from "@shared/types/home-snapshot";
+import { container } from "../../di/container";
+import { MAIN_TOKENS } from "../../di/tokens";
+import type { HomeService } from "../../services/home/service";
+import { publicProcedure, router } from "../trpc";
+
+const getService = () => container.get<HomeService>(MAIN_TOKENS.HomeService);
+
+function subscribe<K extends keyof HomeEvents>(event: K) {
+  return publicProcedure.subscription(async function* (opts) {
+    const service = getService();
+    const iterable = service.toIterable(event, { signal: opts.signal });
+    for await (const data of iterable) {
+      yield data;
+    }
+  });
+}
+
+export const homeRouter = router({
+  getSnapshot: publicProcedure
+    .output(homeSnapshot)
+    .query(() => getService().getSnapshot()),
+  refresh: publicProcedure
+    .output(homeSnapshot)
+    .mutation(() => getService().refresh()),
+  onSnapshotUpdated: subscribe(HomeEvent.SnapshotUpdated),
+});
diff --git a/apps/code/src/main/trpc/routers/workflow.ts b/apps/code/src/main/trpc/routers/workflow.ts
new file mode 100644
index 0000000000..fdb4420e9c
--- /dev/null
+++ b/apps/code/src/main/trpc/routers/workflow.ts
@@ -0,0 +1,36 @@
+import {
+  saveInput,
+  saveResult,
+  WorkflowEvent,
+  type WorkflowEvents,
+  workflowConfig,
+} from "@shared/types/workflow";
+import { container } from "../../di/container";
+import { MAIN_TOKENS } from "../../di/tokens";
+import type { WorkflowService } from "../../services/workflow/service";
+import { publicProcedure, router } from "../trpc";
+
+const getService = () =>
+  container.get<WorkflowService>(MAIN_TOKENS.WorkflowService);
+
+function subscribe<K extends keyof WorkflowEvents>(event: K) {
+  return publicProcedure.subscription(async function* (opts) {
+    const service = getService();
+    const iterable = service.toIterable(event, { signal: opts.signal });
+    for await (const data of iterable) {
+      yield data;
+    }
+  });
+}
+
+export const workflowRouter = router({
+  get: publicProcedure.output(workflowConfig).query(() => getService().get()),
+  save: publicProcedure
+    .input(saveInput)
+    .output(saveResult)
+    .mutation(({ input }) => getService().save(input)),
+  resetToDefault: publicProcedure
+    .output(workflowConfig)
+    .mutation(() => getService().resetToDefault()),
+  onChanged: subscribe(WorkflowEvent.Changed),
+});
diff --git a/apps/code/src/renderer/App.tsx b/apps/code/src/renderer/App.tsx
index c6277ab875..3335551a17 100644
--- a/apps/code/src/renderer/App.tsx
+++ b/apps/code/src/renderer/App.tsx
@@ -13,6 +13,7 @@ import { useAuthSession } from "@features/auth/hooks/useAuthSession";
 import { useIsOrgAdmin } from "@features/auth/hooks/useOrgRole";
 import { registerBillingSubscriptions } from "@features/billing/subscriptions";
 import { AddDirectoryDialog } from "@features/folder-picker/components/AddDirectoryDialog";
+import { registerHomeSubscriptions } from "@features/home/subscriptions";
 import { OnboardingFlow } from "@features/onboarding/components/OnboardingFlow";
 import { useOnboardingStore } from "@features/onboarding/stores/onboardingStore";
 import { Flex, Spinner, Text } from "@radix-ui/themes";
@@ -76,6 +77,11 @@ function App() {
     return registerBillingSubscriptions();
   }, [isAuthenticated]);
 
+  useEffect(() => {
+    if (!isAuthenticated) return;
+    return registerHomeSubscriptions();
+  }, [isAuthenticated]);
+
   // Initialize update store
   useEffect(() => {
     return initializeUpdateStore();
diff --git a/apps/code/src/renderer/features/home/components/HomeActiveAgentsStrip.tsx b/apps/code/src/renderer/features/home/components/HomeActiveAgentsStrip.tsx
new file mode 100644
index 0000000000..8668aff499
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeActiveAgentsStrip.tsx
@@ -0,0 +1,109 @@
+import { openTask } from "@hooks/useOpenTask";
+import { CircleNotch, GitBranch, Warning } from "@phosphor-icons/react";
+import { Box, Flex, ScrollArea, Text } from "@radix-ui/themes";
+import { useTasks } from "@renderer/features/tasks/hooks/useTasks";
+import type { HomeActiveAgent } from "@shared/types/home-snapshot";
+import { formatRelativeTimeShort } from "@utils/time";
+import { useMemo } from "react";
+
+interface HomeActiveAgentsStripProps {
+  agents: HomeActiveAgent[];
+}
+
+export function HomeActiveAgentsStrip({ agents }: HomeActiveAgentsStripProps) {
+  const { data: tasks = [] } = useTasks();
+  const taskById = useMemo(() => new Map(tasks.map((t) => [t.id, t])), [tasks]);
+
+  if (agents.length === 0) return null;
+
+  return (
+    <Box className="border-(--gray-3) border-b px-4 py-3">
+      <Flex align="center" gap="2" mb="2">
+        <CircleNotch
+          size={13}
+          className="animate-spin text-(--green-11)"
+          weight="bold"
+        />
+        <Text className="font-semibold text-[12px] text-gray-12">Running</Text>
+        <Text className="rounded-full bg-(--gray-a3) px-1.5 py-px font-medium text-(--gray-11) text-[10.5px] tabular-nums">
+          {agents.length}
+        </Text>
+      </Flex>
+      <ScrollArea scrollbars="horizontal">
+        <Flex gap="2" className="pb-1">
+          {agents.map((agent) => {
+            const task = taskById.get(agent.taskId);
+            const dotColor = agent.needsPermission
+              ? "var(--amber-9)"
+              : agent.status === "queued"
+                ? "var(--gray-8)"
+                : "var(--green-9)";
+            return (
+              <button
+                key={agent.taskId}
+                type="button"
+                onClick={() => {
+                  if (task) void openTask(task);
+                }}
+                className="group hover:-translate-y-px flex min-w-[260px] max-w-[320px] shrink-0 cursor-pointer flex-col items-start gap-1.5 rounded-lg border border-(--gray-4) bg-(--color-panel-solid) px-3 py-2.5 text-left transition-all hover:border-(--gray-7) hover:shadow-sm"
+              >
+                <Flex
+                  align="center"
+                  gap="2"
+                  justify="between"
+                  className="w-full"
+                >
+                  <Flex align="center" gap="2" className="min-w-0">
+                    <span
+                      className="inline-block h-2 w-2 shrink-0 animate-pulse rounded-full"
+                      style={{ backgroundColor: dotColor }}
+                    />
+                    <Text
+                      className="truncate font-medium text-[13px] text-gray-12 leading-tight"
+                      title={agent.title}
+                    >
+                      {agent.title || "Untitled task"}
+                    </Text>
+                  </Flex>
+                  <Text className="shrink-0 text-(--gray-9) text-[11px]">
+                    {formatRelativeTimeShort(agent.lastActivityAt)}
+                  </Text>
+                </Flex>
+                <Flex
+                  align="center"
+                  gap="2"
+                  className="w-full pl-4 text-(--gray-10) text-[11px]"
+                >
+                  {agent.repoName ? (
+                    <span className="shrink-0 text-(--gray-11)">
+                      {agent.repoName}
+                    </span>
+                  ) : null}
+                  {agent.branch ? (
+                    <Flex align="center" gap="1" className="min-w-0">
+                      <GitBranch size={10} className="shrink-0" />
+                      <span className="truncate" title={agent.branch}>
+                        {agent.branch}
+                      </span>
+                    </Flex>
+                  ) : null}
+                  {agent.needsPermission ? (
+                    <Flex
+                      align="center"
+                      gap="1"
+                      className="shrink-0 text-(--amber-11)"
+                      title="Waiting on permission"
+                    >
+                      <Warning size={10} weight="fill" />
+                      <span>Needs input</span>
+                    </Flex>
+                  ) : null}
+                </Flex>
+              </button>
+            );
+          })}
+        </Flex>
+      </ScrollArea>
+    </Box>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/HomeBoardView.tsx b/apps/code/src/renderer/features/home/components/HomeBoardView.tsx
new file mode 100644
index 0000000000..3abf84f16a
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeBoardView.tsx
@@ -0,0 +1,82 @@
+import { ScrollArea } from "@radix-ui/themes";
+import type { HomeSnapshot } from "@shared/types/home-snapshot";
+import type { SituationId } from "@shared/types/workflow";
+import { useMemo } from "react";
+import { buildBoardColumns, type HomeBoardColumn } from "../utils/boardColumns";
+import { SITUATION_VISUAL, situationCss } from "../utils/situationDisplay";
+import { HomeWorkstreamCard } from "./HomeWorkstreamCard";
+
+interface HomeBoardViewProps {
+  snapshot: HomeSnapshot;
+}
+
+export function HomeBoardView({ snapshot }: HomeBoardViewProps) {
+  const columns = useMemo(
+    () => buildBoardColumns(snapshot.needsAttention, snapshot.inProgress),
+    [snapshot.needsAttention, snapshot.inProgress],
+  );
+
+  return (
+    <ScrollArea scrollbars="horizontal">
+      <div className="flex h-full min-h-0 gap-3 p-4">
+        {columns.map((column) => (
+          <BoardColumn key={column.id} column={column} />
+        ))}
+      </div>
+    </ScrollArea>
+  );
+}
+
+function BoardColumn({ column }: { column: HomeBoardColumn }) {
+  const v = SITUATION_VISUAL[column.id];
+  const c = situationCss(v.color);
+  const Icon = v.Icon;
+  const count = column.workstreams.length;
+
+  return (
+    <div className="flex h-full min-h-0 w-[300px] shrink-0 flex-col">
+      <div className="mb-2 flex items-center gap-2 px-1" title={v.description}>
+        <span style={{ color: c.fg }}>
+          <Icon size={14} weight="bold" />
+        </span>
+        <span className="font-semibold text-[12px] text-gray-12">
+          {v.label}
+        </span>
+        <span
+          className="rounded-full px-1.5 py-px font-semibold text-[10.5px] tabular-nums"
+          style={{ color: c.fg, backgroundColor: c.tint }}
+        >
+          {count}
+        </span>
+      </div>
+
+      <div
+        className="min-h-0 flex-1 rounded-xl border border-(--gray-3)"
+        style={{ backgroundColor: c.wash }}
+      >
+        <ScrollArea scrollbars="vertical">
+          <div className="flex flex-col gap-2 p-2">
+            {count === 0 ? (
+              <EmptyColumn sid={column.id} />
+            ) : (
+              column.workstreams.map((ws) => (
+                <HomeWorkstreamCard key={ws.id} workstream={ws} />
+              ))
+            )}
+          </div>
+        </ScrollArea>
+      </div>
+    </div>
+  );
+}
+
+function EmptyColumn({ sid }: { sid: SituationId }) {
+  const v = SITUATION_VISUAL[sid];
+  const Icon = v.Icon;
+  return (
+    <div className="flex flex-col items-center justify-center gap-1.5 rounded-lg border border-(--gray-a5) border-dashed py-10">
+      <Icon size={18} className="text-(--gray-8)" />
+      <span className="text-(--gray-9) text-[11px]">Nothing here</span>
+    </div>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/HomeEmptyState.tsx b/apps/code/src/renderer/features/home/components/HomeEmptyState.tsx
new file mode 100644
index 0000000000..46e64140cb
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeEmptyState.tsx
@@ -0,0 +1,42 @@
+import { openTaskInput } from "@hooks/useOpenTask";
+import { CheckCircle, Plus } from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Flex, Text } from "@radix-ui/themes";
+
+interface HomeEmptyStateProps {
+  hasRunningAgents: boolean;
+}
+
+export function HomeEmptyState({ hasRunningAgents }: HomeEmptyStateProps) {
+  return (
+    <Flex
+      direction="column"
+      align="center"
+      justify="center"
+      gap="3"
+      className="h-full px-5 py-12"
+    >
+      <Flex
+        align="center"
+        justify="center"
+        className="h-14 w-14 rounded-full bg-(--green-a3)"
+      >
+        <CheckCircle size={30} className="text-(--green-11)" weight="fill" />
+      </Flex>
+      <Text className="font-semibold text-[16px] text-gray-12">
+        You're caught up
+      </Text>
+      <Text className="max-w-[360px] text-center text-(--gray-11) text-[13px]">
+        {hasRunningAgents
+          ? "Nothing else needs your attention. Your active agents are working."
+          : "Nothing needs your attention right now. Start something new when you're ready."}
+      </Text>
+      {!hasRunningAgents ? (
+        <Button variant="primary" size="sm" onClick={() => openTaskInput()}>
+          <Plus size={12} />
+          New task
+        </Button>
+      ) : null}
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/HomeView.tsx b/apps/code/src/renderer/features/home/components/HomeView.tsx
new file mode 100644
index 0000000000..a6e38020e0
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeView.tsx
@@ -0,0 +1,293 @@
+import { DotsCircleSpinner } from "@components/DotsCircleSpinner";
+import { useSetHeaderContent } from "@hooks/useSetHeaderContent";
+import {
+  CircleHalf,
+  Graph,
+  House,
+  Kanban,
+  ListBullets,
+  Warning,
+} from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Box, Flex, ScrollArea, Text } from "@radix-ui/themes";
+import { useEffect, useMemo } from "react";
+import { ConfigMap } from "../config/ConfigMap";
+import { useHomeSnapshot } from "../hooks/useHomeSnapshot";
+import { type HomeViewMode, useHomeUiStore } from "../stores/homeUiStore";
+import { HomeActiveAgentsStrip } from "./HomeActiveAgentsStrip";
+import { HomeBoardView } from "./HomeBoardView";
+import { HomeEmptyState } from "./HomeEmptyState";
+import { HomeWorkstreamDetailPanel } from "./HomeWorkstreamDetailPanel";
+import { HomeWorkstreamRow } from "./HomeWorkstreamRow";
+
+const VIEW_CYCLE: HomeViewMode[] = ["list", "board", "config"];
+
+const HEADER_CONTENT = (
+  <Flex align="center" gap="2" className="w-full min-w-0">
+    <House size={12} className="shrink-0 text-gray-10" />
+    <Text
+      className="truncate whitespace-nowrap font-medium text-[13px]"
+      title="Home"
+    >
+      Home
+    </Text>
+  </Flex>
+);
+
+export function HomeView() {
+  const { snapshot, isLoading } = useHomeSnapshot();
+  const viewMode = useHomeUiStore((s) => s.viewMode);
+  const setViewMode = useHomeUiStore((s) => s.setViewMode);
+  const selectedWorkstreamId = useHomeUiStore((s) => s.selectedWorkstreamId);
+  const setSelectedWorkstreamId = useHomeUiStore(
+    (s) => s.setSelectedWorkstreamId,
+  );
+
+  useSetHeaderContent(HEADER_CONTENT);
+
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      if (e.key === "Escape") {
+        if (selectedWorkstreamId) setSelectedWorkstreamId(null);
+        return;
+      }
+      if (e.key !== "v" || e.metaKey || e.ctrlKey || e.altKey) return;
+      // Don't capture `v` while the user is typing.
+      const target = e.target as HTMLElement | null;
+      const tag = target?.tagName;
+      if (tag === "INPUT" || tag === "TEXTAREA" || target?.isContentEditable) {
+        return;
+      }
+      const idx = VIEW_CYCLE.indexOf(viewMode);
+      setViewMode(VIEW_CYCLE[(idx + 1) % VIEW_CYCLE.length] ?? "list");
+    }
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [viewMode, setViewMode, selectedWorkstreamId, setSelectedWorkstreamId]);
+
+  const { activeAgents, needsAttention, inProgress } = snapshot;
+  const selectedWorkstream = useMemo(
+    () =>
+      selectedWorkstreamId
+        ? (needsAttention.find((ws) => ws.id === selectedWorkstreamId) ??
+          inProgress.find((ws) => ws.id === selectedWorkstreamId) ??
+          null)
+        : null,
+    [selectedWorkstreamId, needsAttention, inProgress],
+  );
+
+  if (isLoading) {
+    return (
+      <Flex align="center" justify="center" className="h-full">
+        <DotsCircleSpinner size={16} className="text-gray-10" />
+      </Flex>
+    );
+  }
+
+  const totalRows = needsAttention.length + inProgress.length;
+  const hasContent = activeAgents.length > 0 || totalRows > 0;
+
+  return (
+    <Flex direction="column" className="h-full">
+      <Box className="border-(--gray-4) border-b px-5 py-3">
+        <Flex align="center" justify="between" gap="3">
+          <Flex direction="column" gap="1" className="min-w-0">
+            <Flex align="center" gap="2">
+              <Text className="font-semibold text-[15px] text-gray-12">
+                Home
+              </Text>
+            </Flex>
+            {hasContent ? (
+              <Flex align="center" gap="3" className="text-[12px]">
+                {needsAttention.length > 0 ? (
+                  <Stat
+                    color="var(--amber-9)"
+                    label={`${needsAttention.length} need${needsAttention.length === 1 ? "s" : ""} attention`}
+                  />
+                ) : null}
+                {activeAgents.length > 0 ? (
+                  <Stat
+                    color="var(--green-9)"
+                    label={`${activeAgents.length} running`}
+                    pulse
+                  />
+                ) : null}
+                {inProgress.length > 0 ? (
+                  <Stat
+                    color="var(--blue-9)"
+                    label={`${inProgress.length} in progress`}
+                  />
+                ) : null}
+              </Flex>
+            ) : (
+              <Text className="text-(--gray-11) text-[12px]">
+                You're caught up
+              </Text>
+            )}
+          </Flex>
+          <Flex align="center" gap="2" className="shrink-0">
+            <ViewModeToggle value={viewMode} onChange={setViewMode} />
+          </Flex>
+        </Flex>
+      </Box>
+
+      {viewMode === "config" ? (
+        <Box className="min-h-0 flex-1">
+          <ConfigMap />
+        </Box>
+      ) : (
+        <>
+          <HomeActiveAgentsStrip agents={activeAgents} />
+          <Flex className="min-h-0 flex-1">
+            <Box className="min-w-0 flex-1">
+              {!hasContent ? (
+                <HomeEmptyState hasRunningAgents={activeAgents.length > 0} />
+              ) : viewMode === "board" ? (
+                <Box className="h-full min-h-0">
+                  <HomeBoardView snapshot={snapshot} />
+                </Box>
+              ) : (
+                <ScrollArea scrollbars="vertical">
+                  {needsAttention.length > 0 ? (
+                    <Section
+                      title="Needs attention"
+                      icon={
+                        <Warning
+                          size={13}
+                          weight="fill"
+                          className="text-(--amber-11)"
+                        />
+                      }
+                      count={needsAttention.length}
+                    >
+                      {needsAttention.map((ws) => (
+                        <HomeWorkstreamRow key={ws.id} workstream={ws} />
+                      ))}
+                    </Section>
+                  ) : null}
+
+                  {inProgress.length > 0 ? (
+                    <Section
+                      title="In progress"
+                      icon={
+                        <CircleHalf
+                          size={13}
+                          weight="fill"
+                          className="text-(--blue-11)"
+                        />
+                      }
+                      count={inProgress.length}
+                    >
+                      {inProgress.map((ws) => (
+                        <HomeWorkstreamRow key={ws.id} workstream={ws} />
+                      ))}
+                    </Section>
+                  ) : null}
+
+                  {totalRows === 0 && activeAgents.length > 0 ? (
+                    <HomeEmptyState hasRunningAgents />
+                  ) : null}
+                </ScrollArea>
+              )}
+            </Box>
+            {selectedWorkstream ? (
+              <Box className="w-[400px] shrink-0 border-(--gray-4) border-l">
+                <HomeWorkstreamDetailPanel
+                  workstream={selectedWorkstream}
+                  onClose={() => setSelectedWorkstreamId(null)}
+                />
+              </Box>
+            ) : null}
+          </Flex>
+        </>
+      )}
+    </Flex>
+  );
+}
+
+interface SectionProps {
+  title: string;
+  count: number;
+  icon?: React.ReactNode;
+  children: React.ReactNode;
+}
+
+interface ViewModeToggleProps {
+  value: HomeViewMode;
+  onChange: (next: HomeViewMode) => void;
+}
+
+function ViewModeToggle({ value, onChange }: ViewModeToggleProps) {
+  return (
+    <Flex
+      align="center"
+      gap="1"
+      className="shrink-0 rounded-md border border-(--gray-4) bg-(--gray-2) p-0.5"
+      title="Switch view (press v to cycle)"
+    >
+      <Button
+        size="xs"
+        variant={value === "list" ? "primary" : "link-muted"}
+        onClick={() => onChange("list")}
+      >
+        <ListBullets size={12} />
+        List
+      </Button>
+      <Button
+        size="xs"
+        variant={value === "board" ? "primary" : "link-muted"}
+        onClick={() => onChange("board")}
+      >
+        <Kanban size={12} />
+        Board
+      </Button>
+      <Button
+        size="xs"
+        variant={value === "config" ? "primary" : "link-muted"}
+        onClick={() => onChange("config")}
+      >
+        <Graph size={12} />
+        Config
+      </Button>
+    </Flex>
+  );
+}
+
+function Stat({
+  color,
+  label,
+  pulse = false,
+}: {
+  color: string;
+  label: string;
+  pulse?: boolean;
+}) {
+  return (
+    <Flex align="center" gap="1.5">
+      <span
+        className={`inline-block h-2 w-2 rounded-full ${pulse ? "animate-pulse" : ""}`}
+        style={{ backgroundColor: color }}
+      />
+      <Text className="text-(--gray-11) text-[12px]">{label}</Text>
+    </Flex>
+  );
+}
+
+function Section({ title, count, icon, children }: SectionProps) {
+  return (
+    <Box>
+      <Flex
+        align="center"
+        gap="2"
+        className="sticky top-0 z-10 border-(--gray-3) border-b bg-(--color-panel-solid) px-4 py-2"
+      >
+        {icon}
+        <Text className="font-semibold text-[12px] text-gray-12">{title}</Text>
+        <Text className="rounded-full bg-(--gray-a3) px-1.5 py-px font-medium text-(--gray-11) text-[10.5px] tabular-nums">
+          {count}
+        </Text>
+      </Flex>
+      {children}
+    </Box>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/HomeWorkstreamCard.tsx b/apps/code/src/renderer/features/home/components/HomeWorkstreamCard.tsx
new file mode 100644
index 0000000000..6cedf4a81e
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeWorkstreamCard.tsx
@@ -0,0 +1,202 @@
+import {
+  GitBranch,
+  GitPullRequest,
+  Sparkle,
+  Warning,
+} from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Box, Flex, Text } from "@radix-ui/themes";
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import { formatRelativeTimeShort } from "@utils/time";
+import { useWorkstreamPresentation } from "../hooks/useWorkstreamPresentation";
+import { useHomeUiStore } from "../stores/homeUiStore";
+import { SITUATION_VISUAL } from "../utils/situationDisplay";
+import { SituationChip } from "./SituationChip";
+import {
+  AuthorAvatar,
+  CiIndicator,
+  type MetaItem,
+  MetaList,
+  WorkstreamOverflowMenu,
+} from "./WorkstreamBits";
+
+interface HomeWorkstreamCardProps {
+  workstream: HomeWorkstream;
+}
+
+export function HomeWorkstreamCard({ workstream }: HomeWorkstreamCardProps) {
+  const {
+    pr,
+    title,
+    primarySid,
+    accent,
+    author,
+    extraSituations,
+    needsPermission,
+    primaryBound,
+    restBound,
+    primaryIsPr,
+    primaryIsTask,
+    showPrInMenu,
+    showTaskInMenu,
+    hasMenu,
+    runAction,
+    openTask,
+    openPr,
+  } = useWorkstreamPresentation(workstream);
+  const setSelectedWorkstreamId = useHomeUiStore(
+    (s) => s.setSelectedWorkstreamId,
+  );
+  const isSelected = useHomeUiStore(
+    (s) => s.selectedWorkstreamId === workstream.id,
+  );
+
+  const taskCount = workstream.tasks.length;
+  const primary = SITUATION_VISUAL[primarySid];
+  const PrimaryIcon = primary.Icon;
+
+  const meta: MetaItem[] = [];
+  if (workstream.branch) {
+    meta.push({
+      key: "branch",
+      node: (
+        <span className="inline-flex min-w-0 items-center gap-1">
+          <GitBranch size={11} className="shrink-0" />
+          <span className="max-w-[150px] truncate" title={workstream.branch}>
+            {workstream.branch}
+          </span>
+        </span>
+      ),
+    });
+  }
+  if (pr) {
+    meta.push({ key: "pr", node: <span>#{pr.number}</span> });
+  }
+  if (needsPermission) {
+    meta.push({
+      key: "perm",
+      node: (
+        <span className="inline-flex items-center gap-1 text-(--amber-11)">
+          <Warning size={11} weight="fill" />
+          Awaiting permission
+        </span>
+      ),
+    });
+  }
+  meta.push({
+    key: "time",
+    node: <span>{formatRelativeTimeShort(workstream.lastActivityAt)}</span>,
+  });
+
+  return (
+    <Box
+      onClick={() => setSelectedWorkstreamId(workstream.id)}
+      onKeyDown={(e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          setSelectedWorkstreamId(workstream.id);
+        }
+      }}
+      role="button"
+      tabIndex={0}
+      aria-label={`Open ${title}`}
+      className="group hover:-translate-y-px relative flex cursor-pointer flex-col gap-2 overflow-hidden rounded-lg border border-(--gray-4) bg-(--color-panel-solid) px-3 pt-3 pb-2.5 transition-all hover:border-(--gray-7) hover:shadow-md"
+      style={
+        isSelected
+          ? {
+              borderColor: "var(--accent-8)",
+              boxShadow: "0 0 0 1px var(--accent-8)",
+            }
+          : undefined
+      }
+    >
+      <span
+        aria-hidden
+        className="absolute inset-x-0 top-0 h-[3px]"
+        style={{ backgroundColor: accent.solid }}
+      />
+
+      <div className="flex items-center justify-between gap-2">
+        <span
+          className="inline-flex min-w-0 items-center gap-1.5 font-semibold text-[11px]"
+          style={{ color: accent.fg }}
+          title={primary.description}
+        >
+          <PrimaryIcon size={13} weight="bold" className="shrink-0" />
+          <span className="truncate">{primary.label}</span>
+        </span>
+        <div className="flex shrink-0 items-center gap-2">
+          {author ? <AuthorAvatar login={author} /> : null}
+          {pr ? <CiIndicator status={pr.ciStatus} /> : null}
+        </div>
+      </div>
+
+      <span
+        className="line-clamp-2 font-medium text-[13px] text-gray-12 leading-snug"
+        title={title}
+      >
+        {title}
+      </span>
+
+      {extraSituations.length > 0 ? (
+        <div className="flex flex-wrap items-center gap-1">
+          {extraSituations.map((sid) => (
+            <SituationChip key={sid} sid={sid} />
+          ))}
+        </div>
+      ) : null}
+
+      <MetaList items={meta} className="mt-0.5" />
+
+      <Flex
+        align="center"
+        justify="between"
+        className="mt-1.5 gap-2 border-(--gray-3) border-t pt-2.5"
+        onClick={(e) => e.stopPropagation()}
+        onKeyDown={(e) => e.stopPropagation()}
+      >
+        {primaryBound ? (
+          <Button
+            variant="primary"
+            size="xs"
+            onClick={() => runAction(primaryBound)}
+            title={`${primaryBound.situationLabel} → ${primaryBound.skillId}`}
+          >
+            <Sparkle size={11} weight="fill" />
+            {primaryBound.label}
+          </Button>
+        ) : primaryIsPr ? (
+          <Button variant="outline" size="xs" onClick={openPr}>
+            <GitPullRequest size={11} />
+            {author ? "Review PR" : "View PR"}
+          </Button>
+        ) : primaryIsTask ? (
+          <Button variant="outline" size="xs" onClick={openTask}>
+            Open task
+          </Button>
+        ) : (
+          <span />
+        )}
+
+        <div className="flex shrink-0 items-center gap-2">
+          {taskCount > 1 ? (
+            <Text className="text-(--gray-10) text-[11px]">
+              {taskCount} tasks
+            </Text>
+          ) : null}
+          {hasMenu ? (
+            <WorkstreamOverflowMenu
+              restBound={restBound}
+              showPrInMenu={showPrInMenu}
+              showTaskInMenu={showTaskInMenu}
+              onRun={runAction}
+              onOpenPr={openPr}
+              onOpenTask={openTask}
+              size="xs"
+            />
+          ) : null}
+        </div>
+      </Flex>
+    </Box>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/HomeWorkstreamDetailPanel.tsx b/apps/code/src/renderer/features/home/components/HomeWorkstreamDetailPanel.tsx
new file mode 100644
index 0000000000..252ea2adc3
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeWorkstreamDetailPanel.tsx
@@ -0,0 +1,343 @@
+import { openTask } from "@hooks/useOpenTask";
+import {
+  ArrowSquareOut,
+  CaretDown,
+  CaretRight,
+  ChatCircle,
+  CheckCircle,
+  CircleDashed,
+  GitBranch,
+  GitPullRequest,
+  Sparkle,
+  Spinner,
+  Warning,
+  X,
+  XCircle,
+} from "@phosphor-icons/react";
+import { Badge, Button } from "@posthog/quill";
+import { Box, DropdownMenu, Flex, Text } from "@radix-ui/themes";
+import { useTasks } from "@renderer/features/tasks/hooks/useTasks";
+import type { TaskRunStatus } from "@shared/types";
+import type {
+  HomeWorkstream,
+  HomeWorkstreamTask,
+} from "@shared/types/home-snapshot";
+import type { PrSnapshot } from "@shared/types/pr-snapshot";
+import { openUrlInBrowser } from "@utils/browser";
+import { formatRelativeTimeShort } from "@utils/time";
+import { type BoundAction, useBoundActions } from "../hooks/useBoundActions";
+import { useRunWorkstreamAction } from "../hooks/useRunWorkstreamAction";
+import { SituationChip } from "./SituationChip";
+import { CiIndicator } from "./WorkstreamBits";
+
+interface Props {
+  workstream: HomeWorkstream;
+  onClose: () => void;
+}
+
+export function HomeWorkstreamDetailPanel({ workstream, onClose }: Props) {
+  const { data: allTasks = [] } = useTasks();
+  const boundActions = useBoundActions(workstream);
+  const runAction = useRunWorkstreamAction();
+
+  const pr = workstream.pr;
+  const headTask = workstream.tasks[0];
+  const title =
+    pr?.title ?? headTask?.title ?? workstream.branch ?? "Workstream";
+
+  function handleOpenTask(task: HomeWorkstreamTask) {
+    const found = allTasks.find((t) => t.id === task.id);
+    if (found) void openTask(found);
+  }
+
+  function handleOpenPr() {
+    if (workstream.prUrl) void openUrlInBrowser(workstream.prUrl);
+  }
+
+  const primaryAction = boundActions[0] ?? null;
+  const overflowActions = boundActions.slice(1);
+
+  return (
+    <Flex
+      direction="column"
+      className="h-full min-h-0 w-full min-w-0 overflow-hidden bg-(--color-panel-solid)"
+    >
+      {/* Header */}
+      <Flex
+        align="start"
+        justify="between"
+        gap="2"
+        className="border-(--gray-4) border-b px-4 py-3"
+      >
+        <Flex direction="column" gap="1" className="min-w-0 flex-1">
+          <Text
+            className="line-clamp-2 break-words font-semibold text-[13px] text-gray-12 leading-snug"
+            title={title}
+          >
+            {title}
+          </Text>
+          <Flex
+            align="center"
+            gap="2"
+            wrap="wrap"
+            className="text-(--gray-10) text-[11px]"
+          >
+            {workstream.repoName ? <Text>{workstream.repoName}</Text> : null}
+            {workstream.branch ? (
+              <Flex align="center" gap="1" className="min-w-0">
+                <GitBranch size={10} />
+                <span className="truncate" title={workstream.branch}>
+                  {workstream.branch}
+                </span>
+              </Flex>
+            ) : null}
+            {pr ? <Text title={`PR #${pr.number}`}>#{pr.number}</Text> : null}
+            <Text>{formatRelativeTimeShort(workstream.lastActivityAt)}</Text>
+          </Flex>
+        </Flex>
+        <Button size="xs" variant="link-muted" onClick={onClose} title="Close">
+          <X size={12} />
+        </Button>
+      </Flex>
+
+      <div className="scrollbar-overlay-y min-h-0 flex-1 overflow-x-hidden">
+        <Flex direction="column" gap="4" className="min-w-0 px-4 py-4">
+          {workstream.situations.length > 0 ? (
+            <Section title="Situations">
+              <Flex gap="1" wrap="wrap">
+                {workstream.situations.map((sid) => (
+                  <SituationChip key={sid} sid={sid} />
+                ))}
+              </Flex>
+            </Section>
+          ) : null}
+
+          {pr ? <PrBlock pr={pr} onOpen={handleOpenPr} /> : null}
+
+          {boundActions.length > 0 ? (
+            <Section title="Quick actions">
+              <Flex gap="1.5" wrap="wrap">
+                {primaryAction ? (
+                  <Button
+                    variant="primary"
+                    size="sm"
+                    onClick={() => runAction(primaryAction, workstream)}
+                    title={`${primaryAction.situationLabel} → ${primaryAction.skillId}`}
+                  >
+                    <Sparkle size={12} />
+                    {primaryAction.label}
+                  </Button>
+                ) : null}
+                {overflowActions.length > 0 ? (
+                  <DropdownMenu.Root>
+                    <DropdownMenu.Trigger>
+                      <Button variant="outline" size="sm">
+                        +{overflowActions.length}
+                        <CaretDown size={10} />
+                      </Button>
+                    </DropdownMenu.Trigger>
+                    <DropdownMenu.Content>
+                      {overflowActions.map((action: BoundAction) => (
+                        <DropdownMenu.Item
+                          key={`${action.situationId}::${action.id}`}
+                          onSelect={() => runAction(action, workstream)}
+                        >
+                          <Sparkle size={11} />
+                          {action.label}
+                          <Text className="ml-auto pl-3 text-(--gray-10) text-[10px]">
+                            {action.situationLabel}
+                          </Text>
+                        </DropdownMenu.Item>
+                      ))}
+                    </DropdownMenu.Content>
+                  </DropdownMenu.Root>
+                ) : null}
+              </Flex>
+            </Section>
+          ) : null}
+
+          <Section
+            title={`Tasks (${workstream.tasks.length})`}
+            subtitle={
+              workstream.tasks.length === 0
+                ? "No tasks attached to this workstream"
+                : undefined
+            }
+          >
+            <Flex direction="column" gap="1">
+              {workstream.tasks.map((task) => (
+                <TaskRow
+                  key={task.id}
+                  task={task}
+                  onClick={() => handleOpenTask(task)}
+                />
+              ))}
+            </Flex>
+          </Section>
+        </Flex>
+      </div>
+
+      {/* Footer links */}
+      {workstream.prUrl ? (
+        <Box className="border-(--gray-4) border-t px-4 py-2">
+          <Button
+            variant="link-muted"
+            size="sm"
+            onClick={handleOpenPr}
+            className="w-full justify-center"
+          >
+            <GitPullRequest size={12} />
+            Open PR in browser
+            <ArrowSquareOut size={10} />
+          </Button>
+        </Box>
+      ) : null}
+    </Flex>
+  );
+}
+
+interface SectionProps {
+  title: string;
+  subtitle?: string;
+  children: React.ReactNode;
+}
+
+function Section({ title, subtitle, children }: SectionProps) {
+  return (
+    <Flex direction="column" gap="2">
+      <Flex direction="column" gap="0">
+        <Text className="font-semibold text-[10px] text-gray-11 uppercase tracking-wider">
+          {title}
+        </Text>
+        {subtitle ? (
+          <Text className="text-[11px] text-gray-10">{subtitle}</Text>
+        ) : null}
+      </Flex>
+      {children}
+    </Flex>
+  );
+}
+
+function PrBlock({ pr, onOpen }: { pr: PrSnapshot; onOpen: () => void }) {
+  return (
+    <Section title="Pull request">
+      <Flex
+        direction="column"
+        gap="2"
+        className="rounded-md border border-(--gray-5) bg-(--gray-2) px-3 py-2.5"
+      >
+        <Flex align="center" justify="between" gap="2">
+          <PrStatePill pr={pr} />
+          <CiIndicator status={pr.ciStatus} showLabel />
+        </Flex>
+        {pr.reviewDecision === "approved" ? (
+          <Flex
+            align="center"
+            gap="1"
+            className="text-(--green-11) text-[11px]"
+          >
+            <CheckCircle size={11} weight="fill" />
+            <span>Approved</span>
+          </Flex>
+        ) : null}
+        {pr.reviewDecision === "changes_requested" ? (
+          <Flex
+            align="center"
+            gap="1"
+            className="text-(--amber-11) text-[11px]"
+          >
+            <Warning size={11} weight="fill" />
+            <span>Changes requested</span>
+          </Flex>
+        ) : null}
+        {pr.unresolvedThreads > 0 ? (
+          <Flex align="center" gap="1" className="text-[11px] text-gray-11">
+            <ChatCircle size={11} />
+            <span>
+              {pr.unresolvedThreads} unresolved review thread
+              {pr.unresolvedThreads === 1 ? "" : "s"}
+            </span>
+          </Flex>
+        ) : null}
+        {pr.author && !pr.isCurrentUserAuthor ? (
+          <Text className="text-[11px] text-gray-11">by @{pr.author}</Text>
+        ) : null}
+        <Button
+          variant="link-muted"
+          size="xs"
+          onClick={onOpen}
+          className="self-start"
+        >
+          <ArrowSquareOut size={10} />
+          Open PR
+        </Button>
+      </Flex>
+    </Section>
+  );
+}
+
+function PrStatePill({ pr }: { pr: PrSnapshot }) {
+  if (pr.state === "merged") return <Badge variant="info">Merged</Badge>;
+  if (pr.state === "draft") return <Badge variant="default">Draft</Badge>;
+  if (pr.state === "closed") return <Badge variant="default">Closed</Badge>;
+  return <Badge variant="success">Open</Badge>;
+}
+
+function TaskRow({
+  task,
+  onClick,
+}: {
+  task: HomeWorkstreamTask;
+  onClick: () => void;
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="flex items-center gap-2 rounded-md border border-(--gray-5) bg-(--gray-1) px-2.5 py-1.5 text-left transition-colors hover:border-(--gray-7) hover:bg-(--gray-2)"
+    >
+      <TaskStatusIcon
+        status={task.status ?? undefined}
+        isGenerating={task.isGenerating}
+      />
+      <Text className="min-w-0 flex-1 truncate text-[12px] text-gray-12">
+        {task.title}
+      </Text>
+      {task.needsPermission ? (
+        <Badge variant="warning" title="Awaiting permission">
+          !
+        </Badge>
+      ) : null}
+      <CaretRight size={11} className="shrink-0 text-(--gray-10)" />
+    </button>
+  );
+}
+
+function TaskStatusIcon({
+  status,
+  isGenerating,
+}: {
+  status: TaskRunStatus | undefined;
+  isGenerating: boolean;
+}) {
+  if (isGenerating || status === "in_progress" || status === "queued") {
+    return (
+      <Spinner size={11} className="shrink-0 animate-spin text-(--accent-11)" />
+    );
+  }
+  if (status === "completed") {
+    return (
+      <CheckCircle
+        size={11}
+        weight="fill"
+        className="shrink-0 text-(--green-9)"
+      />
+    );
+  }
+  if (status === "failed") {
+    return (
+      <XCircle size={11} weight="fill" className="shrink-0 text-(--red-9)" />
+    );
+  }
+  return <CircleDashed size={11} className="shrink-0 text-(--gray-10)" />;
+}
diff --git a/apps/code/src/renderer/features/home/components/HomeWorkstreamRow.tsx b/apps/code/src/renderer/features/home/components/HomeWorkstreamRow.tsx
new file mode 100644
index 0000000000..433fbb8a7f
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/HomeWorkstreamRow.tsx
@@ -0,0 +1,194 @@
+import {
+  ChatCircle,
+  GitBranch,
+  GitPullRequest,
+  Sparkle,
+  Warning,
+} from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Box, Flex, Text } from "@radix-ui/themes";
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import { formatRelativeTimeShort } from "@utils/time";
+import { useWorkstreamPresentation } from "../hooks/useWorkstreamPresentation";
+import { useHomeUiStore } from "../stores/homeUiStore";
+import { SituationChip } from "./SituationChip";
+import {
+  AuthorAvatar,
+  CiIndicator,
+  type MetaItem,
+  MetaList,
+  StatusGlyph,
+  WorkstreamOverflowMenu,
+} from "./WorkstreamBits";
+
+interface HomeWorkstreamRowProps {
+  workstream: HomeWorkstream;
+}
+
+export function HomeWorkstreamRow({ workstream }: HomeWorkstreamRowProps) {
+  const {
+    pr,
+    title,
+    primarySid,
+    accent,
+    author,
+    extraSituations,
+    generating,
+    needsPermission,
+    primaryBound,
+    restBound,
+    primaryIsPr,
+    primaryIsTask,
+    showPrInMenu,
+    showTaskInMenu,
+    hasMenu,
+    runAction,
+    openTask,
+    openPr,
+  } = useWorkstreamPresentation(workstream);
+  const setSelectedWorkstreamId = useHomeUiStore(
+    (s) => s.setSelectedWorkstreamId,
+  );
+  const isSelected = useHomeUiStore(
+    (s) => s.selectedWorkstreamId === workstream.id,
+  );
+
+  const meta: MetaItem[] = [];
+  if (workstream.repoName) {
+    meta.push({
+      key: "repo",
+      node: <span className="text-(--gray-11)">{workstream.repoName}</span>,
+    });
+  }
+  if (workstream.branch) {
+    meta.push({
+      key: "branch",
+      node: (
+        <span className="inline-flex min-w-0 items-center gap-1">
+          <GitBranch size={11} className="shrink-0" />
+          <span className="max-w-[200px] truncate" title={workstream.branch}>
+            {workstream.branch}
+          </span>
+        </span>
+      ),
+    });
+  }
+  if (pr) {
+    meta.push({ key: "pr", node: <span>#{pr.number}</span> });
+  }
+  if (pr && pr.ciStatus !== "passing" && pr.ciStatus !== "none") {
+    meta.push({
+      key: "ci",
+      node: <CiIndicator status={pr.ciStatus} showLabel />,
+    });
+  }
+  if (needsPermission) {
+    meta.push({
+      key: "perm",
+      node: (
+        <span className="inline-flex items-center gap-1 text-(--amber-11)">
+          <Warning size={11} weight="fill" />
+          Awaiting permission
+        </span>
+      ),
+    });
+  }
+  if (generating) {
+    meta.push({
+      key: "gen",
+      node: (
+        <span className="inline-flex items-center gap-1 text-(--accent-11)">
+          <ChatCircle size={11} />
+          Generating
+        </span>
+      ),
+    });
+  }
+
+  return (
+    <Box
+      onClick={() => setSelectedWorkstreamId(workstream.id)}
+      onKeyDown={(e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          setSelectedWorkstreamId(workstream.id);
+        }
+      }}
+      role="button"
+      tabIndex={0}
+      aria-label={`Open ${title}`}
+      className="group relative flex cursor-pointer items-center gap-3 border-(--gray-3) border-b py-2.5 pr-3 pl-4 transition-colors hover:bg-(--gray-2)"
+      style={isSelected ? { backgroundColor: "var(--accent-a3)" } : undefined}
+    >
+      <span
+        aria-hidden
+        className="absolute top-0 bottom-0 left-0 w-[3px]"
+        style={{ backgroundColor: accent.solid }}
+      />
+
+      <StatusGlyph sid={primarySid} size={32} />
+
+      <div className="flex min-w-0 flex-1 flex-col gap-1">
+        <div className="flex min-w-0 items-center gap-2">
+          <span
+            className="truncate font-medium text-[13px] text-gray-12"
+            title={title}
+          >
+            {title}
+          </span>
+          {extraSituations.map((sid) => (
+            <SituationChip key={sid} sid={sid} />
+          ))}
+        </div>
+        <MetaList items={meta} />
+      </div>
+
+      <Flex
+        align="center"
+        className="shrink-0 gap-2.5 pl-2"
+        onClick={(e) => e.stopPropagation()}
+        onKeyDown={(e) => e.stopPropagation()}
+      >
+        {author ? <AuthorAvatar login={author} /> : null}
+        <Text className="w-[40px] shrink-0 text-right text-(--gray-9) text-[11px]">
+          {formatRelativeTimeShort(workstream.lastActivityAt)}
+        </Text>
+
+        <div className="flex items-center gap-1">
+          {primaryBound ? (
+            <Button
+              variant="primary"
+              size="sm"
+              onClick={() => runAction(primaryBound)}
+              title={`${primaryBound.situationLabel} → ${primaryBound.skillId}`}
+            >
+              <Sparkle size={12} weight="fill" />
+              {primaryBound.label}
+            </Button>
+          ) : primaryIsPr ? (
+            <Button variant="outline" size="sm" onClick={openPr}>
+              <GitPullRequest size={12} />
+              {author ? "Review PR" : "View PR"}
+            </Button>
+          ) : primaryIsTask ? (
+            <Button variant="outline" size="sm" onClick={openTask}>
+              Open task
+            </Button>
+          ) : null}
+
+          {hasMenu ? (
+            <WorkstreamOverflowMenu
+              restBound={restBound}
+              showPrInMenu={showPrInMenu}
+              showTaskInMenu={showTaskInMenu}
+              onRun={runAction}
+              onOpenPr={openPr}
+              onOpenTask={openTask}
+              size="sm"
+            />
+          ) : null}
+        </div>
+      </Flex>
+    </Box>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/SituationChip.tsx b/apps/code/src/renderer/features/home/components/SituationChip.tsx
new file mode 100644
index 0000000000..2f1034c9dc
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/SituationChip.tsx
@@ -0,0 +1,24 @@
+import type { SituationId } from "@shared/types/workflow";
+import { SITUATION_VISUAL, situationCss } from "../utils/situationDisplay";
+
+interface Props {
+  sid: SituationId;
+  /** Hide the leading glyph (e.g. when the chip sits next to a status icon). */
+  showIcon?: boolean;
+}
+
+export function SituationChip({ sid, showIcon = true }: Props) {
+  const v = SITUATION_VISUAL[sid];
+  const c = situationCss(v.color);
+  const Icon = v.Icon;
+  return (
+    <span
+      className="inline-flex shrink-0 items-center gap-1 rounded-full px-1.5 py-0.5 font-medium text-[10.5px] leading-none"
+      style={{ color: c.fg, backgroundColor: c.tint }}
+      title={v.description}
+    >
+      {showIcon ? <Icon size={10} weight="fill" /> : null}
+      {v.label}
+    </span>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/components/WorkstreamBits.tsx b/apps/code/src/renderer/features/home/components/WorkstreamBits.tsx
new file mode 100644
index 0000000000..0b7fbb667f
--- /dev/null
+++ b/apps/code/src/renderer/features/home/components/WorkstreamBits.tsx
@@ -0,0 +1,217 @@
+import {
+  ArrowSquareOut,
+  CheckCircle,
+  CircleNotch,
+  DotsThree,
+  GitPullRequest,
+  Sparkle,
+  XCircle,
+} from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { DropdownMenu, Text } from "@radix-ui/themes";
+import type { PrCiStatus } from "@shared/types/pr-snapshot";
+import type { SituationId } from "@shared/types/workflow";
+import { Fragment } from "react";
+import type { BoundAction } from "../hooks/useBoundActions";
+import { SITUATION_VISUAL, situationCss } from "../utils/situationDisplay";
+
+/** The tinted square status tile that leads every row / card, glyphed by primary situation. */
+export function StatusGlyph({
+  sid,
+  size = 30,
+}: {
+  sid: SituationId;
+  size?: number;
+}) {
+  const v = SITUATION_VISUAL[sid];
+  const c = situationCss(v.color);
+  const Icon = v.Icon;
+  return (
+    <span
+      className="flex shrink-0 items-center justify-center rounded-[7px]"
+      style={{
+        width: size,
+        height: size,
+        backgroundColor: c.tint,
+        color: c.fg,
+      }}
+      title={`${v.label} — ${v.description}`}
+    >
+      <Icon size={Math.round(size * 0.52)} weight="bold" />
+    </span>
+  );
+}
+
+export function StatusDot({ sid }: { sid: SituationId }) {
+  const c = situationCss(SITUATION_VISUAL[sid].color);
+  return (
+    <span
+      className="inline-block h-2 w-2 shrink-0 rounded-full"
+      style={{ backgroundColor: c.solid }}
+    />
+  );
+}
+
+/** Compact CI signal — icon-only by default, optional inline label. */
+export function CiIndicator({
+  status,
+  showLabel = false,
+}: {
+  status: PrCiStatus;
+  showLabel?: boolean;
+}) {
+  if (status === "none") return null;
+  if (status === "passing") {
+    return (
+      <span
+        className="inline-flex items-center gap-1 text-(--green-11)"
+        title="CI passing"
+      >
+        <CheckCircle size={13} weight="fill" />
+        {showLabel ? <span className="text-[11px]">CI passing</span> : null}
+      </span>
+    );
+  }
+  if (status === "failing") {
+    return (
+      <span
+        className="inline-flex items-center gap-1 text-(--red-11)"
+        title="CI failing"
+      >
+        <XCircle size={13} weight="fill" />
+        {showLabel ? <span className="text-[11px]">CI failing</span> : null}
+      </span>
+    );
+  }
+  return (
+    <span
+      className="inline-flex items-center gap-1 text-(--amber-11)"
+      title="CI running"
+    >
+      <CircleNotch size={13} weight="bold" className="animate-spin" />
+      {showLabel ? <span className="text-[11px]">CI running</span> : null}
+    </span>
+  );
+}
+
+/**
+ * GitHub avatar for a PR author. Same `github.com/<login>.png` source +
+ * `.github-avatar` placeholder as the inbox; hides itself if it can't load.
+ */
+export function AuthorAvatar({
+  login,
+  size = 18,
+}: {
+  login: string | null;
+  size?: number;
+}) {
+  if (!login) return null;
+  return (
+    <img
+      src={`https://github.com/${login}.png?size=${size * 2}`}
+      alt={`@${login}`}
+      title={`@${login}`}
+      className="github-avatar shrink-0 rounded-full"
+      style={{ width: size, height: size }}
+      onLoad={(e) => e.currentTarget.classList.add("loaded")}
+      onError={(e) => {
+        e.currentTarget.style.display = "none";
+      }}
+    />
+  );
+}
+
+/**
+ * The "more actions" overflow shared by the row and card: non-primary bound
+ * actions, then the open-PR / open-task fallbacks.
+ */
+export function WorkstreamOverflowMenu({
+  restBound,
+  showPrInMenu,
+  showTaskInMenu,
+  onRun,
+  onOpenPr,
+  onOpenTask,
+  size = "sm",
+}: {
+  restBound: BoundAction[];
+  showPrInMenu: boolean;
+  showTaskInMenu: boolean;
+  onRun: (action: BoundAction) => void;
+  onOpenPr: () => void;
+  onOpenTask: () => void;
+  size?: "sm" | "xs";
+}) {
+  const sparkleSize = size === "xs" ? 11 : 12;
+  const dotsSize = size === "xs" ? 15 : 16;
+  return (
+    <DropdownMenu.Root>
+      <DropdownMenu.Trigger>
+        <Button variant="link-muted" size={size} title="More actions">
+          <DotsThree size={dotsSize} weight="bold" />
+        </Button>
+      </DropdownMenu.Trigger>
+      <DropdownMenu.Content align="end">
+        {restBound.map((action) => (
+          <DropdownMenu.Item
+            key={`${action.situationId}::${action.id}`}
+            onSelect={() => onRun(action)}
+          >
+            <Sparkle size={sparkleSize} />
+            {action.label}
+            <Text className="ml-auto pl-3 text-(--gray-10) text-[10px]">
+              {action.situationLabel}
+            </Text>
+          </DropdownMenu.Item>
+        ))}
+        {restBound.length > 0 && (showPrInMenu || showTaskInMenu) ? (
+          <DropdownMenu.Separator />
+        ) : null}
+        {showPrInMenu ? (
+          <DropdownMenu.Item onSelect={onOpenPr}>
+            <GitPullRequest size={12} />
+            Open PR in browser
+            <ArrowSquareOut size={10} className="ml-auto pl-3" />
+          </DropdownMenu.Item>
+        ) : null}
+        {showTaskInMenu ? (
+          <DropdownMenu.Item onSelect={onOpenTask}>Open task</DropdownMenu.Item>
+        ) : null}
+      </DropdownMenu.Content>
+    </DropdownMenu.Root>
+  );
+}
+
+export interface MetaItem {
+  key: string;
+  node: React.ReactNode;
+}
+
+/**
+ * A muted, dot-separated metadata line (repo · branch · #PR · …). Callers pass
+ * only the items that exist, so separators never dangle.
+ */
+export function MetaList({
+  items,
+  className,
+}: {
+  items: MetaItem[];
+  className?: string;
+}) {
+  return (
+    <div
+      className={`flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-0.5 text-(--gray-10) text-[11px] ${className ?? ""}`}
+    >
+      {items.map((item, i) => (
+        <Fragment key={item.key}>
+          {i > 0 ? (
+            <span aria-hidden className="text-(--gray-6)">
+              ·
+            </span>
+          ) : null}
+          {item.node}
+        </Fragment>
+      ))}
+    </div>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/config/ActionEditorPanel.tsx b/apps/code/src/renderer/features/home/config/ActionEditorPanel.tsx
new file mode 100644
index 0000000000..90f4dcbe45
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/ActionEditorPanel.tsx
@@ -0,0 +1,206 @@
+import { useSkillsForPicker } from "@features/home/hooks/useSkillsForPicker";
+import { useWorkflowEditorStore } from "@features/home/stores/workflowEditorStore";
+import { UnifiedModelSelector } from "@features/sessions/components/UnifiedModelSelector";
+import { useSettingsStore } from "@features/settings/stores/settingsStore";
+import { usePreviewConfig } from "@features/task-detail/hooks/usePreviewConfig";
+import { ArrowDown, ArrowUp, Trash, X } from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Card, Flex, Text, TextArea, TextField } from "@radix-ui/themes";
+import {
+  SITUATIONS,
+  type SituationId,
+  type WorkflowAction,
+} from "@shared/types/workflow";
+import { useMemo } from "react";
+import { SITUATION_TONE } from "./workflowMapLayout";
+
+interface Props {
+  situationId: SituationId;
+  action: WorkflowAction;
+  totalInSituation: number;
+  indexInSituation: number;
+}
+
+export function ActionEditorPanel({
+  situationId,
+  action,
+  totalInSituation,
+  indexInSituation,
+}: Props) {
+  const updateAction = useWorkflowEditorStore((s) => s.updateAction);
+  const removeAction = useWorkflowEditorStore((s) => s.removeAction);
+  const moveAction = useWorkflowEditorStore((s) => s.moveAction);
+  const selectSituation = useWorkflowEditorStore((s) => s.selectSituation);
+
+  const { skills, isLoading } = useSkillsForPicker();
+  const selectedSkill = skills.find((s) => s.name === action.skillId) ?? null;
+
+  const lastUsedAdapter = useSettingsStore((s) => s.lastUsedAdapter);
+  const adapterForModel = action.adapter ?? lastUsedAdapter;
+  const { modelOption, isLoading: modelLoading } =
+    usePreviewConfig(adapterForModel);
+  // Show the action's pinned model in the picker, else the adapter's default.
+  const effectiveModelOption = useMemo(() => {
+    if (!modelOption || modelOption.type !== "select" || !action.model) {
+      return modelOption;
+    }
+    return { ...modelOption, currentValue: action.model };
+  }, [modelOption, action.model]);
+
+  const meta = SITUATIONS.find((s) => s.id === situationId);
+  const tone = SITUATION_TONE[situationId];
+
+  function patch(p: Partial<WorkflowAction>) {
+    updateAction(situationId, action.id, p);
+  }
+
+  function handleRemove() {
+    removeAction(situationId, action.id);
+    // Fall back to the situation overview so the user keeps context.
+    selectSituation(situationId);
+  }
+
+  return (
+    <Flex direction="column" className="h-full min-h-0">
+      <Flex
+        align="center"
+        justify="between"
+        gap="2"
+        className={`border-(--gray-4) border-b px-4 py-2.5 ${tone.bg}`}
+      >
+        <Flex direction="column" gap="0">
+          <Text
+            className={`font-semibold text-[10px] uppercase tracking-wider ${tone.label}`}
+          >
+            {meta?.label}
+          </Text>
+          <Text className="text-[11px] text-gray-11">Edit action</Text>
+        </Flex>
+        <Button
+          size="xs"
+          variant="link-muted"
+          onClick={() => selectSituation(situationId)}
+          title="Back to situation"
+        >
+          <X size={12} />
+        </Button>
+      </Flex>
+
+      <div className="flex-1 overflow-y-auto px-4 py-3">
+        <Card variant="surface" className="flex flex-col gap-3 p-3">
+          <Field label="Button label">
+            <TextField.Root
+              size="2"
+              value={action.label}
+              autoFocus
+              placeholder="What the button on the row says"
+              onChange={(e) => patch({ label: e.target.value })}
+            />
+          </Field>
+
+          <Field label="Skill">
+            <select
+              value={action.skillId}
+              onChange={(e) => patch({ skillId: e.target.value })}
+              className="rounded-md border border-(--gray-6) bg-(--gray-1) px-2 py-1.5 text-[12px] text-gray-12"
+            >
+              <option value="">
+                {isLoading ? "Loading…" : "Pick a skill"}
+              </option>
+              {skills.map((s) => (
+                <option key={s.name} value={s.name}>
+                  {s.name}
+                </option>
+              ))}
+            </select>
+            {selectedSkill ? (
+              <Text className="mt-1 text-[10px] text-gray-10">
+                {selectedSkill.description}
+              </Text>
+            ) : null}
+          </Field>
+
+          <Field label="Prompt">
+            <TextArea
+              size="2"
+              value={action.prompt}
+              placeholder="Prompt to send to the agent. It already has access to the current branch, PR, and repo."
+              rows={6}
+              onChange={(e) => patch({ prompt: e.target.value })}
+            />
+          </Field>
+
+          <Field label="Model">
+            <div className="self-start">
+              <UnifiedModelSelector
+                modelOption={effectiveModelOption}
+                adapter={adapterForModel}
+                onAdapterChange={(a) => patch({ adapter: a, model: undefined })}
+                onModelChange={(m) =>
+                  patch({ model: m, adapter: adapterForModel })
+                }
+                isConnecting={modelLoading}
+              />
+            </div>
+            {action.model ? null : (
+              <Text className="mt-1 text-[10px] text-gray-10">
+                Runs on your default model unless you pick one.
+              </Text>
+            )}
+          </Field>
+        </Card>
+
+        <Flex justify="between" align="center" className="mt-3">
+          <Flex gap="1">
+            <Button
+              size="xs"
+              variant="link-muted"
+              onClick={() => moveAction(situationId, action.id, "up")}
+              disabled={indexInSituation === 0}
+              title="Move up (button order on row)"
+            >
+              <ArrowUp size={11} />
+            </Button>
+            <Button
+              size="xs"
+              variant="link-muted"
+              onClick={() => moveAction(situationId, action.id, "down")}
+              disabled={indexInSituation === totalInSituation - 1}
+              title="Move down"
+            >
+              <ArrowDown size={11} />
+            </Button>
+            <Text className="ml-1 self-center text-[10px] text-gray-10">
+              {indexInSituation + 1} of {totalInSituation}
+            </Text>
+          </Flex>
+          <Button
+            size="xs"
+            variant="link-muted"
+            onClick={handleRemove}
+            title="Delete action"
+          >
+            <Trash size={11} />
+            Delete
+          </Button>
+        </Flex>
+      </div>
+    </Flex>
+  );
+}
+
+interface FieldProps {
+  label: string;
+  children: React.ReactNode;
+}
+
+function Field({ label, children }: FieldProps) {
+  return (
+    <div className="flex flex-col gap-1">
+      <Text className="text-[10px] text-gray-11 uppercase tracking-wider">
+        {label}
+      </Text>
+      {children}
+    </div>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/config/ConfigMap.tsx b/apps/code/src/renderer/features/home/config/ConfigMap.tsx
new file mode 100644
index 0000000000..c0d9f2a9cb
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/ConfigMap.tsx
@@ -0,0 +1,326 @@
+import { useWorkflow } from "@features/home/hooks/useWorkflow";
+import { useWorkflowEditorStore } from "@features/home/stores/workflowEditorStore";
+import { useConnectivity } from "@hooks/useConnectivity";
+import {
+  ArrowCounterClockwise,
+  CloudSlash,
+  FloppyDisk,
+  Warning,
+} from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Box, Flex, Text } from "@radix-ui/themes";
+import { useTRPC } from "@renderer/trpc";
+import { SITUATIONS } from "@shared/types/workflow";
+import { validateWorkflow } from "@shared/types/workflow-validate";
+import { useMutation } from "@tanstack/react-query";
+import { toast } from "@utils/toast";
+import { useCallback, useEffect } from "react";
+import { ActionEditorPanel } from "./ActionEditorPanel";
+import { SituationOverviewPanel } from "./SituationOverviewPanel";
+import { SituationStation } from "./SituationStation";
+import { WorkflowMapArrows } from "./WorkflowMapArrows";
+import { MAP_HEIGHT, MAP_WIDTH } from "./workflowMapLayout";
+
+export function ConfigMap() {
+  const trpc = useTRPC();
+  const { workflow, isLoading, error, refetch } = useWorkflow();
+  const { isOnline, isChecking, check } = useConnectivity();
+  const draft = useWorkflowEditorStore((s) => s.draft);
+  const dirty = useWorkflowEditorStore((s) => s.dirty);
+  const diagnostics = useWorkflowEditorStore((s) => s.diagnostics);
+  const selection = useWorkflowEditorStore((s) => s.selection);
+  const beginEdit = useWorkflowEditorStore((s) => s.beginEdit);
+  const setDiagnostics = useWorkflowEditorStore((s) => s.setDiagnostics);
+  const clearSelection = useWorkflowEditorStore((s) => s.clearSelection);
+
+  useEffect(() => {
+    if (!workflow) return;
+    if (!draft || (draft.version !== workflow.version && !dirty)) {
+      beginEdit(workflow);
+    }
+  }, [workflow, draft, dirty, beginEdit]);
+
+  const saveMutation = useMutation(trpc.workflow.save.mutationOptions());
+  const resetMutation = useMutation(
+    trpc.workflow.resetToDefault.mutationOptions(),
+  );
+
+  useEffect(() => {
+    if (!draft) return;
+    setDiagnostics(validateWorkflow(draft).diagnostics);
+  }, [draft, setDiagnostics]);
+
+  const onSave = useCallback(async () => {
+    if (!draft) return;
+    try {
+      const result = await saveMutation.mutateAsync({
+        config: draft,
+        expectedVersion: draft.version,
+      });
+      if (result.status === "saved") {
+        toast.success("Workflow saved");
+        beginEdit(result.config);
+        return;
+      }
+      if (result.status === "conflict") {
+        toast.error("Workflow changed elsewhere", {
+          description:
+            "Another window saved a newer version. Reload to pick it up.",
+        });
+        return;
+      }
+      if (result.status === "invalid") {
+        toast.error("Can't save — fix the errors below");
+        setDiagnostics(result.diagnostics ?? []);
+      }
+    } catch (error) {
+      toast.error("Failed to save workflow", {
+        description:
+          error instanceof Error
+            ? error.message
+            : "Check your connection and try again.",
+      });
+    }
+  }, [draft, saveMutation, beginEdit, setDiagnostics]);
+
+  const onReset = useCallback(async () => {
+    try {
+      const fresh = await resetMutation.mutateAsync();
+      beginEdit(fresh);
+      toast.success("Reset to default workflow");
+    } catch (error) {
+      toast.error("Failed to reset workflow", {
+        description:
+          error instanceof Error
+            ? error.message
+            : "Check your connection and try again.",
+      });
+    }
+  }, [resetMutation, beginEdit]);
+
+  useEffect(() => {
+    function onKey(e: KeyboardEvent) {
+      const mod = e.metaKey || e.ctrlKey;
+      if (mod && e.key === "s") {
+        e.preventDefault();
+        if (dirty && !saveMutation.isPending) void onSave();
+      }
+      if (e.key === "Escape") {
+        clearSelection();
+      }
+    }
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [dirty, saveMutation.isPending, onSave, clearSelection]);
+
+  if (error) {
+    const offline = !isOnline;
+    return (
+      <Flex
+        align="center"
+        justify="center"
+        direction="column"
+        gap="2"
+        className="h-full p-6 text-center"
+      >
+        {offline ? (
+          <CloudSlash size={24} className="text-gray-9" />
+        ) : (
+          <Warning size={24} className="text-(--red-9)" />
+        )}
+        <Text className="font-medium text-[13px] text-gray-12">
+          {offline ? "You're offline" : "Couldn't load workflow"}
+        </Text>
+        <Text className="max-w-[300px] text-[11px] text-gray-10">
+          {offline
+            ? "Your workflow lives on PostHog. Reconnect to view and edit it."
+            : error.message}
+        </Text>
+        <Button
+          size="xs"
+          variant="primary"
+          disabled={isChecking}
+          onClick={() => {
+            void check();
+            void refetch();
+          }}
+        >
+          Retry
+        </Button>
+      </Flex>
+    );
+  }
+
+  if (isLoading || !workflow || !draft) {
+    return (
+      <Flex
+        align="center"
+        justify="center"
+        className="h-full text-[12px] text-gray-10"
+      >
+        Loading workflow…
+      </Flex>
+    );
+  }
+
+  const errors = diagnostics.filter((d) => d.severity === "error");
+
+  let panel: React.ReactNode = null;
+  if (selection?.kind === "action") {
+    const actionsForSituation = draft.bindings[selection.situationId] ?? [];
+    const actionIndex = actionsForSituation.findIndex(
+      (a) => a.id === selection.actionId,
+    );
+    const action = actionsForSituation[actionIndex];
+    if (action) {
+      panel = (
+        <ActionEditorPanel
+          situationId={selection.situationId}
+          action={action}
+          indexInSituation={actionIndex}
+          totalInSituation={actionsForSituation.length}
+        />
+      );
+    }
+  } else if (selection?.kind === "situation") {
+    panel = (
+      <SituationOverviewPanel
+        situationId={selection.situationId}
+        actions={draft.bindings[selection.situationId] ?? []}
+      />
+    );
+  }
+
+  const actionCount = Object.values(draft.bindings).reduce(
+    (sum, list) => sum + list.length,
+    0,
+  );
+
+  return (
+    <Flex direction="column" className="h-full min-h-0">
+      <Box className="border-(--gray-4) border-b bg-(--gray-1) px-5 py-3">
+        <Flex align="center" justify="between" gap="3">
+          <Flex direction="column" gap="1">
+            <Text className="font-medium text-[12px] text-gray-12">
+              Workflow map
+            </Text>
+            <Text className="text-[11px] text-gray-10">
+              v{workflow.version} · {actionCount} action
+              {actionCount === 1 ? "" : "s"} bound
+              {dirty ? " · unsaved changes" : ""}
+            </Text>
+          </Flex>
+          <Flex align="center" gap="2">
+            <Button
+              size="xs"
+              variant="link-muted"
+              onClick={onReset}
+              disabled={resetMutation.isPending}
+            >
+              <ArrowCounterClockwise size={12} />
+              Reset to default
+            </Button>
+            <Button
+              size="xs"
+              variant="link-muted"
+              onClick={() => beginEdit(workflow)}
+              disabled={!dirty}
+            >
+              Discard
+            </Button>
+            <Button
+              size="xs"
+              variant="primary"
+              onClick={onSave}
+              disabled={!dirty || saveMutation.isPending || errors.length > 0}
+            >
+              <FloppyDisk size={12} />
+              {saveMutation.isPending ? "Saving…" : "Save"}
+            </Button>
+          </Flex>
+        </Flex>
+      </Box>
+
+      {errors.length > 0 ? (
+        <Box className="flex items-start gap-2 border-(--red-6) border-b bg-(--red-2) px-5 py-2 text-(--red-11) text-[12px]">
+          <Warning size={14} className="mt-0.5 shrink-0" />
+          <div className="flex flex-col gap-0.5">
+            <Text className="font-medium">
+              {errors.length} error{errors.length === 1 ? "" : "s"} — fix before
+              saving
+            </Text>
+            <ul className="ml-1 list-disc pl-3">
+              {errors.slice(0, 5).map((d, idx) => (
+                <li
+                  key={`${d.code}-${d.situationId ?? d.actionId ?? idx}`}
+                  className="text-[11px]"
+                >
+                  {d.message}
+                </li>
+              ))}
+              {errors.length > 5 ? (
+                <li className="text-[11px] opacity-70">
+                  …and {errors.length - 5} more
+                </li>
+              ) : null}
+            </ul>
+          </div>
+        </Box>
+      ) : null}
+
+      <Flex className="min-h-0 flex-1">
+        <Box className="relative min-w-0 flex-1 overflow-auto bg-(--gray-2)">
+          {/* Outer wrapper carries the dot-grid background so it scrolls
+              with the map content rather than getting clipped to the
+              viewport on narrow displays. */}
+          <div
+            className="relative mx-auto"
+            style={{
+              width: MAP_WIDTH + 80,
+              height: MAP_HEIGHT + 80,
+            }}
+          >
+            <MapBackground />
+            <div
+              className="absolute"
+              style={{
+                left: 40,
+                top: 40,
+                width: MAP_WIDTH,
+                height: MAP_HEIGHT,
+              }}
+            >
+              <WorkflowMapArrows />
+              {SITUATIONS.map((situation) => (
+                <SituationStation
+                  key={situation.id}
+                  id={situation.id}
+                  bindings={draft.bindings}
+                />
+              ))}
+            </div>
+          </div>
+        </Box>
+        {panel ? (
+          <Box className="w-[360px] shrink-0 border-(--gray-4) border-l bg-(--color-panel-solid)">
+            {panel}
+          </Box>
+        ) : null}
+      </Flex>
+    </Flex>
+  );
+}
+
+function MapBackground() {
+  return (
+    <div
+      className="pointer-events-none absolute inset-0"
+      aria-hidden="true"
+      style={{
+        backgroundImage:
+          "radial-gradient(circle, var(--gray-a4) 1px, transparent 1px)",
+        backgroundSize: "20px 20px",
+      }}
+    />
+  );
+}
diff --git a/apps/code/src/renderer/features/home/config/SituationOverviewPanel.tsx b/apps/code/src/renderer/features/home/config/SituationOverviewPanel.tsx
new file mode 100644
index 0000000000..d463f3575c
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/SituationOverviewPanel.tsx
@@ -0,0 +1,144 @@
+import { useWorkflowEditorStore } from "@features/home/stores/workflowEditorStore";
+import { Plus, Sparkle, Trash, X } from "@phosphor-icons/react";
+import { Button } from "@posthog/quill";
+import { Flex, Text } from "@radix-ui/themes";
+import {
+  SITUATIONS,
+  type SituationId,
+  type WorkflowAction,
+} from "@shared/types/workflow";
+import { createDefaultAction } from "./freshActionId";
+import { SITUATION_TONE } from "./workflowMapLayout";
+
+interface Props {
+  situationId: SituationId;
+  actions: WorkflowAction[];
+}
+
+export function SituationOverviewPanel({ situationId, actions }: Props) {
+  const addAction = useWorkflowEditorStore((s) => s.addAction);
+  const removeAction = useWorkflowEditorStore((s) => s.removeAction);
+  const selectAction = useWorkflowEditorStore((s) => s.selectAction);
+  const clearSelection = useWorkflowEditorStore((s) => s.clearSelection);
+
+  const meta = SITUATIONS.find((s) => s.id === situationId);
+  const tone = SITUATION_TONE[situationId];
+
+  function handleAdd() {
+    const action = createDefaultAction(actions.map((a) => a.id));
+    addAction(situationId, action);
+    selectAction({
+      kind: "action",
+      situationId,
+      actionId: action.id,
+    });
+  }
+
+  return (
+    <Flex direction="column" className="h-full min-h-0">
+      <Flex
+        align="center"
+        justify="between"
+        gap="2"
+        className={`border-(--gray-4) border-b px-4 py-2.5 ${tone.bg}`}
+      >
+        <Flex direction="column" gap="0">
+          <Text
+            className={`font-semibold text-[10px] uppercase tracking-wider ${tone.label}`}
+          >
+            {meta?.label}
+          </Text>
+          <Text className="text-[11px] text-gray-11">
+            {actions.length} action{actions.length === 1 ? "" : "s"} bound
+          </Text>
+        </Flex>
+        <Button
+          size="xs"
+          variant="link-muted"
+          onClick={() => clearSelection()}
+          title="Close"
+        >
+          <X size={12} />
+        </Button>
+      </Flex>
+
+      <div className="flex-1 overflow-y-auto px-4 py-3">
+        <Text className="text-[11px] text-gray-11">{meta?.description}</Text>
+        <Text className="mt-2 block font-mono text-[10px] text-gray-9">
+          {situationId}
+        </Text>
+
+        <Flex direction="column" gap="2" className="mt-4">
+          {actions.length === 0 ? (
+            <Text className="text-[11px] text-gray-10">
+              Nothing bound yet. Add a skill to surface a quick-action button on
+              the workstream row when work lands here.
+            </Text>
+          ) : (
+            actions.map((action) => {
+              const incomplete = action.prompt.trim() === "";
+              return (
+                <Flex
+                  key={action.id}
+                  align="center"
+                  justify="between"
+                  gap="2"
+                  className={`rounded-md border bg-(--gray-1) px-2.5 py-2 ${
+                    incomplete
+                      ? "border-(--amber-7)"
+                      : "border-(--gray-5) hover:border-(--gray-7)"
+                  }`}
+                >
+                  <button
+                    type="button"
+                    onClick={() =>
+                      selectAction({
+                        kind: "action",
+                        situationId,
+                        actionId: action.id,
+                      })
+                    }
+                    className="flex min-w-0 flex-1 items-center gap-2 text-left"
+                  >
+                    <Sparkle
+                      size={11}
+                      className={
+                        incomplete ? "text-(--amber-11)" : "text-(--accent-11)"
+                      }
+                    />
+                    <div className="min-w-0 flex-1">
+                      <Text className="truncate font-medium text-[12px] text-gray-12">
+                        {action.label || "(no label)"}
+                      </Text>
+                      <Text className="block truncate text-[10px] text-gray-10">
+                        {action.skillId || "(no skill)"}
+                      </Text>
+                    </div>
+                  </button>
+                  <Button
+                    size="xs"
+                    variant="link-muted"
+                    onClick={() => removeAction(situationId, action.id)}
+                    title="Remove"
+                  >
+                    <Trash size={11} />
+                  </Button>
+                </Flex>
+              );
+            })
+          )}
+        </Flex>
+
+        <Button
+          size="xs"
+          variant="outline"
+          onClick={handleAdd}
+          className="mt-3 w-full"
+        >
+          <Plus size={11} />
+          Add action
+        </Button>
+      </div>
+    </Flex>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/config/SituationStation.tsx b/apps/code/src/renderer/features/home/config/SituationStation.tsx
new file mode 100644
index 0000000000..ac4f47759a
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/SituationStation.tsx
@@ -0,0 +1,131 @@
+import { useWorkflowEditorStore } from "@features/home/stores/workflowEditorStore";
+import { Plus, Sparkle } from "@phosphor-icons/react";
+import { Text } from "@radix-ui/themes";
+import {
+  SITUATIONS,
+  type SituationId,
+  type WorkflowBindings,
+} from "@shared/types/workflow";
+import { createDefaultAction } from "./freshActionId";
+import { SITUATION_TONE, STATION_LAYOUT } from "./workflowMapLayout";
+
+interface Props {
+  id: SituationId;
+  bindings: WorkflowBindings;
+}
+
+export function SituationStation({ id, bindings }: Props) {
+  const layout = STATION_LAYOUT[id];
+  const tone = SITUATION_TONE[id];
+  const meta = SITUATIONS.find((s) => s.id === id);
+  const actions = bindings?.[id] ?? [];
+
+  const selectAction = useWorkflowEditorStore((s) => s.selectAction);
+  const selectSituation = useWorkflowEditorStore((s) => s.selectSituation);
+  const addAction = useWorkflowEditorStore((s) => s.addAction);
+  const selection = useWorkflowEditorStore((s) => s.selection);
+
+  const isStationSelected =
+    selection?.kind === "situation" && selection.situationId === id;
+  const isHostingSelectedAction =
+    selection?.kind === "action" && selection.situationId === id;
+
+  function handleAdd(e: React.MouseEvent) {
+    e.stopPropagation();
+    const newAction = createDefaultAction(actions.map((a) => a.id));
+    addAction(id, newAction);
+    selectAction({
+      kind: "action",
+      situationId: id,
+      actionId: newAction.id,
+    });
+  }
+
+  function handleChip(e: React.MouseEvent, actionId: string) {
+    e.stopPropagation();
+    selectAction({
+      kind: "action",
+      situationId: id,
+      actionId,
+    });
+  }
+
+  function handleStation() {
+    selectSituation(id);
+  }
+
+  return (
+    <button
+      type="button"
+      onClick={handleStation}
+      className={`absolute rounded-lg border ${tone.accent} ${tone.bg} cursor-pointer px-3 py-2.5 text-left shadow-md transition-shadow hover:shadow-lg ${
+        isStationSelected || isHostingSelectedAction
+          ? "ring-(--accent-9) ring-2 ring-offset-(--gray-2) ring-offset-1"
+          : ""
+      }`}
+      style={{
+        left: layout.x,
+        top: layout.y,
+        width: layout.w,
+        height: layout.h,
+      }}
+      aria-label={`${meta?.label ?? id} — ${actions.length} action${actions.length === 1 ? "" : "s"}`}
+    >
+      <div className="flex items-baseline justify-between gap-2">
+        <Text
+          className={`font-semibold text-[11px] uppercase tracking-wider ${tone.label}`}
+        >
+          {meta?.label ?? id}
+        </Text>
+        <Text className="font-mono text-[9px] text-gray-9">{id}</Text>
+      </div>
+      <Text
+        className="mt-0.5 line-clamp-1 text-[10px] text-gray-10"
+        title={meta?.description}
+      >
+        {meta?.description}
+      </Text>
+
+      <div className="mt-2 flex flex-wrap items-center gap-1">
+        {actions.map((action) => {
+          const isChipSelected =
+            selection?.kind === "action" &&
+            selection.situationId === id &&
+            selection.actionId === action.id;
+          const incomplete = action.prompt.trim() === "";
+          return (
+            <button
+              type="button"
+              key={action.id}
+              onClick={(e) => handleChip(e, action.id)}
+              className={`flex max-w-[150px] items-center gap-1 rounded-full border px-2 py-0.5 text-[11px] transition-colors ${
+                isChipSelected
+                  ? "border-(--accent-9) bg-(--accent-3) text-(--accent-12)"
+                  : incomplete
+                    ? "border-(--amber-8) bg-(--amber-4) text-(--amber-11)"
+                    : "border-(--gray-7) bg-(--color-panel-solid) text-gray-12 hover:border-(--gray-9)"
+              }`}
+              title={
+                action.skillId
+                  ? `${action.label} · ${action.skillId}`
+                  : action.label
+              }
+            >
+              <Sparkle size={9} />
+              <span className="truncate">{action.label || "(no label)"}</span>
+            </button>
+          );
+        })}
+        <button
+          type="button"
+          onClick={handleAdd}
+          className="flex items-center gap-1 rounded-full border border-(--gray-8) border-dashed bg-transparent px-2 py-0.5 text-[11px] text-gray-11 transition-colors hover:border-(--gray-10) hover:bg-(--color-panel-solid) hover:text-gray-12"
+          title="Bind a skill to this situation"
+        >
+          <Plus size={9} />
+          Add
+        </button>
+      </div>
+    </button>
+  );
+}
diff --git a/apps/code/src/renderer/features/home/config/WorkflowMapArrows.tsx b/apps/code/src/renderer/features/home/config/WorkflowMapArrows.tsx
new file mode 100644
index 0000000000..a72bd81a81
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/WorkflowMapArrows.tsx
@@ -0,0 +1,104 @@
+import {
+  FLOW_ARROWS,
+  MAP_HEIGHT,
+  MAP_WIDTH,
+  STATION_LAYOUT,
+  stationCentre,
+} from "./workflowMapLayout";
+
+// Decorative flow arrows between stations — not runtime edges (see
+// `FLOW_ARROWS` in workflowMapLayout.ts).
+export function WorkflowMapArrows() {
+  return (
+    <svg
+      width={MAP_WIDTH}
+      height={MAP_HEIGHT}
+      viewBox={`0 0 ${MAP_WIDTH} ${MAP_HEIGHT}`}
+      className="pointer-events-none absolute inset-0"
+      aria-hidden="true"
+    >
+      <defs>
+        <marker
+          id="wf-arrowhead"
+          viewBox="0 0 10 10"
+          refX="8"
+          refY="5"
+          markerWidth="6"
+          markerHeight="6"
+          orient="auto-start-reverse"
+        >
+          <path d="M0,0 L10,5 L0,10 z" className="fill-(--gray-9)" />
+        </marker>
+        <marker
+          id="wf-arrowhead-dim"
+          viewBox="0 0 10 10"
+          refX="8"
+          refY="5"
+          markerWidth="6"
+          markerHeight="6"
+          orient="auto-start-reverse"
+        >
+          <path d="M0,0 L10,5 L0,10 z" className="fill-(--gray-8)" />
+        </marker>
+      </defs>
+
+      {FLOW_ARROWS.map((arrow) => {
+        const a = STATION_LAYOUT[arrow.from];
+        const b = STATION_LAYOUT[arrow.to];
+        const ca = stationCentre(a);
+        const cb = stationCentre(b);
+
+        // Start/end on the rectangle edges along the direction of travel, so
+        // the line doesn't run under the station card.
+        const start = edgePoint(a, cb);
+        const end = edgePoint(b, ca);
+
+        // Slight curve via a quadratic Bézier — control point offset perpendicular from the midpoint.
+        const mx = (start.x + end.x) / 2;
+        const my = (start.y + end.y) / 2;
+        const dx = end.x - start.x;
+        const dy = end.y - start.y;
+        const len = Math.max(1, Math.hypot(dx, dy));
+        const perp = { x: -dy / len, y: dx / len };
+        const curveAmount = arrow.kind === "branch" ? 28 : 12;
+        const cx = mx + perp.x * curveAmount;
+        const cy = my + perp.y * curveAmount;
+
+        const path = `M ${start.x},${start.y} Q ${cx},${cy} ${end.x},${end.y}`;
+        const dim = arrow.kind === "branch";
+
+        return (
+          <path
+            key={`${arrow.from}->${arrow.to}`}
+            d={path}
+            fill="none"
+            strokeWidth={dim ? 1 : 1.5}
+            strokeDasharray={dim ? "4 4" : "none"}
+            className={dim ? "stroke-(--gray-8)" : "stroke-(--gray-9)"}
+            markerEnd={`url(#wf-arrowhead${dim ? "-dim" : ""})`}
+          />
+        );
+      })}
+    </svg>
+  );
+}
+
+// Returns the point on the rectangle's perimeter closest to a target,
+// clipped along the ray from the rectangle's centre toward the target.
+function edgePoint(
+  rect: { x: number; y: number; w: number; h: number },
+  target: { x: number; y: number },
+): { x: number; y: number } {
+  const cx = rect.x + rect.w / 2;
+  const cy = rect.y + rect.h / 2;
+  const dx = target.x - cx;
+  const dy = target.y - cy;
+  if (dx === 0 && dy === 0) return { x: cx, y: cy };
+
+  const halfW = rect.w / 2;
+  const halfH = rect.h / 2;
+  const tx = dx === 0 ? Number.POSITIVE_INFINITY : halfW / Math.abs(dx);
+  const ty = dy === 0 ? Number.POSITIVE_INFINITY : halfH / Math.abs(dy);
+  const t = Math.min(tx, ty);
+  return { x: cx + dx * t, y: cy + dy * t };
+}
diff --git a/apps/code/src/renderer/features/home/config/freshActionId.ts b/apps/code/src/renderer/features/home/config/freshActionId.ts
new file mode 100644
index 0000000000..83ec1bed85
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/freshActionId.ts
@@ -0,0 +1,17 @@
+import type { WorkflowAction } from "@shared/types/workflow";
+
+// Next unused `action_N` id given the ids already in a situation's binding list.
+export function freshActionId(existing: string[]): string {
+  let n = 1;
+  while (existing.includes(`action_${n}`)) n++;
+  return `action_${n}`;
+}
+
+export function createDefaultAction(existingIds: string[]): WorkflowAction {
+  return {
+    id: freshActionId(existingIds),
+    label: "Run skill",
+    skillId: "",
+    prompt: "",
+  };
+}
diff --git a/apps/code/src/renderer/features/home/config/workflowMapLayout.ts b/apps/code/src/renderer/features/home/config/workflowMapLayout.ts
new file mode 100644
index 0000000000..fe46e4af16
--- /dev/null
+++ b/apps/code/src/renderer/features/home/config/workflowMapLayout.ts
@@ -0,0 +1,98 @@
+import type { SituationId } from "@shared/types/workflow";
+
+// Fixed designer-authored canvas layout, not a user-editable graph. Numbers are
+// unitless "canvas points" the renderer scales into a responsive container.
+export const MAP_WIDTH = 1100;
+export const MAP_HEIGHT = 720;
+
+export interface StationLayout {
+  x: number; // top-left of the station card, in canvas points
+  y: number;
+  w: number;
+  h: number;
+}
+
+export const STATION_LAYOUT: Record<SituationId, StationLayout> = {
+  working: { x: 420, y: 30, w: 260, h: 110 },
+  in_review: { x: 420, y: 200, w: 260, h: 110 },
+  ci_failing: { x: 60, y: 370, w: 260, h: 110 },
+  changes_requested: { x: 420, y: 370, w: 260, h: 110 },
+  comments_waiting: { x: 780, y: 370, w: 260, h: 110 },
+  ready_to_merge: { x: 420, y: 540, w: 260, h: 110 },
+  stale: { x: 780, y: 30, w: 260, h: 110 },
+  done: { x: 780, y: 540, w: 260, h: 110 },
+};
+
+export interface FlowArrow {
+  from: SituationId;
+  to: SituationId;
+  /** Visual hint — `branch` arrows are drawn dotted to suggest "and/or". */
+  kind: "main" | "branch";
+}
+
+// Decorative hints about the typical progression of work — NOT runtime edges.
+// The system doesn't enforce or observe these transitions.
+export const FLOW_ARROWS: FlowArrow[] = [
+  { from: "working", to: "in_review", kind: "main" },
+  { from: "in_review", to: "ci_failing", kind: "branch" },
+  { from: "in_review", to: "changes_requested", kind: "branch" },
+  { from: "in_review", to: "comments_waiting", kind: "branch" },
+  { from: "ci_failing", to: "ready_to_merge", kind: "branch" },
+  { from: "changes_requested", to: "ready_to_merge", kind: "branch" },
+  { from: "comments_waiting", to: "ready_to_merge", kind: "branch" },
+  { from: "in_review", to: "ready_to_merge", kind: "main" },
+  { from: "ready_to_merge", to: "done", kind: "main" },
+];
+
+// Per-situation accent colours for the canvas station. Radix scale indices
+// (`*-3` bg, `*-8` border) read in both light and dark modes.
+export const SITUATION_TONE: Record<
+  SituationId,
+  { accent: string; bg: string; label: string }
+> = {
+  working: {
+    accent: "border-(--blue-8)",
+    bg: "bg-(--blue-3)",
+    label: "text-(--blue-11)",
+  },
+  in_review: {
+    accent: "border-(--violet-8)",
+    bg: "bg-(--violet-3)",
+    label: "text-(--violet-11)",
+  },
+  ci_failing: {
+    accent: "border-(--red-8)",
+    bg: "bg-(--red-3)",
+    label: "text-(--red-11)",
+  },
+  changes_requested: {
+    accent: "border-(--amber-8)",
+    bg: "bg-(--amber-3)",
+    label: "text-(--amber-11)",
+  },
+  comments_waiting: {
+    accent: "border-(--amber-8)",
+    bg: "bg-(--amber-3)",
+    label: "text-(--amber-11)",
+  },
+  ready_to_merge: {
+    accent: "border-(--green-8)",
+    bg: "bg-(--green-3)",
+    label: "text-(--green-11)",
+  },
+  stale: {
+    accent: "border-(--gray-8)",
+    bg: "bg-(--gray-3)",
+    label: "text-(--gray-11)",
+  },
+  done: {
+    accent: "border-(--gray-8)",
+    bg: "bg-(--gray-3)",
+    label: "text-(--gray-11)",
+  },
+};
+
+/** Centre point of a station — used to anchor arrows. */
+export function stationCentre(s: StationLayout): { x: number; y: number } {
+  return { x: s.x + s.w / 2, y: s.y + s.h / 2 };
+}
diff --git a/apps/code/src/renderer/features/home/hooks/useBoundActions.ts b/apps/code/src/renderer/features/home/hooks/useBoundActions.ts
new file mode 100644
index 0000000000..868fe19b6b
--- /dev/null
+++ b/apps/code/src/renderer/features/home/hooks/useBoundActions.ts
@@ -0,0 +1,44 @@
+import { useWorkflow } from "@features/home/hooks/useWorkflow";
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import {
+  SITUATIONS,
+  type SituationId,
+  type WorkflowAction,
+} from "@shared/types/workflow";
+import { useMemo } from "react";
+
+export interface BoundAction extends WorkflowAction {
+  /** Situation this action came from — used for telemetry + tooltips. */
+  situationId: SituationId;
+  situationLabel: string;
+}
+
+/**
+ * Joins a workstream's situations against the workflow bindings and returns the
+ * deduped actions bound to any matching situation, in situation then binding order.
+ */
+export function useBoundActions(workstream: HomeWorkstream): BoundAction[] {
+  const { workflow } = useWorkflow();
+  return useMemo(() => {
+    if (!workflow) return [];
+    const bindings = workflow.bindings;
+    const seen = new Set<string>();
+    const out: BoundAction[] = [];
+    for (const sid of workstream.situations) {
+      const actions = bindings?.[sid] ?? [];
+      const meta = SITUATIONS.find((s) => s.id === sid);
+      for (const action of actions) {
+        // Dedup the same action bound under multiple situations.
+        const dedupKey = `${action.skillId}::${action.label}`;
+        if (seen.has(dedupKey)) continue;
+        seen.add(dedupKey);
+        out.push({
+          ...action,
+          situationId: sid,
+          situationLabel: meta?.label ?? sid,
+        });
+      }
+    }
+    return out;
+  }, [workflow, workstream.situations]);
+}
diff --git a/apps/code/src/renderer/features/home/hooks/useHomeSnapshot.ts b/apps/code/src/renderer/features/home/hooks/useHomeSnapshot.ts
new file mode 100644
index 0000000000..a3307f3494
--- /dev/null
+++ b/apps/code/src/renderer/features/home/hooks/useHomeSnapshot.ts
@@ -0,0 +1,22 @@
+import { useTRPC } from "@renderer/trpc";
+import {
+  EMPTY_HOME_SNAPSHOT,
+  type HomeSnapshot,
+} from "@shared/types/home-snapshot";
+import { useQuery } from "@tanstack/react-query";
+
+// Single-query window into the server-computed Home snapshot. Grouping, PR
+// polling, and classification all run server-side (PostHog's
+// evaluate-code-workstreams worker); the subscription registrar keeps this
+// query fresh (features/home/subscriptions.ts).
+export function useHomeSnapshot(): {
+  snapshot: HomeSnapshot;
+  isLoading: boolean;
+} {
+  const trpc = useTRPC();
+  const query = useQuery(trpc.home.getSnapshot.queryOptions());
+  return {
+    snapshot: query.data ?? EMPTY_HOME_SNAPSHOT,
+    isLoading: query.isLoading,
+  };
+}
diff --git a/apps/code/src/renderer/features/home/hooks/useRunWorkstreamAction.ts b/apps/code/src/renderer/features/home/hooks/useRunWorkstreamAction.ts
new file mode 100644
index 0000000000..c11198f30d
--- /dev/null
+++ b/apps/code/src/renderer/features/home/hooks/useRunWorkstreamAction.ts
@@ -0,0 +1,177 @@
+import { useAuthStateValue } from "@features/auth/hooks/authQueries";
+import { resolveDefaultModel } from "@features/inbox/utils/resolveDefaultModel";
+import { useSettingsStore } from "@features/settings/stores/settingsStore";
+import type {
+  TaskCreationInput,
+  TaskService,
+} from "@features/task-detail/service/service";
+import { useCreateTask } from "@features/tasks/hooks/useTasks";
+import { useConnectivity } from "@hooks/useConnectivity";
+import { useUserRepositoryIntegration } from "@hooks/useIntegrations";
+import { openTask, openTaskInput } from "@hooks/useOpenTask";
+import { get } from "@renderer/di/container";
+import { RENDERER_TOKENS } from "@renderer/di/tokens";
+import { navigateToTaskPending } from "@renderer/navigationBridge";
+import { ANALYTICS_EVENTS } from "@shared/types/analytics";
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import { getCloudUrlFromRegion } from "@shared/utils/urls";
+import { pendingTaskPromptStoreApi } from "@stores/pendingTaskPromptStore";
+import { track } from "@utils/analytics";
+import { logger } from "@utils/logger";
+import { toast } from "@utils/toast";
+import { useCallback, useRef } from "react";
+import type { BoundAction } from "./useBoundActions";
+
+const log = logger.scope("home-quick-action");
+
+// The agent runs the bound skill when the prompt starts with `/<skill-id>`, so
+// embed it directly; the descriptive prompt follows as the instruction. With no
+// skill bound, send the prompt on its own.
+function buildSkillPrompt(action: BoundAction): string {
+  const body = action.prompt.trim();
+  const skillId = action.skillId.trim();
+  if (!skillId) return body;
+  const command = `/${skillId}`;
+  return body ? `${command}\n\n${body}` : command;
+}
+
+/**
+ * Runs a bound workflow action as a one-click cloud task: embeds the skill as a
+ * `/<skill-id>` prefix and starts a cloud run on the workstream's repo + branch.
+ * Falls back to the new-task screen (prompt prefilled) when it can't start
+ * cleanly — offline, signed out, or the repo has no GitHub integration.
+ */
+export function useRunWorkstreamAction() {
+  const isAuthenticated = useAuthStateValue(
+    (state) => state.status === "authenticated",
+  );
+  const cloudRegion = useAuthStateValue((state) => state.cloudRegion);
+  const { isOnline } = useConnectivity();
+  const { invalidateTasks } = useCreateTask();
+  const { getUserIntegrationIdForRepo } = useUserRepositoryIntegration();
+  const lastUsedAdapter = useSettingsStore((s) => s.lastUsedAdapter);
+  const lastUsedModel = useSettingsStore((s) => s.lastUsedModel);
+  const inFlightRef = useRef(false);
+
+  return useCallback(
+    (action: BoundAction, workstream: HomeWorkstream) => {
+      const promptText = buildSkillPrompt(action);
+      // The GitHub integration map and cloud repo selector are keyed by the full
+      // "org/repo" slug, so resolve from `repoFullPath`, not the bare `repoName`.
+      const repo = workstream.repoFullPath?.toLowerCase() ?? null;
+      const branch = workstream.branch ?? undefined;
+      const githubUserIntegrationId = repo
+        ? getUserIntegrationIdForRepo(repo)
+        : undefined;
+
+      const fallbackToTaskInput = () => {
+        openTaskInput({
+          initialPrompt: promptText,
+          initialCloudRepository: repo ?? undefined,
+        });
+      };
+
+      // One-click needs an online, authed session and a repo resolvable to a
+      // GitHub integration; anything else routes to the new-task screen.
+      const canOneClick =
+        isAuthenticated && isOnline && !!repo && !!githubUserIntegrationId;
+      if (!canOneClick) {
+        fallbackToTaskInput();
+        return;
+      }
+
+      if (inFlightRef.current) return;
+      inFlightRef.current = true;
+
+      const pendingTaskKey =
+        globalThis.crypto?.randomUUID?.() ?? `pending-${Date.now()}`;
+      pendingTaskPromptStoreApi.set(pendingTaskKey, {
+        promptText,
+        attachments: [],
+      });
+      navigateToTaskPending(pendingTaskKey);
+
+      void (async () => {
+        try {
+          // The cloud runtime requires a model: action-pinned, then last-used,
+          // then the adapter's server default.
+          const adapter = action.adapter ?? lastUsedAdapter;
+          let model = action.model ?? lastUsedModel ?? undefined;
+          if (!model && cloudRegion) {
+            model = await resolveDefaultModel(
+              getCloudUrlFromRegion(cloudRegion),
+              adapter,
+            );
+          }
+          if (!model) {
+            pendingTaskPromptStoreApi.clear(pendingTaskKey);
+            toast.error("Couldn't start task", {
+              description:
+                "No model is configured. Pick a model for this quick action.",
+            });
+            fallbackToTaskInput();
+            return;
+          }
+
+          // `content` carries the skill prefix to the agent; `taskDescription`
+          // is the clean prompt used for the task title and description.
+          const input: TaskCreationInput = {
+            content: promptText,
+            taskDescription: action.prompt.trim() || action.label,
+            repository: repo,
+            workspaceMode: "cloud",
+            branch,
+            githubUserIntegrationId,
+            adapter,
+            model,
+          };
+
+          const taskService = get<TaskService>(RENDERER_TOKENS.TaskService);
+          const result = await taskService.createTask(input, (output) => {
+            invalidateTasks(output.task);
+            pendingTaskPromptStoreApi.move(pendingTaskKey, output.task.id);
+            void openTask(output.task);
+          });
+
+          if (result.success) {
+            track(ANALYTICS_EVENTS.TASK_CREATED, {
+              auto_run: false,
+              created_from: "home-quick-action",
+              repository_provider: "github",
+              workspace_mode: "cloud",
+              has_branch: !!branch,
+              cloud_run_source: "manual",
+              adapter,
+            });
+            return;
+          }
+          pendingTaskPromptStoreApi.clear(pendingTaskKey);
+          toast.error("Failed to start task", { description: result.error });
+          log.error("Quick action task creation failed", {
+            failedStep: result.failedStep,
+            error: result.error,
+          });
+          fallbackToTaskInput();
+        } catch (error) {
+          pendingTaskPromptStoreApi.clear(pendingTaskKey);
+          const description =
+            error instanceof Error ? error.message : "Unknown error";
+          toast.error("Failed to start task", { description });
+          log.error("Quick action task creation threw", { error });
+          fallbackToTaskInput();
+        } finally {
+          inFlightRef.current = false;
+        }
+      })();
+    },
+    [
+      isAuthenticated,
+      isOnline,
+      cloudRegion,
+      invalidateTasks,
+      getUserIntegrationIdForRepo,
+      lastUsedAdapter,
+      lastUsedModel,
+    ],
+  );
+}
diff --git a/apps/code/src/renderer/features/home/hooks/useSkillsForPicker.ts b/apps/code/src/renderer/features/home/hooks/useSkillsForPicker.ts
new file mode 100644
index 0000000000..42e8ef0712
--- /dev/null
+++ b/apps/code/src/renderer/features/home/hooks/useSkillsForPicker.ts
@@ -0,0 +1,12 @@
+import { useTRPC } from "@renderer/trpc";
+import { useQuery } from "@tanstack/react-query";
+
+// Thin wrapper around the skills router for the action editor's skill dropdown.
+export function useSkillsForPicker() {
+  const trpc = useTRPC();
+  const query = useQuery(trpc.skills.list.queryOptions());
+  return {
+    skills: query.data ?? [],
+    isLoading: query.isLoading,
+  };
+}
diff --git a/apps/code/src/renderer/features/home/hooks/useWorkflow.ts b/apps/code/src/renderer/features/home/hooks/useWorkflow.ts
new file mode 100644
index 0000000000..5486940860
--- /dev/null
+++ b/apps/code/src/renderer/features/home/hooks/useWorkflow.ts
@@ -0,0 +1,15 @@
+import { useTRPC } from "@renderer/trpc";
+import { useQuery } from "@tanstack/react-query";
+
+// Single-query window into the persisted WorkflowConfig. Subscription updates
+// write back through the same query key (features/home/subscriptions.ts).
+export function useWorkflow() {
+  const trpc = useTRPC();
+  const query = useQuery(trpc.workflow.get.queryOptions());
+  return {
+    workflow: query.data ?? null,
+    isLoading: query.isLoading,
+    error: query.error,
+    refetch: query.refetch,
+  };
+}
diff --git a/apps/code/src/renderer/features/home/hooks/useWorkstreamPresentation.ts b/apps/code/src/renderer/features/home/hooks/useWorkstreamPresentation.ts
new file mode 100644
index 0000000000..ec1bf4d302
--- /dev/null
+++ b/apps/code/src/renderer/features/home/hooks/useWorkstreamPresentation.ts
@@ -0,0 +1,98 @@
+import { openTask } from "@hooks/useOpenTask";
+import { useTasks } from "@renderer/features/tasks/hooks/useTasks";
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import type { PrSnapshot } from "@shared/types/pr-snapshot";
+import type { SituationId } from "@shared/types/workflow";
+import { openUrlInBrowser } from "@utils/browser";
+import {
+  SITUATION_VISUAL,
+  type SituationCss,
+  situationCss,
+} from "../utils/situationDisplay";
+import { type BoundAction, useBoundActions } from "./useBoundActions";
+import { useRunWorkstreamAction } from "./useRunWorkstreamAction";
+
+export interface WorkstreamPresentation {
+  pr: PrSnapshot | null;
+  title: string;
+  primarySid: SituationId;
+  accent: SituationCss;
+  /** PR author login when it's someone else's PR, else null. */
+  author: string | null;
+  /** Situations to render as chips — primary + the calm `in_review` are omitted. */
+  extraSituations: SituationId[];
+  generating: boolean;
+  /** A task in this workstream is blocked awaiting a permission response. */
+  needsPermission: boolean;
+  primaryBound: BoundAction | null;
+  restBound: BoundAction[];
+  primaryIsPr: boolean;
+  primaryIsTask: boolean;
+  showPrInMenu: boolean;
+  showTaskInMenu: boolean;
+  hasMenu: boolean;
+  runAction: (action: BoundAction) => void;
+  openTask: () => void;
+  openPr: () => void;
+}
+
+/**
+ * Shared presentation + action derivation for a workstream, so the list row and
+ * board card (which differ only in layout) can't drift on what they show or do.
+ */
+export function useWorkstreamPresentation(
+  workstream: HomeWorkstream,
+): WorkstreamPresentation {
+  const { data: tasks = [] } = useTasks();
+  const boundActions = useBoundActions(workstream);
+  const run = useRunWorkstreamAction();
+
+  const pr = workstream.pr;
+  const headTask = workstream.tasks[0];
+  const title =
+    pr?.title ?? headTask?.title ?? workstream.branch ?? "Workstream";
+  const primarySid = workstream.primarySituation ?? "working";
+  const accent = situationCss(SITUATION_VISUAL[primarySid].color);
+  const author = pr?.author && !pr.isCurrentUserAuthor ? pr.author : null;
+  const extraSituations = workstream.situations.filter(
+    (s) => s !== primarySid && s !== "in_review",
+  );
+  const generating = workstream.tasks.some((t) => t.isGenerating);
+  const needsPermission = workstream.tasks.some((t) => t.needsPermission);
+
+  const primaryBound = boundActions[0] ?? null;
+  const restBound = primaryBound ? boundActions.slice(1) : [];
+
+  const primaryIsPr = !primaryBound && !!workstream.prUrl;
+  const primaryIsTask = !primaryBound && !workstream.prUrl && !!headTask;
+  const showPrInMenu = !!workstream.prUrl && !primaryIsPr;
+  const showTaskInMenu = !!headTask && !primaryIsTask;
+  const hasMenu = restBound.length > 0 || showPrInMenu || showTaskInMenu;
+
+  return {
+    pr,
+    title,
+    primarySid,
+    accent,
+    author,
+    extraSituations,
+    generating,
+    needsPermission,
+    primaryBound,
+    restBound,
+    primaryIsPr,
+    primaryIsTask,
+    showPrInMenu,
+    showTaskInMenu,
+    hasMenu,
+    runAction: (action) => run(action, workstream),
+    openTask: () => {
+      if (!headTask) return;
+      const task = tasks.find((t) => t.id === headTask.id);
+      if (task) void openTask(task);
+    },
+    openPr: () => {
+      if (workstream.prUrl) void openUrlInBrowser(workstream.prUrl);
+    },
+  };
+}
diff --git a/apps/code/src/renderer/features/home/stores/homeUiStore.ts b/apps/code/src/renderer/features/home/stores/homeUiStore.ts
new file mode 100644
index 0000000000..c72059bca2
--- /dev/null
+++ b/apps/code/src/renderer/features/home/stores/homeUiStore.ts
@@ -0,0 +1,28 @@
+import { electronStorage } from "@utils/electronStorage";
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+
+export type HomeViewMode = "list" | "board" | "config";
+
+interface HomeUiStore {
+  viewMode: HomeViewMode;
+  setViewMode: (mode: HomeViewMode) => void;
+  selectedWorkstreamId: string | null;
+  setSelectedWorkstreamId: (id: string | null) => void;
+}
+
+export const useHomeUiStore = create<HomeUiStore>()(
+  persist(
+    (set) => ({
+      viewMode: "list",
+      setViewMode: (mode) => set({ viewMode: mode }),
+      selectedWorkstreamId: null,
+      setSelectedWorkstreamId: (id) => set({ selectedWorkstreamId: id }),
+    }),
+    {
+      name: "home-ui-store",
+      storage: electronStorage,
+      partialize: (state) => ({ viewMode: state.viewMode }),
+    },
+  ),
+);
diff --git a/apps/code/src/renderer/features/home/stores/workflowEditorStore.test.ts b/apps/code/src/renderer/features/home/stores/workflowEditorStore.test.ts
new file mode 100644
index 0000000000..164974ee5b
--- /dev/null
+++ b/apps/code/src/renderer/features/home/stores/workflowEditorStore.test.ts
@@ -0,0 +1,232 @@
+import {
+  SITUATION_IDS,
+  type WorkflowAction,
+  type WorkflowBindings,
+  type WorkflowConfig,
+} from "@shared/types/workflow";
+import { beforeEach, describe, expect, it } from "vitest";
+import { useWorkflowEditorStore } from "./workflowEditorStore";
+
+function makeAction(overrides: Partial<WorkflowAction> = {}): WorkflowAction {
+  return {
+    id: "action_1",
+    label: "Review",
+    skillId: "review",
+    prompt: "Review the diff",
+    ...overrides,
+  };
+}
+
+function makeConfig(bindings: Partial<WorkflowBindings> = {}): WorkflowConfig {
+  return {
+    id: "wf_1",
+    version: 3,
+    updatedAt: "2026-01-01T00:00:00Z",
+    bindings: bindings as WorkflowBindings,
+  };
+}
+
+function resetStore() {
+  useWorkflowEditorStore.setState({
+    draft: null,
+    baselineSerialized: null,
+    dirty: false,
+    diagnostics: [],
+    selection: null,
+  });
+}
+
+const store = () => useWorkflowEditorStore.getState();
+
+describe("workflowEditorStore", () => {
+  beforeEach(() => {
+    resetStore();
+  });
+
+  describe("beginEdit", () => {
+    it("normalizes bindings so every situation key is present", () => {
+      store().beginEdit(makeConfig({ working: [makeAction()] }));
+      const { draft } = store();
+      expect(draft).not.toBeNull();
+      expect(Object.keys(draft?.bindings ?? {}).sort()).toEqual(
+        [...SITUATION_IDS].sort(),
+      );
+      expect(draft?.bindings.working).toHaveLength(1);
+      expect(draft?.bindings.in_review).toEqual([]);
+    });
+
+    it("drops updatedAt and preserves id and version", () => {
+      store().beginEdit(makeConfig());
+      const { draft } = store();
+      expect(draft?.id).toBe("wf_1");
+      expect(draft?.version).toBe(3);
+      expect("updatedAt" in (draft ?? {})).toBe(false);
+    });
+
+    it("starts clean with no dirty flag, diagnostics, or selection", () => {
+      useWorkflowEditorStore.setState({
+        dirty: true,
+        diagnostics: [
+          { severity: "error", code: "action_empty_label", message: "x" },
+        ],
+        selection: { kind: "situation", situationId: "working" },
+      });
+      store().beginEdit(makeConfig({ working: [makeAction()] }));
+      expect(store().dirty).toBe(false);
+      expect(store().diagnostics).toEqual([]);
+      expect(store().selection).toBeNull();
+    });
+  });
+
+  describe("mutations are no-ops before beginEdit", () => {
+    it("addAction does nothing while draft is null", () => {
+      store().addAction("working", makeAction());
+      expect(store().draft).toBeNull();
+    });
+  });
+
+  describe("addAction", () => {
+    it("appends to the target situation and marks dirty", () => {
+      store().beginEdit(makeConfig({ working: [makeAction({ id: "a" })] }));
+      store().addAction("working", makeAction({ id: "b" }));
+      expect(store().draft?.bindings.working.map((a) => a.id)).toEqual([
+        "a",
+        "b",
+      ]);
+      expect(store().dirty).toBe(true);
+    });
+
+    it("does not touch other situations", () => {
+      store().beginEdit(makeConfig({ in_review: [makeAction({ id: "x" })] }));
+      store().addAction("working", makeAction({ id: "y" }));
+      expect(store().draft?.bindings.in_review.map((a) => a.id)).toEqual(["x"]);
+    });
+  });
+
+  describe("updateAction", () => {
+    it("patches the matching action", () => {
+      store().beginEdit(makeConfig({ working: [makeAction({ id: "a" })] }));
+      store().updateAction("working", "a", { label: "Renamed" });
+      expect(store().draft?.bindings.working[0].label).toBe("Renamed");
+      expect(store().dirty).toBe(true);
+    });
+
+    it("is a no-op for an unknown action id", () => {
+      store().beginEdit(makeConfig({ working: [makeAction({ id: "a" })] }));
+      store().updateAction("working", "missing", { label: "Renamed" });
+      expect(store().draft?.bindings.working[0].label).toBe("Review");
+      expect(store().dirty).toBe(false);
+    });
+  });
+
+  describe("removeAction", () => {
+    it("removes only the targeted action", () => {
+      store().beginEdit(
+        makeConfig({
+          working: [makeAction({ id: "a" }), makeAction({ id: "b" })],
+        }),
+      );
+      store().removeAction("working", "a");
+      expect(store().draft?.bindings.working.map((act) => act.id)).toEqual([
+        "b",
+      ]);
+    });
+  });
+
+  describe("moveAction", () => {
+    it("does nothing when moving the first item up", () => {
+      store().beginEdit(
+        makeConfig({
+          working: [makeAction({ id: "a" }), makeAction({ id: "b" })],
+        }),
+      );
+      store().moveAction("working", "a", "up");
+      expect(store().draft?.bindings.working.map((act) => act.id)).toEqual([
+        "a",
+        "b",
+      ]);
+      expect(store().dirty).toBe(false);
+    });
+
+    it("does nothing when moving the last item down", () => {
+      store().beginEdit(
+        makeConfig({
+          working: [makeAction({ id: "a" }), makeAction({ id: "b" })],
+        }),
+      );
+      store().moveAction("working", "b", "down");
+      expect(store().draft?.bindings.working.map((act) => act.id)).toEqual([
+        "a",
+        "b",
+      ]);
+      expect(store().dirty).toBe(false);
+    });
+
+    it("swaps an adjacent pair in the middle of the list", () => {
+      store().beginEdit(
+        makeConfig({
+          working: [
+            makeAction({ id: "a" }),
+            makeAction({ id: "b" }),
+            makeAction({ id: "c" }),
+          ],
+        }),
+      );
+      store().moveAction("working", "b", "down");
+      expect(store().draft?.bindings.working.map((act) => act.id)).toEqual([
+        "a",
+        "c",
+        "b",
+      ]);
+      expect(store().dirty).toBe(true);
+    });
+
+    it("is a no-op for an unknown action id", () => {
+      store().beginEdit(makeConfig({ working: [makeAction({ id: "a" })] }));
+      store().moveAction("working", "missing", "down");
+      expect(store().dirty).toBe(false);
+    });
+  });
+
+  describe("dirty flag", () => {
+    it("returns to false after a change is reverted to baseline", () => {
+      store().beginEdit(makeConfig({ working: [makeAction({ id: "a" })] }));
+      store().addAction("working", makeAction({ id: "b" }));
+      expect(store().dirty).toBe(true);
+      store().removeAction("working", "b");
+      expect(store().dirty).toBe(false);
+    });
+  });
+
+  describe("selection", () => {
+    it("round-trips action, situation, and clear", () => {
+      store().selectAction({
+        kind: "action",
+        situationId: "working",
+        actionId: "a",
+      });
+      expect(store().selection).toEqual({
+        kind: "action",
+        situationId: "working",
+        actionId: "a",
+      });
+
+      store().selectSituation("in_review");
+      expect(store().selection).toEqual({
+        kind: "situation",
+        situationId: "in_review",
+      });
+
+      store().selectSituation(null);
+      expect(store().selection).toBeNull();
+
+      store().selectAction({
+        kind: "action",
+        situationId: "working",
+        actionId: "a",
+      });
+      store().clearSelection();
+      expect(store().selection).toBeNull();
+    });
+  });
+});
diff --git a/apps/code/src/renderer/features/home/stores/workflowEditorStore.ts b/apps/code/src/renderer/features/home/stores/workflowEditorStore.ts
new file mode 100644
index 0000000000..7be0de8058
--- /dev/null
+++ b/apps/code/src/renderer/features/home/stores/workflowEditorStore.ts
@@ -0,0 +1,154 @@
+import {
+  SITUATION_IDS,
+  type SituationId,
+  type ValidationDiagnostic,
+  type WorkflowAction,
+  type WorkflowBindings,
+  type WorkflowConfig,
+  type WorkflowDraft,
+} from "@shared/types/workflow";
+import { create } from "zustand";
+
+// Uncommitted editor state for the Config view — the in-flight draft, dirty
+// flag, and diagnostics. The persisted workflow lives in the tRPC query cache.
+export type Selection =
+  | { kind: "action"; situationId: SituationId; actionId: string }
+  | { kind: "situation"; situationId: SituationId }
+  | null;
+
+interface WorkflowEditorStore {
+  draft: WorkflowDraft | null;
+  baselineSerialized: string | null;
+  dirty: boolean;
+  diagnostics: ValidationDiagnostic[];
+  selection: Selection;
+
+  beginEdit(persisted: WorkflowConfig): void;
+  addAction(situation: SituationId, action: WorkflowAction): void;
+  updateAction(
+    situation: SituationId,
+    actionId: string,
+    patch: Partial<WorkflowAction>,
+  ): void;
+  removeAction(situation: SituationId, actionId: string): void;
+  moveAction(
+    situation: SituationId,
+    actionId: string,
+    direction: "up" | "down",
+  ): void;
+  setDiagnostics(diagnostics: ValidationDiagnostic[]): void;
+  selectAction(ref: Extract<Selection, { kind: "action" }> | null): void;
+  selectSituation(id: SituationId | null): void;
+  clearSelection(): void;
+}
+
+function serialize(draft: WorkflowDraft): string {
+  return JSON.stringify(draft.bindings);
+}
+
+function toDraft(config: WorkflowConfig): WorkflowDraft {
+  // Normalize bindings to cover every situation key (z.record allows partial
+  // maps) so consumers can read `bindings[sid]` without optional-chaining.
+  const bindings = Object.fromEntries(
+    SITUATION_IDS.map((sid) => [sid, config.bindings[sid] ?? []]),
+  ) as WorkflowBindings;
+  return {
+    id: config.id,
+    version: config.version,
+    bindings,
+  };
+}
+
+function commit(
+  set: (partial: Partial<WorkflowEditorStore>) => void,
+  next: WorkflowDraft,
+  baseline: string | null,
+) {
+  set({
+    draft: next,
+    dirty: baseline !== null && serialize(next) !== baseline,
+  });
+}
+
+export const useWorkflowEditorStore = create<WorkflowEditorStore>(
+  (set, get) => ({
+    draft: null,
+    baselineSerialized: null,
+    dirty: false,
+    diagnostics: [],
+    selection: null,
+
+    beginEdit(persisted) {
+      const draft = toDraft(persisted);
+      set({
+        draft,
+        baselineSerialized: serialize(draft),
+        dirty: false,
+        diagnostics: [],
+        selection: null,
+      });
+    },
+
+    addAction(situation, action) {
+      const { draft, baselineSerialized } = get();
+      if (!draft) return;
+      const current = draft.bindings[situation] ?? [];
+      const bindings = {
+        ...draft.bindings,
+        [situation]: [...current, action],
+      };
+      commit(set, { ...draft, bindings }, baselineSerialized);
+    },
+
+    updateAction(situation, actionId, patch) {
+      const { draft, baselineSerialized } = get();
+      if (!draft) return;
+      const current = draft.bindings[situation] ?? [];
+      const next = current.map((a) =>
+        a.id === actionId ? { ...a, ...patch } : a,
+      );
+      const bindings = { ...draft.bindings, [situation]: next };
+      commit(set, { ...draft, bindings }, baselineSerialized);
+    },
+
+    removeAction(situation, actionId) {
+      const { draft, baselineSerialized } = get();
+      if (!draft) return;
+      const current = draft.bindings[situation] ?? [];
+      const next = current.filter((a) => a.id !== actionId);
+      const bindings = { ...draft.bindings, [situation]: next };
+      commit(set, { ...draft, bindings }, baselineSerialized);
+    },
+
+    moveAction(situation, actionId, direction) {
+      const { draft, baselineSerialized } = get();
+      if (!draft) return;
+      const current = draft.bindings[situation] ?? [];
+      const idx = current.findIndex((a) => a.id === actionId);
+      if (idx === -1) return;
+      const target = direction === "up" ? idx - 1 : idx + 1;
+      if (target < 0 || target >= current.length) return;
+      const next = [...current];
+      const [removed] = next.splice(idx, 1);
+      if (!removed) return;
+      next.splice(target, 0, removed);
+      const bindings = { ...draft.bindings, [situation]: next };
+      commit(set, { ...draft, bindings }, baselineSerialized);
+    },
+
+    setDiagnostics(diagnostics) {
+      set({ diagnostics });
+    },
+    selectAction(ref) {
+      set({ selection: ref });
+    },
+    selectSituation(id) {
+      set({
+        selection: id === null ? null : { kind: "situation", situationId: id },
+      });
+    },
+    clearSelection() {
+      set({ selection: null });
+    },
+  }),
+);
diff --git a/apps/code/src/renderer/features/home/subscriptions.ts b/apps/code/src/renderer/features/home/subscriptions.ts
new file mode 100644
index 0000000000..e1b9794b80
--- /dev/null
+++ b/apps/code/src/renderer/features/home/subscriptions.ts
@@ -0,0 +1,33 @@
+import { trpc, trpcClient } from "@renderer/trpc";
+import { logger } from "@utils/logger";
+import { queryClient } from "@utils/queryClient";
+
+const log = logger.scope("home-subscriptions");
+
+export function registerHomeSubscriptions() {
+  const workflowChanged = trpcClient.workflow.onChanged.subscribe(undefined, {
+    onData: (next) => {
+      queryClient.setQueryData(trpc.workflow.get.queryKey(), next);
+    },
+    onError: (error) => {
+      log.error("workflow.onChanged subscription error", { error });
+    },
+  });
+
+  const homeSnapshotUpdated = trpcClient.home.onSnapshotUpdated.subscribe(
+    undefined,
+    {
+      onData: (next) => {
+        queryClient.setQueryData(trpc.home.getSnapshot.queryKey(), next);
+      },
+      onError: (error) => {
+        log.error("home.onSnapshotUpdated subscription error", { error });
+      },
+    },
+  );
+
+  return () => {
+    workflowChanged.unsubscribe();
+    homeSnapshotUpdated.unsubscribe();
+  };
+}
diff --git a/apps/code/src/renderer/features/home/utils/boardColumns.test.ts b/apps/code/src/renderer/features/home/utils/boardColumns.test.ts
new file mode 100644
index 0000000000..3d5a730919
--- /dev/null
+++ b/apps/code/src/renderer/features/home/utils/boardColumns.test.ts
@@ -0,0 +1,139 @@
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import type { SituationId } from "@shared/types/workflow";
+import { describe, expect, it } from "vitest";
+import { buildBoardColumns, columnForWorkstream } from "./boardColumns";
+
+function makeWs(overrides: Partial<HomeWorkstream> = {}): HomeWorkstream {
+  return {
+    id: "ws_1",
+    repoName: null,
+    repoFullPath: null,
+    branch: null,
+    prUrl: null,
+    pr: null,
+    tasks: [],
+    situations: [],
+    primarySituation: null,
+    lastActivityAt: 0,
+    ...overrides,
+  };
+}
+
+const ACTIVE_COLUMNS: SituationId[] = [
+  "working",
+  "in_review",
+  "ci_failing",
+  "changes_requested",
+  "comments_waiting",
+  "ready_to_merge",
+];
+
+describe("columnForWorkstream", () => {
+  it("returns null when there is no primary situation", () => {
+    expect(columnForWorkstream(makeWs({ primarySituation: null }))).toBeNull();
+  });
+
+  it("pushes done off the active board", () => {
+    expect(
+      columnForWorkstream(makeWs({ primarySituation: "done" })),
+    ).toBeNull();
+  });
+
+  it("buckets a stale workstream into working", () => {
+    expect(columnForWorkstream(makeWs({ primarySituation: "stale" }))).toBe(
+      "working",
+    );
+  });
+
+  it("maps each active situation to its own column", () => {
+    for (const id of ACTIVE_COLUMNS) {
+      expect(columnForWorkstream(makeWs({ primarySituation: id }))).toBe(id);
+    }
+  });
+});
+
+describe("buildBoardColumns", () => {
+  it("returns the six active columns in order with empty inputs", () => {
+    const columns = buildBoardColumns([], []);
+    expect(columns.map((c) => c.id)).toEqual(ACTIVE_COLUMNS);
+    expect(columns.every((c) => c.workstreams.length === 0)).toBe(true);
+  });
+
+  it("omits stale and done from the columns", () => {
+    const ids = buildBoardColumns([], []).map((c) => c.id);
+    expect(ids).not.toContain("stale");
+    expect(ids).not.toContain("done");
+  });
+
+  it("uses titles and descriptions from situation metadata", () => {
+    const columns = buildBoardColumns([], []);
+    const working = columns.find((c) => c.id === "working");
+    expect(working?.title).toBe("Working");
+    expect(working?.description).toBe("Branch with changes, no PR yet");
+  });
+
+  it("drops workstreams with a done or null primary situation", () => {
+    const columns = buildBoardColumns(
+      [makeWs({ id: "done-ws", primarySituation: "done" })],
+      [makeWs({ id: "null-ws", primarySituation: null })],
+    );
+    expect(columns.every((c) => c.workstreams.length === 0)).toBe(true);
+  });
+
+  it("places a stale workstream in the working column", () => {
+    const columns = buildBoardColumns(
+      [],
+      [makeWs({ id: "stale-ws", primarySituation: "stale" })],
+    );
+    const working = columns.find((c) => c.id === "working");
+    expect(working?.workstreams.map((w) => w.id)).toEqual(["stale-ws"]);
+  });
+
+  it("sorts each column by lastActivityAt descending", () => {
+    const columns = buildBoardColumns(
+      [],
+      [
+        makeWs({ id: "old", primarySituation: "working", lastActivityAt: 100 }),
+        makeWs({ id: "new", primarySituation: "working", lastActivityAt: 300 }),
+        makeWs({ id: "mid", primarySituation: "working", lastActivityAt: 200 }),
+      ],
+    );
+    const working = columns.find((c) => c.id === "working");
+    expect(working?.workstreams.map((w) => w.id)).toEqual([
+      "new",
+      "mid",
+      "old",
+    ]);
+  });
+
+  it("keeps needsAttention ahead of inProgress when activity ties (stable sort)", () => {
+    const columns = buildBoardColumns(
+      [
+        makeWs({
+          id: "attn",
+          primarySituation: "ci_failing",
+          lastActivityAt: 5,
+        }),
+      ],
+      [
+        makeWs({
+          id: "prog",
+          primarySituation: "ci_failing",
+          lastActivityAt: 5,
+        }),
+      ],
+    );
+    const ciFailing = columns.find((c) => c.id === "ci_failing");
+    expect(ciFailing?.workstreams.map((w) => w.id)).toEqual(["attn", "prog"]);
+  });
+
+  it("routes workstreams from both lists into their columns", () => {
+    const columns = buildBoardColumns(
+      [makeWs({ id: "a", primarySituation: "changes_requested" })],
+      [makeWs({ id: "b", primarySituation: "ready_to_merge" })],
+    );
+    const byId = Object.fromEntries(columns.map((c) => [c.id, c.workstreams]));
+    expect(byId.changes_requested.map((w) => w.id)).toEqual(["a"]);
+    expect(byId.ready_to_merge.map((w) => w.id)).toEqual(["b"]);
+  });
+});
diff --git a/apps/code/src/renderer/features/home/utils/boardColumns.ts b/apps/code/src/renderer/features/home/utils/boardColumns.ts
new file mode 100644
index 0000000000..0b1aeebdb5
--- /dev/null
+++ b/apps/code/src/renderer/features/home/utils/boardColumns.ts
@@ -0,0 +1,58 @@
+import type { HomeWorkstream } from "@shared/types/home-snapshot";
+import { SITUATIONS, type SituationId } from "@shared/types/workflow";
+
+export type HomeBoardColumn = {
+  id: SituationId;
+  title: string;
+  description: string;
+  workstreams: HomeWorkstream[];
+};
+
+// Board columns, left → right. `done` (terminal) and `stale` (a modifier, shown
+// as a chip) are omitted.
+const BOARD_COLUMN_IDS: SituationId[] = [
+  "working",
+  "in_review",
+  "ci_failing",
+  "changes_requested",
+  "comments_waiting",
+  "ready_to_merge",
+];
+
+export function columnForWorkstream(
+  workstream: HomeWorkstream,
+): SituationId | null {
+  const primary = workstream.primarySituation;
+  if (!primary) return null;
+  // Push terminal/done situations off the active board.
+  if (primary === "done") return null;
+  // `stale` alone (no PR situation) buckets into `working`.
+  if (primary === "stale") return "working";
+  return primary;
+}
+
+export function buildBoardColumns(
+  needsAttention: HomeWorkstream[],
+  inProgress: HomeWorkstream[],
+): HomeBoardColumn[] {
+  const map = new Map<SituationId, HomeWorkstream[]>();
+  for (const id of BOARD_COLUMN_IDS) map.set(id, []);
+
+  for (const ws of [...needsAttention, ...inProgress]) {
+    const id = columnForWorkstream(ws);
+    if (!id) continue;
+    map.get(id)?.push(ws);
+  }
+
+  return BOARD_COLUMN_IDS.map((id) => {
+    const meta = SITUATIONS.find((s) => s.id === id);
+    return {
+      id,
+      title: meta?.label ?? id,
+      description: meta?.description ?? "",
+      workstreams: (map.get(id) ?? []).sort(
+        (a, b) => b.lastActivityAt - a.lastActivityAt,
+      ),
+    };
+  });
+}
diff --git a/apps/code/src/renderer/features/home/utils/situationDisplay.ts b/apps/code/src/renderer/features/home/utils/situationDisplay.ts
new file mode 100644
index 0000000000..faa79f4ed1
--- /dev/null
+++ b/apps/code/src/renderer/features/home/utils/situationDisplay.ts
@@ -0,0 +1,83 @@
+import {
+  ArrowUUpLeft,
+  ChatCircleDots,
+  CheckCircle,
+  Clock,
+  Eye,
+  GitCommit,
+  GitMerge,
+  type Icon,
+  XCircle,
+} from "@phosphor-icons/react";
+import { SITUATIONS, type SituationId } from "@shared/types/workflow";
+
+// Radix color scales the status system uses, each mapping to the full
+// `--<color>-{1..12}` + `--<color>-a{1..12}` token families.
+export type SituationColor =
+  | "red"
+  | "orange"
+  | "amber"
+  | "green"
+  | "blue"
+  | "purple"
+  | "gray";
+
+export interface SituationVisual {
+  label: string;
+  description: string;
+  /** Radix color scale that gives this situation its identity. */
+  color: SituationColor;
+  /** Phosphor glyph rendered in the status badge / chip. */
+  Icon: Icon;
+}
+
+// Colour + glyph each situation reads as: cool hues = work in flight, warm =
+// "your move", green = go, gray = dormant. Adjacent board columns stay distinct.
+const SITUATION_STYLE: Record<
+  SituationId,
+  { color: SituationColor; Icon: Icon }
+> = {
+  working: { color: "purple", Icon: GitCommit },
+  in_review: { color: "blue", Icon: Eye },
+  ci_failing: { color: "red", Icon: XCircle },
+  changes_requested: { color: "orange", Icon: ArrowUUpLeft },
+  comments_waiting: { color: "amber", Icon: ChatCircleDots },
+  ready_to_merge: { color: "green", Icon: GitMerge },
+  stale: { color: "gray", Icon: Clock },
+  done: { color: "gray", Icon: CheckCircle },
+};
+
+export const SITUATION_VISUAL: Record<SituationId, SituationVisual> =
+  Object.fromEntries(
+    SITUATIONS.map((s) => [
+      s.id,
+      { label: s.label, description: s.description, ...SITUATION_STYLE[s.id] },
+    ]),
+  ) as Record<SituationId, SituationVisual>;
+
+/** CSS-var passthroughs for a colour scale — used in inline `style`. */
+export interface SituationCss {
+  /** Readable text / icon colour, also good on a tinted fill (`--c-11`). */
+  fg: string;
+  /** Saturated solid — dots and accent rails (`--c-9`). */
+  solid: string;
+  /** Soft translucent fill for chips / glyph backgrounds (`--c-a3`). */
+  tint: string;
+  /** Slightly stronger fill for hover / wells (`--c-a4`). */
+  tintStrong: string;
+  /** Hairline border that reads as the colour (`--c-a6`). */
+  border: string;
+  /** Whisper-faint column wash (`--c-a2`). */
+  wash: string;
+}
+
+export function situationCss(color: SituationColor): SituationCss {
+  return {
+    fg: `var(--${color}-11)`,
+    solid: `var(--${color}-9)`,
+    tint: `var(--${color}-a3)`,
+    tintStrong: `var(--${color}-a4)`,
+    border: `var(--${color}-a6)`,
+    wash: `var(--${color}-a2)`,
+  };
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx b/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
index 9107784ee6..b4eec89535 100644
--- a/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
+++ b/apps/code/src/renderer/features/sidebar/components/SidebarMenu.tsx
@@ -13,18 +13,21 @@ import {
 import { useRenameTask, useTasks } from "@features/tasks/hooks/useTasks";
 import { useWorkspaces } from "@features/workspace/hooks/useWorkspace";
 import { useAppView } from "@hooks/useAppView";
+import { useFeatureFlag } from "@hooks/useFeatureFlag";
 import { openTask, openTaskInput } from "@hooks/useOpenTask";
 import { useTaskContextMenu } from "@hooks/useTaskContextMenu";
 import { Separator } from "@posthog/quill";
 import { Box, Flex } from "@radix-ui/themes";
 import {
   navigateToCommandCenter,
+  navigateToHome,
   navigateToInbox,
   navigateToMcpServers,
   navigateToSkills,
   navigateToTaskDetail,
 } from "@renderer/navigationBridge";
 import { trpcClient } from "@renderer/trpc/client";
+import { HOME_TAB_FLAG } from "@shared/constants";
 import type { Task } from "@shared/types";
 import { useCommandMenuStore } from "@stores/commandMenuStore";
 import { useRendererWindowFocusStore } from "@stores/rendererWindowFocusStore";
@@ -38,8 +41,10 @@ import { useTaskViewed } from "../hooks/useTaskViewed";
 import { useSidebarStore } from "../stores/sidebarStore";
 import { useTaskSelectionStore } from "../stores/taskSelectionStore";
 import { CommandCenterItem } from "./items/CommandCenterItem";
-import { InboxItem, NewTaskItem } from "./items/HomeItem";
+import { HomeItem } from "./items/HomeItem";
+import { InboxItem } from "./items/InboxItem";
 import { McpServersItem } from "./items/McpServersItem";
+import { NewTaskItem } from "./items/NewTaskItem";
 import { SearchItem } from "./items/SearchItem";
 import { SkillsItem } from "./items/SkillsItem";
 import { SidebarItem } from "./SidebarItem";
@@ -66,6 +71,8 @@ function SidebarMenuComponent() {
   const { renameTask } = useRenameTask();
   const { togglePin } = usePinnedTasks();
 
+  const homeTabEnabled = useFeatureFlag(HOME_TAB_FLAG);
+
   const sidebarData = useSidebarData({
     activeView: view,
   });
@@ -116,6 +123,10 @@ function SidebarMenuComponent() {
     openTaskInput();
   };
 
+  const handleHomeClick = () => {
+    navigateToHome();
+  };
+
   const handleInboxClick = () => {
     navigateToInbox();
   };
@@ -376,10 +387,18 @@ function SidebarMenuComponent() {
           <NewTaskItem
             isActive={sidebarData.isHomeActive}
             onClick={handleNewTaskClick}
-            variant="primary"
           />
         </Box>
 
+        {homeTabEnabled && (
+          <Box>
+            <HomeItem
+              isActive={sidebarData.isHomeViewActive}
+              onClick={handleHomeClick}
+            />
+          </Box>
+        )}
+
         <Box>
           <SearchItem onClick={handleSearchClick} />
         </Box>
diff --git a/apps/code/src/renderer/features/sidebar/components/items/HomeItem.tsx b/apps/code/src/renderer/features/sidebar/components/items/HomeItem.tsx
index 648ce78d35..936647eb67 100644
--- a/apps/code/src/renderer/features/sidebar/components/items/HomeItem.tsx
+++ b/apps/code/src/renderer/features/sidebar/components/items/HomeItem.tsx
@@ -1,96 +1,35 @@
-import { Tooltip } from "@components/ui/Tooltip";
-import { EnvelopeSimple, Plus } from "@phosphor-icons/react";
-import { Badge, type ButtonProps } from "@posthog/quill";
-import { SHORTCUTS } from "@renderer/constants/keyboard-shortcuts";
-import { useDraftStore } from "@renderer/features/message-editor/stores/draftStore";
-import { isContentEmpty } from "@renderer/features/message-editor/utils/content";
+import { House } from "@phosphor-icons/react";
+import { Badge } from "@posthog/quill";
 import { SidebarItem } from "../SidebarItem";
-import { SidebarKbdHint } from "./SidebarKbdHint";
+import { SidebarCountBadge } from "./SidebarCountBadge";
 
-interface NewTaskItemProps {
+interface HomeItemProps {
   isActive: boolean;
   onClick: () => void;
-  variant?: ButtonProps["variant"];
+  attentionCount?: number;
 }
 
-export function NewTaskItem({ isActive, onClick }: NewTaskItemProps) {
-  const hasDraft = useDraftStore(
-    (s) => !isContentEmpty(s.drafts["task-input"]),
-  );
+export function HomeItem({
+  isActive,
+  onClick,
+  attentionCount = 0,
+}: HomeItemProps) {
   return (
     <SidebarItem
       depth={0}
-      icon={<Plus size={16} weight={isActive ? "bold" : "regular"} />}
-      label="New task"
-      isActive={isActive}
-      onClick={onClick}
-      endContent={
+      icon={<House size={16} weight={isActive ? "fill" : "regular"} />}
+      label={
         <>
-          {hasDraft ? (
-            <Badge variant="default" title="You have unsubmitted changes">
-              Draft
-            </Badge>
-          ) : null}
-          <SidebarKbdHint keys={SHORTCUTS.NEW_TASK} />
+          Home
+          <SidebarCountBadge
+            count={attentionCount}
+            title={`${attentionCount} item${attentionCount === 1 ? "" : "s"} needing attention`}
+          />
         </>
       }
+      isActive={isActive}
+      onClick={onClick}
+      endContent={<Badge variant="warning">Alpha</Badge>}
     />
   );
 }
-
-interface InboxItemProps {
-  isActive: boolean;
-  onClick: () => void;
-  signalCount?: number;
-}
-
-function formatSignalCount(count: number): string {
-  if (count > 99) return "99+";
-  return String(count);
-}
-
-export function InboxItem({ isActive, onClick, signalCount }: InboxItemProps) {
-  return (
-    <Tooltip
-      content={
-        signalCount && signalCount > 0
-          ? `${signalCount} actionable report${signalCount === 1 ? "" : "s"} assigned to you`
-          : "No actionable reports assigned to you yet"
-      }
-      side="right"
-    >
-      <div>
-        <SidebarItem
-          depth={0}
-          icon={
-            <EnvelopeSimple size={16} weight={isActive ? "fill" : "regular"} />
-          }
-          label={
-            <>
-              Inbox
-              {signalCount && signalCount > 0 ? (
-                <span
-                  className="ml-2 inline-flex shrink-0 items-center justify-center rounded-full bg-(--red-9) p-1 font-medium text-[10px] leading-none"
-                  style={{
-                    color: "white",
-                  }}
-                  title={`${signalCount} actionable reports for you`}
-                >
-                  {formatSignalCount(signalCount)}
-                </span>
-              ) : null}
-            </>
-          }
-          isActive={isActive}
-          onClick={onClick}
-          endContent={
-            <>
-              <Badge variant="warning">Alpha</Badge>
-              <SidebarKbdHint keys={SHORTCUTS.INBOX} />
-            </>
-          }
-        />
-      </div>
-    </Tooltip>
-  );
-}
diff --git a/apps/code/src/renderer/features/sidebar/components/items/InboxItem.tsx b/apps/code/src/renderer/features/sidebar/components/items/InboxItem.tsx
new file mode 100644
index 0000000000..230d333d5e
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/items/InboxItem.tsx
@@ -0,0 +1,56 @@
+import { Tooltip } from "@components/ui/Tooltip";
+import { EnvelopeSimple } from "@phosphor-icons/react";
+import { Badge } from "@posthog/quill";
+import { SHORTCUTS } from "@renderer/constants/keyboard-shortcuts";
+import { SidebarItem } from "../SidebarItem";
+import { SidebarCountBadge } from "./SidebarCountBadge";
+import { SidebarKbdHint } from "./SidebarKbdHint";
+
+interface InboxItemProps {
+  isActive: boolean;
+  onClick: () => void;
+  signalCount?: number;
+}
+
+export function InboxItem({
+  isActive,
+  onClick,
+  signalCount = 0,
+}: InboxItemProps) {
+  return (
+    <Tooltip
+      content={
+        signalCount > 0
+          ? `${signalCount} actionable report${signalCount === 1 ? "" : "s"} assigned to you`
+          : "No actionable reports assigned to you yet"
+      }
+      side="right"
+    >
+      <div>
+        <SidebarItem
+          depth={0}
+          icon={
+            <EnvelopeSimple size={16} weight={isActive ? "fill" : "regular"} />
+          }
+          label={
+            <>
+              Inbox
+              <SidebarCountBadge
+                count={signalCount}
+                title={`${signalCount} actionable reports for you`}
+              />
+            </>
+          }
+          isActive={isActive}
+          onClick={onClick}
+          endContent={
+            <>
+              <Badge variant="warning">Alpha</Badge>
+              <SidebarKbdHint keys={SHORTCUTS.INBOX} />
+            </>
+          }
+        />
+      </div>
+    </Tooltip>
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/items/NewTaskItem.tsx b/apps/code/src/renderer/features/sidebar/components/items/NewTaskItem.tsx
new file mode 100644
index 0000000000..bde5537ad3
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/items/NewTaskItem.tsx
@@ -0,0 +1,37 @@
+import { Plus } from "@phosphor-icons/react";
+import { Badge } from "@posthog/quill";
+import { SHORTCUTS } from "@renderer/constants/keyboard-shortcuts";
+import { useDraftStore } from "@renderer/features/message-editor/stores/draftStore";
+import { isContentEmpty } from "@renderer/features/message-editor/utils/content";
+import { SidebarItem } from "../SidebarItem";
+import { SidebarKbdHint } from "./SidebarKbdHint";
+
+interface NewTaskItemProps {
+  isActive: boolean;
+  onClick: () => void;
+}
+
+export function NewTaskItem({ isActive, onClick }: NewTaskItemProps) {
+  const hasDraft = useDraftStore(
+    (s) => !isContentEmpty(s.drafts["task-input"]),
+  );
+  return (
+    <SidebarItem
+      depth={0}
+      icon={<Plus size={16} weight={isActive ? "bold" : "regular"} />}
+      label="New task"
+      isActive={isActive}
+      onClick={onClick}
+      endContent={
+        <>
+          {hasDraft ? (
+            <Badge variant="default" title="You have unsubmitted changes">
+              Draft
+            </Badge>
+          ) : null}
+          <SidebarKbdHint keys={SHORTCUTS.NEW_TASK} />
+        </>
+      }
+    />
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/components/items/SidebarCountBadge.tsx b/apps/code/src/renderer/features/sidebar/components/items/SidebarCountBadge.tsx
new file mode 100644
index 0000000000..6f0fffe973
--- /dev/null
+++ b/apps/code/src/renderer/features/sidebar/components/items/SidebarCountBadge.tsx
@@ -0,0 +1,17 @@
+interface SidebarCountBadgeProps {
+  count: number;
+  title: string;
+}
+
+export function SidebarCountBadge({ count, title }: SidebarCountBadgeProps) {
+  if (count <= 0) return null;
+  return (
+    <span
+      className="ml-2 inline-flex shrink-0 items-center justify-center rounded-full bg-(--red-9) p-1 font-medium text-[10px] leading-none"
+      style={{ color: "white" }}
+      title={title}
+    >
+      {count > 99 ? "99+" : count}
+    </span>
+  );
+}
diff --git a/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts b/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts
index f4f872b8c4..261c74c55a 100644
--- a/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts
+++ b/apps/code/src/renderer/features/sidebar/hooks/useSidebarData.ts
@@ -49,6 +49,7 @@ export type TaskGroup = GenericTaskGroup<TaskData>;
 
 export interface SidebarData {
   isHomeActive: boolean;
+  isHomeViewActive: boolean;
   isInboxActive: boolean;
   isCommandCenterActive: boolean;
   isSkillsActive: boolean;
@@ -69,6 +70,7 @@ interface ViewState {
     | "task-input"
     | "settings"
     | "folder-settings"
+    | "home"
     | "inbox"
     | "archived"
     | "command-center"
@@ -92,6 +94,94 @@ function sortTasks(tasks: TaskData[], sortMode: SortMode): TaskData[] {
   );
 }
 
+// Minimal task shape the mapper reads — satisfied by both TaskSummary and the full Task.
+export interface TaskDataInput {
+  id: string;
+  title: string;
+  created_at: string;
+  updated_at: string;
+  repository?: string | null;
+  latest_run?: {
+    status?: TaskRunStatus | null;
+    environment?: "local" | "cloud" | null;
+    output?: { pr_url?: unknown } | null;
+  } | null;
+  origin_product?: string;
+  slack_thread_url?: string;
+}
+
+export interface TaskDataContext {
+  session?: {
+    isPromptPending?: boolean;
+    pendingPermissions?: { size: number };
+    cloudStatus?: TaskRunStatus;
+    cloudOutput?: { pr_url?: unknown } | null;
+  };
+  workspace?: {
+    folderPath?: string | null;
+    folderId?: string;
+    branchName?: string | null;
+    linkedBranch?: string | null;
+  };
+  taskTimestamps?: {
+    lastActivityAt?: number | null;
+    lastViewedAt?: number | null;
+  };
+  isPinned: boolean;
+  isSuspended: boolean;
+  isSlackOrigin: boolean;
+  slackThreadUrlFallback?: string;
+}
+
+// Single source of truth for Task → TaskData, shared by the sidebar and home tab.
+export function toTaskData(
+  task: TaskDataInput,
+  ctx: TaskDataContext,
+): TaskData {
+  const { session, workspace, taskTimestamps } = ctx;
+  const apiUpdatedAt = new Date(task.updated_at).getTime();
+  const localActivity = taskTimestamps?.lastActivityAt;
+  const lastActivityAt = localActivity
+    ? Math.max(apiUpdatedAt, localActivity)
+    : apiUpdatedAt;
+  const createdAt = new Date(task.created_at).getTime();
+
+  const taskLastViewedAt = taskTimestamps?.lastViewedAt;
+  const isUnread =
+    taskLastViewedAt != null && lastActivityAt > taskLastViewedAt;
+
+  const cloudPrUrl =
+    typeof task.latest_run?.output?.pr_url === "string"
+      ? task.latest_run.output.pr_url
+      : ((session?.cloudOutput?.pr_url as string | undefined) ?? null);
+
+  const originProduct =
+    task.origin_product ?? (ctx.isSlackOrigin ? "slack" : undefined);
+  const slackThreadUrl = task.slack_thread_url ?? ctx.slackThreadUrlFallback;
+
+  return {
+    id: task.id,
+    title: task.title,
+    createdAt,
+    lastActivityAt,
+    isGenerating: session?.isPromptPending ?? false,
+    isUnread,
+    isPinned: ctx.isPinned,
+    isSuspended: ctx.isSuspended,
+    needsPermission: (session?.pendingPermissions?.size ?? 0) > 0,
+    repository: getRepositoryInfo(task, workspace?.folderPath ?? undefined),
+    folderId: workspace?.folderId || undefined,
+    taskRunStatus: session?.cloudStatus ?? task.latest_run?.status ?? undefined,
+    taskRunEnvironment: task.latest_run?.environment ?? undefined,
+    originProduct,
+    slackThreadUrl,
+    folderPath: workspace?.folderPath ?? null,
+    cloudPrUrl,
+    branchName: workspace?.branchName ?? null,
+    linkedBranch: workspace?.linkedBranch ?? null,
+  };
+}
+
 export function useSidebarData({
   activeView,
 }: UseSidebarDataProps): SidebarData {
@@ -220,6 +310,7 @@ export function useSidebarData({
 
   const isHomeActive =
     activeView.type === "task-input" || activeView.type === "task-pending";
+  const isHomeViewActive = activeView.type === "home";
   const isInboxActive = activeView.type === "inbox";
   const isCommandCenterActive = activeView.type === "command-center";
   const isSkillsActive = activeView.type === "skills";
@@ -239,55 +330,17 @@ export function useSidebarData({
   }, [sessions]);
 
   const taskData = useMemo(() => {
-    return allTasks.map((task) => {
-      const session = sessionByTaskId.get(task.id);
-      const workspace = workspaces?.[task.id];
-      const apiUpdatedAt = new Date(task.updated_at).getTime();
-      const taskTimestamps = timestamps[task.id];
-      const localActivity = taskTimestamps?.lastActivityAt;
-      const lastActivityAt = localActivity
-        ? Math.max(apiUpdatedAt, localActivity)
-        : apiUpdatedAt;
-      const createdAt = new Date(task.created_at).getTime();
-
-      const taskLastViewedAt = taskTimestamps?.lastViewedAt;
-      const isUnread =
-        taskLastViewedAt != null && lastActivityAt > taskLastViewedAt;
-
-      const cloudPrUrl =
-        typeof task.latest_run?.output?.pr_url === "string"
-          ? task.latest_run.output.pr_url
-          : ((session?.cloudOutput?.pr_url as string | undefined) ?? null);
-
-      const originProduct =
-        task.origin_product ??
-        (slackTaskIds.has(task.id) ? "slack" : undefined);
-      const slackThreadUrl =
-        task.slack_thread_url ?? slackThreadUrlByTaskId.get(task.id);
-
-      return {
-        id: task.id,
-        title: task.title,
-        createdAt,
-        lastActivityAt,
-        isGenerating: session?.isPromptPending ?? false,
-        isUnread,
+    return allTasks.map((task) =>
+      toTaskData(task, {
+        session: sessionByTaskId.get(task.id),
+        workspace: workspaces?.[task.id],
+        taskTimestamps: timestamps[task.id],
         isPinned: pinnedTaskIds.has(task.id),
         isSuspended: suspendedTaskIds.has(task.id),
-        needsPermission: (session?.pendingPermissions?.size ?? 0) > 0,
-        repository: getRepositoryInfo(task, workspace?.folderPath),
-        folderId: workspace?.folderId || undefined,
-        taskRunStatus:
-          session?.cloudStatus ?? task.latest_run?.status ?? undefined,
-        taskRunEnvironment: task.latest_run?.environment ?? undefined,
-        originProduct,
-        slackThreadUrl,
-        folderPath: workspace?.folderPath ?? null,
-        cloudPrUrl,
-        branchName: workspace?.branchName ?? null,
-        linkedBranch: workspace?.linkedBranch ?? null,
-      };
-    });
+        isSlackOrigin: slackTaskIds.has(task.id),
+        slackThreadUrlFallback: slackThreadUrlByTaskId.get(task.id),
+      }),
+    );
   }, [
     allTasks,
     timestamps,
@@ -348,6 +401,7 @@ export function useSidebarData({
 
   return {
     isHomeActive,
+    isHomeViewActive,
     isInboxActive,
     isCommandCenterActive,
     isSkillsActive,
diff --git a/apps/code/src/renderer/hooks/useAppView.ts b/apps/code/src/renderer/hooks/useAppView.ts
index ab7a113f3b..0ef750a104 100644
--- a/apps/code/src/renderer/hooks/useAppView.ts
+++ b/apps/code/src/renderer/hooks/useAppView.ts
@@ -11,6 +11,7 @@ export type AppViewType =
   | "task-pending"
   | "task-input"
   | "folder-settings"
+  | "home"
   | "inbox"
   | "archived"
   | "command-center"
@@ -49,6 +50,8 @@ function deriveFromMatches(matches: Match[]): AppView {
       return { type: "task-pending", pendingTaskKey: last.params.key };
     case "/folders/$folderId":
       return { type: "folder-settings", folderId: last.params.folderId };
+    case "/code/home":
+      return { type: "home" };
     case "/code/inbox":
       return { type: "inbox" };
     case "/code/archived":
diff --git a/apps/code/src/renderer/navigationBridge.ts b/apps/code/src/renderer/navigationBridge.ts
index 645fb9e4a9..e66741431d 100644
--- a/apps/code/src/renderer/navigationBridge.ts
+++ b/apps/code/src/renderer/navigationBridge.ts
@@ -39,6 +39,10 @@ export function navigateToFolderSettings(folderId: string): void {
   });
 }
 
+export function navigateToHome(): void {
+  void getRouterOrNull()?.navigate({ to: "/code/home" });
+}
+
 export function navigateToInbox(): void {
   void getRouterOrNull()?.navigate({ to: "/code/inbox" });
 }
diff --git a/apps/code/src/renderer/routeTree.gen.ts b/apps/code/src/renderer/routeTree.gen.ts
index e6d4d9846e..91a0a69f90 100644
--- a/apps/code/src/renderer/routeTree.gen.ts
+++ b/apps/code/src/renderer/routeTree.gen.ts
@@ -18,6 +18,7 @@ import { Route as CodeIndexRouteImport } from './routes/code/index'
 import { Route as SettingsCategoryRouteImport } from './routes/settings/$category'
 import { Route as FoldersFolderIdRouteImport } from './routes/folders/$folderId'
 import { Route as CodeInboxRouteImport } from './routes/code/inbox'
+import { Route as CodeHomeRouteImport } from './routes/code/home'
 import { Route as CodeArchivedRouteImport } from './routes/code/archived'
 import { Route as CodeTasksTaskIdRouteImport } from './routes/code/tasks/$taskId'
 import { Route as CodeTasksPendingKeyRouteImport } from './routes/code/tasks/pending.$key'
@@ -67,6 +68,11 @@ const CodeInboxRoute = CodeInboxRouteImport.update({
   path: '/code/inbox',
   getParentRoute: () => rootRouteImport,
 } as any)
+const CodeHomeRoute = CodeHomeRouteImport.update({
+  id: '/code/home',
+  path: '/code/home',
+  getParentRoute: () => rootRouteImport,
+} as any)
 const CodeArchivedRoute = CodeArchivedRouteImport.update({
   id: '/code/archived',
   path: '/code/archived',
@@ -89,6 +95,7 @@ export interface FileRoutesByFullPath {
   '/mcp-servers': typeof McpServersRoute
   '/skills': typeof SkillsRoute
   '/code/archived': typeof CodeArchivedRoute
+  '/code/home': typeof CodeHomeRoute
   '/code/inbox': typeof CodeInboxRoute
   '/folders/$folderId': typeof FoldersFolderIdRoute
   '/settings/$category': typeof SettingsCategoryRoute
@@ -103,6 +110,7 @@ export interface FileRoutesByTo {
   '/mcp-servers': typeof McpServersRoute
   '/skills': typeof SkillsRoute
   '/code/archived': typeof CodeArchivedRoute
+  '/code/home': typeof CodeHomeRoute
   '/code/inbox': typeof CodeInboxRoute
   '/folders/$folderId': typeof FoldersFolderIdRoute
   '/settings/$category': typeof SettingsCategoryRoute
@@ -118,6 +126,7 @@ export interface FileRoutesById {
   '/mcp-servers': typeof McpServersRoute
   '/skills': typeof SkillsRoute
   '/code/archived': typeof CodeArchivedRoute
+  '/code/home': typeof CodeHomeRoute
   '/code/inbox': typeof CodeInboxRoute
   '/folders/$folderId': typeof FoldersFolderIdRoute
   '/settings/$category': typeof SettingsCategoryRoute
@@ -134,6 +143,7 @@ export interface FileRouteTypes {
     | '/mcp-servers'
     | '/skills'
     | '/code/archived'
+    | '/code/home'
     | '/code/inbox'
     | '/folders/$folderId'
     | '/settings/$category'
@@ -148,6 +158,7 @@ export interface FileRouteTypes {
     | '/mcp-servers'
     | '/skills'
     | '/code/archived'
+    | '/code/home'
     | '/code/inbox'
     | '/folders/$folderId'
     | '/settings/$category'
@@ -162,6 +173,7 @@ export interface FileRouteTypes {
     | '/mcp-servers'
     | '/skills'
     | '/code/archived'
+    | '/code/home'
     | '/code/inbox'
     | '/folders/$folderId'
     | '/settings/$category'
@@ -177,6 +189,7 @@ export interface RootRouteChildren {
   McpServersRoute: typeof McpServersRoute
   SkillsRoute: typeof SkillsRoute
   CodeArchivedRoute: typeof CodeArchivedRoute
+  CodeHomeRoute: typeof CodeHomeRoute
   CodeInboxRoute: typeof CodeInboxRoute
   FoldersFolderIdRoute: typeof FoldersFolderIdRoute
   SettingsCategoryRoute: typeof SettingsCategoryRoute
@@ -251,6 +264,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof CodeInboxRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/code/home': {
+      id: '/code/home'
+      path: '/code/home'
+      fullPath: '/code/home'
+      preLoaderRoute: typeof CodeHomeRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/code/archived': {
       id: '/code/archived'
       path: '/code/archived'
@@ -281,6 +301,7 @@ const rootRouteChildren: RootRouteChildren = {
   McpServersRoute: McpServersRoute,
   SkillsRoute: SkillsRoute,
   CodeArchivedRoute: CodeArchivedRoute,
+  CodeHomeRoute: CodeHomeRoute,
   CodeInboxRoute: CodeInboxRoute,
   FoldersFolderIdRoute: FoldersFolderIdRoute,
   SettingsCategoryRoute: SettingsCategoryRoute,
diff --git a/apps/code/src/renderer/routes/__root.tsx b/apps/code/src/renderer/routes/__root.tsx
index 144f6d5df3..e3faa3d20d 100644
--- a/apps/code/src/renderer/routes/__root.tsx
+++ b/apps/code/src/renderer/routes/__root.tsx
@@ -21,7 +21,11 @@ import { useIntegrations } from "@hooks/useIntegrations";
 import { openTask, openTaskInput } from "@hooks/useOpenTask";
 import { Box, Flex } from "@radix-ui/themes";
 import { useTRPC } from "@renderer/trpc/client";
-import { BILLING_FLAG, SYNC_CLOUD_TASKS_FLAG } from "@shared/constants";
+import {
+  BILLING_FLAG,
+  HOME_TAB_FLAG,
+  SYNC_CLOUD_TASKS_FLAG,
+} from "@shared/constants";
 import { useCommandMenuStore } from "@stores/commandMenuStore";
 import { useShortcutsSheetStore } from "@stores/shortcutsSheetStore";
 import { type QueryClient, useQueryClient } from "@tanstack/react-query";
@@ -30,8 +34,16 @@ import {
   Outlet,
   useRouterState,
 } from "@tanstack/react-router";
+import { onFeatureFlagsLoaded } from "@utils/analytics";
 import { logger } from "@utils/logger";
-import { lazy, Suspense, useCallback, useEffect, useRef } from "react";
+import {
+  lazy,
+  Suspense,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+} from "react";
 
 // Dynamic import keeps the devtools chunk out of the prod bundle. Without the
 // gate at the import level, conditional render alone still ships the devtools
@@ -102,6 +114,7 @@ function RootLayout() {
   const reconcilingTaskIds = useRef<Set<string>>(new Set());
   const billingEnabled = useFeatureFlag(BILLING_FLAG);
   const syncCloudTasksEnabled = useFeatureFlag(SYNC_CLOUD_TASKS_FLAG);
+  const homeTabEnabled = useFeatureFlag(HOME_TAB_FLAG);
 
   const sidebarData = useSidebarData({ activeView: view });
   const visualTaskOrder = useVisualTaskOrder(sidebarData);
@@ -155,6 +168,18 @@ function RootLayout() {
   // Note: a malformed /code/tasks/$taskId without a valid id is impossible —
   // TanStack Router only mounts the task-detail route when taskId is in the URL.
 
+  // The /code/home route is only reachable while the home-tab flag is on, but
+  // flags resolve asynchronously — a restored route (or a flag flipping off
+  // mid-session) can leave us on home without access. Redirect to the new-task
+  // screen once flags have loaded and home is gated off.
+  const [flagsLoaded, setFlagsLoaded] = useState(false);
+  useEffect(() => onFeatureFlagsLoaded(() => setFlagsLoaded(true)), []);
+  useEffect(() => {
+    if (flagsLoaded && !homeTabEnabled && view.type === "home") {
+      openTaskInput();
+    }
+  }, [flagsLoaded, homeTabEnabled, view.type]);
+
   const handleToggleCommandMenu = useCallback(() => {
     toggleCommandMenu();
   }, [toggleCommandMenu]);
diff --git a/apps/code/src/renderer/routes/code/home.tsx b/apps/code/src/renderer/routes/code/home.tsx
new file mode 100644
index 0000000000..7d4addef10
--- /dev/null
+++ b/apps/code/src/renderer/routes/code/home.tsx
@@ -0,0 +1,6 @@
+import { HomeView } from "@features/home/components/HomeView";
+import { createFileRoute } from "@tanstack/react-router";
+
+export const Route = createFileRoute("/code/home")({
+  component: HomeView,
+});
diff --git a/apps/code/src/shared/constants.ts b/apps/code/src/shared/constants.ts
index 1cdb2c9f38..89ec4d32a3 100644
--- a/apps/code/src/shared/constants.ts
+++ b/apps/code/src/shared/constants.ts
@@ -3,6 +3,7 @@ export const INBOX_GATED_DUE_TO_SCALE_FLAG = "inbox-gated-due-to-scale";
 export const EXPERIMENT_SUGGESTIONS_FLAG =
   "posthog-code-experiment-suggestions";
 export const SYNC_CLOUD_TASKS_FLAG = "posthog-code-sync-cloud-tasks";
+export const HOME_TAB_FLAG = "posthog-code-home-tab";
 export const DISCOVERY_RUN_FLAG = "posthog-code-discovery-run";
 export const BRANCH_PREFIX = "posthog-code/";
 export const DATA_DIR = ".posthog-code";
diff --git a/apps/code/src/shared/types/analytics.ts b/apps/code/src/shared/types/analytics.ts
index df312790a5..2861212334 100644
--- a/apps/code/src/shared/types/analytics.ts
+++ b/apps/code/src/shared/types/analytics.ts
@@ -7,7 +7,7 @@ import type {
 
 type ExecutionType = "cloud" | "local";
 export type RepositoryProvider = "github" | "gitlab" | "local" | "none";
-type TaskCreatedFrom = "cli" | "command-menu";
+type TaskCreatedFrom = "cli" | "command-menu" | "home-quick-action";
 type RepositorySelectSource = "task-creation" | "task-detail";
 type GitActionType =
   | "push"
diff --git a/apps/code/src/shared/types/home-snapshot.ts b/apps/code/src/shared/types/home-snapshot.ts
new file mode 100644
index 0000000000..84de36d710
--- /dev/null
+++ b/apps/code/src/shared/types/home-snapshot.ts
@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { prSnapshot } from "./pr-snapshot";
+import { situationId } from "./workflow";
+
+// The Home snapshot wire contract. Produced server-side by PostHog's
+// `evaluate-code-workstreams` Temporal worker and served by
+// `GET /api/projects/:id/code_home/`; the main process validates the response
+// against this schema before handing it to the renderer.
+
+// Mirrors TaskRunStatus in @shared/types (the canonical type lives there; this
+// is the runtime enum the snapshot schema validates against).
+export const taskRunStatus = z.enum([
+  "not_started",
+  "queued",
+  "in_progress",
+  "completed",
+  "failed",
+  "cancelled",
+]);
+
+export const homeActiveAgent = z
+  .object({
+    taskId: z.string(),
+    title: z.string(),
+    repoName: z.string().nullable(),
+    branch: z.string().nullable(),
+    status: taskRunStatus,
+    lastActivityAt: z.number(),
+    needsPermission: z.boolean(),
+    cloudPrUrl: z.string().nullable(),
+  })
+  .strict();
+export type HomeActiveAgent = z.infer<typeof homeActiveAgent>;
+
+export const homeWorkstreamTask = z
+  .object({
+    id: z.string(),
+    title: z.string(),
+    status: taskRunStatus.nullable(),
+    isGenerating: z.boolean(),
+    needsPermission: z.boolean(),
+  })
+  .strict();
+export type HomeWorkstreamTask = z.infer<typeof homeWorkstreamTask>;
+
+export const homeWorkstream = z
+  .object({
+    id: z.string(),
+    repoName: z.string().nullable(),
+    repoFullPath: z.string().nullable(),
+    branch: z.string().nullable(),
+    prUrl: z.string().nullable(),
+    pr: prSnapshot.nullable(),
+    tasks: z.array(homeWorkstreamTask),
+    situations: z.array(situationId),
+    // The board column to place this workstream in, picked server-side from
+    // `situations` by priority. Null when no situation applies.
+    primarySituation: situationId.nullable(),
+    lastActivityAt: z.number(),
+  })
+  .strict();
+export type HomeWorkstream = z.infer<typeof homeWorkstream>;
+
+export const homeSnapshot = z
+  .object({
+    activeAgents: z.array(homeActiveAgent),
+    needsAttention: z.array(homeWorkstream),
+    inProgress: z.array(homeWorkstream),
+  })
+  .strict();
+export type HomeSnapshot = z.infer<typeof homeSnapshot>;
+
+export const EMPTY_HOME_SNAPSHOT: HomeSnapshot = {
+  activeAgents: [],
+  needsAttention: [],
+  inProgress: [],
+};
+
+export const HomeEvent = {
+  // Emitted by HomeService whenever a fresh snapshot differs from the last one.
+  SnapshotUpdated: "snapshotUpdated",
+} as const;
+
+export interface HomeEvents {
+  [HomeEvent.SnapshotUpdated]: HomeSnapshot;
+}
diff --git a/apps/code/src/shared/types/pr-snapshot.ts b/apps/code/src/shared/types/pr-snapshot.ts
new file mode 100644
index 0000000000..a93c33fc62
--- /dev/null
+++ b/apps/code/src/shared/types/pr-snapshot.ts
@@ -0,0 +1,38 @@
+import { z } from "zod";
+
+// Canonical PR snapshot the home tab classifies against. Produced server-side
+// by PostHog and embedded in each workstream of the home snapshot
+// (docs/workflow-architecture.md §5).
+
+export const prSnapshotState = z.enum(["open", "draft", "merged", "closed"]);
+export type PrSnapshotState = z.infer<typeof prSnapshotState>;
+
+export const prCiStatus = z.enum(["passing", "failing", "pending", "none"]);
+export type PrCiStatus = z.infer<typeof prCiStatus>;
+
+export const prReviewDecision = z.enum([
+  "approved",
+  "changes_requested",
+  "review_required",
+]);
+export type PrReviewDecision = z.infer<typeof prReviewDecision>;
+
+export const prSnapshot = z
+  .object({
+    url: z.string(),
+    number: z.number().int().nonnegative(),
+    title: z.string(),
+    state: prSnapshotState,
+    ciStatus: prCiStatus,
+    reviewDecision: prReviewDecision.nullable(),
+    unresolvedThreads: z.number().int().nonnegative(),
+    /** GitHub mergeability: true / false / null when unknown. */
+    mergeable: z.boolean().nullable(),
+    isCurrentUserRequestedReviewer: z.boolean(),
+    isCurrentUserAuthor: z.boolean(),
+    author: z.string().nullable(),
+    /** Epoch ms of the PR's last update on GitHub. */
+    lastUpdatedAt: z.number(),
+  })
+  .strict();
+export type PrSnapshot = z.infer<typeof prSnapshot>;
diff --git a/apps/code/src/shared/types/workflow-validate.test.ts b/apps/code/src/shared/types/workflow-validate.test.ts
new file mode 100644
index 0000000000..02f1be26b3
--- /dev/null
+++ b/apps/code/src/shared/types/workflow-validate.test.ts
@@ -0,0 +1,129 @@
+import { describe, expect, it } from "vitest";
+import type { SituationId, WorkflowAction, WorkflowDraft } from "./workflow";
+import { validateWorkflow } from "./workflow-validate";
+
+function makeAction(overrides: Partial<WorkflowAction> = {}): WorkflowAction {
+  return {
+    id: "action_1",
+    label: "Review",
+    skillId: "review",
+    prompt: "Review the diff",
+    ...overrides,
+  };
+}
+
+function makeDraft(
+  bindings: Partial<Record<SituationId, WorkflowAction[]>>,
+): WorkflowDraft {
+  return {
+    id: "wf_1",
+    version: 1,
+    bindings: bindings as WorkflowDraft["bindings"],
+  };
+}
+
+describe("validateWorkflow", () => {
+  it("accepts a fully populated valid draft", () => {
+    const result = validateWorkflow(
+      makeDraft({
+        working: [makeAction()],
+        in_review: [makeAction({ id: "action_2", label: "Nudge" })],
+      }),
+    );
+    expect(result.canSave).toBe(true);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("accepts an empty draft with no bindings", () => {
+    const result = validateWorkflow(makeDraft({}));
+    expect(result.canSave).toBe(true);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("flags duplicate action ids within the same situation", () => {
+    const result = validateWorkflow(
+      makeDraft({
+        working: [makeAction({ id: "dupe" }), makeAction({ id: "dupe" })],
+      }),
+    );
+    expect(result.canSave).toBe(false);
+    expect(result.diagnostics).toEqual([
+      {
+        severity: "error",
+        code: "duplicate_action_id",
+        message: 'Duplicate action id "dupe" in working',
+        situationId: "working",
+        actionId: "dupe",
+      },
+    ]);
+  });
+
+  it("does not flag the same id reused across different situations", () => {
+    const result = validateWorkflow(
+      makeDraft({
+        working: [makeAction({ id: "shared" })],
+        in_review: [makeAction({ id: "shared" })],
+      }),
+    );
+    expect(result.canSave).toBe(true);
+    expect(result.diagnostics).toEqual([]);
+  });
+
+  it("flags a whitespace-only label", () => {
+    const result = validateWorkflow(
+      makeDraft({ working: [makeAction({ label: "   " })] }),
+    );
+    expect(result.canSave).toBe(false);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0]).toMatchObject({
+      severity: "error",
+      code: "action_empty_label",
+      situationId: "working",
+      actionId: "action_1",
+    });
+  });
+
+  it("flags a whitespace-only prompt", () => {
+    const result = validateWorkflow(
+      makeDraft({ working: [makeAction({ prompt: "  \n " })] }),
+    );
+    expect(result.canSave).toBe(false);
+    expect(result.diagnostics).toHaveLength(1);
+    expect(result.diagnostics[0]).toMatchObject({
+      code: "action_empty_prompt",
+      situationId: "working",
+      actionId: "action_1",
+    });
+  });
+
+  it("reports both empty label and empty prompt for one action", () => {
+    const result = validateWorkflow(
+      makeDraft({ working: [makeAction({ label: " ", prompt: " " })] }),
+    );
+    const codes = result.diagnostics.map((d) => d.code).sort();
+    expect(codes).toEqual(["action_empty_label", "action_empty_prompt"]);
+    expect(result.canSave).toBe(false);
+  });
+
+  it("skips empty-field checks on a duplicate so it is reported once", () => {
+    const result = validateWorkflow(
+      makeDraft({
+        working: [
+          makeAction({ id: "dupe" }),
+          makeAction({ id: "dupe", label: " ", prompt: " " }),
+        ],
+      }),
+    );
+    expect(result.diagnostics.map((d) => d.code)).toEqual([
+      "duplicate_action_id",
+    ]);
+  });
+
+  it("blocks saving only on error-severity diagnostics", () => {
+    const result = validateWorkflow(
+      makeDraft({ working: [makeAction({ label: "" })] }),
+    );
+    expect(result.canSave).toBe(false);
+    expect(result.diagnostics.every((d) => d.severity === "error")).toBe(true);
+  });
+});
diff --git a/apps/code/src/shared/types/workflow-validate.ts b/apps/code/src/shared/types/workflow-validate.ts
new file mode 100644
index 0000000000..cead42d570
--- /dev/null
+++ b/apps/code/src/shared/types/workflow-validate.ts
@@ -0,0 +1,51 @@
+import {
+  SITUATION_IDS,
+  type SituationId,
+  type ValidationDiagnostic,
+  type ValidationResult,
+  type WorkflowDraft,
+} from "./workflow";
+
+export function validateWorkflow(draft: WorkflowDraft): ValidationResult {
+  const diagnostics: ValidationDiagnostic[] = [];
+
+  for (const sid of SITUATION_IDS) {
+    const actions = draft.bindings[sid] ?? [];
+    const seenIds = new Set<string>();
+    for (const action of actions) {
+      if (seenIds.has(action.id)) {
+        diagnostics.push({
+          severity: "error",
+          code: "duplicate_action_id",
+          message: `Duplicate action id "${action.id}" in ${sid}`,
+          situationId: sid as SituationId,
+          actionId: action.id,
+        });
+        continue;
+      }
+      seenIds.add(action.id);
+
+      if (action.label.trim() === "") {
+        diagnostics.push({
+          severity: "error",
+          code: "action_empty_label",
+          message: `An action in ${sid} has no label`,
+          situationId: sid as SituationId,
+          actionId: action.id,
+        });
+      }
+      if (action.prompt.trim() === "") {
+        diagnostics.push({
+          severity: "error",
+          code: "action_empty_prompt",
+          message: `Action "${action.label}" in ${sid} has an empty prompt`,
+          situationId: sid as SituationId,
+          actionId: action.id,
+        });
+      }
+    }
+  }
+
+  const canSave = !diagnostics.some((d) => d.severity === "error");
+  return { diagnostics, canSave };
+}
diff --git a/apps/code/src/shared/types/workflow.ts b/apps/code/src/shared/types/workflow.ts
new file mode 100644
index 0000000000..56f31faa22
--- /dev/null
+++ b/apps/code/src/shared/types/workflow.ts
@@ -0,0 +1,148 @@
+import { z } from "zod";
+
+// Order is load-bearing: the renderer iterates this list to render situations in
+// a stable order. Classification itself runs server-side in PostHog.
+export const SITUATIONS = [
+  {
+    id: "working",
+    label: "Working",
+    description: "Branch with changes, no PR yet",
+  },
+  {
+    id: "in_review",
+    label: "In review",
+    description: "PR open, nothing pending from you",
+  },
+  {
+    id: "ci_failing",
+    label: "CI failing",
+    description: "PR open, CI is red",
+  },
+  {
+    id: "changes_requested",
+    label: "Changes requested",
+    description: "A reviewer requested changes",
+  },
+  {
+    id: "comments_waiting",
+    label: "Comments waiting",
+    description: "Unresolved review threads not from you",
+  },
+  {
+    id: "ready_to_merge",
+    label: "Ready to merge",
+    description: "PR open, CI green, approved, mergeable",
+  },
+  {
+    id: "stale",
+    label: "Stale",
+    description: "No activity for a while",
+  },
+  {
+    id: "done",
+    label: "Done",
+    description: "PR merged or closed",
+  },
+] as const;
+
+export type SituationId = (typeof SITUATIONS)[number]["id"];
+export const SITUATION_IDS = SITUATIONS.map((s) => s.id) as [
+  SituationId,
+  ...SituationId[],
+];
+
+export const situationId = z.enum(SITUATION_IDS);
+
+export const workflowAction = z
+  .object({
+    id: z.string().min(1).max(64),
+    label: z.string().min(1).max(120),
+    skillId: z.string(),
+    prompt: z.string().min(1).max(8_000),
+    adapter: z.enum(["claude", "codex"]).optional(),
+    model: z.string().min(1).optional(),
+  })
+  .strict();
+export type WorkflowAction = z.infer<typeof workflowAction>;
+
+export const workflowBindings = z.record(situationId, z.array(workflowAction));
+export type WorkflowBindings = z.infer<typeof workflowBindings>;
+
+export const workflowConfig = z
+  .object({
+    id: z.string().min(1),
+    version: z.number().int().nonnegative(),
+    updatedAt: z.string(),
+    bindings: workflowBindings,
+  })
+  .strict();
+export type WorkflowConfig = z.infer<typeof workflowConfig>;
+
+export const workflowDraft = workflowConfig
+  .omit({ updatedAt: true })
+  .extend({ updatedAt: z.string().optional() });
+export type WorkflowDraft = z.infer<typeof workflowDraft>;
+
+export const validationDiagnostic = z
+  .object({
+    severity: z.enum(["error", "warning"]),
+    code: z.enum([
+      "duplicate_action_id",
+      "action_empty_prompt",
+      "action_empty_label",
+    ]),
+    message: z.string(),
+    situationId: situationId.optional(),
+    actionId: z.string().optional(),
+  })
+  .strict();
+export type ValidationDiagnostic = z.infer<typeof validationDiagnostic>;
+
+export const validationResult = z
+  .object({
+    diagnostics: z.array(validationDiagnostic),
+    canSave: z.boolean(),
+  })
+  .strict();
+export type ValidationResult = z.infer<typeof validationResult>;
+
+export const saveInput = z
+  .object({
+    config: workflowDraft,
+    expectedVersion: z.number().int().nonnegative(),
+  })
+  .strict();
+export type SaveInput = z.infer<typeof saveInput>;
+
+export const saveResult = z.discriminatedUnion("status", [
+  z
+    .object({
+      status: z.literal("saved"),
+      config: workflowConfig,
+      diagnostics: z.array(validationDiagnostic).optional(),
+    })
+    .strict(),
+  z
+    .object({
+      status: z.literal("conflict"),
+      config: workflowConfig.optional(),
+      diagnostics: z.array(validationDiagnostic).optional(),
+    })
+    .strict(),
+  z
+    .object({
+      status: z.literal("invalid"),
+      config: workflowConfig.optional(),
+      diagnostics: z.array(validationDiagnostic).optional(),
+    })
+    .strict(),
+]);
+export type SaveResult = z.infer<typeof saveResult>;
+
+export const WorkflowEvent = {
+  Changed: "changed",
+} as const;
+
+export interface WorkflowEvents {
+  [WorkflowEvent.Changed]: WorkflowConfig;
+}
diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.md
index 2f085463ad..2bd1119024 100644
--- a/docs/TROUBLESHOOTING.md
+++ b/docs/TROUBLESHOOTING.md
@@ -97,6 +97,30 @@ cd apps/code && npx electron-rebuild -f
 
 Then restart the app.
 
+### If `electron-rebuild` itself crashes
+
+The rebuild above can die before it compiles anything, with a stack trace inside yargs:
+
+```
+ReferenceError: require is not defined in ES module scope, you can use import instead
+    at file:///.../node_modules/yargs/yargs:3:69
+```
+
+This happens when the hoisted `@electron/rebuild` resolves to a stale major whose yargs CLI no longer loads (`apps/code` wants `^4`; check yours with `node -p "require('./node_modules/@electron/rebuild/package.json').version"`). Because the rebuild line in `apps/code/scripts/postinstall.sh` ends in `|| true`, the failure is swallowed and the binary is never built.
+
+Compile `better-sqlite3` directly with `node-gyp` against the Electron headers, which sidesteps the broken CLI:
+
+```bash
+ELECTRON_VERSION="$(node -p "require('./node_modules/electron/package.json').version")"
+cd node_modules/better-sqlite3
+npx node-gyp rebuild --release \
+  --arch="$(node -p process.arch)" \
+  --target="$ELECTRON_VERSION" \
+  --dist-url=https://electronjs.org/headers
+```
+
+The ABI comes from the Electron headers (`--target` plus `--dist-url`), not your system Node, so the binary gets the right `NODE_MODULE_VERSION` even when the two differ. It lands at `node_modules/better-sqlite3/build/Release/better_sqlite3.node`. Restart the app.
+
 ## node-gyp failed to rebuild @parcel/watcher
 
 If you see this error after pulling or switching branches:
diff --git a/docs/home-tab.md b/docs/home-tab.md
new file mode 100644
index 0000000000..62af37a8a4
--- /dev/null
+++ b/docs/home-tab.md
@@ -0,0 +1,549 @@
+# Home tab
+
+## 1. Summary
+
+A new **Home** sidebar tab that helps users reach inbox zero on code work. Home aggregates PRs, branches, and worktrees into *workstreams* and surfaces only the items that need the user's attention right now — things that are not already obvious from the existing task list.
+
+The existing task panel already shows what your agents are doing (in-flight, failed, cancelled, needing permission). Home does **not** duplicate that. Home is about everything that happens *around* an agent task — the PR it produced, the comments people left on it, the CI that's failing, the branch that never got a PR, the review someone is waiting on you for.
+
+Home should answer:
+
+- What's running right now? (glanceable strip — no detail)
+- What needs me to do something so this work can ship?
+- What's stale and should be picked up, closed, or cleaned up?
+- Which PRs have feedback, failing checks, or are waiting on my review?
+
+## 2. Goals
+
+1. **One surface for "what needs me"** — PR feedback, failing CI, review requests, stale branches, ready-to-merge PRs.
+2. **Inbox-zero shape** — only render rows the user can act on now; snooze and mute reduce the list; no endless feed.
+3. **Agent-native actions** — primary actions kick off new tasks with the right skill (review, fix CI, address comments).
+4. **Don't duplicate the task list** — running and failed agent runs surface as a compact strip, not as attention rows.
+5. **Three views of the same data** — a triage **list** (severity-first), a workflow **board** (stage-first kanban), and a **config** canvas where the user models the workflow that the other two views derive from. Same workstream model, three renderings.
+6. **User-configurable workflow** — list sections and board columns are *not* hardcoded for the long run. The user defines the pipeline (steps, conditions, agents attached at each step) on the Config canvas; List and Board are projections of that configuration over the live `HomeSnapshot`. A built-in default workflow matches the v1 hardcoded spec so the feature ships useful on day one.
+7. **Host-agnostic architecture** — all aggregation, workflow persistence, and classification in main services; renderer is dumb (yes, even the canvas).
+
+## 3. Non-goals (v1)
+
+- Full Git client or repo browser.
+- Re-surfacing what the task panel already shows (running runs, failed runs, agents needing permission).
+- Cross-org reporting or an "all users" view.
+- Destructive cleanup automation.
+- Mirroring GitHub's notifications inbox.
+- Slack-origin signals or signal reports with no branch/PR yet — Inbox already handles those.
+
+## 4. Sidebar & navigation
+
+**Sidebar order:** New task, **Home**, Search, Inbox, Skills, MCP Servers, Command Center, task list.
+
+**Default landing view:** Home if the user has ≥1 workspace, otherwise New task.
+
+**Implementation:**
+
+- Add `"home"` to `ViewType` in `apps/code/src/renderer/stores/navigationStore.ts:24`.
+- Add `navigateToHome` action.
+- **Rename** existing `apps/code/src/renderer/features/sidebar/components/items/HomeItem.tsx` (which currently exports `NewTaskItem` and `InboxItem`) before this feature lands. New `HomeItem.tsx` owns the Home sidebar entry.
+- Add a `Home` arm to the view switch in `apps/code/src/renderer/components/MainLayout.tsx`.
+- Keep using the existing `navigationStore`; no second router introduced.
+
+## 5. Core model
+
+```ts
+type HomeSnapshot = {
+  generatedAt: string
+  summary: { needsAttention: number; inProgress: number; watching: number }
+  activeAgents: ActiveAgentSummary[]    // compact strip; see §6
+  workstreams: HomeWorkstream[]
+}
+
+type HomeWorkstream = {
+  id: string                    // PR URL → repo#branch → worktreePath → taskId
+  repository: { path?: string; owner: string; name: string } | null
+  branch: string | null
+  baseBranch: string | null
+  pr: HomePullRequest | null
+  tasks: HomeTaskSummary[]      // sorted newest first; count shown, latest expanded
+  attention: HomeAttentionItem[]
+  state: "attention" | "in_progress" | "watching"
+  lastActivityAt: string
+  lastUserViewedAt: string | null
+}
+
+type HomeAttentionItem = {
+  id: string
+  kind:
+    | "pr_review_requested"
+    | "pr_comments"
+    | "pr_ci_failed"
+    | "pr_ready_to_merge"
+    | "stale_no_pr"
+    | "branch_cleanup"
+  severity: "critical" | "attention" | "quiet"
+  source: "git" | "github"
+  title: string                 // "CI failed on test:e2e"
+  detail: string                // one-line context
+  primaryActionId: string
+  secondaryActionIds: string[]
+  snoozedUntil: string | null
+  mutedAt: string | null        // cleared on next state change
+  mutedAtSha: string | null     // anchor for "next change" detection
+}
+
+type HomePullRequest = {
+  url: string; number: number; title: string
+  state: "open" | "draft" | "merged" | "closed"
+  mergeable: boolean | null
+  ciStatus: "passing" | "failing" | "pending" | "none"
+  unresolvedThreads: number
+  newCommentsSinceViewed: number
+  reviewDecision: "approved" | "changes_requested" | "review_required" | null
+  isCurrentUserRequestedReviewer: boolean
+  isCurrentUserAuthor: boolean
+  lastUpdatedAt: string
+}
+
+type ActiveAgentSummary = {
+  taskId: string
+  taskRunId: string
+  title: string
+  branch: string | null
+  prUrl: string | null
+  startedAt: string
+  // Status comes directly from TaskRun; no Home-side classification.
+  status: "queued" | "in_progress"
+}
+```
+
+### Workflow configuration model
+
+The Config canvas persists a `WorkflowConfig` that the List and Board views project over the snapshot. The model lives in main; the renderer reads it via tRPC. A built-in default `WorkflowConfig` (matching the §6.3 hardcoded board columns) ships with the app and is used until the user customises it.
+
+```ts
+type WorkflowConfig = {
+  id: string
+  version: number              // bumps on every save; enables optimistic concurrency
+  updatedAt: string
+  nodes: WorkflowNode[]
+  edges: WorkflowEdge[]
+  layout: Record<NodeId, { x: number; y: number }>  // canvas positions, opaque to main
+}
+
+type WorkflowNode =
+  | { id: NodeId; kind: "input"; label: string; inputType: "pr_url" | "branch" | "task_prompt" }
+  | { id: NodeId; kind: "task"; label: string; skillId: string | null }
+  | { id: NodeId; kind: "step"; label: string; match: WorkflowMatch; agents: AgentBinding[] }
+  | { id: NodeId; kind: "queue"; label: string; queueKind: "stale" | "merge" | "cleanup"; match: WorkflowMatch; agents: AgentBinding[] }
+  | { id: NodeId; kind: "branch"; label: string; condition: WorkflowCondition }
+  | { id: NodeId; kind: "terminal"; label: string; terminalKind: "merged" | "closed" | "archived" }
+
+type WorkflowEdge = {
+  id: EdgeId
+  from: NodeId
+  to: NodeId
+  // Edge fires when the source node's condition resolves to this case (e.g. "ci_failed", "approved").
+  whenCase: string | null
+}
+
+// Declarative predicate; main evaluates it against a HomeWorkstream.
+type WorkflowMatch = {
+  hasPr?: boolean
+  prState?: ("open" | "draft" | "merged" | "closed")[]
+  ciStatus?: ("passing" | "failing" | "pending" | "none")[]
+  reviewDecision?: ("approved" | "changes_requested" | "review_required")[]
+  hasUnresolvedComments?: boolean
+  isStale?: { olderThanHours: number }
+  // Extend as needed; the renderer never interprets this directly.
+}
+
+type WorkflowCondition =
+  | { kind: "ci_status" }       // cases: "passing" | "failing" | "pending"
+  | { kind: "review_decision" } // cases: "approved" | "changes_requested" | "review_required"
+  | { kind: "pr_state" }        // cases: "open" | "draft" | "merged" | "closed"
+
+type AgentBinding = {
+  id: string
+  label: string                 // "Fix CI", "Address comments"
+  skillId: string               // resolved against the skills registry in main
+  promptTemplate: string        // mustache-style; main fills `{{prUrl}}`, `{{branch}}`, etc.
+  trigger: "primary" | "secondary" | "auto"  // "auto" runs as soon as a workstream lands in this node
+}
+```
+
+**Classification (main only).** `HomeService` walks each workstream against the workflow's nodes in declaration order and assigns it to the first matching `step` / `queue` node. The result is a `nodeId` per workstream, stored on the snapshot — the renderer never re-evaluates predicates. This keeps `WorkflowMatch` as a private main-side language.
+
+**Workstream grouping key precedence:** PR URL → `repo + branch` → worktree path → task id.
+
+**Note: no `run_failed` or `agent_needs_input` kinds.** Failed runs, cancelled runs, and runs awaiting permission are already obvious in the task panel. Home does not surface them as attention rows. If they materially affect downstream state (e.g. a failed run left a branch with no PR for >24h), the *branch* surfaces as `stale_no_pr` — the user-facing reason, not the agent-side cause.
+
+## 6. UI layout
+
+Home renders three views over the same `HomeSnapshot` + active `WorkflowConfig`. The user picks one with a persistent toggle in the header; data, actions, and empty states are consistent across views — only the layout and density differ.
+
+- **List view (default)** — triage-first. Two sections (Needs attention / In progress) sorted by severity and recency. Best for "what should I do next?".
+- **Board view** — workflow-first kanban. One column per `step`/`queue` node in the active workflow, left → right. Best for "where is everything in the pipeline?".
+- **Config view** — drag-and-drop canvas where the user authors the workflow that List and Board project over. Best for "how does *my* work actually flow?".
+
+A piece of work belongs to a single bucket in list/board: the list assigns it to a *section* by severity, the board assigns it to a *column* by the workflow node it matched. Same `HomeWorkstream`, two derivations of the same workflow.
+
+### 6.1 Shared chrome (both views)
+
+**Header:** title `Home`, summary line (`3 need attention · 2 running · 4 watching`), repo chip (default: current repo), **view toggle** (`List` / `Board`), refresh button.
+
+**Strip — Active agents.** Horizontal, compact, glanceable. One small card per `in_progress` or `queued` TaskRun.
+
+- Task title, branch chip, elapsed timer, skill icon.
+- Click → opens the task detail view (same as clicking it in the task panel).
+- This strip is **information, not attention**. It never gets a count badge, never blocks empty state. Hidden entirely when no agents are running.
+- The strip lives at the top in **both** views. Agents are a transient activity feed; workstreams are persistent. They run on different timescales, so they don't share visual real estate with the buckets.
+
+**Detail pane** (two-pane, like Inbox): workstream header → PR header (state, CI, reviewers) → attached task runs (clickable to their detail view) → unresolved comments preview → action bar (`SkillButtonsMenu` shape). The detail pane is shared between views — selecting a row in list or a card on the board opens the same panel.
+
+**Keyboard:** `j`/`k` move, `Enter` primary action, `s` snooze, `m` mute, `o` open in browser, `r` refresh, `v` toggle list/board.
+
+**Empty states:**
+
+- Zero attention, no agents running: "You're caught up." + summary chips.
+- Zero attention, agents running: strip is visible, sections/columns empty + "Everything else is healthy."
+- No GitHub auth: degraded mode (local Git signals only) + CTA to connect.
+- No workspaces: redirect to New task.
+
+### 6.2 List view
+
+**Section 1 — Needs attention.** Only rows where `state === "attention"`. Sorted by severity, then last activity. Multiple attention items on one workstream stack as chips on the row; top-severity drives the primary action.
+
+**Section 2 — In progress.** Workstreams with recent activity but no outstanding attention item (e.g. PR open, draft, CI green, no comments waiting on you). Collapsed by default when Section 1 is non-empty.
+
+**Section 3 — Watching.** *Not a section — a counter pill in the header.* Click expands an overlay: snoozed items, PRs awaiting external reviewers, items in pending CI. Never a default list of rows.
+
+**Row anatomy.**
+
+- Left: workstream title (PR title or branch), repo+branch metadata, attention chips.
+- Middle: PR state pill (open/draft/merged), CI dot, task-run count if >1.
+- Right: primary action button (split-button with overflow), timestamp.
+- Severity-tinted left border: red (critical) / amber (attention) / none (quiet).
+
+### 6.3 Board view
+
+**Columns are workflow-derived.** One column per `step` / `queue` node in the active `WorkflowConfig`, ordered by topological-sort over the edges (left = inputs, right = terminals). The mapping `workstream → column` is the `nodeId` already assigned by `HomeService` (see §5 Classification); the renderer does *not* re-evaluate predicates.
+
+**Default workflow (shipped pre-customisation):**
+
+| Column | Backing node | Contains | Empty placeholder |
+|---|---|---|---|
+| **No PR yet** | step `no_pr` | `stale_no_pr`; or any workstream with a branch but no PR and no other attention | "Nothing here" |
+| **In review** | step `in_review` | PR open or draft with no attention items — awaiting external reviewer or CI | "Nothing here" |
+| **Needs me** | step `needs_me` | `pr_ci_failed`, `pr_comments`, `pr_review_requested` | "Nothing here" |
+| **Ready to merge** | queue `merge_queue` | `pr_ready_to_merge` | "Nothing here" |
+| **Cleanup** | queue `cleanup` | `branch_cleanup` | "Nothing here" |
+
+A workstream belongs to exactly one column — the first node whose `match` predicate it satisfies, walked in declaration order. The default config encodes today's resolution order (`cleanup` → `merge_queue` → `needs_me` → `no_pr` → `in_review`). Once the user edits the workflow in the Config view, this default is replaced; the renderer doesn't know or care.
+
+**Card anatomy** (denser than a row):
+
+- Title (line-clamp-2), CI status icon top-right.
+- Repo, branch chip, PR `#number`, relative time.
+- Attention chips (abbreviated: `Review` / `CI` / `Feedback` / `Mergeable` / `Stale` / `Cleanup`).
+- Author chip when it's someone else's PR (`by @user`).
+- Review decision line ("Changes requested" / "Approved") when relevant.
+- One-line summary from the top attention.
+- Primary action button + task count if >1.
+- Severity-tinted left border, same colour scheme as the list rows.
+
+**Empty columns render a dashed "Nothing here" placeholder.** Important for kanban scanning — the user should be able to glance and see *which stage is empty*, not just *which stage is full*.
+
+**Why kanban as well as list:** PRs move through a fixed workflow. The list is great when you're doing inbox-zero triage ("what should I act on first?"). The board is great when you're doing a status review ("how many things are stuck in review? what's about to ship?"). Same data, different question.
+
+### 6.4 Config view
+
+A drag-and-drop canvas where the user models their workflow. The canvas is the *only* heavy frontend surface in Home; everything that touches data still goes through main per R1/R2.
+
+**What you can build.**
+
+- **Input nodes** — entry points for new work. Examples: "Paste a PR URL", "Start from a task prompt", "Pick a branch". When the user triggers an input, it creates or attaches a workstream.
+- **Task nodes** — kick off a new agent task with a chosen skill. Used as starting nodes (user-initiated) or as transition handlers (the next-step agent in a chain).
+- **Step nodes** — workflow stages a workstream sits in (e.g. `In review`, `Needs me`). Each step has a `match` predicate and zero-or-more `AgentBinding`s that surface as quick actions on the List/Board row when a workstream lands there.
+- **Queue nodes** — like steps but visually distinct on the board (e.g. `Stale queue`, `Merge queue`, `Cleanup`). Same predicate model.
+- **Branch nodes** — split the flow by a condition (e.g. `CI status` → `passing` / `failing` / `pending`). Outgoing edges declare which case they handle via `whenCase`.
+- **Terminal nodes** — `merged`, `closed`, `archived`. Workstreams that match a terminal disappear from List/Board.
+
+**Worked example (matches the user's brief):**
+
+```
+[Input: PR URL]                                  ┐
+                                                  ├──► [Step: PR open]──► [Branch: CI status]
+[Task: "Create a PR" (skill: create-pr)] ──────────                              │
+                                                                                 ├─ failing ──► [Step: Needs me] ─► [Agent binding: "Fix CI"]
+[Step: No PR yet] ──► [Branch: PR exists?]                                       │
+                       └─ no ──► [Queue: Stale queue]                            ├─ pending ──► [Step: In review]
+                                                                                 │
+                                                                                 └─ passing ──► [Branch: review_decision]
+                                                                                                  ├─ changes_requested ──► [Step: Needs me] ─► [Agent: "Address comments"]
+                                                                                                  ├─ review_required   ──► [Step: In review]
+                                                                                                  └─ approved          ──► [Queue: Merge queue] ─► [Terminal: merged]
+```
+
+The board renders one column per step/queue node in the order above; the list renders the same nodes as severity-banded sections (severity inferred from each node's attention kinds).
+
+**Canvas UI behaviour.**
+
+- Pan / zoom / fit-to-content; minimap toggle.
+- Sidebar palette of node types — drag onto canvas to add.
+- Click a node → inspector panel on the right: label, match predicate builder, attached `AgentBinding`s (skill picker + prompt template editor with `{{prUrl}}` / `{{branch}}` / `{{failingChecks}}` placeholders).
+- Click an edge → set `whenCase` from the source branch node's case list.
+- Validation surfaces inline: orphan nodes, unreachable terminals, duplicate `whenCase` on a branch's outgoing edges, predicates that overlap a higher-priority node. Validation runs in main (the canvas only renders the diagnostics).
+- **Save model: explicit, not auto.** A dirty banner appears once the user changes anything; "Save" submits the whole workflow; "Discard" reverts to the persisted version. No silent autosave — workflow edits drive every other Home surface, so an accidental save would be loud.
+- Versioned saves with optimistic concurrency: if the persisted `version` has advanced (e.g. another window edited it), the save mutation rejects and the canvas offers reload or force-overwrite.
+
+**Architecture (heavy frontend, but the rules still hold).**
+
+Per R1 / R2 / R3: even though the canvas is the most visually expensive surface in the app, no business logic lives in the renderer.
+
+- **`WorkflowService` (main).** Thin authenticated client over `/code_workflow/*`: reads/writes the canonical `WorkflowConfig` and emits `workflow.onChanged`. The config endpoint is the only source of truth — load failures propagate so the canvas can show an offline/error state, never a fabricated config. Persistence, version bumps, validation, the default seed, and classification all live server-side in PostHog.
+- **tRPC `workflow.*` router (main).** One-liners only: `workflow.get` (query, returns `WorkflowConfig`), `workflow.save` (mutation, `{ config, expectedVersion }` → new version or `ConflictError`), `workflow.resetToDefault` (mutation), `workflow.onChanged` (subscription, `WorkflowConfig` diff stream).
+- **`useWorkflow` (renderer hook).** Single `useQuery` against `workflow.get`, kept fresh by the subscription registrar in `features/home/subscriptions.ts` per R9. No multi-query orchestration in the hook.
+- **`workflowEditorStore` (renderer Zustand, R2-clean).** Holds *only* uncommitted edit state: `viewport: { x, y, zoom }`, `selectedNodeId`, `selectedEdgeId`, `draftConfig` (deep-clone of the persisted config the moment editing starts), `dirty`, `validationErrors` (fed from main on each draft change via `workflow.validateDraft`). The persisted `WorkflowConfig` is *not* in this store — it's the `useQuery` result. Save action is one `useMutation` call; the store's job ends there.
+- **`workflowCanvasService` (renderer service, R3 escape hatch).** Drag-and-drop coordinator, snap-to-grid maths, hit-testing, edge-routing — the exact "non-trivial renderer-only UI mechanic shared across components" R3 carves out. No data fetching, no cross-store reach-ins.
+- **Components (`features/home/config/`).** `ConfigCanvas.tsx`, `NodePalette.tsx`, `NodeInspector.tsx`, `EdgeInspector.tsx`, `ValidationBanner.tsx`. Components consume the `useWorkflow` query for the persisted state and the editor store for the draft.
+- **Cross-feature coordination (R5).** `WorkflowService` emits `WorkflowChanged`; `HomeService` reacts by re-classifying and pushing a new `home.onSnapshotUpdated` frame. The renderer's List and Board re-render off the new snapshot. No store ever reaches across to another store.
+- **Library choice.** Use [`@xyflow/react`](https://reactflow.dev/) for the canvas primitive (pan / zoom / nodes / edges / minimap). It's the lightest mainstream option and the canvas state it owns is fine to keep local-to-component — we don't lift its internal state into the store. Wrap it once so the renderer service can layer our snap/validation behaviour.
+
+**Empty / new-user state.** Until the user touches Config, they see the default workflow on the canvas (read-only outline + "Customise" CTA). After customisation, "Reset to default" is always one click away in the header.
+
+**Keyboard:** `Cmd+S` save, `Cmd+Z` / `Cmd+Shift+Z` undo/redo within the draft, `Delete` / `Backspace` remove selected node or edge, `Esc` clears selection, `v` exits to last non-config view.
+
+### 6.5 View persistence
+
+The user's choice persists across sessions via `homeUiStore.viewMode: "list" | "board" | "config"`. Default for new users is `list` (the inbox-zero shape we open with). Toggle is keyboard-accessible (`v` cycles `list → board → config → list`).
+
+## 7. Data sources
+
+The snapshot is assembled **server-side in PostHog** (`products/tasks/`, see
+[docs/workflow-architecture.md](./workflow-architecture.md)) — the Electron app
+reads the finished snapshot over the REST API and renders it; it does not
+aggregate these sources itself.
+
+| Source | Data |
+|---|---|
+| Tasks / task runs | status, branch, PR URL; the live active-agent set |
+| GitHub PR metadata | title, state, draft, mergeable, CI rollup, review decision, unresolved threads, requested reviewers |
+| GitHub review requests | PRs where the current user is a requested reviewer |
+
+Snooze / mute / viewed (`home_attention_state`) is not implemented yet — see
+[docs/workflow-architecture.md](./workflow-architecture.md) §4.
+
+## 8. Architecture
+
+The data layer — workstream grouping, PR polling, and situation classification —
+runs **server-side in PostHog** (`products/tasks/`, a Temporal worker). The
+Electron app is a thin authenticated client. Full server design and wire shapes:
+[docs/workflow-architecture.md](./workflow-architecture.md).
+
+**Main (`apps/code/src/main/`)** — thin clients over the REST API, no local
+persistence and no `gh` polling:
+
+- `services/home/service.ts` (`HomeService`) — polls `GET /code_home/` and emits `home.onSnapshotUpdated` when the snapshot changes.
+- `services/workflow/service.ts` (`WorkflowService`) — reads/writes the workflow config via `/code_workflow/*` and emits `workflow.onChanged`; load failures propagate so the canvas shows an offline/error state rather than a fabricated config.
+- `services/auth/service.ts` (`authenticatedProjectFetch`) — the project-scoped authenticated fetch both services share.
+- tRPC routers (`trpc/routers/home.ts`, `trpc/routers/workflow.ts`) — one-liners over the two services: `home.getSnapshot` / `home.refresh` / `home.onSnapshotUpdated`, and `workflow.get` / `workflow.save` / `workflow.resetToDefault` / `workflow.onChanged`.
+
+Wire shapes (Zod, the shared source of truth for the renderer types):
+`shared/types/home-snapshot.ts`, `shared/types/workflow.ts`,
+`shared/types/pr-snapshot.ts`.
+
+**Renderer (`apps/code/src/renderer/features/home/`)**
+
+- `components/` — `HomeView`, `HomeActiveAgentsStrip`, `HomeWorkstreamRow`, `HomeWorkstreamCard`, `HomeBoardView`, `HomeWorkstreamDetailPanel`, `HomeEmptyState`.
+- `config/` — the workflow editor (`ConfigMap` and friends).
+- `utils/boardColumns.ts` — pure projection of the snapshot into board columns. No I/O, no React.
+- `hooks/useHomeSnapshot.ts`, `hooks/useWorkflow.ts` — one `useQuery` each, kept fresh by `subscriptions.ts` (registered once at boot per R9).
+- `stores/homeUiStore.ts` — UI state only (view mode, selection). `stores/workflowEditorStore.ts` — the uncommitted editor draft only.
+
+Situation classification is authoritative on the server, including the
+`primarySituation` (the priority pick used for board column placement and
+accents) which arrives on each workstream in the snapshot. The renderer never
+re-derives situations or the primary from PR state — it reads `primarySituation`
+directly and uses `situations` only to render the extra chips.
+
+**Rules honoured:** R1 (main owns the client + orchestration), R2 (stores are UI state + subscription caches only), R4 (one `useQuery` per surface), R5 (main emits `workflow.onChanged`; Home reacts via its subscription registrar), R6 (Zod everywhere, inferred types), R9 (subscriptions registered once at boot), R10 (router one-liners).
+
+## 9. PR data
+
+PR metadata (state, draft, mergeable, CI rollup, review decision, unresolved
+threads, requested reviewers) is fetched **server-side** by the PostHog worker
+via `GitHubIntegration.get_pull_request_snapshot` — the Electron app does not
+poll `gh` for the home tab. The serialised shape is `PrSnapshot`
+(`shared/types/pr-snapshot.ts`).
+
+## 10. Polling & rate-limit strategy
+
+- **Server worker** keeps PR snapshots fresh: a Temporal schedule fans out a per-team evaluation every ~3 min that polls each tracked PR (GitHub GraphQL via the team integration, rate-limit aware) and rebuilds the workstreams.
+- **Client** just pulls the latest snapshot: `HomeService` polls `GET /code_home/` on a fixed cadence and emits `home.onSnapshotUpdated` on change; `home.refresh` triggers an on-demand server evaluation. No `gh` calls, no rate-limit handling in the app.
+- Active agents stream from the existing cloud-task SSE, not from polling.
+
+## 11. Classification & ranking
+
+**Attention kinds → severity:**
+
+| Kind | Severity |
+|---|---|
+| `pr_ci_failed` | critical |
+| `pr_review_requested` (on me) | attention |
+| `pr_comments` (unresolved, not by me) | attention |
+| `pr_ready_to_merge` | attention |
+| `stale_no_pr` | quiet |
+| `branch_cleanup` (merged/closed but worktree lingering) | quiet |
+
+**Stale thresholds (constants in `home/service.ts`):**
+
+- Completed run with diff on a branch and no PR: 24h → `stale_no_pr`.
+- Branch/worktree with no activity and no PR: 3 days → `stale_no_pr` (escalated severity).
+- Merged/closed PR with worktree still around: 1 day → `branch_cleanup`.
+
+**Row ordering inside "Needs attention":** severity → ownership (mine first) → staleness → `lastActivityAt`.
+
+## 12. Actions (registry-driven)
+
+| Situation | Primary | Secondary |
+|---|---|---|
+| `stale_no_pr` | Create PR | Resume with agent, Open changes, Archive |
+| `pr_ci_failed` | Fix CI with agent | Open checks, Open PR |
+| `pr_comments` | Address comments with agent | Open review thread, Open PR |
+| `pr_review_requested` | **Review with agent** | Open PR, Snooze |
+| `pr_ready_to_merge` | Open PR | Ask agent for final check |
+| `branch_cleanup` | Archive task & worktree | Open PR |
+
+Agent actions prefill the task input with structured context (PR URL, branch, failing-check summary, unresolved-comment list, suggested skill id) and reuse `TaskCreationSaga` + `sendPromptToAgent`.
+
+Action descriptors are data, not hardcoded buttons. The registry maps `actionId → { label, icon, run: (workstream) => Effect }` and lives in `HomeService` so it remains serializable across the IPC boundary.
+
+## 13. The code-review skill (keystone, ships with M3)
+
+The existing `code-review` feature in `apps/code/src/renderer/features/code-review/` only handles *responding* to PR comments inside an active task. We need a new marketplace skill `code-review` that:
+
+- Takes a PR URL as input.
+- Checks out the PR into a fresh worktree.
+- Runs a structured review: scope, risk areas, tests, security, style.
+- Posts a single review with inline comments via `gh pr review`.
+- Lives at `apps/code/skills/code-review/` so it loads through the existing `readSkillMetadataFromDir` discovery.
+
+This is a blocker for M3, not an open question.
+
+## 14. Snooze, mute, viewed
+
+- **Snooze** — hide until `now + N hours`. Default 24h; options 1h/4h/1d/3d.
+- **Mute** — hide until the underlying state changes (new commit on the branch, new comment, CI flip, reviewer change). Cleared automatically by `HomeService` when the watermark moves.
+- **markViewed** — updates `lastUserViewedAt`; powers `pr.newCommentsSinceViewed`.
+
+Persistence (`home_attention_state`) is server-side and not implemented yet — see [docs/workflow-architecture.md](./workflow-architecture.md) §4.
+
+## 15. Analytics events
+
+- `home_viewed` (viewMode: list | board)
+- `home_view_mode_changed` (from, to)
+- `home_attention_action_clicked` (kind, actionId, viewMode)
+- `home_attention_snoozed` (kind, durationHours)
+- `home_attention_muted` (kind)
+- `home_action_started_task` (kind, skillId)
+- `home_refresh_requested` (reason: manual | visible | poll)
+- `home_active_agent_clicked` (taskId)
+- `home_config_opened`
+- `home_config_workflow_saved` (nodeCount, edgeCount, agentBindingCount, version)
+- `home_config_workflow_reset_to_default`
+- `home_config_node_added` (nodeKind)
+- `home_config_validation_blocked_save` (errorCount)
+
+Follow naming conventions in `docs/conventions.md`.
+
+## 16. Phasing
+
+### M1 — Skeleton (no new I/O)
+
+- Home route, sidebar entry, view scaffold.
+- `HomeService.getSnapshot` built from existing `useTasks` data + `WorkspaceService` state piped to main.
+- **Active agents strip** wired to existing `CloudTaskService` stream (zero new infra).
+- Kinds that work without new `gh` calls: `stale_no_pr`.
+- **List and board ship together with the built-in default workflow.** No editor yet. The board reads the built-in default `WorkflowConfig` (`workflow/default-workflow.ts`); no server round-trip needed at this stage. Column projection lives in `utils/boardColumns.ts`.
+- Ships visible value immediately and validates the layout.
+
+### M2 — PR enrichment
+
+- Server-side PR enrichment: the worker polls each tracked PR and serialises a `PrSnapshot`.
+- New kinds: `pr_ci_failed`, `pr_comments`, `pr_ready_to_merge`, `branch_cleanup`.
+- PR row UI; refresh button.
+
+### M3 — Reviewer flow + code-review skill
+
+- `pr_review_requested` kind (PRs where the user is a requested reviewer).
+- **Ship the `code-review` skill in this same milestone.**
+- "Review with agent" action wired through `TaskCreationSaga`.
+
+### M4 — Inbox-zero controls
+
+- Snooze, mute, `lastUserViewedAt`, keyboard shortcuts (`j`/`k`/`s`/`m`/`Enter`).
+- Server-side `home_attention_state` for snooze/mute/viewed.
+
+### M5 — Config canvas (workflow editor)
+
+- `WorkflowService` client + server-side workflow config persistence (`code_workflow/*`); the default workflow is seeded server-side on first read.
+- `workflow.*` tRPC router with Zod schemas.
+- Renderer: `ConfigCanvas`, palette, inspectors, validation banner.
+- `workflowEditorStore` + `workflowCanvasService` (R3 escape hatch).
+- `WorkflowChanged` event flow into `HomeService` so List/Board re-render on save.
+- Agent bindings on step/queue nodes drive primary/secondary actions in the action registry (replaces the M2 hardcoded action table).
+- View toggle becomes three-way; `v` keyboard cycle updated.
+
+### M6 — Polish
+
+- Multi-repo chip, GitHub integration toggle.
+- Optional native notifications on critical kinds (opt-in).
+- Settings (stale thresholds, polling cadence).
+- Workflow templates (share-and-import a `WorkflowConfig` JSON).
+
+## 17. Implementation checklist
+
+**M1–M4 (List + Board with built-in default workflow):**
+
+- [ ] Rename existing `HomeItem.tsx` to free the filename.
+- [ ] Add `home` to `ViewType` + `navigateToHome`.
+- [ ] Scaffold `HomeService` (REST client), schemas, router, DI token, root router wiring.
+- [ ] Add the built-in default `WorkflowConfig` (`workflow/default-workflow.ts`); `WorkflowService` falls back to it when offline.
+- [ ] Server-side `home_attention_state` for snooze/mute/viewed.
+- [ ] `HomeService` poll loop → `home.onSnapshotUpdated`, kept fresh by the subscription registrar.
+- [ ] M2: server-side PR enrichment; `home.refresh` triggers an on-demand evaluation.
+- [ ] M3: `code-review` skill in `apps/code/skills/code-review/`.
+- [ ] Renderer: `useHomeSnapshot` (query + subscription), `HomeView`, active-agents strip, row + card components, board view, view toggle in header, detail pane, empty states.
+- [ ] `utils/boardColumns.ts` — column projection from `(workflow, snapshot) → BoardColumn[]` + unit tests covering every attention combination.
+- [ ] `homeUiStore.viewMode` persistence + `v` keyboard shortcut for toggle.
+- [ ] Action registry + `home.startAction` dispatcher (link to `TaskCreationSaga` / `sendPromptToAgent` / urlOpener).
+- [ ] Analytics events (include `home_view_mode_changed`).
+- [ ] Tests: workstream grouping, column projection, staleness classification, severity ranking, snooze/mute decay, action prompt builders.
+- [ ] Component tests for empty / caught-up / heavy states **in both list and board layouts**.
+
+**M5 (Config canvas):**
+
+- [ ] `WorkflowService` client (default workflow, `workflow.onChanged` event) + server-side workflow config persistence.
+- [ ] `workflow.*` tRPC router with Zod input/output schemas (`get`, `save`, `validateDraft`, `resetToDefault`, `onChanged`).
+- [ ] `useWorkflow` hook (query + subscription); subscription wired in `features/home/subscriptions.ts`.
+- [ ] `workflowEditorStore` (Zustand, UI-only) + `workflowCanvasService` (R3 escape hatch for drag/snap/hit-test).
+- [ ] Components: `ConfigCanvas`, `NodePalette`, `NodeInspector`, `EdgeInspector`, `ValidationBanner`.
+- [ ] Three-way view toggle + `v` cycle + `Cmd+S` save + undo/redo within draft.
+- [ ] `WorkflowChanged` → `HomeService.reclassify()` → new snapshot frame; both List and Board update without any renderer-side coordination.
+- [ ] Agent bindings drive primary/secondary action registry (replaces the M2 hardcoded mapping in §12).
+- [ ] Tests: workflow Zod round-trip, predicate evaluation (matching `boardColumns` expectations against the default config), validation diagnostics, optimistic-concurrency reject + reload, draft → save → snapshot reclassification end-to-end.
+
+## 18. Open questions
+
+1. Should Home replace Command Center, given overlap on "see all running tasks"? Probably not — Command Center is a grid-of-agents work view, Home is workstream-grouped triage — but confirm.
+2. When a PR has both `pr_ci_failed` and `pr_comments`, do we stack chips on one row (current spec) or split into two attention items? Current: stack, single row, primary action follows top severity.
+3. Which GitHub identity wins when both the GitHub integration and `gh` auth are present? Suggestion: `gh` for queries, GitHub integration for permission checks.
+4. Should "Review with agent" auto-checkout into a new worktree or reuse the user's current one with a stash? Suggestion: new worktree, always.
+5. Cross-device snooze sync? v1: local only.
+6. Native OS notifications on critical kinds? Defer to M5; opt-in.
+7. Should the board support drag-to-move between columns? Current answer: **no for v1**. Columns are derived from underlying state, not user-set status — dragging would either need an override store (extra concept, sync complexity) or have to perform the underlying action (e.g. "drag to Ready to merge" = merge the PR), which is too consequential for a drag gesture. Default: cards are read-only with explicit action buttons.
+8. Should the board surface snoozed and muted items in a "Watching" column, or keep the list view's behaviour (counter pill only, not a column)? Current answer: **counter pill only**. Adding a sixth column dilutes the workflow story — Watching items aren't a workflow stage.
+9. Default view for new users — list or board? Current answer: **list**. Inbox-zero shape is what we open with; the board reveals itself via the toggle.
+10. Should the Config canvas be per-user, per-repo, or per-project? Current answer: **per-user, global**. Cross-repo workflows are the same shape ("PR → review → merge") so a single workflow keeps the model simple. Revisit if teams ask for per-repo overrides.
+11. Are workflow edits live for everyone in the org, or local? Current answer: **local for v1**. Sync via PostHog API is M6+.
+12. Should `terminal: archived` automatically run the existing archive action when a workstream lands there? Current answer: **no for v1**. Terminals just hide the workstream from List/Board; actions stay user-initiated.
+13. Should the canvas render the *live* workstreams (a count chip on each node) so it doubles as a board? Current answer: **yes for v1, read-only chips only**. Helps the user understand what their workflow is doing without making the canvas a third board.
+14. Library: `@xyflow/react` vs roll our own. Current answer: **`@xyflow/react`**. Pan/zoom/edge routing is enough work that "prefer writing our own" doesn't apply; wrap it once so we can swap later.
diff --git a/docs/workflow-architecture.md b/docs/workflow-architecture.md
new file mode 100644
index 0000000000..4eb5714cdd
--- /dev/null
+++ b/docs/workflow-architecture.md
@@ -0,0 +1,118 @@
+# Home workflow architecture
+
+The Home tab's data layer — workstream grouping, PR polling, situation
+classification, and workflow-config persistence — runs **server-side in
+PostHog**, in the `tasks` product (`products/tasks/` in the posthog repo). The
+Electron app is a thin authenticated client.
+
+The Electron app and the PostHog `tasks` product share wire shapes and
+classification logic — if you change either, update both sides and this doc.
+
+---
+
+## 1. What "the workflow" is
+
+A user-authored mapping of **situations** a piece of work can be in
+(`working`, `in_review`, `ci_failing`, `changes_requested`, `comments_waiting`,
+`ready_to_merge`, `stale`, `done`) → **actions** (skill + prompt) the user
+wants available when work lands in each situation.
+
+Three concerns sit on top of that:
+
+1. **Storage** — the per-user bindings JSON (`CodeWorkflowConfig`).
+2. **PR / signal polling** — CI status, review decision, threads, mergeability
+   for each tracked PR (`CodePrSnapshot`).
+3. **Grouping + classification** — group a user's tasks into workstreams and
+   compute the situations each is in (`CodeWorkstream`).
+
+All three live in PostHog now.
+
+---
+
+## 2. Server (PostHog `products/tasks/backend/`)
+
+**Pure logic** (ported 1:1 from the original TypeScript; unit-tested without
+Django) — `code_workstreams/`:
+
+- `situations.py` — situation ids, priority order, attention set.
+- `classify.py` — `classify(input) → set[SituationId]`, `pick_primary_situation`.
+- `grouping.py` — `build_workstreams(tasks, pr_by_task, now)`: groups tasks
+  (PR URL → repo+branch → path), extracts the active-agent set, classifies, and
+  buckets into needs-attention / in-progress.
+- `default_workflow.py`, `validation.py` — default bindings + save validation.
+
+**Models** (`models.py`):
+
+- `CodeWorkflowConfig` — per `(team, user)` bindings + monotonic `version`.
+- `CodePrSnapshot` — per `(team, pr_url)` polled GitHub state (shared across a
+  team's users).
+- `CodeWorkstream` — per `(team, user, key)` grouped + classified workstream;
+  the API reads these rows directly.
+
+**Temporal worker** (`temporal/code_workstreams/`, task queue
+`TASKS_TASK_QUEUE`):
+
+- `evaluate-code-workstreams` (dispatcher) — a Temporal **Schedule** every 3 min
+  enumerates teams with recent code activity and fans out one child workflow per
+  team (bounded concurrency).
+- `evaluate-team-code-workstreams` — per team: `load_team_pr_urls` →
+  `poll_team_pull_requests` (GitHub GraphQL via the team integration, rate-limit
+  aware, heartbeated) → `rebuild_team_workstreams` (group + classify + upsert
+  `CodeWorkstream`, prune stale).
+- On-demand refresh: `client.trigger_team_code_workstreams_evaluation(team_id)`.
+
+PR state is fetched with `GitHubIntegration.get_pull_request_snapshot(pr_url)`
+(a single GraphQL call: state, draft, mergeable, review decision, CI rollup,
+unresolved threads, requested reviewers).
+
+**REST API** (`code_home_api.py`, registered under `/api/projects/:id/`):
+
+- `GET    /code_workflow/`        → `WorkflowConfig` (seeds the default first time)
+- `POST   /code_workflow/save/`   → `{ config, expectedVersion }` → `SaveResult`
+  (`saved` | `conflict` (409) | `invalid` (422)); optimistic concurrency + validation
+- `POST   /code_workflow/reset/`  → reseed default
+- `GET    /code_home/`            → `HomeSnapshot { activeAgents, needsAttention, inProgress }`
+  (workstreams from `CodeWorkstream`; `activeAgents` computed live from `TaskRun`)
+- `POST   /code_home/refresh/`    → trigger an on-demand evaluation (202)
+
+Responses use the exact camelCase wire shapes the Electron app validates.
+
+---
+
+## 3. Electron app (`apps/code/`)
+
+Thin authenticated clients over the REST API — no local persistence, no `gh`
+polling, no client-side classification:
+
+| Concern | File |
+|---|---|
+| Snapshot wire schema (Zod, source of truth for the renderer types) | `apps/code/src/shared/types/home-snapshot.ts` |
+| Workflow config wire schema | `apps/code/src/shared/types/workflow.ts` |
+| Snapshot client + poll loop | `apps/code/src/main/services/home/service.ts` (`HomeService`) |
+| Workflow config client | `apps/code/src/main/services/workflow/service.ts` (`WorkflowService`) |
+| tRPC routers | `apps/code/src/main/trpc/routers/{home,workflow}.ts` |
+| Renderer query hooks | `features/home/hooks/{useHomeSnapshot,useWorkflow}.ts` |
+| Subscription registrar (keeps the query caches fresh) | `features/home/subscriptions.ts` |
+| Board column projection (pure, renderer-only) | `features/home/utils/boardColumns.ts` |
+
+Delivery for v1 is **REST + client poll**: `HomeService` polls
+`GET /code_home/` and emits `home.onSnapshotUpdated`; `WorkflowService` calls the
+config endpoints and emits `workflow.onChanged`. Both subscriptions write back
+into the TanStack Query cache. A realtime push channel (SSE) is a future
+enhancement — the tRPC subscription contract wouldn't change.
+
+`WorkflowService.get()` surfaces network/load failures rather than masking them:
+the config endpoint is the only source of truth, so when it can't be reached the
+canvas shows an offline/error state with a retry instead of fabricating a config.
+
+---
+
+## 4. What is intentionally NOT here yet
+
+- **`unresolvedThreads` for PRs the user doesn't author** — only the M3 reviewer
+  flow needs it; `is_current_user_requested_reviewer` defaults false.
+- **Realtime push (SSE)** — v1 is client poll; the worker keeps server data fresh.
+- **Snooze / mute / viewed** (`home_attention_state`) — M4, not migrated yet.
+- **`auto`-trigger actions** — deliberately omitted.
+- **Continue-as-new batching in the dispatcher** — current active-team counts
+  fan out in one pass (capped + logged); page with continue-as-new at larger scale.