@nanobpm/nano-workforce 0.36.0 → 0.37.0

package/operations/getVersion.test.ts

@@ -1,11 +1,11 @@
 // Tests for GET /app/api/version → operation `getVersion` (ADR 0058 OpenAPI surface).
 // Ported from the previous actions/version.test.ts. Method handling now belongs to the router
 // (only GET is routed here), so there is no 405 case to test at the delegate level.
-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 "./getVersion.ts";
 
-// deno-lint-ignore no-explicit-any
 const app = {} as any as AppApi;
 
 function input(headers: Record<string, string> = {}) {
@@ -16,7 +16,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: {},
@@ -24,9 +23,8 @@ function input(headers: Record<string, string> = {}) {
   };
 }
 
-Deno.test("returns 200 with the app identity", async () => {
+test("returns 200 with the app identity", async () => {
   const res = await handler(input(), app);
-  // deno-lint-ignore no-explicit-any
   const r = res as any;
   assertEquals(r.status, 200);
   assertEquals(r.body.name, "nano-workforce");
@@ -40,21 +38,19 @@ Deno.test("returns 200 with the app identity", async () => {
   assert(typeof r.body.uptimeSeconds === "number");
 });
 
-Deno.test("shared-secret guard rejects a missing/wrong 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/wrong secret when configured", async () => {
+  const prev = process.env["NANO_PR_WEBHOOK_SECRET"];
+  process.env["NANO_PR_WEBHOOK_SECRET"] = "s3cr3t";
   try {
     // SECRET is bound at import time, so import a cache-busted copy to observe the guard.
     const mod = await import(`./getVersion.ts?guard=${Date.now()}`);
     const guarded = mod.default as typeof handler;
-    // 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);
   } 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/getVersion.ts

@@ -9,9 +9,8 @@
 import { defineOperation } from "@nanobpm/urban";
 import { buildVersionInfo, envVar, type VersionInfo } 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") ?? "";
 
 export default defineOperation<

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/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.36.0",
+  "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,14 +33,13 @@
     "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"
   },

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/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,39 +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`.
-// biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
-const g = globalThis as {
-  Deno?: {
-    args: string[];
-    exit(c: number): never;
-    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();
@@ -54,12 +33,11 @@ const countDi = (xml: string) => ({
 });
 
 function exit(code: number): never {
-  if (g.Deno) return g.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";

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

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/record-plan-review/worker.test.ts

@@ -5,7 +5,8 @@
 // plan was empty (e.g. the planner agent couldn't persist its result) — completed the whole epic
 // GREEN having done nothing (instance 21). We now HARD-FAIL: the terminal, unapproved round raises
 // a non-retryable `PLAN_REJECTED` BpmnError (→ incident), so an un-approved plan never dispatches.
-import { assertEquals, assertRejects } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals, assertRejects } from "#test-assert";
 import { BpmnError } from "@nanobpm/urban";
 import handler from "./worker.ts";
 import { MAX_PLAN_REVIEW_ROUNDS, type PlanReview } from "../../app/plan.ts";
@@ -18,9 +19,7 @@ function fakeApp(existing: PlanReview[] = []) {
     data: {
       table() {
         return {
-          // deno-lint-ignore no-explicit-any
           findOne: (q: any) => Promise.resolve(rows.find((r) => match(r, q)) ?? null),
-          // deno-lint-ignore no-explicit-any
           count: (q: any) => Promise.resolve(rows.filter((r) => match(r, q)).length),
           insert: (row: PlanReview) => {
             rows.push(row);
@@ -31,7 +30,6 @@ function fakeApp(existing: PlanReview[] = []) {
     },
     log: () => {},
     _rows: rows,
-    // deno-lint-ignore no-explicit-any
   } as any;
 }
 
@@ -48,16 +46,15 @@ function priorRounds(planKey: string, n: number): PlanReview[] {
 }
 
 const call = async (app: unknown, vars: Record<string, unknown>, jobKey = "j-new") =>
-  // deno-lint-ignore no-explicit-any
   await handler({ variables: vars, jobKey } as any, app as any);
 
-Deno.test("approved round proceeds (planApproved=true, no throw)", async () => {
+test("approved round proceeds (planApproved=true, no throw)", async () => {
   const app = fakeApp(priorRounds("o/r#1", 0));
   const out = await call(app, { planKey: "o/r#1", approved: true });
   assertEquals((out as { planApproved: boolean }).planApproved, true);
 });
 
-Deno.test("unapproved, non-final round revises (planApproved=false, no throw)", async () => {
+test("unapproved, non-final round revises (planApproved=false, no throw)", async () => {
   // First round of a 3-round cap: not final, so revise.
   const app = fakeApp(priorRounds("o/r#2", 0));
   const out = await call(app, { planKey: "o/r#2", approved: false, findings: "fix X" });
@@ -65,7 +62,7 @@ Deno.test("unapproved, non-final round revises (planApproved=false, no throw)",
   assertEquals((out as { planFindings: string }).planFindings, "fix X");
 });
 
-Deno.test("unapproved FINAL round hard-fails with PLAN_REJECTED incident", async () => {
+test("unapproved FINAL round hard-fails with PLAN_REJECTED incident", async () => {
   // Seed cap-1 prior rounds so this job is the last permitted round; unapproved ⇒ must throw.
   const app = fakeApp(priorRounds("o/r#3", MAX_PLAN_REVIEW_ROUNDS - 1));
   const err = await assertRejects(
@@ -75,7 +72,7 @@ Deno.test("unapproved FINAL round hard-fails with PLAN_REJECTED incident", async
   assertEquals((err as BpmnError).errorCode, "PLAN_REJECTED");
 });
 
-Deno.test("approved on the FINAL round still proceeds (no throw)", async () => {
+test("approved on the FINAL round still proceeds (no throw)", async () => {
   const app = fakeApp(priorRounds("o/r#4", MAX_PLAN_REVIEW_ROUNDS - 1));
   const out = await call(app, { planKey: "o/r#4", approved: true });
   assertEquals((out as { planApproved: boolean }).planApproved, true);