@nanobpm/nano-workforce 0.36.0 → 0.38.0

package/app/blackboard.ts

@@ -13,7 +13,7 @@
 //     stable `dedupe_key` is a no-op (backed by a unique index; we also short-circuit here).
 //   - CAPABILITY URL. The per-plan token IS the credential; the agent curls the exact URL it was
 //     handed (delivered in `appendPrompt`). Delivery is in-band (rides the prompt the harness
-//     already forwards); use is out-of-band (a direct side-channel to `/hooks/blackboard`).
+//     already forwards); use is out-of-band (a direct side-channel to `/app/api/hooks/blackboard`).
 //
 // Data access goes through the record gateway (`data.table`), never hand-written SQL — matching
 // app/service.ts and app/plan.ts.
@@ -87,7 +87,7 @@ export function publicBaseUrl(env: string | undefined = process.env.NANO_PR_PUBL
 /** The capability URL for a plan's blackboard: the token rides the query string, so the agent can
  * GET/POST the exact string it was handed with no header assembly. */
 export function blackboardUrl(token: string, base: string = publicBaseUrl()): string {
-  return `${base}/hooks/blackboard?token=${encodeURIComponent(token)}`;
+  return `${base}/app/api/hooks/blackboard?token=${encodeURIComponent(token)}`;
 }
 
 /** The coordination-protocol block appended (verbatim, via `appendPrompt`) to each implementer

package/app/ensure-pr.test.ts

@@ -2,7 +2,8 @@
 // `pull_requests` FK parent before a child (`rounds`/`escalations`/`merges`) insert, so an
 // engine/app.db store desync never parks an opaque `FOREIGN KEY constraint failed` incident
 // (observed on convergence-loop instance 94).
-import { assert, assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import { canonicalPrUrl, ensurePr } from "./service.ts";
 
@@ -18,11 +19,9 @@ function memData(opts: { throwOnInsert?: boolean; seedOnThrow?: boolean } = {}):
   let insertCalls = 0;
   function tbl(name: string, key: string) {
     return {
-      // deno-lint-ignore require-await
       async get(id: string) {
         return rows.get(id);
       },
-      // deno-lint-ignore no-explicit-any require-await
       async insert(row: any) {
         insertCalls++;
         if (opts.throwOnInsert) {
@@ -34,14 +33,13 @@ function memData(opts: { throwOnInsert?: boolean; seedOnThrow?: boolean } = {}):
       },
     };
   }
-  // deno-lint-ignore no-explicit-any
   const data = { table: (n: string, k: string) => tbl(n, k) } as any as DataLayer;
   return { data, rows, get insertCalls() {
     return insertCalls;
   } };
 }
 
-Deno.test("ensurePr is a no-op when the parent already exists", async () => {
+test("ensurePr is a no-op when the parent already exists", async () => {
   const mem = memData();
   const { data, rows } = mem;
   rows.set("o/r#1", { pr_key: "o/r#1", status: "converging" });
@@ -52,7 +50,7 @@ Deno.test("ensurePr is a no-op when the parent already exists", async () => {
   assertEquals(mem.insertCalls, 0, "insert is never attempted — the no-write guarantee holds");
 });
 
-Deno.test("ensurePr reconstructs a minimal converging row when the parent is absent", async () => {
+test("ensurePr reconstructs a minimal converging row when the parent is absent", async () => {
   const { data, rows } = memData();
   await ensurePr(data, { prKey: "o/r#2", repo: "o/r", number: 2, round: 3 });
   const row = rows.get("o/r#2")!;
@@ -65,7 +63,7 @@ Deno.test("ensurePr reconstructs a minimal converging row when the parent is abs
   assert(typeof row.abandon_token === "string" && (row.abandon_token as string).length > 0);
 });
 
-Deno.test("ensurePr defaults current_round to 1 (rounds are 1-based) when none is passed", async () => {
+test("ensurePr defaults current_round to 1 (rounds are 1-based) when none is passed", async () => {
   const { data, rows } = memData();
   await ensurePr(data, { prKey: "o/r#5", repo: "o/r", number: 5 });
   assertEquals(
@@ -75,7 +73,7 @@ Deno.test("ensurePr defaults current_round to 1 (rounds are 1-based) when none i
   );
 });
 
-Deno.test("ensurePr reuses a supplied abandon token instead of minting a new one", async () => {
+test("ensurePr reuses a supplied abandon token instead of minting a new one", async () => {
   const { data, rows } = memData();
   await ensurePr(data, { prKey: "o/r#7", repo: "o/r", number: 7, abandonToken: "TOK-en_123" });
   assertEquals(
@@ -85,27 +83,27 @@ Deno.test("ensurePr reuses a supplied abandon token instead of minting a new one
   );
 });
 
-Deno.test("ensurePr mints a token when none is supplied", async () => {
+test("ensurePr mints a token when none is supplied", async () => {
   const { data, rows } = memData();
   await ensurePr(data, { prKey: "o/r#8", repo: "o/r", number: 8 });
   const tok = rows.get("o/r#8")!.abandon_token;
   assert(typeof tok === "string" && (tok as string).length > 0, "a fresh token is minted as a fallback");
 });
 
-Deno.test("ensurePr prefers an explicit url over the canonical one", async () => {
+test("ensurePr prefers an explicit url over the canonical one", async () => {
   const { data, rows } = memData();
   const url = "https://github.com/o/r/pull/9";
   await ensurePr(data, { prKey: "o/r#9", repo: "o/r", number: 9, url });
   assertEquals(rows.get("o/r#9")!.url, url);
 });
 
-Deno.test("ensurePr swallows an insert race when the row appears anyway", async () => {
+test("ensurePr swallows an insert race when the row appears anyway", async () => {
   // insert throws (unique-violation / concurrent writer) but the row is now present → healed.
   const { data } = memData({ throwOnInsert: true, seedOnThrow: true });
   await ensurePr(data, { prKey: "o/r#3", repo: "o/r", number: 3 });
 });
 
-Deno.test("ensurePr rethrows when the insert fails and the row is still absent", async () => {
+test("ensurePr rethrows when the insert fails and the row is still absent", async () => {
   const { data } = memData({ throwOnInsert: true, seedOnThrow: false });
   let threw = false;
   try {

package/app/github.test.ts

@@ -1,7 +1,8 @@
 // Unit tests for `fetchPrFiles` token-transport paging (issue #58): the D2 conflict-scan must get
 // a COMPLETE file list or a thrown error — never a silently truncated one that under-approximates
 // the merge-exclusion graph. Force the token transport and stub `globalThis.fetch`.
-import { assertEquals, assertRejects } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals, assertRejects } from "#test-assert";
 import { fetchPrFiles } from "./github.ts";
 
 // A fake `fetch` that serves `pages` of file batches; each page N (1-based) returns `pages[N-1]`
@@ -25,31 +26,31 @@ function stubFetch(pages: number[]) {
 }
 
 async function withTokenTransport<T>(pages: number[], fn: () => Promise<T>): Promise<T> {
-  const prevMode = Deno.env.get("NANO_PR_GITHUB_TRANSPORT");
+  const prevMode = process.env["NANO_PR_GITHUB_TRANSPORT"];
   const prevFetch = globalThis.fetch;
-  Deno.env.set("NANO_PR_GITHUB_TRANSPORT", "token");
+  process.env["NANO_PR_GITHUB_TRANSPORT"] = "token";
   globalThis.fetch = stubFetch(pages) as typeof fetch;
   try {
     return await fn();
   } finally {
     globalThis.fetch = prevFetch;
-    if (prevMode === undefined) Deno.env.delete("NANO_PR_GITHUB_TRANSPORT");
-    else Deno.env.set("NANO_PR_GITHUB_TRANSPORT", prevMode);
+    if (prevMode === undefined) delete process.env["NANO_PR_GITHUB_TRANSPORT"];
+    else process.env["NANO_PR_GITHUB_TRANSPORT"] = prevMode;
   }
 }
 
-Deno.test("fetchPrFiles: returns the complete list for a sub-cap PR (short final page)", async () => {
+test("fetchPrFiles: returns the complete list for a sub-cap PR (short final page)", async () => {
   const files = await withTokenTransport([100, 42], () => fetchPrFiles("o/r", 1, "tok"));
   assertEquals(files?.length, 142);
 });
 
-Deno.test("fetchPrFiles: exactly 500 files with no next page is complete, not truncated", async () => {
+test("fetchPrFiles: exactly 500 files with no next page is complete, not truncated", async () => {
   // 5 full pages, but no `rel="next"` on the last → the list is exactly complete at the cap.
   const files = await withTokenTransport([100, 100, 100, 100, 100], () => fetchPrFiles("o/r", 2, "tok"));
   assertEquals(files?.length, 500);
 });
 
-Deno.test("fetchPrFiles: throws when the cap genuinely truncates (full last page + next)", async () => {
+test("fetchPrFiles: throws when the cap genuinely truncates (full last page + next)", async () => {
   // 6 pages available but only 5 fetched → the 5th page still advertises `rel="next"`.
   await assertRejects(
     () => withTokenTransport([100, 100, 100, 100, 100, 100], () => fetchPrFiles("o/r", 3, "tok")),

package/app/github.ts

@@ -9,7 +9,7 @@
 //   • auto  — prefer `gh` when the binary is present; otherwise fall back to `token`.
 //
 // The poller is app-side host glue (main.ts), so host-specific subprocess I/O is allowed here.
-// Cross-runtime: runs under Node (`node:child_process`) and Deno (`Deno.Command`).
+// Cross-runtime: runs under Node (`node:child_process`).
 
 /** A GitHub pull-request review, narrowed to the fields the poller needs. */
 export interface GhReview {
@@ -26,30 +26,10 @@ export function githubTransport(): GithubTransport {
   return t === "gh" || t === "token" ? t : "auto";
 }
 
-interface DenoCommandCtor {
-  new (
-    command: string,
-    options: { args: string[]; stdout: "piped"; stderr: "piped" },
-  ): { output(): Promise<{ code: number; stdout: Uint8Array; stderr: Uint8Array }> };
-}
-
 /** Run the host `gh` CLI with the given args (no shell — args are passed as a vector, so a
  * `repo`/`number` from the datastore cannot inject a command). Resolves stdout, rejects on a
  * non-zero exit with stderr as the message. */
 async function runGh(args: string[]): Promise<string> {
-  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
-  const g = globalThis as { Deno?: { Command?: DenoCommandCtor } };
-  if (g.Deno?.Command) {
-    const { code, stdout, stderr } = await new g.Deno.Command("gh", {
-      args,
-      stdout: "piped",
-      stderr: "piped",
-    }).output();
-    if (code !== 0) {
-      throw new Error(new TextDecoder().decode(stderr).trim() || `gh exited ${code}`);
-    }
-    return new TextDecoder().decode(stdout);
-  }
   const { execFile } = await import("node:child_process");
   return await new Promise<string>((resolve, reject) => {
     execFile(

package/app/instance-tracking.test.ts

@@ -4,7 +4,9 @@
 // crashed) run stuck "active" in the UI — the exact drift Copilot flagged on #96. This ties the
 // manifest to the code's single source of truth for "done" (TERMINAL_STATUSES / PLAN_TERMINAL_
 // STATUSES) so the two can't diverge silently.
-import { assert, assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { readFileSync } from "node:fs";
 import { TERMINAL_STATUSES } from "./service.ts";
 import { PLAN_TERMINAL_STATUSES } from "./plan.ts";
 
@@ -16,7 +18,7 @@ interface Binding {
 }
 
 async function bindings(): Promise<Binding[]> {
-  const manifest = JSON.parse(await Deno.readTextFile(new URL("../nano.app.json", import.meta.url)));
+  const manifest = JSON.parse(readFileSync(new URL("../nano.app.json", import.meta.url), "utf8"));
   return manifest.instanceTracking as Binding[];
 }
 
@@ -26,7 +28,7 @@ function bindingFor(all: Binding[], table: string): Binding {
   return b;
 }
 
-Deno.test("instanceTracking: pull_requests activeStatuses excludes every terminal status", async () => {
+test("instanceTracking: pull_requests activeStatuses excludes every terminal status", async () => {
   const b = bindingFor(await bindings(), "pull_requests");
   for (const terminal of TERMINAL_STATUSES) {
     assert(
@@ -40,7 +42,7 @@ Deno.test("instanceTracking: pull_requests activeStatuses excludes every termina
 // pull_requests row can hold while a live engine instance still backs it (see app/service.ts merge
 // poller: converging/waiting_review/escalated + the merge-stage waiting_deps/waiting_merge/
 // waiting_lane/queued/merging). If a new one is added to the flow, add it here AND to the manifest.
-Deno.test("instanceTracking: pull_requests activeStatuses covers every in-flight status", async () => {
+test("instanceTracking: pull_requests activeStatuses covers every in-flight status", async () => {
   const inFlight = [
     "converging",
     "waiting_review",
@@ -59,14 +61,14 @@ Deno.test("instanceTracking: pull_requests activeStatuses covers every in-flight
   for (const s of inFlight) assert(!TERMINAL_STATUSES.includes(s));
 });
 
-Deno.test("instanceTracking: plans activeStatuses excludes every terminal status", async () => {
+test("instanceTracking: plans activeStatuses excludes every terminal status", async () => {
   const b = bindingFor(await bindings(), "plans");
   for (const terminal of PLAN_TERMINAL_STATUSES) {
     assert(!b.activeStatuses?.includes(terminal), `terminal status "${terminal}" must not be active`);
   }
 });
 
-Deno.test("instanceTracking: plans activeStatuses covers every in-flight status", async () => {
+test("instanceTracking: plans activeStatuses covers every in-flight status", async () => {
   const inFlight = ["planning", "dispatched"];
   const b = bindingFor(await bindings(), "plans");
   assertEquals([...(b.activeStatuses ?? [])].sort(), [...inFlight].sort());

package/app/mergeExclusion.test.ts

@@ -1,5 +1,6 @@
 // Unit tests for the merge-exclusion graph + conflict-scan (D1/D2, issues #57 #58 / #49).
-import { assert, assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import {
   clearExclusions,
@@ -13,58 +14,48 @@ import {
 import { computeWaves } from "./waves.ts";
 
 // In-memory record-gateway fake (insert/find/findOne/update/delete), mirroring the app tests.
-// deno-lint-ignore no-explicit-any
 function memData(): { data: DataLayer; stores: Record<string, any[]> } {
-  // deno-lint-ignore no-explicit-any
   const stores: Record<string, any[]> = {};
   const seq: Record<string, number> = {};
   function tbl(name: string, pk = "id") {
-    // deno-lint-ignore no-explicit-any
     const rows = (stores[name] ??= [] as any[]);
-    // deno-lint-ignore no-explicit-any
     const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
     return {
-      // deno-lint-ignore no-explicit-any require-await
       async insert(row: any) {
         const id = (seq[name] = (seq[name] ?? 0) + 1);
         rows.push({ id, ...row });
         return id;
       },
-      // deno-lint-ignore no-explicit-any require-await
       async find(where: any = {}) {
         return rows.filter((r) => match(r, where));
       },
-      // deno-lint-ignore no-explicit-any require-await
       async findOne(where: any = {}) {
         return rows.find((r) => match(r, where));
       },
-      // deno-lint-ignore no-explicit-any require-await
       async update(id: any, patch: any) {
         const r = rows.find((row) => row.id === id);
         if (r) Object.assign(r, patch);
       },
-      // deno-lint-ignore no-explicit-any require-await
       async delete(id: any) {
         const i = rows.findIndex((row) => row.id === id);
         if (i >= 0) rows.splice(i, 1);
       },
     };
   }
-  // deno-lint-ignore no-explicit-any
   const data = { table: (n: string, pk?: string) => tbl(n, pk) } as any as DataLayer;
   return { data, stores };
 }
 
 const files = (e: ExclusionEdge) => e.files;
 
-Deno.test("normalizePair: orders deterministically and rejects self/blank pairs", () => {
+test("normalizePair: orders deterministically and rejects self/blank pairs", () => {
   assertEquals(normalizePair("b", "a"), ["a", "b"]);
   assertEquals(normalizePair("a", "b"), ["a", "b"]);
   assertEquals(normalizePair("a", "a"), null, "a task never excludes itself");
   assertEquals(normalizePair("", "a"), null);
 });
 
-Deno.test("deriveExclusions: an edge per file-overlapping pair, carrying the sorted overlap", () => {
+test("deriveExclusions: an edge per file-overlapping pair, carrying the sorted overlap", () => {
   const edges = deriveExclusions(
     new Map([
       ["gap-2", ["engine/tests.rs", "engine/state.rs"]],
@@ -83,14 +74,14 @@ Deno.test("deriveExclusions: an edge per file-overlapping pair, carrying the sor
   assert(!edges.some((e) => e.taskA === "gap-5" || e.taskB === "gap-5"), "gap-5 excluded (no overlap)");
 });
 
-Deno.test("deriveExclusions: no overlap → no edges; blank paths ignored", () => {
+test("deriveExclusions: no overlap → no edges; blank paths ignored", () => {
   assertEquals(
     deriveExclusions(new Map([["a", ["x.rs"]], ["b", ["y.rs"]], ["c", ["", "  "]]])),
     [],
   );
 });
 
-Deno.test("recordExclusions: upserts per unordered pair — a re-scan refreshes files, never duplicates", async () => {
+test("recordExclusions: upserts per unordered pair — a re-scan refreshes files, never duplicates", async () => {
   const { data, stores } = memData();
   const first = await recordExclusions(data, "p", deriveExclusions(
     new Map([["gap-2", ["a.rs"]], ["gap-8", ["a.rs"]]]),
@@ -109,7 +100,7 @@ Deno.test("recordExclusions: upserts per unordered pair — a re-scan refreshes
   assertEquals(edge.files, ["a.rs", "b.rs"], "files refreshed in place");
 });
 
-Deno.test("recordExclusions: a duplicate pair within one batch folds into an update, never a second row", async () => {
+test("recordExclusions: a duplicate pair within one batch folds into an update, never a second row", async () => {
   const { data, stores } = memData();
   // The same unordered pair appears twice in one call (second given in the other order + more files).
   // The in-memory map must fold the newly inserted id back so the second occurrence updates in place.
@@ -123,7 +114,7 @@ Deno.test("recordExclusions: a duplicate pair within one batch folds into an upd
   assertEquals(edge.files, ["x.rs", "y.rs"], "later occurrence refreshed files in place");
 });
 
-Deno.test("clearExclusions: drops one plan's graph, leaving others intact", async () => {
+test("clearExclusions: drops one plan's graph, leaving others intact", async () => {
   const { data } = memData();
   await recordExclusions(data, "p", deriveExclusions(new Map([["a", ["x"]], ["b", ["x"]]])));
   await recordExclusions(data, "q", deriveExclusions(new Map([["c", ["y"]], ["d", ["y"]]])));
@@ -132,7 +123,7 @@ Deno.test("clearExclusions: drops one plan's graph, leaving others intact", asyn
   assertEquals((await readExclusions(data, "q")).length, 1, "the other plan survives");
 });
 
-Deno.test("mergeLanes: connected components are serial landing lanes; singletons land in parallel", () => {
+test("mergeLanes: connected components are serial landing lanes; singletons land in parallel", () => {
   // gap-2—gap-8—gap-9 form one chain (transitive shared surface); gap-5 stands alone.
   const edges = deriveExclusions(
     new Map([
@@ -146,11 +137,11 @@ Deno.test("mergeLanes: connected components are serial landing lanes; singletons
   assertEquals(lanes, [["gap-2", "gap-8", "gap-9"], ["gap-5"]]);
 });
 
-Deno.test("mergeLanes: with no edges, every task is its own lane (fully parallel landing)", () => {
+test("mergeLanes: with no edges, every task is its own lane (fully parallel landing)", () => {
   assertEquals(mergeLanes([], ["b", "a", "c"]), [["a"], ["b"], ["c"]]);
 });
 
-Deno.test("D1 invariant: a merge-exclusion is NOT a dispatch dependency", () => {
+test("D1 invariant: a merge-exclusion is NOT a dispatch dependency", () => {
   // Two tasks that collide on a shared file but declare no build-on dependency.
   const overlap = new Map([["gap-2", ["engine/tests.rs"]], ["gap-8", ["engine/tests.rs"]]]);
   const edges = deriveExclusions(overlap);

package/app/mergeProtocol.test.ts

@@ -3,8 +3,9 @@
 // extractor must find the fenced ```merge-protocol JSON, and the fresh-head-run decision must fire
 // exactly once per landing attempt — only in the frugal-CI stuck state (no head run + waiting) —
 // so a converged PR is nudged into a fresh CI run without disturbing a run already in flight.
-// Run with `deno test -A`.
-import { assertEquals } from "jsr:@std/assert@1";
+// Run with `node --test`.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import {
   DEFAULT_MERGE_PROTOCOL,
   extractProtocolBlock,
@@ -13,14 +14,14 @@ import {
   parseMergeProtocol,
 } from "./mergeProtocol.ts";
 
-Deno.test("parseMergeProtocol: non-object / junk → defaults (total, never throws)", () => {
+test("parseMergeProtocol: non-object / junk → defaults (total, never throws)", () => {
   assertEquals(parseMergeProtocol(undefined), { ...DEFAULT_MERGE_PROTOCOL });
   assertEquals(parseMergeProtocol(null), { ...DEFAULT_MERGE_PROTOCOL });
   assertEquals(parseMergeProtocol("nope"), { ...DEFAULT_MERGE_PROTOCOL });
   assertEquals(parseMergeProtocol([1, 2]), { ...DEFAULT_MERGE_PROTOCOL });
 });
 
-Deno.test("parseMergeProtocol: full nano-bpm-style descriptor", () => {
+test("parseMergeProtocol: full nano-bpm-style descriptor", () => {
   const got = parseMergeProtocol({
     autoMerge: false,
     freshHeadRun: "ready-or-reopen",
@@ -37,7 +38,7 @@ Deno.test("parseMergeProtocol: full nano-bpm-style descriptor", () => {
   assertEquals(got.doc, "AGENTS.md#merging-prs");
 });
 
-Deno.test("parseMergeProtocol: invalid enums / wrong types fall back per-field", () => {
+test("parseMergeProtocol: invalid enums / wrong types fall back per-field", () => {
   const got = parseMergeProtocol({
     autoMerge: "yes", // not a boolean → default
     freshHeadRun: "sometimes", // not in the enum → default (none)
@@ -50,12 +51,12 @@ Deno.test("parseMergeProtocol: invalid enums / wrong types fall back per-field",
   assertEquals(got.requiredChecks, ["ok"]);
 });
 
-Deno.test("parseMergeProtocol: comment dropped when absent", () => {
+test("parseMergeProtocol: comment dropped when absent", () => {
   const got = parseMergeProtocol({ land: { method: "admin" } });
   assertEquals(got.land, { method: "admin" });
 });
 
-Deno.test("extractProtocolBlock: finds the fenced merge-protocol JSON (with info word)", () => {
+test("extractProtocolBlock: finds the fenced merge-protocol JSON (with info word)", () => {
   const md = [
     "## Merging PRs",
     "Some prose about how to merge.",
@@ -73,7 +74,7 @@ Deno.test("extractProtocolBlock: finds the fenced merge-protocol JSON (with info
   assertEquals(p.land.method, "mergify-queue");
 });
 
-Deno.test("extractProtocolBlock: none present → null", () => {
+test("extractProtocolBlock: none present → null", () => {
   assertEquals(extractProtocolBlock("# Doc\n```json\n{}\n```\n"), null);
 });
 
@@ -82,14 +83,14 @@ const NANO: MergeProtocol = parseMergeProtocol({
   land: { method: "mergify-queue" },
 });
 
-Deno.test("freshHeadRunAction: fires in the frugal-CI stuck state (no run + waiting)", () => {
+test("freshHeadRunAction: fires in the frugal-CI stuck state (no run + waiting)", () => {
   // ready PR, no head run at all → reopen (ready-or-reopen, not a draft)
   assertEquals(freshHeadRunAction(NANO, "waiting", 0, false), "reopen");
   // draft PR, no head run → mark ready
   assertEquals(freshHeadRunAction(NANO, "waiting", 0, true), "ready");
 });
 
-Deno.test("freshHeadRunAction: fires once per landing-attempt head, then re-fires after rebase", () => {
+test("freshHeadRunAction: fires once per landing-attempt head, then re-fires after rebase", () => {
   assertEquals(
     freshHeadRunAction(NANO, "waiting", 0, false, { headRefOid: "h1", lastActionHeadRefOid: null }),
     "reopen",
@@ -104,7 +105,7 @@ Deno.test("freshHeadRunAction: fires once per landing-attempt head, then re-fire
   );
 });
 
-Deno.test("freshHeadRunAction: never fires once a run exists, or when not waiting", () => {
+test("freshHeadRunAction: never fires once a run exists, or when not waiting", () => {
   assertEquals(freshHeadRunAction(NANO, "waiting", 1, false), null); // run already in flight
   assertEquals(freshHeadRunAction(NANO, "waiting", -1, false), null); // token mode (unknown) → conservative
   assertEquals(freshHeadRunAction(NANO, "ready", 0, false), null); // already landable
@@ -113,11 +114,11 @@ Deno.test("freshHeadRunAction: never fires once a run exists, or when not waitin
   assertEquals(freshHeadRunAction(NANO, "conflict", 0, false), null); // conflict → rebase arm (#42)
 });
 
-Deno.test("freshHeadRunAction: protocol.freshHeadRun=none is a no-op (default repos unchanged)", () => {
+test("freshHeadRunAction: protocol.freshHeadRun=none is a no-op (default repos unchanged)", () => {
   assertEquals(freshHeadRunAction(DEFAULT_MERGE_PROTOCOL, "waiting", 0, false), null);
 });
 
-Deno.test("freshHeadRunAction: mode=ready only acts on drafts", () => {
+test("freshHeadRunAction: mode=ready only acts on drafts", () => {
   const readyOnly = parseMergeProtocol({ freshHeadRun: "ready", land: { method: "gh-merge" } });
   assertEquals(freshHeadRunAction(readyOnly, "waiting", 0, true), "ready");
   assertEquals(freshHeadRunAction(readyOnly, "waiting", 0, false), null); // not a draft → nothing to ready

package/app/mergeRebaseArm.test.ts

@@ -10,9 +10,11 @@
 // way it originally shipped. It is a pure text assertion over the BPMN (no engine), matching the
 // repo's lightweight model-guard style.
 
-import { assert, assertStringIncludes } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertStringIncludes } from "#test-assert";
+import { readFileSync } from "node:fs";
 
-const bpmn = await Deno.readTextFile("resources/processes/merge-loop.bpmn");
+const bpmn = readFileSync("resources/processes/merge-loop.bpmn", "utf8");
 
 // Collapse whitespace so attribute-order / line-wrapping churn doesn't make the assertions brittle.
 const flat = bpmn.replace(/\s+/g, " ");
@@ -27,14 +29,14 @@ function hasFlow(source: string, target: string): boolean {
   return re.test(flat);
 }
 
-Deno.test("conflict routes to the rebase budget gate, not straight to a human", () => {
+test("conflict routes to the rebase budget gate, not straight to a human", () => {
   // The conflict verdict must reach the auto-rebase gate…
   assert(hasFlow("gw-mergeable", "gw-rebase"), "gw-mergeable → gw-rebase (conflict) missing");
   // …guarded by the exact conflict condition (DIRTY → mergeState = "conflict").
   assertStringIncludes(flat, 'mergeState = "conflict"');
 });
 
-Deno.test("rebase arm mirrors the fix-ci arm: budget gate → agent → result gate", () => {
+test("rebase arm mirrors the fix-ci arm: budget gate → agent → result gate", () => {
   // Budget gate: within budget → the agent; exhausted → the (existing) conflict escalation.
   assert(hasFlow("gw-rebase", "rebase"), "gw-rebase → rebase (within budget) missing");
   assert(hasFlow("gw-rebase", "merge-esc-conflict"), "gw-rebase → merge-esc-conflict (budget exhausted) missing");
@@ -49,7 +51,7 @@ Deno.test("rebase arm mirrors the fix-ci arm: budget gate → agent → result g
   assertStringIncludes(flat, "=rebaseRound + 1");
 });
 
-Deno.test("rebase result: success re-arms the poller; unresolved escalates to a human", () => {
+test("rebase result: success re-arms the poller; unresolved escalates to a human", () => {
   // Success loops back to re-attempt the merge — forward progress, no human needed.
   assert(hasFlow("gw-rebase-result", "arm-merge"), "gw-rebase-result → arm-merge (rebased) missing");
   assertStringIncludes(flat, 'status = "rebased"');
@@ -60,7 +62,7 @@ Deno.test("rebase result: success re-arms the poller; unresolved escalates to a
   );
 });
 
-Deno.test("regression: the conflict verdict passes through the rebase actor, not straight to escalation", () => {
+test("regression: the conflict verdict passes through the rebase actor, not straight to escalation", () => {
   // The original #42 livelock had the conflict verdict escalate to a human with no remediation
   // actor. The primary target of the conflict verdict must now be the rebase gate.
   assert(

package/app/mergeTrain.test.ts

@@ -1,5 +1,6 @@
 // Red/green regression for D6's pure merge-train lane planner.
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import { planLane, planPrLane, taskDependencyDepths } from "./mergeTrain.ts";
 
 const taskToPr = new Map([
@@ -9,7 +10,7 @@ const taskToPr = new Map([
   ["gap-10", "o/r#10"],
 ]);
 
-Deno.test("planLane: dependency depth then task id picks the single lane head", () => {
+test("planLane: dependency depth then task id picks the single lane head", () => {
   const depth = new Map([["gap-8", 2], ["gap-2", 0], ["gap-9", 0]]);
   assertEquals(planLane(["gap-8", "gap-9", "gap-2"], taskToPr, new Set(), depth), {
     headTaskId: "gap-2",
@@ -19,7 +20,7 @@ Deno.test("planLane: dependency depth then task id picks the single lane head",
   });
 });
 
-Deno.test("taskDependencyDepths: longest dependency path determines landing order depth", () => {
+test("taskDependencyDepths: longest dependency path determines landing order depth", () => {
   const depths = taskDependencyDepths([
     { task_id: "b", depends_on_task_id: "a" },
     { task_id: "c", depends_on_task_id: "b" },
@@ -36,7 +37,7 @@ Deno.test("taskDependencyDepths: longest dependency path determines landing orde
   ]);
 });
 
-Deno.test("planLane: task id is the deterministic tiebreaker", () => {
+test("planLane: task id is the deterministic tiebreaker", () => {
   assertEquals(planLane(["gap-9", "gap-2", "gap-8"], taskToPr, new Set()), {
     headTaskId: "gap-2",
     headPrKey: "o/r#2",
@@ -45,7 +46,7 @@ Deno.test("planLane: task id is the deterministic tiebreaker", () => {
   });
 });
 
-Deno.test("planLane: already-merged head advances to the next unmerged member", () => {
+test("planLane: already-merged head advances to the next unmerged member", () => {
   assertEquals(planLane(["gap-2", "gap-8", "gap-9"], taskToPr, new Set(["o/r#2"])), {
     headTaskId: "gap-8",
     headPrKey: "o/r#8",
@@ -54,7 +55,7 @@ Deno.test("planLane: already-merged head advances to the next unmerged member",
   });
 });
 
-Deno.test("planLane: single-member lanes never hold their PR", () => {
+test("planLane: single-member lanes never hold their PR", () => {
   assertEquals(planLane(["gap-10"], taskToPr, new Set()), {
     headTaskId: null,
     headPrKey: null,
@@ -63,7 +64,7 @@ Deno.test("planLane: single-member lanes never hold their PR", () => {
   });
 });
 
-Deno.test("planLane: tasks without PR keys do not block PR-backed members", () => {
+test("planLane: tasks without PR keys do not block PR-backed members", () => {
   assertEquals(planLane(["scaffold", "gap-2", "gap-8"], taskToPr, new Set()), {
     headTaskId: "gap-2",
     headPrKey: "o/r#2",
@@ -72,7 +73,7 @@ Deno.test("planLane: tasks without PR keys do not block PR-backed members", () =
   });
 });
 
-Deno.test("planPrLane: held PRs point at the current lane head", () => {
+test("planPrLane: held PRs point at the current lane head", () => {
   assertEquals(
     planPrLane([["gap-2", "gap-8"], ["gap-10"]], taskToPr, new Set(), "o/r#8"),
     {
@@ -84,7 +85,7 @@ Deno.test("planPrLane: held PRs point at the current lane head", () => {
   );
 });
 
-Deno.test("planPrLane: lane head and PRs outside exclusion lanes are not held", () => {
+test("planPrLane: lane head and PRs outside exclusion lanes are not held", () => {
   assertEquals(planPrLane([["gap-2", "gap-8"], ["gap-10"]], taskToPr, new Set(), "o/r#2").isHeld, false);
   assertEquals(planPrLane([["gap-2", "gap-8"], ["gap-10"]], taskToPr, new Set(), "o/r#10").isHeld, false);
   assertEquals(planPrLane([["gap-2", "gap-8"]], taskToPr, new Set(), "o/r#404").isHeld, false);