@nanobpm/nano-workforce 0.30.0 → 0.32.0

package/workers/record-results/worker.test.ts

@@ -0,0 +1,91 @@
+// Red/green for the no-work terminal guard (issue #86).
+//
+// `record-results` is the epic's finalizer. Before this guard it always marked the plan `done` and
+// completed the process GREEN — even when ZERO PRs were opened (empty plan, or every task
+// blocked/skipped). A no-op run was indistinguishable from success (instance 21). It now raises a
+// non-retryable `NO_WORK_DISPATCHED` BpmnError (→ incident) when the epic finalizes with no opened
+// PR, recording a `failed` terminal status + outcome first, so "accomplished nothing" surfaces
+// instead of masquerading as a completed epic.
+import { assertEquals, assertRejects } from "jsr:@std/assert@1";
+import { BpmnError } from "@nanobpm/urban";
+import handler from "./worker.ts";
+import type { PlanTaskStatus } from "../../app/plan.ts";
+
+interface Row {
+  id: number;
+  plan_key: string;
+  task_id: string;
+  status: PlanTaskStatus;
+}
+
+function fakeApp(rows: Row[]) {
+  const plans: Record<string, unknown>[] = [];
+  return {
+    data: {
+      table(name: string, key: string) {
+        if (name === "plans") {
+          return {
+            // deno-lint-ignore no-explicit-any
+            update: (k: any, patch: any) => {
+              plans.push({ [key]: k, ...patch });
+              return Promise.resolve(patch);
+            },
+          };
+        }
+        // plan_tasks
+        return {
+          // deno-lint-ignore no-explicit-any
+          find: (q: any) =>
+            Promise.resolve(
+              rows.filter((r) =>
+                Object.entries(q).every(([f, v]) =>
+                  (r as unknown as Record<string, unknown>)[f] === v
+                )
+              ),
+            ),
+        };
+      },
+    },
+    log: () => {},
+    _plans: plans,
+    // deno-lint-ignore no-explicit-any
+  } as any;
+}
+
+const call = async (app: unknown, planKey = "o/r#1") =>
+  // deno-lint-ignore no-explicit-any
+  await handler({ variables: { planKey } } as any, app as any);
+
+Deno.test("no opened PRs (empty plan) hard-fails with NO_WORK_DISPATCHED", async () => {
+  const app = fakeApp([]);
+  const err = await assertRejects(() => call(app), BpmnError);
+  assertEquals((err as BpmnError).errorCode, "NO_WORK_DISPATCHED");
+  // The failure outcome + terminal `failed` status must be recorded before throwing, so the DB
+  // state matches the parked incident and startPlan can re-plan it.
+  const plan = app._plans.at(-1) as Record<string, unknown>;
+  assertEquals(plan.status, "failed");
+  assertEquals(plan.outcome, "no work dispatched — the planner produced no tasks");
+});
+
+Deno.test("tasks present but none opened (all skipped/blocked) hard-fails", async () => {
+  const app = fakeApp([
+    { id: 1, plan_key: "o/r#1", task_id: "a", status: "skipped" },
+    { id: 2, plan_key: "o/r#1", task_id: "b", status: "blocked" },
+  ]);
+  const err = await assertRejects(() => call(app), BpmnError);
+  assertEquals((err as BpmnError).errorCode, "NO_WORK_DISPATCHED");
+  const plan = app._plans.at(-1) as Record<string, unknown>;
+  assertEquals(plan.status, "failed");
+  assertEquals(plan.outcome, "no work dispatched — every task was blocked or skipped");
+});
+
+Deno.test("at least one opened PR finalizes cleanly (no throw)", async () => {
+  const app = fakeApp([
+    { id: 1, plan_key: "o/r#1", task_id: "a", status: "opened" },
+    { id: 2, plan_key: "o/r#1", task_id: "b", status: "skipped" },
+  ]);
+  await call(app);
+  const plan = app._plans.at(-1) as Record<string, unknown>;
+  assertEquals(plan.status, "done");
+  assertEquals(plan.outcome, "1 PR(s) dispatched to convergence");
+});

package/workers/record-results/worker.ts

@@ -2,8 +2,15 @@
 //
 // PR enrollment now happens per wave in `pr.record-wave` (so later waves can declare earlier
 // waves' PRs as dependencies), leaving this worker as the terminal finalizer: it summarizes the
-// plan from `plan_tasks` and marks it `done`. It reads no `results` — every task's outcome was
-// already recorded by `record-wave` (opened / blocked) or `select-wave` (skipped).
+// plan from `plan_tasks`. It reads no `results` — every task's outcome was already recorded by
+// `record-wave` (opened / blocked) or `select-wave` (skipped).
+//
+// Two terminal outcomes:
+//   • at least one PR opened → mark the plan `done` (dispatched to convergence).
+//   • zero PRs opened → record a `failed` outcome for observability, then throw the non-retryable
+//     `NO_WORK_DISPATCHED` BpmnError so the engine parks the instance on an incident instead of
+//     completing green (issue #86). The `failed` status is terminal, so `startPlan` can re-plan it.
+import { BpmnError } from "@nanobpm/urban";
 import type { AppJobHandler } from "@nanobpm/urban";
 import { planTasks } from "../../app/plan.ts";
 
@@ -18,11 +25,34 @@ const handler: AppJobHandler<In> = async (job, app) => {
   const rows = await planTasks(app.data).find({ plan_key: planKey });
   const opened = rows.filter((r) => r.status === "opened").length;
 
-  const patch: Record<string, unknown> = { status: "done", updated_at: ts };
-  // When the planner emitted no tasks, `record-plan` already set a meaningful outcome (its
-  // note) and moved the plan to `done`. Preserve it rather than overwriting with "0 PR(s)…".
-  if (rows.length > 0) patch.outcome = `${opened} PR(s) dispatched to convergence`;
-  await app.data.table("plans", "plan_key").update(planKey, patch);
+  // Categorical no-work guard (issue #86): the epic reached its finalizer having opened ZERO PRs —
+  // an empty plan (e.g. the planner agent could not persist its result), or every task
+  // blocked/skipped. It accomplished nothing, so it must NOT complete green and masquerade as
+  // success. Record a `failed` terminal outcome for observability (so the DB state matches the
+  // parked incident and `startPlan` can re-plan it — `dispatched`/`done` would otherwise block a
+  // restart), then raise a non-retryable BpmnError so the engine parks the instance on an incident
+  // (no boundary catches `NO_WORK_DISPATCHED`) instead of completing the process. This backstops
+  // any zero-work path regardless of the review outcome.
+  if (opened === 0) {
+    const outcome = rows.length === 0
+      ? "no work dispatched — the planner produced no tasks"
+      : "no work dispatched — every task was blocked or skipped";
+    await app.data.table("plans", "plan_key").update(planKey, {
+      status: "failed",
+      outcome,
+      updated_at: ts,
+    });
+    app.log("error", `record-results: ${planKey} finalized with 0 opened PRs`, {
+      taskCount: rows.length,
+    });
+    throw new BpmnError("NO_WORK_DISPATCHED", `${planKey}: ${outcome}`);
+  }
+
+  await app.data.table("plans", "plan_key").update(planKey, {
+    status: "done",
+    outcome: `${opened} PR(s) dispatched to convergence`,
+    updated_at: ts,
+  });
 
   return {};
 };