@nanobpm/nano-workforce 0.167.4 → 0.168.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.168.1](https://github.com/nanobpm/nano-workforce/compare/v0.168.0...v0.168.1) (2026-08-31)
+
+### Bug Fixes
+
+* **cockpit:** render the agentic transcript beneath the supply table ([#660](https://github.com/nanobpm/nano-workforce/issues/660)) ([#662](https://github.com/nanobpm/nano-workforce/issues/662)) ([ed2c041](https://github.com/nanobpm/nano-workforce/commit/ed2c041e0e4508e825324ed2b398bf64b5c66c37))
+
+## [0.168.0](https://github.com/nanobpm/nano-workforce/compare/v0.167.4...v0.168.0) (2026-08-31)
+
+### Features
+
+* correlate callActivity child-cell escalations & epic phase via parent/root keys ([#633](https://github.com/nanobpm/nano-workforce/issues/633)) ([#657](https://github.com/nanobpm/nano-workforce/issues/657)) ([22b8674](https://github.com/nanobpm/nano-workforce/commit/22b86746548627921a1bc049b7999eeaa8fb5104)), closes [Magikcraft/nano-bpm#977](https://github.com/Magikcraft/nano-bpm/issues/977) [#464](https://github.com/nanobpm/nano-workforce/issues/464) [#591](https://github.com/nanobpm/nano-workforce/issues/591)
+
 ## [0.167.4](https://github.com/nanobpm/nano-workforce/compare/v0.167.3...v0.167.4) (2026-08-31)
 
 ### Build System

package/app/agentCompletion.ts

@@ -68,6 +68,8 @@ export const taskCompletions = (data: DataLayer) =>
  *  agent path is scoped to escalations — it can never complete an arbitrary internal user task. */
 export const ESCALATION_TASK_ELEMENTS: ReadonlySet<string> = new Set([
   "feature-escalation",
+  "escalation", // shared human-escalation cell (human-escalation.bpmn, ADR 0006 S4 #603/#633) — the same
+  //              agent-answerable feature-escalation task, relocated into a callActivity child cell
   "plan-review-decision",
   "trial-merge-decision",
   "wait-answer", // PR review-loop escalation (convergence-loop.bpmn, U3)
@@ -121,6 +123,7 @@ export const HUMAN_COMPLETABLE_ELEMENTS: ReadonlySet<string> = new Set([
  *  validates against the SAME `.form` the task inbox renders — one contract, no second field list. */
 const ESCALATION_FORM_BY_ELEMENT: Readonly<Record<string, string>> = {
   "feature-escalation": "feature-escalation",
+  "escalation": "feature-escalation", // shared human-escalation cell renders the SAME feature-escalation form (#603/#633)
   "plan-review-decision": "plan-review-decision",
   "trial-merge-decision": "trial-merge-decision",
   "wait-answer": "pr-escalation",

package/app/agentic/cockpit/cockpit-browser-bundle.test.ts

@@ -0,0 +1,102 @@
+// #660 — the browser transcript bundle is DERIVED from the typed core, and it RENDERS (never dumps raw
+// `nwfTranscriptEvent` JSON).
+//
+// Two guarantees:
+//  1. Drift guard — the committed `pages/cockpit/generated/*.js` is byte-identical to a fresh transpile
+//     of the `.ts` core, so the deployed browser render path can never silently drift from the typed,
+//     tested source (the exact failure mode #660 was: a hand-copy that lost the render path).
+//  2. Behaviour — importing the GENERATED module the browser actually loads and rendering it into the
+//     DOM double proves a `nwfTranscriptEvent` chunk is surfaced as derived turns/tool/diff/permission
+//     cards, and NEVER verbatim.
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { cockpitBrowserBundle } from "../../../scripts/build-cockpit-browser.ts";
+import { FakeDocument, FakeElement } from "../../../test/agentic-cockpit-doubles.ts";
+import { TRANSCRIPT_EVENT_MARKER, TRANSCRIPT_EVENT_VERSION } from "../transcript-events.ts";
+// The module under test is the GENERATED browser artifact the deployed cockpit imports — NOT the .ts
+// source — so this exercises exactly the code path the browser runs.
+import { renderDerivedTranscript } from "../../../pages/cockpit/generated/transcript-derive.js";
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
+
+test("the committed browser bundle is byte-identical to its typed source (no drift surface)", () => {
+  for (const { out, content } of cockpitBrowserBundle()) {
+    const committed = readFileSync(resolve(repoRoot, out), "utf8");
+    assertEquals(
+      committed,
+      content,
+      `${out} is stale — regenerate with: node --experimental-strip-types scripts/build-cockpit-browser.ts`,
+    );
+  }
+});
+
+const doc = new FakeDocument();
+
+function env(kind: string, extra: Record<string, unknown> = {}): string {
+  return JSON.stringify({ [TRANSCRIPT_EVENT_MARKER]: TRANSCRIPT_EVENT_VERSION, kind, ...extra });
+}
+
+/** A page whose chunks are `nwfTranscriptEvent` envelopes: messages, a tool call/result diff, a permission prompt. */
+function report(): {
+  stream: string;
+  from: number;
+  gap: boolean;
+  nextOffset: number;
+  entries: Array<{ offset: number; chunk: string }>;
+} {
+  const chunks = [
+    env("turn", { index: 0 }),
+    env("message", { role: "user", text: "please build it" }),
+    env("tool-call", { name: "edit", callId: "c1", args: { path: "a.txt", oldText: "one\n", newText: "two\n" } }),
+    env("tool-result", { callId: "c1", ok: true, content: "done" }),
+    env("message", { role: "assistant", text: "built it" }),
+    env("permission", {
+      phase: "request",
+      callId: "p1",
+      policy: "escalate",
+      title: "Run shell?",
+      toolName: "bash",
+      options: [
+        { optionId: "ok", name: "Allow", kind: "allow-once" },
+        { optionId: "no", name: "Deny", kind: "reject-once" },
+      ],
+    }),
+  ];
+  return { stream: "job:1", from: 0, gap: false, nextOffset: chunks.length, entries: chunks.map((chunk, offset) => ({ offset, chunk })) };
+}
+
+test("regression: a nwfTranscriptEvent chunk is rendered as derived cards, NEVER surfaced verbatim", () => {
+  const host = new FakeElement("div");
+  renderDerivedTranscript(host as never, doc, report() as never);
+  // The rendered structured view exists…
+  assertEquals(host.byClass("cockpit-transcript-derived").length, 1);
+  // …and the raw envelope marker is nowhere in the rendered text (the #660 bug: raw JSON echoed).
+  assert(!host.text().includes(TRANSCRIPT_EVENT_MARKER), "rendered transcript must not contain the raw nwfTranscriptEvent marker");
+});
+
+test("feature: messages coalesce into one turn, tool/diff card renders, permission prompt renders", () => {
+  const host = new FakeElement("div");
+  renderDerivedTranscript(host as never, doc, report() as never);
+
+  // Message coalescing: both the user and assistant messages fold under a SINGLE derived turn section.
+  const turns = host.byClass("cockpit-transcript-turn");
+  assertEquals(turns.length, 1);
+  const roles = turns[0]?.byClass("cockpit-transcript-message").map((n) => n.getAttribute("data-role")) ?? [];
+  assertEquals(roles, ["user", "assistant"]);
+
+  // Tool card with a synthesized diff (structured edit args → add/del lines).
+  const tool = host.byData("tool", "edit")[0];
+  assert(tool !== undefined, "the tool card is rendered");
+  assertEquals(tool?.getAttribute("data-tool-kind"), "diff");
+  const diffKinds = host.byClass("cockpit-transcript-diff-line").map((n) => n.getAttribute("data-diff-line"));
+  assert(diffKinds.includes("add") && diffKinds.includes("del"), "the diff shows add + del lines");
+
+  // Permission prompt with interactive Allow/Deny options.
+  const perm = host.byData("permission", "request")[0];
+  assert(perm !== undefined, "the permission prompt is rendered");
+  assertEquals(perm?.getAttribute("data-status"), "pending");
+  assertEquals(host.byClass("cockpit-transcript-permission-option").length, 2);
+});

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

@@ -0,0 +1,162 @@
+// #660 — the DEPLOYED browser adapter (pages/cockpit/mount.js) renders the transcript for BOTH a live
+// drill and a past-session replay, and NEVER surfaces a raw `nwfTranscriptEvent` chunk verbatim.
+//
+// This drives mount.js end-to-end on Node against a real (linkedom) DOM, a stub relay WebSocket, and a
+// stub `fetch`, so it exercises the actual live-drill sink wiring and the replay fetch→render path — the
+// two seams that used to write relay chunks straight to xterm. It also asserts the rendered transcript
+// region sits directly beneath the Workers — supply table.
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { encodeFrame } from "@nanobpm/agentic/protocol";
+import { parseHTML } from "linkedom";
+import { TRANSCRIPT_EVENT_MARKER, TRANSCRIPT_EVENT_VERSION } from "../transcript-events.ts";
+
+function envChunk(kind: string, extra: Record<string, unknown> = {}): string {
+  return JSON.stringify({ [TRANSCRIPT_EVENT_MARKER]: TRANSCRIPT_EVENT_VERSION, kind, ...extra });
+}
+
+/** A stub browser WebSocket that records instances and lets a test drive open + inbound frames by hand. */
+class StubWebSocket {
+  static readonly instances: StubWebSocket[] = [];
+  binaryType = "";
+  readonly url: string;
+  readonly #listeners = new Map<string, Array<(event: unknown) => void>>();
+  constructor(url: string) {
+    this.url = url;
+    StubWebSocket.instances.push(this);
+  }
+  addEventListener(type: string, handler: (event: unknown) => void): void {
+    const list = this.#listeners.get(type) ?? [];
+    list.push(handler);
+    this.#listeners.set(type, list);
+  }
+  send(): void {}
+  close(): void {}
+  fireOpen(): void {
+    for (const h of this.#listeners.get("open") ?? []) h({});
+  }
+  /** Deliver one relay frame (as the browser would: an ArrayBuffer message event). */
+  deliver(frame: unknown): void {
+    const bytes = encodeFrame(frame as never);
+    for (const h of this.#listeners.get("message") ?? []) h({ data: bytes.buffer });
+  }
+}
+
+/** Install a linkedom DOM + stub WebSocket/fetch as globals mount.js reads; returns a cleanup fn. */
+function installEnv(fetchImpl: (url: string) => Promise<unknown>): () => void {
+  const { window, document } = parseHTML("<!doctype html><html><body><main id='root'></main></body></html>");
+  const g = globalThis as Record<string, unknown>;
+  const saved = {
+    window: g.window,
+    document: g.document,
+    location: g.location,
+    WebSocket: g.WebSocket,
+    fetch: g.fetch,
+  };
+  g.window = window;
+  g.document = document;
+  g.location = { hash: "", href: "http://app.test/cockpit/", pathname: "/cockpit/", search: "" };
+  g.WebSocket = StubWebSocket;
+  g.fetch = (url: unknown) => fetchImpl(String(url));
+  StubWebSocket.instances.length = 0;
+  return () => {
+    g.window = saved.window;
+    g.document = saved.document;
+    g.location = saved.location;
+    g.WebSocket = saved.WebSocket;
+    g.fetch = saved.fetch;
+  };
+}
+
+const SUPPLY = { leaves: [], correlations: [] };
+
+/** A fetch stub answering the supply poll, the past-sessions list, and a single-stream replay. */
+function fetchStub(replay?: unknown) {
+  return (url: string): Promise<unknown> => {
+    const ok = (body: unknown) => Promise.resolve({ ok: true, status: 200, json: async () => body });
+    if (url.includes("/supply")) return ok(SUPPLY);
+    if (replay !== undefined && /\/transcripts\/[^/]+$/.test(url)) return ok(replay);
+    if (url.includes("/transcripts")) return ok({ sessions: [] });
+    return Promise.resolve({ ok: false, status: 404, json: async () => ({}) });
+  };
+}
+
+const OPTS = {
+  reportUrl: "http://app.test/app/api/agentic/supply",
+  transcriptsUrl: "http://app.test/app/api/agentic/transcripts",
+  relayUrl: "ws://app.test/agentic",
+  refreshMs: 1_000_000, // effectively disable the self-scheduling poll; we dispose() at the end.
+};
+
+test("the rendered transcript region sits directly beneath the Workers — supply table", async () => {
+  const restore = installEnv(fetchStub());
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    const shell = document.querySelector(".cockpit-shell");
+    const order = [...(shell?.children ?? [])].map((c: { className: string }) => c.className);
+    assertEquals(order, ["cockpit-supply-region", "cockpit-terminal", "cockpit-past-region"]);
+    handle.dispose();
+  } finally {
+    restore();
+  }
+});
+
+test("live drill renders the transcript — a nwfTranscriptEvent chunk is never surfaced verbatim", async () => {
+  const restore = installEnv(fetchStub());
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    handle.drill("job:live");
+    const socket = StubWebSocket.instances[0];
+    assert(socket !== undefined, "a relay socket was opened for the drill");
+    socket.fireOpen();
+    socket.deliver({ lane: "control", family: "relay", seq: 0, payload: { op: "subscribed", stream: "job:live", gap: false, nextOffset: 0 } });
+    socket.deliver({
+      lane: "bulk",
+      family: "relay",
+      seq: 1,
+      payload: { stream: "job:live", offset: 0, chunk: envChunk("message", { role: "assistant", text: "hello from the agent" }) },
+    });
+
+    const host = document.querySelector('[data-terminal="host"]');
+    const rendered = host?.querySelector(".cockpit-transcript-derived");
+    assert(rendered != null, "the derived transcript is rendered into the terminal host");
+    assert((host?.textContent ?? "").includes("hello from the agent"), "the message text is rendered");
+    assert(!(host?.textContent ?? "").includes(TRANSCRIPT_EVENT_MARKER), "the raw nwfTranscriptEvent marker is never shown");
+    assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "live");
+    handle.dispose();
+  } finally {
+    restore();
+  }
+});
+
+test("replay renders a past session's transcript — never a raw nwfTranscriptEvent dump", async () => {
+  const replay = {
+    stream: "job:past",
+    from: 0,
+    gap: false,
+    nextOffset: 3,
+    entries: [
+      { offset: 0, chunk: envChunk("message", { role: "user", text: "kick off" }) },
+      { offset: 1, chunk: envChunk("tool-call", { name: "grep", callId: "c1" }) },
+      { offset: 2, chunk: envChunk("tool-result", { callId: "c1", ok: true, content: "match" }) },
+    ],
+  };
+  const restore = installEnv(fetchStub(replay));
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    await handle.replay("job:past");
+
+    const host = document.querySelector('[data-terminal="host"]');
+    assert(host?.querySelector(".cockpit-transcript-derived") != null, "the derived transcript is rendered on replay");
+    assert((host?.textContent ?? "").includes("kick off"), "the message text is rendered");
+    assert(host?.querySelector('[data-tool="grep"]') != null, "the tool card is rendered");
+    assert(!(host?.textContent ?? "").includes(TRANSCRIPT_EVENT_MARKER), "the raw nwfTranscriptEvent marker is never shown");
+    assertEquals(document.querySelector(".cockpit-terminal")?.getAttribute("data-terminal-mode"), "replay");
+    handle.dispose();
+  } finally {
+    restore();
+  }
+});

package/app/pollEpicPhase.test.ts

@@ -157,3 +157,67 @@ test("pollEpicPhase skips a live epic that has no engine instance yet", async ()
     assertEquals(called, false);
   });
 });
+
+/** Stub `globalThis.fetch` so `pollEpicPhase`'s callActivity hierarchy walk (issue #633) reads its
+ *  descendant instances from `childrenByParent` (keyed on the queried `parentProcessInstanceKey`), and
+ *  404s any other path so a stray call is loud. Returns a restore fn. */
+function stubProcessInstanceSearch(childrenByParent: Record<string, string[]>): () => void {
+  const orig = globalThis.fetch;
+  // biome-ignore lint/suspicious/noExplicitAny: minimal fetch double for the raw-REST search surface
+  globalThis.fetch = (async (url: string | URL, init?: any) => {
+    const u = String(url);
+    if (!u.endsWith("/process-instances/search")) return new Response("not found", { status: 404 });
+    const body = JSON.parse(init?.body ?? "{}");
+    const parent: string = body?.filter?.parentProcessInstanceKey ?? "";
+    const items = (childrenByParent[parent] ?? []).map((k) => ({ processInstanceKey: k }));
+    return new Response(JSON.stringify({ items }), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+  }) as typeof fetch;
+  return () => {
+    globalThis.fetch = orig;
+  };
+}
+
+test("pollEpicPhase derives from an element INSIDE a callActivity CHILD cell via parent/root traversal (issue #633)", async () => {
+  // ADR 0006 S4 (#603/#633): once a wave/slice runs as a callActivity CHILD cell, the furthest-reached
+  // live token can sit INSIDE that child instance ("child-pi"), not on the parent plan-fanout spine
+  // ("pi-1"). The parent instance shows only a settled (COMPLETED) `record-plan`, so a parent-ONLY read
+  // would leave the phase at PLANNING; walking the hierarchy (parent → child) surfaces the child's ACTIVE
+  // `review-plan`, advancing the phase to Reviewing. The pure `deriveEpicPhaseLive` is unchanged — only
+  // its INPUT is widened to the whole instance hierarchy.
+  await withData(async (data) => {
+    await seedPlan(data, { epic_phase: EPIC_PHASE.PLANNING });
+    const engine = {
+      searchElementInstances: async ({ processInstanceKey }: { processInstanceKey: string }) =>
+        processInstanceKey === "child-pi"
+          ? [{ elementInstanceKey: "c1", processInstanceKey: "child-pi", elementId: "review-plan", state: "ACTIVE" }]
+          : [{ elementInstanceKey: "e1", processInstanceKey: "pi-1", elementId: "record-plan", state: "COMPLETED" }],
+    };
+    const restore = stubProcessInstanceSearch({ "pi-1": ["child-pi"], "child-pi": [] });
+    try {
+      await pollEpicPhase(data, engine as never, { restAddress: "http://engine.test/v2" });
+    } finally {
+      restore();
+    }
+    assertEquals((await plans(data).get("owner/repo#7"))?.epic_phase, EPIC_PHASE.REVIEWING);
+  });
+});
+
+test("pollEpicPhase without a raw-REST surface reads the parent instance ALONE (no traversal, pre-#633 behaviour)", async () => {
+  // The typed seam cannot enumerate children, so with no `engineRest` the walk degrades to the parent
+  // plan-fanout instance only — a child-cell token is invisible and the phase stays at PLANNING. This
+  // pins the two-arg (no-REST) call the unit path and degraded hosts use.
+  await withData(async (data) => {
+    await seedPlan(data, { epic_phase: EPIC_PHASE.PLANNING });
+    const engine = {
+      searchElementInstances: async ({ processInstanceKey }: { processInstanceKey: string }) =>
+        processInstanceKey === "child-pi"
+          ? [{ elementInstanceKey: "c1", processInstanceKey: "child-pi", elementId: "review-plan", state: "ACTIVE" }]
+          : [{ elementInstanceKey: "e1", processInstanceKey: "pi-1", elementId: "record-plan", state: "COMPLETED" }],
+    };
+    await pollEpicPhase(data, engine as never);
+    assertEquals((await plans(data).get("owner/repo#7"))?.epic_phase, EPIC_PHASE.PLANNING);
+  });
+});

package/app/pollUserTasks.test.ts

@@ -370,7 +370,7 @@ test("pollUserTasks: an instance whose only task is COMPLETED surfaces no row",
 
 /** A single task as the raw Camunda-8 `/v2/user-tasks/search` reports it — carries `processInstanceKey`
  *  (the typed seam omits it) so the sweep can map a task back to its subject for enrichment. */
-type RawTask = { userTaskKey: string; elementId?: string; processInstanceKey?: string; state?: string; formKey?: string | number | null };
+type RawTask = { userTaskKey: string; elementId?: string; processInstanceKey?: string; rootProcessInstanceKey?: string | number | null; state?: string; formKey?: string | number | null };
 
 /** Stub `globalThis.fetch` so `pollUserTasks`' engine-first sweep reads its open tasks from `tasks`.
  *  Honours the `page.from`/`page.limit` pagination the sweep drives, and 404s any other path so a stray
@@ -444,7 +444,6 @@ test("pollUserTasks (engine-first): orphaned plan-review and PR-wait escalations
 });
 
 test("pollUserTasks (engine-first): a TRACKED task is still fully enriched from its subject row (no regression)", async () => {
-  // Enrich, don't gate: when a subject row DOES reference the task's instance, title/url/question come
   // from it exactly as the per-subject scan produced — the sweep maps by `processInstanceKey`.
   const { data, stores } = memData({
     feature_runs: [
@@ -479,6 +478,40 @@ test("pollUserTasks (engine-first): a TRACKED task is still fully enriched from
   assertEquals(byKey["ut-plan"].question, "scope too broad");
 });
 
+test("pollUserTasks (engine-first): a child-cell escalation correlates to its PARENT run via rootProcessInstanceKey (issue #633)", async () => {
+  // ADR 0006 S4 (#603/#633): once a slice's implement step runs as a callActivity CHILD cell, the
+  // agent-stuck escalation parks on the shared `human-escalation` cell's `escalation` element inside a
+  // CHILD instance ("child-pi") whose key NO subject row tracks — the owning feature run is tracked under
+  // the PARENT/root instance ("fp-10") the engine reports as `rootProcessInstanceKey`. The poller must
+  // correlate the child-instance task back to the parent run (subject + question + kind), not strand it
+  // as an orphan keyed to the raw child instance.
+  const { data, stores } = memData({
+    feature_runs: [
+      { feature_key: "o/r#10", status: "escalated", process_key: "fp-10", issue_url: "https://github.com/o/r/issues/10", title: "Add the framework selector", delivery_label: null },
+    ],
+    feature_escalations: [
+      { id: 1, feature_key: "o/r#10", question: "which framework?", created_at: "2025-01-01T00:00:00.000Z", job_key: "j1" },
+    ],
+  });
+  const restore = stubUserTaskSearch([
+    { userTaskKey: "ut-child", elementId: "escalation", processInstanceKey: "child-pi", rootProcessInstanceKey: "fp-10", state: "CREATED" },
+  ]);
+  try {
+    await pollUserTasks(data, fakeEngine({}), REST);
+  } finally {
+    restore();
+  }
+
+  const byKey = Object.fromEntries((stores.user_tasks ?? []).map((r) => [r.user_task_key, r]));
+  assertEquals(Object.keys(byKey), ["ut-child"]);
+  assertEquals(byKey["ut-child"].element_id, "escalation");
+  assertEquals(byKey["ut-child"].kind_label, "Feature escalation");
+  assertEquals(byKey["ut-child"].subject_type, "feature");
+  assertEquals(byKey["ut-child"].subject_key, "o/r#10"); // correlated to the PARENT run, not the child instance
+  assertEquals(byKey["ut-child"].subject_title, "Add the framework selector");
+  assertEquals(byKey["ut-child"].question, "which framework?"); // same feature_escalations log via the parent subject
+});
+
 test("pollUserTasks (engine-first): never leaks a non-escalation element nor a non-CREATED task", async () => {
   // The `USER_TASK_KIND_LABELS` gate keeps an arbitrary internal user task out of the inbox, and the
   // defensive state re-filter drops a lagging COMPLETED/CANCELED read (a dead affordance, #294) even if
@@ -825,6 +858,47 @@ test("pollUserTasks (engine-first): does NOT heal a JUST-escalated run inside th
   assertEquals(byKey["o/r#old"].status, "running", "a genuinely-stranded (old) run is still healed");
 });
 
+test("pollUserTasks (engine-first): does NOT heal an escalated run parked in a callActivity CHILD instance the sweep missed (issue #633)", async () => {
+  // A run's escalation can park inside a callActivity CHILD instance on the shared `human-escalation`
+  // cell's `escalation` element (ADR 0006 S4, #633), correlated back to the parent run via the root key.
+  // When this pass's engine-first sweep is truncated/unavailable, that child task is absent from `desired`,
+  // so the run falls through to the per-instance confirmation. Confirming ONLY the parent `process_key`
+  // (whose own open tasks are empty — the escalation lives in the CHILD instance) would read "no
+  // escalation open" and wrongly flip a genuinely-parked run back to `running`. The confirmation must
+  // include the callActivity descendants when the raw-REST surface is available.
+  const stale = new Date(Date.now() - 60 * 60_000).toISOString(); // past the heal grace window
+  const { data, stores } = memData({
+    feature_runs: [
+      { feature_key: "o/r#child", status: "escalated", process_key: "fp-parent", updated_at: stale, issue_url: null, title: "parked in child cell", delivery_label: null },
+    ],
+  });
+  // The sweep is unavailable (returns empty), so fp-parent is NOT confirmed parked via `desired`; the
+  // descendant walk over `/process-instances/search` surfaces the child instance carrying the escalation.
+  const orig = globalThis.fetch;
+  // biome-ignore lint/suspicious/noExplicitAny: minimal fetch double for the raw-REST search surfaces
+  globalThis.fetch = (async (url: string | URL, init?: any) => {
+    const u = String(url);
+    if (u.endsWith("/user-tasks/search")) {
+      return new Response(JSON.stringify({ items: [] }), { status: 200, headers: { "content-type": "application/json" } });
+    }
+    if (u.endsWith("/process-instances/search")) {
+      const parent = JSON.parse(init?.body ?? "{}")?.filter?.parentProcessInstanceKey;
+      const items = parent === "fp-parent" ? [{ processInstanceKey: "child-1" }] : [];
+      return new Response(JSON.stringify({ items }), { status: 200, headers: { "content-type": "application/json" } });
+    }
+    return new Response("not found", { status: 404 });
+  }) as typeof fetch;
+  // The escalation is parked in the CHILD instance on the `escalation` element, not on the parent.
+  const engine = fakeEngine({ "fp-parent": [], "child-1": [{ userTaskKey: "ut-child", elementId: "escalation" }] });
+  try {
+    await pollUserTasks(data, engine, REST);
+  } finally {
+    globalThis.fetch = orig;
+  }
+  const byKey = Object.fromEntries((stores.feature_runs ?? []).map((r) => [r.feature_key, r]));
+  assertEquals(byKey["o/r#child"].status, "escalated", "a run parked in a callActivity child cell survives when the sweep missed it");
+});
+
 test("pollUserTasks (typed-seam fallback): self-heals an escalated run with no open feature-escalation task (issue #642)", async () => {
   // The reduced-capability path scans FEATURE_ACTIVE_STATUSES instances (incl. `escalated`) directly,
   // so the per-instance open-task read is just as authoritative for the self-heal.