diff --git a/CLAUDE.md b/CLAUDE.md
index 096ca0ff7..7e6c9d601 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -117,7 +117,10 @@ make vet        # go vet
 
 ### End-to-End Tests
 
-**E2E tests are non-negotiable.** Every major feature, bug fix, and refactor must include e2e tests that exercise the full stack (HTTP API with real SQLite). Even small changes merit e2e coverage when they touch API behavior, data flow between layers, or anything a user would notice if it broke. When in doubt, write the e2e test — the cost of a missing one is always higher than the cost of writing it.
+Coverage of real behavior is non-negotiable; the lane is chosen to avoid the one expensive cost — the **browser**, not the Go backend. Two independent axes:
+
+- **Browser only when you must.** Reserve Playwright for real rendering/layout: screenshots/video, `getBoundingClientRect`, scroll/sticky/overflow geometry, container queries, pointer drag, viewport emulation, canvas/xterm, computed CSS pixels. Everything else runs in **Vitest + jsdom** (`vp test`) — mount the real `App.svelte` via `frontend/src/test/appHarness.ts`. Mounting the whole app or using routing is not a reason to stay in Playwright.
+- **Real Go backend by default; mocking is the exception.** Backend-dependent behavior (sync, persistence, capabilities, normalization, wire shape) must hit real Go (`frontend/tests/e2e-full/` or `internal/server/` Go tests) — don't assert backend-computed values through a hand-written fixture. Mock the API (`frontend/src/test/mockApiFetch.ts`, never fork the Playwright copy) only for the rare scenario the seeded server can't produce.
 
 ### Test Guidelines
 
@@ -168,7 +171,7 @@ make vet        # go vet
 - Use conventional commit messages whose subject explains the reason or user-visible outcome, not just the mechanical change. Good subjects answer "why does this commit exist?" (for example, `fix: restore workspace activity for launched agents`), while vague mechanics such as `fix: run agents under tmux` are not acceptable on their own
 - Commit bodies must add any important context about the bug, regression, constraint, or tradeoff that motivated the change; do not rely on the diff to explain intent
 - Run tests before committing when applicable
-- Before pushing any frontend change, you must have run the full affected Playwright e2e suite locally after the final frontend/test edit; focused component tests, type checks, and CI-only verification are not enough.
+- Before pushing any frontend change, you must have run the full affected suite locally after the final frontend/test edit — the full `vp test` Vitest run, plus the full affected Playwright e2e suite whenever the change touches Playwright specs or the shared mock fixtures they rely on; type checks and CI-only verification are not enough.
 - Never push new workstreams unless explicitly asked. When addressing review feedback or CI failures on an existing PR, an agent may push after the fix is implemented and relevant local validation has run.
 
 ## Pull Requests
diff --git a/frontend/src/App.activity-collapse.test.ts b/frontend/src/App.activity-collapse.test.ts
new file mode 100644
index 000000000..3762a3c5d
--- /dev/null
+++ b/frontend/src/App.activity-collapse.test.ts
@@ -0,0 +1,215 @@
+// Threaded activity collapse behavior exercised through the real app shell
+// with the API mocked at the fetch boundary.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { fireEvent } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, resetKeyboardModuleState, type MountedApp } from "./test/appHarness.js";
+import { jsonResponse, type MockRouteOverride } from "./test/mockApiFetch.js";
+
+function event(id: string, number: number, type: string, created: string): unknown {
+  return {
+    id,
+    cursor: id,
+    activity_type: type,
+    author: "marius",
+    body_preview: "",
+    created_at: created,
+    item_number: number,
+    item_state: "open",
+    item_title: number === 42 ? "Add browser regression coverage" : "Refactor theme system",
+    item_type: "pr",
+    item_url: `https://github.com/acme/widgets/pull/${number}`,
+    platform_host: "github.com",
+    repo_owner: "acme",
+    repo_name: "widgets",
+    repo: {
+      provider: "github",
+      platform_host: "github.com",
+      owner: "acme",
+      name: "widgets",
+      repo_path: "acme/widgets",
+      capabilities: {},
+    },
+  };
+}
+
+function activitySettings(viewMode: "flat" | "threaded"): MockRouteOverride {
+  return (req) => {
+    if (req.method !== "GET" || req.url.pathname !== "/api/v1/settings") return null;
+    return jsonResponse({
+      repos: [
+        {
+          provider: "github",
+          platform_host: "github.com",
+          owner: "acme",
+          name: "widgets",
+          repo_path: "acme/widgets",
+          is_glob: false,
+          matched_repo_count: 1,
+        },
+      ],
+      activity: {
+        view_mode: viewMode,
+        time_range: "7d",
+        hide_closed: false,
+        hide_bots: false,
+        collapse_threads: false,
+      },
+      terminal: {
+        font_family: "",
+        font_size: 14,
+        scrollback: 1000,
+        line_height: 1,
+        letter_spacing: 0,
+        cursor_blink: true,
+        font_ligatures: false,
+        renderer: "xterm",
+      },
+      agents: [],
+    });
+  };
+}
+
+function activityItems(items: unknown[]): MockRouteOverride {
+  return (req) => {
+    if (req.method !== "GET" || req.url.pathname !== "/api/v1/activity") return null;
+    return jsonResponse({ capped: false, items });
+  };
+}
+
+const defaultEvents = [
+  event("a1", 42, "comment", "2026-03-30T14:00:00Z"),
+  event("a2", 42, "review", "2026-03-30T13:00:00Z"),
+  event("b1", 55, "comment", "2026-03-30T12:00:00Z"),
+];
+
+async function mountThreadedActivity(): Promise<MountedApp> {
+  const app = await mountApp("/?view=threaded", {
+    overrides: [activitySettings("threaded"), activityItems(defaultEvents)],
+  });
+  await waitFor(() => expect(itemRows()).toHaveLength(2));
+  return app;
+}
+
+function itemRows(): Element[] {
+  return Array.from(document.querySelectorAll(".item-row"));
+}
+
+function eventRows(): Element[] {
+  return Array.from(document.querySelectorAll(".event-row"));
+}
+
+describe("threaded activity collapse", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("collapses, drills into one item, and persists across reload", async () => {
+    const app = await mountThreadedActivity();
+    expect(eventRows().length).toBeGreaterThan(0);
+
+    await fireEvent.click(screen.getByRole("button", { name: "Collapse all" }));
+    await waitFor(() => expect(eventRows()).toHaveLength(0));
+    expect(itemRows()).toHaveLength(2);
+
+    // Drill into a single item via its caret.
+    await fireEvent.click(itemRows()[0]!.querySelector(".thread-caret")!);
+    await waitFor(() => expect(eventRows().length).toBeGreaterThan(0));
+
+    // Collapse-all wrote ?collapsed=1; a reload (remount at the current
+    // URL) restores the collapsed state and clears the session-only
+    // single-item override.
+    expect(window.location.search).toContain("collapsed=1");
+    app.unmount();
+
+    await mountApp(window.location.pathname + window.location.search, {
+      overrides: [activitySettings("threaded"), activityItems(defaultEvents)],
+    });
+    await waitFor(() => expect(itemRows()).toHaveLength(2));
+    expect(eventRows()).toHaveLength(0);
+  });
+
+  it("collapse control works while the side detail pane is open", async () => {
+    await mountThreadedActivity();
+
+    // Open a detail by clicking the item row body (not the caret).
+    await fireEvent.click(itemRows()[0]!.querySelector(".item-title")!);
+    await waitFor(() => expect(document.querySelector(".activity-detail")).not.toBeNull());
+    expect(document.querySelector(".activity-pane")).not.toBeNull();
+
+    // Opening the side pane switches the feed into compact mode, where the
+    // control keeps its accessible name (CSS hides only the text label —
+    // that visual hiding is asserted in the browser lane, see
+    // tests/e2e/activity-collapse-compact-label.spec.ts). Here we verify the
+    // behavior jsdom can see: compact mode is active and the control still
+    // collapses the threads.
+    expect(document.querySelector(".activity-feed--compact")).not.toBeNull();
+    const collapseBtn = screen.getByRole("button", { name: "Collapse all" });
+
+    await fireEvent.click(collapseBtn);
+    await waitFor(() => expect(eventRows()).toHaveLength(0));
+  });
+
+  it("expand all restores every item's events", async () => {
+    await mountThreadedActivity();
+    const initialCount = eventRows().length;
+    expect(initialCount).toBeGreaterThan(0);
+
+    await fireEvent.click(screen.getByRole("button", { name: "Collapse all" }));
+    await waitFor(() => expect(eventRows()).toHaveLength(0));
+
+    // The control flips to Expand all; clicking it brings every event back.
+    await fireEvent.click(screen.getByRole("button", { name: "Expand all" }));
+    await waitFor(() => expect(eventRows()).toHaveLength(initialCount));
+  });
+
+  // Starting from flat view mode, the test switches to Threaded through the
+  // View dropdown before exercising the collapse controls.
+  it("switches to threaded via the View dropdown, then collapse/expand all", async () => {
+    await mountApp("/", {
+      overrides: [activitySettings("flat"), activityItems(defaultEvents)],
+    });
+    await waitFor(() => expect(document.querySelector(".activity-table .activity-row")).not.toBeNull());
+
+    await fireEvent.click(screen.getByRole("button", { name: "View" }));
+    await fireEvent.click(screen.getByRole("button", { name: "Threaded" }));
+    await waitFor(() => expect(document.querySelector(".threaded-view .item-row")).not.toBeNull());
+
+    const initialCount = eventRows().length;
+    expect(initialCount).toBeGreaterThan(0);
+
+    await fireEvent.click(screen.getByRole("button", { name: "Collapse all" }));
+    await waitFor(() => expect(eventRows()).toHaveLength(0));
+    expect(document.querySelector(".threaded-view .item-row")).not.toBeNull();
+
+    await fireEvent.click(screen.getByRole("button", { name: "Expand all" }));
+    await waitFor(() => expect(eventRows().length).toBeGreaterThan(0));
+  });
+
+  it("a single caret expands only its own item after collapse all", async () => {
+    await mountThreadedActivity();
+    const fullCount = eventRows().length;
+    expect(fullCount).toBeGreaterThan(1);
+
+    await fireEvent.click(screen.getByRole("button", { name: "Collapse all" }));
+    await waitFor(() => expect(eventRows()).toHaveLength(0));
+
+    await fireEvent.click(itemRows()[0]!.querySelector(".thread-caret")!);
+
+    // Only the clicked item's events reappear; the rest stay collapsed.
+    await waitFor(() => expect(eventRows().length).toBeGreaterThan(0));
+    const partial = eventRows().length;
+    expect(partial).toBeLessThan(fullCount);
+  });
+});
diff --git a/frontend/src/App.activity-thread-runs.test.ts b/frontend/src/App.activity-thread-runs.test.ts
new file mode 100644
index 000000000..8d446f45e
--- /dev/null
+++ b/frontend/src/App.activity-thread-runs.test.ts
@@ -0,0 +1,154 @@
+// Same-author event runs collapse into a single summary row in threaded
+// activity, rendered through the real app shell with the API mocked at the
+// fetch boundary.
+
+import { cleanup, waitFor } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, resetKeyboardModuleState } from "./test/appHarness.js";
+import { jsonResponse, type MockRouteOverride } from "./test/mockApiFetch.js";
+
+const REPO = {
+  provider: "github",
+  platform_host: "github.com",
+  owner: "acme",
+  name: "widgets",
+  repo_path: "acme/widgets",
+  capabilities: {},
+};
+
+function prEvent(args: {
+  id: string;
+  type: "comment" | "review" | "commit" | "force_push" | "new_pr";
+  author: string;
+  createdAt: string;
+}): unknown {
+  return {
+    id: args.id,
+    cursor: args.id,
+    activity_type: args.type,
+    author: args.author,
+    body_preview: "",
+    created_at: args.createdAt,
+    item_number: 42,
+    item_state: "open",
+    item_title: "Add browser regression coverage",
+    item_type: "pr",
+    item_url: "https://github.com/acme/widgets/pull/42",
+    platform_host: "github.com",
+    repo_owner: "acme",
+    repo_name: "widgets",
+    repo: REPO,
+  };
+}
+
+const settingsOverride: MockRouteOverride = (req) => {
+  if (req.method !== "GET" || req.url.pathname !== "/api/v1/settings") return null;
+  return jsonResponse({
+    repos: [
+      {
+        provider: "github",
+        platform_host: "github.com",
+        owner: "acme",
+        name: "widgets",
+        repo_path: "acme/widgets",
+        is_glob: false,
+        matched_repo_count: 1,
+      },
+    ],
+    activity: {
+      view_mode: "threaded",
+      time_range: "7d",
+      hide_closed: false,
+      hide_bots: false,
+      collapse_threads: false,
+    },
+    terminal: {
+      font_family: "",
+      font_size: 14,
+      scrollback: 1000,
+      line_height: 1,
+      letter_spacing: 0,
+      cursor_blink: true,
+      font_ligatures: false,
+      renderer: "xterm",
+    },
+    agents: [],
+  });
+};
+
+function activityItems(items: unknown[]): MockRouteOverride {
+  return (req) => {
+    if (req.method !== "GET" || req.url.pathname !== "/api/v1/activity") return null;
+    return jsonResponse({ capped: false, items });
+  };
+}
+
+async function mountThreadedActivity(items: unknown[]): Promise<void> {
+  await mountApp("/?view=threaded", {
+    overrides: [settingsOverride, activityItems(items)],
+  });
+  await waitFor(() => expect(document.querySelector(".item-row")).not.toBeNull());
+}
+
+function collapsedEventRows(): Element[] {
+  return Array.from(document.querySelectorAll(".event-row.collapsed-event"));
+}
+
+function plainEventRows(): Element[] {
+  return Array.from(document.querySelectorAll(".event-row:not(.collapsed-event)"));
+}
+
+describe("threaded activity run collapse", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("collapses a run of three or more reviews from the same author", async () => {
+    await mountThreadedActivity([
+      prEvent({ id: "r5", type: "review", author: "alice", createdAt: "2026-04-27T15:00:00Z" }),
+      prEvent({ id: "r4", type: "review", author: "alice", createdAt: "2026-04-27T14:00:00Z" }),
+      prEvent({ id: "r3", type: "review", author: "alice", createdAt: "2026-04-27T13:00:00Z" }),
+      prEvent({ id: "r2", type: "review", author: "alice", createdAt: "2026-04-27T12:00:00Z" }),
+      prEvent({ id: "r1", type: "review", author: "alice", createdAt: "2026-04-27T11:00:00Z" }),
+    ]);
+
+    const collapsed = collapsedEventRows().filter((row) => row.textContent?.includes("5 reviews"));
+    expect(collapsed).toHaveLength(1);
+    expect(collapsed[0]!.querySelector(".evt-review")).not.toBeNull();
+    expect(plainEventRows()).toHaveLength(0);
+  });
+
+  it("collapses comments and reviews into separate runs by event type", async () => {
+    await mountThreadedActivity([
+      prEvent({ id: "c3", type: "comment", author: "alice", createdAt: "2026-04-27T16:00:00Z" }),
+      prEvent({ id: "c2", type: "comment", author: "alice", createdAt: "2026-04-27T15:00:00Z" }),
+      prEvent({ id: "c1", type: "comment", author: "alice", createdAt: "2026-04-27T14:00:00Z" }),
+      prEvent({ id: "r3", type: "review", author: "alice", createdAt: "2026-04-27T13:00:00Z" }),
+      prEvent({ id: "r2", type: "review", author: "alice", createdAt: "2026-04-27T12:00:00Z" }),
+      prEvent({ id: "r1", type: "review", author: "alice", createdAt: "2026-04-27T11:00:00Z" }),
+    ]);
+
+    expect(collapsedEventRows().filter((row) => row.textContent?.includes("3 comments"))).toHaveLength(1);
+    expect(collapsedEventRows().filter((row) => row.textContent?.includes("3 reviews"))).toHaveLength(1);
+  });
+
+  it("leaves short runs of comments unrolled", async () => {
+    await mountThreadedActivity([
+      prEvent({ id: "c2", type: "comment", author: "alice", createdAt: "2026-04-27T13:00:00Z" }),
+      prEvent({ id: "c1", type: "comment", author: "alice", createdAt: "2026-04-27T12:00:00Z" }),
+    ]);
+
+    expect(collapsedEventRows()).toHaveLength(0);
+    expect(plainEventRows()).toHaveLength(2);
+  });
+});
diff --git a/frontend/src/App.cheatsheet.test.ts b/frontend/src/App.cheatsheet.test.ts
new file mode 100644
index 000000000..7e4e7f066
--- /dev/null
+++ b/frontend/src/App.cheatsheet.test.ts
@@ -0,0 +1,57 @@
+// The ? shortcut opens the cheatsheet through the app shell's global
+// keydown handler, view-scoped shortcuts appear under "On this view", and
+// Escape closes it.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, pressKey, resetKeyboardModuleState } from "./test/appHarness.js";
+
+function cheatsheetDialog(): HTMLElement | null {
+  return screen.queryByRole("dialog", { name: "Keyboard shortcuts" });
+}
+
+describe("cheatsheet", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("? opens the cheatsheet and shows j/k under On this view", async () => {
+    await mountApp("/pulls");
+    await waitFor(() => expect(document.querySelector("[data-test='pr-list']")).not.toBeNull());
+
+    pressKey("?", { shift: true });
+    const sheet = await waitFor(() => {
+      const dialog = cheatsheetDialog();
+      expect(dialog).not.toBeNull();
+      return dialog!;
+    });
+
+    // j and k navigate PRs on /pulls — they should appear under "On this view".
+    const onThisView = Array.from(sheet.querySelectorAll(".cheatsheet-section")).find((section) =>
+      section.textContent?.includes("On this view"),
+    );
+    expect(onThisView).toBeTruthy();
+    expect(onThisView!.textContent).toMatch(/Next pull request|Previous pull request/i);
+  });
+
+  it("Escape closes the cheatsheet", async () => {
+    await mountApp("/pulls");
+    await waitFor(() => expect(document.querySelector("[data-test='pr-list']")).not.toBeNull());
+
+    pressKey("?", { shift: true });
+    await waitFor(() => expect(cheatsheetDialog()).not.toBeNull());
+
+    pressKey("Escape");
+    await waitFor(() => expect(cheatsheetDialog()).toBeNull());
+  });
+});
diff --git a/frontend/src/App.issue-routing.test.ts b/frontend/src/App.issue-routing.test.ts
new file mode 100644
index 000000000..92db4516b
--- /dev/null
+++ b/frontend/src/App.issue-routing.test.ts
@@ -0,0 +1,152 @@
+// Issue detail routes must preserve the platform host in detail requests
+// (direct load and popstate), and the detail meta row renders assignees.
+// The app is mounted for real with fetch mocked at the network boundary so
+// the asserted host is the one the app actually sent.
+
+import { cleanup, waitFor } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { firePopstate, installAppDomGlobals, mountApp, resetKeyboardModuleState } from "./test/appHarness.js";
+import { jsonResponse, type MockRequest, type MockRouteOverride } from "./test/mockApiFetch.js";
+
+const mirrorIssueDetail = {
+  issue: {
+    ID: 2,
+    RepoID: 2,
+    GitHubID: 202,
+    Number: 7,
+    URL: "https://ghe.example.com/acme/widgets/issues/7",
+    Title: "Mirror host issue",
+    Author: "marius",
+    State: "open",
+    Body: "",
+    CommentCount: 1,
+    LabelsJSON: "[]",
+    CreatedAt: "2026-03-28T14:00:00Z",
+    UpdatedAt: "2026-03-30T14:00:00Z",
+    LastActivityAt: "2026-03-30T14:00:00Z",
+    ClosedAt: null,
+    Starred: false,
+  },
+  events: [],
+  platform_host: "ghe.example.com",
+  repo_owner: "acme",
+  repo_name: "widgets",
+  detail_loaded: true,
+  detail_fetched_at: "2026-03-30T14:00:00Z",
+};
+
+const assignedIssueDetail = {
+  issue: {
+    ...mirrorIssueDetail.issue,
+    ID: 3,
+    GitHubID: 303,
+    Number: 12,
+    URL: "https://ghe.example.com/acme/widgets/issues/12",
+    Title: "Issue with assignees",
+    CommentCount: 0,
+    assignees: ["alice", "bob"],
+  },
+  events: [],
+  platform_host: "ghe.example.com",
+  repo_owner: "acme",
+  repo_name: "widgets",
+  detail_loaded: true,
+  detail_fetched_at: "2026-03-30T14:00:00Z",
+};
+
+function mirrorIssueRoutes(detail: unknown, number: number): MockRouteOverride {
+  return (req) => {
+    if (req.method !== "GET") return null;
+    const { pathname } = req.url;
+    const legacy = new RegExp(`^/api/v1/repos/acme/widgets/issues/${number}$`);
+    const hosted = `/api/v1/host/ghe.example.com/issues/github/acme/widgets/${number}`;
+    if (legacy.test(pathname) || pathname === hosted) {
+      return jsonResponse(detail);
+    }
+    return null;
+  };
+}
+
+/**
+ * Hosts a request carried for the mirror issue: the provider-aware
+ * /host/{platform_host}/ path segment or an explicit platform_host query
+ * param on the legacy repo route.
+ */
+function seenHosts(requests: MockRequest[], number: number): string[] {
+  const hosts: string[] = [];
+  for (const req of requests) {
+    const { pathname } = req.url;
+    if (pathname === `/api/v1/host/ghe.example.com/issues/github/acme/widgets/${number}`) {
+      hosts.push("ghe.example.com");
+    } else if (pathname === `/api/v1/repos/acme/widgets/issues/${number}`) {
+      hosts.push(req.url.searchParams.get("platform_host") ?? "");
+    }
+  }
+  return hosts;
+}
+
+function detailTitle(): string {
+  return document.querySelector(".issue-detail .detail-title")?.textContent ?? "";
+}
+
+describe("issue route platform host", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("direct issue load preserves platform_host in detail requests", async () => {
+    const app = await mountApp("/host/ghe.example.com/issues/github/acme/widgets/7", {
+      overrides: [mirrorIssueRoutes(mirrorIssueDetail, 7)],
+    });
+
+    await waitFor(() => expect(detailTitle()).toContain("Mirror host issue"));
+    expect(seenHosts(app.api.requests, 7)).toContain("ghe.example.com");
+  });
+
+  it("popstate preserves platform_host in detail requests", async () => {
+    const app = await mountApp("/issues", {
+      overrides: [mirrorIssueRoutes(mirrorIssueDetail, 7)],
+    });
+    await waitFor(() => expect(document.body.textContent).toContain("Theme toggle does not stick"));
+
+    await firePopstate("/host/ghe.example.com/issues/github/acme/widgets/7");
+
+    await waitFor(() => expect(detailTitle()).toContain("Mirror host issue"));
+    expect(seenHosts(app.api.requests, 7)).toContain("ghe.example.com");
+  });
+});
+
+describe("issue detail assignees", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("renders assignees in the meta row when present", async () => {
+    await mountApp("/host/ghe.example.com/issues/github/acme/widgets/12", {
+      overrides: [mirrorIssueRoutes(assignedIssueDetail, 12)],
+    });
+
+    await waitFor(() => expect(detailTitle()).toContain("Issue with assignees"));
+    const assigneeList = document.querySelector(".issue-detail .meta-row [data-user-list-editor='assignees']");
+    expect(assigneeList?.textContent).toContain("alice, bob");
+  });
+});
diff --git a/frontend/src/App.keyboard-shortcuts.test.ts b/frontend/src/App.keyboard-shortcuts.test.ts
new file mode 100644
index 000000000..adce55f22
--- /dev/null
+++ b/frontend/src/App.keyboard-shortcuts.test.ts
@@ -0,0 +1,95 @@
+// Global shortcuts served by the keyboard registry — j/k list navigation,
+// the Cmd+[ sidebar toggle, and the routes where Cmd+[ is reserved
+// (consumed without toggling) because no sidebar target exists.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, pressKey, resetKeyboardModuleState } from "./test/appHarness.js";
+
+describe("migrated global shortcuts", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("j and k navigate the PR list", async () => {
+    await mountApp("/pulls");
+    await waitFor(() => expect(document.querySelector(".pr-list-row")).not.toBeNull());
+
+    pressKey("j");
+    await waitFor(() => expect(document.querySelector(".pr-list-row.selected")).not.toBeNull());
+
+    pressKey("k");
+    await waitFor(() => expect(document.querySelector(".pr-list-row.selected")).not.toBeNull());
+  });
+
+  it("Cmd+[ toggles the sidebar", async () => {
+    await mountApp("/pulls");
+    const sidebar = await waitFor(() => {
+      const el = document.querySelector("[data-test='sidebar']");
+      expect(el).not.toBeNull();
+      return el!;
+    });
+    const wasCollapsed = sidebar.getAttribute("data-collapsed") === "true";
+
+    pressKey("[", { meta: true });
+
+    await waitFor(() =>
+      expect(document.querySelector("[data-test='sidebar']")?.getAttribute("data-collapsed")).toBe(
+        (!wasCollapsed).toString(),
+      ),
+    );
+  });
+
+  it("Cmd+[ is reserved on Activity without toggling the sidebar", async () => {
+    localStorage.setItem("middleman-sidebar", "collapsed");
+    await mountApp("/");
+
+    const expandButton = await waitFor(() => screen.getByRole("button", { name: "Expand sidebar" }));
+    expect(document.querySelectorAll("header kbd[aria-label$='-[']")).toHaveLength(0);
+
+    // Toggle sidebar must not be offered in the palette on this page.
+    pressKey("k", { meta: true });
+    const palette = await waitFor(() => screen.getByRole("dialog", { name: "Command palette" }));
+    expect(
+      Array.from(palette.querySelectorAll(".palette-row")).filter((row) => row.textContent?.includes("Toggle sidebar")),
+    ).toHaveLength(0);
+    pressKey("Escape");
+    await waitFor(() => expect(screen.queryByRole("dialog", { name: "Command palette" })).toBeNull());
+
+    // Nor in the cheatsheet.
+    pressKey("?", { shift: true });
+    const cheatsheet = await waitFor(() => screen.getByRole("dialog", { name: "Keyboard shortcuts" }));
+    expect(cheatsheet.textContent).not.toContain("Toggle sidebar");
+    pressKey("Escape");
+    await waitFor(() => expect(screen.queryByRole("dialog", { name: "Keyboard shortcuts" })).toBeNull());
+
+    // The chord is still consumed (reserved) so the browser default never
+    // fires, but the collapsed sidebar stays collapsed.
+    const event = pressKey("[", { meta: true });
+    expect(event.defaultPrevented).toBe(true);
+    expect(screen.getByRole("button", { name: "Expand sidebar" })).toBeTruthy();
+  });
+
+  it("Cmd+[ is reserved on compact PR list without toggling persisted sidebar state", async () => {
+    await mountApp("/pulls", { viewportWidth: 480 });
+    await waitFor(() => expect(document.body.textContent).toContain("Add browser regression coverage"));
+
+    expect(document.querySelectorAll(".sidebar")).toHaveLength(0);
+    localStorage.removeItem("middleman-sidebar");
+
+    const event = pressKey("[", { meta: true });
+
+    expect(event.defaultPrevented).toBe(true);
+    expect(localStorage.getItem("middleman-sidebar")).toBeNull();
+  });
+});
diff --git a/frontend/src/App.palette-commands.test.ts b/frontend/src/App.palette-commands.test.ts
new file mode 100644
index 000000000..a11b46ca5
--- /dev/null
+++ b/frontend/src/App.palette-commands.test.ts
@@ -0,0 +1,98 @@
+// Palette open/close wiring and command dispatch through the real app
+// shell's global keydown handler, with the API mocked at the fetch
+// boundary.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { fireEvent } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, pressKey, resetKeyboardModuleState } from "./test/appHarness.js";
+
+function paletteDialog(): HTMLElement | null {
+  return screen.queryByRole("dialog", { name: "Command palette" });
+}
+
+function paletteInput(): HTMLInputElement {
+  const input = document.querySelector<HTMLInputElement>(".palette-input");
+  expect(input).not.toBeNull();
+  return input!;
+}
+
+async function waitForPaletteOpenAndFocused(): Promise<void> {
+  await waitFor(() => {
+    expect(paletteDialog()).not.toBeNull();
+    expect(document.activeElement).toBe(paletteInput());
+  });
+}
+
+describe("palette command dispatch", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("header trigger and Cmd+Shift+P open the palette", async () => {
+    await mountApp("/pulls");
+    const trigger = await waitFor(() => screen.getByRole("button", { name: "Open command palette" }));
+    await fireEvent.click(trigger);
+    await waitForPaletteOpenAndFocused();
+
+    pressKey("Escape");
+    await waitFor(() => expect(paletteDialog()).toBeNull());
+
+    pressKey("P", { meta: true, shift: true });
+    await waitForPaletteOpenAndFocused();
+
+    pressKey("P", { meta: true, shift: true });
+    await waitFor(() => expect(paletteDialog()).toBeNull());
+  });
+
+  it("'>' filters to commands; running Open settings navigates", async () => {
+    await mountApp("/pulls");
+    await waitFor(() => expect(document.querySelector("[data-test='pr-list']")).not.toBeNull());
+
+    pressKey("k", { meta: true });
+    await waitForPaletteOpenAndFocused();
+
+    await fireEvent.input(paletteInput(), { target: { value: ">settings" } });
+    pressKey("Enter", {}, paletteInput());
+
+    await waitFor(() => expect(window.location.pathname).toBe("/settings"));
+  });
+
+  it("typing a single character in the search input does not fire global j", async () => {
+    await mountApp("/pulls");
+    // Wait for PR rows to render so .pr-list-row.selected has a chance
+    // to appear if the j shortcut leaks through.
+    await waitFor(() => expect(document.querySelector(".pr-list-row")).not.toBeNull());
+
+    pressKey("k", { meta: true });
+    await waitForPaletteOpenAndFocused();
+
+    const before = document.querySelectorAll(".pr-list-row.selected").length;
+    pressKey("j", {}, paletteInput());
+    await fireEvent.input(paletteInput(), { target: { value: "j" } });
+    const after = document.querySelectorAll(".pr-list-row.selected").length;
+    expect(after).toBe(before);
+  });
+
+  it("Cmd+P inside the palette closes it instead of opening browser print", async () => {
+    await mountApp("/pulls");
+
+    pressKey("k", { meta: true });
+    await waitForPaletteOpenAndFocused();
+
+    const event = pressKey("p", { meta: true }, paletteInput());
+    await waitFor(() => expect(paletteDialog()).toBeNull());
+    // The shortcut must be consumed so the browser print dialog never opens.
+    expect(event.defaultPrevented).toBe(true);
+  });
+});
diff --git a/frontend/src/App.palette-focus-trap.test.ts b/frontend/src/App.palette-focus-trap.test.ts
new file mode 100644
index 000000000..cb030009b
--- /dev/null
+++ b/frontend/src/App.palette-focus-trap.test.ts
@@ -0,0 +1,54 @@
+// Tab and Shift+Tab must keep focus inside the open palette. The trap is
+// programmatic (the dialog's keydown handler moves focus and prevents
+// default), so jsdom exercises the same code path a browser does.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, pressKey, resetKeyboardModuleState } from "./test/appHarness.js";
+
+describe("palette focus trap", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("Tab and Shift+Tab cycle within the open palette", async () => {
+    await mountApp("/pulls");
+
+    // The palette is opened from anywhere via Meta+K (Ctrl+K on non-mac);
+    // both bindings are wired to palette.open in defaultActions.
+    pressKey("k", { meta: true });
+
+    const input = await waitFor(() => {
+      const el = document.querySelector<HTMLInputElement>(".palette-input");
+      expect(el).not.toBeNull();
+      expect(document.activeElement).toBe(el);
+      return el!;
+    });
+
+    const palette = document.querySelector(".palette");
+    expect(palette).not.toBeNull();
+
+    // Forward Tab: focus must stay inside the .palette dialog.
+    const tab = pressKey("Tab", {}, input);
+    expect(palette!.contains(document.activeElement)).toBe(true);
+    expect(tab.defaultPrevented).toBe(true);
+
+    // Reverse Tab: same containment guarantee.
+    pressKey("Tab", { shift: true }, document.activeElement!);
+    expect(palette!.contains(document.activeElement)).toBe(true);
+
+    // Escape closes the palette and tears down the modal frame.
+    pressKey("Escape", {}, document.activeElement!);
+    await waitFor(() => expect(screen.queryByRole("dialog", { name: "Command palette" })).toBeNull());
+  });
+});
diff --git a/frontend/src/App.palette-pr-detail-commands.test.ts b/frontend/src/App.palette-pr-detail-commands.test.ts
new file mode 100644
index 000000000..bbbc53d54
--- /dev/null
+++ b/frontend/src/App.palette-pr-detail-commands.test.ts
@@ -0,0 +1,176 @@
+// PR-detail palette commands (`pr.approve`, `pr.ready`,
+// `pr.approveWorkflows`). The merge palette command is intentionally not
+// registered (the trigger lives in PullDetail.svelte's local component
+// state). The app is mounted for real so the asserted approve POST flows
+// through the same closure the detail-pane button uses.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { fireEvent } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, pressKey, resetKeyboardModuleState } from "./test/appHarness.js";
+import { jsonResponse, type MockRouteOverride } from "./test/mockApiFetch.js";
+
+const capabilities = {
+  read_repositories: true,
+  read_merge_requests: true,
+  read_issues: true,
+  read_comments: true,
+  read_releases: true,
+  read_ci: true,
+  read_labels: true,
+  comment_mutation: true,
+  state_mutation: true,
+  merge_mutation: true,
+  label_mutation: true,
+  review_mutation: true,
+  workflow_approval: true,
+  ready_for_review: true,
+  issue_mutation: true,
+  review_draft_mutation: false,
+  review_thread_resolution: false,
+  read_review_threads: false,
+  native_multiline_ranges: false,
+  mutation_head_binding: false,
+  thread_reply: false,
+  thread_resolve: false,
+  supported_review_actions: [],
+};
+
+const repo = {
+  provider: "github",
+  platform_host: "github.com",
+  repo_path: "acme/widgets",
+  owner: "acme",
+  name: "widgets",
+  capabilities,
+};
+
+const closedPR55: MockRouteOverride = (req) => {
+  if (req.method !== "GET" || req.url.pathname !== "/api/v1/pulls/github/acme/widgets/55") return null;
+  return jsonResponse({
+    merge_request: {
+      ID: 3,
+      RepoID: 1,
+      GitHubID: 301,
+      Number: 55,
+      URL: "https://github.com/acme/widgets/pull/55",
+      Title: "Refactor theme system",
+      Author: "luisa",
+      State: "closed",
+      IsDraft: false,
+      Body: "Consolidates theme tokens.",
+      HeadBranch: "refactor/theme",
+      BaseBranch: "main",
+      Additions: 80,
+      Deletions: 40,
+      CommentCount: 0,
+      ReviewDecision: "",
+      CIStatus: "pending",
+      CIChecksJSON: "[]",
+      CreatedAt: "2026-03-29T14:00:00Z",
+      UpdatedAt: "2026-03-30T14:00:00Z",
+      LastActivityAt: "2026-03-30T14:00:00Z",
+      MergedAt: null,
+      ClosedAt: "2026-03-30T14:00:00Z",
+      KanbanStatus: "new",
+      Starred: false,
+      repo_owner: "acme",
+      repo_name: "widgets",
+      platform_host: "github.com",
+      repo,
+      worktree_links: [],
+    },
+    events: [],
+    repo,
+    repo_owner: "acme",
+    repo_name: "widgets",
+    platform_host: "github.com",
+    detail_loaded: true,
+    detail_fetched_at: "2026-03-30T14:00:00Z",
+    worktree_links: [],
+  });
+};
+
+function paletteInput(): HTMLInputElement {
+  const input = document.querySelector<HTMLInputElement>(".palette-input");
+  expect(input).not.toBeNull();
+  return input!;
+}
+
+async function openPaletteWith(query: string): Promise<void> {
+  pressKey("k", { meta: true });
+  await waitFor(() => {
+    expect(screen.queryByRole("dialog", { name: "Command palette" })).not.toBeNull();
+    expect(document.activeElement).toBe(paletteInput());
+  });
+  await fireEvent.input(paletteInput(), { target: { value: query } });
+}
+
+function paletteRowsNamed(pattern: RegExp): HTMLElement[] {
+  // Palette rows render as <button class="palette-row">; query by the
+  // actual role so a regression that surfaces the command anyway would
+  // fail this assertion.
+  return screen.queryAllByRole("button", { name: pattern });
+}
+
+describe("PR-detail palette commands", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("Approve PR runs from the palette and triggers the approve flow", async () => {
+    const app = await mountApp("/pulls/github/acme/widgets/42");
+    await waitFor(() => expect(document.body.textContent).toContain("Adds Playwright smoke tests"));
+
+    await openPaletteWith("approve pr");
+    // The command must actually surface for the open, approvable PR —
+    // this also keeps the absence assertions below non-vacuous.
+    await waitFor(() => expect(paletteRowsNamed(/Approve PR/i).length).toBeGreaterThan(0));
+
+    pressKey("Enter", {}, paletteInput());
+
+    // The action wires through the same closure the detail-pane approve
+    // button uses; observable effect is the approve POST on the wire.
+    const approvePost = await waitFor(() => {
+      const post = app.api.requests.find(
+        (req) => req.method === "POST" && req.url.pathname === "/api/v1/pulls/github/acme/widgets/42/approve",
+      );
+      expect(post).toBeTruthy();
+      return post!;
+    });
+
+    // The approve must pin the head the detail view rendered so the server
+    // can reject the action when the head moved after review.
+    const body = JSON.parse(approvePost.bodyText || "{}") as { expected_head_sha?: string };
+    expect(body.expected_head_sha).toBe("42aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa42");
+  });
+
+  it("Approve PR is absent from the palette when the PR is closed", async () => {
+    await mountApp("/pulls/github/acme/widgets/55", { overrides: [closedPR55] });
+    await waitFor(() => expect(document.body.textContent).toContain("Consolidates theme tokens"));
+
+    await openPaletteWith("approve pr");
+
+    expect(paletteRowsNamed(/Approve PR/i)).toHaveLength(0);
+  });
+
+  it("Mark ready for review appears only when the PR is a draft", async () => {
+    await mountApp("/pulls/github/acme/widgets/42");
+    await waitFor(() => expect(document.body.textContent).toContain("Adds Playwright smoke tests"));
+
+    await openPaletteWith("ready for review");
+
+    // Non-draft PR; the action should be filtered out by `when`.
+    expect(paletteRowsNamed(/Mark ready for review/i)).toHaveLength(0);
+  });
+});
diff --git a/frontend/src/App.svelte b/frontend/src/App.svelte
index 06204bd4a..fd41c3eb2 100644
--- a/frontend/src/App.svelte
+++ b/frontend/src/App.svelte
@@ -171,6 +171,11 @@
 
   function stopFullAppShell() {
     fullShellStores?.events.disconnect();
+    // runAppStartup begins sync polling once the shell is ready; its cancel
+    // only aborts in-flight startup, so the interval must be stopped here or
+    // it keeps firing after teardown (leaking across embed-route navigation
+    // and, in jsdom tests, hitting whichever fetch stub is current).
+    fullShellStores?.sync.stopPolling();
     cleanupFullAppShell?.();
     cleanupFullAppShell = undefined;
     fullShellStores = undefined;
diff --git a/frontend/src/App.teardown.test.ts b/frontend/src/App.teardown.test.ts
new file mode 100644
index 000000000..4c4490a9d
--- /dev/null
+++ b/frontend/src/App.teardown.test.ts
@@ -0,0 +1,57 @@
+// Unmounting the app shell must stop the sync polling interval. runAppStartup
+// starts it after readiness, and a leaked interval keeps firing across tests
+// against whichever fetch stub is current (and keeps workers alive). Guards
+// the stopPolling() call wired into stopFullAppShell.
+//
+// Note: this test wraps the global interval timers but never uses waitFor
+// (which itself polls on setInterval and would be counted as a live timer).
+// Svelte runs onDestroy synchronously on unmount, so the post-unmount
+// assertion is synchronous.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, resetKeyboardModuleState } from "./test/appHarness.js";
+
+describe("app shell teardown", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  let cleanupTimers = (): void => {};
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanupTimers();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("stops sync polling on unmount so no interval outlives the test", async () => {
+    const live = new Set<ReturnType<typeof setInterval>>();
+    const realSet = globalThis.setInterval.bind(globalThis);
+    const realClear = globalThis.clearInterval.bind(globalThis);
+    vi.stubGlobal("setInterval", (...args: Parameters<typeof setInterval>) => {
+      const handle = realSet(...args);
+      live.add(handle);
+      return handle;
+    });
+    vi.stubGlobal("clearInterval", (handle: Parameters<typeof clearInterval>[0]) => {
+      if (handle !== undefined) live.delete(handle as ReturnType<typeof setInterval>);
+      return realClear(handle);
+    });
+    cleanupTimers = () => live.forEach((h) => realClear(h));
+
+    const app = await mountApp("/pulls");
+    // Let startup run (readiness -> settings -> onReady -> sync.startPolling).
+    // Real setTimeout is left unstubbed, so this is a genuine settle.
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    expect(live.size).toBeGreaterThan(0);
+
+    // onDestroy runs synchronously: stopFullAppShell -> sync.stopPolling +
+    // each component effect's interval cleanup -> every interval cleared.
+    app.unmount();
+    expect(live.size).toBe(0);
+  });
+});
diff --git a/frontend/src/lib/components/layout/StatusBar.budget.test.ts b/frontend/src/lib/components/layout/StatusBar.budget.test.ts
new file mode 100644
index 000000000..398764e67
--- /dev/null
+++ b/frontend/src/lib/components/layout/StatusBar.budget.test.ts
@@ -0,0 +1,303 @@
+// Budget bars and popover in the status bar, rendered through the real app
+// shell with rate-limit data mocked at the fetch boundary.
+//
+// Color expectations are asserted on the inline style values the components
+// set (`var(--budget-red)`), not on computed rgb pixels: jsdom does not
+// resolve CSS custom properties, and the token is the semantic contract.
+
+import { cleanup, screen, waitFor } from "@testing-library/svelte";
+import { fireEvent } from "@testing-library/svelte";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+
+import { installAppDomGlobals, mountApp, resetKeyboardModuleState } from "../../../test/appHarness.js";
+import { jsonResponse, type MockRouteOverride } from "../../../test/mockApiFetch.js";
+
+function rateLimits(hosts: Record<string, unknown>): MockRouteOverride {
+  return (req) => {
+    if (req.method !== "GET" || req.url.pathname !== "/api/v1/rate-limits") return null;
+    return jsonResponse({ hosts });
+  };
+}
+
+const knownHost = {
+  requests_hour: 100,
+  rate_remaining: 4500,
+  rate_limit: 5000,
+  rate_reset_at: new Date(Date.now() + 30 * 60_000).toISOString(),
+  hour_start: new Date().toISOString(),
+  sync_throttle_factor: 1,
+  sync_paused: false,
+  reserve_buffer: 200,
+  known: true,
+  budget_limit: 500,
+  budget_spent: 100,
+  budget_remaining: 400,
+  gql_remaining: 4900,
+  gql_limit: 5000,
+  gql_reset_at: new Date(Date.now() + 25 * 60_000).toISOString(),
+  gql_known: true,
+};
+
+const unknownHost = {
+  requests_hour: 0,
+  rate_remaining: -1,
+  rate_limit: -1,
+  rate_reset_at: "",
+  hour_start: new Date().toISOString(),
+  sync_throttle_factor: 1,
+  sync_paused: false,
+  reserve_buffer: 200,
+  known: false,
+  budget_limit: 0,
+  budget_spent: 0,
+  budget_remaining: 0,
+  gql_remaining: -1,
+  gql_limit: -1,
+  gql_reset_at: "",
+  gql_known: false,
+};
+
+const pausedHost = {
+  requests_hour: 500,
+  rate_remaining: 50,
+  rate_limit: 5000,
+  rate_reset_at: new Date(Date.now() + 10 * 60_000).toISOString(),
+  hour_start: new Date().toISOString(),
+  sync_throttle_factor: 8,
+  sync_paused: true,
+  reserve_buffer: 200,
+  known: true,
+  budget_limit: 500,
+  budget_spent: 400,
+  budget_remaining: 100,
+  gql_remaining: 100,
+  gql_limit: 5000,
+  gql_reset_at: new Date(Date.now() + 10 * 60_000).toISOString(),
+  gql_known: true,
+};
+
+async function mountStatusBar(overrides: MockRouteOverride[] = []): Promise<HTMLElement> {
+  await mountApp("/pulls", { overrides });
+  await waitFor(() => expect(document.querySelector(".budget-bars")).not.toBeNull());
+  return document.querySelector<HTMLElement>(".budget-bars")!;
+}
+
+async function openPopover(bars: HTMLElement): Promise<HTMLElement> {
+  await fireEvent.click(bars);
+  await waitFor(() => expect(screen.getByRole("dialog", { name: "API Budget" })).toBeTruthy());
+  return screen.getByRole("dialog", { name: "API Budget" });
+}
+
+function healthDot(popover: HTMLElement, hostname: string): HTMLElement {
+  const section = Array.from(popover.querySelectorAll<HTMLElement>(".host-section")).find((s) =>
+    s.textContent?.includes(hostname),
+  );
+  expect(section).toBeTruthy();
+  const dot = section!.querySelector<HTMLElement>(".health-dot");
+  expect(dot).toBeTruthy();
+  return dot!;
+}
+
+describe("budget display", () => {
+  vi.setConfig({ testTimeout: 20_000 });
+
+  beforeEach(() => {
+    installAppDomGlobals();
+  });
+
+  afterEach(async () => {
+    cleanup();
+    vi.unstubAllGlobals();
+    localStorage.clear();
+    await resetKeyboardModuleState();
+  });
+
+  it("status bar shows budget bars with known data", async () => {
+    const bars = await mountStatusBar();
+    expect(bars.textContent).toContain("REST");
+    expect(bars.textContent).toContain("GQL");
+  });
+
+  it("budget bars show middleman count when budget enabled", async () => {
+    const bars = await mountStatusBar();
+    expect(bars.textContent).toContain("42 req/hr");
+  });
+
+  // The popover dialog exposes REST req, GraphQL pts, and the middleman
+  // budget spend from the same payload.
+  it("clicking budget area opens popover with per-host breakdown", async () => {
+    const bars = await mountStatusBar();
+    const popover = await openPopover(bars);
+    const units = Array.from(popover.querySelectorAll(".row-unit")).map((el) => el.textContent?.trim());
+    expect(units).toContain("req");
+    expect(units).toContain("pts");
+    expect(popover.querySelector(".budget-spent")?.textContent).toBe("42");
+  });
+
+  it("popover dismisses on Escape", async () => {
+    const bars = await mountStatusBar();
+    await openPopover(bars);
+
+    await fireEvent.keyDown(document, { key: "Escape" });
+    await waitFor(() => expect(document.querySelector(".budget-popover")).toBeNull());
+  });
+
+  it("popover dismisses on click outside", async () => {
+    const bars = await mountStatusBar();
+    await openPopover(bars);
+
+    // Popover attaches its outside-click listener via setTimeout(0) to
+    // avoid catching the opening click. Let that timer run before
+    // clicking outside.
+    await new Promise((resolve) => setTimeout(resolve, 5));
+
+    await fireEvent.click(document.querySelector(".app-main")!);
+    await waitFor(() => expect(document.querySelector(".budget-popover")).toBeNull());
+  });
+
+  // Merges the Enter/Space keyboard cases from both original suites: jsdom
+  // does not synthesize click from Enter/Space the way a browser's native
+  // button activation does, so the conversion asserts the platform
+  // guarantee directly — the trigger is a real <button>, whose activation
+  // (click) opens the popover and Escape closes it.
+  it("popover trigger is a native button so Enter/Space activate it", async () => {
+    const bars = await mountStatusBar();
+    expect(bars.tagName).toBe("BUTTON");
+    expect(bars.getAttribute("aria-haspopup")).toBe("dialog");
+    expect(bars.getAttribute("aria-expanded")).toBe("false");
+
+    bars.focus();
+    expect(document.activeElement).toBe(bars);
+    await fireEvent.click(bars);
+    await waitFor(() => expect(document.querySelector(".budget-popover")).not.toBeNull());
+    expect(bars.getAttribute("aria-expanded")).toBe("true");
+
+    await fireEvent.keyDown(document, { key: "Escape" });
+    await waitFor(() => expect(document.querySelector(".budget-popover")).toBeNull());
+  });
+
+  it("mixed known/unknown hosts show worst-case from known only", async () => {
+    const bars = await mountStatusBar([
+      rateLimits({
+        "github.com": knownHost,
+        "ghe.corp.example.com": unknownHost,
+      }),
+    ]);
+
+    // Should show REST/GQL labels (not --) because github.com is known
+    expect(bars.textContent).toContain("REST");
+    expect(bars.textContent).toContain("GQL");
+
+    // REST bar fill should reflect github.com's known ratio
+    expect(bars.querySelector(".budget-fill")).not.toBeNull();
+
+    // Popover should show both hosts
+    const popover = await openPopover(bars);
+    expect(popover.textContent).toContain("github.com");
+    expect(popover.textContent).toContain("ghe.corp.example.com");
+    // Known host shows compact ratio + abbreviated unit
+    expect(popover.textContent).toMatch(/4\.5k\s*\/\s*5k\s+req\b/);
+    expect(popover.textContent).toContain("not yet observed");
+
+    // Unknown host's health dot must be tagged unknown so it renders
+    // with the muted color token instead of a budget color.
+    expect(healthDot(popover, "github.com").classList.contains("health-dot--unknown")).toBe(false);
+    expect(healthDot(popover, "ghe.corp.example.com").classList.contains("health-dot--unknown")).toBe(true);
+  });
+
+  it("budget bars show unknown state when host not known", async () => {
+    const bars = await mountStatusBar([rateLimits({ "github.com": unknownHost })]);
+
+    // Unknown state: labels show -- instead of REST/GQL
+    expect(bars.textContent).toContain("--");
+    expect(bars.textContent).not.toContain("REST");
+    expect(bars.textContent).not.toContain("GQL");
+    // No budget count when budget disabled
+    expect(bars.textContent).not.toContain("req/hr");
+  });
+
+  it("paused host shows red bars and sync paused indicator", async () => {
+    const bars = await mountStatusBar([rateLimits({ "github.com": pausedHost })]);
+
+    expect(bars.textContent).toContain("REST");
+    // Bar fill should use the budget-red token when paused
+    const restFill = bars.querySelector<HTMLElement>(".budget-fill");
+    expect(restFill).not.toBeNull();
+    expect(restFill!.style.background).toBe("var(--budget-red)");
+
+    // Open popover — should show "sync paused" indicator
+    const popover = await openPopover(bars);
+    expect(popover.textContent).toContain("sync paused");
+    // Single-host mode hides hostname header (and health dot).
+    // Health dot color is tested in the multi-host paused case below.
+  });
+
+  it("paused multi-host shows red health dot in popover", async () => {
+    const freshSecondHost = {
+      ...unknownHost,
+      requests_hour: 10,
+      rate_remaining: 4900,
+      rate_limit: 5000,
+      rate_reset_at: new Date(Date.now() + 50 * 60_000).toISOString(),
+      known: true,
+    };
+    const bars = await mountStatusBar([
+      rateLimits({
+        "github.com": pausedHost,
+        "ghe.example.com": freshSecondHost,
+      }),
+    ]);
+
+    const popover = await openPopover(bars);
+    // Paused host (github.com) health dot should be the red token
+    expect(healthDot(popover, "github.com").style.background).toBe("var(--budget-red)");
+  });
+
+  it("GQL known but REST unknown still shows budget count", async () => {
+    const bars = await mountStatusBar([
+      rateLimits({
+        "github.com": {
+          ...unknownHost,
+          budget_limit: 500,
+          budget_spent: 10,
+          budget_remaining: 490,
+          gql_remaining: 4800,
+          gql_limit: 5000,
+          gql_reset_at: new Date(Date.now() + 30 * 60_000).toISOString(),
+          gql_known: true,
+        },
+      }),
+    ]);
+
+    // GQL bar should show (known), REST should show -- placeholder
+    expect(bars.textContent).toContain("GQL");
+    expect(bars.textContent).not.toContain("REST");
+    expect(bars.textContent).toContain("--");
+    // Budget count visible — budget is independent of REST rate observation
+    expect(bars.textContent).toContain("10 req/hr");
+  });
+
+  it("stale host excluded from compact bars, fresh host drives ratio", async () => {
+    const staleHost = {
+      ...unknownHost,
+      rate_limit: 5000,
+      known: true,
+    };
+    const bars = await mountStatusBar([
+      rateLimits({
+        "github.com": knownHost,
+        "ghe.example.com": staleHost,
+      }),
+    ]);
+
+    // Compact bars should show REST/GQL from the fresh host (github.com)
+    expect(bars.textContent).toContain("REST");
+    expect(bars.textContent).toContain("GQL");
+    // Bar fill should be present (driven by fresh host, not stale)
+    expect(bars.querySelector(".budget-fill")).not.toBeNull();
+
+    // Popover: stale host health dot should be muted
+    const popover = await openPopover(bars);
+    expect(healthDot(popover, "ghe.example.com").classList.contains("health-dot--unknown")).toBe(true);
+  });
+});
diff --git a/frontend/src/lib/testing/AppProviderMock.svelte b/frontend/src/lib/testing/AppProviderMock.svelte
index 4e8b79803..f168716f6 100644
--- a/frontend/src/lib/testing/AppProviderMock.svelte
+++ b/frontend/src/lib/testing/AppProviderMock.svelte
@@ -22,6 +22,11 @@
     events: {
       disconnect: noop,
     },
+    // stopFullAppShell stops sync polling on teardown; the mock store must
+    // expose it or onDestroy throws once the shell has started.
+    sync: {
+      stopPolling: noop,
+    },
     pulls: {
       getSelectedPR: () => null,
       loadPulls: noop,
diff --git a/frontend/src/test/appHarness.ts b/frontend/src/test/appHarness.ts
new file mode 100644
index 000000000..89d864122
--- /dev/null
+++ b/frontend/src/test/appHarness.ts
@@ -0,0 +1,165 @@
+// Shared jsdom harness for mounting the real App shell (real Provider, real
+// stores, real views) with the API mocked at the fetch boundary. Used by
+// component tests converted from the Playwright mock-API e2e suite.
+
+import { act, render } from "@testing-library/svelte";
+import { vi } from "vite-plus/test";
+
+import { createMockApiFetch, type MockApiHandle, type MockRouteOverride } from "./mockApiFetch.js";
+
+class StubEventSource {
+  static instances: StubEventSource[] = [];
+  url: string;
+  readyState = 0;
+  onopen: ((ev: unknown) => void) | null = null;
+  onmessage: ((ev: unknown) => void) | null = null;
+  onerror: ((ev: unknown) => void) | null = null;
+
+  constructor(url: string) {
+    this.url = url;
+    StubEventSource.instances.push(this);
+  }
+
+  addEventListener(): void {}
+  removeEventListener(): void {}
+  dispatchEvent(): boolean {
+    return false;
+  }
+  close(): void {
+    this.readyState = 2;
+  }
+}
+
+export function installAppDomGlobals(): void {
+  vi.stubGlobal("matchMedia", (query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  }));
+  vi.stubGlobal(
+    "ResizeObserver",
+    class {
+      observe = vi.fn();
+      unobserve = vi.fn();
+      disconnect = vi.fn();
+    },
+  );
+  vi.stubGlobal(
+    "IntersectionObserver",
+    class {
+      observe = vi.fn();
+      unobserve = vi.fn();
+      disconnect = vi.fn();
+      takeRecords = vi.fn(() => []);
+    },
+  );
+  vi.stubGlobal("EventSource", StubEventSource);
+  if (typeof Element.prototype.scrollIntoView !== "function") {
+    Element.prototype.scrollIntoView = () => {};
+  }
+  // xterm probes a canvas context during module evaluation; jsdom logs a
+  // loud "not implemented" error for it. Returning null keeps it quiet.
+  HTMLCanvasElement.prototype.getContext = (() => null) as typeof HTMLCanvasElement.prototype.getContext;
+}
+
+export interface MountedApp {
+  api: MockApiHandle;
+  target: HTMLElement;
+  unmount: () => void;
+}
+
+export interface MountAppOptions {
+  overrides?: MockRouteOverride[];
+  /**
+   * Simulated layout width in px. jsdom has no real layout, so this drives
+   * both window.innerWidth and the #app element's clientWidth, which the
+   * container store classifies. Defaults to a desktop width.
+   */
+  viewportWidth?: number;
+}
+
+/**
+ * Mount the real App.svelte at the given in-app path with fetch served by
+ * the mock API fixtures. Equivalent to the Playwright mock suite's
+ * `mockApi(page); page.goto(path)`.
+ */
+export async function mountApp(path: string, options: MountAppOptions = {}): Promise<MountedApp> {
+  const api = createMockApiFetch(options.overrides ?? []);
+  vi.stubGlobal("fetch", api.fetch);
+
+  const width = options.viewportWidth ?? 1280;
+  Object.defineProperty(window, "innerWidth", { value: width, configurable: true, writable: true });
+
+  window.history.replaceState(null, "", path);
+  const { replaceUrl } = await import("../lib/stores/router.svelte.js");
+  replaceUrl(path);
+
+  // App.svelte resolves its container by id; a leftover #app from an
+  // earlier mount in the same test would shadow this one.
+  document.getElementById("app")?.remove();
+  const target = document.createElement("div");
+  target.id = "app";
+  Object.defineProperty(target, "clientWidth", { value: width, configurable: true });
+  document.body.appendChild(target);
+
+  const { default: App } = await import("../App.svelte");
+  const { unmount } = render(App, { target });
+
+  return {
+    api,
+    target,
+    unmount: () => {
+      unmount();
+      target.remove();
+    },
+  };
+}
+
+/**
+ * Re-parse the current URL through the router, mirroring what a browser
+ * back/forward (popstate) does after history.pushState.
+ */
+export async function firePopstate(path: string): Promise<void> {
+  window.history.pushState(null, "", path);
+  await act(() => {
+    window.dispatchEvent(new PopStateEvent("popstate"));
+  });
+}
+
+/**
+ * Dispatch a keydown on window the way a real keystroke reaches the app
+ * shell's global handler. `target` defaults to document.body.
+ */
+export async function resetKeyboardModuleState(): Promise<void> {
+  const { resetPaletteState } = await import("../lib/stores/keyboard/palette-state.svelte.js");
+  const { resetCheatsheetState } = await import("../lib/stores/keyboard/cheatsheet-state.svelte.js");
+  const { resetRegistry } = await import("../lib/stores/keyboard/registry.svelte.js");
+  const { resetModalStack } = await import("@middleman/ui/stores/keyboard/modal-stack");
+  resetPaletteState();
+  resetCheatsheetState();
+  resetRegistry();
+  resetModalStack();
+}
+
+export function pressKey(
+  key: string,
+  modifiers: { meta?: boolean; ctrl?: boolean; shift?: boolean; alt?: boolean } = {},
+  target: EventTarget | null = document.activeElement ?? document.body,
+): KeyboardEvent {
+  const event = new KeyboardEvent("keydown", {
+    key,
+    metaKey: modifiers.meta ?? false,
+    ctrlKey: modifiers.ctrl ?? false,
+    shiftKey: modifiers.shift ?? false,
+    altKey: modifiers.alt ?? false,
+    bubbles: true,
+    cancelable: true,
+  });
+  (target ?? document.body).dispatchEvent(event);
+  return event;
+}
diff --git a/frontend/src/test/mockApiFetch.ts b/frontend/src/test/mockApiFetch.ts
new file mode 100644
index 000000000..aac27b9ae
--- /dev/null
+++ b/frontend/src/test/mockApiFetch.ts
@@ -0,0 +1,717 @@
+// Shared mock of the middleman REST API: one set of fixtures and one
+// /api/v1 route matcher consumed by two thin adapters so the suites cannot
+// drift apart:
+//
+//   - createMockApiFetch: fetch adapter for jsdom component tests (tests
+//     stub globalThis.fetch with it);
+//   - createMockApiHandler: transport-neutral core, also wrapped by the
+//     Playwright page.route adapter in tests/e2e/support/mockApi.ts.
+//
+// This module must stay free of @playwright/test imports. Unhandled paths
+// get a JSON 404 so optional endpoints fail softly in both suites.
+
+const defaultProviderCapabilities = {
+  read_repositories: true,
+  read_merge_requests: true,
+  read_issues: true,
+  read_comments: true,
+  read_releases: true,
+  read_ci: true,
+  read_labels: true,
+  comment_mutation: true,
+  state_mutation: true,
+  merge_mutation: true,
+  label_mutation: true,
+  review_mutation: true,
+  workflow_approval: true,
+  ready_for_review: true,
+  issue_mutation: true,
+  review_draft_mutation: false,
+  review_thread_resolution: false,
+  read_review_threads: false,
+  native_multiline_ranges: false,
+  mutation_head_binding: false,
+  thread_reply: false,
+  thread_resolve: false,
+  supported_review_actions: [],
+};
+
+const defaultOperationAvailability = { available: true };
+
+const defaultRepoOperations = {
+  add_comment: defaultOperationAvailability,
+  add_label: defaultOperationAvailability,
+  approve_workflow: defaultOperationAvailability,
+  close_issue: defaultOperationAvailability,
+  close_pr: defaultOperationAvailability,
+  mark_ready_for_review: defaultOperationAvailability,
+  merge_pr: defaultOperationAvailability,
+  remove_label: defaultOperationAvailability,
+  reopen_issue: defaultOperationAvailability,
+  reopen_pr: defaultOperationAvailability,
+  submit_review: defaultOperationAvailability,
+};
+
+function repoRef(owner: string, name: string, platformHost: string) {
+  return {
+    provider: "github",
+    platform_host: platformHost,
+    repo_path: `${owner}/${name}`,
+    owner,
+    name,
+    capabilities: defaultProviderCapabilities,
+  };
+}
+
+const pulls = [
+  {
+    ID: 1,
+    RepoID: 1,
+    GitHubID: 101,
+    Number: 42,
+    URL: "https://github.com/acme/widgets/pull/42",
+    Title: "Add browser regression coverage",
+    Author: "marius",
+    State: "open",
+    IsDraft: false,
+    Body: "Adds Playwright smoke tests for workspace panel.",
+    HeadBranch: "feature/playwright",
+    BaseBranch: "main",
+    Additions: 120,
+    Deletions: 12,
+    CommentCount: 3,
+    ReviewDecision: "APPROVED",
+    CIStatus: "success",
+    CIChecksJSON: "[]",
+    CreatedAt: "2026-03-29T14:00:00Z",
+    UpdatedAt: "2026-03-30T14:00:00Z",
+    LastActivityAt: "2026-03-30T14:00:00Z",
+    MergedAt: null,
+    ClosedAt: null,
+    KanbanStatus: "reviewing",
+    Starred: false,
+    repo_owner: "acme",
+    repo_name: "widgets",
+    platform_host: "github.com",
+    platform_head_sha: "42aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa42",
+    repo: repoRef("acme", "widgets", "github.com"),
+    worktree_links: [],
+  },
+  {
+    ID: 2,
+    RepoID: 2,
+    GitHubID: 201,
+    Number: 84,
+    URL: "https://example.com/acme/widgets/pull/84",
+    Title: "Mirror host stub PR",
+    Author: "marius",
+    State: "open",
+    IsDraft: false,
+    Body: "",
+    HeadBranch: "mirror/stub",
+    BaseBranch: "main",
+    Additions: 1,
+    Deletions: 0,
+    CommentCount: 0,
+    ReviewDecision: "",
+    CIStatus: "success",
+    CIChecksJSON: "[]",
+    CreatedAt: "2026-03-29T14:00:00Z",
+    UpdatedAt: "2026-03-30T14:00:00Z",
+    LastActivityAt: "2026-03-30T14:00:00Z",
+    MergedAt: null,
+    ClosedAt: null,
+    KanbanStatus: "new",
+    Starred: false,
+    repo_owner: "acme",
+    repo_name: "widgets",
+    platform_host: "example.com",
+    platform_head_sha: "84bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb84",
+    repo: repoRef("acme", "widgets", "example.com"),
+    worktree_links: [],
+  },
+  {
+    ID: 3,
+    RepoID: 1,
+    GitHubID: 301,
+    Number: 55,
+    URL: "https://github.com/acme/widgets/pull/55",
+    Title: "Refactor theme system",
+    Author: "luisa",
+    State: "open",
+    IsDraft: false,
+    Body: "Consolidates theme tokens.",
+    HeadBranch: "refactor/theme",
+    BaseBranch: "main",
+    Additions: 80,
+    Deletions: 40,
+    CommentCount: 0,
+    ReviewDecision: "",
+    CIStatus: "pending",
+    CIChecksJSON: "[]",
+    CreatedAt: "2026-03-29T14:00:00Z",
+    UpdatedAt: "2026-03-30T14:00:00Z",
+    LastActivityAt: "2026-03-30T14:00:00Z",
+    MergedAt: null,
+    ClosedAt: null,
+    KanbanStatus: "new",
+    Starred: false,
+    repo_owner: "acme",
+    repo_name: "widgets",
+    platform_host: "github.com",
+    platform_head_sha: "55cccccccccccccccccccccccccccccccccccc55",
+    repo: repoRef("acme", "widgets", "github.com"),
+    worktree_links: [
+      {
+        worktree_key: "projects/theme-rework",
+        worktree_branch: "refactor/theme",
+      },
+    ],
+  },
+];
+
+const issues = [
+  {
+    ID: 2,
+    RepoID: 1,
+    GitHubID: 202,
+    Number: 7,
+    URL: "https://github.com/acme/widgets/issues/7",
+    Title: "Theme toggle does not stick",
+    Author: "marius",
+    State: "open",
+    Body: "",
+    CommentCount: 1,
+    LabelsJSON: "[]",
+    CreatedAt: "2026-03-28T14:00:00Z",
+    UpdatedAt: "2026-03-30T14:00:00Z",
+    LastActivityAt: "2026-03-30T14:00:00Z",
+    ClosedAt: null,
+    Starred: false,
+    platform_host: "github.com",
+    repo_owner: "acme",
+    repo_name: "widgets",
+    repo: repoRef("acme", "widgets", "github.com"),
+  },
+];
+
+const repos = [
+  {
+    ID: 1,
+    Owner: "acme",
+    Name: "widgets",
+    Platform: "github",
+    PlatformHost: "github.com",
+    AllowSquashMerge: true,
+    AllowMergeCommit: true,
+    AllowRebaseMerge: true,
+    BackfillIssueComplete: true,
+    BackfillIssueCompletedAt: "2026-03-30T14:00:30Z",
+    BackfillIssuePage: 1,
+    BackfillPRComplete: true,
+    BackfillPRCompletedAt: "2026-03-30T14:00:30Z",
+    BackfillPRPage: 1,
+    ViewerCanMerge: true,
+    LastSyncStartedAt: "2026-03-30T14:00:00Z",
+    LastSyncCompletedAt: "2026-03-30T14:00:30Z",
+    LastSyncError: "",
+    CreatedAt: "2026-03-01T00:00:00Z",
+    capabilities: defaultProviderCapabilities,
+    operations: defaultRepoOperations,
+  },
+];
+
+// Twelve repos with open PRs on only a few of them, so switching the summary
+// page filter between "All" (2-digit count) and "Has PRs" (1-digit count)
+// exercises the results-label digit change.
+const repoSummaries = Array.from({ length: 12 }, (_, i) => {
+  const name = `repo-${String(i + 1).padStart(2, "0")}`;
+  return {
+    owner: "acme",
+    name,
+    platform_host: "github.com",
+    repo: {
+      provider: "github",
+      platform_host: "github.com",
+      owner: "acme",
+      name,
+      repo_path: `acme/${name}`,
+    },
+    cached_pr_count: i < 4 ? 3 : 0,
+    open_pr_count: i < 4 ? 3 : 0,
+    draft_pr_count: 0,
+    cached_issue_count: i < 3 ? 2 : 0,
+    open_issue_count: i < 3 ? 2 : 0,
+    most_recent_activity_at: "2026-03-30T12:00:00Z",
+    last_sync_completed_at: "2026-03-30T14:00:30Z",
+    last_sync_started_at: "2026-03-30T14:00:00Z",
+    last_sync_error: "",
+    active_authors: [],
+    recent_issues: [],
+  };
+});
+
+const syncStatus = {
+  running: false,
+  last_run_at: "2026-03-30T14:00:30Z",
+  last_error: "",
+};
+
+const settings = {
+  repos: [
+    {
+      provider: "github",
+      platform_host: "github.com",
+      owner: "acme",
+      name: "widgets",
+      repo_path: "acme/widgets",
+      is_glob: false,
+      matched_repo_count: 1,
+    },
+  ],
+  activity: {
+    view_mode: "threaded",
+    time_range: "7d",
+    hide_closed: false,
+    hide_bots: false,
+  },
+  terminal: {
+    font_family: "",
+    font_size: 14,
+    scrollback: 1000,
+    line_height: 1,
+    letter_spacing: 0,
+    cursor_blink: true,
+    font_ligatures: false,
+    renderer: "xterm",
+  },
+  agents: [],
+};
+
+export function makeRateLimits() {
+  const now = Date.now();
+  return {
+    hosts: {
+      "github.com": {
+        requests_hour: 188,
+        rate_remaining: 4812,
+        rate_limit: 5000,
+        rate_reset_at: new Date(now + 42 * 60_000).toISOString(),
+        hour_start: new Date(now - 18 * 60_000).toISOString(),
+        sync_throttle_factor: 1,
+        sync_paused: false,
+        reserve_buffer: 200,
+        known: true,
+        budget_limit: 500,
+        budget_spent: 42,
+        budget_remaining: 458,
+        gql_remaining: 4950,
+        gql_limit: 5000,
+        gql_reset_at: new Date(now + 38 * 60_000).toISOString(),
+        gql_known: true,
+      },
+    },
+  };
+}
+
+export function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(body === undefined ? null : JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" },
+  });
+}
+
+function decodePathSegment(segment: string | undefined): string {
+  return decodeURIComponent(segment ?? "");
+}
+
+function canonicalProvider(provider: string): string {
+  const normalized = provider.toLowerCase();
+  if (normalized === "gh") return "github";
+  if (normalized === "gl") return "gitlab";
+  if (normalized === "fj") return "forgejo";
+  return normalized;
+}
+
+function defaultPlatformHost(provider: string): string {
+  switch (canonicalProvider(provider)) {
+    case "github":
+      return "github.com";
+    case "gitlab":
+      return "gitlab.com";
+    case "forgejo":
+      return "codeberg.org";
+    case "gitea":
+      return "gitea.com";
+    default:
+      return "";
+  }
+}
+
+function routePlatformHost(provider: string, hostSegment: string | undefined): string {
+  const host = decodePathSegment(hostSegment).trim();
+  return host || defaultPlatformHost(provider);
+}
+
+function matchesRouteIdentity(
+  candidate: {
+    repo?: { provider?: string | undefined } | undefined;
+    platform_host: string;
+    repo_owner: string;
+    repo_name: string;
+    Number: number;
+  },
+  ref: {
+    provider: string;
+    platformHost: string;
+    owner: string;
+    name: string;
+    number: number;
+  },
+): boolean {
+  return (
+    canonicalProvider(candidate.repo?.provider ?? "") === ref.provider &&
+    candidate.platform_host === ref.platformHost &&
+    candidate.repo_owner === ref.owner &&
+    candidate.repo_name === ref.name &&
+    candidate.Number === ref.number
+  );
+}
+
+function pullDetailResponse(pr: (typeof pulls)[number]) {
+  return {
+    merge_request: pr,
+    repo: pr.repo,
+    repo_owner: pr.repo_owner,
+    repo_name: pr.repo_name,
+    platform_host: pr.platform_host,
+    platform_head_sha: pr.platform_head_sha ?? "",
+    reviewed_head_sha: pr.platform_head_sha ?? "",
+    detail_loaded: true,
+    detail_fetched_at: "2026-03-30T14:00:00Z",
+    worktree_links: pr.worktree_links,
+  };
+}
+
+export interface MockRequest {
+  method: string;
+  url: URL;
+  bodyText: string;
+}
+
+/**
+ * Route override, equivalent to layering an extra page.route over mockApi
+ * in the Playwright suite. Return a Response to handle the request, or
+ * null/undefined to fall through to the default fixtures.
+ */
+export type MockRouteOverride = (req: MockRequest) => Response | null | undefined;
+
+export interface MockApiHandler {
+  /** Resolve one request against overrides, then the default fixtures. */
+  handle: (req: MockRequest) => Response;
+  /** Every request seen by this handler, in order. */
+  requests: MockRequest[];
+}
+
+export interface MockApiHandle {
+  fetch: typeof globalThis.fetch;
+  /** Every request the app issued, in order. */
+  requests: MockRequest[];
+}
+
+export function createMockApiHandler(overrides: MockRouteOverride[] = []): MockApiHandler {
+  // Deep-clone so mutations (e.g. PATCH) don't leak between tests.
+  const localPulls: typeof pulls = JSON.parse(JSON.stringify(pulls));
+  const requests: MockRequest[] = [];
+
+  function handle(req: MockRequest): Response {
+    requests.push(req);
+    for (const override of overrides) {
+      const res = override(req);
+      if (res) return res;
+    }
+
+    const { method } = req;
+    const { pathname } = req.url;
+
+    if (method === "GET" && pathname === "/api/v1/pulls") {
+      return jsonResponse(localPulls);
+    }
+
+    const providerPrMatch = pathname.match(
+      /^\/api\/v1(?:\/host\/([^/]+))?\/pulls\/([^/]+)\/([^/]+)\/([^/]+)\/(\d+)(?:\/(sync|sync\/async))?$/,
+    );
+    if (
+      providerPrMatch &&
+      ((method === "GET" && !providerPrMatch[6]) || (method === "POST" && providerPrMatch[6]?.startsWith("sync")))
+    ) {
+      const prProvider = canonicalProvider(decodePathSegment(providerPrMatch[2]));
+      const platformHost = routePlatformHost(prProvider, providerPrMatch[1]);
+      const prOwner = decodePathSegment(providerPrMatch[3]);
+      const prName = decodePathSegment(providerPrMatch[4]);
+      const prNumber = parseInt(providerPrMatch[5]!, 10);
+      const pr = localPulls.find((p) =>
+        matchesRouteIdentity(p, {
+          provider: prProvider,
+          platformHost,
+          owner: prOwner,
+          name: prName,
+          number: prNumber,
+        }),
+      );
+      if (pr) {
+        return jsonResponse(pullDetailResponse(pr));
+      }
+      return jsonResponse({ error: "Not found" }, 404);
+    }
+
+    if (providerPrMatch && method === "PATCH" && !providerPrMatch[6]) {
+      const prProvider = canonicalProvider(decodePathSegment(providerPrMatch[2]));
+      const platformHost = routePlatformHost(prProvider, providerPrMatch[1]);
+      const prOwner = decodePathSegment(providerPrMatch[3]);
+      const prName = decodePathSegment(providerPrMatch[4]);
+      const prNumber = parseInt(providerPrMatch[5]!, 10);
+      const pr = localPulls.find((p) =>
+        matchesRouteIdentity(p, {
+          provider: prProvider,
+          platformHost,
+          owner: prOwner,
+          name: prName,
+          number: prNumber,
+        }),
+      );
+      if (!pr) {
+        return jsonResponse({ title: "Not found" }, 404);
+      }
+      const reqBody = JSON.parse(req.bodyText || "{}");
+      if (reqBody.title !== undefined) pr.Title = reqBody.title;
+      if (reqBody.body !== undefined) pr.Body = reqBody.body;
+      return jsonResponse(pullDetailResponse(pr));
+    }
+
+    const approvePrMatch = pathname.match(
+      /^\/api\/v1(?:\/host\/([^/]+))?\/pulls\/([^/]+)\/([^/]+)\/([^/]+)\/(\d+)\/approve$/,
+    );
+    if (approvePrMatch && method === "POST") {
+      const prProvider = canonicalProvider(decodePathSegment(approvePrMatch[2]));
+      const platformHost = routePlatformHost(prProvider, approvePrMatch[1]);
+      const prOwner = decodePathSegment(approvePrMatch[3]);
+      const prName = decodePathSegment(approvePrMatch[4]);
+      const prNumber = parseInt(approvePrMatch[5]!, 10);
+      const pr = localPulls.find((p) =>
+        matchesRouteIdentity(p, {
+          provider: prProvider,
+          platformHost,
+          owner: prOwner,
+          name: prName,
+          number: prNumber,
+        }),
+      );
+      if (!pr) {
+        return jsonResponse({ title: "Not found" }, 404);
+      }
+      return jsonResponse({ status: "approved" });
+    }
+
+    const singlePrMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)$/);
+    if (method === "GET" && singlePrMatch) {
+      const prOwner = singlePrMatch[1];
+      const prName = singlePrMatch[2];
+      const prNumber = parseInt(singlePrMatch[3]!, 10);
+      const pr = localPulls.find((p) => p.repo_owner === prOwner && p.repo_name === prName && p.Number === prNumber);
+      if (pr) {
+        return jsonResponse(pullDetailResponse(pr));
+      }
+      return jsonResponse({ error: "Not found" }, 404);
+    }
+
+    if (method === "GET" && pathname === "/api/v1/issues") {
+      return jsonResponse(issues);
+    }
+
+    const providerIssueMatch = pathname.match(
+      /^\/api\/v1(?:\/host\/([^/]+))?\/issues\/([^/]+)\/([^/]+)\/([^/]+)\/(\d+)(?:\/(sync|sync\/async))?$/,
+    );
+    if (
+      providerIssueMatch &&
+      ((method === "GET" && !providerIssueMatch[6]) || (method === "POST" && providerIssueMatch[6]?.startsWith("sync")))
+    ) {
+      const issueProvider = canonicalProvider(decodePathSegment(providerIssueMatch[2]));
+      const platformHost = routePlatformHost(issueProvider, providerIssueMatch[1]);
+      const issueOwner = decodePathSegment(providerIssueMatch[3]);
+      const issueName = decodePathSegment(providerIssueMatch[4]);
+      const issueNumber = parseInt(providerIssueMatch[5]!, 10);
+      const issue = issues.find((candidate) =>
+        matchesRouteIdentity(candidate, {
+          provider: issueProvider,
+          platformHost,
+          owner: issueOwner,
+          name: issueName,
+          number: issueNumber,
+        }),
+      );
+      if (!issue) {
+        return jsonResponse({ title: "Not found" }, 404);
+      }
+      return jsonResponse({
+        issue,
+        repo: issue.repo,
+        events: [],
+        platform_host: issue.platform_host,
+        repo_owner: issue.repo_owner,
+        repo_name: issue.repo_name,
+        detail_loaded: true,
+        detail_fetched_at: "2026-03-30T14:00:00Z",
+      });
+    }
+
+    const singleIssueMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/issues\/(\d+)$/);
+    if (method === "GET" && singleIssueMatch) {
+      const issueOwner = singleIssueMatch[1];
+      const issueName = singleIssueMatch[2];
+      const issueNumber = parseInt(singleIssueMatch[3]!, 10);
+      const issue = issues.find(
+        (candidate) =>
+          candidate.repo_owner === issueOwner && candidate.repo_name === issueName && candidate.Number === issueNumber,
+      );
+      if (!issue) {
+        return jsonResponse({ title: "Not found" }, 404);
+      }
+      return jsonResponse({
+        issue,
+        repo: issue.repo,
+        events: [],
+        platform_host: issue.platform_host,
+        repo_owner: issue.repo_owner,
+        repo_name: issue.repo_name,
+        detail_loaded: true,
+        detail_fetched_at: "2026-03-30T14:00:00Z",
+      });
+    }
+
+    const syncIssueMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/issues\/(\d+)\/sync$/);
+    if (method === "POST" && syncIssueMatch) {
+      const issueOwner = syncIssueMatch[1];
+      const issueName = syncIssueMatch[2];
+      const issueNumber = parseInt(syncIssueMatch[3]!, 10);
+      const issue = issues.find(
+        (candidate) =>
+          candidate.repo_owner === issueOwner && candidate.repo_name === issueName && candidate.Number === issueNumber,
+      );
+      if (!issue) {
+        return jsonResponse({ title: "Not found" }, 404);
+      }
+      return jsonResponse({
+        issue,
+        events: [],
+        platform_host: issue.platform_host,
+        repo_owner: issue.repo_owner,
+        repo_name: issue.repo_name,
+        detail_loaded: true,
+        detail_fetched_at: "2026-03-30T14:00:00Z",
+      });
+    }
+
+    if (method === "GET" && pathname === "/api/v1/repos") {
+      return jsonResponse(repos);
+    }
+
+    if (method === "GET" && pathname === "/api/v1/repos/summary") {
+      return jsonResponse(repoSummaries);
+    }
+
+    const singleRepoMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)$/);
+    if (method === "GET" && singleRepoMatch) {
+      const repo = repos.find((r) => r.Owner === singleRepoMatch[1] && r.Name === singleRepoMatch[2]);
+      if (!repo) {
+        return jsonResponse({ error: "Not found" }, 404);
+      }
+      return jsonResponse(repo);
+    }
+
+    const providerRepoMatch = pathname.match(/^\/api\/v1(?:\/host\/([^/]+))?\/repo\/([^/]+)\/([^/]+)\/([^/]+)$/);
+    if (method === "GET" && providerRepoMatch) {
+      const repoProvider = canonicalProvider(decodePathSegment(providerRepoMatch[2]));
+      const platformHost = routePlatformHost(repoProvider, providerRepoMatch[1]);
+      const repoOwner = decodePathSegment(providerRepoMatch[3]);
+      const repoName = decodePathSegment(providerRepoMatch[4]);
+      const repo = repos.find(
+        (r) =>
+          canonicalProvider(r.Platform) === repoProvider &&
+          r.PlatformHost === platformHost &&
+          r.Owner === repoOwner &&
+          r.Name === repoName,
+      );
+      if (!repo) {
+        return jsonResponse({ error: "Not found" }, 404);
+      }
+      return jsonResponse(repo);
+    }
+
+    if (method === "GET" && pathname === "/api/v1/sync/status") {
+      return jsonResponse(syncStatus);
+    }
+
+    if (method === "GET" && pathname === "/api/v1/settings") {
+      return jsonResponse(settings);
+    }
+
+    if (method === "GET" && pathname === "/api/v1/rate-limits") {
+      return jsonResponse(makeRateLimits());
+    }
+
+    if (method === "POST" && pathname === "/api/v1/sync") {
+      return jsonResponse(undefined, 202);
+    }
+
+    const patchPrMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)$/);
+    if (method === "PATCH" && patchPrMatch) {
+      const prOwner = patchPrMatch[1];
+      const prName = patchPrMatch[2];
+      const prNumber = parseInt(patchPrMatch[3]!, 10);
+      const pr = localPulls.find((p) => p.repo_owner === prOwner && p.repo_name === prName && p.Number === prNumber);
+      if (!pr) {
+        return jsonResponse({ title: "Not found" }, 404);
+      }
+      const reqBody = JSON.parse(req.bodyText || "{}");
+      if (reqBody.title !== undefined) pr.Title = reqBody.title;
+      if (reqBody.body !== undefined) pr.Body = reqBody.body;
+      return jsonResponse(pullDetailResponse(pr));
+    }
+
+    return jsonResponse({ error: `Unhandled ${method} ${pathname}` }, 404);
+  }
+
+  return { handle, requests };
+}
+
+// Root-level liveness endpoints the app shell polls during startup
+// (waitUntilBackendReady) before it mounts any view. The Playwright lane
+// gets these from the Vite dev server's healthcheck plugin and never routes
+// them through the mock (page.route only intercepts /api/v1); the jsdom lane
+// stubs fetch wholesale, so the adapter must answer them or startup spins on
+// "Loading" forever.
+const READINESS_PATHS = new Set(["/healthz", "/livez"]);
+
+export function createMockApiFetch(overrides: MockRouteOverride[] = []): MockApiHandle {
+  const handler = createMockApiHandler(overrides);
+
+  const mockFetch: typeof globalThis.fetch = async (input, init) => {
+    // jsdom runs on undici, where `new Request("/relative")` throws because
+    // there is no document base — but the app shell fetches readiness and
+    // other paths relatively. Resolve against window.location the way a
+    // browser would before building the Request.
+    const request = input instanceof Request ? input : new Request(new URL(String(input), window.location.href), init);
+    const url = new URL(request.url);
+    if (READINESS_PATHS.has(url.pathname)) {
+      return jsonResponse({ status: "ok" });
+    }
+    return handler.handle({
+      method: request.method.toUpperCase(),
+      url,
+      bodyText: request.method === "GET" || request.method === "HEAD" ? "" : await request.text(),
+    });
+  };
+
+  return { fetch: mockFetch, requests: handler.requests };
+}
diff --git a/frontend/tests/e2e-full/activity-collapse.spec.ts b/frontend/tests/e2e-full/activity-collapse.spec.ts
deleted file mode 100644
index 2b49e19ba..000000000
--- a/frontend/tests/e2e-full/activity-collapse.spec.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-
-// Full-stack coverage (real HTTP API + SQLite). The shared e2e server seeds the
-// Activity config with view_mode "flat" and 7d activity data that includes
-// comment/review events, so switching to threaded mode renders item rows with
-// nested event rows that the collapse controls can hide and show.
-
-async function openActivityViewDropdown(page: Page) {
-  const dropdown = page.locator(".activity-feed .filter-dropdown");
-  if (await dropdown.isVisible()) {
-    return dropdown;
-  }
-  await page.locator(".activity-feed .filter-btn", { hasText: "View" }).click();
-  await expect(dropdown).toBeVisible();
-  return dropdown;
-}
-
-async function selectActivityViewItem(page: Page, label: string): Promise<void> {
-  const dropdown = await openActivityViewDropdown(page);
-  await dropdown.locator(".filter-item", { hasText: label }).click();
-}
-
-async function gotoThreadedActivity(page: Page): Promise<void> {
-  await page.goto("/");
-  await page.locator(".activity-table .activity-row").first().waitFor({ state: "visible", timeout: 10_000 });
-  await selectActivityViewItem(page, "Threaded");
-  await page.locator(".threaded-view .item-row").first().waitFor({ state: "visible", timeout: 10_000 });
-}
-
-test.describe("threaded activity collapse", () => {
-  test("collapse all hides every event row and expand all restores them", async ({ page }) => {
-    await gotoThreadedActivity(page);
-
-    const eventRows = page.locator(".threaded-view .event-row");
-    await expect(eventRows.first()).toBeVisible();
-    const initialCount = await eventRows.count();
-    expect(initialCount).toBeGreaterThan(0);
-
-    await page.getByRole("button", { name: "Collapse all" }).click();
-    await expect(eventRows).toHaveCount(0);
-    await expect(page.locator(".threaded-view .item-row").first()).toBeVisible();
-
-    // The control flips to Expand all; clicking it brings event rows back.
-    // The activity feed may refresh in the background during the full e2e suite,
-    // so the exact event count is not stable enough to assert here.
-    await page.getByRole("button", { name: "Expand all" }).click();
-    await expect(eventRows.first()).toBeVisible();
-  });
-
-  test("a single caret expands only its own item after collapse all", async ({ page }) => {
-    await gotoThreadedActivity(page);
-
-    const eventRows = page.locator(".threaded-view .event-row");
-    const fullCount = await eventRows.count();
-    expect(fullCount).toBeGreaterThan(1);
-
-    await page.getByRole("button", { name: "Collapse all" }).click();
-    await expect(eventRows).toHaveCount(0);
-
-    await page.locator(".threaded-view .item-row").first().locator(".thread-caret").click();
-
-    // Only the clicked item's events reappear; the rest stay collapsed.
-    await expect(eventRows.first()).toBeVisible();
-    const partial = await eventRows.count();
-    expect(partial).toBeGreaterThan(0);
-    expect(partial).toBeLessThan(fullCount);
-  });
-});
diff --git a/frontend/tests/e2e-full/budget-display.spec.ts b/frontend/tests/e2e-full/budget-display.spec.ts
deleted file mode 100644
index fe4bf05e1..000000000
--- a/frontend/tests/e2e-full/budget-display.spec.ts
+++ /dev/null
@@ -1,42 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-test("budget bars render with seeded rate-limit data", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await expect(bars).toBeVisible();
-  await expect(bars.getByText("REST")).toBeVisible();
-});
-
-test("popover shows per-host breakdown from seeded data", async ({ page }) => {
-  await page.goto("/pulls");
-
-  await page.locator(".budget-bars").click();
-
-  // Popover exposes itself as a dialog with the expected accessible name.
-  const popover = page.getByRole("dialog", { name: "API Budget" });
-  await expect(popover).toBeVisible();
-  await expect(popover.getByText("req", { exact: true })).toBeVisible();
-  await expect(popover.getByText("pts", { exact: true })).toBeVisible(); // GQL data
-  await expect(popover.getByText(/75/)).toBeVisible(); // budget_spent
-});
-
-test("popover opens via keyboard (Enter)", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await bars.focus();
-  await page.keyboard.press("Enter");
-
-  await expect(page.locator(".budget-popover")).toBeVisible();
-});
-
-test("popover opens via keyboard (Space)", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await bars.focus();
-  await page.keyboard.press("Space");
-
-  await expect(page.locator(".budget-popover")).toBeVisible();
-});
diff --git a/frontend/tests/e2e/activity-collapse-compact-label.spec.ts b/frontend/tests/e2e/activity-collapse-compact-label.spec.ts
new file mode 100644
index 000000000..009852406
--- /dev/null
+++ b/frontend/tests/e2e/activity-collapse-compact-label.spec.ts
@@ -0,0 +1,109 @@
+import { expect, test, type Page } from "@playwright/test";
+
+import { mockApi } from "./support/mockApi";
+
+// Browser-only remainder of the activity-collapse coverage: when the side
+// detail pane opens, the feed switches to compact mode and the Collapse all
+// control becomes icon-only via `.activity-feed--compact .collapse-all-label
+// { display: none }`. Compact-mode activation and the control's behavior are
+// covered in jsdom (src/App.activity-collapse.test.ts); the actual label
+// hiding is a real computed-CSS effect jsdom cannot see, so it stays here.
+
+function event(id: string, number: number, type: string, created: string): unknown {
+  return {
+    id,
+    cursor: id,
+    activity_type: type,
+    author: "marius",
+    body_preview: "",
+    created_at: created,
+    item_number: number,
+    item_state: "open",
+    item_title: number === 42 ? "Add browser regression coverage" : "Refactor theme system",
+    item_type: "pr",
+    item_url: `https://github.com/acme/widgets/pull/${number}`,
+    platform_host: "github.com",
+    repo_owner: "acme",
+    repo_name: "widgets",
+    repo: {
+      provider: "github",
+      platform_host: "github.com",
+      owner: "acme",
+      name: "widgets",
+      repo_path: "acme/widgets",
+      capabilities: {},
+    },
+  };
+}
+
+async function mockActivity(page: Page): Promise<void> {
+  await mockApi(page);
+  await page.route("**/api/v1/settings", async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        repos: [
+          {
+            provider: "github",
+            platform_host: "github.com",
+            owner: "acme",
+            name: "widgets",
+            repo_path: "acme/widgets",
+            is_glob: false,
+            matched_repo_count: 1,
+          },
+        ],
+        activity: {
+          view_mode: "threaded",
+          time_range: "7d",
+          hide_closed: false,
+          hide_bots: false,
+          collapse_threads: false,
+        },
+        terminal: {
+          font_family: "",
+          font_size: 14,
+          scrollback: 1000,
+          line_height: 1,
+          letter_spacing: 0,
+          cursor_blink: true,
+          font_ligatures: false,
+          renderer: "xterm",
+        },
+        agents: [],
+      }),
+    });
+  });
+  await page.route("**/api/v1/activity**", async (route) => {
+    await route.fulfill({
+      status: 200,
+      contentType: "application/json",
+      body: JSON.stringify({
+        capped: false,
+        items: [
+          event("a1", 42, "comment", "2026-03-30T14:00:00Z"),
+          event("a2", 42, "review", "2026-03-30T13:00:00Z"),
+          event("b1", 55, "comment", "2026-03-30T12:00:00Z"),
+        ],
+      }),
+    });
+  });
+}
+
+test("compact collapse control hides its text label in the side detail pane", async ({ page }) => {
+  await mockActivity(page);
+  await page.goto("/?view=threaded");
+
+  // Open a detail by clicking the item row body (not the caret).
+  await page.locator(".item-row").first().locator(".item-title").click();
+  await expect(page.locator(".activity-detail")).toBeVisible();
+  await expect(page.locator(".activity-pane")).toBeVisible();
+
+  // The control stays reachable by its accessible name, but its text label
+  // is hidden by the compact-feed CSS so it does not stack awkwardly in the
+  // narrow pane.
+  const collapseBtn = page.getByRole("button", { name: "Collapse all" });
+  await expect(collapseBtn).toBeVisible();
+  await expect(page.locator(".collapse-all-btn .collapse-all-label")).toBeHidden();
+});
diff --git a/frontend/tests/e2e/activity-collapse.spec.ts b/frontend/tests/e2e/activity-collapse.spec.ts
deleted file mode 100644
index 4567f0e9a..000000000
--- a/frontend/tests/e2e/activity-collapse.spec.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-function event(id: string, number: number, type: string, created: string): unknown {
-  return {
-    id,
-    cursor: id,
-    activity_type: type,
-    author: "marius",
-    body_preview: "",
-    created_at: created,
-    item_number: number,
-    item_state: "open",
-    item_title: number === 42 ? "Add browser regression coverage" : "Refactor theme system",
-    item_type: "pr",
-    item_url: `https://github.com/acme/widgets/pull/${number}`,
-    platform_host: "github.com",
-    repo_owner: "acme",
-    repo_name: "widgets",
-    repo: {
-      provider: "github",
-      platform_host: "github.com",
-      owner: "acme",
-      name: "widgets",
-      repo_path: "acme/widgets",
-      capabilities: {},
-    },
-  };
-}
-
-async function mockActivity(page: Page): Promise<void> {
-  await mockApi(page);
-  await page.route("**/api/v1/settings", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        repos: [
-          {
-            provider: "github",
-            platform_host: "github.com",
-            owner: "acme",
-            name: "widgets",
-            repo_path: "acme/widgets",
-            is_glob: false,
-            matched_repo_count: 1,
-          },
-        ],
-        activity: {
-          view_mode: "threaded",
-          time_range: "7d",
-          hide_closed: false,
-          hide_bots: false,
-          collapse_threads: false,
-        },
-        terminal: {
-          font_family: "",
-          font_size: 14,
-          scrollback: 1000,
-          line_height: 1,
-          letter_spacing: 0,
-          cursor_blink: true,
-          font_ligatures: false,
-          renderer: "xterm",
-        },
-        agents: [],
-      }),
-    });
-  });
-  await page.route("**/api/v1/activity**", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        capped: false,
-        items: [
-          event("a1", 42, "comment", "2026-03-30T14:00:00Z"),
-          event("a2", 42, "review", "2026-03-30T13:00:00Z"),
-          event("b1", 55, "comment", "2026-03-30T12:00:00Z"),
-        ],
-      }),
-    });
-  });
-}
-
-test.describe("threaded activity collapse", () => {
-  test("collapses, drills into one item, and persists across reload", async ({ page }) => {
-    await mockActivity(page);
-    await page.goto("/?view=threaded");
-
-    const itemRows = page.locator(".item-row");
-    const eventRows = page.locator(".event-row");
-    await expect(itemRows).toHaveCount(2);
-    await expect(eventRows.first()).toBeVisible();
-
-    await page.getByRole("button", { name: "Collapse all" }).click();
-    await expect(itemRows).toHaveCount(2);
-    await expect(eventRows).toHaveCount(0);
-
-    // Drill into a single item via its caret.
-    await itemRows.first().locator(".thread-caret").click();
-    await expect(eventRows.first()).toBeVisible();
-
-    // Collapse-all wrote ?collapsed=1; a reload restores the collapsed state
-    // and clears the session-only single-item override.
-    await page.reload();
-    await expect(page.locator(".item-row")).toHaveCount(2);
-    await expect(page.locator(".event-row")).toHaveCount(0);
-  });
-
-  test("collapse control works while the side detail pane is open", async ({ page }) => {
-    await mockActivity(page);
-    await page.goto("/?view=threaded");
-
-    // Open a detail by clicking the item row body (not the caret).
-    await page.locator(".item-row").first().locator(".item-title").click();
-    await expect(page.locator(".activity-detail")).toBeVisible();
-    await expect(page.locator(".activity-pane")).toBeVisible();
-
-    // In the narrow pane the control is icon-only: the button is present by
-    // its accessible name, but its text label is hidden to avoid stacking.
-    const collapseBtn = page.getByRole("button", {
-      name: "Collapse all",
-    });
-    await expect(collapseBtn).toBeVisible();
-    await expect(page.locator(".collapse-all-btn .collapse-all-label")).toBeHidden();
-    await collapseBtn.click();
-    await expect(page.locator(".event-row")).toHaveCount(0);
-  });
-
-  test("expand all restores every item's events", async ({ page }) => {
-    await mockActivity(page);
-    await page.goto("/?view=threaded");
-
-    const eventRows = page.locator(".event-row");
-    await expect(eventRows.first()).toBeVisible();
-    const initialCount = await eventRows.count();
-
-    await page.getByRole("button", { name: "Collapse all" }).click();
-    await expect(eventRows).toHaveCount(0);
-
-    // The control flips to Expand all; clicking it brings every event back.
-    await page.getByRole("button", { name: "Expand all" }).click();
-    await expect(eventRows).toHaveCount(initialCount);
-  });
-});
diff --git a/frontend/tests/e2e/activity-thread-runs.spec.ts b/frontend/tests/e2e/activity-thread-runs.spec.ts
deleted file mode 100644
index d1b2607d0..000000000
--- a/frontend/tests/e2e/activity-thread-runs.spec.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-const REPO = {
-  provider: "github",
-  platform_host: "github.com",
-  owner: "acme",
-  name: "widgets",
-  repo_path: "acme/widgets",
-  capabilities: {},
-};
-
-function prEvent(args: {
-  id: string;
-  type: "comment" | "review" | "commit" | "force_push" | "new_pr";
-  author: string;
-  createdAt: string;
-}): unknown {
-  return {
-    id: args.id,
-    cursor: args.id,
-    activity_type: args.type,
-    author: args.author,
-    body_preview: "",
-    created_at: args.createdAt,
-    item_number: 42,
-    item_state: "open",
-    item_title: "Add browser regression coverage",
-    item_type: "pr",
-    item_url: "https://github.com/acme/widgets/pull/42",
-    platform_host: "github.com",
-    repo_owner: "acme",
-    repo_name: "widgets",
-    repo: REPO,
-  };
-}
-
-async function mockSettings(page: Page): Promise<void> {
-  await mockApi(page);
-  await page.route("**/api/v1/settings", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        repos: [
-          {
-            provider: "github",
-            platform_host: "github.com",
-            owner: "acme",
-            name: "widgets",
-            repo_path: "acme/widgets",
-            is_glob: false,
-            matched_repo_count: 1,
-          },
-        ],
-        activity: {
-          view_mode: "threaded",
-          time_range: "7d",
-          hide_closed: false,
-          hide_bots: false,
-          collapse_threads: false,
-        },
-        terminal: {
-          font_family: "",
-          font_size: 14,
-          scrollback: 1000,
-          line_height: 1,
-          letter_spacing: 0,
-          cursor_blink: true,
-          font_ligatures: false,
-          renderer: "xterm",
-        },
-        agents: [],
-      }),
-    });
-  });
-}
-
-async function mockActivity(page: Page, items: unknown[]): Promise<void> {
-  await page.route("**/api/v1/activity**", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({ capped: false, items }),
-    });
-  });
-}
-
-test.describe("threaded activity run collapse", () => {
-  test("collapses a run of three or more reviews from the same author", async ({ page }) => {
-    await mockSettings(page);
-    await mockActivity(page, [
-      prEvent({
-        id: "r5",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T15:00:00Z",
-      }),
-      prEvent({
-        id: "r4",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T14:00:00Z",
-      }),
-      prEvent({
-        id: "r3",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T13:00:00Z",
-      }),
-      prEvent({
-        id: "r2",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T12:00:00Z",
-      }),
-      prEvent({
-        id: "r1",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T11:00:00Z",
-      }),
-    ]);
-    await page.goto("/?view=threaded");
-
-    const collapsed = page.locator(".event-row.collapsed-event", {
-      hasText: "5 reviews",
-    });
-    await expect(collapsed).toHaveCount(1);
-    await expect(collapsed.locator(".evt-review")).toBeVisible();
-    await expect(page.locator(".event-row:not(.collapsed-event)")).toHaveCount(0);
-  });
-
-  test("collapses comments and reviews into separate runs by event type", async ({ page }) => {
-    await mockSettings(page);
-    await mockActivity(page, [
-      prEvent({
-        id: "c3",
-        type: "comment",
-        author: "alice",
-        createdAt: "2026-04-27T16:00:00Z",
-      }),
-      prEvent({
-        id: "c2",
-        type: "comment",
-        author: "alice",
-        createdAt: "2026-04-27T15:00:00Z",
-      }),
-      prEvent({
-        id: "c1",
-        type: "comment",
-        author: "alice",
-        createdAt: "2026-04-27T14:00:00Z",
-      }),
-      prEvent({
-        id: "r3",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T13:00:00Z",
-      }),
-      prEvent({
-        id: "r2",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T12:00:00Z",
-      }),
-      prEvent({
-        id: "r1",
-        type: "review",
-        author: "alice",
-        createdAt: "2026-04-27T11:00:00Z",
-      }),
-    ]);
-    await page.goto("/?view=threaded");
-
-    await expect(
-      page.locator(".event-row.collapsed-event", {
-        hasText: "3 comments",
-      }),
-    ).toHaveCount(1);
-    await expect(
-      page.locator(".event-row.collapsed-event", {
-        hasText: "3 reviews",
-      }),
-    ).toHaveCount(1);
-  });
-
-  test("leaves short runs of comments unrolled", async ({ page }) => {
-    await mockSettings(page);
-    await mockActivity(page, [
-      prEvent({
-        id: "c2",
-        type: "comment",
-        author: "alice",
-        createdAt: "2026-04-27T13:00:00Z",
-      }),
-      prEvent({
-        id: "c1",
-        type: "comment",
-        author: "alice",
-        createdAt: "2026-04-27T12:00:00Z",
-      }),
-    ]);
-    await page.goto("/?view=threaded");
-
-    await expect(page.locator(".event-row.collapsed-event")).toHaveCount(0);
-    await expect(page.locator(".event-row:not(.collapsed-event)")).toHaveCount(2);
-  });
-});
diff --git a/frontend/tests/e2e/budget-display.spec.ts b/frontend/tests/e2e/budget-display.spec.ts
deleted file mode 100644
index f003a7d81..000000000
--- a/frontend/tests/e2e/budget-display.spec.ts
+++ /dev/null
@@ -1,437 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-test.beforeEach(async ({ page }) => {
-  await mockApi(page);
-});
-
-test("status bar shows budget bars with known data", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await expect(bars).toBeVisible();
-  await expect(bars.getByText("REST")).toBeVisible();
-  await expect(bars.getByText("GQL")).toBeVisible();
-});
-
-test("budget bars show middleman count when budget enabled", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await expect(bars.getByText("42 req/hr")).toBeVisible();
-});
-
-test("clicking budget area opens popover", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await bars.click();
-
-  // Popover exposes itself as a dialog with the expected accessible name.
-  const popover = page.getByRole("dialog", { name: "API Budget" });
-  await expect(popover).toBeVisible();
-  await expect(popover.getByText("req", { exact: true })).toBeVisible();
-  await expect(popover.getByText("pts", { exact: true })).toBeVisible();
-});
-
-test("popover dismisses on Escape", async ({ page }) => {
-  await page.goto("/pulls");
-
-  await page.locator(".budget-bars").click();
-  await expect(page.locator(".budget-popover")).toBeVisible();
-
-  await page.keyboard.press("Escape");
-  await expect(page.locator(".budget-popover")).not.toBeVisible();
-});
-
-test("popover dismisses on click outside", async ({ page }) => {
-  await page.goto("/pulls");
-
-  await page.locator(".budget-bars").click();
-  await expect(page.locator(".budget-popover")).toBeVisible();
-
-  // Popover attaches its outside-click listener via setTimeout(0) to
-  // avoid catching the opening click. Flush one animation frame so the
-  // listener is registered before we click outside.
-  await page.evaluate(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())));
-
-  await page.locator(".app-main").click();
-  await expect(page.locator(".budget-popover")).not.toBeVisible();
-});
-
-test("popover opens via keyboard (Enter) and closes via Escape", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await bars.focus();
-  await page.keyboard.press("Enter");
-
-  const popover = page.locator(".budget-popover");
-  await expect(popover).toBeVisible();
-
-  await page.keyboard.press("Escape");
-  await expect(popover).not.toBeVisible();
-});
-
-test("popover opens via keyboard (Space)", async ({ page }) => {
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await bars.focus();
-  await page.keyboard.press("Space");
-
-  await expect(page.locator(".budget-popover")).toBeVisible();
-});
-
-test("mixed known/unknown hosts show worst-case from known only", async ({ page }) => {
-  await page.route("**/api/v1/rate-limits", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        hosts: {
-          "github.com": {
-            requests_hour: 100,
-            rate_remaining: 4500,
-            rate_limit: 5000,
-            rate_reset_at: new Date(Date.now() + 30 * 60_000).toISOString(),
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: true,
-            budget_limit: 500,
-            budget_spent: 100,
-            budget_remaining: 400,
-            gql_remaining: 4900,
-            gql_limit: 5000,
-            gql_reset_at: new Date(Date.now() + 25 * 60_000).toISOString(),
-            gql_known: true,
-          },
-          "ghe.corp.example.com": {
-            requests_hour: 0,
-            rate_remaining: -1,
-            rate_limit: -1,
-            rate_reset_at: "",
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: false,
-            budget_limit: 0,
-            budget_spent: 0,
-            budget_remaining: 0,
-            gql_remaining: -1,
-            gql_limit: -1,
-            gql_reset_at: "",
-            gql_known: false,
-          },
-        },
-      }),
-    });
-  });
-
-  await page.goto("/pulls");
-
-  // Should show REST/GQL labels (not --) because github.com is known
-  const bars = page.locator(".budget-bars");
-  await expect(bars.getByText("REST")).toBeVisible();
-  await expect(bars.getByText("GQL")).toBeVisible();
-
-  // REST bar fill should reflect github.com's 90% ratio (green)
-  const restFill = bars.locator(".budget-fill").first();
-  await expect(restFill).toBeVisible();
-
-  // Popover should show both hosts
-  await bars.click();
-  const popover = page.locator(".budget-popover");
-  await expect(popover.getByText("github.com")).toBeVisible();
-  await expect(popover.getByText("ghe.corp.example.com")).toBeVisible();
-  // Known host shows compact ratio + abbreviated unit
-  await expect(popover.getByText(/4\.5k\s*\/\s*5k\s+req\b/)).toBeVisible();
-  await expect(popover.getByText("not yet observed").first()).toBeVisible();
-
-  // Unknown host's health dot must be tagged unknown so it renders
-  // with the muted color token instead of a budget color.
-  const ghHealthDot = popover
-    .locator(".host-section")
-    .filter({
-      hasText: "github.com",
-    })
-    .locator(".health-dot");
-  const gheHealthDot = popover
-    .locator(".host-section")
-    .filter({
-      hasText: "ghe.corp.example.com",
-    })
-    .locator(".health-dot");
-  await expect(ghHealthDot).not.toHaveClass(/health-dot--unknown/);
-  await expect(gheHealthDot).toHaveClass(/health-dot--unknown/);
-});
-
-test("budget bars show unknown state when host not known", async ({ page }) => {
-  await page.route("**/api/v1/rate-limits", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        hosts: {
-          "github.com": {
-            requests_hour: 0,
-            rate_remaining: -1,
-            rate_limit: -1,
-            rate_reset_at: "",
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: false,
-            budget_limit: 0,
-            budget_spent: 0,
-            budget_remaining: 0,
-            gql_remaining: -1,
-            gql_limit: -1,
-            gql_reset_at: "",
-            gql_known: false,
-          },
-        },
-      }),
-    });
-  });
-
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await expect(bars).toBeVisible();
-  // Unknown state: labels show -- instead of REST/GQL
-  await expect(bars.getByText("--").first()).toBeVisible();
-  await expect(bars.getByText("REST")).not.toBeVisible();
-  await expect(bars.getByText("GQL")).not.toBeVisible();
-  // No budget count when budget disabled
-  await expect(bars.getByText("req/hr")).not.toBeVisible();
-});
-
-test("paused host shows red health dot and sync paused indicator", async ({ page }) => {
-  await page.route("**/api/v1/rate-limits", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        hosts: {
-          "github.com": {
-            requests_hour: 500,
-            rate_remaining: 50,
-            rate_limit: 5000,
-            rate_reset_at: new Date(Date.now() + 10 * 60_000).toISOString(),
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 8,
-            sync_paused: true,
-            reserve_buffer: 200,
-            known: true,
-            budget_limit: 500,
-            budget_spent: 400,
-            budget_remaining: 100,
-            gql_remaining: 100,
-            gql_limit: 5000,
-            gql_reset_at: new Date(Date.now() + 10 * 60_000).toISOString(),
-            gql_known: true,
-          },
-        },
-      }),
-    });
-  });
-
-  await page.goto("/pulls");
-
-  // Compact bars should be red when paused — labels inherit barColor
-  const bars = page.locator(".budget-bars");
-  await expect(bars.getByText("REST")).toBeVisible();
-  // Bar fill should use budget-red
-  const restFill = bars.locator(".budget-fill").first();
-  await expect(restFill).toHaveCSS("background-color", "rgb(248, 113, 113)");
-
-  // Open popover — should show "sync paused" indicator
-  await bars.click();
-  const popover = page.getByRole("dialog", { name: "API Budget" });
-  await expect(popover).toBeVisible();
-  await expect(popover.getByText("sync paused")).toBeVisible();
-  // Single-host mode hides hostname header (and health dot).
-  // Health dot color is tested in the multi-host paused case below.
-});
-
-test("paused multi-host shows red health dot in popover", async ({ page }) => {
-  await page.route("**/api/v1/rate-limits", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        hosts: {
-          "github.com": {
-            requests_hour: 500,
-            rate_remaining: 50,
-            rate_limit: 5000,
-            rate_reset_at: new Date(Date.now() + 10 * 60_000).toISOString(),
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 8,
-            sync_paused: true,
-            reserve_buffer: 200,
-            known: true,
-            budget_limit: 500,
-            budget_spent: 400,
-            budget_remaining: 100,
-            gql_remaining: 100,
-            gql_limit: 5000,
-            gql_reset_at: new Date(Date.now() + 10 * 60_000).toISOString(),
-            gql_known: true,
-          },
-          "ghe.example.com": {
-            requests_hour: 10,
-            rate_remaining: 4900,
-            rate_limit: 5000,
-            rate_reset_at: new Date(Date.now() + 50 * 60_000).toISOString(),
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: true,
-            budget_limit: 0,
-            budget_spent: 0,
-            budget_remaining: 0,
-            gql_remaining: -1,
-            gql_limit: -1,
-            gql_reset_at: "",
-            gql_known: false,
-          },
-        },
-      }),
-    });
-  });
-
-  await page.goto("/pulls");
-
-  await page.locator(".budget-bars").click();
-  const popover = page.getByRole("dialog", { name: "API Budget" });
-  await expect(popover).toBeVisible();
-
-  // Paused host (github.com) health dot should be red
-  const pausedDot = popover
-    .locator(".host-section")
-    .filter({
-      hasText: "github.com",
-    })
-    .locator(".health-dot");
-  await expect(pausedDot).toHaveCSS("background-color", "rgb(248, 113, 113)");
-});
-
-test("GQL known but REST unknown still shows budget count", async ({ page }) => {
-  await page.route("**/api/v1/rate-limits", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        hosts: {
-          "github.com": {
-            requests_hour: 0,
-            rate_remaining: -1,
-            rate_limit: -1,
-            rate_reset_at: "",
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: false,
-            budget_limit: 500,
-            budget_spent: 10,
-            budget_remaining: 490,
-            gql_remaining: 4800,
-            gql_limit: 5000,
-            gql_reset_at: new Date(Date.now() + 30 * 60_000).toISOString(),
-            gql_known: true,
-          },
-        },
-      }),
-    });
-  });
-
-  await page.goto("/pulls");
-
-  const bars = page.locator(".budget-bars");
-  await expect(bars).toBeVisible();
-  // GQL bar should show (known), REST should show -- placeholder
-  await expect(bars.getByText("GQL")).toBeVisible();
-  await expect(bars.getByText("REST")).not.toBeVisible();
-  await expect(bars.getByText("--").first()).toBeVisible();
-  // Budget count visible — budget is independent of REST rate observation
-  await expect(bars.getByText("10 req/hr")).toBeVisible();
-});
-
-test("stale host excluded from compact bars, fresh host drives ratio", async ({ page }) => {
-  await page.route("**/api/v1/rate-limits", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        hosts: {
-          "github.com": {
-            requests_hour: 100,
-            rate_remaining: 4500,
-            rate_limit: 5000,
-            rate_reset_at: new Date(Date.now() + 30 * 60_000).toISOString(),
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: true,
-            budget_limit: 500,
-            budget_spent: 100,
-            budget_remaining: 400,
-            gql_remaining: 4900,
-            gql_limit: 5000,
-            gql_reset_at: new Date(Date.now() + 25 * 60_000).toISOString(),
-            gql_known: true,
-          },
-          "ghe.example.com": {
-            requests_hour: 0,
-            rate_remaining: -1,
-            rate_limit: 5000,
-            rate_reset_at: "",
-            hour_start: new Date().toISOString(),
-            sync_throttle_factor: 1,
-            sync_paused: false,
-            reserve_buffer: 200,
-            known: true,
-            budget_limit: 0,
-            budget_spent: 0,
-            budget_remaining: 0,
-            gql_remaining: -1,
-            gql_limit: -1,
-            gql_reset_at: "",
-            gql_known: false,
-          },
-        },
-      }),
-    });
-  });
-
-  await page.goto("/pulls");
-
-  // Compact bars should show REST/GQL from fresh host (github.com)
-  const bars = page.locator(".budget-bars");
-  await expect(bars.getByText("REST")).toBeVisible();
-  await expect(bars.getByText("GQL")).toBeVisible();
-  // Bar fill should be visible (driven by fresh host, not stale)
-  await expect(bars.locator(".budget-fill").first()).toBeVisible();
-
-  // Popover: stale host health dot should be muted
-  await bars.click();
-  const popover = page.getByRole("dialog", { name: "API Budget" });
-  await expect(popover).toBeVisible();
-  const staleDot = popover
-    .locator(".host-section")
-    .filter({
-      hasText: "ghe.example.com",
-    })
-    .locator(".health-dot");
-  await expect(staleDot).toHaveClass(/health-dot--unknown/);
-});
diff --git a/frontend/tests/e2e/cheatsheet.spec.ts b/frontend/tests/e2e/cheatsheet.spec.ts
deleted file mode 100644
index 3800ae976..000000000
--- a/frontend/tests/e2e/cheatsheet.spec.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-import { mockApi } from "./support/mockApi";
-
-test.beforeEach(async ({ page }) => {
-  await mockApi(page);
-});
-
-async function focusAppBody(page: Page): Promise<void> {
-  await page.locator("main").click({ position: { x: 520, y: 260 } });
-}
-
-test("? opens the cheatsheet and shows j/k under On this view", async ({ page }) => {
-  await page.goto("/pulls");
-  await focusAppBody(page);
-  await page.keyboard.press("Shift+/");
-  const sheet = page.getByRole("dialog", {
-    name: "Keyboard shortcuts",
-  });
-  await expect(sheet).toBeVisible();
-  // j and k navigate PRs on /pulls — they should appear under "On this view".
-  const onThisView = sheet.locator(".cheatsheet-section", {
-    hasText: "On this view",
-  });
-  await expect(onThisView).toContainText(/Next pull request|Previous pull request/i);
-});
-
-test("Escape closes the cheatsheet", async ({ page }) => {
-  await page.goto("/pulls");
-  await focusAppBody(page);
-  await page.keyboard.press("Shift+/");
-  await expect(page.getByRole("dialog", { name: "Keyboard shortcuts" })).toBeVisible();
-  await page.keyboard.press("Escape");
-  await expect(page.getByRole("dialog", { name: "Keyboard shortcuts" })).toBeHidden();
-});
diff --git a/frontend/tests/e2e/issue-routing.spec.ts b/frontend/tests/e2e/issue-routing.spec.ts
deleted file mode 100644
index 4be73bc9e..000000000
--- a/frontend/tests/e2e/issue-routing.spec.ts
+++ /dev/null
@@ -1,184 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-const mirrorIssueDetail = {
-  issue: {
-    ID: 2,
-    RepoID: 2,
-    GitHubID: 202,
-    Number: 7,
-    URL: "https://ghe.example.com/acme/widgets/issues/7",
-    Title: "Mirror host issue",
-    Author: "marius",
-    State: "open",
-    Body: "",
-    CommentCount: 1,
-    LabelsJSON: "[]",
-    CreatedAt: "2026-03-28T14:00:00Z",
-    UpdatedAt: "2026-03-30T14:00:00Z",
-    LastActivityAt: "2026-03-30T14:00:00Z",
-    ClosedAt: null,
-    Starred: false,
-  },
-  events: [],
-  platform_host: "ghe.example.com",
-  repo_owner: "acme",
-  repo_name: "widgets",
-  detail_loaded: true,
-  detail_fetched_at: "2026-03-30T14:00:00Z",
-};
-
-async function mockIssueDetailAndTrackHosts(page: Page): Promise<string[]> {
-  const seenHosts: string[] = [];
-
-  await mockApi(page);
-  await page.route("**/api/v1/settings", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        repos: [
-          {
-            owner: "acme",
-            name: "widgets",
-            is_glob: false,
-            matched_repo_count: 1,
-          },
-        ],
-        activity: { hidden_authors: [] },
-        terminal: {
-          font_family: "",
-          font_size: 14,
-          scrollback: 1000,
-          line_height: 1,
-          letter_spacing: 0,
-          cursor_blink: true,
-          font_ligatures: false,
-          renderer: "xterm",
-        },
-      }),
-    });
-  });
-  await page.route(/\/api\/v1\/repos\/acme\/widgets\/issues\/7(?:[/?]|$)/, async (route) => {
-    const url = new URL(route.request().url());
-    seenHosts.push(url.searchParams.get("platform_host") ?? "");
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify(mirrorIssueDetail),
-    });
-  });
-  await page.route("**/api/v1/host/ghe.example.com/issues/github/acme/widgets/7", async (route) => {
-    seenHosts.push("ghe.example.com");
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify(mirrorIssueDetail),
-    });
-  });
-
-  return seenHosts;
-}
-
-test.describe("issue route platform host", () => {
-  test("direct issue load preserves platform_host in detail requests", async ({ page }) => {
-    const seenHosts = await mockIssueDetailAndTrackHosts(page);
-
-    await page.goto("/host/ghe.example.com/issues/github/acme/widgets/7");
-
-    await expect(page.locator(".issue-detail .detail-title")).toContainText("Mirror host issue");
-    await expect.poll(() => seenHosts).toContain("ghe.example.com");
-  });
-
-  test("popstate preserves platform_host in detail requests", async ({ page }) => {
-    const seenHosts = await mockIssueDetailAndTrackHosts(page);
-
-    await page.goto("/issues");
-    await page.evaluate(() => {
-      window.history.pushState(null, "", "/host/ghe.example.com/issues/github/acme/widgets/7");
-      window.dispatchEvent(new PopStateEvent("popstate"));
-    });
-
-    await expect(page.locator(".issue-detail .detail-title")).toContainText("Mirror host issue");
-    await expect.poll(() => seenHosts).toContain("ghe.example.com");
-  });
-});
-
-const assignedIssueDetail = {
-  issue: {
-    ID: 3,
-    RepoID: 2,
-    GitHubID: 303,
-    Number: 12,
-    URL: "https://ghe.example.com/acme/widgets/issues/12",
-    Title: "Issue with assignees",
-    Author: "marius",
-    State: "open",
-    Body: "",
-    CommentCount: 0,
-    LabelsJSON: "[]",
-    CreatedAt: "2026-03-28T14:00:00Z",
-    UpdatedAt: "2026-03-30T14:00:00Z",
-    LastActivityAt: "2026-03-30T14:00:00Z",
-    ClosedAt: null,
-    Starred: false,
-    assignees: ["alice", "bob"],
-  },
-  events: [],
-  platform_host: "ghe.example.com",
-  repo_owner: "acme",
-  repo_name: "widgets",
-  detail_loaded: true,
-  detail_fetched_at: "2026-03-30T14:00:00Z",
-};
-
-async function mockAssignedIssueDetail(page: Page): Promise<void> {
-  await mockApi(page);
-  await page.route("**/api/v1/settings", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify({
-        repos: [
-          {
-            owner: "acme",
-            name: "widgets",
-            is_glob: false,
-            matched_repo_count: 1,
-          },
-        ],
-        activity: { hidden_authors: [] },
-        terminal: {
-          font_family: "",
-          font_size: 14,
-          scrollback: 1000,
-          line_height: 1,
-          letter_spacing: 0,
-          cursor_blink: true,
-          font_ligatures: false,
-          renderer: "xterm",
-        },
-      }),
-    });
-  });
-  await page.route("**/api/v1/host/ghe.example.com/issues/github/acme/widgets/12", async (route) => {
-    await route.fulfill({
-      status: 200,
-      contentType: "application/json",
-      body: JSON.stringify(assignedIssueDetail),
-    });
-  });
-}
-
-test.describe("issue detail assignees", () => {
-  test("renders assignees in the meta row when present", async ({ page }) => {
-    await mockAssignedIssueDetail(page);
-
-    await page.goto("/host/ghe.example.com/issues/github/acme/widgets/12");
-
-    await expect(page.locator(".issue-detail .detail-title")).toContainText("Issue with assignees");
-    const metaRow = page.locator(".issue-detail .meta-row");
-    await expect(metaRow.locator("[data-user-list-editor='assignees']")).toContainText("alice, bob");
-  });
-});
diff --git a/frontend/tests/e2e/keyboard-shortcuts-migration.spec.ts b/frontend/tests/e2e/keyboard-shortcuts-migration.spec.ts
deleted file mode 100644
index 00a10d924..000000000
--- a/frontend/tests/e2e/keyboard-shortcuts-migration.spec.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-test.beforeEach(async ({ page }) => {
-  await mockApi(page);
-});
-
-test.describe("migrated global shortcuts", () => {
-  test("j and k navigate the PR list", async ({ page }) => {
-    await page.goto("/pulls");
-    await page.waitForSelector("[data-test='pr-list']");
-    await page.keyboard.press("j");
-    await expect(page.locator(".pr-list-row.selected").first()).toBeVisible();
-    await page.keyboard.press("k");
-    await expect(page.locator(".pr-list-row.selected").first()).toBeVisible();
-  });
-
-  test("Cmd+[ toggles the sidebar", async ({ page }) => {
-    await page.goto("/pulls");
-    const sidebar = page.locator("[data-test='sidebar']");
-    const wasCollapsed = (await sidebar.getAttribute("data-collapsed")) === "true";
-    await page.keyboard.press("Meta+BracketLeft");
-    await expect(sidebar).toHaveAttribute("data-collapsed", (!wasCollapsed).toString());
-  });
-
-  test("Cmd+[ is reserved on Activity without toggling the sidebar", async ({ page }) => {
-    await page.addInitScript(() => {
-      localStorage.setItem("middleman-sidebar", "collapsed");
-    });
-    await page.goto("/");
-
-    const expandButton = page.getByRole("button", {
-      name: "Expand sidebar",
-    });
-    await expect(expandButton).toBeVisible();
-    await expect(page.locator("header kbd[aria-label$='-[']")).toHaveCount(0);
-
-    await page.locator("main.app-main").click();
-    await page.keyboard.press("Meta+K");
-    const palette = page.getByRole("dialog", { name: "Command palette" });
-    await expect(palette).toBeVisible();
-    await expect(palette.getByText("Toggle sidebar", { exact: true })).toHaveCount(0);
-    await page.keyboard.press("Escape");
-    await expect(palette).toBeHidden();
-
-    await page.locator("main.app-main").click();
-    await page.keyboard.press("Shift+/");
-    const cheatsheet = page.getByRole("dialog", { name: "Keyboard shortcuts" });
-    await expect(cheatsheet).toBeVisible();
-    await expect(cheatsheet.getByText("Toggle sidebar", { exact: true })).toHaveCount(0);
-    await page.keyboard.press("Escape");
-    await expect(cheatsheet).toBeHidden();
-
-    await page.evaluate(() => {
-      const state = window as Window & {
-        __middleman_last_bracket_default_prevented?: boolean | null;
-      };
-      state.__middleman_last_bracket_default_prevented = null;
-      window.addEventListener("keydown", (event) => {
-        if ((event.metaKey || event.ctrlKey) && event.key === "[") {
-          state.__middleman_last_bracket_default_prevented = event.defaultPrevented;
-        }
-      });
-    });
-
-    await page.keyboard.press("Meta+BracketLeft");
-
-    await expect
-      .poll(() =>
-        page.evaluate(
-          () =>
-            (
-              window as Window & {
-                __middleman_last_bracket_default_prevented?: boolean | null;
-              }
-            ).__middleman_last_bracket_default_prevented,
-        ),
-      )
-      .toBe(true);
-    await expect(expandButton).toBeVisible();
-  });
-
-  test("Cmd+[ is reserved on compact PR list without toggling persisted sidebar state", async ({ page }) => {
-    await page.setViewportSize({ width: 480, height: 800 });
-    await page.goto("/pulls");
-
-    await expect(page.locator(".sidebar")).toHaveCount(0);
-    await page.evaluate(() => {
-      localStorage.removeItem("middleman-sidebar");
-      const state = window as Window & {
-        __middleman_last_bracket_default_prevented?: boolean | null;
-      };
-      state.__middleman_last_bracket_default_prevented = null;
-      window.addEventListener("keydown", (event) => {
-        if ((event.metaKey || event.ctrlKey) && event.key === "[") {
-          state.__middleman_last_bracket_default_prevented = event.defaultPrevented;
-        }
-      });
-    });
-
-    await page.keyboard.press("Meta+BracketLeft");
-
-    await expect
-      .poll(() =>
-        page.evaluate(
-          () =>
-            (
-              window as Window & {
-                __middleman_last_bracket_default_prevented?: boolean | null;
-              }
-            ).__middleman_last_bracket_default_prevented,
-        ),
-      )
-      .toBe(true);
-    await expect.poll(() => page.evaluate(() => localStorage.getItem("middleman-sidebar"))).toBeNull();
-  });
-});
diff --git a/frontend/tests/e2e/palette-commands.spec.ts b/frontend/tests/e2e/palette-commands.spec.ts
deleted file mode 100644
index 87ad0e6c7..000000000
--- a/frontend/tests/e2e/palette-commands.spec.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-test.beforeEach(async ({ page }) => {
-  await mockApi(page);
-});
-
-test.describe("palette command dispatch", () => {
-  test("header trigger and Cmd+Shift+P open the palette", async ({ page }) => {
-    await page.goto("/pulls");
-
-    const trigger = page.getByRole("button", { name: "Open command palette" });
-    await expect(trigger).toBeVisible();
-    await trigger.click();
-
-    const dialog = page.getByRole("dialog", { name: "Command palette" });
-    await expect(dialog).toBeVisible();
-    await expect(page.locator(".palette-input")).toBeFocused();
-
-    await page.keyboard.press("Escape");
-    await expect(dialog).toBeHidden();
-
-    await page.keyboard.press("Meta+Shift+P");
-    await expect(dialog).toBeVisible();
-    await expect(page.locator(".palette-input")).toBeFocused();
-
-    await page.keyboard.press("Meta+Shift+P");
-    await expect(dialog).toBeHidden();
-  });
-
-  test("'>' filters to commands; running Open settings navigates", async ({ page }) => {
-    await page.goto("/pulls");
-    await page.keyboard.press("Meta+K");
-    await page.locator(".palette-input").fill(">settings");
-    await page.keyboard.press("Enter");
-    await expect(page).toHaveURL(/\/settings/);
-  });
-
-  test("typing a single character in the search input does not fire global j", async ({ page }) => {
-    await page.goto("/pulls");
-    // Wait for the PR list to render so .pr-list-row.selected has a
-    // chance to appear if the j shortcut leaks through.
-    await page.waitForSelector("[data-test='pr-list']");
-    await page.keyboard.press("Meta+K");
-    const before = await page.locator(".pr-list-row.selected").count();
-    await page.locator(".palette-input").fill("j");
-    const after = await page.locator(".pr-list-row.selected").count();
-    expect(after).toBe(before);
-  });
-
-  test("Cmd+P inside the palette closes it instead of opening browser print", async ({ page }) => {
-    await page.goto("/pulls");
-    await page.keyboard.press("Meta+K");
-    const dialog = page.getByRole("dialog", {
-      name: "Command palette",
-    });
-    await expect(dialog).toBeVisible();
-    await page.keyboard.press("Meta+P");
-    await expect(dialog).toBeHidden();
-  });
-});
diff --git a/frontend/tests/e2e/palette-focus-trap.spec.ts b/frontend/tests/e2e/palette-focus-trap.spec.ts
deleted file mode 100644
index cca430f42..000000000
--- a/frontend/tests/e2e/palette-focus-trap.spec.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-test.beforeEach(async ({ page }) => {
-  await mockApi(page);
-});
-
-test.describe("palette focus trap", () => {
-  test("Tab and Shift+Tab cycle within the open palette", async ({ page }) => {
-    await page.goto("/pulls");
-    // The palette is opened from anywhere via Meta+K (Ctrl+K on
-    // non-mac). Both bindings are wired to palette.open in
-    // defaultActions; Playwright's Meta key chord matches the mac
-    // convention used elsewhere in the suite.
-    await page.keyboard.press("Meta+K");
-
-    const dialog = page.getByRole("dialog", {
-      name: "Command palette",
-    });
-    await expect(dialog).toBeVisible();
-
-    const input = page.locator(".palette-input");
-    await expect(input).toBeFocused();
-
-    // Forward Tab: focus must stay inside the .palette dialog. The
-    // current palette markup has a single focusable element (the
-    // input), so the trap keeps focus there; once additional
-    // focusable rows land it should still cycle without escaping.
-    await page.keyboard.press("Tab");
-    const afterTab = await page.evaluate(() => {
-      const palette = document.querySelector(".palette");
-      return !!palette && palette.contains(document.activeElement);
-    });
-    expect(afterTab).toBe(true);
-
-    // Reverse Tab: same containment guarantee.
-    await page.keyboard.press("Shift+Tab");
-    const afterShiftTab = await page.evaluate(() => {
-      const palette = document.querySelector(".palette");
-      return !!palette && palette.contains(document.activeElement);
-    });
-    expect(afterShiftTab).toBe(true);
-
-    // Escape closes the palette and tears down the modal frame.
-    await page.keyboard.press("Escape");
-    await expect(dialog).toBeHidden();
-  });
-});
diff --git a/frontend/tests/e2e/palette-pr-detail-commands.spec.ts b/frontend/tests/e2e/palette-pr-detail-commands.spec.ts
deleted file mode 100644
index e63795658..000000000
--- a/frontend/tests/e2e/palette-pr-detail-commands.spec.ts
+++ /dev/null
@@ -1,171 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-import { mockApi } from "./support/mockApi";
-
-// E2E coverage for the PR-detail palette commands (`pr.approve`,
-// `pr.ready`, `pr.approveWorkflows`). The merge palette command is
-// intentionally not registered (the trigger lives in PullDetail.svelte's
-// local component state).
-
-test.beforeEach(async ({ page }) => {
-  await mockApi(page);
-});
-
-test.describe("PR-detail palette commands", () => {
-  test("Approve PR runs from the palette and triggers the approve flow", async ({ page }) => {
-    await page.goto("/pulls/github/acme/widgets/42");
-
-    // Capture the approve POST so we can assert the action wired
-    // through the same closure the existing button uses.
-    const approveRequest = page.waitForRequest(
-      (req) =>
-        req.method() === "POST" && /\/pulls\/github\/acme\/widgets\/42\/approve$/.test(new URL(req.url()).pathname),
-    );
-
-    await page.keyboard.press("Meta+K");
-    await page.locator(".palette-input").fill("approve pr");
-    await page.keyboard.press("Enter");
-
-    // The approve must pin the head the detail view rendered so the
-    // server can reject the action when the head moved after review.
-    const request = await approveRequest;
-    const body = request.postDataJSON() as { expected_head_sha?: string };
-    expect(body.expected_head_sha).toBe("42aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa42");
-  });
-
-  test("Approve PR is absent from the palette when the PR is closed", async ({ page }) => {
-    await page.route("**/api/v1/pulls/github/acme/widgets/55", async (route) => {
-      if (route.request().method() !== "GET") {
-        await route.fallback();
-        return;
-      }
-      await route.fulfill({
-        status: 200,
-        contentType: "application/json",
-        body: JSON.stringify({
-          merge_request: {
-            ID: 3,
-            RepoID: 1,
-            GitHubID: 301,
-            Number: 55,
-            URL: "https://github.com/acme/widgets/pull/55",
-            Title: "Refactor theme system",
-            Author: "luisa",
-            State: "closed",
-            IsDraft: false,
-            Body: "Consolidates theme tokens.",
-            HeadBranch: "refactor/theme",
-            BaseBranch: "main",
-            Additions: 80,
-            Deletions: 40,
-            CommentCount: 0,
-            ReviewDecision: "",
-            CIStatus: "pending",
-            CIChecksJSON: "[]",
-            CreatedAt: "2026-03-29T14:00:00Z",
-            UpdatedAt: "2026-03-30T14:00:00Z",
-            LastActivityAt: "2026-03-30T14:00:00Z",
-            MergedAt: null,
-            ClosedAt: "2026-03-30T14:00:00Z",
-            KanbanStatus: "new",
-            Starred: false,
-            repo_owner: "acme",
-            repo_name: "widgets",
-            platform_host: "github.com",
-            repo: {
-              provider: "github",
-              platform_host: "github.com",
-              repo_path: "acme/widgets",
-              owner: "acme",
-              name: "widgets",
-              capabilities: {
-                read_repositories: true,
-                read_merge_requests: true,
-                read_issues: true,
-                read_comments: true,
-                read_releases: true,
-                read_ci: true,
-                read_labels: true,
-                comment_mutation: true,
-                state_mutation: true,
-                merge_mutation: true,
-                label_mutation: true,
-                review_mutation: true,
-                workflow_approval: true,
-                ready_for_review: true,
-                issue_mutation: true,
-                review_draft_mutation: false,
-                review_thread_resolution: false,
-                read_review_threads: false,
-                native_multiline_ranges: false,
-                mutation_head_binding: false,
-                thread_reply: false,
-                thread_resolve: false,
-                supported_review_actions: [],
-              },
-            },
-            worktree_links: [],
-          },
-          events: [],
-          repo: {
-            provider: "github",
-            platform_host: "github.com",
-            repo_path: "acme/widgets",
-            owner: "acme",
-            name: "widgets",
-            capabilities: {
-              read_repositories: true,
-              read_merge_requests: true,
-              read_issues: true,
-              read_comments: true,
-              read_releases: true,
-              read_ci: true,
-              read_labels: true,
-              comment_mutation: true,
-              state_mutation: true,
-              merge_mutation: true,
-              label_mutation: true,
-              review_mutation: true,
-              workflow_approval: true,
-              ready_for_review: true,
-              issue_mutation: true,
-              review_draft_mutation: false,
-              review_thread_resolution: false,
-              read_review_threads: false,
-              native_multiline_ranges: false,
-              mutation_head_binding: false,
-              thread_reply: false,
-              thread_resolve: false,
-              supported_review_actions: [],
-            },
-          },
-          repo_owner: "acme",
-          repo_name: "widgets",
-          platform_host: "github.com",
-          detail_loaded: true,
-          detail_fetched_at: "2026-03-30T14:00:00Z",
-          worktree_links: [],
-        }),
-      });
-    });
-    await page.goto("/pulls/github/acme/widgets/55");
-
-    await page.keyboard.press("Meta+K");
-    await page.locator(".palette-input").fill("approve pr");
-
-    // Palette rows render as <button class="palette-row">; query by name
-    // against the actual role so a regression that surfaces the command
-    // anyway would fail this assertion (the previous role="option" query
-    // matched nothing regardless of palette state).
-    await expect(page.getByRole("button", { name: /Approve PR/i })).toHaveCount(0);
-  });
-
-  test("Mark ready for review appears only when the PR is a draft", async ({ page }) => {
-    await page.goto("/pulls/github/acme/widgets/42");
-    await page.keyboard.press("Meta+K");
-    await page.locator(".palette-input").fill("ready for review");
-    // Non-draft PR; the action should be filtered out by `when`. Same
-    // role-correctness note as the closed-PR test above.
-    await expect(page.getByRole("button", { name: /Mark ready for review/i })).toHaveCount(0);
-  });
-});
diff --git a/frontend/tests/e2e/support/mockApi.ts b/frontend/tests/e2e/support/mockApi.ts
index 6a2fac692..c6bae3008 100644
--- a/frontend/tests/e2e/support/mockApi.ts
+++ b/frontend/tests/e2e/support/mockApi.ts
@@ -1,650 +1,28 @@
-import type { Page, Route } from "@playwright/test";
+// Playwright page.route adapter over the shared mock API in
+// src/test/mockApiFetch.ts. The fixtures and /api/v1 route matching live
+// there (one definition for both the Playwright and Vitest suites); this
+// file only translates Playwright's Route/Request into the shared handler's
+// request shape. Specs layer scenario-specific page.route overrides on top
+// as before — later registrations win, so they shadow these defaults.
 
-const defaultProviderCapabilities = {
-  read_repositories: true,
-  read_merge_requests: true,
-  read_issues: true,
-  read_comments: true,
-  read_releases: true,
-  read_ci: true,
-  read_labels: true,
-  comment_mutation: true,
-  state_mutation: true,
-  merge_mutation: true,
-  label_mutation: true,
-  review_mutation: true,
-  workflow_approval: true,
-  ready_for_review: true,
-  issue_mutation: true,
-  review_draft_mutation: false,
-  review_thread_resolution: false,
-  read_review_threads: false,
-  native_multiline_ranges: false,
-  mutation_head_binding: false,
-  thread_reply: false,
-  thread_resolve: false,
-  supported_review_actions: [],
-};
+import type { Page } from "@playwright/test";
 
-const defaultOperationAvailability = { available: true };
-
-const defaultRepoOperations = {
-  add_comment: defaultOperationAvailability,
-  add_label: defaultOperationAvailability,
-  approve_workflow: defaultOperationAvailability,
-  close_issue: defaultOperationAvailability,
-  close_pr: defaultOperationAvailability,
-  mark_ready_for_review: defaultOperationAvailability,
-  merge_pr: defaultOperationAvailability,
-  remove_label: defaultOperationAvailability,
-  reopen_issue: defaultOperationAvailability,
-  reopen_pr: defaultOperationAvailability,
-  submit_review: defaultOperationAvailability,
-};
-
-function repoRef(owner: string, name: string, platformHost: string) {
-  return {
-    provider: "github",
-    platform_host: platformHost,
-    repo_path: `${owner}/${name}`,
-    owner,
-    name,
-    capabilities: defaultProviderCapabilities,
-  };
-}
-
-const pulls = [
-  {
-    ID: 1,
-    RepoID: 1,
-    GitHubID: 101,
-    Number: 42,
-    URL: "https://github.com/acme/widgets/pull/42",
-    Title: "Add browser regression coverage",
-    Author: "marius",
-    State: "open",
-    IsDraft: false,
-    Body: "Adds Playwright smoke tests for workspace panel.",
-    HeadBranch: "feature/playwright",
-    BaseBranch: "main",
-    Additions: 120,
-    Deletions: 12,
-    CommentCount: 3,
-    ReviewDecision: "APPROVED",
-    CIStatus: "success",
-    CIChecksJSON: "[]",
-    CreatedAt: "2026-03-29T14:00:00Z",
-    UpdatedAt: "2026-03-30T14:00:00Z",
-    LastActivityAt: "2026-03-30T14:00:00Z",
-    MergedAt: null,
-    ClosedAt: null,
-    KanbanStatus: "reviewing",
-    Starred: false,
-    repo_owner: "acme",
-    repo_name: "widgets",
-    platform_host: "github.com",
-    platform_head_sha: "42aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa42",
-    repo: repoRef("acme", "widgets", "github.com"),
-    worktree_links: [],
-  },
-  {
-    ID: 2,
-    RepoID: 2,
-    GitHubID: 201,
-    Number: 84,
-    URL: "https://example.com/acme/widgets/pull/84",
-    Title: "Mirror host stub PR",
-    Author: "marius",
-    State: "open",
-    IsDraft: false,
-    Body: "",
-    HeadBranch: "mirror/stub",
-    BaseBranch: "main",
-    Additions: 1,
-    Deletions: 0,
-    CommentCount: 0,
-    ReviewDecision: "",
-    CIStatus: "success",
-    CIChecksJSON: "[]",
-    CreatedAt: "2026-03-29T14:00:00Z",
-    UpdatedAt: "2026-03-30T14:00:00Z",
-    LastActivityAt: "2026-03-30T14:00:00Z",
-    MergedAt: null,
-    ClosedAt: null,
-    KanbanStatus: "new",
-    Starred: false,
-    repo_owner: "acme",
-    repo_name: "widgets",
-    platform_host: "example.com",
-    platform_head_sha: "84bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb84",
-    repo: repoRef("acme", "widgets", "example.com"),
-    worktree_links: [],
-  },
-  {
-    ID: 3,
-    RepoID: 1,
-    GitHubID: 301,
-    Number: 55,
-    URL: "https://github.com/acme/widgets/pull/55",
-    Title: "Refactor theme system",
-    Author: "luisa",
-    State: "open",
-    IsDraft: false,
-    Body: "Consolidates theme tokens.",
-    HeadBranch: "refactor/theme",
-    BaseBranch: "main",
-    Additions: 80,
-    Deletions: 40,
-    CommentCount: 0,
-    ReviewDecision: "",
-    CIStatus: "pending",
-    CIChecksJSON: "[]",
-    CreatedAt: "2026-03-29T14:00:00Z",
-    UpdatedAt: "2026-03-30T14:00:00Z",
-    LastActivityAt: "2026-03-30T14:00:00Z",
-    MergedAt: null,
-    ClosedAt: null,
-    KanbanStatus: "new",
-    Starred: false,
-    repo_owner: "acme",
-    repo_name: "widgets",
-    platform_host: "github.com",
-    platform_head_sha: "55cccccccccccccccccccccccccccccccccccc55",
-    repo: repoRef("acme", "widgets", "github.com"),
-    worktree_links: [
-      {
-        worktree_key: "projects/theme-rework",
-        worktree_branch: "refactor/theme",
-      },
-    ],
-  },
-];
-
-const issues = [
-  {
-    ID: 2,
-    RepoID: 1,
-    GitHubID: 202,
-    Number: 7,
-    URL: "https://github.com/acme/widgets/issues/7",
-    Title: "Theme toggle does not stick",
-    Author: "marius",
-    State: "open",
-    Body: "",
-    CommentCount: 1,
-    LabelsJSON: "[]",
-    CreatedAt: "2026-03-28T14:00:00Z",
-    UpdatedAt: "2026-03-30T14:00:00Z",
-    LastActivityAt: "2026-03-30T14:00:00Z",
-    ClosedAt: null,
-    Starred: false,
-    platform_host: "github.com",
-    repo_owner: "acme",
-    repo_name: "widgets",
-    repo: repoRef("acme", "widgets", "github.com"),
-  },
-];
-
-const repos = [
-  {
-    ID: 1,
-    Owner: "acme",
-    Name: "widgets",
-    Platform: "github",
-    PlatformHost: "github.com",
-    AllowSquashMerge: true,
-    AllowMergeCommit: true,
-    AllowRebaseMerge: true,
-    BackfillIssueComplete: true,
-    BackfillIssueCompletedAt: "2026-03-30T14:00:30Z",
-    BackfillIssuePage: 1,
-    BackfillPRComplete: true,
-    BackfillPRCompletedAt: "2026-03-30T14:00:30Z",
-    BackfillPRPage: 1,
-    ViewerCanMerge: true,
-    LastSyncStartedAt: "2026-03-30T14:00:00Z",
-    LastSyncCompletedAt: "2026-03-30T14:00:30Z",
-    LastSyncError: "",
-    CreatedAt: "2026-03-01T00:00:00Z",
-    capabilities: defaultProviderCapabilities,
-    operations: defaultRepoOperations,
-  },
-];
-
-// Twelve repos with open PRs on only a few of them, so switching the summary
-// page filter between "All" (2-digit count) and "Has PRs" (1-digit count)
-// exercises the results-label digit change.
-const repoSummaries = Array.from({ length: 12 }, (_, i) => {
-  const name = `repo-${String(i + 1).padStart(2, "0")}`;
-  return {
-    owner: "acme",
-    name,
-    platform_host: "github.com",
-    repo: {
-      provider: "github",
-      platform_host: "github.com",
-      owner: "acme",
-      name,
-      repo_path: `acme/${name}`,
-    },
-    cached_pr_count: i < 4 ? 3 : 0,
-    open_pr_count: i < 4 ? 3 : 0,
-    draft_pr_count: 0,
-    cached_issue_count: i < 3 ? 2 : 0,
-    open_issue_count: i < 3 ? 2 : 0,
-    most_recent_activity_at: "2026-03-30T12:00:00Z",
-    last_sync_completed_at: "2026-03-30T14:00:30Z",
-    last_sync_started_at: "2026-03-30T14:00:00Z",
-    last_sync_error: "",
-    active_authors: [],
-    recent_issues: [],
-  };
-});
-
-const syncStatus = {
-  running: false,
-  last_run_at: "2026-03-30T14:00:30Z",
-  last_error: "",
-};
-
-const settings = {
-  repos: [
-    {
-      provider: "github",
-      platform_host: "github.com",
-      owner: "acme",
-      name: "widgets",
-      repo_path: "acme/widgets",
-      is_glob: false,
-      matched_repo_count: 1,
-    },
-  ],
-  activity: {
-    view_mode: "threaded",
-    time_range: "7d",
-    hide_closed: false,
-    hide_bots: false,
-  },
-  terminal: {
-    font_family: "",
-    font_size: 14,
-    scrollback: 1000,
-    line_height: 1,
-    letter_spacing: 0,
-    cursor_blink: true,
-    font_ligatures: false,
-    renderer: "xterm",
-  },
-  agents: [],
-};
-
-function makeRateLimits() {
-  const now = Date.now();
-  return {
-    hosts: {
-      "github.com": {
-        requests_hour: 188,
-        rate_remaining: 4812,
-        rate_limit: 5000,
-        rate_reset_at: new Date(now + 42 * 60_000).toISOString(),
-        hour_start: new Date(now - 18 * 60_000).toISOString(),
-        sync_throttle_factor: 1,
-        sync_paused: false,
-        reserve_buffer: 200,
-        known: true,
-        budget_limit: 500,
-        budget_spent: 42,
-        budget_remaining: 458,
-        gql_remaining: 4950,
-        gql_limit: 5000,
-        gql_reset_at: new Date(now + 38 * 60_000).toISOString(),
-        gql_known: true,
-      },
-    },
-  };
-}
-
-async function fulfillJson(route: Route, body: unknown, status = 200): Promise<void> {
-  await route.fulfill({
-    status,
-    contentType: "application/json",
-    body: JSON.stringify(body),
-  });
-}
-
-function decodePathSegment(segment: string | undefined): string {
-  return decodeURIComponent(segment ?? "");
-}
-
-function canonicalProvider(provider: string): string {
-  const normalized = provider.toLowerCase();
-  if (normalized === "gh") return "github";
-  if (normalized === "gl") return "gitlab";
-  if (normalized === "fj") return "forgejo";
-  return normalized;
-}
-
-function defaultPlatformHost(provider: string): string {
-  switch (canonicalProvider(provider)) {
-    case "github":
-      return "github.com";
-    case "gitlab":
-      return "gitlab.com";
-    case "forgejo":
-      return "codeberg.org";
-    case "gitea":
-      return "gitea.com";
-    default:
-      return "";
-  }
-}
-
-function routePlatformHost(provider: string, hostSegment: string | undefined): string {
-  const host = decodePathSegment(hostSegment).trim();
-  return host || defaultPlatformHost(provider);
-}
-
-function matchesRouteIdentity(
-  candidate: {
-    repo?: { provider?: string | undefined } | undefined;
-    platform_host: string;
-    repo_owner: string;
-    repo_name: string;
-    Number: number;
-  },
-  ref: {
-    provider: string;
-    platformHost: string;
-    owner: string;
-    name: string;
-    number: number;
-  },
-): boolean {
-  return (
-    canonicalProvider(candidate.repo?.provider ?? "") === ref.provider &&
-    candidate.platform_host === ref.platformHost &&
-    candidate.repo_owner === ref.owner &&
-    candidate.repo_name === ref.name &&
-    candidate.Number === ref.number
-  );
-}
-
-function pullDetailResponse(pr: (typeof pulls)[number]) {
-  return {
-    merge_request: pr,
-    repo: pr.repo,
-    repo_owner: pr.repo_owner,
-    repo_name: pr.repo_name,
-    platform_host: pr.platform_host,
-    platform_head_sha: pr.platform_head_sha ?? "",
-    reviewed_head_sha: pr.platform_head_sha ?? "",
-    detail_loaded: true,
-    detail_fetched_at: "2026-03-30T14:00:00Z",
-    worktree_links: pr.worktree_links,
-  };
-}
+import { createMockApiHandler } from "../../../src/test/mockApiFetch";
 
 export async function mockApi(page: Page): Promise<void> {
-  // Deep-clone so mutations (e.g. PATCH) don't leak between tests.
-  const localPulls: typeof pulls = JSON.parse(JSON.stringify(pulls));
+  const api = createMockApiHandler();
 
   await page.route("**/api/v1/**", async (route) => {
-    const url = new URL(route.request().url());
-    const { pathname } = url;
-    const method = route.request().method();
-
-    if (method === "GET" && pathname === "/api/v1/pulls") {
-      await fulfillJson(route, localPulls);
-      return;
-    }
-
-    const providerPrMatch = pathname.match(
-      /^\/api\/v1(?:\/host\/([^/]+))?\/pulls\/([^/]+)\/([^/]+)\/([^/]+)\/(\d+)(?:\/(sync|sync\/async))?$/,
-    );
-    if (
-      providerPrMatch &&
-      ((method === "GET" && !providerPrMatch[6]) || (method === "POST" && providerPrMatch[6]?.startsWith("sync")))
-    ) {
-      const prProvider = canonicalProvider(decodePathSegment(providerPrMatch[2]));
-      const platformHost = routePlatformHost(prProvider, providerPrMatch[1]);
-      const prOwner = decodePathSegment(providerPrMatch[3]);
-      const prName = decodePathSegment(providerPrMatch[4]);
-      const prNumber = parseInt(providerPrMatch[5]!, 10);
-      const pr = localPulls.find((p) =>
-        matchesRouteIdentity(p, {
-          provider: prProvider,
-          platformHost,
-          owner: prOwner,
-          name: prName,
-          number: prNumber,
-        }),
-      );
-      if (pr) {
-        await fulfillJson(route, pullDetailResponse(pr));
-      } else {
-        await fulfillJson(route, { error: "Not found" }, 404);
-      }
-      return;
-    }
+    const request = route.request();
+    const url = new URL(request.url());
 
-    if (providerPrMatch && method === "PATCH" && !providerPrMatch[6]) {
-      const prProvider = canonicalProvider(decodePathSegment(providerPrMatch[2]));
-      const platformHost = routePlatformHost(prProvider, providerPrMatch[1]);
-      const prOwner = decodePathSegment(providerPrMatch[3]);
-      const prName = decodePathSegment(providerPrMatch[4]);
-      const prNumber = parseInt(providerPrMatch[5]!, 10);
-      const pr = localPulls.find((p) =>
-        matchesRouteIdentity(p, {
-          provider: prProvider,
-          platformHost,
-          owner: prOwner,
-          name: prName,
-          number: prNumber,
-        }),
-      );
-      if (!pr) {
-        await fulfillJson(route, { title: "Not found" }, 404);
-        return;
-      }
-      const reqBody = JSON.parse((await route.request().postData()) ?? "{}");
-      if (reqBody.title !== undefined) pr.Title = reqBody.title;
-      if (reqBody.body !== undefined) pr.Body = reqBody.body;
-      await fulfillJson(route, pullDetailResponse(pr));
-      return;
-    }
-
-    const approvePrMatch = pathname.match(
-      /^\/api\/v1(?:\/host\/([^/]+))?\/pulls\/([^/]+)\/([^/]+)\/([^/]+)\/(\d+)\/approve$/,
-    );
-    if (approvePrMatch && method === "POST") {
-      const prProvider = canonicalProvider(decodePathSegment(approvePrMatch[2]));
-      const platformHost = routePlatformHost(prProvider, approvePrMatch[1]);
-      const prOwner = decodePathSegment(approvePrMatch[3]);
-      const prName = decodePathSegment(approvePrMatch[4]);
-      const prNumber = parseInt(approvePrMatch[5]!, 10);
-      const pr = localPulls.find((p) =>
-        matchesRouteIdentity(p, {
-          provider: prProvider,
-          platformHost,
-          owner: prOwner,
-          name: prName,
-          number: prNumber,
-        }),
-      );
-      if (!pr) {
-        await fulfillJson(route, { title: "Not found" }, 404);
-        return;
-      }
-      await fulfillJson(route, { status: "approved" });
-      return;
-    }
-
-    const singlePrMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)$/);
-    if (method === "GET" && singlePrMatch) {
-      const prOwner = singlePrMatch[1];
-      const prName = singlePrMatch[2];
-      const prNumber = parseInt(singlePrMatch[3]!, 10);
-      const pr = localPulls.find((p) => p.repo_owner === prOwner && p.repo_name === prName && p.Number === prNumber);
-      if (pr) {
-        await fulfillJson(route, pullDetailResponse(pr));
-      } else {
-        await fulfillJson(route, { error: "Not found" }, 404);
-      }
-      return;
-    }
-
-    if (method === "GET" && pathname === "/api/v1/issues") {
-      await fulfillJson(route, issues);
-      return;
-    }
-
-    const providerIssueMatch = pathname.match(
-      /^\/api\/v1(?:\/host\/([^/]+))?\/issues\/([^/]+)\/([^/]+)\/([^/]+)\/(\d+)(?:\/(sync|sync\/async))?$/,
-    );
-    if (
-      providerIssueMatch &&
-      ((method === "GET" && !providerIssueMatch[6]) || (method === "POST" && providerIssueMatch[6]?.startsWith("sync")))
-    ) {
-      const issueProvider = canonicalProvider(decodePathSegment(providerIssueMatch[2]));
-      const platformHost = routePlatformHost(issueProvider, providerIssueMatch[1]);
-      const issueOwner = decodePathSegment(providerIssueMatch[3]);
-      const issueName = decodePathSegment(providerIssueMatch[4]);
-      const issueNumber = parseInt(providerIssueMatch[5]!, 10);
-      const issue = issues.find((candidate) =>
-        matchesRouteIdentity(candidate, {
-          provider: issueProvider,
-          platformHost,
-          owner: issueOwner,
-          name: issueName,
-          number: issueNumber,
-        }),
-      );
-      if (!issue) {
-        await fulfillJson(route, { title: "Not found" }, 404);
-        return;
-      }
-      await fulfillJson(route, {
-        issue,
-        repo: issue.repo,
-        events: [],
-        platform_host: issue.platform_host,
-        repo_owner: issue.repo_owner,
-        repo_name: issue.repo_name,
-        detail_loaded: true,
-        detail_fetched_at: "2026-03-30T14:00:00Z",
-      });
-      return;
-    }
-
-    const singleIssueMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/issues\/(\d+)$/);
-    if (method === "GET" && singleIssueMatch) {
-      const issueOwner = singleIssueMatch[1];
-      const issueName = singleIssueMatch[2];
-      const issueNumber = parseInt(singleIssueMatch[3]!, 10);
-      const issue = issues.find(
-        (candidate) =>
-          candidate.repo_owner === issueOwner && candidate.repo_name === issueName && candidate.Number === issueNumber,
-      );
-      if (!issue) {
-        await fulfillJson(route, { title: "Not found" }, 404);
-        return;
-      }
-      await fulfillJson(route, {
-        issue,
-        repo: issue.repo,
-        events: [],
-        platform_host: issue.platform_host,
-        repo_owner: issue.repo_owner,
-        repo_name: issue.repo_name,
-        detail_loaded: true,
-        detail_fetched_at: "2026-03-30T14:00:00Z",
-      });
-      return;
-    }
-
-    const syncIssueMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/issues\/(\d+)\/sync$/);
-    if (method === "POST" && syncIssueMatch) {
-      const issueOwner = syncIssueMatch[1];
-      const issueName = syncIssueMatch[2];
-      const issueNumber = parseInt(syncIssueMatch[3]!, 10);
-      const issue = issues.find(
-        (candidate) =>
-          candidate.repo_owner === issueOwner && candidate.repo_name === issueName && candidate.Number === issueNumber,
-      );
-      if (!issue) {
-        await fulfillJson(route, { title: "Not found" }, 404);
-        return;
-      }
-      await fulfillJson(route, {
-        issue,
-        events: [],
-        platform_host: issue.platform_host,
-        repo_owner: issue.repo_owner,
-        repo_name: issue.repo_name,
-        detail_loaded: true,
-        detail_fetched_at: "2026-03-30T14:00:00Z",
-      });
-      return;
-    }
-
-    if (method === "GET" && pathname === "/api/v1/repos") {
-      await fulfillJson(route, repos);
-      return;
-    }
-
-    if (method === "GET" && pathname === "/api/v1/repos/summary") {
-      await fulfillJson(route, repoSummaries);
-      return;
-    }
-
-    const providerRepoMatch = pathname.match(/^\/api\/v1(?:\/host\/([^/]+))?\/repo\/([^/]+)\/([^/]+)\/([^/]+)$/);
-    if (method === "GET" && providerRepoMatch) {
-      const repoProvider = canonicalProvider(decodePathSegment(providerRepoMatch[2]));
-      const platformHost = routePlatformHost(repoProvider, providerRepoMatch[1]);
-      const repoOwner = decodePathSegment(providerRepoMatch[3]);
-      const repoName = decodePathSegment(providerRepoMatch[4]);
-      const repo = repos.find(
-        (r) =>
-          canonicalProvider(r.Platform) === repoProvider &&
-          r.PlatformHost === platformHost &&
-          r.Owner === repoOwner &&
-          r.Name === repoName,
-      );
-      if (!repo) {
-        await fulfillJson(route, { error: "Not found" }, 404);
-        return;
-      }
-      await fulfillJson(route, repo);
-      return;
-    }
-
-    const singleRepoMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)$/);
-    if (method === "GET" && singleRepoMatch) {
-      const repo = repos.find((r) => r.Owner === singleRepoMatch[1] && r.Name === singleRepoMatch[2]);
-      if (!repo) {
-        await fulfillJson(route, { error: "Not found" }, 404);
-        return;
-      }
-      await fulfillJson(route, repo);
-      return;
-    }
-
-    if (method === "GET" && pathname === "/api/v1/sync/status") {
-      await fulfillJson(route, syncStatus);
-      return;
-    }
-
-    if (method === "GET" && pathname === "/api/v1/settings") {
-      await fulfillJson(route, settings);
-      return;
-    }
-
-    if (method === "GET" && pathname === "/api/v1/events") {
+    if (request.method() === "GET" && url.pathname === "/api/v1/events") {
       // Server-Sent Events endpoint. Tests don't need live data over the
       // wire, so reply with an empty SSE stream that keeps the connection
       // open just long enough for the page to settle. EventSource fires an
       // `error` event when the response closes; the events store treats
       // that as "disconnected" and the rest of the app keeps working.
+      // (The jsdom suite stubs EventSource instead, so this stays here.)
       await route.fulfill({
         status: 200,
         contentType: "text/event-stream",
@@ -653,33 +31,15 @@ export async function mockApi(page: Page): Promise<void> {
       return;
     }
 
-    if (method === "GET" && pathname === "/api/v1/rate-limits") {
-      await fulfillJson(route, makeRateLimits());
-      return;
-    }
-
-    if (method === "POST" && pathname === "/api/v1/sync") {
-      await fulfillJson(route, undefined, 202);
-      return;
-    }
-
-    const patchPrMatch = pathname.match(/^\/api\/v1\/repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)$/);
-    if (method === "PATCH" && patchPrMatch) {
-      const prOwner = patchPrMatch[1];
-      const prName = patchPrMatch[2];
-      const prNumber = parseInt(patchPrMatch[3]!, 10);
-      const pr = localPulls.find((p) => p.repo_owner === prOwner && p.repo_name === prName && p.Number === prNumber);
-      if (!pr) {
-        await fulfillJson(route, { title: "Not found" }, 404);
-        return;
-      }
-      const reqBody = JSON.parse((await route.request().postData()) ?? "{}");
-      if (reqBody.title !== undefined) pr.Title = reqBody.title;
-      if (reqBody.body !== undefined) pr.Body = reqBody.body;
-      await fulfillJson(route, pullDetailResponse(pr));
-      return;
-    }
-
-    await fulfillJson(route, { error: `Unhandled ${method} ${pathname}` }, 404);
+    const response = api.handle({
+      method: request.method().toUpperCase(),
+      url,
+      bodyText: request.postData() ?? "",
+    });
+    await route.fulfill({
+      status: response.status,
+      contentType: response.headers.get("Content-Type") ?? "application/json",
+      body: await response.text(),
+    });
   });
 }