@nanobpm/nano-workforce 0.99.1 → 0.100.0

package/workers/record-blocked-ack/worker.ts

@@ -26,11 +26,6 @@ const handler: AppJobHandler<In, Record<string, never>> = async (job, app) => {
   await featureRuns(app.data).update(featureKey, {
     status: "blocked",
     delivery_label: note ? `operator: ${note}` : "acknowledged",
-    // The run has left the `feature-blocked` wait, so clear the denormalised completable-task pointer
-    // the pages gate the "Acknowledge blocked" affordance on. pollFeatureBlocked only sweeps
-    // `awaiting_operator` runs, so this terminal-ward transition must clear it itself or a stale pointer
-    // would linger on the now-terminal row.
-    blocked_user_task_key: null,
     updated_at: ts,
   });
   app.log.info("record-blocked-ack", { featureKey, note: note ?? null });

package/workers/record-feature/worker.ts

@@ -54,12 +54,6 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     status: rowStatus,
     pr_key: prKey,
     outcome: summary ?? null,
-    // The run has left the `feature-escalation` wait (answered → abandon, SLA auto-abandon, or the
-    // agent finished without escalating), so clear the denormalised escalation pointer the pages gate
-    // on. pollFeatureEscalations only sweeps `running`/`escalated` runs, so a terminal-ward transition
-    // through here must clear it itself or the stale question would linger on the row.
-    escalation_question: null,
-    escalation_user_task_key: null,
     updated_at: ts,
   });
   app.log.info("record-feature", { featureKey, featureStatus, rowStatus, prKey });

package/workers/record-feature-escalation/worker.test.ts

@@ -1,9 +1,10 @@
 // Unit coverage for pr.record-feature-escalation — a feature run parked on the native
 // `feature-escalation` user task (issue #210). Runs on the `escalated` arm, before the user task
-// exists, and must flip the row to the non-terminal `escalated` status and persist the agent's
-// `question` so the nwf UI can surface it (the poller can't read task-local vars, so this is the
-// question's source of truth). It clears the completable-task pointer to NULL (the task does not
-// exist yet, so any non-null value is stale); the poller fills the real key once it is observable.
+// exists, and must flip the row to the non-terminal `escalated` status and append the agent's
+// `question` to the canonical `feature_escalations` audit log so the nwf UI can surface it (the poller
+// can't read task-local vars, so this is the question's source of truth). Issue #332 dropped the
+// denormalised `feature_runs.escalation_question` / `escalation_user_task_key` columns, so this worker
+// now only flips the status and appends the audit row.
 import { test } from "node:test";
 import { assertEquals } from "#test-assert";
 import { noopLog } from "../../test/log.ts";
@@ -43,8 +44,8 @@ function fakeApp(rows: Record<string, unknown>[]): any {
   };
 }
 
-test("record-feature-escalation: flips the run to escalated and persists the question", async () => {
-  const rows = [{ feature_key: "owner/repo#7", status: "running", escalation_question: null, escalation_user_task_key: null }];
+test("record-feature-escalation: flips the run to escalated and appends the question to the audit log", async () => {
+  const rows = [{ feature_key: "owner/repo#7", status: "running" }];
   const app = fakeApp(rows);
   const out = await handler(
     { jobKey: "job-1", variables: { featureKey: "owner/repo#7", question: "Which API should I use?" } } as never,
@@ -52,11 +53,8 @@ test("record-feature-escalation: flips the run to escalated and persists the que
   );
   assertEquals(out, {});
   assertEquals(rows[0].status, "escalated");
-  assertEquals(rows[0].escalation_question, "Which API should I use?");
-  // The user task does not exist yet — the pointer is cleared to NULL here (poller fills the real key).
-  assertEquals(rows[0].escalation_user_task_key, null);
-  // Dual-write (issue #305): the question is ALSO appended to the canonical `feature_escalations`
-  // audit log so `pollUserTasks` can source it from a surviving table once the denormalised column drops.
+  // Issue #305/#332: the question is the sole responsibility of the canonical `feature_escalations`
+  // audit log so `pollUserTasks` can source it from a surviving table (the denormalised column is gone).
   assertEquals(app.stores.feature_escalations.length, 1);
   assertEquals(app.stores.feature_escalations[0].feature_key, "owner/repo#7");
   assertEquals(app.stores.feature_escalations[0].question, "Which API should I use?");
@@ -68,7 +66,7 @@ test("record-feature-escalation: a retried job (same jobKey) reuses its audit ro
   // before job completion re-runs with the SAME jobKey. The `job_key` idempotency guard must reuse the
   // existing `feature_escalations` row rather than append a duplicate (which would bloat the append-only
   // log and could skew "latest question" selection). Mirrors `record-plan-review`'s `plan_reviews` guard.
-  const rows = [{ feature_key: "owner/repo#7", status: "running", escalation_question: null, escalation_user_task_key: null }];
+  const rows = [{ feature_key: "owner/repo#7", status: "running" }];
   const app = fakeApp(rows);
   const job = { jobKey: "job-retry", variables: { featureKey: "owner/repo#7", question: "Which API?" } } as never;
   await handler(job, app);
@@ -77,22 +75,11 @@ test("record-feature-escalation: a retried job (same jobKey) reuses its audit ro
   assertEquals(app.stores.feature_escalations[0].job_key, "job-retry");
 });
 
-test("record-feature-escalation: clears a stale completable-task pointer at escalation entry", async () => {
-  // The task does not exist yet here, so a non-null key can only be stale (a prior escalation's key
-  // left behind, a manual DB repair, etc). Leaving it would bind the pages' answer/abandon affordance
-  // to the wrong task until the poller overwrites it; clear it so the row reads "key unknown here".
-  const rows = [{ feature_key: "owner/repo#9", status: "running", escalation_question: null, escalation_user_task_key: "stale-ut" }];
-  const app = fakeApp(rows);
-  await handler({ jobKey: "job-9", variables: { featureKey: "owner/repo#9", question: "Q?" } } as never, app);
-  assertEquals(rows[0].status, "escalated");
-  assertEquals(rows[0].escalation_question, "Q?");
-  assertEquals(rows[0].escalation_user_task_key, null);
-});
-
-test("record-feature-escalation: a blank/absent question is persisted as NULL (badge/affordance stay off)", async () => {
-  const rows = [{ feature_key: "owner/repo#8", status: "running", escalation_question: null }];
+test("record-feature-escalation: a blank/absent question is appended as NULL (badge/affordance stay off)", async () => {
+  const rows = [{ feature_key: "owner/repo#8", status: "running" }];
   const app = fakeApp(rows);
   await handler({ jobKey: "job-8", variables: { featureKey: "owner/repo#8", question: "   " } } as never, app);
   assertEquals(rows[0].status, "escalated");
-  assertEquals(rows[0].escalation_question, null);
+  assertEquals(app.stores.feature_escalations.length, 1);
+  assertEquals(app.stores.feature_escalations[0].question, null);
 });

package/workers/record-feature-escalation/worker.ts

@@ -1,17 +1,17 @@
 // pr.record-feature-escalation — a feature run has parked on the native `feature-escalation`
 // user task (the agent reported `status:"escalated"` with a non-blank `question`). This service
-// task runs on the `escalated` arm, immediately BEFORE the user task is created, and persists the
-// escalation onto the `feature_runs` row so the nwf UI can surface it (issue #210):
-//   • flips `status` to the non-terminal `escalated` so status-based views and counts flag it, and
-//   • denormalises the agent's `question` for the Escalation column + the answer affordance.
+// task runs on the `escalated` arm, immediately BEFORE the user task is created, and:
+//   • flips `feature_runs.status` to the non-terminal `escalated` so status-based views and counts
+//     flag it (and a re-dispatch of the same issue short-circuits while it is parked), and
+//   • appends the agent's `question` to the append-only `feature_escalations` audit log (issue #305),
+//     the canonical, poller-readable source for a parked run's question.
 //
-// It deliberately does NOT record a REAL completable `userTaskKey` — the task does not exist yet at
-// this point — and clears any stale pointer so the row reads "key unknown until observed".
-// `pollFeatureEscalations` (app/service.ts) fills that pointer in once the user task is
-// observable via `searchUserTasks`, which is also the reason the question is captured HERE rather
-// than by the poller: the WASM testkit engine does not surface a user task's ioMapping-mapped local
-// variables through `searchUserTasks`, so the process variable must be persisted while it is still
-// in scope on the job.
+// The completable `userTaskKey` is NOT recorded here — the task does not exist yet at this point.
+// `pollUserTasks` (app/service.ts) reads the engine's open `feature-escalation` task directly once it
+// is observable and projects it onto the `user_tasks` Tasks inbox, pairing it with the audit log's
+// question. Capturing the question HERE (not in the poller) is required because the WASM testkit
+// engine does not surface a user task's ioMapping-mapped local variables through the user-task query,
+// so the process variable must be persisted while it is still in scope on the job.
 import type { AppJobHandler } from "@nanobpm/urban";
 import { featureRuns, recordFeatureEscalation } from "../../app/feature.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
@@ -27,19 +27,13 @@ const handler: AppJobHandler<In> = async (job, app) => {
   const question = nonBlank(job.variables.question);
   await featureRuns(app.data).update(featureKey, {
     status: "escalated",
-    escalation_question: question,
-    // The user task does not exist yet, so any non-null pointer here can only be stale (a prior
-    // escalation's key, a manual DB repair). Clear it so the row reads "key unknown until observed"
-    // and the pages don't bind the answer/abandon affordance to a dead task; the poller re-fills the
-    // real key (it can always re-derive it from `searchUserTasks`), so this clear is never lossy.
-    escalation_user_task_key: null,
     updated_at: new Date().toISOString(),
   });
-  // Append the question to the canonical `feature_escalations` audit log (issue #305) so the poller
-  // can source it from a SURVIVING table once the denormalised `feature_runs.escalation_question`
-  // column is dropped in the contract phase — the feature analogue of `record-plan-review` writing
-  // `plan_reviews`. Dual-write for now (the column above still feeds the legacy page reads); the log
-  // is authoritative for `pollUserTasks`.
+  // Append the question to the canonical `feature_escalations` audit log (issue #305) — the SURVIVING
+  // table `pollUserTasks` reads to enrich the parked `feature-escalation` task's question on the Tasks
+  // inbox (the feature analogue of `record-plan-review` writing `plan_reviews`). The denormalised
+  // `feature_runs.escalation_question` column it used to dual-write was dropped in the contract phase
+  // (issue #332), so this log is now the sole source of the question text.
   await recordFeatureEscalation(app.data, { featureKey, question, jobKey: job.jobKey });
   app.log.info("record-feature-escalation", { featureKey, hasQuestion: question !== null });
   return {};

package/app/featureBlocked.test.ts

@@ -1,182 +0,0 @@
-// Read-model derivation test for the FEATURE-run BLOCKED reconcile (issue #220 — a blocked feature run
-// parked at `feature-blocked` had no completion affordance in nwf). When a run reaches a `blocked`
-// outcome `record-feature` holds the row at the non-terminal `awaiting_operator` status and it parks on
-// the native `feature-blocked` operator user task; `feature_runs` (which the pages read) had a status
-// but NO completable-task pointer, so the pages could not drive an acknowledge action. The blocked twin
-// of `deriveFeatureEscalationPatch` — the pure source of truth tested here — reconciles ONLY that
-// completable-task pointer (never the status, which `record-feature`/`record-blocked-ack` own), which
-// `pollFeatureBlocked` projects onto the row.
-import { test } from "node:test";
-import { assertEquals } from "#test-assert";
-import type { DataLayer, EngineClient } from "@nanobpm/urban";
-import { deriveFeatureBlockedPatch } from "./feature.ts";
-import { pollFeatureBlocked } from "./service.ts";
-
-// biome-ignore lint/suspicious/noExplicitAny: tiny in-memory table double, mirrors featureEscalation.test.ts
-function memData(): { data: DataLayer; stores: Record<string, any[]> } {
-  // biome-ignore lint/suspicious/noExplicitAny: see above
-  const stores: Record<string, any[]> = {};
-  function tbl(name: string, pk = "id") {
-    // biome-ignore lint/suspicious/noExplicitAny: see above
-    const rows = (stores[name] ??= [] as any[]);
-    // biome-ignore lint/suspicious/noExplicitAny: see above
-    const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
-    return {
-      async all() {
-        return rows.slice();
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async get(id: any) {
-        return rows.find((r) => r[pk] === id);
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async find(where: any = {}) {
-        return rows.filter((r) => match(r, where));
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async insert(row: any) {
-        rows.push({ ...row });
-        return row[pk];
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async update(id: any, patch: any) {
-        const r = rows.find((row) => row[pk] === id);
-        if (r) Object.assign(r, patch);
-      },
-    };
-  }
-  const data = { table: (n: string, pk?: string) => tbl(n, pk) } as unknown as DataLayer;
-  return { data, stores };
-}
-
-/** A single engine-reported user task in the fixture. `state` mirrors the engine lifecycle; it
- *  defaults to `"CREATED"` (the only open/answerable state) so existing fixtures read as live tasks.
- *  A looping run holds multiple tasks for one element (COMPLETED from prior rounds + the live one). */
-type FakeTask = { userTaskKey: string; elementId?: string; state?: "CREATED" | "COMPLETED" | "CANCELED" };
-
-/** A fake engine whose user tasks are keyed by processInstanceKey (the only field
- *  pollFeatureBlocked queries on). It models the real engine's two accessors from ONE fixture so a test
- *  genuinely exercises the lifecycle-state filtering: `searchUserTasks` returns tasks in ANY state
- *  (COMPLETED first, as the live API does — issue #294), while `openUserTasks` pins `state:"CREATED"`. */
-function fakeEngine(byInstance: Record<string, FakeTask[]>): EngineClient {
-  const all = (filter?: { processInstanceKey?: string }) =>
-    filter?.processInstanceKey ? (byInstance[filter.processInstanceKey] ?? []) : [];
-  return {
-    searchUserTasks: (filter?: { processInstanceKey?: string }) => Promise.resolve(all(filter)),
-    openUserTasks: (filter?: { processInstanceKey?: string }) =>
-      Promise.resolve(all(filter).filter((t) => (t.state ?? "CREATED") === "CREATED")),
-  } as unknown as EngineClient;
-}
-
-test("deriveFeatureBlockedPatch: a run parked at feature-blocked records the completable key (status untouched)", () => {
-  const patch = deriveFeatureBlockedPatch({ blocked_user_task_key: null }, { userTaskKey: "ut-9" });
-  assertEquals(patch, { blocked_user_task_key: "ut-9" });
-});
-
-test("deriveFeatureBlockedPatch: an already-recorded parked run yields no patch (idempotent)", () => {
-  const patch = deriveFeatureBlockedPatch({ blocked_user_task_key: "ut-9" }, { userTaskKey: "ut-9" });
-  assertEquals(patch, null);
-});
-
-test("deriveFeatureBlockedPatch: an observed run whose task is gone clears the stale pointer", () => {
-  const patch = deriveFeatureBlockedPatch({ blocked_user_task_key: "ut-9" }, null);
-  assertEquals(patch, { blocked_user_task_key: null });
-});
-
-// The pre-observation self-healing window (record-feature has persisted `awaiting_operator` but the
-// user task is not yet visible, so the pointer is still NULL): a premature "not parked" pass must NOT
-// write anything — the pointer is filled in on the next pass once the task is observable.
-test("deriveFeatureBlockedPatch: the pre-observation self-healing window yields no patch", () => {
-  const patch = deriveFeatureBlockedPatch({ blocked_user_task_key: null }, null);
-  assertEquals(patch, null);
-});
-
-test("pollFeatureBlocked: a parked awaiting_operator run is denormalised with the completable key", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#1", status: "awaiting_operator", process_key: "100", blocked_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "100": [{ userTaskKey: "ut-1", elementId: "feature-blocked" }] });
-
-  await pollFeatureBlocked(data, engine);
-
-  // The poller never flips status — record-feature owns `awaiting_operator`, record-blocked-ack the terminal.
-  assertEquals(stores.feature_runs[0].status, "awaiting_operator");
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, "ut-1");
-});
-
-test("pollFeatureBlocked: an observed run whose task is gone (out-of-band completion) clears the pointer", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#2", status: "awaiting_operator", process_key: "200", blocked_user_task_key: "ut-2" },
-  ];
-  const engine = fakeEngine({ "200": [] });
-
-  await pollFeatureBlocked(data, engine);
-
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, null);
-});
-
-test("pollFeatureBlocked: only touches awaiting_operator runs, and never one without a process_key", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#3", status: "blocked", process_key: "300", blocked_user_task_key: null },
-    { feature_key: "o/r#4", status: "awaiting_operator", process_key: null, blocked_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "300": [{ userTaskKey: "ut-3", elementId: "feature-blocked" }] });
-
-  await pollFeatureBlocked(data, engine);
-
-  // blocked is terminal → not a candidate; awaiting_operator with no process_key → skipped.
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, null);
-  assertEquals(stores.feature_runs[1].blocked_user_task_key, null);
-});
-
-test("pollFeatureBlocked: a parked non-blocked task (feature-escalation) does not record a pointer", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#5", status: "awaiting_operator", process_key: "500", blocked_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "500": [{ userTaskKey: "ut-5", elementId: "feature-escalation" }] });
-
-  await pollFeatureBlocked(data, engine);
-
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, null);
-});
-
-// ── Defect-class guard (issue #294): a looping run holds MULTIPLE feature-blocked tasks ────────────
-// The blocked wait sits on a blocked→ack loop, so a re-blocked run holds a COMPLETED feature-blocked
-// task from a prior round alongside the live CREATED one; the engine returns the COMPLETED task first.
-// Scoping the query to open (CREATED) tasks records the live key, never the terminal one.
-test("pollFeatureBlocked: a looping run records the CREATED task, never the COMPLETED one", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#6", status: "awaiting_operator", process_key: "600", blocked_user_task_key: null },
-  ];
-  const engine = fakeEngine({
-    "600": [
-      { userTaskKey: "ut-completed", elementId: "feature-blocked", state: "COMPLETED" },
-      { userTaskKey: "ut-live", elementId: "feature-blocked", state: "CREATED" },
-    ],
-  });
-
-  await pollFeatureBlocked(data, engine);
-
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, "ut-live");
-});
-
-// Self-heal reached: a run past the blocked wait whose only feature-blocked task is COMPLETED must
-// clear the stale pointer (open-task query returns [] → `parked=null`), not latch it on the dead key.
-test("pollFeatureBlocked: a run whose only feature-blocked task is COMPLETED clears the stale pointer", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#7", status: "awaiting_operator", process_key: "700", blocked_user_task_key: "ut-7" },
-  ];
-  const engine = fakeEngine({
-    "700": [{ userTaskKey: "ut-7", elementId: "feature-blocked", state: "COMPLETED" }],
-  });
-
-  await pollFeatureBlocked(data, engine);
-
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, null);
-});

package/app/featureEscalation.test.ts

@@ -1,235 +0,0 @@
-// Read-model derivation test for the FEATURE-run escalation reconcile (issue #210 — feature-run
-// escalations were invisible in the nwf UI). When a feature run escalates it parks on the native
-// `feature-escalation` user task; `feature_runs` (which the pages read) stayed `running` with
-// nothing to show. Two collaborators fix that: the `record-feature-escalation` service task persists
-// the `status`-flip's companion `question` at escalation entry (it can read the process variable
-// while it is still in scope), and `deriveFeatureEscalationPatch` — the pure source of truth tested
-// here — reconciles the run's LIVENESS (status + completable-task pointer) that `pollFeatureEscalations`
-// projects onto the row. The poller never touches `escalation_question`, so it can never clobber the
-// service task's write during the self-healing window before the user task is observable.
-import { test } from "node:test";
-import { assertEquals } from "#test-assert";
-import type { DataLayer, EngineClient } from "@nanobpm/urban";
-import { deriveFeatureEscalationPatch } from "./feature.ts";
-import { pollFeatureEscalations } from "./service.ts";
-
-// biome-ignore lint/suspicious/noExplicitAny: tiny in-memory table double, mirrors featureDelivery.test.ts
-function memData(): { data: DataLayer; stores: Record<string, any[]> } {
-  // biome-ignore lint/suspicious/noExplicitAny: see above
-  const stores: Record<string, any[]> = {};
-  function tbl(name: string, pk = "id") {
-    // biome-ignore lint/suspicious/noExplicitAny: see above
-    const rows = (stores[name] ??= [] as any[]);
-    // biome-ignore lint/suspicious/noExplicitAny: see above
-    const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
-    return {
-      async all() {
-        return rows.slice();
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async get(id: any) {
-        return rows.find((r) => r[pk] === id);
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async find(where: any = {}) {
-        return rows.filter((r) => match(r, where));
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async insert(row: any) {
-        rows.push({ ...row });
-        return row[pk];
-      },
-      // biome-ignore lint/suspicious/noExplicitAny: see above
-      async update(id: any, patch: any) {
-        const r = rows.find((row) => row[pk] === id);
-        if (r) Object.assign(r, patch);
-      },
-    };
-  }
-  const data = { table: (n: string, pk?: string) => tbl(n, pk) } as unknown as DataLayer;
-  return { data, stores };
-}
-
-/** A single engine-reported user task in the fixture. `state` mirrors the engine lifecycle; it
- *  defaults to `"CREATED"` (the only open/answerable state) so existing fixtures read as live tasks.
- *  A looping run holds multiple tasks for one element (COMPLETED from prior rounds + the live one). */
-type FakeTask = { userTaskKey: string; elementId?: string; state?: "CREATED" | "COMPLETED" | "CANCELED" };
-
-/** A fake engine whose user tasks are keyed by processInstanceKey (the only field
- *  pollFeatureEscalations queries on). It models the real engine's two accessors from ONE fixture so a
- *  test genuinely exercises the lifecycle-state filtering: `searchUserTasks` returns tasks in ANY state
- *  (COMPLETED first, as the live API does — issue #294), while `openUserTasks` pins `state:"CREATED"`. */
-function fakeEngine(byInstance: Record<string, FakeTask[]>): EngineClient {
-  const all = (filter?: { processInstanceKey?: string }) =>
-    filter?.processInstanceKey ? (byInstance[filter.processInstanceKey] ?? []) : [];
-  return {
-    searchUserTasks: (filter?: { processInstanceKey?: string }) => Promise.resolve(all(filter)),
-    openUserTasks: (filter?: { processInstanceKey?: string }) =>
-      Promise.resolve(all(filter).filter((t) => (t.state ?? "CREATED") === "CREATED")),
-  } as unknown as EngineClient;
-}
-
-test("deriveFeatureEscalationPatch: a running run parked at feature-escalation flips to escalated + records the key", () => {
-  const patch = deriveFeatureEscalationPatch(
-    { status: "running", escalation_user_task_key: null },
-    { userTaskKey: "ut-9" },
-  );
-  assertEquals(patch, { status: "escalated", escalation_user_task_key: "ut-9" });
-});
-
-test("deriveFeatureEscalationPatch: an already-escalated run with the key recorded yields no patch (idempotent)", () => {
-  const patch = deriveFeatureEscalationPatch(
-    { status: "escalated", escalation_user_task_key: "ut-9" },
-    { userTaskKey: "ut-9" },
-  );
-  assertEquals(patch, null);
-});
-
-test("deriveFeatureEscalationPatch: an escalated run that un-parked resumes to running, pointer + question cleared", () => {
-  const patch = deriveFeatureEscalationPatch({ status: "escalated", escalation_user_task_key: "ut-9" }, null);
-  assertEquals(patch, { status: "running", escalation_user_task_key: null, escalation_question: null });
-});
-
-test("deriveFeatureEscalationPatch: a run past escalated with a stale pointer clears the pointer + question", () => {
-  const patch = deriveFeatureEscalationPatch({ status: "awaiting_operator", escalation_user_task_key: "ut-9" }, null);
-  assertEquals(patch, { escalation_user_task_key: null, escalation_question: null });
-});
-
-// Self-heal: a task completed out-of-band (external UI, bypassing the answer operation) leaves the
-// run un-parked but with the pointer still recording the observed task. The poller clears BOTH the
-// pointer and the now-stale question so the UI stops surfacing an Escalation on a resumed run.
-test("deriveFeatureEscalationPatch: un-park after an out-of-band completion clears the stale question", () => {
-  const patch = deriveFeatureEscalationPatch({ status: "escalated", escalation_user_task_key: "ut-9" }, null);
-  assertEquals(patch?.escalation_question, null);
-});
-
-// The pre-observation self-healing window (record-feature-escalation has persisted the question but
-// the task is not yet visible, so the pointer is still NULL): a premature "not parked" pass must NOT
-// clobber the freshly-persisted question — only reset the transient status, re-flipped next pass.
-test("deriveFeatureEscalationPatch: the pre-observation self-healing window never clears the question", () => {
-  const patch = deriveFeatureEscalationPatch({ status: "escalated", escalation_user_task_key: null }, null);
-  assertEquals(patch, { status: "running" });
-});
-
-test("deriveFeatureEscalationPatch: a clean running run not parked yields no patch", () => {
-  const patch = deriveFeatureEscalationPatch({ status: "running", escalation_user_task_key: null }, null);
-  assertEquals(patch, null);
-});
-
-test("pollFeatureEscalations: a parked run is flipped to escalated with the completable key (question left to the service task)", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#1", status: "running", process_key: "100", escalation_question: null, escalation_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "100": [{ userTaskKey: "ut-1", elementId: "feature-escalation" }] });
-
-  await pollFeatureEscalations(data, engine);
-
-  assertEquals(stores.feature_runs[0].status, "escalated");
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, "ut-1");
-  // The poller does not synthesise the question — that is the record-feature-escalation service task's.
-  assertEquals(stores.feature_runs[0].escalation_question, null);
-});
-
-test("pollFeatureEscalations: an escalated run whose task is gone resumes to running, clears the pointer + stale question", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#2", status: "escalated", process_key: "200", escalation_question: "Q", escalation_user_task_key: "ut-2" },
-  ];
-  const engine = fakeEngine({ "200": [] });
-
-  await pollFeatureEscalations(data, engine);
-
-  assertEquals(stores.feature_runs[0].status, "running");
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, null);
-  // The observed task is gone → self-heal the now-stale question so the UI stops surfacing it.
-  assertEquals(stores.feature_runs[0].escalation_question, null);
-});
-
-test("pollFeatureEscalations: a re-observed parked run keeps its persisted question, only filling the key", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#3", status: "escalated", process_key: "300", escalation_question: "kept", escalation_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "300": [{ userTaskKey: "ut-3", elementId: "feature-escalation" }] });
-
-  await pollFeatureEscalations(data, engine);
-
-  assertEquals(stores.feature_runs[0].status, "escalated");
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, "ut-3");
-  assertEquals(stores.feature_runs[0].escalation_question, "kept");
-});
-
-test("pollFeatureEscalations: only touches running/escalated runs, and never one without a process_key", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#4", status: "opened", process_key: "400", escalation_question: null, escalation_user_task_key: null },
-    { feature_key: "o/r#5", status: "running", process_key: null, escalation_question: null, escalation_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "400": [{ userTaskKey: "ut-4", elementId: "feature-escalation" }] });
-
-  await pollFeatureEscalations(data, engine);
-
-  // opened is terminal → not a candidate; running with no process_key → skipped.
-  assertEquals(stores.feature_runs[0].status, "opened");
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, null);
-  assertEquals(stores.feature_runs[1].status, "running");
-});
-
-test("pollFeatureEscalations: a parked non-escalation task (feature-blocked) does not flip the run", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#6", status: "running", process_key: "600", escalation_question: null, escalation_user_task_key: null },
-  ];
-  const engine = fakeEngine({ "600": [{ userTaskKey: "ut-6", elementId: "feature-blocked" }] });
-
-  await pollFeatureEscalations(data, engine);
-
-  assertEquals(stores.feature_runs[0].status, "running");
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, null);
-});
-
-// ── Defect-class guard (issue #294): a looping run holds MULTIPLE feature-escalation tasks ─────────
-// A run in an escalate→answer→implement→re-escalate loop holds a COMPLETED feature-escalation task
-// from a prior round alongside the live CREATED one. The engine returns the COMPLETED task first, so a
-// poller that reads UNFILTERED tasks and `.find`s by element latches onto the terminal key — pinning
-// the pointer at a dead task. Scoping the query to open (CREATED) tasks resolves the live one.
-test("pollFeatureEscalations: a looping run resolves the CREATED task, never the COMPLETED one", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#7", status: "running", process_key: "700", escalation_question: null, escalation_user_task_key: null },
-  ];
-  // Engine returns the COMPLETED (prior-round) task FIRST, then the live CREATED one (issue #294).
-  const engine = fakeEngine({
-    "700": [
-      { userTaskKey: "ut-completed", elementId: "feature-escalation", state: "COMPLETED" },
-      { userTaskKey: "ut-live", elementId: "feature-escalation", state: "CREATED" },
-    ],
-  });
-
-  await pollFeatureEscalations(data, engine);
-
-  assertEquals(stores.feature_runs[0].status, "escalated");
-  // Must be the live CREATED task, not the COMPLETED prior-round one.
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, "ut-live");
-});
-
-// Self-heal reached: once a run finally exits escalation for good, only a lingering COMPLETED
-// feature-escalation task remains. The open-task query returns [], so `parked=null` and the run
-// resets escalated→running — instead of a false-positive pointer built from the terminal task pinning
-// `status='escalated'` forever.
-test("pollFeatureEscalations: a run whose only feature-escalation task is COMPLETED self-heals to running", async () => {
-  const { data, stores } = memData();
-  stores.feature_runs = [
-    { feature_key: "o/r#8", status: "escalated", process_key: "800", escalation_question: "Q", escalation_user_task_key: "ut-8" },
-  ];
-  const engine = fakeEngine({
-    "800": [{ userTaskKey: "ut-8", elementId: "feature-escalation", state: "COMPLETED" }],
-  });
-
-  await pollFeatureEscalations(data, engine);
-
-  assertEquals(stores.feature_runs[0].status, "running");
-  assertEquals(stores.feature_runs[0].escalation_user_task_key, null);
-  assertEquals(stores.feature_runs[0].escalation_question, null);
-});