@nanobpm/nano-workforce 0.35.2 → 0.37.0

package/operations/listActivePrs.test.ts

@@ -1,19 +1,17 @@
 // Tests for GET /app/api/status → operation `listActivePrs` (ADR 0058 OpenAPI surface).
 // Covers the happy path (count/prs projection) and the optional shared-secret guard. A minimal
 // in-memory DataLayer backs `activePrs` (it reads the `pull_requests` table via `.all()`).
-import { assert, assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import handler from "./listActivePrs.ts";
 
-// deno-lint-ignore no-explicit-any
 function memApp(rows: any[]): AppApi {
   const tbl = {
-    // deno-lint-ignore require-await
     async all() {
       return rows;
     },
   };
-  // deno-lint-ignore no-explicit-any
   return { data: { table: () => tbl } } as any as AppApi;
 }
 
@@ -25,7 +23,6 @@ function input(headers: Record<string, string> = {}) {
       query: new URLSearchParams(),
       headers: new Headers(headers),
       text: async () => "",
-      // deno-lint-ignore no-explicit-any
     } as any,
     params: {},
     query: {},
@@ -33,13 +30,12 @@ function input(headers: Record<string, string> = {}) {
   };
 }
 
-Deno.test("returns 200 with a count + projected active PRs", async () => {
+test("returns 200 with a count + projected active PRs", async () => {
   const app = memApp([
     { pr_key: "o/r#1", repo: "o/r", number: 1, url: "u1", title: "t", status: "converging", current_round: 2, process_key: "9", updated_at: "2026-01-02" },
     { pr_key: "o/r#2", repo: "o/r", number: 2, url: "u2", title: null, status: "converged", current_round: 1, process_key: null, updated_at: "2026-01-01" },
   ]);
   const res = await handler(input(), app);
-  // deno-lint-ignore no-explicit-any
   const r = res as any;
   assertEquals(r.status, 200);
   // `converged` is terminal → filtered out, leaving one active PR.
@@ -49,22 +45,20 @@ Deno.test("returns 200 with a count + projected active PRs", async () => {
   assertEquals(r.body.prs[0].processKey, "9");
 });
 
-Deno.test("shared-secret guard rejects a missing secret when configured", async () => {
-  const prev = Deno.env.get("NANO_PR_WEBHOOK_SECRET");
-  Deno.env.set("NANO_PR_WEBHOOK_SECRET", "s3cr3t");
+test("shared-secret guard rejects a missing secret when configured", async () => {
+  const prev = process.env["NANO_PR_WEBHOOK_SECRET"];
+  process.env["NANO_PR_WEBHOOK_SECRET"] = "s3cr3t";
   try {
     const mod = await import(`./listActivePrs.ts?guard=${Date.now()}`);
     const guarded = mod.default as typeof handler;
     const app = memApp([]);
-    // deno-lint-ignore no-explicit-any
     const bad = (await guarded(input(), app)) as any;
     assertEquals(bad.status, 401);
-    // deno-lint-ignore no-explicit-any
     const ok = (await guarded(input({ "x-hook-secret": "s3cr3t" }), app)) as any;
     assertEquals(ok.status, 200);
     assert("count" in ok.body);
   } finally {
-    if (prev === undefined) Deno.env.delete("NANO_PR_WEBHOOK_SECRET");
-    else Deno.env.set("NANO_PR_WEBHOOK_SECRET", prev);
+    if (prev === undefined) delete process.env["NANO_PR_WEBHOOK_SECRET"];
+    else process.env["NANO_PR_WEBHOOK_SECRET"] = prev;
   }
 });

package/operations/listActivePrs.ts

@@ -10,9 +10,8 @@ import { defineOperation } from "@nanobpm/urban";
 import { type ActivePr, activePrs } from "../app/service.ts";
 import { envVar } from "../app/version.ts";
 
-// Cross-runtime env read (Node `process.env` OR Deno `Deno.env`): reading via `process.env` alone
-// would silently disable the guard under Deno/compiled runtimes where `process` is absent, leaving
-// the endpoint open even when NANO_PR_WEBHOOK_SECRET is set. Captured once, at module load.
+// The optional shared-secret guard: when NANO_PR_WEBHOOK_SECRET is set, callers must present it via
+// the x-hook-secret header. Captured once, at module load.
 const SECRET = envVar("NANO_PR_WEBHOOK_SECRET") ?? "";
 
 type Res = { count: number; prs: ActivePr[] } | { error: string };

package/operations/postMessage.ts

@@ -9,8 +9,8 @@
 // for free); this delegate keeps the message-name dispatch — the discriminator + downstream behavior
 // is app logic, not something the JSON schema can express.
 import { defineOperation } from "@nanobpm/urban";
-import { answerEscalation } from "../app/service.ts";
 import { answerTaskEscalation, FEATURE_ESCALATION_MESSAGE } from "../app/plan.ts";
+import { answerEscalation } from "../app/service.ts";
 
 interface Body {
   name?: unknown;
@@ -28,7 +28,7 @@ export default defineOperation<
 
   if (name === "escalation-answered") {
     const prKey = String(b.correlationKey ?? "");
-    const answer = String((b.variables?.answer ?? "") as string).trim();
+    const answer = String(b.variables?.answer ?? "").trim();
     if (!prKey) return { status: 400, body: { error: "correlationKey is required" } };
     if (!answer) return { status: 400, body: { error: "answer is required" } };
     const r = await answerEscalation(app.data, app.engine, prKey, answer);
@@ -40,7 +40,7 @@ export default defineOperation<
     // `<plan_key>:<task_id>`; record the answer, resume the parked child, and re-surface the next
     // open escalation.
     const corrKey = String(b.correlationKey ?? "");
-    const answer = String((b.variables?.answer ?? "") as string).trim();
+    const answer = String(b.variables?.answer ?? "").trim();
     if (!corrKey) return { status: 400, body: { error: "correlationKey is required" } };
     if (!answer) return { status: 400, body: { error: "answer is required" } };
     const r = await answerTaskEscalation(app.data, app.engine, corrKey, answer);

package/operations/startAndMessage.test.ts

@@ -2,19 +2,17 @@
 // These cover the app-logic guards the JSON schema can't express (reference parsing, message-name
 // dispatch); the runtime's schema validation (required `variables`/`name`) is exercised by urban's
 // own api runtime tests.
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import startConvergenceLoop from "./startConvergenceLoop.ts";
 import startPlanFanout from "./startPlanFanout.ts";
 import postMessage from "./postMessage.ts";
 
-// deno-lint-ignore no-explicit-any
 const app = {} as any as AppApi;
 
-// deno-lint-ignore no-explicit-any
 function input(body: any) {
   return {
-    // deno-lint-ignore no-explicit-any
     req: { method: "POST", path: "/", query: new URLSearchParams(), headers: new Headers(), text: async () => "" } as any,
     params: {},
     query: {},
@@ -22,33 +20,29 @@ function input(body: any) {
   };
 }
 
-Deno.test("startConvergenceLoop → 400 on an unparseable PR reference", async () => {
+test("startConvergenceLoop → 400 on an unparseable PR reference", async () => {
   const res = await startConvergenceLoop(input({ variables: { pr: "not a pr" } }), app);
-  // deno-lint-ignore no-explicit-any
   const r = res as any;
   assertEquals(r.status, 400);
   assertEquals(typeof r.body.error, "string");
 });
 
-Deno.test("startPlanFanout → 400 on an unparseable issue reference", async () => {
+test("startPlanFanout → 400 on an unparseable issue reference", async () => {
   const res = await startPlanFanout(input({ variables: { issue: "" } }), app);
-  // deno-lint-ignore no-explicit-any
   const r = res as any;
   assertEquals(r.status, 400);
   assertEquals(typeof r.body.error, "string");
 });
 
-Deno.test("postMessage → 400 when name is blank", async () => {
+test("postMessage → 400 when name is blank", async () => {
   const res = await postMessage(input({ name: "" }), app);
-  // deno-lint-ignore no-explicit-any
   const r = res as any;
   assertEquals(r.status, 400);
   assertEquals(r.body.error, "name is required");
 });
 
-Deno.test("postMessage → 400 when escalation-answered lacks a correlationKey", async () => {
+test("postMessage → 400 when escalation-answered lacks a correlationKey", async () => {
   const res = await postMessage(input({ name: "escalation-answered", variables: { answer: "yes" } }), app);
-  // deno-lint-ignore no-explicit-any
   const r = res as any;
   assertEquals(r.status, 400);
   assertEquals(r.body.error, "correlationKey is required");

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.35.2",
+  "version": "0.37.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",
+  "imports": {
+    "#test-assert": "./test/assert.ts"
+  },
   "engines": {
     "node": ">=22.6"
   },
@@ -30,19 +33,21 @@
     "upgrade": "node --experimental-strip-types scripts/upgrade-from-pack.ts",
     "check": "urban check",
     "typecheck": "tsc --noEmit",
-    "check:prompts": "deno run -A scripts/check-agent-prompts.ts",
+    "check:prompts": "node --experimental-strip-types scripts/check-agent-prompts.ts",
     "gen": "urban gen",
     "gen:check": "urban gen --check",
     "layout": "node --experimental-strip-types scripts/layout-bpmn.ts",
     "layout:check": "node --experimental-strip-types scripts/layout-bpmn.ts --check",
     "dev": "urban dev",
-    "compile": "deno task compile",
-    "test": "deno test -A"
+    "test": "node --experimental-strip-types --test",
+    "lint": "biome check app operations actions workers pages components scripts main.ts",
+    "lint:fix": "biome check --write app operations actions workers pages components scripts main.ts"
   },
   "dependencies": {
     "@nanobpm/urban": "^0.33.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.11",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/npm": "^13.1.5",

package/plugins/no-unsafe-type-assertion.grit

@@ -0,0 +1,12 @@
+engine biome(1.0)
+language js(typescript)
+
+`$expr as $type` as $assertion where {
+    $type <: not r"^const$",
+    $assertion <: not within JsImport(),
+    register_diagnostic(
+        span = $assertion,
+        message = "Type assertions (`as T`) bypass the type system. Use a type guard or `satisfies` instead. If unavoidable, add `// biome-ignore lint/plugin: <reason>` above.",
+        severity = "error"
+    )
+}

package/scripts/check-agent-prompts.test.ts

@@ -4,7 +4,11 @@
 // blank agent-prompt header — ships an effectively prompt-less agent (the root of the empty
 // "(no question provided)" escalations on Magikcraft/nano-bpm #597/#599). These cases assert it
 // fails on each of those shapes and passes on a well-formed app.
-import { assert, assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
 import { checkAgentPrompts } from "./check-agent-prompts.ts";
 
 const MANIFEST = JSON.stringify({
@@ -16,17 +20,17 @@ function header(value: string): string {
 }
 
 // Build a throwaway app tree and return its root. Each entry maps a repo-relative path to content.
-async function fixture(files: Record<string, string>): Promise<string> {
-  const root = await Deno.makeTempDir({ prefix: "agent-prompts-" });
+function fixture(files: Record<string, string>): string {
+  const root = mkdtempSync(join(tmpdir(), "agent-prompts-"));
   for (const [rel, content] of Object.entries(files)) {
-    const abs = `${root}/${rel}`;
-    await Deno.mkdir(abs.slice(0, abs.lastIndexOf("/")), { recursive: true });
-    await Deno.writeTextFile(abs, content);
+    const abs = join(root, rel);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, content);
   }
   return root;
 }
 
-Deno.test("passes when every {{token}} resolves to a non-blank template", async () => {
+test("passes when every {{token}} resolves to a non-blank template", async () => {
   const root = await fixture({
     "nano.app.json": MANIFEST,
     "resources/processes/loop.bpmn": header("{{review-round}}"),
@@ -38,7 +42,7 @@ Deno.test("passes when every {{token}} resolves to a non-blank template", async
   assertEquals(res.resolved, ["review-round"]);
 });
 
-Deno.test("fails when a header references an undeclared template", async () => {
+test("fails when a header references an undeclared template", async () => {
   const root = await fixture({
     "nano.app.json": MANIFEST,
     "resources/processes/loop.bpmn": header("{{does-not-exist}}"),
@@ -49,7 +53,7 @@ Deno.test("fails when a header references an undeclared template", async () => {
   assert(res.errors.some((e) => e.includes("{{does-not-exist}}") && e.includes("no such template")));
 });
 
-Deno.test("fails when the referenced template file is blank (would substitute to nothing)", async () => {
+test("fails when the referenced template file is blank (would substitute to nothing)", async () => {
   const root = await fixture({
     "nano.app.json": MANIFEST,
     "resources/processes/loop.bpmn": header("{{review-round}}"),
@@ -60,7 +64,7 @@ Deno.test("fails when the referenced template file is blank (would substitute to
   assert(res.errors.some((e) => e.includes("empty") && e.includes("review-round")));
 });
 
-Deno.test("fails when a reserved agent-prompt header is blank", async () => {
+test("fails when a reserved agent-prompt header is blank", async () => {
   const root = await fixture({
     "nano.app.json": MANIFEST,
     "resources/processes/loop.bpmn": header(""),
@@ -71,7 +75,7 @@ Deno.test("fails when a reserved agent-prompt header is blank", async () => {
   assert(res.errors.some((e) => e.includes("is empty")));
 });
 
-Deno.test("checks the real repo: all committed agent prompts resolve", () => {
+test("checks the real repo: all committed agent prompts resolve", () => {
   // The guard must be green against the actual app it protects — this is the case CI relies on.
   const repoRoot = decodeURIComponent(new URL("../", import.meta.url).pathname);
   const res = checkAgentPrompts(repoRoot);

package/scripts/check-agent-prompts.ts

@@ -64,9 +64,10 @@ function templateMap(root: string, patterns: string[]): Record<string, string> {
 // signal can't see (an empty value carries no `{{token}}` to be unresolved).
 function hasBlankAgentPromptHeader(bpmn: string): boolean {
   const re = /<zeebe:header\s+key="([^"]*)"\s+value="([^"]*)"\s*\/?>/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(bpmn)) !== null) {
+  let m = re.exec(bpmn);
+  while (m !== null) {
     if (m[1] === AGENT_PROMPT_HEADER && m[2].trim() === "") return true;
+    m = re.exec(bpmn);
   }
   return false;
 }
@@ -86,6 +87,7 @@ export function checkAgentPrompts(root: string): CheckResult {
   if (!existsSync(manifestPath)) {
     return { ok: false, errors: [`nano.app.json not found under ${root}`], resolved: [] };
   }
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as AppManifest;
   const models = manifest.models ?? {};
   const templates = templateMap(root, models.templates ?? []);

package/scripts/layout-bpmn.ts

@@ -1,4 +1,4 @@
-// npm run layout <file.bpmn ...> (or `deno task layout <file.bpmn ...>`) — (re)generate the
+// npm run layout <file.bpmn ...> — (re)generate the
 // bpmndi:BPMNDiagram for one or more BPMN models using the urban toolkit's `layoutBpmn`
 // (bpmn-auto-layout). The semantic model stays authoritative: author the process elements
 // (tasks, gateways, flows, zeebe extensions) and run this to derive an auto-laid-out diagram,
@@ -8,37 +8,18 @@
 // `--check` (npm run layout:check) regenerates the DI in memory and fails with a non-zero exit
 // if any committed diagram is stale, WITHOUT rewriting files — the CI freshness gate that stops
 // a BPMN flow change from merging with an un-regenerated diagram.
+import { readdir, readFile, writeFile } from "node:fs/promises";
 import { layoutBpmn } from "@nanobpm/urban";
 
-// Host-agnostic file I/O: Deno inside a compiled binary, else node:fs under Node — mirrors
-// app/plan.ts's readAsset seam so this runs the same under `npm run` and `deno task`.
-const g = globalThis as {
-  Deno?: {
-    args: string[];
-    readDir(p: string): AsyncIterable<{ name: string; isFile: boolean }>;
-    readTextFile(p: string): Promise<string>;
-    writeTextFile(p: string, s: string): Promise<void>;
-  };
-};
-
 async function readText(path: string): Promise<string> {
-  return g.Deno?.readTextFile
-    ? await g.Deno.readTextFile(path)
-    : await (await import("node:fs/promises")).readFile(path, "utf8");
+  return await readFile(path, "utf8");
 }
 async function writeText(path: string, text: string): Promise<void> {
-  if (g.Deno?.writeTextFile) return await g.Deno.writeTextFile(path, text);
-  await (await import("node:fs/promises")).writeFile(path, text, "utf8");
+  await writeFile(path, text, "utf8");
 }
 async function defaultProcessFiles(): Promise<string[]> {
   const dir = "resources/processes";
-  if (g.Deno?.readDir) {
-    const files: string[] = [];
-    for await (const e of g.Deno.readDir(dir)) if (e.isFile && e.name.endsWith(".bpmn")) files.push(`${dir}/${e.name}`);
-    return files.sort();
-  }
-  const fs = await import("node:fs/promises");
-  return (await fs.readdir(dir, { withFileTypes: true }))
+  return (await readdir(dir, { withFileTypes: true }))
     .filter((e) => e.isFile() && e.name.endsWith(".bpmn"))
     .map((e) => `${dir}/${e.name}`)
     .sort();
@@ -52,12 +33,11 @@ const countDi = (xml: string) => ({
 });
 
 function exit(code: number): never {
-  if (g.Deno) return (globalThis as { Deno?: { exit(c: number): never } }).Deno!.exit(code);
   process.exit(code);
 }
 
 async function main() {
-  const argv = g.Deno?.args ?? process.argv.slice(2);
+  const argv = process.argv.slice(2);
   // `--check` mode: regenerate the DI in memory and fail (non-zero) if it differs from what's
   // committed, WITHOUT rewriting any file. This is the CI freshness gate — it catches a BPMN
   // flow change whose author forgot to re-run `npm run layout`, so a stale diagram can't merge.

package/scripts/pages-contract.test.ts

@@ -10,7 +10,9 @@
 // It also pins the issue #87 surfaces: the plan-review audit log (`plan_reviews`) — which is
 // persisted but was surfaced on no page — must appear on the epic page (flat grid) and inside the
 // home page's plan detail (child grid). Feature coverage so the trace can't silently regress out.
-import { assert } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert } from "#test-assert";
+import { readdirSync, readFileSync } from "node:fs";
 
 // Percent-decode the pathname: `new URL(..).pathname` can contain encoded characters (e.g. a space
 // as `%20`), which `Deno.readDir`/`readTextFile` would fail to resolve. Matches the repo convention
@@ -79,22 +81,21 @@ function splitTopLevel(body: string): string[] {
   return out;
 }
 
-async function loadSchema(): Promise<Map<string, Set<string>>> {
+function loadSchema(): Map<string, Set<string>> {
   const schema = new Map<string, Set<string>>();
   const files: string[] = [];
-  for await (const e of Deno.readDir(`${ROOT}db/migrations`)) {
-    if (e.isFile && e.name.endsWith(".sql")) files.push(e.name);
+  for (const e of readdirSync(`${ROOT}db/migrations`, { withFileTypes: true })) {
+    if (e.isFile() && e.name.endsWith(".sql")) files.push(e.name);
   }
   files.sort(); // migration order doesn't matter for the union, but keep it deterministic
   for (const f of files) {
-    parseSchema(await Deno.readTextFile(`${ROOT}db/migrations/${f}`), schema);
+    parseSchema(readFileSync(`${ROOT}db/migrations/${f}`, "utf8"), schema);
   }
   return schema;
 }
 
 // ---- pages -> datasource references -------------------------------------------------------------
 
-// deno-lint-ignore no-explicit-any
 type Json = any;
 
 interface Ref {
@@ -164,11 +165,11 @@ function collectRefs(page: string, node: Json, out: Ref[]): void {
   for (const v of Object.values(node)) collectRefs(page, v, out);
 }
 
-async function loadRefs(): Promise<Ref[]> {
+function loadRefs(): Ref[] {
   const refs: Ref[] = [];
-  for await (const e of Deno.readDir(`${ROOT}pages`)) {
-    if (!e.isFile || !e.name.endsWith(".page.json")) continue;
-    const page = JSON.parse(await Deno.readTextFile(`${ROOT}pages/${e.name}`));
+  for (const e of readdirSync(`${ROOT}pages`, { withFileTypes: true })) {
+    if (!e.isFile() || !e.name.endsWith(".page.json")) continue;
+    const page = JSON.parse(readFileSync(`${ROOT}pages/${e.name}`, "utf8"));
     collectRefs(e.name, page, refs);
   }
   return refs;
@@ -176,7 +177,7 @@ async function loadRefs(): Promise<Ref[]> {
 
 // ---- guards -------------------------------------------------------------------------------------
 
-Deno.test("every page datasource table exists in the migrations", async () => {
+test("every page datasource table exists in the migrations", async () => {
   const schema = await loadSchema();
   const refs = await loadRefs();
   assert(refs.length > 0, "no datasource references found — collector or pages are broken");
@@ -190,7 +191,7 @@ Deno.test("every page datasource table exists in the migrations", async () => {
   }
 });
 
-Deno.test("every page datasource column exists on its table", async () => {
+test("every page datasource column exists on its table", async () => {
   const schema = await loadSchema();
   const refs = await loadRefs();
   for (const r of refs) {
@@ -206,7 +207,7 @@ Deno.test("every page datasource column exists on its table", async () => {
   }
 });
 
-Deno.test("issue #87: plan_reviews is surfaced on the epic and home pages", async () => {
+test("issue #87: plan_reviews is surfaced on the epic and home pages", async () => {
   const refs = await loadRefs();
   const onEpic = refs.some((r) => r.page === "epic.page.json" && r.table === "plan_reviews");
   const onHome = refs.some((r) => r.page === "home.page.json" && r.table === "plan_reviews");

package/scripts/purge-db.ts

@@ -1,4 +1,4 @@
-// npm run purge (or `deno task purge`) — wipe the app's sqlite datasource so `npm start`
+// npm run purge — wipe the app's sqlite datasource so `npm start`
 // comes up against a fresh schema (the runtime re-applies db/migrations on boot). Deletes the
 // sqlite file and its WAL/SHM sidecars for the `app` source declared in nano.app.json.
 import { rmSync } from "node:fs";
@@ -51,7 +51,8 @@ for (const suffix of ["", "-wal", "-shm"]) {
     rmSync(path + suffix);
     console.log(`removed ${path}${suffix}`);
   } catch (err) {
-    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+    const code = typeof err === "object" && err !== null ? Reflect.get(err, "code") : undefined;
+    if (code !== "ENOENT") throw err;
   }
 }
 console.log("app db purged");

package/scripts/upgrade-from-pack.ts

@@ -1,4 +1,4 @@
-// npm run upgrade (or `deno task upgrade`) — refresh THIS app's source from a newer
+// npm run upgrade — refresh THIS app's source from a newer
 // published pack of @nanobpm/nano-workforce, WITHOUT touching your data.
 //
 // Why this exists: a Console project stamped from the example pack is a one-time
@@ -29,6 +29,8 @@
 //                       (skips `npm pack`; --version/--package are ignored)
 //   --force             overlay even if the cwd doesn't look like this app
 //   -h, --help          show this help
+
+import { execFileSync } from "node:child_process";
 import {
   cpSync,
   existsSync,
@@ -39,7 +41,6 @@ import {
   rmSync,
   statSync,
 } from "node:fs";
-import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
@@ -199,10 +200,12 @@ function runTar(tarArgs: string[], tgz: string): string {
   try {
     return execFileSync("tar", tarArgs, { encoding: "utf8" });
   } catch (e) {
-    if ((e as NodeJS.ErrnoException).code === "ENOENT") {
+    const code = typeof e === "object" && e !== null ? Reflect.get(e, "code") : undefined;
+    if (code === "ENOENT") {
       throw new Error(`'tar' not found on PATH — install it to extract ${tgz}`, { cause: e });
     }
-    throw new Error(`tar failed on ${tgz}: ${(e as Error).message}`, { cause: e });
+    const message = e instanceof Error ? e.message : String(e);
+    throw new Error(`tar failed on ${tgz}: ${message}`, { cause: e });
   }
 }
 
@@ -329,6 +332,7 @@ function report(label: string, files: string[]): void {
 try {
   main();
 } catch (err) {
-  console.error(`upgrade failed: ${(err as Error).message}`);
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`upgrade failed: ${message}`);
   process.exit(1);
 }

package/test/assert.ts

@@ -0,0 +1,74 @@
+// Node-native test assertions, presenting the small `@std/assert` surface this repo's suite used
+// under Deno so the 35 ported `*.test.ts` files keep their call sites unchanged (only their import
+// line moved to `#test-assert`). Backed by `node:assert/strict`. Semantics intentionally mirror
+// Deno's std/assert (deep structural equality; the throw helpers return the caught error).
+import nodeAssert from "node:assert/strict";
+
+/** Deep structural equality (Deno `assertEquals`). */
+export function assertEquals<T>(actual: T, expected: T, msg?: string): void {
+  nodeAssert.deepStrictEqual(actual, expected, msg);
+}
+
+/** Deep structural inequality (Deno `assertNotEquals`). */
+export function assertNotEquals<T>(actual: T, expected: T, msg?: string): void {
+  nodeAssert.notDeepStrictEqual(actual, expected, msg);
+}
+
+/** Truthiness (Deno `assert`). */
+export function assert(expr: unknown, msg?: string): asserts expr {
+  nodeAssert.ok(expr, msg);
+}
+
+/** Substring containment (Deno `assertStringIncludes`). */
+export function assertStringIncludes(actual: string, expected: string, msg?: string): void {
+  nodeAssert.ok(
+    actual.includes(expected),
+    msg ?? `expected string to contain "${expected}" but got "${actual}"`,
+  );
+}
+
+// The constructor rest is `any[]` so error subclasses with required args (e.g. WaveError(message))
+// satisfy the type — param contravariance rejects a narrower `unknown[]`/`never[]` here.
+type ErrorClass = new (...args: any[]) => Error;
+
+function checkError(error: unknown, ErrorClass?: ErrorClass, msgIncludes?: string): Error {
+  const err = error instanceof Error ? error : new Error(String(error));
+  const gotName = err.constructor.name;
+  if (ErrorClass && !(err instanceof ErrorClass)) {
+    nodeAssert.fail(`expected error to be instance of ${ErrorClass.name}, got ${gotName}`);
+  }
+  if (msgIncludes && !err.message.includes(msgIncludes)) {
+    nodeAssert.fail(`expected error message to include "${msgIncludes}", got "${err.message}"`);
+  }
+  return err;
+}
+
+/** Assert a sync fn throws; optionally check the error type/message. Returns the caught error
+ *  (Deno `assertThrows`). */
+export function assertThrows(
+  fn: () => unknown,
+  ErrorClass?: ErrorClass,
+  msgIncludes?: string,
+): Error {
+  try {
+    fn();
+  } catch (error) {
+    return checkError(error, ErrorClass, msgIncludes);
+  }
+  nodeAssert.fail("expected function to throw, but it did not");
+}
+
+/** Assert an async fn rejects; optionally check the error type/message. Returns the caught error
+ *  (Deno `assertRejects`). */
+export async function assertRejects(
+  fn: () => Promise<unknown>,
+  ErrorClass?: ErrorClass,
+  msgIncludes?: string,
+): Promise<Error> {
+  try {
+    await fn();
+  } catch (error) {
+    return checkError(error, ErrorClass, msgIncludes);
+  }
+  nodeAssert.fail("expected promise to reject, but it resolved");
+}

package/tsconfig.json

@@ -37,11 +37,14 @@
   },
   "include": [
     "main.ts",
+    "app/**/*.ts",
+    "operations/**/*.ts",
     "workers/**/*.ts",
     "lib/**/*.ts",
     "src/**/*.ts",
     "scripts/**/*.ts",
-    "actions/**/*.ts"
+    "actions/**/*.ts",
+    "test/**/*.ts"
   ],
   "exclude": [
     "node_modules",

package/workers/finalize/worker.ts

@@ -2,9 +2,9 @@
 // merge stage (start the `merge-loop` process and park the PR in `waiting_deps`) when auto-merge
 // is on, or (b) close the PR out as `converged` (review-only mode).
 import type { AppJobHandler } from "@nanobpm/urban";
-import { AUTO_MERGE, ensurePr, startMerge } from "../../app/service.ts";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
 import { maybeStartRetro } from "../../app/retro.ts";
+import { AUTO_MERGE, ensurePr, startMerge } from "../../app/service.ts";
 
 // Extends Record so the declared fields are typed while the job may still carry
 // other process variables (e.g. io.nanobpm.agentResult, read by transcriptOf).
@@ -22,6 +22,7 @@ interface In extends Record<string, unknown> {
 
 const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
 function transcriptOf(vars: Record<string, unknown>): string | null {
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const env = vars[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
   return typeof env?.output === "string" ? env.output : null;
 }