@nanobpm/nano-workforce 0.123.1 → 0.123.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.123.2](https://github.com/nanobpm/nano-workforce/compare/v0.123.1...v0.123.2) (2026-08-22)
+
+
+### Bug Fixes
+
+* **merge:** make draft PRs a first-class not-landable verdict ([#454](https://github.com/nanobpm/nano-workforce/issues/454)) ([#455](https://github.com/nanobpm/nano-workforce/issues/455)) ([d684086](https://github.com/nanobpm/nano-workforce/commit/d684086748c840fe6a77fd7d86c5cdecbf8bfe2a))
+* **read-model:** derive feature attention badge from open user tasks, not sticky status ([#458](https://github.com/nanobpm/nano-workforce/issues/458)) ([496971d](https://github.com/nanobpm/nano-workforce/commit/496971dba95f19857d659e5a9d7fa56085d932fa)), closes [#439](https://github.com/nanobpm/nano-workforce/issues/439) [#448](https://github.com/nanobpm/nano-workforce/issues/448) [#422](https://github.com/nanobpm/nano-workforce/issues/422) [#422](https://github.com/nanobpm/nano-workforce/issues/422)
+* **tasks:** scan running delivery-graph runs in the typed-seam fallback so human gates surface without raw-REST ([#457](https://github.com/nanobpm/nano-workforce/issues/457)) ([9e82d37](https://github.com/nanobpm/nano-workforce/commit/9e82d37a101d532de447c6ca0bf64bd3d9a3bee7)), closes [#443](https://github.com/nanobpm/nano-workforce/issues/443) [#442](https://github.com/nanobpm/nano-workforce/issues/442)
+
 ## [0.123.1](https://github.com/nanobpm/nano-workforce/compare/v0.123.0...v0.123.1) (2026-08-22)
 
 

package/app/deliveryGraphDeploy.test.ts

@@ -0,0 +1,209 @@
+// End-to-end coverage that the delivery-graph compiler (ADR 0005) emits BPMN that is BOTH
+// EXECUTABLE and RENDERABLE — the two disjoint validity axes of the one BPMN in this system that is
+// generated at RUNTIME by raw string concatenation rather than authored (issue #451).
+//
+// The pure compiler tests (`deliveryGraphCompiler.test.ts`) assert only on the XML STRING SHAPE
+// (`includes(...)`, regex counts). A string-shape assert proves the text LOOKS right; it does NOT
+// prove it DEPLOYS — a mis-wired boundary event, a flow to a dropped element, a bad `ioMapping`, or a
+// `jobType` typo yields BPMN that passes every `includes()` and still fails `engine.deploy(xml)` with
+// a misleading "unknown target element" at the flow (the AGENTS.md "it parsed but didn't execute"
+// drift class). So here we DEPLOY the compiled graph through the real in-process WASM engine
+// (`@nanobpm/urban-testkit`) via the SAME S4 path the runner uses (`runDeliveryGraph`) and ADVANCE a
+// live instance to a terminal state — the exact deploy → instance → user-tasks → complete → terminal
+// path that otherwise only gets hand-verified against a live node.
+//
+// Renderability and executability are DISJOINT (a graph can lay out perfectly and still fail deploy,
+// and vice-versa), so `di coverage` guards the visual axis independently: every emitted flow node
+// carries a `bpmndi:BPMNShape` and every sequence flow a `bpmndi:BPMNEdge`, so a future node kind
+// cannot silently ship without a diagram (AGENTS.md: "BPMN Models need DI for rendering").
+import { test } from "node:test";
+import { createWasmEngineClient } from "@nanobpm/urban-testkit";
+import { assert, assertEquals } from "#test-assert";
+import { DELIVERY_CONNECTOR_TASK_TYPE } from "./deliveryConnector.ts";
+import { compileDeliveryGraph } from "./deliveryGraphCompiler.ts";
+import { runDeliveryGraph } from "./deliveryRunner.ts";
+import type { DeliveryGraph } from "../nano-generated/api-io.d.ts";
+
+/** A graph exercising the full node-kind matrix: `agent` (a named `senior:*` job), `wait` (the
+ *  `pr.readiness-probe` poll gate), `human` (a user task), and `connector` (the delivery-connector
+ *  delegate). This is the ADR's motivating release runbook. */
+const MATRIX_GRAPH: DeliveryGraph = {
+  name: "release runbook",
+  nodes: [
+    { id: "impl", kind: "agent", agent: { jobType: "senior:feature", prompt: "un-draft + merge #B" } },
+    { id: "watch", kind: "wait", wait: { kind: "pr", target: "owner/repo#42", match: { prState: "merged" } }, emits: [{ name: "mergedSha", type: "string" }] },
+    { id: "publish", kind: "human", human: { prompt: "run the manual OTP publish" }, emits: [{ name: "resolvedArtifact", type: "artifact" }] },
+    { id: "consume", kind: "connector", connector: { target: "npm:install", dedupeKey: "consume-1" } },
+  ],
+  edges: [
+    { from: "impl", to: "watch" },
+    { from: "watch.mergedSha", to: "publish" },
+    { from: "publish.resolvedArtifact", to: "consume" },
+  ],
+};
+
+/** The generic completion payload for a delivery user task. Satisfies BOTH the `human` node's output
+ *  ioMapping (`value` → `humanEmitValue`, `resolvedArtifact` → `humanEmitArtifact`, `note` →
+ *  `humanNote`) and the escalation task's generic form (`value` required, `note`). */
+const HUMAN_PAYLOAD = { value: "done", note: "ok", resolvedArtifact: "@nanobpm/demo@1.0.0" };
+
+/** Upper bound on drive rounds — a terminal graph settles in a handful; the cap turns a wiring bug
+ *  (a node that never advances) into a loud failure instead of a hang. */
+const MAX_ROUNDS = 16;
+
+test("deploy+advance: a well-formed graph deploys through the real engine and every node kind advances to a COMPLETED instance", async () => {
+  const engine = await createWasmEngineClient();
+  try {
+    // Serve every service node's job so each node completes NORMALLY (no boundary timeout fires): the
+    // agent job, the readiness probe (return `ready: true` so the poll loop exits on its first pass),
+    // and the connector delegate.
+    await engine.registerWorker("senior:feature", async () => ({}));
+    await engine.registerWorker("pr.readiness-probe", async () => ({ ready: true, mergedSha: "deadbeefcafe" }));
+    await engine.registerWorker(DELIVERY_CONNECTOR_TASK_TYPE, async () => ({}));
+
+    const run = await runDeliveryGraph(engine, MATRIX_GRAPH);
+    assert(run.ok, `runDeliveryGraph failed: ${JSON.stringify(run)}`);
+    const key = run.handle.processInstanceKey;
+
+    // Drive to terminal: serve jobs (drain), then complete any parked human user task, repeat. No
+    // virtual-clock advance — the happy path stalls ONLY on the human node, never on a timer.
+    const humanTasks: string[] = [];
+    let state = "?";
+    for (let round = 0; round < MAX_ROUNDS; round++) {
+      await engine.drain();
+      const [pi] = await engine.searchProcessInstances({ processInstanceKeys: [key] });
+      assert(pi, `no process instance snapshot for ${key} — searchProcessInstances returned empty`);
+      state = pi.state ?? "?";
+      if (state === "COMPLETED" || state === "TERMINATED") break;
+      const open = await engine.searchUserTasks({ processInstanceKey: key, state: "CREATED" });
+      assert(open.length > 0, `instance is ${state} with no open user task — a service node never advanced`);
+      for (const t of open) {
+        humanTasks.push(t.elementId ?? "?");
+        await engine.completeUserTask(t.userTaskKey, HUMAN_PAYLOAD);
+      }
+    }
+
+    assertEquals(state, "COMPLETED", "the deployed delivery graph must run to a COMPLETED instance");
+    // The ONE stop on the happy path is the `publish` human node; its compiled user-task element id is
+    // `delivery-human-task__<element>`. Assert we actually surfaced (and completed) it — proof the
+    // human node's user task deployed and is completable, not just that the instance ended.
+    assertEquals(humanTasks.length, 1, `expected exactly one human user task, saw ${JSON.stringify(humanTasks)}`);
+    assert(
+      humanTasks[0].startsWith("delivery-human-task__") && !humanTasks[0].endsWith("__esc"),
+      `expected a human node task, saw ${humanTasks[0]}`,
+    );
+  } finally {
+    await engine.close();
+  }
+});
+
+test("deploy+advance: a stalled service node escalates on its node-timeout boundary onto a human-completable task that advances the instance to COMPLETED", async () => {
+  const engine = await createWasmEngineClient();
+  try {
+    // A minimal agent → human graph. We deliberately register NO `senior:feature` worker, so the agent
+    // node stalls and MUST escalate on its `=nodeTimeout` boundary timer — the exact path a stuck node
+    // takes on a live fleet (and the one hand-verified against merlin).
+    const graph: DeliveryGraph = {
+      name: "escalation graph",
+      nodes: [
+        { id: "impl", kind: "agent", agent: { jobType: "senior:feature", prompt: "do it" } },
+        { id: "signoff", kind: "human", human: { prompt: "sign off" } },
+      ],
+      edges: [{ from: "impl", to: "signoff" }],
+    };
+    // Short node timeout so the boundary fires within one virtual-clock advance; a long SLA so the
+    // human node's own escalation boundary never fires during the drive.
+    const run = await runDeliveryGraph(engine, graph, { nodeTimeout: "PT1M", escalationSlaTimeout: "PT1H" });
+    assert(run.ok, `runDeliveryGraph failed: ${JSON.stringify(run)}`);
+    const key = run.handle.processInstanceKey;
+
+    // The stalled agent has NOT escalated yet: no user task before the timeout.
+    await engine.drain();
+    let open = await engine.searchUserTasks({ processInstanceKey: key, state: "CREATED" });
+    assertEquals(open.length, 0, "the stalled agent must not surface a task before its node timeout");
+
+    // Fire the PT1M node-timeout boundary → the agent node escalates onto its `__esc` user task.
+    await engine.advanceTime(60_000);
+    open = await engine.searchUserTasks({ processInstanceKey: key, state: "CREATED" });
+    assertEquals(open.length, 1, "the node timeout must surface exactly one escalation user task");
+    assert(open[0].elementId?.endsWith("__esc"), `expected an __esc escalation task, saw ${open[0].elementId}`);
+
+    // Complete the escalation task → the agent node ends → the flow reaches the human node → complete
+    // that → terminal.
+    const completed: string[] = [];
+    let state = "?";
+    for (let round = 0; round < MAX_ROUNDS; round++) {
+      await engine.drain();
+      const [pi] = await engine.searchProcessInstances({ processInstanceKeys: [key] });
+      assert(pi, `no process instance snapshot for ${key} — searchProcessInstances returned empty`);
+      state = pi.state ?? "?";
+      if (state === "COMPLETED" || state === "TERMINATED") break;
+      const tasks = await engine.searchUserTasks({ processInstanceKey: key, state: "CREATED" });
+      assert(tasks.length > 0, `instance is ${state} with no open task after escalation — a node never advanced`);
+      for (const t of tasks) {
+        completed.push(t.elementId ?? "?");
+        await engine.completeUserTask(t.userTaskKey, HUMAN_PAYLOAD);
+      }
+    }
+
+    assertEquals(state, "COMPLETED", "completing the escalation + human task must run the graph to COMPLETED");
+    assert(
+      completed.some((id) => id.endsWith("__esc")),
+      `the escalation task must have been driven, saw ${JSON.stringify(completed)}`,
+    );
+    assert(
+      completed.some((id) => id.startsWith("delivery-human-task__") && !id.endsWith("__esc")),
+      `the downstream human task must have been driven, saw ${JSON.stringify(completed)}`,
+    );
+  } finally {
+    await engine.close();
+  }
+});
+
+/** Every BPMN flow-node tag that must carry a `bpmndi:BPMNShape` to be rendered by human tooling. */
+const FLOW_NODE_TAGS = [
+  "startEvent",
+  "endEvent",
+  "task",
+  "serviceTask",
+  "userTask",
+  "subProcess",
+  "exclusiveGateway",
+  "parallelGateway",
+  "inclusiveGateway",
+  "boundaryEvent",
+  "intermediateCatchEvent",
+  "intermediateThrowEvent",
+  "callActivity",
+].join("|");
+
+/** Extract every `id="…"` for the given opening-tag alternation from the BPMN source. */
+function idsForTags(bpmn: string, tagAlternation: string): string[] {
+  const re = new RegExp(`<bpmn:(?:${tagAlternation})\\b[^>]*\\bid="([^"]+)"`, "g");
+  return [...bpmn.matchAll(re)].map((m) => m[1]);
+}
+
+test("di coverage: every compiled flow node carries a BPMNShape and every sequence flow a BPMNEdge", async () => {
+  const r = await compileDeliveryGraph(MATRIX_GRAPH);
+  assert(r.ok, `expected ok:true, got ${JSON.stringify(r)}`);
+  const bpmn = r.bpmn;
+
+  const flowNodeIds = idsForTags(bpmn, FLOW_NODE_TAGS);
+  assert(flowNodeIds.length > 0, "expected the compiled graph to contain flow nodes");
+  const shapeless = flowNodeIds.filter(
+    (id) => !new RegExp(`<bpmndi:BPMNShape[^>]*bpmnElement="${escapeRe(id)}"`).test(bpmn),
+  );
+  assertEquals(shapeless, [], `every flow node must have a BPMNShape; missing: ${JSON.stringify(shapeless)}`);
+
+  const sequenceFlowIds = idsForTags(bpmn, "sequenceFlow");
+  assert(sequenceFlowIds.length > 0, "expected the compiled graph to contain sequence flows");
+  const edgeless = sequenceFlowIds.filter(
+    (id) => !new RegExp(`<bpmndi:BPMNEdge[^>]*bpmnElement="${escapeRe(id)}"`).test(bpmn),
+  );
+  assertEquals(edgeless, [], `every sequence flow must have a BPMNEdge; missing: ${JSON.stringify(edgeless)}`);
+});
+
+/** Escape a BPMN element id for embedding in a RegExp (ids can contain `.` from fact-qualified names). */
+function escapeRe(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/app/featureReadModel.test.ts

@@ -10,13 +10,16 @@
 // datasource on a terminated instance — bypassing the gateway and freezing the display columns.
 // 073_feature_read_model.sql retires the write-time projection: the derived columns are now a VIEW
 // over each row's own `status`/`pr_key`/`converge`/`auto_merge`/`acknowledged_at`, so there is no
-// stored column and no write-path for any writer to leave stale.
+// stored column and no write-path for any writer to leave stale. 075_feature_read_model_attention_
+// from_user_tasks.sql then moves `attention` off the drift-prone `status` variable onto ENGINE TRUTH
+// — an OPEN `feature-blocked`/`feature-escalation` row in the `user_tasks` inbox (issue #422).
 //
-// This exercises the REAL SQLite view (073 applied to an in-memory DB, mirroring
+// This exercises the REAL SQLite view (073+075 applied to an in-memory DB, mirroring
 // app/plansReadModel.test.ts / app/mergesPerDayView.test.ts) and pins that its CASE expressions
-// reproduce `deriveStage` / `deriveListBucket` EXACTLY over the full status matrix — the SAME pure
-// helpers the acknowledge operations guard on — plus a RED/GREEN guard reproducing the reconciler
-// bypass: a RAW-datasource `status` write must leave the projection correct.
+// reproduce `deriveStage` / `deriveListBucket` EXACTLY over the full status × open-task matrix — the
+// SAME pure helpers the acknowledge operations guard on — plus RED/GREEN guards reproducing the
+// reconciler bypass (a RAW-datasource `status` write must leave the projection correct) and the #422
+// answered-escalation drift (a sticky `status='escalated'` with no open task must show no ⚠).
 import { readFileSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import { test } from "node:test";
@@ -40,10 +43,27 @@ function viewDb(): DatabaseSync {
        outcome TEXT, delivery_label TEXT, acknowledged_at TEXT, created_at TEXT, updated_at TEXT,
        stage TEXT, stage_state TEXT, stage_skipped TEXT, attention TEXT, list_bucket TEXT);`,
   );
+  // The `user_tasks` inbox (034_user_tasks_inbox.sql) — the engine-truth source the 075 VIEW derives
+  // `attention` from (a row IFF an escalation user task is OPEN). Minimal shape: the three columns the
+  // correlated EXISTS lookups read, plus its PK.
+  db.exec(
+    `CREATE TABLE user_tasks (
+       user_task_key TEXT PRIMARY KEY, element_id TEXT NOT NULL, subject_type TEXT NOT NULL,
+       subject_key TEXT NOT NULL);`,
+  );
   db.exec(MIG("073_feature_read_model.sql"));
+  db.exec(MIG("075_feature_read_model_attention_from_user_tasks.sql"));
   return db;
 }
 
+// Simulate `pollUserTasks` opening one native user task for a feature run: the presence of this row is
+// the engine truth the VIEW's `attention` derives from (its deletion = the task answered/closed).
+function openUserTask(db: DatabaseSync, feature_key: string, element_id: "feature-escalation" | "feature-blocked"): void {
+  db.prepare(
+    "INSERT INTO user_tasks (user_task_key, element_id, subject_type, subject_key) VALUES (?, ?, 'feature', ?)",
+  ).run(`${feature_key}:${element_id}`, element_id, feature_key);
+}
+
 interface SampleRun {
   status: string;
   pr_key?: string | null;
@@ -94,34 +114,51 @@ function projection(db: DatabaseSync, feature_key: string): Record<string, unkno
   return { ...r };
 }
 
-test("feature_read_model derives stage/stage_state/stage_skipped/attention EXACTLY like deriveStage, over every status × converge/auto_merge/pr_key combination", () => {
+test("feature_read_model derives stage/stage_state/stage_skipped/attention EXACTLY like deriveStage, over every status × converge/auto_merge/pr_key × open-task combination", () => {
   const db = viewDb();
-  const cases: Array<{ key: string; run: SampleRun }> = [];
+  const cases: Array<{ key: string; run: SampleRun; hasOpenBlockedTask: boolean; hasOpenEscalationTask: boolean }> = [];
   let i = 0;
   for (const status of FEATURE_RUN_STATUSES) {
     for (const converge of [0, 1]) {
       for (const auto_merge of [0, 1]) {
         for (const pr_key of [null, `o/r#pr${i}`]) {
-          const key = `o/r#${i++}`;
-          cases.push({ key, run: { status, converge, auto_merge, pr_key } });
-          addRun(db, key, { status, converge, auto_merge, pr_key });
+          // The open-task dimension only matters for the two human-wait statuses (escalated/
+          // awaiting_operator), whose derivation reads open tasks — for them exercise BOTH
+          // task-present and task-absent (the #422 drift case = the task already gone). Every other
+          // status ignores open tasks (`el` is null, so no task is ever created), so iterating the
+          // dimension there would only duplicate identical cases; iterate [false] alone.
+          const el = status === "escalated" ? "feature-escalation" : status === "awaiting_operator" ? "feature-blocked" : null;
+          for (const openTask of el !== null ? [false, true] : [false]) {
+            const key = `o/r#${i++}`;
+            const hasTask = openTask && el !== null;
+            cases.push({
+              key,
+              run: { status, converge, auto_merge, pr_key },
+              hasOpenBlockedTask: hasTask && el === "feature-blocked",
+              hasOpenEscalationTask: hasTask && el === "feature-escalation",
+            });
+            addRun(db, key, { status, converge, auto_merge, pr_key });
+            if (hasTask && el !== null) openUserTask(db, key, el);
+          }
         }
       }
     }
   }
 
-  for (const { key, run } of cases) {
+  for (const { key, run, hasOpenBlockedTask, hasOpenEscalationTask } of cases) {
     const oracle = deriveStage({
       status: run.status,
       pr_key: run.pr_key ?? null,
       converge: run.converge ?? 0,
       auto_merge: run.auto_merge ?? 0,
+      hasOpenBlockedTask,
+      hasOpenEscalationTask,
     });
     const row = projection(db, key);
     assertEquals(row.stage, oracle.stage, `${key} (status=${run.status}): stage`);
     assertEquals(row.stage_state, oracle.state, `${key} (status=${run.status}): stage_state`);
     assertEquals(row.stage_skipped, oracle.skipped, `${key} (status=${run.status}): stage_skipped`);
-    assertEquals(row.attention, oracle.attention, `${key} (status=${run.status}): attention`);
+    assertEquals(row.attention, oracle.attention, `${key} (status=${run.status}, openBlocked=${hasOpenBlockedTask}, openEsc=${hasOpenEscalationTask}): attention`);
   }
 });
 
@@ -162,6 +199,37 @@ test("feature_read_model IGNORES any stale STORED projection columns — it read
   });
 });
 
+test("RED/GREEN GUARD #422: an ANSWERED escalation (status sticky 'escalated', no open user task) shows NO ⚠; the badge tracks the OPEN task, not status", () => {
+  // The `feature` process answer-loop returns the token to `implement-task` without resetting the
+  // `status` variable, so a run whose escalation was already answered still reads `status="escalated"`
+  // until its next agent job completes (observed live on merlin: feature instance 31779). The OLD VIEW
+  // derived `attention` from that value and rendered a stale ⚠ on Overview. The badge now derives from
+  // engine truth — the presence of an OPEN `feature-escalation` user task (`pollUserTasks` deletes the
+  // row the moment it is answered) — so it clears immediately regardless of the stale status.
+  const db = viewDb();
+
+  // Answered escalation: status STILL 'escalated' (stale) + a stored ⚠ that lied, but NO open task.
+  addRun(db, "o/r#answered", { status: "escalated", stored: { attention: "⚠", stage: "Implementing" } });
+  const answered = projection(db, "o/r#answered");
+  assertEquals(answered.attention, null, "the stale ⚠ is gone once the escalation task is closed");
+  assertEquals(answered.stage, "Implementing", "the run is back implementing (stage unchanged, correct either way)");
+
+  // Genuinely-parked escalation: the SAME status, but its `feature-escalation` user task is OPEN → ⚠.
+  addRun(db, "o/r#parked", { status: "escalated" });
+  openUserTask(db, "o/r#parked", "feature-escalation");
+  assertEquals(projection(db, "o/r#parked").attention, "⚠", "an OPEN escalation task shows ⚠");
+
+  // Answering it (deleting the row — what `pollUserTasks` does) clears the badge with status untouched.
+  db.prepare("DELETE FROM user_tasks WHERE subject_key = ?").run("o/r#parked");
+  assertEquals(projection(db, "o/r#parked").attention, null, "closing the task clears ⚠ though status is still 'escalated'");
+
+  // Symmetric operator/blocked wait: 'blocked' glyph IFF an open `feature-blocked` task exists.
+  addRun(db, "o/r#stuck", { status: "awaiting_operator", stored: { attention: "blocked" } });
+  assertEquals(projection(db, "o/r#stuck").attention, null, "no open feature-blocked task → no glyph despite awaiting_operator");
+  openUserTask(db, "o/r#stuck", "feature-blocked");
+  assertEquals(projection(db, "o/r#stuck").attention, "blocked", "an OPEN feature-blocked task shows the blocked glyph");
+});
+
 test("RED/GREEN GUARD: a RAW-datasource feature_runs.status write (the instanceTracking reconciler bypass) leaves the projection CORRECT (stage=Done, terminal stage_state, attention=null, Dismiss renderable, still Active)", () => {
   // Reproduce the framework `instanceTracking` reconciler class of bug: on a terminated (cancelled)
   // process instance it writes `{status:"abandoned"}` to `feature_runs` through the RAW datasource,

package/app/github.test.ts

@@ -663,6 +663,40 @@ for (const c of TOKEN_MODE) {
   });
 }
 
+// ── Draft PRs are never landable (issue #454) ────────────────────────────────────────────────────
+//
+// A draft PR with green checks reports `mergeStateStatus: CLEAN`, so the old `mergeStateStatus`
+// switch classified it `"ready"` → the poller attempted the merge → GitHub refused it (draft) → a
+// misleading "the merge attempt did not land (result: blocked), investigate why GitHub refused"
+// escalation. A draft is *categorically* not landable regardless of checks, and the remedy is
+// always the same (mark it ready), so `isDraft` outranks every other signal and yields a
+// first-class `"draft"` verdict the model can escalate with an actionable message.
+test("classifyMergeability: a draft PR is never ready — even with green checks (issue #454)", () => {
+  // CLEAN + green rollup would be `"ready"` if `isDraft` were ignored.
+  assertEquals(classifyMergeability(mergePrState({ mergeStateStatus: "CLEAN", isDraft: true })), "draft");
+  assertEquals(
+    classifyMergeability(
+      mergePrState({ mergeStateStatus: "CLEAN", isDraft: true, rollup: [{ name: "build", conclusion: "SUCCESS" }] }),
+      protocolWith({ requiredChecks: reqChecks("build") }),
+    ),
+    "draft",
+  );
+});
+
+test("classifyMergeability: draft outranks every mergeStateStatus (issue #454)", () => {
+  for (const status of ["CLEAN", "HAS_HOOKS", "UNSTABLE", "BEHIND", "DIRTY", "BLOCKED", "UNKNOWN", ""]) {
+    assertEquals(
+      classifyMergeability(prState({ mergeStateStatus: status, isDraft: true })),
+      "draft",
+      `draft should outrank ${status || "''"}`,
+    );
+  }
+});
+
+test("classifyMergeability: a non-draft PR is unaffected (regression guard, issue #454)", () => {
+  assertEquals(classifyMergeability(prState({ mergeStateStatus: "CLEAN", isDraft: false })), "ready");
+});
+
 // `checkConclusions` must report a terminal conclusion per check but normalise a STILL-IN-FLIGHT run
 // to "" for BOTH rollup shapes — a CheckRun whose `status` is not COMPLETED, and a legacy
 // StatusContext whose `state` is PENDING/EXPECTED — so a caller never mistakes a pending

package/app/github.ts

@@ -954,9 +954,11 @@ export async function baseBranchLanded(
 }
 
 /** A settled landability verdict, or `waiting` when GitHub hasn't determined it yet (or is
- * still running checks / awaiting review). The poller only advances the process on a settled
- * verdict; `waiting` means re-poll later. */
-export type Mergeability = "ready" | "waiting" | "conflict" | "blocked";
+ * still running checks / awaiting review). `draft` is a settled *not-landable* verdict: a draft PR
+ * can never be merged (GitHub refuses it outright), regardless of its checks — so it outranks every
+ * other signal and carries its own actionable remedy (mark it ready). The poller only advances the
+ * process on a settled verdict; `waiting` means re-poll later. */
+export type Mergeability = "ready" | "waiting" | "conflict" | "blocked" | "draft";
 
 /** Intersect a repo's declared `requiredChecks` against the head's actual per-check conclusions —
  * an INDEPENDENT backstop that runs BEFORE the `mergeStateStatus` switch, so nwf never merges a red
@@ -1009,6 +1011,13 @@ function requiredChecksVerdict(s: PrState, protocol?: MergeProtocol): "blocked"
 }
 
 export function classifyMergeability(s: PrState, protocol?: MergeProtocol): Mergeability {
+  // A draft PR is NEVER landable — GitHub refuses the merge outright, whatever its checks say — so
+  // draft outranks every other signal (issue #454). Surface it as a first-class verdict rather than
+  // letting a green draft read as `CLEAN` → `"ready"` → an attempted merge that GitHub blocks with an
+  // opaque "the merge did not land (blocked)" escalation. The remedy is always the same: mark it
+  // ready. The poller self-heals this (mark-ready) when the repo's protocol wants a fresh head run,
+  // else escalates with an actionable message.
+  if (s.isDraft) return "draft";
   // Protocol-aware backstop FIRST (issue #392): honour the repo's declared `requiredChecks`
   // against the actual head rollup, so an `UNSTABLE` PR with a red DECLARED-required
   // check is no longer blindly `ready`. This never weakens GitHub branch protection (the switch

package/app/maybeEnsureFreshHeadRun.test.ts

@@ -0,0 +1,150 @@
+// Regression guard for the frugal-CI self-heal escalation fall-through (PR #455 review).
+//
+// `maybeEnsureFreshHeadRun` gates the `"draft"` merge branch: the poller `continue`s (re-polls)
+// when it returns `true`, and falls through to the actionable "mark it ready" escalation when it
+// returns `false`. The bug: it returned `true` whenever an action was *selected*, even if
+// `ensureFreshHeadRun` FAILED (`ok === false`, e.g. missing permission / repo policy). A draft PR
+// whose self-heal can never succeed would then `continue` forever, re-attempting `gh pr ready`/
+// reopen every pass and never escalating to a human. The fix returns `ok`, so a persistently
+// failing self-heal falls through to escalation. These tests pin: return value tracks `ok`;
+// persistence (`fresh_head_run_head`) happens only on success; and no action → no attempt.
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import type { DataLayer } from "@nanobpm/urban";
+import type { PrState } from "./github.ts";
+import { parseMergeProtocol } from "./mergeProtocol.ts";
+import { maybeEnsureFreshHeadRun, type PullRequest } from "./service.ts";
+
+const READY = parseMergeProtocol({ freshHeadRun: "ready", land: { method: "gh-merge" } });
+
+function memData(seed: PullRequest): { data: DataLayer; row: () => PullRequest } {
+  const rows: PullRequest[] = [{ ...seed }];
+  const table = {
+    async update(id: string, patch: Partial<PullRequest>) {
+      const r = rows.find((x) => x.pr_key === id);
+      if (r) Object.assign(r, patch);
+    },
+  };
+  const data = { table: () => table } as unknown as DataLayer;
+  return { data, row: () => rows[0] };
+}
+
+function draftState(overrides: Partial<PrState> = {}): PrState {
+  return {
+    merged: false,
+    state: "open",
+    mergeStateStatus: "DRAFT",
+    failingChecks: 0,
+    failingCheckNames: [],
+    totalChecks: 0, // no head run yet → frugal-CI stuck state
+    presentCheckNames: [],
+    pendingCheckNames: [],
+    checkConclusions: {},
+    isDraft: true,
+    headRefOid: "h1",
+    ...overrides,
+  };
+}
+
+function prRow(overrides: Partial<PullRequest> = {}): PullRequest {
+  return {
+    pr_key: "o/r#1",
+    repo: "o/r",
+    number: 1,
+    url: "https://github.com/o/r/pull/1",
+    title: "t",
+    status: "waiting_merge",
+    current_round: 0,
+    process_key: null,
+    waiting_since: null,
+    last_review_id: null,
+    outcome: null,
+    created_at: "t",
+    updated_at: "t",
+    converged_at: null,
+    merged_at: null,
+    active_worker: null,
+    lease_until: null,
+    last_nudge_at: null,
+    fresh_head_run_head: null,
+    abandon_token: null,
+    incident_key: null,
+    incident_message: null,
+    root_request_key: null,
+    ...overrides,
+  };
+}
+
+test("maybeEnsureFreshHeadRun: successful self-heal returns true and records the head", async () => {
+  const { data, row } = memData(prRow());
+  const ret = await maybeEnsureFreshHeadRun(
+    data,
+    "o/r",
+    1,
+    "o/r#1",
+    READY,
+    "draft",
+    draftState(),
+    prRow(),
+    async () => true,
+  );
+  assertEquals(ret, true); // caller re-polls
+  assertEquals(row().fresh_head_run_head, "h1"); // one-shot de-dupe recorded
+});
+
+test("maybeEnsureFreshHeadRun: FAILED self-heal returns false so the draft branch escalates", async () => {
+  const { data, row } = memData(prRow());
+  const ret = await maybeEnsureFreshHeadRun(
+    data,
+    "o/r",
+    1,
+    "o/r#1",
+    READY,
+    "draft",
+    draftState(),
+    prRow(),
+    async () => false, // ensureFreshHeadRun could not perform the action (e.g. permission)
+  );
+  assertEquals(ret, false); // caller falls through to the actionable escalation
+  assertEquals(row().fresh_head_run_head, null); // not recorded → not a wasted one-shot
+});
+
+test("maybeEnsureFreshHeadRun: a throwing self-heal is caught and returns false", async () => {
+  const { data, row } = memData(prRow());
+  const ret = await maybeEnsureFreshHeadRun(
+    data,
+    "o/r",
+    1,
+    "o/r#1",
+    READY,
+    "draft",
+    draftState(),
+    prRow(),
+    async () => {
+      throw new Error("boom");
+    },
+  );
+  assertEquals(ret, false);
+  assertEquals(row().fresh_head_run_head, null);
+});
+
+test("maybeEnsureFreshHeadRun: no applicable action never attempts the self-heal and returns false", async () => {
+  const { data } = memData(prRow());
+  let attempted = false;
+  const ret = await maybeEnsureFreshHeadRun(
+    data,
+    "o/r",
+    1,
+    "o/r#1",
+    READY,
+    "draft",
+    draftState({ totalChecks: 1 }), // required run already present → no action selected
+    prRow(),
+    async () => {
+      attempted = true;
+      return true;
+    },
+  );
+  assertEquals(ret, false);
+  assert(!attempted, "must not attempt a self-heal when no action applies");
+});

package/app/mergeEscalationQuestion.test.ts

@@ -155,3 +155,36 @@ test("regression: a question-less escalation can no longer park a dead wait-merg
     "merge-esc-attempt must NOT flow directly into wait-merge-answer (the #329 dead-wait defect)",
   );
 });
+
+// ── Draft PR escalation (issue #454) ─────────────────────────────────────────────────────────────
+//
+// A draft PR is never landable — `classifyMergeability` now yields a first-class `"draft"` verdict
+// (app/github.ts) that the poller (app/service.ts) publishes as `mergeState = "draft"`. It routes
+// through `gw-mergeable`'s default (`f_m_mBlocked → merge-esc-conflict`), so `merge-esc-conflict`'s
+// question must recognise `draft` and give the ACTIONABLE remedy (mark it ready) instead of the
+// generic "resolve the conflict or failing required check" text (which is the wrong remedy for a
+// draft), and — before this fix — instead of `merge-esc-attempt`'s misleading "the merge attempt did
+// not land (blocked), investigate why GitHub refused the merge".
+const escConflictRaw = flat.match(/<bpmn:serviceTask\b[^>]*\bid="merge-esc-conflict"[\s\S]*?<\/bpmn:serviceTask>/);
+const escConflict = escConflictRaw ? escConflictRaw[0].replace(/&#34;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&") : null;
+
+test("merge-esc-conflict gives a draft PR an actionable 'mark it ready' question (issue #454)", () => {
+  assert(escConflict, "merge-esc-conflict service task must exist");
+  const el = escConflict!;
+  // Branches on the draft verdict…
+  assertStringIncludes(el, 'mergeState = "draft"', "merge-esc-conflict must branch on the draft verdict");
+  // …with the actionable remedy (mark it ready), not the conflict/failing-check remedy.
+  assertStringIncludes(el, "draft and can't be merged", "the draft question must state the PR is in draft");
+  assertStringIncludes(el, "gh pr ready", "the draft question must tell the human to mark it ready");
+});
+
+test("merge-esc-conflict keeps the non-draft not-mergeable branch intact (regression guard, issue #454)", () => {
+  assert(escConflict, "merge-esc-conflict service task must exist");
+  const el = escConflict!;
+  // The original conflict/failing-check message must still be reachable for non-draft states.
+  assertStringIncludes(el, "This PR is not mergeable (state:", "the non-draft not-mergeable message must remain");
+  // The draft branch must precede the generic message so it isn't shadowed.
+  const draftIdx = el.indexOf('mergeState = "draft"');
+  const genericIdx = el.indexOf("This PR is not mergeable (state:");
+  assert(draftIdx !== -1 && genericIdx !== -1 && draftIdx < genericIdx, "the draft branch must be evaluated before the generic not-mergeable message");
+});

package/app/mergeProtocol.test.ts

@@ -114,6 +114,31 @@ test("freshHeadRunAction: fires in the frugal-CI stuck state (no run + waiting)"
   assertEquals(freshHeadRunAction(NANO, "waiting", 0, true), "ready");
 });
 
+test("freshHeadRunAction: a 'draft' verdict self-heals like waiting (issue #454)", () => {
+  // The merge poller now classifies a draft PR as the distinct "draft" verdict (not "waiting"),
+  // so guard that the fresh-head-run self-heal accepts it directly. A draft is always isDraft=true.
+  assertEquals(freshHeadRunAction(NANO, "draft", 0, true), "ready"); // no run yet → mark ready (un-drafts + runs)
+  assertEquals(freshHeadRunAction(NANO, "draft", 1, true), null); // required run already present → wait
+  assertEquals(freshHeadRunAction(NANO, "draft", -1, true), null); // token mode (unknown) → conservative
+  // fires once per landing-attempt head, then not again until the head changes (post-rebase)
+  assertEquals(
+    freshHeadRunAction(NANO, "draft", 0, true, { headRefOid: "h1", lastActionHeadRefOid: null }),
+    "ready",
+  );
+  assertEquals(
+    freshHeadRunAction(NANO, "draft", 0, true, { headRefOid: "h1", lastActionHeadRefOid: "h1" }),
+    null,
+  );
+  // reopen-only protocol: a draft yields NULL, not "reopen". Reopening (close+reopen) does NOT
+  // un-draft a PR, so a "reopen" self-heal can never resolve the draft-merge failure — it only
+  // emits noisy close/reopen events and delays the actionable escalation by a round (issue #454).
+  // With no mark-ready capability there is no valid draft self-heal, so escalate immediately.
+  const reopenOnly = parseMergeProtocol({ freshHeadRun: "reopen", land: { method: "gh-merge" } });
+  assertEquals(freshHeadRunAction(reopenOnly, "draft", 0, true), null);
+  // none protocol → no self-heal for a draft either
+  assertEquals(freshHeadRunAction(DEFAULT_MERGE_PROTOCOL, "draft", 0, true), null);
+});
+
 test("freshHeadRunAction: fires once per landing-attempt head, then re-fires after rebase", () => {
   assertEquals(
     freshHeadRunAction(NANO, "waiting", 0, false, { headRefOid: "h1", lastActionHeadRefOid: null }),

package/app/mergeProtocol.ts

@@ -241,23 +241,29 @@ export function headRunPresenceCount(
  * same head already got its nudge, this returns `null`, so the poller never re-triggers inside one
  * landing attempt. A rebase changes `headRefOid`, so the decision is re-derived and can fire again
  * for the fresh post-rebase head. A genuinely-failing check (`blocked`) is left to the fix-ci arm,
- * a conflict (`conflict`) to the rebase arm (#42). */
+ * a conflict (`conflict`) to the rebase arm (#42). A `draft` verdict (issue #454) is treated like
+ * `waiting` here so the `freshHeadRun: "ready"`/`"ready-or-reopen"` self-heal still marks a draft
+ * ready (which both un-drafts it and produces the required run). But a `"reopen"` action is
+ * **never** returned for a draft: reopening (close+reopen) does not un-draft a PR, so it can never
+ * resolve the draft-merge failure — it only emits noisy close/reopen events and delays the poller's
+ * actionable escalation. When no mark-ready self-heal applies to a draft, this returns `null` and the
+ * poller escalates immediately. */
 export function freshHeadRunAction(
   protocol: MergeProtocol,
-  verdict: "ready" | "waiting" | "conflict" | "blocked",
+  verdict: "ready" | "waiting" | "conflict" | "blocked" | "draft",
   headRunCount: number,
   isDraft: boolean,
   attempt: FreshHeadRunAttempt = {},
 ): "ready" | "reopen" | null {
   if (protocol.freshHeadRun === "none") return null;
-  if (verdict !== "waiting") return null; // ready = go land; blocked/conflict = other arms
+  if (verdict !== "waiting" && verdict !== "draft") return null; // ready = go land; blocked/conflict = other arms
   if (headRunCount !== 0) return null; // required run already present (or unknown in token mode) → wait
   if (attempt.headRefOid && attempt.headRefOid === attempt.lastActionHeadRefOid) return null;
   switch (protocol.freshHeadRun) {
     case "ready":
       return isDraft ? "ready" : null;
     case "reopen":
-      return "reopen";
+      return isDraft ? null : "reopen";
     case "ready-or-reopen":
       return isDraft ? "ready" : "reopen";
     default:

package/app/pollUserTasks.test.ts

@@ -584,3 +584,30 @@ test("pollUserTasks (engine-first): a delivery-human task on an UNTRACKED run st
   assertEquals(byKey["35002"].subject_type, "delivery");
   assertEquals(byKey["35002"].subject_key, "dg-9"); // instance fallback — non-blank so it renders
 });
+
+test("pollUserTasks (typed-seam fallback): projects an inlined delivery-human task on a RUNNING run, bucketed `delivery` (issue #442)", async () => {
+  // The reduced-capability host (no raw-REST surface) discovers open tasks by scanning each active
+  // subject's instance through the typed `openUserTasks` seam. A delivery-graph `human` node parks on its
+  // RUNNING run's instance, so that instance MUST be scanned here too — else the inlined
+  // `delivery-human-task__<node>` gate is dropped on this path even though its leak guard would accept it.
+  // Guards the OTHER discovery path the engine-first sweep tests don't reach.
+  const { data, stores } = memData({
+    delivery_graph_runs: [
+      { run_key: "delivery-graph-403eb22e", process_key: "dg-1", status: "running", title: "release runbook" },
+      { run_key: "delivery-graph-pending", process_key: null, status: "awaiting-approval", title: "not launched yet" },
+    ],
+  });
+  const engine = fakeEngine({
+    "dg-1": [{ userTaskKey: "35002", elementId: "delivery-human-task__n1" }],
+  });
+
+  await pollUserTasks(data, engine); // no engineRest → typed-seam fallback
+
+  const byKey = Object.fromEntries((stores.user_tasks ?? []).map((r) => [r.user_task_key, r]));
+  assertEquals(Object.keys(byKey), ["35002"]);
+  assertEquals(byKey["35002"].element_id, "delivery-human-task__n1");
+  assertEquals(byKey["35002"].kind_label, "Delivery: human step");
+  assertEquals(byKey["35002"].subject_type, "delivery");
+  assertEquals(byKey["35002"].subject_key, "delivery-graph-403eb22e");
+  assertEquals(byKey["35002"].subject_title, "release runbook");
+});

package/app/service.ts

@@ -51,7 +51,12 @@ import {
 } from "./github.ts";
 import { pollLineage } from "./lineage.ts";
 import { mergeLanes, readExclusions } from "./mergeExclusion.ts";
-import { freshHeadRunAction, headRunPresenceCount, loadMergeProtocol } from "./mergeProtocol.ts";
+import {
+  freshHeadRunAction,
+  headRunPresenceCount,
+  loadMergeProtocol,
+  type MergeProtocol,
+} from "./mergeProtocol.ts";
 import { type PrLaneDecision, planPrLane, taskDependencyDepths } from "./mergeTrain.ts";
 import {
   capabilityGates,
@@ -178,7 +183,7 @@ export const MERGE_ADMIN = ["1", "true", "on", "yes"].includes(
 
 const now = () => new Date().toISOString();
 
-interface PullRequest {
+export interface PullRequest {
   pr_key: string;
   repo: string;
   number: number;
@@ -1099,6 +1104,41 @@ async function advanceIfTerminalOutOfBand(
   return true;
 }
 
+/** Frugal-CI fresh-head-run self-heal, shared by the `"waiting"` and `"draft"` merge verdicts
+ * (issue #454). Both verdicts feed the same {@link freshHeadRunAction} decision — when the repo's
+ * merge protocol wants a fresh head run and this head has not been nudged yet, produce one
+ * (mark-ready / reopen) and record the head so we fire at most once per landing attempt. Returns
+ * `true` only when the self-heal was **actually applied** (the caller should re-poll); returns
+ * `false` when no self-heal applies **or** the action was selected but failed (`ok === false`, e.g.
+ * missing permission / repo policy) — so a caller that gates escalation on this (the `"draft"`
+ * branch) falls through to the actionable escalation instead of `continue`-looping forever on a
+ * self-heal that can never succeed. One implementation so the two verdicts can never drift (attempt
+ * de-dupe, persistence, logging). `ensure` is injectable for tests; production uses the real
+ * {@link ensureFreshHeadRun}. */
+export async function maybeEnsureFreshHeadRun(
+  data: DataLayer,
+  repo: string,
+  number: number,
+  prKey: string,
+  protocol: MergeProtocol,
+  verdict: "ready" | "waiting" | "conflict" | "blocked" | "draft",
+  st: PrState,
+  pr: PullRequest,
+  ensure: typeof ensureFreshHeadRun = ensureFreshHeadRun,
+): Promise<boolean> {
+  const action = freshHeadRunAction(protocol, verdict, headRunPresenceCount(protocol, st), st.isDraft, {
+    headRefOid: st.headRefOid,
+    lastActionHeadRefOid: pr.fresh_head_run_head,
+  });
+  if (!action) return false;
+  const ok = await ensure(repo, number, action).catch(() => false);
+  if (ok && st.headRefOid) {
+    await prs(data).update(prKey, { fresh_head_run_head: st.headRefOid, updated_at: now() });
+  }
+  console.log(`[poller] ${verdict} -> fresh head run (${action}) ${ok ? "requested" : "skipped"} -> ${prKey}`);
+  return ok;
+}
+
 /** Merge-stage poll pass (SPEC §11). Four durable waits, each keyed off the PR's `status`, are
  * advanced by correlating a message — mirroring the review-ready pattern so the process owns
  * the wait and this glue only signals when a GitHub condition is met:
@@ -1159,6 +1199,35 @@ export async function pollMerges(data: DataLayer, engine: EngineClient, token: s
       // the PR as UNSTABLE. The same handle is reused by the frugal-CI fresh-head-run branch below.
       const protocol = await loadMergeProtocol(repo, token).catch(() => null);
       const verdict = classifyMergeability(st, protocol ?? undefined);
+      if (verdict === "draft") {
+        // A draft PR is never landable — GitHub refuses the merge outright (issue #454). Two remedies,
+        // in order: (1) self-heal — when the repo's merge protocol has a mark-ready capability
+        // (`freshHeadRun: "ready"`/`"ready-or-reopen"`), mark the PR ready ourselves (the frugal-CI
+        // path), which both un-drafts it and produces the required run, then re-poll; a `"reopen"`-only
+        // protocol has NO mark-ready capability, so `freshHeadRunAction` returns null for a draft (a
+        // reopen can't un-draft) and this falls straight through to (2). (2) otherwise — no self-heal
+        // applies, OR the self-heal was attempted but could not be performed (e.g. missing permission /
+        // repo policy) — escalate with an ACTIONABLE "mark it ready" message, instead of
+        // `continue`-looping forever on a self-heal that can never succeed or surfacing GitHub's opaque
+        // "blocked" refusal.
+        if (protocol) {
+          if (await maybeEnsureFreshHeadRun(data, repo, number, prKey, protocol, verdict, st, pr)) {
+            continue; // re-poll: the mark-ready both un-drafts the PR and produces the required run
+          }
+        }
+        // No applicable (or successful) protocol-driven self-heal → escalate so a human marks it ready.
+        await flipToMergingThenPublish(data, engine, prKey, "waiting_merge", {
+          name: "merge-ready",
+          correlationKey: prKey,
+          variables: {
+            mergeState: verdict, // "draft" → gw-mergeable default → merge-esc-conflict (draft-aware FEEL)
+            failingChecks: st.failingChecks,
+            failingChecksList: st.failingCheckNames.join("\n"),
+          },
+        });
+        console.log(`[poller] draft (no self-heal) -> escalate mark-ready -> ${prKey}`);
+        continue;
+      }
       if (verdict === "waiting") {
         // Frugal-CI remedy (#43): when the repo publishes a merge protocol that wants a fresh
         // head run and the PR has NO required head run yet, review has converged but the last push
@@ -1170,17 +1239,7 @@ export async function pollMerges(data: DataLayer, engine: EngineClient, token: s
         // `headRefOid`, so downstream merge-train PRs get a new nudge after every post-rebase
         // landing attempt.
         if (protocol) {
-          const action = freshHeadRunAction(protocol, verdict, headRunPresenceCount(protocol, st), st.isDraft, {
-            headRefOid: st.headRefOid,
-            lastActionHeadRefOid: pr.fresh_head_run_head,
-          });
-          if (action) {
-            const ok = await ensureFreshHeadRun(repo, number, action).catch(() => false);
-            if (ok && st.headRefOid) {
-              await prs(data).update(prKey, { fresh_head_run_head: st.headRefOid, updated_at: now() });
-            }
-            console.log(`[poller] fresh head run (${action}) ${ok ? "requested" : "skipped"} -> ${prKey}`);
-          }
+          await maybeEnsureFreshHeadRun(data, repo, number, prKey, protocol, verdict, st, pr);
         }
         continue; // GitHub still computing / checks pending
       }
@@ -2381,6 +2440,11 @@ export async function pollUserTasks(
     for (const status of PLAN_ACTIVE_STATUSES) for (const plan of await plans(data).find({ status })) await scanInstance(plan.process_key);
     for (const status of PR_ACTIVE_STATUSES) for (const pr of await prs(data).find({ status })) await scanInstance(pr.process_key);
     for (const review of await activeConformanceReviews(data)) await scanInstance(review.process_key);
+    // A delivery-graph `human` node parks on its RUNNING run's engine instance (an awaiting-approval run
+    // has no instance yet — mirrors `pollDeliveryGraphPhase`). Scan it too so the inlined
+    // `delivery-human-task__<node>` gate surfaces on this reduced-capability path exactly as it does on
+    // the engine-first sweep — otherwise the typed-seam host silently drops every delivery human gate.
+    for (const run of await deliveryGraphRuns(data).find({ status: "running" })) await scanInstance(run.process_key);
   }
 
   const desired = [...desiredByKey.values()];

package/app/stage.test.ts

@@ -68,14 +68,28 @@ test("skipped: the three converge/auto_merge cases", () => {
   assertEquals(deriveStage(base({ status: "running", converge: 1, auto_merge: 1 })).skipped, "");
 });
 
-test("attention: derives from status alone (blocked, escalation, none)", () => {
-  // Issue #332 dropped the denormalised escalation pointer/question columns; `attention` is now a pure
-  // function of `status` — `awaiting_operator` (a parked blocked run) → "blocked", `escalated` → "⚠".
-  assertEquals(deriveStage(base({ status: "awaiting_operator" })).attention, "blocked");
-  assertEquals(deriveStage(base({ status: "escalated" })).attention, "⚠");
+test("attention: derives from OPEN user-task engine truth (blocked, escalation, none), NOT from status", () => {
+  // Issue #422: `attention` is a pure function of whether an OPEN native user task exists for the run
+  // (the `user_tasks` inbox — the authoritative "who is waiting on a human" set), never of the sticky
+  // `status` variable. An open `feature-blocked` task → "blocked"; an open `feature-escalation` task → "⚠".
+  assertEquals(deriveStage(base({ status: "awaiting_operator", hasOpenBlockedTask: true })).attention, "blocked");
+  assertEquals(deriveStage(base({ status: "escalated", hasOpenEscalationTask: true })).attention, "⚠");
   assertEquals(deriveStage(base({ status: "running" })).attention, null);
 });
 
+test("attention #422: an ANSWERED escalation (status still 'escalated' but NO open task) shows NO badge", () => {
+  // The answer-loop returns the token to `implement-task` with no status reset, so `status` reads a
+  // stale "escalated" while the escalation user task is already gone. Sourcing the badge from engine
+  // truth (no open task) clears the ⚠ — the drift the old `status`-derived badge produced.
+  assertEquals(deriveStage(base({ status: "escalated" })).attention, null);
+  assertEquals(deriveStage(base({ status: "escalated", hasOpenEscalationTask: false })).attention, null);
+  // And an escalated run WHOSE task is genuinely open still shows ⚠.
+  assertEquals(deriveStage(base({ status: "escalated", hasOpenEscalationTask: true })).attention, "⚠");
+  // Symmetrically for the blocked/operator wait.
+  assertEquals(deriveStage(base({ status: "awaiting_operator" })).attention, null);
+  assertEquals(deriveStage(base({ status: "awaiting_operator", hasOpenBlockedTask: true })).attention, "blocked");
+});
+
 // The three parked-status rows called out by the plan review.
 test("escalated WITH pr_key → PR open / null", () => {
   const d = deriveStage(base({ status: "escalated", pr_key: "o/r#5" }));
@@ -89,8 +103,8 @@ test("escalated WITHOUT pr_key → Implementing / null", () => {
   assertEquals(d.state, null);
 });
 
-test("awaiting_operator WITHOUT pr_key → Implementing / null, attention 'blocked' when parked", () => {
-  const d = deriveStage(base({ status: "awaiting_operator", pr_key: null }));
+test("awaiting_operator WITHOUT pr_key → Implementing / null, attention 'blocked' when its task is open", () => {
+  const d = deriveStage(base({ status: "awaiting_operator", pr_key: null, hasOpenBlockedTask: true }));
   assertEquals(d.stage, "Implementing");
   assertEquals(d.state, null);
   assertEquals(d.attention, "blocked");

package/app/stage.ts

@@ -43,6 +43,14 @@ export interface StageInput {
   pr_key?: string | null;
   converge?: number | boolean | null;
   auto_merge?: number | boolean | null;
+  /** Engine truth for the `attention` badge (issue #422): whether an OPEN native user task of each
+   * human-wait kind currently exists for this run, from the `user_tasks` inbox (`pollUserTasks`, the
+   * authoritative "who is waiting on a human" set). `attention` derives from THESE, never from the
+   * drift-prone `status` variable — so once an escalation is answered (its `user_tasks` row deleted)
+   * the badge clears immediately even while `status` still reads a stale `"escalated"`. Omitted/false
+   * ⇒ no open task ⇒ no badge. `feature_read_model` (075) mirrors this with correlated EXISTS lookups. */
+  hasOpenBlockedTask?: boolean | null;
+  hasOpenEscalationTask?: boolean | null;
 }
 
 /** The derived pipeline projection for one run. `skipped` is a space-separated set of stage keys not
@@ -91,11 +99,16 @@ export function deriveStage(run: StageInput): DerivedStage {
 
   // `attention`: a short badge for the active stage (the renderer colours it from `state`). This is how
   // a parked `awaiting_operator`/`escalated` run surfaces as attention WITHOUT altering its stage.
-  // Derived from `status` alone (issue #332): the parked-task pointers that used to source it were
-  // dropped with the denormalised escalation surface, and the authoritative "who is waiting on a human"
-  // list now lives on the `user_tasks` Tasks inbox. `awaiting_operator` (parked at `feature-blocked`)
-  // shows the blocked glyph; `escalated` (parked at `feature-escalation`) shows the ⚠ badge.
-  const attention = status === "awaiting_operator" ? "blocked" : status === "escalated" ? "⚠" : null;
+  // Derived from ENGINE TRUTH — the presence of an OPEN native user task (issue #422), NOT from the
+  // `status` variable. `status` is worker-written imperatively and goes stale on the answer-loop back
+  // into `implement-task` (the process does not reset it), so a run whose escalation was already
+  // ANSWERED still reads `status="escalated"` until its next job completes; sourcing the badge from
+  // that value made the read model lie (a resolved run flagged ⚠ on Overview). The authoritative
+  // "who is waiting on a human" set is the `user_tasks` inbox (`pollUserTasks`), which holds a row
+  // IFF the task is open and deletes it the moment it is answered — so a run shows the blocked glyph
+  // IFF an open `feature-blocked` task exists, and ⚠ IFF an open `feature-escalation` task exists.
+  // Once answered, the row is gone and the badge clears regardless of the stale `status`.
+  const attention = truthy(run.hasOpenBlockedTask) ? "blocked" : truthy(run.hasOpenEscalationTask) ? "⚠" : null;
 
   return { stage, state, skipped: skippedKeys.join(" "), attention };
 }

package/db/migrations/075_feature_read_model_attention_from_user_tasks.sql

@@ -0,0 +1,113 @@
+-- Feature-run `attention` badge: derive it from engine truth (an OPEN native user task), not from the
+-- drift-prone `status` variable (issue #422 — the L1 surface closure #439 named but did not ship).
+--
+-- 073_feature_read_model.sql retired the WRITE-TIME display projection (L2) into this VIEW, but it
+-- still derived `attention` from the row's own `status` column:
+--     WHEN fr.status = 'awaiting_operator' THEN 'blocked'
+--     WHEN fr.status = 'escalated'         THEN '⚠'
+-- `status` is a process-scope variable set imperatively by the workers on the happy path. The `feature`
+-- process loops the answer arm (`w_answerLoop`, resolution="answer") straight back into `implement-task`
+-- with NO reset step, so after an escalation is ANSWERED the token is ACTIVE again at `implement-task`
+-- while `status` still reads the previous iteration's `"escalated"` until the re-running agent job
+-- completes and overwrites it (issue #422, observed live on merlin: feature instance 31779 showing ⚠
+-- on Overview though its escalation was resolved and it was back implementing). Deriving the badge from
+-- that sticky value makes the read model LIE — the exact "projected state maintained imperatively at
+-- write time" defect class #439 set out to close ("derive it, don't maintain it — No Drift Surfaces").
+--
+-- The authoritative "who is waiting on a human" set is NOT `status` — it is the `user_tasks` inbox
+-- (034_user_tasks_inbox.sql): `pollUserTasks` (app/service.ts) reconciles exactly one row per CURRENTLY
+-- OPEN escalation user task from the engine and DELETES the row the moment the task closes (answered
+-- here, via the Tasks inbox, or out-of-band). So a run is:
+--   * awaiting an operator (blocked glyph) IFF an open `feature-blocked`     user task exists for it, and
+--   * escalated            (⚠     badge)  IFF an open `feature-escalation`   user task exists for it.
+-- Deriving `attention` from that presence (engine truth) instead of `status` closes the surface: once
+-- the escalation is answered the `user_tasks` row is gone, so ⚠ clears immediately REGARDLESS of the
+-- stale `status`. There is no stored column and no write path any writer can leave stale — the badge is
+-- a pure function of the live open-task set, recomputed on every read. `deriveStage` (app/stage.ts)
+-- remains the canonical TS oracle: it now takes the same open-task signals, and
+-- app/featureReadModel.test.ts pins the VIEW to it in lockstep over the full status × open-task matrix
+-- (including the #422 case: status='escalated' with NO open task → attention NULL).
+--
+-- pollUserTasks keys these rows `subject_type='feature'`, `subject_key=<feature_key>` (app/service.ts
+-- DEFAULT_SUBJECT_TYPE / contextFor), so the correlated match is on `fr.feature_key`. `stage` is
+-- deliberately UNCHANGED — an escalated/awaiting_operator run maps to `Implementing`, which is correct
+-- whether or not the flag is stale (a run back at `implement-task` IS implementing); only the attention
+-- badge was drifting, so only it moves to engine-truth derivation.
+--
+-- Forward-only, non-additive to `feature_runs` (a VIEW redefinition): `DROP VIEW` then `CREATE VIEW`,
+-- plus one idempotent `CREATE INDEX IF NOT EXISTS` on `user_tasks` to front the correlated `attention`
+-- lookups (see the trailing index comment).
+-- 073 is a MERGED, IMMUTABLE migration — never edited; this is a NEW migration that supersedes its VIEW
+-- definition. `user_tasks` (034) already exists earlier in the chain, so the correlated subquery
+-- resolves. A single plain `CREATE VIEW … SELECT … FROM feature_runs fr` (the `user_tasks` lookups are
+-- nested EXISTS subqueries at paren depth ≥ 1, so `feature_runs fr` stays the sole top-level FROM and
+-- every output column stays aliased — the static pages↔schema contract guard, scripts/pages-contract.
+-- test.ts, still parses the projection). Numbered after the current highest prefix on origin/main (074).
+-- The runner wraps each file in its own transaction, so this file must NOT contain BEGIN/COMMIT.
+
+DROP VIEW IF EXISTS feature_read_model;
+
+CREATE VIEW feature_read_model AS
+SELECT
+  fr.feature_key AS feature_key,
+  fr.repo AS repo,
+  fr.issue_number AS issue_number,
+  fr.issue_url AS issue_url,
+  fr.title AS title,
+  fr.base_branch AS base_branch,
+  fr.status AS status,
+  fr.process_key AS process_key,
+  fr.pr_key AS pr_key,
+  fr.converge AS converge,
+  fr.auto_merge AS auto_merge,
+  fr.outcome AS outcome,
+  fr.delivery_label AS delivery_label,
+  fr.acknowledged_at AS acknowledged_at,
+  fr.created_at AS created_at,
+  fr.updated_at AS updated_at,
+  (CASE
+    WHEN fr.status IN ('merged', 'converged', 'blocked', 'failed', 'skipped', 'abandoned') THEN 'Done'
+    WHEN fr.status = 'converging' THEN 'Converging'
+    WHEN (fr.pr_key IS NOT NULL AND fr.pr_key <> '') OR fr.status = 'opened' THEN 'PR open'
+    WHEN fr.status IN ('running', 'escalated', 'awaiting_operator') THEN 'Implementing'
+    ELSE 'Requested'
+  END) AS stage,
+  (CASE
+    WHEN fr.status IN ('merged', 'converged') THEN 'ok'
+    WHEN fr.status = 'blocked' THEN 'blocked'
+    WHEN fr.status IN ('failed', 'skipped', 'abandoned') THEN 'failed'
+    ELSE NULL
+  END) AS stage_state,
+  (CASE
+    WHEN NOT (fr.converge IS NOT NULL AND fr.converge <> 0) THEN 'Converging Merging'
+    WHEN NOT (fr.auto_merge IS NOT NULL AND fr.auto_merge <> 0) THEN 'Merging'
+    ELSE ''
+  END) AS stage_skipped,
+  (CASE
+    WHEN EXISTS (
+      SELECT 1 FROM user_tasks ut
+      WHERE ut.subject_type = 'feature' AND ut.subject_key = fr.feature_key
+        AND ut.element_id = 'feature-blocked'
+    ) THEN 'blocked'
+    WHEN EXISTS (
+      SELECT 1 FROM user_tasks ut
+      WHERE ut.subject_type = 'feature' AND ut.subject_key = fr.feature_key
+        AND ut.element_id = 'feature-escalation'
+    ) THEN '⚠'
+    ELSE NULL
+  END) AS attention,
+  (CASE
+    WHEN fr.status IN ('merged', 'converged', 'blocked', 'failed', 'skipped', 'abandoned') AND fr.acknowledged_at IS NOT NULL THEN 'history'
+    ELSE 'active'
+  END) AS list_bucket
+FROM feature_runs fr;
+
+-- Supporting index for the correlated `attention` EXISTS lookups above. Each row of
+-- `feature_read_model` probes `user_tasks` by `(subject_type, subject_key, element_id)` (twice: once
+-- for `feature-blocked`, once for `feature-escalation`); the only prior index (034) is on
+-- `(element_id, updated_at)`, which does not front the equality on `subject_type`/`subject_key`, so a
+-- page reading many `feature_runs` rows would repeat a `user_tasks` scan per row. A composite index on
+-- the exact equality tuple turns each probe into an index seek. `IF NOT EXISTS` keeps the migration
+-- idempotent on any DB that already carries the index.
+CREATE INDEX IF NOT EXISTS idx_user_tasks_subject_element
+  ON user_tasks(subject_type, subject_key, element_id);

package/e2e/convergence-escalation.e2e.ts

@@ -93,6 +93,16 @@ describe("nano-workforce PR review-loop escalation (U4 userTask)", () => {
     await app.engine.registerWorker("senior:scope-classify", () => {
       return { scopeBlocked: false, scopeBlockReason: "" };
     });
+    // The converged round also runs the deterministic `pr.converge-gate` app worker, which FAILS
+    // CLOSED without a live GitHub transport (sealed here). This e2e isolates the review-escalation
+    // round-trip — the gate is exercised by `app/convergeGate.test.ts` + the worker integration
+    // test — so stub it as "converged cleanly" so the resumed round finalizes rather than parking
+    // on a second, converge-gate escalation. (Before engine-wasm 0.7.2, a blocked gate's escalation
+    // *question* silently blanked through ioMapping and was suppressed as a non-escalation, hiding
+    // this second escalation; the IO_MAPPING_ERROR fix now renders it, so it must be stubbed out.)
+    await app.engine.registerWorker("pr.converge-gate", () => {
+      return { convergeBlocked: false, convergeBlockReason: "" };
+    });
   });
 
   after(async () => {

package/e2e/retire-escalation-subsystem.e2e.ts

@@ -88,6 +88,19 @@ describe("retire escalation subsystem (U7 — destructive contract phase)", () =
       capturedAnswer = (job.variables as Record<string, unknown>).answer;
       return { status: "converged", summary: "resolved after the human answer" };
     });
+    // The converged round runs the deterministic `pr.converge-gate` app worker (and then
+    // `senior:scope-classify`), both of which FAIL CLOSED / park without a live transport (sealed
+    // here). This e2e isolates the escalation round-trip — the gate/classifier have their own tests
+    // — so stub both as "converged cleanly" so the resumed round finalizes rather than parking on a
+    // second escalation. (Before engine-wasm 0.7.2, a blocked gate's escalation *question* silently
+    // blanked through ioMapping and was suppressed as a non-escalation, hiding this; the
+    // IO_MAPPING_ERROR fix now renders it, so it must be stubbed out.)
+    await app.engine.registerWorker("pr.converge-gate", () => {
+      return { convergeBlocked: false, convergeBlockReason: "" };
+    });
+    await app.engine.registerWorker("senior:scope-classify", () => {
+      return { scopeBlocked: false, scopeBlockReason: "" };
+    });
   });
 
   after(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.123.1",
+  "version": "0.123.2",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",
@@ -59,12 +59,12 @@
   },
   "dependencies": {
     "@nanobpm/agentic": "^0.1.0",
-    "@nanobpm/urban": "^0.75.0",
+    "@nanobpm/urban": "^0.77.1",
     "bpmn-auto-layout": "^2.0.0-alpha.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",
-    "@nanobpm/urban-testkit": "^0.5.0",
+    "@nanobpm/urban-testkit": "^0.11.0",
     "@nanobpm/workflow": "^0.14.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",

package/resources/processes/merge-loop.bpmn

@@ -194,7 +194,7 @@
         </zeebe:properties>
         <zeebe:ioMapping>
           <zeebe:input source="=&#34;blocked&#34;" target="status" />
-          <zeebe:input source="=&#34;This PR is not mergeable (state: &#34; + mergeState + &#34;). Resolve the conflict or failing required check on the branch, then reply to retry.&#34;" target="question" />
+          <zeebe:input source="=if mergeState = &#34;draft&#34; then &#34;This PR is in draft and can&#39;t be merged. Mark it ready (gh pr ready), then reply to retry.&#34; else &#34;This PR is not mergeable (state: &#34; + mergeState + &#34;). Resolve the conflict or failing required check on the branch, then reply to retry.&#34;" target="question" />
         </zeebe:ioMapping>
       </bpmn:extensionElements>
       <bpmn:incoming>f_m_mBlocked</bpmn:incoming>