@nanobpm/nano-workforce 0.60.0 → 0.61.1

package/workers/record-blocked-ack/worker.ts

@@ -0,0 +1,36 @@
+// pr.record-blocked-ack — an operator acknowledged a blocked single-issue feature run (issue #172).
+//
+// A `blocked` outcome from `record-feature` is routed to the `feature-blocked` operator user task,
+// which keeps the instance alive (parked at the operators' inbox) and holds the row at the
+// NON-terminal `awaiting_operator` status so a re-dispatch of the same issue short-circuits instead
+// of spawning an orphaned parallel run. This worker fires once the operator completes that task: it
+// settles the row at the TERMINAL `blocked` status and records the operator's disposition note, so
+// the same issue can be re-dispatched afterwards. Persistence goes through the record gateway
+// (`app.data`), never hand-written SQL — matching the other record-* workers.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { featureRuns } from "../../app/feature.ts";
+
+interface In extends Record<string, unknown> {
+  featureKey: string;
+  note?: unknown;
+}
+
+const str = (v: unknown): string | undefined =>
+  typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined;
+
+const handler: AppJobHandler<In, Record<string, never>> = async (job, app) => {
+  const featureKey = job.variables.featureKey;
+  const note = str(job.variables.note);
+  const ts = new Date().toISOString();
+
+  await featureRuns(app.data).update(featureKey, {
+    status: "blocked",
+    delivery_label: note ? `operator: ${note}` : "acknowledged",
+    updated_at: ts,
+  });
+  app.log.info("record-blocked-ack", { featureKey, note: note ?? null });
+
+  return {};
+};
+
+export default handler;

package/workers/record-feature/worker.ts

@@ -45,15 +45,21 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   // (the run is complete), just with no `pr_key` to converge.
   const prKey = parsed?.prKey ?? null;
   const featureStatus: FeatureRunStatus = status;
+  // A `blocked` outcome is routed (via the `blocked?` gateway) to the `feature-blocked` operator user
+  // task, which keeps the instance ALIVE until a human acknowledges it. Persist the row as the
+  // NON-terminal `awaiting_operator` for that parked window so a re-dispatch of the same issue
+  // short-circuits (no orphaned parallel run); `record-blocked-ack` writes the terminal `blocked`
+  // once the operator completes the task. `opened`/`skipped` are already terminal — persist as-is.
+  const rowStatus: FeatureRunStatus = status === "blocked" ? "awaiting_operator" : status;
   const ts = new Date().toISOString();
 
   await featureRuns(app.data).update(featureKey, {
-    status: featureStatus,
+    status: rowStatus,
     pr_key: prKey,
     outcome: summary ?? null,
     updated_at: ts,
   });
-  app.log.info("record-feature", { featureKey, featureStatus, prKey });
+  app.log.info("record-feature", { featureKey, featureStatus, rowStatus, prKey });
 
   return { featureStatus, prKey };
 };