🤖 feat: keep the VS Code host's workspace list live

[ThomasK33]

Summary

Second layer of the #5109 stack (the first, #5634, has merged). The VS Code extension host now keeps its workspace list live between refreshes. One workspace.onMetadata subscription feeds the host. For each update, the host compares only the changed workspace's projection with what it last posted. Events that change nothing the webview receives post nothing and touch no list. The webview UI and the dock activity are unchanged in this layer. The next layer (PR2b) adds the selected + descendants activity pump and the sub-agent tasks strip.

Refs #5109

Implementation

• vscode/src/workspaceMetadataPump.ts (new, unit-tested outside extension.ts): it forwards the snapshot once (onSnapshot) and then one onUpdate(workspaceId, metadata | null) per event. Archived workspaces arrive as removals, as workspace.list omits them. An aborted subscription ignores late events and errors.
• extension.ts:
  • refreshWorkspaces starts one metadata subscription on the client that just listed the workspaces, so it needs no extra discovery or auth ping. It aborts the previous one. A mux.serverUrl or auth token change, file mode, refresh failures and dispose stop it, so no event from an old endpoint lands.
  • The host keeps a per-workspace map of the JSON it last posted (postedProjections). An update computes toUiWorkspace for that one workspace and compares the string. Equal means no list rebuild, no sort and no post: the host only refreshes its stored copy of that workspace in a map (for example the name that opening the workspace reads). Removal of an unknown workspace also returns at once.
  • A real change (creation, removal, archive, or a projected field such as the title) re-sorts the list once, built from that map, and posts it. The snapshot takes the same path, and posts only if the whole list differs. A refresh always posts, because a new webview has no list.
  • If the selected workspace disappears, the host clears the selection, as a refresh does.
  • There is no timer debounce and no onChat batchReplay or replayWindow opt-in.

Numbers (perf-owner scenario: ~4.5k workspaces, 10 unrelated metadata events per second for 60 s)

Two runs, both with the real XumChatViewProvider from extension.ts. "Unrelated" means a change to fields the webview is never sent. The harness runs under Bun. The handler time comes from a timing patch applied only for these runs (script below).

In-process (local oRPC server in the test process, 4,502 workspaces):

	This PR	Previous design of this PR (full list rebuild per event)
Unrelated events	593	593
workspaces posts from them	0	0
Host handler time for them	11.72 ms in total (0.02 ms each)	3,395.6 ms for 604 calls (5.6 ms each)
Process CPU during the 60 s load (idle 60 s: 1,356 ms / 1,375 ms)	7,908 ms	14,242 ms
Event-loop delay under load	p50 1.00 ms, p99 3.26 ms	p50 1.00 ms, p99 5.94 ms
10 real task renames	10 posts, latency p50 6.25 ms, max 13.24 ms	10 posts, p50 10.15 ms, max 12.02 ms

Rerun after the round-1 review fix (head 40d359fe64, which adds one Map.set to the skip path): 594 unrelated events, 0 workspaces posts, skip-path handler time 13.10 ms in total (0.02 ms each), process CPU 8,990 ms under load vs 1,511 ms idle, event-loop delay p99 2.40 ms under load vs 1.60 ms idle. 10 real task renames gave 10 posts, latency p50 14.23 ms, max 15.43 ms. The table above and the live table below were measured at b21cc4494f; the two later review fixes touch only the skip path's Map.set and the subscription's shutdown on connection changes.

Live xum server (mock AI, a fresh root seeded with 4,502 workspaces, one of them a sub-agent task). The load driver alternates setPinned and updateTags on synthetic workspaces at 10 calls per second. The real change is updateTitle on the sub-agent task.

Measure	Result
Unrelated API changes / metadata events delivered	593 / 445
workspaces posts from them	0
Host handler time for the 445 events	11.03 ms in total (0.025 ms each)
Process CPU, 60 s load vs 60 s idle	8,279 ms vs 1,050 ms
Event-loop delay, load vs idle	p99 2.49 ms vs 1.88 ms (max 6.70 ms vs 4.38 ms)
10 sub-agent retitles	10 posts; latency from the API call to the post p50 131.78 ms, max 232.72 ms

The process CPU includes the oRPC transport and, in the live run, the load driver's 593 HTTP calls in the same process. The host's own share is the handler time row.

Earlier small live run (fresh root, 7 workspaces): 31 metadata events, of which 20 changed no projected field (pin and tag updates, unchanged titles, the second event of each creation or archive). Those 20 caused 0 posts. The other 11 caused 11 posts.

Benchmark harness (kept outside the repo)

make-bench.sh copies vscode/src/extension.test.ts (mocked vscode, local oRPC server, real chat view provider), turns off Bun.serve's 10 s idle timeout, optionally points the provider at a live server, and appends one benchmark. Run from vscode/: bun test src/bench5109.test.ts -t bench5109 (in-process) or LIVE_URL=... LIVE_TOKEN=... bun test src/bench5109.test.ts -t live5109.

# usage: bash make-bench.sh.txt <worktree> <append-file>
# Copies extension.test.ts (its harness: mocked vscode, local oRPC server, real chat view
# provider), disables the local server's 10 s idle timeout, and appends the benchmark.
set -euo pipefail
W=$1; A=$2
sed -e 's/^    port: 0,$/    port: 0,\n    idleTimeout: 0,/' \
    -e 's#settings.set("mux.serverUrl", server.url);#settings.set("mux.serverUrl", process.env.LIVE_URL ?? server.url);#' \
    -e 's#\[\[SECRET_KEY, "token-a"\]\]#[[SECRET_KEY, process.env.LIVE_TOKEN ?? "token-a"]]#' \
    "$W/vscode/src/extension.test.ts" > "$W/vscode/src/bench5109.test.ts"
cat "$A" >> "$W/vscode/src/bench5109.test.ts"
grep -c 'idleTimeout: 0\|LIVE_URL ?? server.url\|LIVE_TOKEN ?? "token-a"' "$W/vscode/src/bench5109.test.ts"

Timing patch applied to extension.ts for the handler rows:

diff --git a/vscode/src/extension.ts b/vscode/src/extension.ts
index 31eba1b190..e8722738ab 100644
--- a/vscode/src/extension.ts
+++ b/vscode/src/extension.ts
@@ -1781,13 +1781,14 @@ class XumChatViewProvider implements vscode.WebviewViewProvider, vscode.Disposab
       signal: controller.signal,
       onSnapshot: (workspaces) => this.relist(workspaces),
       onUpdate: async (workspaceId, metadata) => {
+        const __t0 = performance.now(); (globalThis as any).__benchN = ((globalThis as any).__benchN ?? 0) + 1; queueMicrotask(() => { (globalThis as any).__benchMs = ((globalThis as any).__benchMs ?? 0) + performance.now() - __t0; });
         const previous = this.workspacesById.get(workspaceId);
         const next = metadata && { ...metadata, extensionMetadata: previous?.extensionMetadata };
         // Compare only this workspace with its last posted projection: most events change fields
         // the webview never sees, and rebuilding a list of thousands per event is too slow. Such
         // an event also leaves the stored copy as is; the host reads nothing it changed.
         const posted = this.postedProjections.get(workspaceId);
-        if (posted === (next ? JSON.stringify(toUiWorkspace(next)) : undefined)) return;
+        if (posted === (next ? JSON.stringify(toUiWorkspace(next)) : undefined)) { (globalThis as any).__skipMs = ((globalThis as any).__skipMs ?? 0) + performance.now() - __t0; (globalThis as any).__skipN = ((globalThis as any).__skipN ?? 0) + 1; return; }
         const others = this.workspaces.filter((w) => w.id !== workspaceId);
         await this.relist(next ? [...others, next] : others);
       },

In-process benchmark:

// ---- #5109 PR2a benchmark (scratch, not committed): appended to a copy of extension.test.ts ----
describe("bench5109", () => {
  test("bench5109: 10 unrelated metadata events/s for 60 s with 4.5k workspaces", async () => {
    const SECONDS = Number(process.env.BENCH_SECONDS ?? 60);
    const synthetic = Array.from({ length: 4_500 }, (_, i) => ({
      ...WORKSPACE,
      id: `ws-s${i}`,
      name: `s${i}`,
      createdAt: "2026-09-01T00:00:00.000Z",
    }));
    const child = { ...WORKSPACE, id: "ws-child", name: "child", parentWorkspaceId: WORKSPACE.id };
    const harness = await setup([WORKSPACE, child, ...synthetic]);
    const { state } = harness.server;
    type Msg = PostedMessage & { workspaces?: unknown[] };
    const lists = () => (harness.posted as Msg[]).filter((m) => m.type === "workspaces").length;
    await until(() => lists() >= 1, "the first list");
    await new Promise((r) => setTimeout(r, 1000)); // let the snapshot settle

    // Event-loop delay: a 10 ms sampler; delay = actual interval - 10 ms.
    const sampleLoop = (ms: number) =>
      new Promise<number[]>((resolve) => {
        const delays: number[] = [];
        let last = performance.now();
        const timer = setInterval(() => {
          const now = performance.now();
          delays.push(Math.max(0, now - last - 10));
          last = now;
        }, 10);
        setTimeout(() => {
          clearInterval(timer);
          resolve(delays);
        }, ms);
      });
    const stats = (values: number[]) => {
      const s = [...values].sort((a, b) => a - b);
      const at = (p: number) => s[Math.min(s.length - 1, Math.floor(p * s.length))].toFixed(2);
      return `p50 ${at(0.5)} ms, p99 ${at(0.99)} ms, max ${s[s.length - 1].toFixed(2)} ms`;
    };
    const cpuMs = (u: NodeJS.CpuUsage) => ((u.user + u.system) / 1000).toFixed(0);

    // Baseline: same window, no events.
    let cpu0 = process.cpuUsage();
    const idleDelays = await sampleLoop(SECONDS * 1000);
    const idleCpu = process.cpuUsage(cpu0);

    // Load: 10 unrelated events per second (fields the webview is never sent).
    const posts0 = lists();
    cpu0 = process.cpuUsage();
    let sent = 0;
    const emitter = setInterval(() => {
      const target = synthetic[(sent * 37) % synthetic.length];
      state.metadata.push({
        workspaceId: target.id,
        metadata: { ...target, namedWorkspacePath: `/tmp/n${sent}`, pinned: sent % 2 === 0 },
      });
      sent += 1;
      notify();
    }, 100);
    const loadDelays = await sampleLoop(SECONDS * 1000);
    clearInterval(emitter);
    await new Promise((r) => setTimeout(r, 500));
    const loadCpu = process.cpuUsage(cpu0);
    const unrelatedPosts = lists() - posts0;

    // Real task changes: rename the sub-agent 10 times; each must post once.
    const latencies: number[] = [];
    const posts1 = lists();
    for (let i = 0; i < 10; i++) {
      const before = lists();
      const t0 = performance.now();
      state.metadata.push({ workspaceId: child.id, metadata: { ...child, title: `Task ${i}` } });
      notify();
      await until(() => lists() > before, "the rename post");
      latencies.push(performance.now() - t0);
      await new Promise((r) => setTimeout(r, 200));
    }
    const realPosts = lists() - posts1;

    const report = [
      `workspaces listed: ${synthetic.length + 2}; window: ${SECONDS} s`,
      `idle:  CPU ${cpuMs(idleCpu)} ms; event-loop delay ${stats(idleDelays)}`,
      `load:  ${sent} unrelated events; workspaces posts ${unrelatedPosts}; CPU ${cpuMs(loadCpu)} ms; event-loop delay ${stats(loadDelays)}`,
      `real:  10 task renames; workspaces posts ${realPosts}; latency ${stats(latencies)}`,
    ].join("\n");
    console.log(`BENCH5109\n${report}\nhandler: ${(globalThis as any).__benchN} calls, ${(globalThis as any).__benchMs?.toFixed(1)} ms; skip path ${(globalThis as any).__skipN} calls ${(globalThis as any).__skipMs?.toFixed(2)} ms`);
  }, 10 * 60_000);
});

Live benchmark (the server ran as XUM_ROOT=<seeded root> XUM_MOCK_AI=1 node dist/cli/index.js server --auth-token ..., with 4,500 s<i> workspaces plus a parent and one sub-agent task in config.json):

// ---- #5109 PR2a live benchmark (scratch, not committed): real xum server with ~4.5k workspaces ----
import { createApiClient as createLiveClient } from "./api/client";
describe("live5109", () => {
  test("live5109: 10 unrelated metadata changes/s for 60 s against a live server", async () => {
    const SECONDS = Number(process.env.BENCH_SECONDS ?? 60);
    const live = createLiveClient({ baseUrl: process.env.LIVE_URL!, authToken: process.env.LIVE_TOKEN! });
    const all = await live.workspace.list();
    const child = all.find((w) => w.parentWorkspaceId != null);
    const synthetic = all.filter((w) => w.name.startsWith("s"));
    if (!child || synthetic.length < 4000) throw new Error(`bad root: ${all.length}`);
    const harness = await setup();
    type Msg = PostedMessage & { workspaces?: unknown[] };
    const lists = () => (harness.posted as Msg[]).filter((m) => m.type === "workspaces");
    await until(() => lists().length >= 1, "the first list");
    await new Promise((r) => setTimeout(r, 3000)); // the snapshot after the refresh
    const listedCount = lists().at(-1)?.workspaces?.length;

    const sampleLoop = (ms: number) =>
      new Promise<number[]>((resolve) => {
        const delays: number[] = [];
        let last = performance.now();
        const timer = setInterval(() => {
          const now = performance.now();
          delays.push(Math.max(0, now - last - 10));
          last = now;
        }, 10);
        setTimeout(() => { clearInterval(timer); resolve(delays); }, ms);
      });
    const stats = (values: number[]) => {
      const s = [...values].sort((a, b) => a - b);
      const at = (p: number) => s[Math.min(s.length - 1, Math.floor(p * s.length))].toFixed(2);
      return `p50 ${at(0.5)} ms, p99 ${at(0.99)} ms, max ${s[s.length - 1].toFixed(2)} ms`;
    };
    const cpuMs = (u: NodeJS.CpuUsage) => ((u.user + u.system) / 1000).toFixed(0);

    let cpu0 = process.cpuUsage();
    const idleDelays = await sampleLoop(SECONDS * 1000);
    const idleCpu = process.cpuUsage(cpu0);

    // Unrelated: pin/unpin and tag edits, which the webview is never sent.
    const posts0 = lists().length;
    cpu0 = process.cpuUsage();
    let sent = 0;
    const calls: Promise<unknown>[] = [];
    const emitter = setInterval(() => {
      const target = synthetic[(sent * 37) % synthetic.length];
      calls.push(
        sent % 2 === 0
          ? live.workspace.setPinned({ workspaceId: target.id, pinned: (sent >> 1) % 2 === 0 } as never)
          : live.workspace.updateTags({ workspaceId: target.id, tags: { bench: String(sent) } } as never)
      );
      sent += 1;
    }, 100);
    const loadDelays = await sampleLoop(SECONDS * 1000);
    clearInterval(emitter);
    await Promise.all(calls);
    await new Promise((r) => setTimeout(r, 1000));
    const loadCpu = process.cpuUsage(cpu0);
    const unrelatedPosts = lists().length - posts0;

    // Real task change: retitle the sub-agent workspace; latency from the API call to the post.
    const latencies: number[] = [];
    const posts1 = lists().length;
    for (let i = 0; i < 10; i++) {
      const before = lists().length;
      const t0 = performance.now();
      await live.workspace.updateTitle({ workspaceId: child.id, title: `Task ${Date.now()}-${i}` });
      await until(() => lists().length > before, "the retitle post");
      latencies.push(performance.now() - t0);
      await new Promise((r) => setTimeout(r, 300));
    }
    await new Promise((r) => setTimeout(r, 1000));
    const realPosts = lists().length - posts1;

    console.log(
      [
        "LIVE5109",
        `server workspaces: ${all.length}; host list: ${listedCount}; window: ${SECONDS} s`,
        `idle:  CPU ${cpuMs(idleCpu)} ms; event-loop delay ${stats(idleDelays)}`,
        `load:  ${sent} unrelated changes; workspaces posts ${unrelatedPosts}; CPU ${cpuMs(loadCpu)} ms; event-loop delay ${stats(loadDelays)}`,
        `real:  10 sub-agent retitles; workspaces posts ${realPosts}; latency ${stats(latencies)}`,
        `handler: ${(globalThis as any).__benchN} calls; skip path ${(globalThis as any).__skipN} calls ${(globalThis as any).__skipMs?.toFixed(2)} ms`,
      ].join("\n")
    );
  }, 10 * 60_000);
});

Tests

• extension.test.ts: a burst of 21 metadata events against 4,500 synthetic workspaces plus the real ones. Only the creation, the rename, the archive and a final creation post. Five unrelated updates to synthetic workspaces, five to the new child, a removal of an unknown workspace and a removal of an already archived one post nothing. Each post still carries all 4,500 synthetic workspaces.
• extension.test.ts: with a display title set, a rename changes only name; opening the workspace afterwards uses the new checkout path.
• extension.test.ts: a server URL change and an auth token change each close the subscription; a refresh opens a new one.
• workspaceMetadataPump.test.ts: a subscription replaced mid-stream ignores its late event and its error.

Pre-fix: with extension.ts reverted to the base commit, the new burst case in extension.test.ts fails (timed out waiting for the end of the burst); the other 8 cases in the two files pass.

Risks

Low. The host now posts workspaces between refreshes. The webview already handles that message idempotently: it re-seeds sub-agent AI settings and does not reset the transcript.

Size: 313 changed lines (304+, 9-), tests included.

---

Generated with xum • Model: anthropic:claude-opus-5-5 • Thinking: high • Cost: $39.94

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-04T21:53:39.017563Z	85cd59b	New commits
🔒 Security Review	✅ Completed 2026-10-04T21:55:04.318611Z	85cd59b	New commits

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: b21cc4494f

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 40d359fe64

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[ThomasK33]

Readiness record

• Final commit: 85cd59bf315a2f590a5c9e9cac5b58122743a9d8
• Local validation on this head: make static-check passed; bun test ./vscode/src/ 151 pass, 0 fail.
• Required CI: all passing on this head (the optional Pixel / Review is ignored).
• Review count: 7 assessments. 6 automatic (3 rounds: 1 P2, 1 P2, clean) and 1 final independent check. Slot 7 granted by the coordinator for the final check.
• Both P2 findings were defects this PR introduced. Each was fixed with a failing-first test (40d359f, 85cd59b).
• Perf requirements: per-workspace projection compare, 0 workspaces posts for unrelated events at 4,502 workspaces (in-process and live server numbers in the PR body), no timer debounce.
• Final independent check: "ready with tracked follow-ups". No P1. Its non-blocking suggestions (refresh race on a connection change, reconnect after a stream error, multi-project filter on updates, two optional tests) are tracked in 🤖 fix: VS Code live workspace list follow-ups (refresh race, reconnect, multi-project filter) #5654 (backlog).
• Reason for stopping: required checks green, all threads resolved, final check recommends ready.

---

Generated with xum • Model: anthropic:claude-opus-5-5 • Thinking: high