@nanobpm/nano-workforce 0.36.0 → 0.37.0

package/app/blackboard.test.ts

@@ -1,5 +1,6 @@
 // Unit tests for the epic coordination blackboard (Tier 1, issues #51 / #49 D4).
-import { assert, assertEquals, assertStringIncludes } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals, assertStringIncludes } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import {
   appendEntry,
@@ -17,16 +18,12 @@ import {
 
 // A tiny in-memory stand-in for the record gateway, matching the subset of the Table<T> API the
 // blackboard uses (insert/find/findOne). Mirrors the fake-app style used across 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[]);
     return {
-      // deno-lint-ignore no-explicit-any require-await
       async insert(row: any) {
         if (pk === "id") {
           const id = (seq[name] = (seq[name] ?? 0) + 1);
@@ -36,22 +33,19 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
         rows.push({ ...row });
         return row[pk];
       },
-      // deno-lint-ignore no-explicit-any require-await
       async find(where: any = {}) {
         return rows.filter((r) => Object.entries(where).every(([k, v]) => r[k] === v));
       },
-      // deno-lint-ignore no-explicit-any require-await
       async findOne(where: any = {}) {
         return rows.find((r) => Object.entries(where).every(([k, v]) => r[k] === v));
       },
     };
   }
-  // deno-lint-ignore no-explicit-any
   const data = { table: (n: string, pk?: string) => tbl(n, pk) } as any as DataLayer;
   return { data, stores };
 }
 
-Deno.test("mintBlackboardToken: URL-safe, unguessable, unique", () => {
+test("mintBlackboardToken: URL-safe, unguessable, unique", () => {
   const a = mintBlackboardToken();
   const b = mintBlackboardToken();
   assert(a !== b, "two mints must differ");
@@ -59,12 +53,12 @@ Deno.test("mintBlackboardToken: URL-safe, unguessable, unique", () => {
   assert(a.length >= 32, "token should carry enough entropy");
 });
 
-Deno.test("publicBaseUrl: honours the env override and trims a trailing slash", () => {
+test("publicBaseUrl: honours the env override and trims a trailing slash", () => {
   assertEquals(publicBaseUrl("https://pr.example.com/"), "https://pr.example.com");
   assertEquals(publicBaseUrl("https://pr.example.com///"), "https://pr.example.com");
 });
 
-Deno.test("publicBaseUrl: a blank/whitespace override falls back instead of yielding a bad URL", () => {
+test("publicBaseUrl: a blank/whitespace override falls back instead of yielding a bad URL", () => {
   const prev = process.env.NANO_PR_BASE_URL;
   delete process.env.NANO_PR_BASE_URL;
   try {
@@ -77,14 +71,14 @@ Deno.test("publicBaseUrl: a blank/whitespace override falls back instead of yiel
   }
 });
 
-Deno.test("blackboardUrl: capability token rides the query string", () => {
+test("blackboardUrl: capability token rides the query string", () => {
   assertEquals(
     blackboardUrl("tok+en/x", "https://h"),
     "https://h/hooks/blackboard?token=tok%2Ben%2Fx",
   );
 });
 
-Deno.test("normalizeKind: valid passes through, anything else becomes note", () => {
+test("normalizeKind: valid passes through, anything else becomes note", () => {
   assertEquals(normalizeKind("file-claim"), "file-claim");
   assertEquals(normalizeKind("constraint-change"), "constraint-change");
   assertEquals(normalizeKind("learning"), "learning");
@@ -92,7 +86,7 @@ Deno.test("normalizeKind: valid passes through, anything else becomes note", ()
   assertEquals(normalizeKind(undefined), "note");
 });
 
-Deno.test("renderCoordinationBrief: leads with a separator and teaches the protocol + URL", () => {
+test("renderCoordinationBrief: leads with a separator and teaches the protocol + URL", () => {
   const url = "https://h/hooks/blackboard?token=abc";
   const brief = renderCoordinationBrief(url);
   assert(brief.startsWith("\n\n---"), "must own a leading separator (appendPrompt adds none)");
@@ -112,7 +106,7 @@ Deno.test("renderCoordinationBrief: leads with a separator and teaches the proto
   assertStringIncludes(brief, "Share what you learn");
 });
 
-Deno.test("planKeyForToken: resolves a token to its plan, undefined otherwise", async () => {
+test("planKeyForToken: resolves a token to its plan, undefined otherwise", async () => {
   const { data } = memData();
   await data.table("plans", "plan_key").insert({ plan_key: "o/r#7", blackboard_token: "tok7" });
   assertEquals(await planKeyForToken(data, "tok7"), "o/r#7");
@@ -120,7 +114,7 @@ Deno.test("planKeyForToken: resolves a token to its plan, undefined otherwise",
   assertEquals(await planKeyForToken(data, ""), undefined);
 });
 
-Deno.test("appendEntry + readBlackboard: append, encode files, read back in write order", async () => {
+test("appendEntry + readBlackboard: append, encode files, read back in write order", async () => {
   const { data } = memData();
   await appendEntry(data, "o/r#1", { author_task: "gap-2", kind: "file-claim", files: ["a.rs"], body: "touches a.rs" });
   await appendEntry(data, "o/r#1", { author_task: "gap-8", kind: "note", body: "heads up" });
@@ -133,14 +127,14 @@ Deno.test("appendEntry + readBlackboard: append, encode files, read back in writ
   assertEquals(entries[1].author_task, "gap-8");
 });
 
-Deno.test("appendEntry: trims whitespace-padded file paths so stored/read values are clean", async () => {
+test("appendEntry: trims whitespace-padded file paths so stored/read values are clean", async () => {
   const { data } = memData();
   await appendEntry(data, "p", { kind: "file-claim", files: ["  engine/state.rs  ", "\tengine/mine.rs\n"], body: "claims" });
   const [e] = await readBlackboard(data, "p");
   assertEquals(e.files, ["engine/state.rs", "engine/mine.rs"], "paths stored trimmed, not whitespace-padded");
 });
 
-Deno.test("appendEntry: a missing author defaults to 'system' and kind is normalised", async () => {
+test("appendEntry: a missing author defaults to 'system' and kind is normalised", async () => {
   const { data } = memData();
   await appendEntry(data, "p", { body: "x", kind: "weird" as unknown });
   const [e] = await readBlackboard(data, "p");
@@ -148,7 +142,7 @@ Deno.test("appendEntry: a missing author defaults to 'system' and kind is normal
   assertEquals(e.kind, "note");
 });
 
-Deno.test("appendEntry: idempotent on dedupe_key (a job retry re-POST is a no-op)", async () => {
+test("appendEntry: idempotent on dedupe_key (a job retry re-POST is a no-op)", async () => {
   const { data, stores } = memData();
   const first = await appendEntry(data, "p", { author_task: "t", body: "claim", dedupe_key: "t:claim:1" });
   const again = await appendEntry(data, "p", { author_task: "t", body: "claim", dedupe_key: "t:claim:1" });
@@ -158,15 +152,13 @@ Deno.test("appendEntry: idempotent on dedupe_key (a job retry re-POST is a no-op
   assertEquals(stores["plan_blackboard"].length, 1, "exactly one row persisted");
 });
 
-Deno.test("appendEntry: a lost UNIQUE race collapses to a no-op instead of a 500", async () => {
+test("appendEntry: a lost UNIQUE race collapses to a no-op instead of a 500", async () => {
   // Simulate the concurrency window: two POSTs share a dedupe_key, both miss the findOne
   // pre-check, then insert loses the race on the UNIQUE (plan_key, dedupe_key) index. The
   // catch branch must re-read the winner's row and return it rather than propagate the throw.
   const winner = { id: 42, plan_key: "p", dedupe_key: "t:claim:1", author_task: "t", body: "claim" };
   let preCheckDone = false;
-  // deno-lint-ignore no-explicit-any
   const table: any = {
-    // deno-lint-ignore require-await
     async findOne() {
       // Pre-check misses (row not yet visible); the recovery read after the collision hits.
       if (!preCheckDone) {
@@ -175,21 +167,19 @@ Deno.test("appendEntry: a lost UNIQUE race collapses to a no-op instead of a 500
       }
       return winner;
     },
-    // deno-lint-ignore require-await
     async insert() {
       throw Object.assign(new Error("UNIQUE constraint failed: plan_blackboard.dedupe_key"), {
         code: "SQLITE_CONSTRAINT_UNIQUE",
       });
     },
   };
-  // deno-lint-ignore no-explicit-any
   const data = { table: () => table } as any as DataLayer;
   const res = await appendEntry(data, "p", { author_task: "t", body: "claim", dedupe_key: "t:claim:1" });
   assertEquals(res.inserted, false, "a lost race is not a fresh insert");
   assertEquals(res.id, 42, "returns the winning row's id");
 });
 
-Deno.test("appendEntry: a blank body is rejected", async () => {
+test("appendEntry: a blank body is rejected", async () => {
   const { data } = memData();
   let threw = false;
   try {
@@ -200,7 +190,7 @@ Deno.test("appendEntry: a blank body is rejected", async () => {
   assert(threw, "blank body must throw");
 });
 
-Deno.test("readBlackboard: since returns only newer entries (incremental poll)", async () => {
+test("readBlackboard: since returns only newer entries (incremental poll)", async () => {
   const { data } = memData();
   await appendEntry(data, "p", { body: "one" });
   await appendEntry(data, "p", { body: "two" });
@@ -210,7 +200,7 @@ Deno.test("readBlackboard: since returns only newer entries (incremental poll)",
   assertEquals(tail.map((e) => e.body), ["two", "three"]);
 });
 
-Deno.test("readBlackboardPage: cursor is the plan head and lets an agent poll to caught-up (Tier 2)", async () => {
+test("readBlackboardPage: cursor is the plan head and lets an agent poll to caught-up (Tier 2)", async () => {
   const { data } = memData();
   await appendEntry(data, "p", { body: "one" });
   await appendEntry(data, "p", { body: "two" });
@@ -231,14 +221,14 @@ Deno.test("readBlackboardPage: cursor is the plan head and lets an agent poll to
   assertEquals(next.cursor, next.entries[0].id);
 });
 
-Deno.test("readBlackboardPage: an empty plan yields no entries and a zero cursor", async () => {
+test("readBlackboardPage: an empty plan yields no entries and a zero cursor", async () => {
   const { data } = memData();
   const page = await readBlackboardPage(data, "empty");
   assertEquals(page.entries, []);
   assertEquals(page.cursor, 0);
 });
 
-Deno.test("detectFileClaimConflicts: a sibling's prior claim on the same file is surfaced", async () => {
+test("detectFileClaimConflicts: a sibling's prior claim on the same file is surfaced", async () => {
   const { data } = memData();
   await appendEntry(data, "p", { author_task: "gap-2", kind: "file-claim", files: ["engine/state.rs"], body: "owns state.rs" });
 
@@ -251,7 +241,7 @@ Deno.test("detectFileClaimConflicts: a sibling's prior claim on the same file is
   assertEquals(conflicts[0].author_task, "gap-2", "reports the first (winning) claimer");
 });
 
-Deno.test("detectFileClaimConflicts: your own prior claim and non-file-claim entries are not conflicts", async () => {
+test("detectFileClaimConflicts: your own prior claim and non-file-claim entries are not conflicts", async () => {
   const { data } = memData();
   await appendEntry(data, "p", { author_task: "gap-2", kind: "file-claim", files: ["a.rs"], body: "my earlier claim" });
   await appendEntry(data, "p", { author_task: "gap-8", kind: "note", files: ["a.rs"], body: "just a note about a.rs" });
@@ -265,7 +255,7 @@ Deno.test("detectFileClaimConflicts: your own prior claim and non-file-claim ent
   assertEquals(await detectFileClaimConflicts(data, "p", { author_task: "gap-9", files: [] }), []);
 });
 
-Deno.test("detectFileClaimConflicts: beforeId restricts to strictly prior claims (insertion order wins)", async () => {
+test("detectFileClaimConflicts: beforeId restricts to strictly prior claims (insertion order wins)", async () => {
   const { data } = memData();
   const prior = await appendEntry(data, "p", {
     author_task: "gap-2",
@@ -299,7 +289,7 @@ Deno.test("detectFileClaimConflicts: beforeId restricts to strictly prior claims
   assert(Number(later.id) > Number(mine.id));
 });
 
-Deno.test("isUniqueViolation: true for UNIQUE/PK, false for FOREIGN KEY and unrelated errors", () => {
+test("isUniqueViolation: true for UNIQUE/PK, false for FOREIGN KEY and unrelated errors", () => {
   // Extended SQLite codes.
   assert(isUniqueViolation(Object.assign(new Error("x"), { code: "SQLITE_CONSTRAINT_UNIQUE" })));
   assert(isUniqueViolation(Object.assign(new Error("x"), { code: "SQLITE_CONSTRAINT_PRIMARYKEY" })));

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);