@nanobpm/nano-workforce 0.35.2 → 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/blackboard.ts

@@ -58,11 +58,9 @@ export interface BlackboardInput {
   dedupe_key?: string;
 }
 
-const KIND_SET = new Set<string>(BLACKBOARD_KINDS);
-
 /** Coerce an arbitrary `kind` to a known value, defaulting to "note" for anything unrecognised. */
 export function normalizeKind(kind: unknown): BlackboardKind {
-  return typeof kind === "string" && KIND_SET.has(kind) ? (kind as BlackboardKind) : "note";
+  return BLACKBOARD_KINDS.find((k) => k === kind) ?? "note";
 }
 
 /** A URL-safe, unguessable capability token (192 bits of randomness, base64url, no padding). */
@@ -79,9 +77,10 @@ export function mintBlackboardToken(): string {
 export function publicBaseUrl(env: string | undefined = process.env.NANO_PR_PUBLIC_BASE_URL): string {
   // Cascade through the fallback chain, skipping any value that is unset OR blank/whitespace, so an
   // explicitly-set-but-empty NANO_PR_PUBLIC_BASE_URL can't yield a malformed capability URL.
-  const base = [env, process.env.NANO_PR_BASE_URL, "http://localhost:3000"]
-    .map((v) => v?.trim())
-    .find((v) => v) as string;
+  const base =
+    [env, process.env.NANO_PR_BASE_URL, "http://localhost:3000"]
+      .map((v) => v?.trim())
+      .find((v): v is string => Boolean(v)) ?? "http://localhost:3000";
   return base.replace(/\/+$/, "");
 }
 
@@ -313,8 +312,10 @@ export async function appendEntry(
  * corruption, not a benign duplicate) is always rethrown rather than silently swallowed. */
 export function isUniqueViolation(err: unknown): boolean {
   if (!err || typeof err !== "object") return false;
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const code = (err as { code?: unknown }).code;
   if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") return true;
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const message = (err as { message?: unknown }).message;
   return typeof message === "string" &&
     /(unique|primary key) constraint failed|duplicate/i.test(message);

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,29 +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> {
-  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(
@@ -66,7 +47,10 @@ async function runGh(args: string[]): Promise<string> {
 let ghAvailable: Promise<boolean> | undefined;
 /** Whether the host `gh` CLI is present (memoized — probed at most once per process). */
 function isGhAvailable(): Promise<boolean> {
-  return (ghAvailable ??= runGh(["--version"]).then(() => true, () => false));
+  if (!ghAvailable) {
+    ghAvailable = runGh(["--version"]).then(() => true, () => false);
+  }
+  return ghAvailable;
 }
 
 /** Fetch the reviews for one PR via the configured transport. Throws on transport failure so
@@ -81,6 +65,7 @@ export async function fetchPrReviews(
   const path = `repos/${repo}/pulls/${number}/reviews?per_page=100`;
   if (useGh) {
     const out = await runGh(["api", path, "-H", "Accept: application/vnd.github+json"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     return JSON.parse(out) as GhReview[];
   }
   if (!token) return null; // token mode with no token → poller idles
@@ -88,6 +73,7 @@ export async function fetchPrReviews(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   return (await r.json()) as GhReview[];
 }
 
@@ -122,6 +108,7 @@ export async function hasPendingCopilotReviewer(
   let users: { login?: string }[];
   if (await useGh()) {
     const out = await runGh(["api", path, "-H", "Accept: application/vnd.github+json"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     users = (JSON.parse(out) as { users?: { login?: string }[] }).users ?? [];
   } else {
     if (!token) return null;
@@ -129,6 +116,7 @@ export async function hasPendingCopilotReviewer(
       headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
     });
     if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     users = ((await r.json()) as { users?: { login?: string }[] }).users ?? [];
   }
   return users.some((u) => isCopilot(u.login));
@@ -198,6 +186,7 @@ export async function fetchPrMeta(
 ): Promise<PrMeta | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "title,body"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { title?: string; body?: string };
     return { title: j.title ?? null, body: j.body ?? "" };
   }
@@ -206,6 +195,7 @@ export async function fetchPrMeta(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as { title?: string; body?: string };
   return { title: j.title ?? null, body: j.body ?? "" };
 }
@@ -273,6 +263,7 @@ export async function fetchPrState(
       "--json",
       "state,mergedAt,mergeStateStatus,statusCheckRollup,isDraft,headRefOid",
     ]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as {
       state?: string;
       mergedAt?: string | null;
@@ -298,6 +289,7 @@ export async function fetchPrState(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as {
     merged?: boolean;
     merged_at?: string | null;
@@ -328,6 +320,7 @@ export async function fetchPrFiles(
 ): Promise<string[] | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "files"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { files?: { path?: string }[] };
     return (j.files ?? []).map((f) => f.path ?? "").filter((p) => p !== "");
   }
@@ -341,6 +334,7 @@ export async function fetchPrFiles(
       { headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" } },
     );
     if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const batch = (await r.json()) as { filename?: string }[];
     for (const f of batch) if (f.filename) paths.push(f.filename);
     // A short final page means we've read every file — the list is complete.
@@ -367,6 +361,7 @@ export async function fetchPrHead(
 ): Promise<{ headRef: string | null; headSha: string | null } | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "headRefName,headRefOid"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { headRefName?: string | null; headRefOid?: string | null };
     return { headRef: j.headRefName ?? null, headSha: j.headRefOid ?? null };
   }
@@ -375,6 +370,7 @@ export async function fetchPrHead(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as { head?: { ref?: string | null; sha?: string | null } };
   return { headRef: j.head?.ref ?? null, headSha: j.head?.sha ?? null };
 }
@@ -389,6 +385,7 @@ export async function fetchPrBase(
 ): Promise<string | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "baseRefName"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { baseRefName?: string };
     return j.baseRefName ?? null;
   }
@@ -397,6 +394,7 @@ export async function fetchPrBase(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as { base?: { ref?: string } };
   return j.base?.ref ?? null;
 }
@@ -413,6 +411,7 @@ export async function fetchDefaultBranch(repo: string, token: string): Promise<s
   let name: string | null = null;
   if (await useGh()) {
     const out = await runGh(["repo", "view", repo, "--json", "defaultBranchRef"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { defaultBranchRef?: { name?: string } };
     name = j.defaultBranchRef?.name ?? null;
   } else if (token) {
@@ -420,6 +419,7 @@ export async function fetchDefaultBranch(repo: string, token: string): Promise<s
       headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
     });
     if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = (await r.json()) as { default_branch?: string };
     name = j.default_branch ?? null;
   } else {
@@ -455,6 +455,7 @@ export async function baseBranchLanded(
       "--limit",
       "20",
     ]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const arr = JSON.parse(out) as { state?: string }[];
     if (arr.some((p) => (p.state ?? "").toUpperCase() === "MERGED")) return "landed";
     if (arr.some((p) => (p.state ?? "").toUpperCase() === "OPEN")) return "open";
@@ -467,6 +468,7 @@ export async function baseBranchLanded(
     { headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" } },
   );
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const arr = (await r.json()) as { state?: string; merged_at?: string | null }[];
   if (arr.some((p) => p.merged_at || (p.state ?? "").toUpperCase() === "MERGED")) return "landed";
   if (arr.some((p) => (p.state ?? "").toLowerCase() === "open")) return "open";
@@ -491,7 +493,6 @@ export function classifyMergeability(s: PrState): Mergeability {
       // A required check failed -> a human must act. Pending checks / awaiting review -> wait.
       // When we can't enumerate checks (failingChecks < 0, token mode) stay conservative: wait.
       return s.failingChecks > 0 ? "blocked" : "waiting";
-    case "DRAFT":
     default: // UNKNOWN / "" — GitHub is still computing mergeability
       return "waiting";
   }
@@ -550,6 +551,7 @@ export async function mergePr(
     // in this pass. Trust `merged` when true; otherwise verify the PR's actual state and report
     // `queued` when it hasn't landed yet, so the merge-loop waits for `merge-landed` rather than
     // marking it merged prematurely.
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const body = (await r.json().catch(() => ({}))) as { merged?: boolean };
     if (body.merged) return { outcome: "merged", detail: "merged" };
     const st = await fetchPrState(repo, number, token).catch(() => null);