@nanobpm/nano-workforce 0.171.1 → 0.171.2

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.171.2](https://github.com/nanobpm/nano-workforce/compare/v0.171.1...v0.171.2) (2026-08-31)
+
+### Bug Fixes
+
+* surface + complete readiness/preflight escalations in the Tasks inbox ([#675](https://github.com/nanobpm/nano-workforce/issues/675)) ([9d874e8](https://github.com/nanobpm/nano-workforce/commit/9d874e889f3155b7887bb48032e39c5f78e33ce3)), closes [#674](https://github.com/nanobpm/nano-workforce/issues/674)
+
 ## [0.171.1](https://github.com/nanobpm/nano-workforce/compare/v0.171.0...v0.171.1) (2026-08-31)
 
 ### Code Refactoring

package/app/agentCompletion.test.ts

@@ -286,6 +286,38 @@ test("empty-plan-escalation is HUMAN-completable but NOT agent-completable (issu
   assertEquals(completed[0].variables, { directive: "revise", notes: "look again" });
 });
 
+test("readiness-escalation(-pf) is HUMAN-completable but NOT agent-completable (issue #674)", async () => {
+  // A readiness/preflight gate adjudicates whether upstream is ACTUALLY ready (proceed) or the gate
+  // should be abandoned. Like feature-blocked/conformance/empty-plan it is a HUMAN operator decision —
+  // an agent must never auto-answer it, or the fleet would silently defeat the very readiness gate the
+  // task exists to enforce. So both ids stay OUTSIDE `ESCALATION_TASK_ELEMENTS` (agent-refused) but are
+  // retired by the HUMAN completer via the one canonical `complete-user-task` door.
+  for (const elementId of ["readiness-escalation-pf", "readiness-escalation"] as const) {
+    const stores = { task_completions: { rows: [] as any[], key: "id" } };
+    const data = memData(stores);
+    const { engine, completed } = fakeEngine([{ userTaskKey: "ut-r", elementId }]);
+
+    const asAgent = await completeEscalationAsAgent(data, engine, {
+      userTaskKey: "ut-r",
+      agentId: "bot",
+      variables: { resolution: "acknowledge" },
+    });
+    assertEquals(asAgent.ok, false, `the agent completer refuses ${elementId}`);
+    assertEquals(asAgent.reason, "not a completable task");
+    assertEquals(completed.length, 0);
+
+    const asHuman = await completeEscalationAsHuman(data, engine, {
+      userTaskKey: "ut-r",
+      operatorId: "alice",
+      variables: { resolution: "abandon", answer: "upstream never published" },
+    });
+    assertEquals(asHuman.ok, true, `the human completer retires ${elementId}`);
+    assertEquals(asHuman.elementId, elementId);
+    assertEquals(completed.length, 1);
+    assertEquals(completed[0].variables, { resolution: "abandon", answer: "upstream never published" });
+  }
+});
+
 test("human completer refuses a non-escalation user task and is a no-op for an unknown key", async () => {
   const stores = { task_completions: { rows: [] as any[], key: "id" } };
   const data = memData(stores);

package/app/agentCompletion.ts

@@ -24,7 +24,7 @@ import { readFileSync } from "node:fs";
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
 import { CONFORMANCE_ESCALATION_ELEMENT } from "./conformance.ts";
 import { DELIVERY_HUMAN_ELEMENT, isDeliveryHumanElement } from "./deliveryHuman.ts";
-import { ACP_PERMISSION_ELEMENT, EMPTY_PLAN_ELEMENT } from "./userTasks.ts";
+import { ACP_PERMISSION_ELEMENT, EMPTY_PLAN_ELEMENT, READINESS_ESCALATION_ELEMENT, READINESS_ESCALATION_PF_ELEMENT } from "./userTasks.ts";
 
 const now = () => new Date().toISOString();
 
@@ -101,6 +101,16 @@ export const CONFORMANCE_ESCALATION_TASK_ELEMENT = CONFORMANCE_ESCALATION_ELEMEN
  *  Re-exported from the canonical `EMPTY_PLAN_ELEMENT` (app/userTasks.ts) — one source of truth. */
 export const EMPTY_PLAN_TASK_ELEMENT = EMPTY_PLAN_ELEMENT;
 
+/** The readiness/preflight escalation user-task element ids (`readiness-escalation-pf` in feature.bpmn's
+ *  readiness preflight + plan-fanout.bpmn's producer-capability preflight; `readiness-escalation` in
+ *  readiness-gate.bpmn / wait-gate.bpmn). Like `feature-blocked`, `conformance-escalation` and
+ *  `empty-plan-escalation` these are HUMAN-only decisions — an agent must never auto-answer a readiness
+ *  gate (that would silently defeat the "is upstream actually ready?" adjudication the gate exists for),
+ *  so they live OUTSIDE `ESCALATION_TASK_ELEMENTS` and only the HUMAN completer accepts them (issue
+ *  #674). Re-exported from the canonical constants in app/userTasks.ts — one source of truth. */
+export const READINESS_ESCALATION_PF_TASK_ELEMENT = READINESS_ESCALATION_PF_ELEMENT;
+export const READINESS_ESCALATION_TASK_ELEMENT = READINESS_ESCALATION_ELEMENT;
+
 /** The user-task `elementId`s a HUMAN operator may complete from the Tasks inbox via the one canonical
  *  `complete-user-task` door: every agent-answerable escalation PLUS the human-only `feature-blocked`
  *  and `conformance-escalation` acknowledgements, PLUS the advisory ACP permission prompt
@@ -115,6 +125,8 @@ export const HUMAN_COMPLETABLE_ELEMENTS: ReadonlySet<string> = new Set([
   FEATURE_BLOCKED_TASK_ELEMENT,
   CONFORMANCE_ESCALATION_TASK_ELEMENT,
   EMPTY_PLAN_TASK_ELEMENT,
+  READINESS_ESCALATION_PF_TASK_ELEMENT,
+  READINESS_ESCALATION_TASK_ELEMENT,
   ACP_PERMISSION_ELEMENT,
 ]);
 
@@ -131,6 +143,8 @@ const ESCALATION_FORM_BY_ELEMENT: Readonly<Record<string, string>> = {
   "feature-blocked": "feature-blocked",
   [EMPTY_PLAN_TASK_ELEMENT]: "empty-plan-escalation",
   [CONFORMANCE_ESCALATION_TASK_ELEMENT]: "conformance-escalation",
+  [READINESS_ESCALATION_PF_TASK_ELEMENT]: "readiness-escalation",
+  [READINESS_ESCALATION_TASK_ELEMENT]: "readiness-escalation",
   // NOTE: the delivery-graph `human` node (`DELIVERY_HUMAN_ELEMENT`, ADR 0005 S3) is intentionally
   // ABSENT here. Unlike the fixed-form escalations above, ONE `delivery-human-task` element is DESIGNED
   // to render DIFFERENT forms per node (explicit → category → generic → agent-router, `app/deliveryHuman.ts`

package/app/pollUserTasks.test.ts

@@ -161,6 +161,69 @@ test("pollUserTasks: projects a feature-escalation that lands on a plan-fanout p
   assertEquals(byKey["ut-embedded-feat"].question, "the agent returned no machine-readable result — enrol the PR?");
 });
 
+test("pollUserTasks: projects a readiness-escalation-pf preflight task on a feature run (issue #674)", async () => {
+  // The leading readiness preflight (feature.bpmn `pf_*` embedded subprocess) parks on the run's OWN
+  // engine instance when it times out before its ReadinessProbe goes green. Before #674 the element id
+  // was absent from USER_TASK_KIND_LABELS, so `contextFor`'s leak guard dropped it and the parked run
+  // was invisible + uncompletable in the Tasks surface. It must now project as an "Upstream readiness
+  // stalled" row on the feature subject, carrying the run's wait rollup as the question.
+  const { data, stores } = memData({
+    feature_runs: [
+      {
+        feature_key: "o/r#674",
+        status: "running",
+        process_key: "fp-674",
+        issue_url: "https://github.com/o/r/issues/674",
+        title: "Ship the widget",
+        delivery_label: "waiting on @scope/upstream@1.2.0 · re-checks every 30s",
+      },
+    ],
+  });
+  const engine = fakeEngine({ "fp-674": [{ userTaskKey: "ut-readiness-pf", elementId: "readiness-escalation-pf", formKey: "26" }] });
+
+  await pollUserTasks(data, engine);
+
+  const byKey = Object.fromEntries((stores.user_tasks ?? []).map((r) => [r.user_task_key, r]));
+  assertEquals(Object.keys(byKey), ["ut-readiness-pf"]);
+  assertEquals(byKey["ut-readiness-pf"].element_id, "readiness-escalation-pf");
+  assertEquals(byKey["ut-readiness-pf"].kind_label, "Upstream readiness stalled");
+  assertEquals(byKey["ut-readiness-pf"].subject_type, "feature");
+  assertEquals(byKey["ut-readiness-pf"].subject_key, "o/r#674");
+  assertEquals(byKey["ut-readiness-pf"].subject_title, "Ship the widget");
+  assertEquals(byKey["ut-readiness-pf"].question, "waiting on @scope/upstream@1.2.0 · re-checks every 30s");
+  assertEquals(byKey["ut-readiness-pf"].form_key, "26");
+});
+
+test("pollUserTasks: projects a readiness-escalation wait-gate task on a plan, with the wait-gate label as question (issue #674)", async () => {
+  // The standalone inter-epic wait-gate cell (readiness-gate.bpmn / wait-gate.bpmn) parks a dependent
+  // epic on `readiness-escalation` when its bounded capability wait elapses. It surfaces on the plan
+  // subject; the question derivation leans on the wait-gate projection (`plans.wait_gate_label`).
+  const { data, stores } = memData({
+    plans: [
+      {
+        plan_key: "o/r#700",
+        status: "dispatched",
+        process_key: "pp-700",
+        issue_url: "https://github.com/o/r/issues/700",
+        title: "Dependent epic",
+        wait_gate: "escalated",
+        wait_gate_label: "escalated · still waiting on @scope/producer@2.0.0 after 24h",
+      },
+    ],
+  });
+  const engine = fakeEngine({ "pp-700": [{ userTaskKey: "ut-readiness", elementId: "readiness-escalation" }] });
+
+  await pollUserTasks(data, engine);
+
+  const byKey = Object.fromEntries((stores.user_tasks ?? []).map((r) => [r.user_task_key, r]));
+  assertEquals(Object.keys(byKey), ["ut-readiness"]);
+  assertEquals(byKey["ut-readiness"].element_id, "readiness-escalation");
+  assertEquals(byKey["ut-readiness"].kind_label, "Readiness escalation");
+  assertEquals(byKey["ut-readiness"].subject_type, "plan");
+  assertEquals(byKey["ut-readiness"].subject_key, "o/r#700");
+  assertEquals(byKey["ut-readiness"].question, "escalated · still waiting on @scope/producer@2.0.0 after 24h");
+});
+
 test("pollUserTasks: projects a merge-loop wait-merge-answer escalation into user_tasks as \"PR merge\"", async () => {
   // During the merge phase a PR's process_key points at its merge-loop instance; the merge escalation
   // parks on a native `wait-merge-answer` userTask (#256) and writes the SAME `escalations` row the

package/app/service.ts

@@ -99,6 +99,9 @@ import {
   PR_WAIT_ANSWER_ELEMENT,
   PR_WAIT_MERGE_ANSWER_ELEMENT,
   prEscalations,
+  READINESS_ESCALATION_ELEMENT,
+  READINESS_ESCALATION_PF_ELEMENT,
+  readinessEscalationQuestion,
   reconcileUserTasks,
   TRIAL_MERGE_ELEMENT,
   toOpenEscalation,
@@ -2652,15 +2655,19 @@ export async function pollUserTasks(
     url?: string | null;
     deliveryLabel?: string | null;
     conformanceSummary?: string | null;
+    /** The subject's at-a-glance "waiting on <capability> · …" rollup, denormalised for the readiness
+     *  escalation question (issue #674): the wait-gate projection on `plans.wait_gate_label`, or the
+     *  feature run's `delivery_label` for the inline preflight. */
+    waitGateLabel?: string | null;
   }
   const subjectByInstance = new Map<string, Subject>();
   for (const run of await featureRuns(data).all()) {
     if (run.process_key) {
-      subjectByInstance.set(run.process_key, { type: "feature", key: run.feature_key, title: run.title, url: run.issue_url, deliveryLabel: run.delivery_label });
+      subjectByInstance.set(run.process_key, { type: "feature", key: run.feature_key, title: run.title, url: run.issue_url, deliveryLabel: run.delivery_label, waitGateLabel: run.delivery_label });
     }
   }
   for (const plan of await plans(data).all()) {
-    if (plan.process_key) subjectByInstance.set(plan.process_key, { type: "plan", key: plan.plan_key, title: plan.title, url: plan.issue_url });
+    if (plan.process_key) subjectByInstance.set(plan.process_key, { type: "plan", key: plan.plan_key, title: plan.title, url: plan.issue_url, waitGateLabel: plan.wait_gate_label });
   }
   for (const pr of await prs(data).all()) {
     if (pr.process_key) subjectByInstance.set(pr.process_key, { type: "pr", key: pr.pr_key, title: pr.title, url: pr.url });
@@ -2687,6 +2694,8 @@ export async function pollUserTasks(
     [PLAN_REVIEW_ELEMENT]: "plan",
     [TRIAL_MERGE_ELEMENT]: "plan",
     [CONFORMANCE_ESCALATION_ELEMENT]: "plan",
+    [READINESS_ESCALATION_PF_ELEMENT]: "feature",
+    [READINESS_ESCALATION_ELEMENT]: "plan",
     [PR_WAIT_ANSWER_ELEMENT]: "pr",
     [PR_WAIT_MERGE_ANSWER_ELEMENT]: "pr",
   };
@@ -2744,6 +2753,13 @@ export async function pollUserTasks(
       case CONFORMANCE_ESCALATION_ELEMENT:
         question = conformanceEscalationQuestion(subj ? { summary: subj.conformanceSummary } : undefined);
         break;
+      case READINESS_ESCALATION_PF_ELEMENT:
+      case READINESS_ESCALATION_ELEMENT:
+        // The leading readiness/capability gate stalled: surface WHAT it is waiting on. The wait-gate
+        // projection already rendered that clause on the subject row (`plans.wait_gate_label`, or the
+        // feature preflight's `delivery_label`), with a static readiness-stalled fallback (#674).
+        question = readinessEscalationQuestion(subj?.waitGateLabel ?? null);
+        break;
     }
     return { userTaskKey, elementId, subjectType, subjectKey, subjectTitle: subj?.title ?? null, subjectUrl: subj?.url ?? null, question, processKey: processInstanceKey, formKey: resolvedFormKey };
   };

package/app/userTaskInboxDriftGuard.test.ts

@@ -0,0 +1,102 @@
+// Drift guard for the Tasks-inbox closed sets (issue #674 — fix the class, not the bug).
+//
+// Root cause of #674: the readiness/preflight escalation user tasks (`readiness-escalation-pf`,
+// `readiness-escalation`) were deployed BPMN `<bpmn:userTask>`s with a linked `.form`, but their
+// element ids were never added to the app-tier closed sets that gate surfacing (`USER_TASK_KIND_LABELS`,
+// app/userTasks.ts) and completion (`HUMAN_COMPLETABLE_ELEMENTS` / `ESCALATION_FORM_BY_ELEMENT`,
+// app/agentCompletion.ts). The poller's leak guard (`userTaskKindLabel(id) === undefined`) silently
+// DROPPED every such task, so a parked run went invisible in the Tasks surface AND uncompletable
+// through the one canonical `complete-user-task` door.
+//
+// This test makes that drift structurally impossible: it enumerates EVERY human `<bpmn:userTask>`
+// (bearing a `<zeebe:userTask />`) in the deployed processes (`resources/processes/*.bpmn`) and asserts
+// each element id is a KNOWN Tasks-inbox kind, and — where it declares a static `zeebe:formDefinition`
+// form and is completable — that the completer's form contract resolves to the SAME `.form` the BPMN
+// declares. So a future BPMN user task can never again vanish from the inbox by being absent from the
+// hand-maintained closed set: the closed set's completeness is DERIVED from the deployed BPMN, not
+// asserted blind.
+//
+// On `main` (before #674's registration) this test FAILS on `readiness-escalation-pf` /
+// `readiness-escalation`; it passes once both are registered.
+import { readdirSync, readFileSync } from "node:fs";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { escalationFormId, HUMAN_COMPLETABLE_ELEMENTS } from "./agentCompletion.ts";
+import { isDeliveryHumanElement } from "./deliveryHuman.ts";
+import { userTaskKindLabel } from "./userTasks.ts";
+
+const PROCESS_DIR = "resources/processes";
+
+/** Demo/fixture processes that are deployed for the engine-spine e2e (`e2e/user-task-spine.e2e.ts`)
+ *  but are NOT part of the workforce escalation surface — their user tasks are deliberately not
+ *  Tasks-inbox kinds. Kept as a tiny, explicitly-documented file allowlist (not a per-id one) so a new
+ *  REAL escalation process is still fully guarded. */
+const DEMO_PROCESS_FILES: ReadonlySet<string> = new Set(["spine-demo.bpmn"]);
+
+interface DeployedUserTask {
+  file: string;
+  elementId: string;
+  /** The `zeebe:formDefinition formId`, when the task declares a static form. */
+  formId: string | null;
+}
+
+/** Parse every human `<bpmn:userTask>` (one bearing a `<zeebe:userTask />`, i.e. a native user task an
+ *  operator answers — not a job-worker task) out of the deployed process BPMN. Text parsing, matching
+ *  the repo's lightweight model-guard style (convergenceEscalationGuard.test.ts et al.). */
+function deployedHumanUserTasks(): DeployedUserTask[] {
+  const out: DeployedUserTask[] = [];
+  for (const file of readdirSync(PROCESS_DIR).filter((f) => f.endsWith(".bpmn"))) {
+    if (DEMO_PROCESS_FILES.has(file)) continue;
+    const xml = readFileSync(`${PROCESS_DIR}/${file}`, "utf8");
+    for (const m of xml.matchAll(/<bpmn:userTask\b[^>]*\bid="([^"]+)"([\s\S]*?)<\/bpmn:userTask>/g)) {
+      const [, elementId, body] = m;
+      if (!/<zeebe:userTask\b/.test(body)) continue; // not a native human user task (no <zeebe:userTask/>)
+      const form = body.match(/<zeebe:formDefinition\b[^>]*\bformId="([^"]+)"/);
+      out.push({ file, elementId, formId: form ? form[1] : null });
+    }
+  }
+  return out;
+}
+
+test("drift guard: every deployed human user task is a known Tasks-inbox kind (issue #674)", () => {
+  const tasks = deployedHumanUserTasks();
+  // Sanity: the sweep actually found the deployed escalations (guards against a parser that silently
+  // matches nothing and vacuously passes).
+  assert(tasks.length > 0, `expected the process sweep to find the deployed user tasks, got ${tasks.length}`);
+  assert(
+    tasks.some((t) => t.elementId === "readiness-escalation-pf"),
+    "expected readiness-escalation-pf among the deployed user tasks",
+  );
+  assert(
+    tasks.some((t) => t.elementId === "readiness-escalation"),
+    "expected readiness-escalation among the deployed user tasks",
+  );
+
+  const unsurfaced = tasks.filter((t) => userTaskKindLabel(t.elementId) === undefined);
+  assertEquals(
+    unsurfaced.map((t) => `${t.file}:${t.elementId}`),
+    [],
+    "deployed user task(s) are not registered in USER_TASK_KIND_LABELS — pollUserTasks' leak guard would drop them from the Tasks inbox (issue #674)",
+  );
+});
+
+test("drift guard: every deployed fixed-form user task is human-completable through the canonical door (issue #674)", () => {
+  // The delivery-graph `human` node renders DIFFERENT forms per node (variable form, resolved at
+  // activation), so it is intentionally absent from the static `ESCALATION_FORM_BY_ELEMENT` contract —
+  // exclude it from the fixed-form assertion (it is still asserted to be a KNOWN kind above).
+  const fixedForm = deployedHumanUserTasks().filter((t) => t.formId && !isDeliveryHumanElement(t.elementId));
+
+  const notCompletable = fixedForm.filter((t) => !HUMAN_COMPLETABLE_ELEMENTS.has(t.elementId));
+  assertEquals(
+    notCompletable.map((t) => `${t.file}:${t.elementId}`),
+    [],
+    "deployed fixed-form user task(s) are not in HUMAN_COMPLETABLE_ELEMENTS — the canonical complete-user-task door would reject them",
+  );
+
+  const formMismatch = fixedForm.filter((t) => escalationFormId(t.elementId) !== t.formId);
+  assertEquals(
+    formMismatch.map((t) => `${t.file}:${t.elementId} bpmn=${t.formId} app=${escalationFormId(t.elementId) ?? "undefined"}`),
+    [],
+    "deployed user task(s) map to a different .form contract in ESCALATION_FORM_BY_ELEMENT than the BPMN declares",
+  );
+});

package/app/userTasks.ts

@@ -72,6 +72,24 @@ export const ACP_PERMISSION_ELEMENT = "acp-permission";
  *  escalation is filtered out by the unknown-kind guard and silently vanishes from the Tasks inbox. */
 export const HUMAN_ESCALATION_ELEMENT = "escalation";
 
+/** The readiness/preflight escalation user task parked when a LEADING readiness/capability PREFLIGHT
+ *  times out before its `ReadinessProbe` went green — a human decision (acknowledge/proceed vs abandon).
+ *  This is the `pf_*` embedded-subprocess variant that appears both in `feature.bpmn` (the feature-run
+ *  readiness preflight) and `plan-fanout.bpmn` (the producer-capability preflight). It parks on the
+ *  run's OWN engine instance (an embedded subprocess, not a callActivity child), renders the deployed
+ *  `readiness-escalation` `.form`, and is HUMAN-only: an agent must NOT auto-answer a readiness gate
+ *  (that would silently defeat the very "is upstream actually ready?" decision the gate exists to make),
+ *  so it lives in `HUMAN_COMPLETABLE_ELEMENTS`, never in `ESCALATION_TASK_ELEMENTS`. Without this the
+ *  task's kind is `undefined`, the poller's leak guard drops it, and the run wedges invisibly + unanswerably
+ *  (issue #674). */
+export const READINESS_ESCALATION_PF_ELEMENT = "readiness-escalation-pf";
+
+/** The readiness/wait-gate escalation user task (`readiness-gate.bpmn`, `wait-gate.bpmn`) — the same
+ *  human readiness decision on the standalone inter-epic wait-gate cell rather than the inline preflight.
+ *  Same `readiness-escalation` `.form`, same HUMAN-only policy as `READINESS_ESCALATION_PF_ELEMENT`
+ *  (issue #674). */
+export const READINESS_ESCALATION_ELEMENT = "readiness-escalation";
+
 /** One row per currently-open native user-task escalation, denormalised for the Tasks page. Keyed on
  *  the completable `user_task_key` (a task is open at most once). Present iff the engine reports the
  *  task open; `pollUserTasks` deletes it once the task is gone. */
@@ -186,6 +204,8 @@ export const USER_TASK_KIND_LABELS: Readonly<Record<string, string>> = {
   [PR_WAIT_ANSWER_ELEMENT]: "PR review",
   [PR_WAIT_MERGE_ANSWER_ELEMENT]: "PR merge",
   [CONFORMANCE_ESCALATION_ELEMENT]: "Conformance review",
+  [READINESS_ESCALATION_PF_ELEMENT]: "Upstream readiness stalled",
+  [READINESS_ESCALATION_ELEMENT]: "Readiness escalation",
   [DELIVERY_HUMAN_ELEMENT]: "Delivery: human step",
   [ACP_PERMISSION_ELEMENT]: "Agent permission",
 };
@@ -342,8 +362,21 @@ export function latestTrialMergeQuestion(audits: readonly TrialMergeAuditRow[]):
   return latest?.summary ?? null;
 }
 
-/** One PR review-loop escalation (001_init.sql `escalations`). `status` is open | answered; the poller
- *  reads the OPEN row's `question`. */
+/** Pure: the "what is the run waiting on" question line for a readiness/preflight escalation
+ *  (`readiness-escalation-pf` / `readiness-escalation`, issue #674) — the unresolved probe/capability
+ *  the leading readiness gate stalled on. The wait-gate projection already renders that clause on the
+ *  subject row: a plan gated behind a producer capability carries it on `plans.wait_gate_label`
+ *  ("waiting on <clause> · re-checks …", app/waitGate.ts), and a feature preflight carries its rollup
+ *  on `feature_runs.delivery_label`. Prefer whichever the subject supplies; fall back to a static
+ *  readiness-stalled line so the Tasks grid never renders a blank question for a parked gate.
+ *  Always returns a non-empty string — the static fallback guarantees a question is never blank. */
+export function readinessEscalationQuestion(label?: string | null): string {
+  const t = typeof label === "string" ? label.trim() : "";
+  return (
+    t ||
+    "The readiness preflight timed out before its ReadinessProbe went green. Proceed against the (now-published) upstream, or abandon the gate."
+  );
+}
 export interface PrEscalationRow {
   id: number;
   pr_key: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.171.1",
+  "version": "0.171.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",