@nanobpm/nano-workforce 0.151.0 → 0.151.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.151.1](https://github.com/nanobpm/nano-workforce/compare/v0.151.0...v0.151.1) (2026-08-28)
+
+### Bug Fixes
+
+* **delivery-graph:** read parked human nodes via searchUserTasks until engine projects USER_TASK wait states ([#595](https://github.com/nanobpm/nano-workforce/issues/595)) ([5dfb3fe](https://github.com/nanobpm/nano-workforce/commit/5dfb3fed1b0483c3a110979bd0aa7802ef3b17d2)), closes [#542](https://github.com/nanobpm/nano-workforce/issues/542) [Magikcraft/nano-bpm#1042](https://github.com/Magikcraft/nano-bpm/issues/1042) [nanobpm/nano-workforce#594](https://github.com/nanobpm/nano-workforce/issues/594)
+
 ## [0.151.0](https://github.com/nanobpm/nano-workforce/compare/v0.150.4...v0.151.0) (2026-08-28)
 
 ### Features

package/app/deliveryGraphRun.test.ts

@@ -115,7 +115,55 @@ test("pollDeliveryGraphPhase: a numeric engine processInstanceKey still matches
     // The engine can yield a NUMERIC key; the poller compares against the string process_key.
     const engine = {
       searchProcessInstances: async () => [{ processInstanceKey: 12345, state: "COMPLETED" }],
-      searchElementInstanceWaitStates: async () => [],
+      searchUserTasks: async () => [],
+    };
+    await pollDeliveryGraphPhase(data, engine as never);
+    assertEquals((await runs.get("rk"))?.status, "done");
+  });
+});
+
+// ── pollDeliveryGraphPhase: engine 422 on USER_TASK wait-state read (nano-bpm#1042) ────────────
+// The deployed engine's wait-state read model only accepts JOB | MESSAGE, so a `waitStateType:
+// "USER_TASK"` filter 422s on a live gateway. This pass reads parks via `searchUserTasks({ state:
+// "CREATED" })` — NOT `searchElementInstanceWaitStates` — precisely so that 422 can never reject the
+// `Promise.all` and skip reconciliation. Guard both projections this pass owns against regressing back
+// onto the wait-state channel: the parked-label projection AND the COMPLETED → `done` transition.
+test("pollDeliveryGraphPhase: with an engine that 422s on waitStateType=USER_TASK, the parked label still projects (reads via searchUserTasks)", async () => {
+  await withData(async (data) => {
+    const runs = deliveryGraphRuns(data);
+    const humanEl = humanTaskElementId("publish");
+    await runs.insert({
+      ...claimRow("running"),
+      process_key: "PI-1",
+      human_labels: JSON.stringify({ [humanEl]: "run the manual OTP publish" }),
+    });
+    // A client that rejects the wait-state read the way a live gateway does (HTTP 422). If the poller
+    // reached for it, the throw would reject the Promise.all and reconciliation would be skipped.
+    const engine = {
+      searchProcessInstances: async () => [{ processInstanceKey: "PI-1", state: "ACTIVE" }],
+      searchUserTasks: async () => [{ userTaskKey: "ut-1", elementId: humanEl }],
+      searchElementInstanceWaitStates: async () => {
+        throw new Error("HttpSdkError: HTTP 422 — filter.waitStateType did not match any variant of untagged enum WaitStateTypeFilterProperty");
+      },
+    };
+    await pollDeliveryGraphPhase(data, engine as never);
+    const row = await runs.get("rk");
+    assertEquals(row?.status, "running");
+    assertEquals(row?.phase, "Parked on human node: run the manual OTP publish");
+    assertEquals(row?.phase_node_id, humanEl);
+  });
+});
+
+test("pollDeliveryGraphPhase: with an engine that 422s on waitStateType=USER_TASK, a COMPLETED instance still reconciles to done", async () => {
+  await withData(async (data) => {
+    const runs = deliveryGraphRuns(data);
+    await runs.insert({ ...claimRow("running"), process_key: "PI-2" });
+    const engine = {
+      searchProcessInstances: async () => [{ processInstanceKey: "PI-2", state: "COMPLETED" }],
+      searchUserTasks: async () => [],
+      searchElementInstanceWaitStates: async () => {
+        throw new Error("HttpSdkError: HTTP 422 — filter.waitStateType did not match any variant of untagged enum WaitStateTypeFilterProperty");
+      },
     };
     await pollDeliveryGraphPhase(data, engine as never);
     assertEquals((await runs.get("rk"))?.status, "done");

package/app/service.ts

@@ -2391,13 +2391,19 @@ export async function pollEpicPhase(
  * a graph that ends normally would otherwise stay `running` forever). Generalises the `epic_phase`
  * derived-phase machinery to a graph whose element ids aren't known ahead of time: the parked-node
  * label is derived from the run row's stamped `human_labels` + the instance's live USER_TASK parks.
- * The parked node is now sourced from the unified element-instance wait-state channel
- * (`searchElementInstanceWaitStates`, nano-ide#473) rather than a separate user-task search, folding
- * this read onto the same live element-instance model the epic derivation uses (S8, #542). Scoped to
- * `running` rows (an `awaiting-approval` run has no instance yet), so it stays O(in-flight). */
+ * The parked node is read via `searchUserTasks({ state: "CREATED" })` rather than the unified
+ * element-instance wait-state channel (`searchElementInstanceWaitStates({ waitStateType: "USER_TASK" })`,
+ * S8, #542/nano-ide#473): the deployed engine's wait-state read model only accepts `JOB | MESSAGE`, so
+ * a `USER_TASK` filter 422s on a live gateway, rejecting the whole `Promise.all` and skipping this pass's
+ * reconciliation entirely (the parked label never updates and the COMPLETED → `done` transition this pass
+ * OWNS never fires, leaving a finished graph `running` forever). `deriveDeliveryPhase` consumes only
+ * `elementId` from the park rows, which `searchUserTasks` supplies the same way.
+ * TODO(Magikcraft/nano-bpm#1042): re-fold onto `searchElementInstanceWaitStates({ waitStateType:
+ * "USER_TASK" })` once the engine projects `USER_TASK` wait states and that engine is deployed.
+ * Scoped to `running` rows (an `awaiting-approval` run has no instance yet), so it stays O(in-flight). */
 export async function pollDeliveryGraphPhase(
   data: DataLayer,
-  engine: Pick<EngineClient, "searchProcessInstances" | "searchElementInstanceWaitStates">,
+  engine: Pick<EngineClient, "searchProcessInstances" | "searchUserTasks">,
 ) {
   for (const run of await deliveryGraphRuns(data).find({ status: "running" })) {
     if (!run.process_key) continue;
@@ -2405,7 +2411,7 @@ export async function pollDeliveryGraphPhase(
     try {
       const [snapshots, parks] = await Promise.all([
         engine.searchProcessInstances({ processInstanceKeys: [processKey] }),
-        engine.searchElementInstanceWaitStates({ processInstanceKey: processKey, waitStateType: "USER_TASK" }),
+        engine.searchUserTasks({ processInstanceKey: processKey, state: "CREATED" }),
       ]);
       const state = snapshots.find((s) => String(s.processInstanceKey) === processKey)?.state ?? null;
       const projection = deriveDeliveryPhase(state, parks, parseHumanLabels(run.human_labels));

package/package.json

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