@nanobpm/nano-workforce 0.120.0 → 0.120.2

package/app/service.ts

@@ -29,6 +29,7 @@ import {
 import { isUniqueConstraintFence } from "./dbFence.ts";
 import { deriveDelivery, TERMINAL_STATUSES } from "./delivery.ts";
 import { deliveryGraphRuns, deriveDeliveryPhase, parseHumanLabels } from "./deliveryGraphRun.ts";
+import { isDeliveryHumanElement } from "./deliveryHuman.ts";
 import { fleetSupportsDurableResume } from "./durableResume.ts";
 import { backfillFeatureStages, deriveFeatureDelivery, FEATURE_BLOCKED_ELEMENT, FEATURE_ESCALATION_ELEMENT, FEATURE_RUN_STATUSES, type FeatureRunStatus, featureEscalations, featureRuns } from "./feature.ts";
 import {
@@ -70,6 +71,7 @@ import {
   probeOnce,
   READINESS_READY_MESSAGE,
   type ReadinessProbe,
+  readinessPollEvery,
   readinessTimeout,
 } from "./readiness.ts";
 import { clampNudgeMinutes, reviewWaitTimeout } from "./reviewWait.ts";
@@ -86,9 +88,9 @@ import {
   prEscalations,
   reconcileUserTasks,
   TRIAL_MERGE_ELEMENT,
-  USER_TASK_KIND_LABELS,
   type UserTaskContext,
   type UserTaskRow,
+  userTaskKindLabel,
   userTasks,
 } from "./userTasks.ts";
 import { deriveWaitGate } from "./waitGate.ts";
@@ -1688,6 +1690,10 @@ function capabilityGateTimeout(env: Record<string, string | undefined>): string
   return readinessTimeout({ kind: "capability", target: "" } satisfies ReadinessProbe, env);
 }
 
+function capabilityGatePollEvery(env: Record<string, string | undefined>): string {
+  return readinessPollEvery({ kind: "capability", target: "" } satisfies ReadinessProbe, env);
+}
+
 /** Capability-edge reconcile pass (issue #289). The host half of the "consumer readiness edge":
  * plan-fanout's per-task fan-out parks at the `wait-caps-resolved` message barrier for any task that
  * declared cross-repo capability `needs` (049_plan_task_needs.sql). Here we reconcile, on EVERY pass
@@ -1721,6 +1727,7 @@ export async function pollCapabilityGatesImpl(
 ) {
   const gateTable = capabilityGates(data);
   const probeTimeout = capabilityGateTimeout(env);
+  const probePollEvery = capabilityGatePollEvery(env);
   for (const plan of await plans(data).all()) {
     const planKey = plan.plan_key;
     const processKey = plan.process_key;
@@ -1757,7 +1764,7 @@ export async function pollCapabilityGatesImpl(
           // need as unresolved (it can only clear once the handle is corrected on a re-plan).
           let probeInput: ReturnType<typeof capabilityNeedToProbeInput>;
           try {
-            probeInput = capabilityNeedToProbeInput(need, { planKey, taskId, probeTimeout });
+            probeInput = capabilityNeedToProbeInput(need, { planKey, taskId, probeTimeout, probePollEvery });
           } catch (err) {
             if (err instanceof UnresolvableCapabilityRefError) {
               if (!row) {
@@ -1808,6 +1815,7 @@ export async function pollCapabilityGatesImpl(
                 variables: {
                   gateKey: probeInput.gateKey,
                   probeTimeout: probeInput.probeTimeout,
+                  probePollEvery: probeInput.probePollEvery,
                   onTimeout: probeInput.onTimeout,
                   probe: probeInput.probe,
                 },
@@ -2159,7 +2167,7 @@ async function sweepOpenEscalationTasks(base: string, headers: Record<string, st
       // answerable, so a lagging COMPLETED/CANCELED read must never surface a dead affordance (#294).
       if (typeof it.state === "string" && it.state.toUpperCase() !== "CREATED") continue;
       const elementId = typeof it.elementId === "string" ? it.elementId : undefined;
-      if (!elementId || !Object.hasOwn(USER_TASK_KIND_LABELS, elementId)) continue;
+      if (!elementId || userTaskKindLabel(elementId) === undefined) continue;
       const userTaskKey = it.userTaskKey == null ? "" : String(it.userTaskKey);
       if (!userTaskKey || seen.has(userTaskKey)) continue;
       seen.add(userTaskKey);
@@ -2247,7 +2255,7 @@ export async function pollUserTasks(
   // summary for the `conformance-escalation` ack (its instance is tracked on `plan_conformance`, not a
   // delivery aggregate).
   interface Subject {
-    type: "feature" | "plan" | "pr";
+    type: "feature" | "plan" | "pr" | "delivery";
     key: string;
     title?: string | null;
     url?: string | null;
@@ -2271,6 +2279,13 @@ export async function pollUserTasks(
     const plan = await plans(data).get(review.plan_key);
     subjectByInstance.set(review.process_key, { type: "plan", key: review.plan_key, title: plan?.title ?? null, url: plan?.issue_url ?? null, conformanceSummary: review.summary });
   }
+  // A delivery-graph `human` node parks on its run's engine instance; enrich from the run row so the
+  // Tasks inbox shows the graph's title (its `run_key` as the stable subject key), mirroring the
+  // feature/plan/pr enrichment. The row's inlined `delivery-human-task__<node>` id is recognised by
+  // the shared `userTaskKindLabel` predicate, and buckets as `delivery` (below).
+  for (const run of await deliveryGraphRuns(data).all()) {
+    if (run.process_key) subjectByInstance.set(run.process_key, { type: "delivery", key: run.run_key, title: run.title, url: null });
+  }
 
   // Per-element subject type for an ORPHANED task (no subject row) — the kind implies its aggregate even
   // when tracking is lost, so the fallback row still buckets correctly on the page.
@@ -2289,9 +2304,12 @@ export async function pollUserTasks(
   // when the instance is tracked or a per-kind fallback when it is orphaned. Returns `null` for a
   // non-escalation element (the leak guard) so an arbitrary internal user task can never reach the inbox.
   const contextFor = async (elementId: string, userTaskKey: string, processInstanceKey: string): Promise<UserTaskContext | null> => {
-    if (!Object.hasOwn(USER_TASK_KIND_LABELS, elementId)) return null;
+    if (userTaskKindLabel(elementId) === undefined) return null;
     const subj = subjectByInstance.get(processInstanceKey);
-    const subjectType = subj?.type ?? DEFAULT_SUBJECT_TYPE[elementId] ?? "plan";
+    // Orphaned-task fallback: the kind implies its aggregate even when no subject row references the
+    // instance. A delivery-human node's id is inlined (`delivery-human-task__<node>`), so its bucket is
+    // derived from the predicate rather than the static per-element table.
+    const subjectType = subj?.type ?? DEFAULT_SUBJECT_TYPE[elementId] ?? (isDeliveryHumanElement(elementId) ? "delivery" : "plan");
     const subjectKey = subj?.key ?? processInstanceKey;
     let question: string | null = null;
     switch (elementId) {

package/biome.json

@@ -137,5 +137,28 @@
   ],
   "formatter": {
     "enabled": false
-  }
+  },
+  "overrides": [
+    {
+      "includes": [
+        "workers/readiness-probe/**"
+      ],
+      "linter": {
+        "rules": {
+          "style": {
+            "noRestrictedGlobals": {
+              "level": "error",
+              "options": {
+                "deniedGlobals": {
+                  "setTimeout": "Use engine BPMN timers; readiness-probe must be single-shot.",
+                  "setInterval": "Use engine BPMN timers; readiness-probe must be single-shot.",
+                  "Date": "Use engine BPMN timers; readiness-probe must not read wall-clock time."
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
 }

package/e2e/delivery-graph.e2e.ts

@@ -172,7 +172,7 @@ describe("delivery-graph runner — engine-native execution (S4)", () => {
       ],
       edges: [],
     };
-    const run = await runDeliveryGraph(app.engine, graph, { probeTimeout: "PT2S", escalationSlaTimeout: "PT1H" });
+    const run = await runDeliveryGraph(app.engine, graph, { probeTimeout: "PT2S", probePollEvery: "PT1S", escalationSlaTimeout: "PT1H" });
     assert.ok(run.ok, `graph should deploy + run, got ${JSON.stringify(run)}`);
     await app.settle();
 
@@ -188,6 +188,7 @@ describe("delivery-graph runner — engine-native execution (S4)", () => {
     // wait is BOUNDED — its poll budget elapses and it escalates onto a human-completable task, parking
     // for a human rather than silently wedging or falsely resolving.
     assert.ok(!takenFlows(app).some((f) => f.endsWith("->End")), "the wait branch never falsely resolves to End");
+    await app.advanceTime(2_100);
     const esc = (await app.engine.searchUserTasks({ state: "CREATED" })).filter((t) => t.elementId?.endsWith("__esc"));
     assert.ok(
       esc.length >= 1,

package/e2e/feature-preflight.e2e.ts

@@ -77,6 +77,7 @@ function featureVars(overrides: Record<string, unknown>): Record<string, unknown
     customInstructions: null,
     readinessProbes: null,
     probeTimeout: null,
+    probePollEvery: null,
     gateKey: null,
     resolvedArtifacts: null,
     ...overrides,
@@ -129,6 +130,7 @@ describe("single-issue feature intake readiness gate (feature.bpmn, issue #295)"
             },
           ],
           probeTimeout: "PT30M",
+          probePollEvery: "PT15S",
           gateKey: "feature-readiness:owner/repo#7",
         }),
       });

package/e2e/inter-epic-dependency.e2e.ts

@@ -66,6 +66,7 @@ function planVars(overrides: Record<string, unknown>): Record<string, unknown> {
     waveCount: 1,
     readinessProbes: null,
     probeTimeout: null,
+    probePollEvery: null,
     gateKey: null,
     resolvedArtifacts: null,
     ...overrides,
@@ -115,6 +116,7 @@ describe("inter-epic capability gate — adversarial (plan-fanout.bpmn, issue #2
         variables: planVars({
           readinessProbes: [redProbe()],
           probeTimeout: "PT2S",
+          probePollEvery: "PT1S",
           gateKey: "preflight:owner/repo#2",
         }),
       });
@@ -133,7 +135,8 @@ describe("inter-epic capability gate — adversarial (plan-fanout.bpmn, issue #2
         !flows.includes("readiness-preflight->ensure-base-branch"),
         "the gate HOLDS wave 0 — a parked dependent never reaches the fan-out head",
       );
-      // The token is parked on the escalation user task, not lost.
+      await app.advanceTime(2_100);
+      // The token is parked on the escalation user task after the engine-owned timeout, not lost.
       const tasks = (await app.engine.searchUserTasks({ processInstanceKey })).filter(
         (t) => t.elementId === "readiness-escalation-pf",
       );
@@ -153,10 +156,12 @@ describe("inter-epic capability gate — adversarial (plan-fanout.bpmn, issue #2
         variables: planVars({
           readinessProbes: [redProbe()],
           probeTimeout: "PT2S",
+          probePollEvery: "PT1S",
           gateKey: "preflight:owner/repo#2",
         }),
       });
       await app.settle();
+      await app.advanceTime(2_100);
 
       const escalations = (await app.engine.searchUserTasks({ processInstanceKey })).filter(
         (t) => t.elementId === "readiness-escalation-pf",
@@ -196,6 +201,7 @@ describe("inter-epic capability gate — adversarial (plan-fanout.bpmn, issue #2
         }),
       });
       await app.settle();
+      await app.advanceTime(2_100);
 
       // Parked on the escalation, no human acts. Before the SLA it has NOT proceeded.
       const before = takenFlows(app);

package/e2e/plan-fanout-preflight.e2e.ts

@@ -65,6 +65,7 @@ function planVars(overrides: Record<string, unknown>): Record<string, unknown> {
     waveCount: 1,
     readinessProbes: null,
     probeTimeout: null,
+    probePollEvery: null,
     gateKey: null,
     resolvedArtifacts: null,
     ...overrides,
@@ -116,6 +117,7 @@ describe("plan-fanout inter-epic capability preflight (plan-fanout.bpmn, issue #
             },
           ],
           probeTimeout: "PT30M",
+          probePollEvery: "PT15S",
           gateKey: "preflight:owner/repo#2",
         }),
       });

package/e2e/readiness-gate.e2e.ts

@@ -18,14 +18,14 @@
 // The probes are deterministic shell builtins (`true`/`false`) so the flow is hermetic — no
 // network, no GitHub. GitHub transport is still forced offline to match the sibling e2es.
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, rmSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { after, before, describe, test } from "node:test";
 import { fileURLToPath } from "node:url";
 import { bootTestApp, type TestApp } from "@nanobpm/urban-testkit";
 
 const APP_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+let dbSeq = 0;
 
 const GITHUB_ENV_OVERRIDES: Record<string, string> = {
   NANO_PR_GITHUB_TRANSPORT: "token",
@@ -49,7 +49,8 @@ function takenFlows(app: TestApp): string[] {
 // Each scenario boots its own app so `takenSequenceFlows` (engine-global + cumulative) reflects
 // exactly one instance's history.
 async function boot(): Promise<{ app: TestApp; dbDir: string }> {
-  const dbDir = mkdtempSync(join(tmpdir(), "nwf-readiness-"));
+  const dbDir = join(APP_ROOT, ".test-artifacts", `nwf-readiness-${process.pid}-${dbSeq++}`);
+  mkdirSync(dbDir, { recursive: true });
   const app = await bootTestApp(APP_ROOT, { env: { NANO_APP_DB_URL: `file:${join(dbDir, "app.db")}` } });
   return { app, dbDir };
 }
@@ -79,6 +80,7 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
           probe: { kind: "command", target: "true", poll: { everyMs: 5, timeoutMs: 5000, backoff: "fixed" } },
           // A long engine timer that must NOT fire — readiness wins the race first.
           probeTimeout: "PT30M",
+          probePollEvery: "PT15S",
           onTimeout: "escalate",
         },
       });
@@ -90,8 +92,8 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
         `the gate released on the readiness signal (flows: ${flows.join(", ")})`,
       );
       assert.ok(
-        flows.includes("probe->probe-done"),
-        "the probe branch settled after publishing the readiness signal",
+        flows.includes("probe-loop->probe-done"),
+        "the probe loop branch settled after publishing the readiness signal",
       );
       // The gate never timed out — no escalation userTask exists.
       const tasks = await app.engine.searchUserTasks({});
@@ -115,15 +117,16 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
           gateKey: "gate-timeout-1",
           // `false` is never ready; a tiny local budget makes the worker exhaust fast (real time),
           // leaving the ENGINE timer as the authoritative bound.
-          probe: { kind: "command", target: "false", poll: { everyMs: 5, timeoutMs: 40, backoff: "fixed" } },
+          probe: { kind: "command", target: "false", poll: { everyMs: 15_000, timeoutMs: 60_000, backoff: "fixed" } },
           probeTimeout: "PT1M",
+          probePollEvery: "PT15S",
           onTimeout: "escalate",
         },
       });
       await app.settle();
 
-      // The wait has NOT hung and has NOT yet escalated: the probe branch settled not-ready, and the
-      // gate is parked on the timer catch — no escalation userTask before the timer's duration.
+      // The wait has NOT hung and has NOT yet escalated: the first single-shot probe returned not-ready,
+      // and the retry cadence is parked on the engine-owned poll timer.
       const beforeTimer = await app.engine.searchUserTasks({ processInstanceKey });
       assert.equal(
         beforeTimer.filter((t) => t.elementId === "readiness-escalation").length,
@@ -133,9 +136,18 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
       const beforeFlows = takenFlows(app);
       assert.ok(!beforeFlows.includes("wait-ready->gate-ready"), "a never-green probe never releases as ready");
 
-      // Advancing past the engine timer is the ONLY thing that ends the wait — proving the bound is
-      // engine-owned. The token races off the timer catch onto the escalation userTask.
-      await app.advanceTime(61_000);
+      await app.advanceTime(15_000);
+      const afterPoll = takenFlows(app);
+      assert.ok(afterPoll.includes("wait-poll->probe"), "the engine timer, not a worker sleep loop, schedules the next probe");
+      assert.equal(
+        (await app.engine.searchUserTasks({ processInstanceKey })).filter((t) => t.elementId === "readiness-escalation").length,
+        0,
+        "one poll interval only re-probes; it does not consume the timeout",
+      );
+
+      // Advancing past the engine timer is the ONLY thing that ends the wait. The timeout arm routes
+      // through one last empirical probe before the event-based gateway timer opens escalation.
+      await app.advanceTime(46_000);
 
       const afterFlows = takenFlows(app);
       assert.ok(
@@ -171,6 +183,7 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
           gateKey: "gate-abandon-1",
           probe: { kind: "command", target: "false", poll: { everyMs: 5, timeoutMs: 40, backoff: "fixed" } },
           probeTimeout: "PT1M",
+          probePollEvery: "PT15S",
           onTimeout: "escalate",
         },
       });
@@ -209,6 +222,7 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
           gateKey: "gate-continue-1",
           probe: { kind: "command", target: "false", poll: { everyMs: 5, timeoutMs: 40, backoff: "fixed" } },
           probeTimeout: "PT1M",
+          probePollEvery: "PT15S",
           onTimeout: "continue",
         },
       });
@@ -236,6 +250,7 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
           // Neither probe.onTimeout nor a top-level onTimeout is declared.
           probe: { kind: "command", target: "false", poll: { everyMs: 5, timeoutMs: 40, backoff: "fixed" } },
           probeTimeout: "PT1M",
+          probePollEvery: "PT15S",
         },
       });
       await app.settle();
@@ -266,6 +281,7 @@ describe("nano-workforce artifact-readiness wait-gate (readiness-gate.bpmn)", ()
           // The descriptor asks to continue; a stale top-level onTimeout says escalate. probe wins.
           probe: { kind: "command", target: "false", onTimeout: "continue", poll: { everyMs: 5, timeoutMs: 40, backoff: "fixed" } },
           probeTimeout: "PT1M",
+          probePollEvery: "PT15S",
           onTimeout: "escalate",
         },
       });

package/operations/compileDeliveryGraph.test.ts

@@ -29,6 +29,9 @@ test("compile-delivery-graph: a well-formed graph → 200 with the pure preview"
   assertEquals(res.status, 200);
   assertEquals(res.body.ok, true);
   assert(typeof res.body.bpmn === "string" && res.body.bpmn.length > 0);
+  // The compile preview must show what actually deploys — including the auto-laid-out diagram
+  // interchange (#440), so the process explorer can render the previewed graph.
+  assert(res.body.bpmn.includes("<bpmndi:BPMNDiagram"), "the previewed bpmn carries diagram interchange");
   assert(typeof res.body.diagram === "string" && res.body.diagram.length > 0);
   assertEquals(res.body.resolved.nodes.length, 2);
   assertEquals(res.body.humanNodes.length, 1);

package/operations/compileDeliveryGraph.ts

@@ -20,7 +20,7 @@ export default defineOperation("compileDeliveryGraph", async ({ body }, app) =>
   // the SEMANTIC checks (acyclicity, edge integrity, fact resolution) the schema cannot express. A
   // directly-invoked delegate could still pass `undefined` — the compiler reads its input as
   // `unknown` and maps that to a clean `ok:false`, never a 500.
-  const result = compileDeliveryGraph(body);
+  const result = await compileDeliveryGraph(body);
   if (!result.ok) {
     app.log.warn("compile-delivery-graph rejected", { errors: result.errors.length });
     return { status: 400, body: result };

package/operations/dispatchDeliveryGraph.ts

@@ -37,7 +37,7 @@ export default defineOperation("dispatchDeliveryGraph", async (input, app) => {
   // dispatches. A compile failure here surfaces as a clean 400 rather than reaching the start door.
   let approvalToken: string | undefined;
   if (approve) {
-    const compiled = compileDeliveryGraph(parsed.graph);
+    const compiled = await compileDeliveryGraph(parsed.graph);
     if (!compiled.ok) {
       app.log.warn("dispatch-delivery-graph rejected: compile", { errors: compiled.errors.length });
       return {

package/operations/previewDeliveryGraph.ts

@@ -22,7 +22,7 @@ export default defineOperation("previewDeliveryGraph", async ({ body }, app) =>
     app.log.warn("preview-delivery-graph rejected: parse", { message: parsed.error });
     return { status: 400, body: { ok: false, error: parsed.error } };
   }
-  const compiled = compileDeliveryGraph(parsed.graph);
+  const compiled = await compileDeliveryGraph(parsed.graph);
   if (!compiled.ok) {
     app.log.warn("preview-delivery-graph rejected: compile", { errors: compiled.errors.length });
     return {

package/operations/startDeliveryGraph.ts

@@ -56,7 +56,7 @@ export default defineOperation("startDeliveryGraph", async ({ body }, app) => {
 
   // 2) Compile via S1. This yields the deterministic BPMN (→ the content digest / approval token) plus
   //    the graph's shape: its side effects (whether approval is required), human stops, and node count.
-  const compiled = compileDeliveryGraph(graph);
+  const compiled = await compileDeliveryGraph(graph);
   if (!compiled.ok) {
     app.log.warn("start-delivery-graph rejected: compile", { count: compiled.errors.length });
     return { status: 400, body: { ok: false, errors: compiled.errors } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.120.0",
+  "version": "0.120.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,7 +59,8 @@
   },
   "dependencies": {
     "@nanobpm/agentic": "^0.1.0",
-    "@nanobpm/urban": "^0.75.0"
+    "@nanobpm/urban": "^0.75.0",
+    "bpmn-auto-layout": "^2.0.0-alpha.2"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",