@nanobpm/nano-workforce 0.95.0 → 0.96.0

package/pages/tasks.page.json

@@ -110,6 +110,22 @@
           }
         ],
         "rowKey": "user_task_key",
+        "rowActions": [
+          {
+            "label": "Abandon",
+            "confirm": "Abandon this escalated task? The run gives up on it (no PR).",
+            "showWhenField": "user_task_key",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "resolution": "abandon"
+                }
+              }
+            }
+          }
+        ],
         "detail": {
           "linkField": "subject_url",
           "fields": [
@@ -117,7 +133,26 @@
               "field": "question",
               "label": "Escalation question"
             }
-          ]
+          ],
+          "form": {
+            "showWhenField": "user_task_key",
+            "title": "Answer escalation",
+            "promptField": "question",
+            "inputKey": "answer",
+            "inputLabel": "Guidance for the implementation agent",
+            "submitLabel": "Answer & re-dispatch",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "successLabel": "Answered — the agent will resume",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "resolution": "answer",
+                  "answer": "{{form.answer}}"
+                }
+              }
+            }
+          }
         },
         "refreshMs": 5000
       }
@@ -176,6 +211,22 @@
           }
         ],
         "rowKey": "user_task_key",
+        "rowActions": [
+          {
+            "label": "Proceed",
+            "confirm": "Proceed with the current plan as-is? It is dispatched unchanged.",
+            "showWhenField": "user_task_key",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "directive": "proceed"
+                }
+              }
+            }
+          }
+        ],
         "detail": {
           "linkField": "subject_url",
           "fields": [
@@ -183,7 +234,26 @@
               "field": "question",
               "label": "Review findings"
             }
-          ]
+          ],
+          "form": {
+            "showWhenField": "user_task_key",
+            "title": "Revise — send the plan back to the planner",
+            "promptField": "question",
+            "inputKey": "notes",
+            "inputLabel": "Revision guidance for the planner",
+            "submitLabel": "Revise & re-plan",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "successLabel": "Sent back — the planner will revise",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "directive": "revise",
+                  "notes": "{{form.notes}}"
+                }
+              }
+            }
+          }
         },
         "refreshMs": 5000
       }
@@ -242,6 +312,50 @@
           }
         ],
         "rowKey": "user_task_key",
+        "rowActions": [
+          {
+            "label": "Proceed",
+            "confirm": "Accept the red trial merge and continue?",
+            "showWhenField": "user_task_key",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "action": "proceed"
+                }
+              }
+            }
+          },
+          {
+            "label": "Rebase",
+            "confirm": "Re-run the trial merge?",
+            "showWhenField": "user_task_key",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "action": "rebase"
+                }
+              }
+            }
+          },
+          {
+            "label": "Abandon",
+            "confirm": "Stop and finalize the plan?",
+            "showWhenField": "user_task_key",
+            "action": {
+              "path": "/app/api/actions/complete-user-task",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "variables": {
+                  "action": "abandon"
+                }
+              }
+            }
+          }
+        ],
         "detail": {
           "linkField": "subject_url",
           "fields": [
@@ -400,7 +514,23 @@
               "field": "question",
               "label": "Disposition"
             }
-          ]
+          ],
+          "form": {
+            "showWhenField": "user_task_key",
+            "title": "Acknowledge blocked run",
+            "promptField": "question",
+            "inputKey": "note",
+            "inputLabel": "Disposition note (what you did / why)",
+            "submitLabel": "Acknowledge & close",
+            "action": {
+              "path": "/app/api/actions/acknowledge-blocked",
+              "successLabel": "Acknowledged — the run will close",
+              "body": {
+                "userTaskKey": "{{row.user_task_key}}",
+                "note": "{{form.note}}"
+              }
+            }
+          }
         },
         "refreshMs": 5000
       }

package/resources/processes/plan-fanout.bpmn

@@ -70,6 +70,7 @@
         <nano:shape id="SelectWaveIn" name="Select wave — input">
           <nano:extend name="planKey" type="string" />
           <nano:extend name="currentWave" type="integer" />
+          <nano:extend name="resolvedArtifacts" type="string" list="true" optional="true" />
         </nano:shape>
         <nano:shape id="ResolveTrialAttentionIn" name="Clear trial attention — input">
           <nano:extend name="planKey" type="string" />

package/workers/record-feature-escalation/worker.test.ts

@@ -13,6 +13,7 @@ import handler from "./worker.ts";
 function fakeApp(rows: Record<string, unknown>[]): any {
   const stores: Record<string, Record<string, unknown>[]> = { feature_runs: rows };
   return {
+    stores,
     data: {
       table(name: string, key: string) {
         const store = (stores[name] ??= []);
@@ -22,6 +23,9 @@ function fakeApp(rows: Record<string, unknown>[]): any {
           // biome-ignore lint/suspicious/noExplicitAny: test double
           find: (q: any) => Promise.resolve(store.filter((r) => Object.entries(q).every(([f, v]) => r[f] === v))),
           // biome-ignore lint/suspicious/noExplicitAny: test double
+          findOne: (q: any) =>
+            Promise.resolve(store.find((r) => Object.entries(q).every(([f, v]) => r[f] === v)) ?? null),
+          // biome-ignore lint/suspicious/noExplicitAny: test double
           insert: (row: any) => {
             store.push(row);
             return Promise.resolve(store.length);
@@ -43,7 +47,7 @@ test("record-feature-escalation: flips the run to escalated and persists the que
   const rows = [{ feature_key: "owner/repo#7", status: "running", escalation_question: null, escalation_user_task_key: null }];
   const app = fakeApp(rows);
   const out = await handler(
-    { variables: { featureKey: "owner/repo#7", question: "Which API should I use?" } } as never,
+    { jobKey: "job-1", variables: { featureKey: "owner/repo#7", question: "Which API should I use?" } } as never,
     app,
   );
   assertEquals(out, {});
@@ -51,6 +55,26 @@ test("record-feature-escalation: flips the run to escalated and persists the que
   assertEquals(rows[0].escalation_question, "Which API should I use?");
   // The user task does not exist yet — the pointer is cleared to NULL here (poller fills the real key).
   assertEquals(rows[0].escalation_user_task_key, null);
+  // Dual-write (issue #305): the question is ALSO appended to the canonical `feature_escalations`
+  // audit log so `pollUserTasks` can source it from a surviving table once the denormalised column drops.
+  assertEquals(app.stores.feature_escalations.length, 1);
+  assertEquals(app.stores.feature_escalations[0].feature_key, "owner/repo#7");
+  assertEquals(app.stores.feature_escalations[0].question, "Which API should I use?");
+  assertEquals(app.stores.feature_escalations[0].job_key, "job-1");
+});
+
+test("record-feature-escalation: a retried job (same jobKey) reuses its audit row, never duplicating", async () => {
+  // `record-feature-escalation` is at-least-once: a job that crashed/timed out AFTER the insert but
+  // before job completion re-runs with the SAME jobKey. The `job_key` idempotency guard must reuse the
+  // existing `feature_escalations` row rather than append a duplicate (which would bloat the append-only
+  // log and could skew "latest question" selection). Mirrors `record-plan-review`'s `plan_reviews` guard.
+  const rows = [{ feature_key: "owner/repo#7", status: "running", escalation_question: null, escalation_user_task_key: null }];
+  const app = fakeApp(rows);
+  const job = { jobKey: "job-retry", variables: { featureKey: "owner/repo#7", question: "Which API?" } } as never;
+  await handler(job, app);
+  await handler(job, app); // retry with the same jobKey
+  assertEquals(app.stores.feature_escalations.length, 1, "the retry reuses the row, no duplicate append");
+  assertEquals(app.stores.feature_escalations[0].job_key, "job-retry");
 });
 
 test("record-feature-escalation: clears a stale completable-task pointer at escalation entry", async () => {
@@ -59,7 +83,7 @@ test("record-feature-escalation: clears a stale completable-task pointer at esca
   // to the wrong task until the poller overwrites it; clear it so the row reads "key unknown here".
   const rows = [{ feature_key: "owner/repo#9", status: "running", escalation_question: null, escalation_user_task_key: "stale-ut" }];
   const app = fakeApp(rows);
-  await handler({ variables: { featureKey: "owner/repo#9", question: "Q?" } } as never, app);
+  await handler({ jobKey: "job-9", variables: { featureKey: "owner/repo#9", question: "Q?" } } as never, app);
   assertEquals(rows[0].status, "escalated");
   assertEquals(rows[0].escalation_question, "Q?");
   assertEquals(rows[0].escalation_user_task_key, null);
@@ -68,7 +92,7 @@ test("record-feature-escalation: clears a stale completable-task pointer at esca
 test("record-feature-escalation: a blank/absent question is persisted as NULL (badge/affordance stay off)", async () => {
   const rows = [{ feature_key: "owner/repo#8", status: "running", escalation_question: null }];
   const app = fakeApp(rows);
-  await handler({ variables: { featureKey: "owner/repo#8", question: "   " } } as never, app);
+  await handler({ jobKey: "job-8", variables: { featureKey: "owner/repo#8", question: "   " } } as never, app);
   assertEquals(rows[0].status, "escalated");
   assertEquals(rows[0].escalation_question, null);
 });

package/workers/record-feature-escalation/worker.ts

@@ -13,7 +13,7 @@
 // variables through `searchUserTasks`, so the process variable must be persisted while it is still
 // in scope on the job.
 import type { AppJobHandler } from "@nanobpm/urban";
-import { featureRuns } from "../../app/feature.ts";
+import { featureRuns, recordFeatureEscalation } from "../../app/feature.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
 // Input typed off the model data envelope (`RecordFeatureEscalationIn` in feature.bpmn) — ADR 0040.
@@ -35,6 +35,12 @@ const handler: AppJobHandler<In> = async (job, app) => {
     escalation_user_task_key: null,
     updated_at: new Date().toISOString(),
   });
+  // Append the question to the canonical `feature_escalations` audit log (issue #305) so the poller
+  // can source it from a SURVIVING table once the denormalised `feature_runs.escalation_question`
+  // column is dropped in the contract phase — the feature analogue of `record-plan-review` writing
+  // `plan_reviews`. Dual-write for now (the column above still feeds the legacy page reads); the log
+  // is authoritative for `pollUserTasks`.
+  await recordFeatureEscalation(app.data, { featureKey, question, jobKey: job.jobKey });
   app.log.info("record-feature-escalation", { featureKey, hasQuestion: question !== null });
   return {};
 };

package/workers/select-wave/worker.test.ts

@@ -81,6 +81,43 @@ test("select-wave projects the active wave onto plans.current_wave", async () =>
   assertEquals(plans[0].epic_phase, "Implementing (wave 2/2)");
 });
 
+test("select-wave captures the preflight's resolvedArtifacts onto plans.bound_artifacts (#292 S4)", async () => {
+  // A dependent epic reaching select-wave proves its S3 capability preflight went green; the bound
+  // pkg@version(s) ride `resolvedArtifacts` and must be captured for the S4 operator projection.
+  const rows: Row[] = [
+    { id: 1, plan_key: "owner/repo#63", task_id: "a", title: "A", prompt: "do A", status: "pending", wave: 0 },
+  ];
+  const plans: Record<string, unknown>[] = [{ plan_key: "owner/repo#63" }];
+  await handler(
+    {
+      variables: {
+        planKey: "owner/repo#63",
+        currentWave: 0,
+        // MI output collection: one entry per producer probe; null/empty/whitespace-only entries
+        // are filtered out (a probe may publish without a bind).
+        resolvedArtifacts: ["@scope/api@1.4.0", null, "", "   ", "@scope/core@2.0.0"],
+      },
+      elementId: "select-wave",
+    } as any,
+    fakeApp(rows, [], plans),
+  );
+  assertEquals(plans[0].bound_artifacts, JSON.stringify(["@scope/api@1.4.0", "@scope/core@2.0.0"]));
+});
+
+test("select-wave leaves bound_artifacts untouched for a root epic (no resolvedArtifacts)", async () => {
+  // A root fans out with no preflight -> resolvedArtifacts is null; the stamp must not write an
+  // empty/garbage bound_artifacts (the S4 projection reads NULL as "no bound version").
+  const rows: Row[] = [
+    { id: 1, plan_key: "owner/repo#63", task_id: "a", title: "A", prompt: "do A", status: "pending", wave: 0 },
+  ];
+  const plans: Record<string, unknown>[] = [{ plan_key: "owner/repo#63" }];
+  await handler(
+    { variables: { planKey: "owner/repo#63", currentWave: 0 }, elementId: "select-wave" } as any,
+    fakeApp(rows, [], plans),
+  );
+  assertEquals(plans[0].bound_artifacts, undefined);
+});
+
 test("select-wave nulls all three progress fields when there are no levelized rows", async () => {
   // No plan_tasks rows => waveCount 0. current_wave must be NULL too (not a stray index against a
   // NULL wave_count/wave_label), matching the documented "NULL until dispatched with tasks".

package/workers/select-wave/worker.ts

@@ -61,6 +61,16 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const epicPhase = waveCount > 0
     ? deriveEpicPhase(job.elementId, { current: currentWave, total: waveCount })
     : null;
+  // Inter-epic gate projection (#292 slice S4): reaching select-wave proves this epic's leading
+  // capability PREFLIGHT (S3) already went GREEN, so capture the `resolvedArtifacts` the preflight
+  // bound — the exact `pkg@version`s first carrying each producer's awaited capability — onto the
+  // plan row. `pollWaitGate` (app/service.ts) reads this to show a satisfied dependent's bound
+  // version. NULL for a root (no preflight → no resolved artifacts); display-only, control flow is
+  // unchanged. Filter the MI output to non-blank strings (a probe may publish without a bind),
+  // mirroring the `resolvedArtifacts[item != null]` filter the implement-task prompt uses.
+  const boundArtifacts = Array.isArray(job.variables.resolvedArtifacts)
+    ? job.variables.resolvedArtifacts.filter((v): v is string => typeof v === "string" && v.trim().length > 0)
+    : [];
   try {
     await plans(app.data).update(planKey, {
       // Keep the three progress fields consistent: with no levelized rows (waveCount 0) there is
@@ -69,6 +79,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
       wave_count: waveCount > 0 ? waveCount : null,
       wave_label: waveCount > 0 ? `${currentWave + 1}/${waveCount}` : null,
       ...(epicPhase ? { epic_phase: epicPhase } : {}),
+      ...(boundArtifacts.length > 0 ? { bound_artifacts: JSON.stringify(boundArtifacts) } : {}),
       updated_at: ts,
     });
   } catch (err) {