@nanobpm/nano-workforce 0.103.0 → 0.105.0

package/workers/conformance-record/worker.ts

@@ -0,0 +1,95 @@
+// pr.conformance-record — persist the `senior:conformance` agent's result into `plan_conformance`
+// (052_plan_conformance.sql): the outcome status, the report comment it posted on the epic issue,
+// the per-item verdict counts, and the two deviation counts (raised / unraised). Advisory only —
+// this gates no control flow; it exists so the epic surface can show what the conformance audit
+// concluded, and (in a later slice) drive escalation off `has_deviations`.
+//
+// The agentTask runner hoists the agent's result-JSON keys (`status`, `commentUrl`, the counts,
+// `hasDeviations`, `summary`) into top-level process variables (same mechanism pr.retro-record
+// reads `status`/`pr`/`summary` through), and exposes the raw transcript under the
+// `io.nanobpm.agentResult` envelope's `.output`.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { recordConformance } from "../../app/conformance.ts";
+import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
+
+const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
+
+// Input typed off the model data envelope (`ConformanceRecordIn` in retro.bpmn) — ADR 0040.
+type In = WorkerInputs["pr.conformance-record"];
+
+function asStr(v: unknown): string | null {
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : null;
+}
+
+function asInt(v: unknown): number {
+  // Tolerate a numeric string ("1") too — the agentTask runner hoists result-JSON keys as-is, and an
+  // agent may emit counts as strings; silently coercing those to 0 would wrongly clear the verdict.
+  const n = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : Number.NaN;
+  return Number.isFinite(n) ? Math.max(0, Math.trunc(n)) : 0;
+}
+
+// Tolerant boolean coercion mirroring record-plan-review's `isApproved`: honour boolean `true` OR a
+// case-insensitive "true" string, so a stringified flag the agent hoists isn't silently dropped.
+function asBool(v: unknown): boolean {
+  return v === true || (typeof v === "string" && v.trim().toLowerCase() === "true");
+}
+
+function asStatus(v: unknown, hasComment: boolean): "filed" | "skipped" | "blocked" {
+  const s = asStr(v);
+  if (s === "filed" || s === "skipped" || s === "blocked") {
+    // A "filed" with no report comment is not really filed — downgrade to skipped so the record
+    // never claims a report a human can't open.
+    if (s === "filed" && !hasComment) return "skipped";
+    return s;
+  }
+  return hasComment ? "filed" : "skipped";
+}
+
+const handler: AppJobHandler<In> = async (job, app) => {
+  const planKey = job.variables.planKey;
+
+  const commentUrl = asStr(job.variables.commentUrl);
+  const status = asStatus(job.variables.status, commentUrl !== null);
+  const summary = asStr(job.variables.summary);
+
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
+  const env = (job.variables as Record<string, unknown>)[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
+  const report = typeof env?.output === "string" ? env.output : null;
+
+  // Only a "filed" audit produced a verified verdict; a skipped/blocked one has no trustworthy
+  // per-item counts or deviations, so persist zeros rather than whatever the agent hoisted. This
+  // keeps the row internally consistent (no status="skipped" with has_deviations=1) and honours the
+  // schema/prompt contract that skipped/blocked audits omit counts. summary + report are retained as
+  // human-readable context explaining why the audit didn't file.
+  const filed = status === "filed";
+  const slicesReduced = filed ? asInt(job.variables.slicesReduced) : 0;
+  const slicesNotVerified = filed ? asInt(job.variables.slicesNotVerified) : 0;
+  const deviationsUnraised = filed ? asInt(job.variables.deviationsUnraised) : 0;
+  // Derive `has_deviations` from ground truth rather than trusting the agent's boolean alone: any
+  // reduced / not-verified item, or any unraised deviation, means the epic did not cleanly meet its
+  // spec. The agent's flag is honoured as an additional trigger but can't suppress a real signal.
+  // Forced false for a non-filed audit (all counts are zeroed above, and there is no verified verdict).
+  const hasDeviations = filed &&
+    (asBool(job.variables.hasDeviations) ||
+      slicesReduced > 0 || slicesNotVerified > 0 || deviationsUnraised > 0);
+
+  await recordConformance(app.data, planKey, {
+    status,
+    commentUrl: filed ? commentUrl : null,
+    slicesMet: filed ? asInt(job.variables.slicesMet) : 0,
+    slicesReduced,
+    slicesNotVerified,
+    deviationsRaised: filed ? asInt(job.variables.deviationsRaised) : 0,
+    deviationsUnraised,
+    hasDeviations,
+    summary,
+    report,
+  });
+
+  app.log.info(
+    `conformance-record: ${planKey} — status=${status} deviations=${hasDeviations ? "yes" : "no"}`,
+  );
+  return {};
+};
+
+export default handler;

package/workers/merge/worker.test.ts

@@ -26,6 +26,10 @@ function fakeApp() {
               Promise.resolve(
                 store.filter((r) => Object.entries(q).every(([f, v]) => r[f] === v)),
               ),
+            findOne: (q: any) =>
+              Promise.resolve(
+                store.find((r) => Object.entries(q).every(([f, v]) => r[f] === v)) ?? null,
+              ),
             insert: (row: any) => {
               store.push(row);
               return Promise.resolve(store.length);

package/workers/merge/worker.ts

@@ -12,11 +12,11 @@
 // shapes the escalation payload on a block.
 import type { AppJobHandler } from "@nanobpm/urban";
 import { matchTags, tag } from "@nanobpm/urban/effect";
-import { ABANDONED_STATUS, abandonTokenFromUrl } from "../../app/abandon.ts";
+import { abandonTokenFromUrl } from "../../app/abandon.ts";
 import { checkBaseTarget, classifyBaseGuard } from "../../app/baseGuard.ts";
 import { classifyPrLiveness, enqueueViaComment, fetchPrState, mergePr } from "../../app/github.ts";
 import { classifyMergeLanding, DEFAULT_MERGE_PROTOCOL, loadMergeProtocol } from "../../app/mergeProtocol.ts";
-import { ensurePr, MERGE_ADMIN, MERGE_METHOD } from "../../app/service.ts";
+import { abandonClosedPr, ensurePr, MERGE_ADMIN, MERGE_METHOD } from "../../app/service.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
 // Input typed off the model data envelope (`MergeAttemptIn` in merge-loop.bpmn) — ADR 0040.
@@ -74,22 +74,17 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   // user task: a closed PR is terminal state, not a human decision. Symmetric with the merged
   // short-circuit above and runs on the same live-state read, so one `fetchPrState` classifies both.
   if (liveness === "closed") {
-    await app.data.table("merges", "id").insert({
-      pr_key: prKey,
-      outcome: "abandoned",
-      method: "pr-closed",
-      detail: "PR was closed on GitHub without merging (e.g. superseded) — abandoning the merge loop",
-      at: now,
-    });
-    // Terminal status write. This branch drives the model's terminate/abandon end event, which runs
-    // NO mark-merged worker (the merged path's `pr.mark-merged` is what sets `status:"merged"`). If
-    // we don't flip the row here it lingers on its in-flight status (e.g. the transient `merging`),
-    // so `activePrs`/delivery keep treating a dead PR as live. Symmetric with mark-merged's write;
-    // `ensurePr` above guarantees the row exists to update.
-    await app.data.table("pull_requests", "pr_key").update(prKey, {
-      status: ABANDONED_STATUS,
-      updated_at: now,
-    });
+    // One canonical abandon writer (`abandonClosedPr`, app/service.ts) records the terminal `merges`
+    // audit row and flips the `pull_requests` row — and every `plan_tasks` row keyed to this PR — to
+    // `abandoned`. Flipping the task row (not just the PR row) drops a dead wave member out of the
+    // wave-merge gate (#352). This branch drives the model's terminate/abandon end event, which runs
+    // NO mark-merged worker, so the terminal write must happen here; `ensurePr` above guarantees the
+    // PR row exists to update. Symmetric with the merged short-circuit on the same live-state read.
+    await abandonClosedPr(
+      app.data,
+      prKey,
+      "PR was closed on GitHub without merging (e.g. superseded) — abandoning the merge loop",
+    );
     return { mergeStatus: "abandoned" };
   }
 

package/workers/retro-gather/worker.test.ts

@@ -37,6 +37,8 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
 test("retro-gather: emits a digest brief + learning count for the plan", async () => {
   const { data, stores } = memData();
   stores["plans"] = [{ plan_key: "o/r#3", repo: "o/r", issue_url: "https://x/3", title: "Epic" }];
+  stores["plan_tasks"] = [{ id: 1, plan_key: "o/r#3", task_index: 0, task_id: "t1", title: "Auth", prompt: "add auth", status: "opened", pr_key: "o/r#10" }];
+  stores["pull_requests"] = [{ pr_key: "o/r#10", status: "merged" }];
   await appendEntry(data, "o/r#3", { author_task: "t1", kind: "learning", body: "regen before build" });
   await appendEntry(data, "o/r#3", { author_task: "t2", kind: "learning", body: "use nextest" });
 
@@ -50,6 +52,10 @@ test("retro-gather: emits a digest brief + learning count for the plan", async (
   assertStringIncludes(String(out.retroDigest), "regen before build");
   assertStringIncludes(String(out.retroDigest), "use nextest");
   assertStringIncludes(String(out.retroDigest), "o/r#3");
+  // The gather step also produces the conformance brief pointing at the landed PR + slice spec.
+  assertStringIncludes(String(out.conformanceDigest), "Conformance input");
+  assertStringIncludes(String(out.conformanceDigest), "o/r#10");
+  assertStringIncludes(String(out.conformanceDigest), "add auth");
 });
 
 test("retro-gather: an epic with no learnings still renders a valid brief", async () => {

package/workers/retro-gather/worker.ts

@@ -1,9 +1,13 @@
 // pr.retro-gather — first step of the `retro` process. Assemble the plan's accumulated
 // coordination knowledge (the `learning` blackboard entries agents posted while implementing, plus
-// the task-delta rollup and any other blackboard notes) into a compact markdown brief, and emit it
-// as `retroDigest`. The next step maps that onto the `senior:retro` agent's `appendPrompt`, so the
-// agent reflects on real material rather than re-deriving it.
+// the task-delta rollup and any other blackboard notes) into a compact markdown brief, emitted as
+// `retroDigest`, AND the spec-conformance material (the spec + the landed PRs to examine + the
+// deviations raised during implementation) as `conformanceDigest`. The two downstream agent steps
+// (`senior:conformance` then `senior:retro`) map these onto their `appendPrompt`, so each reflects
+// on real material rather than re-deriving it.
 import type { AppJobHandler } from "@nanobpm/urban";
+import { readBlackboard } from "../../app/blackboard.ts";
+import { gatherConformance, renderConformanceBrief } from "../../app/conformance.ts";
 import { gatherRetro, renderRetroBrief } from "../../app/retro.ts";
 import type { WorkerInputs } from "../../nano-generated/worker-io.d.ts";
 
@@ -13,15 +17,23 @@ type In = WorkerInputs["pr.retro-gather"];
 interface Out extends Record<string, unknown> {
   retroDigest: string;
   retroLearnings: number;
+  conformanceDigest: string;
 }
 
 const handler: AppJobHandler<In, Out> = async (job, app) => {
   const planKey = job.variables.planKey;
-  const digest = await gatherRetro(app.data, planKey);
-  app.log.info(`retro-gather: ${planKey} — ${digest.counts.learnings} learnings, ${digest.counts.deltas} deltas`);
+  // Both gatherRetro and gatherConformance need the plan's blackboard; scan it once here and share
+  // the snapshot so a retro run does a single blackboard read, not one per gatherer.
+  const entries = await readBlackboard(app.data, planKey);
+  const digest = await gatherRetro(app.data, planKey, entries);
+  const conformance = await gatherConformance(app.data, planKey, entries);
+  app.log.info(
+    `retro-gather: ${planKey} — ${digest.counts.learnings} learnings, ${digest.counts.deltas} deltas, ${conformance.deliveredPrs.length} delivered PR(s)`,
+  );
   return {
     retroDigest: renderRetroBrief(digest),
     retroLearnings: digest.counts.learnings,
+    conformanceDigest: renderConformanceBrief(conformance),
   };
 };