@nanobpm/nano-workforce 0.195.1 → 0.196.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.196.0](https://github.com/nanobpm/nano-workforce/compare/v0.195.2...v0.196.0) (2026-09-30)
+
+### Features
+
+* **cockpit:** 'Agent' link on active rows opens the cockpit focused on that process ([#834](https://github.com/nanobpm/nano-workforce/issues/834)) ([c9c07a3](https://github.com/nanobpm/nano-workforce/commit/c9c07a3886d065d407260c2dabe2abb410fc7d2d)), closes [#833](https://github.com/nanobpm/nano-workforce/issues/833)
+
+## [0.195.2](https://github.com/nanobpm/nano-workforce/compare/v0.195.1...v0.195.2) (2026-09-30)
+
+### Bug Fixes
+
+* **converge-gate:** gate Copilot ccr-overview-v2 table findings ([#835](https://github.com/nanobpm/nano-workforce/issues/835)) ([#836](https://github.com/nanobpm/nano-workforce/issues/836)) ([8e3c0b6](https://github.com/nanobpm/nano-workforce/commit/8e3c0b690b7a212b0fcd4904b9e50ab7589e5bda))
+
 ## [0.195.1](https://github.com/nanobpm/nano-workforce/compare/v0.195.0...v0.195.1) (2026-09-30)
 
 ### Bug Fixes

package/app/agentic/cockpit/cockpit-route.test.ts

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
 
-import { parseCockpitRoute } from "./cockpit-route.ts";
+import { parseCockpitRoute, parseHostCockpitParam } from "./cockpit-route.ts";
 
 test("parses empty and main cockpit hashes as the main route", () => {
   assert.deepEqual(parseCockpitRoute(""), { kind: "main" });
@@ -19,3 +19,17 @@ test("empty worker and junk hashes fall back to the main route", () => {
   assert.deepEqual(parseCockpitRoute("#/elsewhere"), { kind: "main" });
   assert.deepEqual(parseCockpitRoute("#/cockpit/worker/%E0%A4%A"), { kind: "main" });
 });
+
+test("#833: parses a process-focus hash into the process route", () => {
+  assert.deepEqual(parseCockpitRoute("#/cockpit/process/2251799813685249"), { kind: "process", processInstanceKey: "2251799813685249" });
+  assert.deepEqual(parseCockpitRoute("#/cockpit/process/"), { kind: "main" });
+});
+
+test("#833: the host page's #/cockpit/<process_key> param (an 'Agent' grid link) focuses that process", () => {
+  assert.equal(parseHostCockpitParam("#/cockpit/2251799813685249"), "2251799813685249");
+  assert.equal(parseHostCockpitParam("#/cockpit/a%20b"), "a b");
+  assert.equal(parseHostCockpitParam("#/cockpit"), undefined);
+  assert.equal(parseHostCockpitParam("#/cockpit/"), undefined);
+  assert.equal(parseHostCockpitParam("#/overview/123"), undefined);
+  assert.equal(parseHostCockpitParam("#/cockpit/%E0%A4%A"), undefined);
+});

package/app/agentic/cockpit/cockpit-route.ts

@@ -1,17 +1,46 @@
-export type CockpitRoute = { readonly kind: "main" } | { readonly kind: "worker"; readonly instance: string };
+export type CockpitRoute =
+  | { readonly kind: "main" }
+  | { readonly kind: "worker"; readonly instance: string }
+  /** Focused on one process instance (#833) — the target of an "Agent" grid link. */
+  | { readonly kind: "process"; readonly processInstanceKey: string };
+
+function decodeSegment(raw: string): string | undefined {
+  if (raw === "") return undefined;
+  try {
+    const value = decodeURIComponent(raw);
+    return value === "" ? undefined : value;
+  } catch {
+    return undefined;
+  }
+}
 
 /** Parse the cockpit hash route. Unknown or malformed hashes fall back to the main list. */
 export function parseCockpitRoute(hash: string): CockpitRoute {
   const route = hash.startsWith("#") ? hash.slice(1) : hash;
-  if (route === "" || route === "/cockpit" || route === "/cockpit/") return { kind: "main" };
-  const prefix = "/cockpit/worker/";
-  if (!route.startsWith(prefix)) return { kind: "main" };
-  const raw = route.slice(prefix.length);
-  if (raw === "") return { kind: "main" };
-  try {
-    const instance = decodeURIComponent(raw);
-    return instance === "" ? { kind: "main" } : { kind: "worker", instance };
-  } catch {
-    return { kind: "main" };
+  const worker = "/cockpit/worker/";
+  if (route.startsWith(worker)) {
+    const instance = decodeSegment(route.slice(worker.length));
+    return instance === undefined ? { kind: "main" } : { kind: "worker", instance };
+  }
+  const process = "/cockpit/process/";
+  if (route.startsWith(process)) {
+    const processInstanceKey = decodeSegment(route.slice(process.length));
+    return processInstanceKey === undefined ? { kind: "main" } : { kind: "process", processInstanceKey };
   }
+  return { kind: "main" };
+}
+
+/**
+ * The process-instance key carried by the HOST page's `#/cockpit/<param>` route (#833). An "Agent" grid
+ * link (`{ kind: "page", page: "cockpit", keyField: "process_key" }`) navigates the host page — the
+ * cockpit embed is an iframe with its own hash — so the embed reads the param from its same-origin
+ * parent. Only a single, decodable segment counts; anything else is undefined (no focus).
+ */
+export function parseHostCockpitParam(hash: string): string | undefined {
+  const route = hash.startsWith("#") ? hash.slice(1) : hash;
+  const prefix = "/cockpit/";
+  if (!route.startsWith(prefix)) return undefined;
+  const raw = route.slice(prefix.length);
+  if (raw.includes("/")) return undefined;
+  return decodeSegment(raw);
 }

package/app/agentic/cockpit/mount.test.ts

@@ -99,6 +99,7 @@ test("the rendered transcript region sits directly beneath the Workers — suppl
     const shell = document.querySelector(".cockpit-shell");
     const order = [...(shell?.children ?? [])].map((c: { className: string }) => c.className);
     assertEquals(order, [
+      "cockpit-focus",
       "cockpit-supply-region",
       "cockpit-terminal",
       "cockpit-past-region",
@@ -407,3 +408,393 @@ test("agent-history tool call with an empty-string elementId renders no empty ()
     restore();
   }
 });
+
+// #833 — an "Agent" grid link lands on the cockpit focused on ONE process instance. The agent may run
+// in a CHILD instance (call activity), so the focus resolves the engine AgentInstances whose ROOT is
+// the linked key and matches live job correlations against every instance in that tree.
+const PI_ROOT = "pi-root";
+const FOCUS_INSTANCE = {
+  agentInstanceKey: "ai-7",
+  status: "THINKING",
+  processInstanceKey: "pi-child",
+  rootProcessInstanceKey: PI_ROOT,
+  elementId: "implement-task",
+  creationDate: "2024-01-01T00:00:00Z",
+};
+const FOCUS_HISTORY = {
+  agentInstanceKey: "ai-7",
+  count: 1,
+  instance: FOCUS_INSTANCE,
+  records: [
+    {
+      historyItemKey: "h-0",
+      agentInstanceKey: "ai-7",
+      loopIteration: 0,
+      role: "ASSISTANT",
+      commitStatus: "COMMITTED",
+      content: [{ contentType: "TEXT", text: "working on the focused process" }],
+      toolCalls: [],
+    },
+  ],
+};
+
+function focusStub(opts: { correlations: unknown[]; transcripts?: unknown[]; replay?: unknown; seen?: string[] }) {
+  return (url: string): Promise<unknown> => {
+    opts.seen?.push(url);
+    const ok = (body: unknown) => Promise.resolve({ ok: true, status: 200, json: async () => body });
+    if (url.includes("/supply")) return ok({ leaves: [], workers: [], correlations: opts.correlations });
+    if (/\/agent-instances\/[^/?]+\/history/.test(url)) return ok(FOCUS_HISTORY);
+    if (url.includes("/agent-instances")) {
+      const root = url.includes(`rootProcessInstanceKey=${PI_ROOT}`);
+      return ok(root ? { count: 1, instances: [FOCUS_INSTANCE] } : { count: 0, instances: [] });
+    }
+    if (/[?&]stream=/.test(url)) return ok(opts.replay);
+    if (url.includes("/transcripts")) {
+      const mine = (opts.transcripts ?? []).filter((t) => url.includes(`processInstanceKey=${(t as { processInstanceKey: string }).processInstanceKey}`));
+      return ok({ count: mine.length, transcripts: mine });
+    }
+    return Promise.resolve({ ok: false, status: 404, json: async () => ({}) });
+  };
+}
+
+async function settle(): Promise<void> {
+  for (let i = 0; i < 20; i++) await new Promise((r) => setTimeout(r, 0));
+}
+
+test("#833: a process-focus route live-drills the worker running a job of a CHILD instance and shows its agent history", async () => {
+  const restore = installEnv(focusStub({ correlations: [{ jobKey: "j1", stream: "wk-a/j1", processInstanceKey: "pi-child" }] }));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assert((document.querySelector(".cockpit-focus")?.textContent ?? "").includes(PI_ROOT), "the focus banner names the process");
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "live");
+      assert(StubWebSocket.instances.length > 0, "a relay socket was opened for the focused job");
+      const transcript = document.querySelector('.cockpit-agent-transcript[data-agent-instance-key="ai-7"]');
+      assert((transcript?.textContent ?? "").includes("working on the focused process"), "the focused agent's history is shown");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#833: with no live job, the process focus replays the newest captured transcript of that process", async () => {
+  const replay = {
+    stream: "wk-a/j9",
+    from: 0,
+    gap: false,
+    nextOffset: 1,
+    entries: [{ offset: 0, chunk: envChunk("message", { role: "assistant", text: "finished earlier" }) }],
+  };
+  const transcripts = [
+    { stream: "wk-a/j9", lifecycle: "ephemeral", status: "completed", createdAt: "2024-01-01T00:00:00Z", nextOffset: 1, byteLength: 10, chunkCount: 1, processInstanceKey: "pi-child" },
+  ];
+  const restore = installEnv(focusStub({ correlations: [], transcripts, replay }));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "replay");
+      assert((document.querySelector('[data-terminal="host"]')?.textContent ?? "").includes("finished earlier"));
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#833: embedded, the host page's #/cockpit/<process_key> (the grid 'Agent' link) focuses the cockpit", async () => {
+  const restore = installEnv(focusStub({ correlations: [] }));
+  const win = (globalThis as { window: Record<string, unknown> }).window;
+  const savedParent = win.parent;
+  win.parent = { location: { hash: `#/cockpit/${PI_ROOT}` } };
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assert((document.querySelector(".cockpit-focus")?.textContent ?? "").includes(PI_ROOT), "the host param focused the cockpit");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    win.parent = savedParent;
+    restore();
+  }
+});
+
+test("#833: no focus route → no focus banner", async () => {
+  const restore = installEnv(fetchStub());
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assertEquals(document.querySelector(".cockpit-focus")?.getAttribute("data-focus"), "none");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+// #834 review — a MUTABLE fetch stub: the supply correlations and per-tree transcripts can change
+// between polls, so a test can model a focused live job finishing and its session becoming a capture.
+function mutableFocusStub(state: { correlations: unknown[]; transcripts: unknown[]; replay?: unknown; roots?: string[] }) {
+  return (url: string): Promise<unknown> => {
+    const ok = (body: unknown) => Promise.resolve({ ok: true, status: 200, json: async () => body });
+    if (url.includes("/supply")) return ok({ leaves: [], workers: [], correlations: state.correlations });
+    if (/\/agent-instances\/[^/?]+\/history/.test(url)) return ok(FOCUS_HISTORY);
+    if (url.includes("/agent-instances")) {
+      const root = (state.roots ?? [PI_ROOT]).some((r) => url.includes(`rootProcessInstanceKey=${r}`));
+      return ok(root ? { count: 1, instances: [FOCUS_INSTANCE] } : { count: 0, instances: [] });
+    }
+    if (/[?&]stream=/.test(url)) return ok(state.replay);
+    if (url.includes("/transcripts")) {
+      const mine = state.transcripts.filter((t) => url.includes(`processInstanceKey=${(t as { processInstanceKey: string }).processInstanceKey}`));
+      return ok({ count: mine.length, transcripts: mine });
+    }
+    return Promise.resolve({ ok: false, status: 404, json: async () => ({}) });
+  };
+}
+
+test("#834: when the auto-followed live job finishes, the focus falls back to the newest capture", async () => {
+  const replay = {
+    stream: "wk-a/j1",
+    from: 0,
+    gap: false,
+    nextOffset: 1,
+    entries: [{ offset: 0, chunk: envChunk("message", { role: "assistant", text: "captured after finish" }) }],
+  };
+  const state = {
+    correlations: [{ jobKey: "j1", stream: "wk-a/j1", processInstanceKey: "pi-child" }] as unknown[],
+    transcripts: [] as unknown[],
+    replay,
+  };
+  const restore = installEnv(mutableFocusStub(state));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "live");
+      // The followed job finishes: its live correlation drops out and its session becomes a capture.
+      state.correlations = [];
+      state.transcripts = [
+        { stream: "wk-a/j1", lifecycle: "ephemeral", status: "completed", createdAt: "2024-01-01T00:00:00Z", nextOffset: 1, byteLength: 10, chunkCount: 1, processInstanceKey: "pi-child" },
+      ];
+      await handle.refresh();
+      await settle();
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "replay");
+      assert((document.querySelector('[data-terminal="host"]')?.textContent ?? "").includes("captured after finish"), "the newest capture replays after the live job ends");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#834: changing the focused process resets the terminal — it never keeps showing the old process's live stream", async () => {
+  const state = {
+    correlations: [{ jobKey: "j1", stream: "wk-a/j1", processInstanceKey: "pi-child" }] as unknown[],
+    transcripts: [] as unknown[],
+    replay: undefined as unknown,
+  };
+  const restore = installEnv(mutableFocusStub(state));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "live");
+      // Focus a DIFFERENT process with no live job and no capture: the terminal must reset to idle,
+      // not keep replaying process A's live stream.
+      handle.focus("pi-other");
+      await settle();
+      assert((document.querySelector(".cockpit-focus")?.textContent ?? "").includes("pi-other"), "the banner names the new focus");
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "idle");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#834: navigating from a process route to the main route clears the focus", async () => {
+  const restore = installEnv(focusStub({ correlations: [] }));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assert((document.querySelector(".cockpit-focus")?.textContent ?? "").includes(PI_ROOT), "the process route focused the cockpit");
+      // Navigate away to the main route: the URL no longer selects a process, so the focus must clear
+      // (the banner and background focus polls must not keep following the process the view left).
+      // linkedom's dispatchEvent rejects a native Event, so construct the event from the stub window.
+      (globalThis as { location: { hash: string } }).location.hash = "#/cockpit";
+      const win = (globalThis as { window: { Event: new (t: string) => unknown; dispatchEvent: (e: unknown) => void } }).window;
+      win.dispatchEvent(new win.Event("hashchange"));
+      await settle();
+      assertEquals(document.querySelector(".cockpit-focus")?.getAttribute("data-focus"), "none");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#834: a failed auto-opened history read is retried on a later poll", async () => {
+  // The history read fails on the FIRST attempt (ok:false → boundedJson throws), then succeeds. The
+  // focus must not latch the run as shown on the failed read: a later poll re-fires it and lands the detail.
+  let historyCalls = 0;
+  const state = { correlations: [] as unknown[], transcripts: [] as unknown[], replay: undefined as unknown };
+  const base = mutableFocusStub(state);
+  const restore = installEnv((url: string) => {
+    if (/\/agent-instances\/[^/?]+\/history/.test(url)) {
+      historyCalls++;
+      if (historyCalls === 1) return Promise.resolve({ ok: false, status: 500, json: async () => ({}) });
+    }
+    return base(url);
+  });
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assertEquals(historyCalls, 1, "the focus auto-opened the newest run's history once");
+      assert(
+        (document.querySelector(".cockpit-agent-transcript")?.textContent ?? "").includes("working on the focused process") === false,
+        "the failed read rendered nothing",
+      );
+      // A later poll retries the failed read; the detail now renders.
+      await handle.refresh();
+      await settle();
+      assert(historyCalls >= 2, "the failed auto-open was retried on a later poll");
+      assert(
+        (document.querySelector(".cockpit-agent-transcript")?.textContent ?? "").includes("working on the focused process"),
+        "the retried read rendered the focused agent's history",
+      );
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#834: 'Show all' clears the focus route from the URL so a refresh does not reopen the process", async () => {
+  const restore = installEnv(focusStub({ correlations: [] }));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assert((document.querySelector(".cockpit-focus")?.textContent ?? "").includes(PI_ROOT), "the process route focused the cockpit");
+      // Clicking "Show all" must navigate the focus route out of the URL, not just hide the banner —
+      // otherwise refreshing/sharing `#/cockpit/process/<key>` reopens the process just cleared (#834).
+      const clear = document.querySelector(".cockpit-focus-clear");
+      assert(clear != null, "the focus banner offers a 'Show all' control");
+      const win = (globalThis as { window: { Event: new (t: string) => unknown; dispatchEvent: (e: unknown) => void } }).window;
+      (clear as { dispatchEvent: (e: unknown) => void }).dispatchEvent(new win.Event("click"));
+      assertEquals((globalThis as { location: { hash: string } }).location.hash, "#/cockpit", "'Show all' navigated the URL back to the cockpit root");
+      // The resulting hashchange then clears the focus, exactly as a real browser navigation would.
+      win.dispatchEvent(new win.Event("hashchange"));
+      await settle();
+      assertEquals(document.querySelector(".cockpit-focus")?.getAttribute("data-focus"), "none");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#834: switching the focused process clears the old focus's agent-history list immediately", async () => {
+  const state = { correlations: [] as unknown[], transcripts: [] as unknown[], replay: undefined as unknown };
+  const restore = installEnv(mutableFocusStub(state));
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      assert(document.querySelector(".cockpit-agent-region .cockpit-agent-history") != null, "focus A rendered its agent-history list");
+      // The switch must blank the list SYNCHRONOUSLY, not leave A's rows up until B's reads land: a click
+      // on a stale A row would otherwise start a detail read under B's focus generation (#834).
+      handle.focus("pi-other");
+      assertEquals(document.querySelector(".cockpit-agent-region")?.childElementCount, 0, "the old focus's history list was cleared immediately on focus change");
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
+test("#834: a superseded focus's in-flight transcript scan does not block the new focus's scan", async () => {
+  // Park focus A's per-tree transcript scan on a never-settling fetch, then switch to B. With a shared
+  // scan lock, B would skip its scan until A's request settled (up to the 15s timeout); the lock must be
+  // scoped to the focus generation so B scans immediately and replays its own capture (#834).
+  let releaseA: () => void = () => {};
+  const aParked = new Promise<void>((r) => {
+    releaseA = r;
+  });
+  const bReplay = {
+    stream: "wk-b/j9",
+    from: 0,
+    gap: false,
+    nextOffset: 1,
+    entries: [{ offset: 0, chunk: envChunk("message", { role: "assistant", text: "B capture replays" }) }],
+  };
+  const state = { correlations: [] as unknown[], transcripts: [] as unknown[], replay: bReplay, roots: [] as string[] };
+  const base = mutableFocusStub(state);
+  const restore = installEnv(async (url: string) => {
+    if (url.includes("/transcripts") && url.includes(`processInstanceKey=${PI_ROOT}`)) {
+      await aParked; // focus A's scan hangs here until released
+      return { ok: true, status: 200, json: async () => ({ count: 0, transcripts: [] }) };
+    }
+    return base(url);
+  });
+  (globalThis as { location: { hash: string } }).location.hash = `#/cockpit/process/${PI_ROOT}`;
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await settle();
+      // A is focused; its transcript scan is parked awaiting `aParked` and holds the scan lock.
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "idle");
+      // Switch to B, which HAS a capture: its scan must run despite A's lock still being held.
+      state.transcripts = [
+        { stream: "wk-b/j9", lifecycle: "ephemeral", status: "completed", createdAt: "2024-01-01T00:00:00Z", nextOffset: 1, byteLength: 10, chunkCount: 1, processInstanceKey: "pi-bee" },
+      ];
+      handle.focus("pi-bee");
+      await settle();
+      assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "replay");
+      assert(
+        (document.querySelector('[data-terminal="host"]')?.textContent ?? "").includes("B capture replays"),
+        "the new focus replayed its capture even though the superseded focus's scan is still in flight",
+      );
+    } finally {
+      releaseA();
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});

package/app/convergeGate.test.ts

@@ -1123,3 +1123,76 @@ test("the blocked-comments escalation routes through gw-escalated toward an answ
   // The human sees the gate's own reason (the unresolved threads / unacknowledged advisories).
   assertStringIncludes(task[0], "convergeBlockReason");
 });
+
+// ── Copilot ccr-overview-v2 review format (issue #835) ──────────────────────
+// The v2 overview has no "Suppressed comments" block; findings without an inline thread live only in
+// the "What changed" file table as `… (<severity>, N vote[s])` clauses. Paths carry zero-width spaces.
+const V2_REVIEW_BODY = [
+  "<!-- ccr-overview-v2 -->",
+  "",
+  "## Copilot review overview",
+  "",
+  "<details open>",
+  "<summary><strong>Open (1)</strong></summary>",
+  "",
+  "- [Replace HEAD with a valid bootstrap commit SHA](#discussion_r1) · New",
+  "</details>",
+  "",
+  "<details>",
+  "<summary><strong>What changed in this PR</strong></summary>",
+  "",
+  "| File | Summary and final review notes |",
+  "|---|---|",
+  "| `skills/\u200bcamunda-forms/\u200bportability.json` | Adds dependency requirements. |",
+  "| `skills/\u200bcamunda-job-workers/\u200bportability.json` | Adds dependency requirements; Camunda version conflicts with the documented Node fallback (moderate, 1 vote), and Java/TypeScript runtime paths are missing (moderate, 1 vote). |",
+  "| `release-please-config.json` | Configures automated releases; `bootstrap-sha` must be removed or replaced with a full base commit SHA (moderate, 3 votes). |",
+  "</details>",
+].join("\n");
+
+test("parseSuppressedAdvisories: ccr-overview-v2 table findings are gated advisories (#835)", () => {
+  const advisories = parseSuppressedAdvisories(V2_REVIEW_BODY);
+  assertEquals(
+    advisories.map((a) => [a.path, a.text]),
+    [
+      [
+        "skills/camunda-job-workers/portability.json",
+        "Adds dependency requirements; Camunda version conflicts with the documented Node fallback",
+      ],
+      ["skills/camunda-job-workers/portability.json", "Java/TypeScript runtime paths are missing"],
+      [
+        "release-please-config.json",
+        "Configures automated releases; `bootstrap-sha` must be removed or replaced with a full base commit SHA",
+      ],
+    ],
+  );
+  // Keyed on path + prose (vote count excluded, so a re-vote next round keeps the same key).
+  assertEquals(
+    advisories[1].key,
+    advisoryStableKey("skills/camunda-job-workers/portability.json", "Java/TypeScript runtime paths are missing"),
+  );
+});
+
+test("parseSuppressedAdvisories: a v2 table finding is acked by the canonical nano-ack marker and unblocks the gate (#835)", () => {
+  const advisories = parseSuppressedAdvisories(V2_REVIEW_BODY);
+  const threads: ReviewThread[] = advisories.map((a) => ({
+    isResolved: true,
+    path: a.path,
+    bodies: [`Declined. nano-ack: ${a.path} :: ${a.text}`],
+  }));
+  const blocked = evaluateConvergeGate({ unresolvedThreadCount: 0, suppressedAdvisories: advisories, acknowledgedKeys: [] });
+  assertEquals(blocked.convergeBlocked, true);
+  const r = evaluateConvergeGate({
+    unresolvedThreadCount: 0,
+    suppressedAdvisories: advisories,
+    acknowledgedKeys: parseAckedAdvisories(threads),
+  });
+  assertEquals(r.convergeBlocked, false);
+});
+
+test("parseSuppressedAdvisories: v2 table rows without findings yield nothing; non-v2 tables are ignored (#835)", () => {
+  assertEquals(
+    parseSuppressedAdvisories("<!-- ccr-overview-v2 -->\n| `a.ts` | Adds a thing. |"),
+    [],
+  );
+  assertEquals(parseSuppressedAdvisories("| `a.ts` | Broken thing (moderate, 1 vote). |"), []);
+});