@nanobpm/nano-workforce 0.42.0 → 0.44.0

package/workers/record-dependency/worker.ts

@@ -0,0 +1,109 @@
+// pr.record-dependency — a merge-stage agent discovered that this PR cannot land until ANOTHER
+// PR merges first (e.g. a stacked base PR must land, or a sibling PR closes an issue this one
+// requires). That is a WAIT, not a human escalation: record the discovered edge(s) in the
+// `pr_dependencies` DAG and park the PR back in `waiting_deps` so the merge poller's dependency
+// pass (`pollMerges` block 1) advances it — publishing `deps-cleared` — once every named PR has
+// merged. The process re-enters its existing `wait-deps` catch, so no human has to babysit an
+// ordering constraint the machinery already knows how to satisfy.
+//
+// `dependsOn` is whatever the agent returned (see prompts/fix-ci.md, prompts/rebase.md): a
+// string of one or more `owner/repo#N` refs (or PR URLs) separated by commas/whitespace/newlines,
+// or an array of such tokens. We parse each robustly (reusing `parsePr`), drop self-references and
+// duplicates, and insert missing edges idempotently — a worker retry never double-inserts, and an
+// already-recorded edge is a no-op.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { ensurePr, parsePr } from "../../app/service.ts";
+
+interface In extends Record<string, unknown> {
+  prKey: string;
+  dependsOn?: unknown;
+}
+
+interface DependencyRow {
+  pr_key: string;
+  depends_on_key: string;
+  created_at: string;
+}
+
+/** Normalize the agent's `dependsOn` into a de-duplicated list of `owner/repo#N` keys.
+ * Accepts a string (split on commas/whitespace/newlines) or an array of such tokens; unparseable
+ * tokens are ignored, mirroring `parseDependsOn`'s tolerance for the `Depends-on:` PR-body line. */
+function parseDependsOn(raw: unknown): string[] {
+  const tokens: string[] = [];
+  if (typeof raw === "string") {
+    tokens.push(...raw.split(/[,\s]+/));
+  } else if (Array.isArray(raw)) {
+    for (const item of raw) {
+      if (typeof item === "string") tokens.push(...item.split(/[,\s]+/));
+    }
+  }
+  const out = new Set<string>();
+  for (const tok of tokens) {
+    const parsed = parsePr(tok);
+    if (parsed) out.add(parsed.prKey);
+  }
+  return [...out];
+}
+
+const handler: AppJobHandler<In> = async (job, app) => {
+  const prKey = job.variables.prKey;
+  const depKeys = parseDependsOn(job.variables.dependsOn);
+  const ts = new Date().toISOString();
+
+  const depTable = app.data.table<DependencyRow>("pr_dependencies", "pr_key");
+
+  // Append the discovered edges to whatever the plan DAG already declared — never wipe the set
+  // (a `registerDependencies`-style replace would drop still-relevant sibling ordering). Dedupe
+  // against existing rows so this is safe to retry.
+  const existing = await depTable.find({ pr_key: prKey });
+  const have = new Set(existing.map((d) => d.depends_on_key));
+  let recorded = 0;
+  for (const depKey of depKeys) {
+    if (depKey === prKey || have.has(depKey)) continue; // never wait on self; skip known edges
+    await depTable.insert({ pr_key: prKey, depends_on_key: depKey, created_at: ts });
+    have.add(depKey);
+    recorded += 1;
+  }
+
+  if (depKeys.length === 0) {
+    // The agent signalled "waiting-on-pr" but named no parseable PR. Whether this actually strands
+    // the PR depends on the existing DAG: with no other edges the poller clears it immediately (an
+    // empty dep set trivially "all merged"); if prior edges already exist it will keep waiting on
+    // those. Either way the miswiring — a "waiting-on-pr" signal with no parseable ref — is a
+    // defect worth logging loudly.
+    const clause =
+      have.size === 0
+        ? "it will clear immediately (no other dependencies recorded)"
+        : `it still has ${have.size} previously-recorded dependency edge(s) to wait on`;
+    app.log(
+      "error",
+      `record-dependency: ${prKey} reported waiting-on-pr but no parseable dependsOn ref; ` +
+        `${clause}. Raw: ${JSON.stringify(job.variables.dependsOn)}`,
+    );
+  }
+
+  // Heal a missing FK parent (engine/app.db desync) before updating `pull_requests`; otherwise the
+  // update silently no-ops and the instance re-enters `wait-deps` with no row for the merge poller
+  // to watch — wedging the merge loop. Mirrors persist-round's heal; repo/number are derived from
+  // the canonical `owner/repo#N` prKey since the RecordDepIn envelope carries only prKey/dependsOn.
+  const parsed = parsePr(prKey);
+  if (parsed) {
+    await ensurePr(app.data, { prKey, repo: parsed.repo, number: parsed.number, url: parsed.url });
+  }
+
+  // Park the PR back in the merge-stage dependency wait so `pollMerges` block 1 watches it.
+  await app.data.table("pull_requests", "pr_key").update(prKey, {
+    status: "waiting_deps",
+    updated_at: ts,
+  });
+
+  app.log("info", `record-dependency: ${prKey} waiting on ${depKeys.length} PR(s)`, {
+    prKey,
+    dependsOn: depKeys,
+    recorded,
+  });
+
+  return {};
+};
+
+export default handler;

package/workers/record-plan/worker.ts

@@ -83,7 +83,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     });
     waveOf = new Map();
     for (const t of tasks) waveOf.set(t.id, 0);
-    app.log("warn", `record-plan: ${planKey} plan not levelizable, running flat`, {
+    app.log.warn(`record-plan: ${planKey} plan not levelizable, running flat`, {
       err: err.message,
     });
   }

package/workers/record-plan-review/worker.test.ts

@@ -8,6 +8,7 @@
 import { test } from "node:test";
 import { assertEquals, assertRejects } from "#test-assert";
 import { BpmnError } from "@nanobpm/urban";
+import { noopLog } from "../../test/log.ts";
 import handler from "./worker.ts";
 import { MAX_PLAN_REVIEW_ROUNDS, type PlanReview } from "../../app/plan.ts";
 
@@ -28,7 +29,7 @@ function fakeApp(existing: PlanReview[] = []) {
         };
       },
     },
-    log: () => {},
+    log: noopLog(),
     _rows: rows,
   } as any;
 }

package/workers/record-plan-review/worker.ts

@@ -92,7 +92,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   // `PLAN_REJECTED`, so the engine parks the instance on an incident rather than dispatching an
   // un-approved plan. The round is 0-based, so `round + 1 >= cap` is the last permitted round.
   if (round + 1 >= MAX_PLAN_REVIEW_ROUNDS) {
-    app.log("error", `record-plan-review: ${planKey} not approved after ${MAX_PLAN_REVIEW_ROUNDS} round(s)`, {
+    app.log.error(`record-plan-review: ${planKey} not approved after ${MAX_PLAN_REVIEW_ROUNDS} round(s)`, {
       round,
     });
     throw new BpmnError(
@@ -102,7 +102,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   }
 
   // Otherwise loop: the planner revises against this round's findings.
-  app.log("info", `record-plan-review: ${planKey} round ${round} — revise`, { approved: false });
+  app.log.info(`record-plan-review: ${planKey} round ${round} — revise`, { approved: false });
   return { planApproved: false, planFindings: roundFindings };
 };
 

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

@@ -9,6 +9,7 @@
 import { test } from "node:test";
 import { assertEquals, assertRejects } from "#test-assert";
 import { BpmnError } from "@nanobpm/urban";
+import { noopLog } from "../../test/log.ts";
 import handler from "./worker.ts";
 import type { PlanTaskStatus } from "../../app/plan.ts";
 
@@ -45,7 +46,7 @@ function fakeApp(rows: Row[]) {
         };
       },
     },
-    log: () => {},
+    log: noopLog(),
     _plans: plans,
   } as any;
 }

package/workers/record-results/worker.ts

@@ -43,7 +43,7 @@ const handler: AppJobHandler<In> = async (job, app) => {
       outcome,
       updated_at: ts,
     });
-    app.log("error", `record-results: ${planKey} finalized with 0 opened PRs`, {
+    app.log.error(`record-results: ${planKey} finalized with 0 opened PRs`, {
       taskCount: rows.length,
     });
     throw new BpmnError("NO_WORK_DISPATCHED", `${planKey}: ${outcome}`);

package/workers/record-trial-merge/worker.test.ts

@@ -1,5 +1,6 @@
 import { test } from "node:test";
 import { assertEquals, assertStringIncludes } from "#test-assert";
+import { noopLog } from "../../test/log.ts";
 import handler, { parseResult } from "./worker.ts";
 
 function fakeApp() {
@@ -19,7 +20,7 @@ function fakeApp() {
         };
       },
     },
-    log: () => undefined,
+    log: noopLog(),
   };
   return { app, inserts };
 }

package/workers/record-trial-merge/worker.ts

@@ -67,7 +67,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
       jobKey,
     });
   } catch (err) {
-    app.log("error", `record-trial-merge: audit persist failed for ${planKey} wave ${wave}`, { err: String(err) });
+    app.log.error(`record-trial-merge: audit persist failed for ${planKey} wave ${wave}`, { err: String(err) });
   }
 
   const trialMergeRed = trialMergeDecision(result) === "escalate";

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

@@ -3,6 +3,7 @@
 // finish the plan with a still-pending task.
 import { test } from "node:test";
 import { assertEquals } from "#test-assert";
+import { noopLog } from "../../test/log.ts";
 import handler from "./worker.ts";
 import type { PlanTaskStatus } from "../../app/plan.ts";
 import { _clearMergeProtocolCache } from "../../app/mergeProtocol.ts";
@@ -61,7 +62,7 @@ function fakeApp(rows: Row[]) {
           };
         },
       },
-      log: () => undefined,
+      log: noopLog(),
       engine: {
         createInstance: () => Promise.resolve({ processInstanceKey: "pi" }),
       },

package/workers/record-wave/worker.ts

@@ -164,7 +164,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
           });
         }
       } catch (err) {
-        app.log("error", `record-wave: recording delta for ${taskId} failed`, {
+        app.log.error(`record-wave: recording delta for ${taskId} failed`, {
           err: String(err),
         });
       }
@@ -194,7 +194,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
       try {
         await submitPr(app.data, app.engine, parsed, depPrKeys);
       } catch (err) {
-        app.log("error", `record-wave: handoff failed for ${parsed.prKey}`, {
+        app.log.error(`record-wave: handoff failed for ${parsed.prKey}`, {
           err: String(err),
         });
       }
@@ -220,7 +220,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
         if (meta?.headRef) head.headRef = meta.headRef;
         if (meta?.headSha) head.headSha = meta.headSha;
       } catch (err) {
-        app.log("error", `record-wave: pr head fetch failed for ${head.repo}#${head.prNumber}`, { err: String(err) });
+        app.log.error(`record-wave: pr head fetch failed for ${head.repo}#${head.prNumber}`, { err: String(err) });
       }
       return head;
     }));
@@ -253,7 +253,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
           for (const f of files) set.add(f);
           touchesByTask.set(o.taskId, set);
         } catch (err) {
-          app.log("error", `record-wave: pr files fetch failed for ${o.repo}#${o.number}`, {
+          app.log.error(`record-wave: pr files fetch failed for ${o.repo}#${o.number}`, {
             err: String(err),
           });
         }
@@ -261,7 +261,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
       const edges = deriveExclusions(touchesByTask);
       if (edges.length > 0) {
         const { inserted, updated } = await recordExclusions(app.data, planKey, edges);
-        app.log("info", `record-wave: merge-exclusion scan wave ${currentWave}`, {
+        app.log.info(`record-wave: merge-exclusion scan wave ${currentWave}`, {
           planKey,
           edges: edges.length,
           inserted,
@@ -269,7 +269,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
         });
       }
     } catch (err) {
-      app.log("error", `record-wave: merge-exclusion scan failed for ${planKey}`, {
+      app.log.error(`record-wave: merge-exclusion scan failed for ${planKey}`, {
         err: String(err),
       });
     }
@@ -291,7 +291,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
       updated_at: ts,
     });
   } catch (err) {
-    app.log("error", `record-wave: arming wave gate failed for ${planKey}`, { err: String(err) });
+    app.log.error(`record-wave: arming wave gate failed for ${planKey}`, { err: String(err) });
   }
 
   return {

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

@@ -1,6 +1,7 @@
 import { test } from "node:test";
 import { assert, assertEquals, assertStringIncludes } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
+import { noopLog } from "../../test/log.ts";
 import { appendEntry } from "../../app/blackboard.ts";
 import handler from "./worker.ts";
 
@@ -38,7 +39,7 @@ test("retro-gather: emits a digest brief + learning count for the plan", async (
   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" });
 
-  const app = { data, log: () => undefined };
+  const app = { data, log: noopLog() };
   const out = await handler(
     { variables: { planKey: "o/r#3" } } as any,
     app as any,
@@ -53,7 +54,7 @@ test("retro-gather: emits a digest brief + learning count for the plan", async (
 test("retro-gather: an epic with no learnings still renders a valid brief", async () => {
   const { data, stores } = memData();
   stores["plans"] = [{ plan_key: "o/r#4", repo: "o/r", issue_url: "", title: null }];
-  const app = { data, log: () => undefined };
+  const app = { data, log: noopLog() };
   const out = await handler(
     { variables: { planKey: "o/r#4" } } as any,
     app as any,

package/workers/retro-gather/worker.ts

@@ -18,7 +18,7 @@ interface Out extends Record<string, unknown> {
 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`);
+  app.log.info(`retro-gather: ${planKey} — ${digest.counts.learnings} learnings, ${digest.counts.deltas} deltas`);
   return {
     retroDigest: renderRetroBrief(digest),
     retroLearnings: digest.counts.learnings,

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

@@ -1,5 +1,6 @@
 import { test } from "node:test";
 import { assertEquals } from "#test-assert";
+import { noopLog } from "../../test/log.ts";
 import handler from "./worker.ts";
 
 function fakeApp() {
@@ -29,7 +30,7 @@ function fakeApp() {
       },
     };
   }
-  const app = { data: { table: (n: string, pk?: string) => tbl(n, pk) }, log: () => undefined };
+  const app = { data: { table: (n: string, pk?: string) => tbl(n, pk) }, log: noopLog() };
   return { app, stores };
 }
 

package/workers/retro-record/worker.ts

@@ -53,7 +53,7 @@ const handler: AppJobHandler<In> = async (job, app) => {
     report,
   });
 
-  app.log("info", `retro-record: ${planKey} — status=${status}${prKey ? ` pr=${prKey}` : ""}`);
+  app.log.info(`retro-record: ${planKey} — status=${status}${prKey ? ` pr=${prKey}` : ""}`);
   return {};
 };