@nanobpm/nano-workforce 0.99.0 → 0.100.0

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);
-});

package/operations/acknowledgeBlocked.test.ts

@@ -1,111 +0,0 @@
-// Tests for the POST /app/api/actions/acknowledge-blocked operation `acknowledgeBlocked` (issue #220).
-// The nwf UI's completion affordance for a blocked feature run parked at `feature-blocked`: it routes
-// through the canonical attributed completer (completeBlockedAsHuman → completeUserTaskAttributed),
-// resuming the process (→ pr.record-blocked-ack) exactly as the task inbox would, and immediately
-// clears the denormalised completable-task pointer so the affordance stops rendering. Mirrors the
-// escalation twin (operations/answerFeatureEscalation.ts).
-import { test } from "node:test";
-import { assertEquals } from "#test-assert";
-import type { AppApi } from "@nanobpm/urban";
-import { noopLog } from "../test/log.ts";
-import handler from "./acknowledgeBlocked.ts";
-
-function memApp(openTasks: { userTaskKey: string; elementId?: string }[]): {
-  app: AppApi;
-  stores: Record<string, any[]>;
-  completed: { userTaskKey: string; variables: Record<string, unknown> }[];
-} {
-  const stores: Record<string, any[]> = {};
-  const completed: { userTaskKey: string; variables: Record<string, unknown> }[] = [];
-  function tbl(name: string, pk: string) {
-    const rows = (stores[name] ??= [] as any[]);
-    return {
-      async insert(row: any) {
-        rows.push({ ...row });
-        return rows.length;
-      },
-      async get(id: any) {
-        return rows.find((r) => r[pk] === id);
-      },
-      async find(where: any = {}) {
-        return rows.filter((r) => Object.entries(where).every(([k, v]) => r[k] === v));
-      },
-      async delete(id: any) {
-        const i = rows.findIndex((r) => r[pk] === id);
-        if (i >= 0) rows.splice(i, 1);
-      },
-      async update(id: any, patch: any) {
-        const r = rows.find((row) => row[pk] === id);
-        if (r) Object.assign(r, patch);
-      },
-    };
-  }
-  const engine = {
-    searchUserTasks: async () => openTasks,
-    completeUserTask: async (userTaskKey: string, variables: Record<string, unknown>) => {
-      completed.push({ userTaskKey, variables });
-    },
-  };
-  const app = {
-    data: { table: (n: string, pk: string) => tbl(n, pk) },
-    engine,
-    log: noopLog(),
-  } as any as AppApi;
-  return { app, stores, completed };
-}
-
-async function call(app: AppApi, body: unknown) {
-  return (await handler({ req: {} as any, params: {}, query: {}, body } as any, app)) as any;
-}
-
-test("acknowledge-blocked: completes the feature-blocked task, records the note, clears the pointer", async () => {
-  const { app, stores, completed } = memApp([{ userTaskKey: "ut-1", elementId: "feature-blocked" }]);
-  stores.feature_runs = [{ feature_key: "o/r#1", status: "awaiting_operator", blocked_user_task_key: "ut-1" }];
-
-  const res = await call(app, { userTaskKey: "ut-1", note: "reassigned to a human", operator: "alice" });
-
-  assertEquals(res.status, 200);
-  assertEquals(res.body.ok, true);
-  // The task is completed with the typed `note` variable the record-blocked-ack ioMapping reads.
-  assertEquals(completed.length, 1);
-  assertEquals(completed[0].userTaskKey, "ut-1");
-  assertEquals(completed[0].variables, { note: "reassigned to a human" });
-  // The attribution ledger records WHO acknowledged (a human — the authority, not reversible).
-  assertEquals(stores.task_completions.length, 1);
-  assertEquals(stores.task_completions[0].actor_kind, "human");
-  assertEquals(stores.task_completions[0].actor_id, "alice");
-  assertEquals(stores.task_completions[0].reversible, 0);
-  // The operation clears its own action's pointer immediately (status left to record-blocked-ack).
-  assertEquals(stores.feature_runs[0].blocked_user_task_key, null);
-});
-
-test("acknowledge-blocked: a blank note omits the variable so the ioMapping fallback fires", async () => {
-  const { app, stores, completed } = memApp([{ userTaskKey: "ut-2", elementId: "feature-blocked" }]);
-  stores.feature_runs = [{ feature_key: "o/r#2", status: "awaiting_operator", blocked_user_task_key: "ut-2" }];
-
-  const res = await call(app, { userTaskKey: "ut-2", note: "   " });
-
-  assertEquals(res.status, 200);
-  assertEquals(completed[0].variables, {});
-});
-
-test("acknowledge-blocked: a missing userTaskKey → 400", async () => {
-  const { app } = memApp([]);
-  const res = await call(app, { note: "x" });
-  assertEquals(res.status, 400);
-  assertEquals(res.body.ok, false);
-});
-
-test("acknowledge-blocked: no matching open task → 404", async () => {
-  const { app } = memApp([]);
-  const res = await call(app, { userTaskKey: "ut-gone" });
-  assertEquals(res.status, 404);
-  assertEquals(res.body.ok, false);
-});
-
-test("acknowledge-blocked: refuses a non-blocked task (an escalation) → 400", async () => {
-  const { app } = memApp([{ userTaskKey: "ut-esc", elementId: "feature-escalation" }]);
-  const res = await call(app, { userTaskKey: "ut-esc" });
-  assertEquals(res.status, 400);
-  assertEquals(res.body.ok, false);
-});

package/operations/acknowledgeBlocked.ts

@@ -1,62 +0,0 @@
-// POST /app/api/actions/acknowledge-blocked → operationId `acknowledgeBlocked` (issue #220).
-// The nwf UI's completion affordance for a BLOCKED single-issue feature run: an operator acknowledges
-// the parked `feature-blocked` user task (with an optional disposition note) directly from the Feature /
-// Overview pages, instead of the run sitting parked forever with no control (the escalation path got
-// this in issue #210; the blocked path did not).
-//
-// It routes through the ONE canonical attributed completer (`completeBlockedAsHuman` →
-// `completeUserTaskAttributed`), so the completion uses the exact same typed `.form` variable (`note`)
-// and engine resume path a human drives from the task inbox — no parallel completion — while recording
-// WHO acknowledged in the `task_completions` ledger. Completing the task fires `pr.record-blocked-ack`,
-// which settles the row to the terminal `blocked` status with the operator's note. The poller then
-// reconciles the completable-task pointer off the row (pollFeatureBlocked) once the task is gone.
-//
-// The runtime validates the body against openapi.yaml (`userTaskKey` required); this delegate narrows
-// the validated shape and builds the typed completion variables the `feature-blocked` form + the
-// `record-blocked-ack` ioMapping expect.
-
-import { completeBlockedAsHuman } from "../app/agentCompletion.ts";
-import { featureRuns } from "../app/feature.ts";
-import { defineOperation } from "../nano-generated/operations.ts";
-
-const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
-
-export default defineOperation("acknowledgeBlocked", async ({ body }, app) => {
-  if (!body || typeof body !== "object") {
-    app.log.warn("acknowledge-blocked rejected: missing request body");
-    return { status: 400, body: { ok: false, error: "userTaskKey is required" } };
-  }
-
-  const userTaskKey = str(body.userTaskKey);
-  if (!userTaskKey) return { status: 400, body: { ok: false, error: "userTaskKey is required" } };
-
-  // The `feature-blocked` form completes with an optional `note`; the `record-blocked-ack` ioMapping
-  // reads it (`if is defined(note) then note else null`) into `delivery_label`. An absent/blank note is
-  // recorded as an "acknowledged" label rather than an empty string — omit the variable entirely so the
-  // ioMapping's `is defined` fallback fires.
-  const note = str(body.note);
-  const variables: Record<string, unknown> = note ? { note } : {};
-
-  // The completing operator, for the attribution ledger. Optional — the UI has no per-operator auth, so
-  // default to a generic handle rather than blocking the acknowledgement.
-  const operatorId = str(body.operator) || "operator";
-
-  const r = await completeBlockedAsHuman(app.data, app.engine, { userTaskKey, operatorId, variables });
-  if (r.ok) {
-    // Reconcile this operation's OWN action immediately: clear the denormalised blocked pointer so the
-    // pages stop offering an acknowledge affordance for a task that is now completed. Leave `status` to
-    // `record-blocked-ack` (which settles it to terminal `blocked`), so we never overwrite the status the
-    // resumed run has advanced to.
-    for (const run of await featureRuns(app.data).find({ blocked_user_task_key: userTaskKey })) {
-      await featureRuns(app.data).update(run.feature_key, {
-        blocked_user_task_key: null,
-        updated_at: new Date().toISOString(),
-      });
-    }
-    app.log.info("operator acknowledged blocked feature run", { userTaskKey, elementId: r.elementId });
-    return { status: 200, body: { ok: true, completionId: r.completionId, elementId: r.elementId } };
-  }
-  const status = r.reason === "no open blocked task" ? 404 : 400;
-  app.log.warn("acknowledge-blocked: not completed", { userTaskKey, reason: r.reason });
-  return { status, body: { ok: false, error: r.reason } };
-});