@nanobpm/nano-workforce 0.36.0 → 0.37.0

package/.github/workflows/ci.yml

@@ -11,7 +11,7 @@ permissions:
 
 jobs:
   typecheck:
-    name: typecheck (Node + Deno)
+    name: typecheck + test (Node)
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -41,23 +41,13 @@ jobs:
       - name: Check BPMN diagram freshness (layout)
         run: npm run layout:check
 
-      - name: Setup Deno
-        uses: denoland/setup-deno@v2
-        with:
-          deno-version: v2.x
-
-      - name: Typecheck (Deno)
-        run: deno check main.ts 'workers/**/*.ts' 'actions/**/*.ts' 'operations/**/*.ts'
-
       # Deploy-safety gate: every model-authored `{{template}}` agent-prompt header must resolve
       # to a declared, non-blank prompt (and no agent prompt may ship blank). A broken/blank token
       # means a prompt-less agent — the root of the empty escalations on nano-bpm #597/#599.
       - name: Check agent prompt templates
-        run: deno run -A scripts/check-agent-prompts.ts
-
-      # Runs the app/*.test.ts suite (never exercised by the check globs above)
-      # AND guards the committed lockfile: --frozen fails the build if deno.lock
-      # is out of date for the full graph (incl. tests), so lockfile drift — e.g.
-      # a regenerate that drops the jsr:@std/* test deps — can't be merged.
-      - name: Test + frozen lockfile guard (Deno)
-        run: deno test -A --frozen
+        run: npm run check:prompts
+
+      # Runs the full *.test.ts suite under Node's built-in test runner (node:test), which strips
+      # TypeScript types on the fly (Node >= 22.6) — no build step.
+      - name: Test (Node)
+        run: npm test

package/AGENTS.md

@@ -51,7 +51,7 @@ path, a second review loop) — extend the canonical one.
 
 ### Zero tolerance for warnings, errors, and test failures
 There are no pre-existing failures or warnings, and you will not allow any to
-enter the codebase. `tsc`, `urban check`, `deno check`, and `deno test` must all
+enter the codebase. `tsc`, `urban check`, `biome check`, and `node --test` must all
 be clean.
 
 ### No task without a tracked issue or PR
@@ -138,20 +138,21 @@ Migrations live in `db/migrations/*.sql` and are **auto-applied on boot** from
 
 ## Runtime & CI gates
 
-Node-hosted (`node --experimental-strip-types`), but the sources are
-**cross-runtime**: workers/actions/`main.ts` also typecheck and run under Deno.
+Node-hosted (`node --experimental-strip-types`); Node is the only runtime. Tests run
+on Node's built-in runner (`node:test`), which strips TypeScript types on the fly.
 Match CI locally before pushing:
 
 ```bash
+npm run lint                                          # biome check (incl. ban-`as` gate)
 npm run typecheck                                     # tsc --noEmit (Node)
 npm run check                                         # urban check (manifest validation)
 npm run layout:check                                  # BPMN diagram freshness (no drift)
-deno check main.ts 'workers/**/*.ts' 'actions/**/*.ts'  # Deno typecheck
-deno test -A                                          # unit tests (run with -A)
+npm run check:prompts                                 # agent-prompt template resolution
+npm test                                              # unit tests (node --test)
 ```
 
-CI (`.github/workflows/ci.yml`) gates typecheck, `urban check`, `layout:check`,
-Deno typecheck, and the Deno test suite. Run `npm run layout <file.bpmn>` after
+CI (`.github/workflows/ci.yml`) gates lint, typecheck, `urban check`, `layout:check`,
+the prompt check, and the Node test suite. Run `npm run layout <file.bpmn>` after
 any BPMN flow change and commit the regenerated diagram — the `layout:check`
 gate fails the build otherwise.
 

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.37.0](https://github.com/nanobpm/nano-workforce/compare/v0.36.0...v0.37.0) (2026-08-10)
+
+
+### Features
+
+* remove Deno — Node is the only runtime ([#108](https://github.com/nanobpm/nano-workforce/issues/108)) ([d077e9c](https://github.com/nanobpm/nano-workforce/commit/d077e9c94696e2030a2033ad53a05c86a4c18a3e)), closes [#test-assert](https://github.com/nanobpm/nano-workforce/issues/test-assert)
+
 # [0.36.0](https://github.com/nanobpm/nano-workforce/compare/v0.35.2...v0.36.0) (2026-08-10)
 
 

package/README.md

@@ -84,8 +84,7 @@ it's the same app and the same behaviour.
 - A running **Nano gateway/engine** (default `http://localhost:8080`) — what the app
   deploys to and what agents pull jobs from.
 - **[Node](https://nodejs.org/) >= 22.6** (the app hosts on Node built-ins;
-  `@nanobpm/urban` declares `engines.node >=22.6`). **[Deno](https://deno.land/)** is
-  optional (only for `npm run compile`).
+  `@nanobpm/urban` declares `engines.node >=22.6`).
 - The **c8ctl CLI with the `nano` plugin** (to hire/run agents).
 - On each agent host: the **GitHub CLI** logged in (`gh auth login`) or a
   `GITHUB_TOKEN`/`GH_TOKEN` in the environment, plus the agent harness itself (e.g.
@@ -277,25 +276,6 @@ per-instance context (e.g. a human's escalation answer) is appended by the harne
 
 ---
 
-## Compile to a native binary
-
-The app is authored on Node built-ins, so **Deno** can cross-compile it into a native
-executable that bundles the runtime, deps, and entry code (the target box needs no
-Node/Deno/`node_modules`):
-
-```sh
-npm run compile   # → dist/nano-workforce  (via deno compile)
-```
-
-> **Not yet a single self-contained file.** The binary bundles the runtime + deps +
-> entry code, but the Urban runtime loads the app's declarative files
-> (`nano.app.json`, `pages/`, `db/migrations/`, `prompts/`, `resources/`, and the
-> `actions/`/`workers/` modules) from the **working directory at runtime** — so ship
-> the binary alongside those app files and run it from that directory. Add `--target`
-> in the `deno.json` `compile` task to cross-compile for another OS/arch.
-
----
-
 ## Architecture & contributing
 
 - **[SPEC.md](SPEC.md)** — the behavioural source of truth for the processes.

package/actions/abandon.test.ts

@@ -1,28 +1,23 @@
 // Tests for the GET /hooks/abandon endpoint (issue #76).
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import handler from "./abandon.ts";
 
-// deno-lint-ignore no-explicit-any
 function memApp(): { app: AppApi } {
-  // deno-lint-ignore no-explicit-any
   const stores: Record<string, any[]> = {};
   function tbl(name: string) {
-    // 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) {
         rows.push({ ...row });
         return row.pr_key;
       },
-      // 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 app = { data: { table: (n: string) => tbl(n) } } as any as AppApi;
   return { app };
 }
@@ -38,9 +33,7 @@ function req(method: string, query: Record<string, string>) {
 }
 
 async function call(app: AppApi, method: string, query: Record<string, string>) {
-  // deno-lint-ignore no-explicit-any
   const res = await handler({ req: req(method, query) as any, body: undefined }, app);
-  // deno-lint-ignore no-explicit-any
   return res as any;
 }
 
@@ -48,18 +41,18 @@ async function seedPr(app: AppApi, prKey: string, token: string, status: string)
   await app.data.table("pull_requests", "pr_key").insert({ pr_key: prKey, abandon_token: token, status });
 }
 
-Deno.test("missing token → 400", async () => {
+test("missing token → 400", async () => {
   const { app } = memApp();
   assertEquals((await call(app, "GET", {})).status, 400);
 });
 
-Deno.test("unknown token → 404 (does not reveal PRs)", async () => {
+test("unknown token → 404 (does not reveal PRs)", async () => {
   const { app } = memApp();
   await seedPr(app, "o/r#1", "good", "converging");
   assertEquals((await call(app, "GET", { token: "bad" })).status, 404);
 });
 
-Deno.test("a running PR → { abandoned: false }", async () => {
+test("a running PR → { abandoned: false }", async () => {
   const { app } = memApp();
   await seedPr(app, "o/r#1", "tok", "converging");
   const res = await call(app, "GET", { token: "tok" });
@@ -67,7 +60,7 @@ Deno.test("a running PR → { abandoned: false }", async () => {
   assertEquals(res.body, { prKey: "o/r#1", status: "converging", abandoned: false });
 });
 
-Deno.test("a cancelled PR → { abandoned: true }", async () => {
+test("a cancelled PR → { abandoned: true }", async () => {
   const { app } = memApp();
   await seedPr(app, "o/r#1", "tok", "abandoned");
   const res = await call(app, "GET", { token: "tok" });
@@ -75,18 +68,17 @@ Deno.test("a cancelled PR → { abandoned: true }", async () => {
   assertEquals(res.body.abandoned, true);
 });
 
-Deno.test("token via header is accepted", async () => {
+test("token via header is accepted", async () => {
   const { app } = memApp();
   await seedPr(app, "o/r#1", "tok", "abandoned");
   const r = req("GET", {});
   r.headers.set("x-abandon-token", "tok");
-  // deno-lint-ignore no-explicit-any
   const res = await handler({ req: r as any, body: undefined }, app) as any;
   assertEquals(res.status, 200);
   assertEquals(res.body.abandoned, true);
 });
 
-Deno.test("non-GET → 405", async () => {
+test("non-GET → 405", async () => {
   const { app } = memApp();
   await seedPr(app, "o/r#1", "tok", "converging");
   assertEquals((await call(app, "POST", { token: "tok" })).status, 405);

package/actions/blackboard.test.ts

@@ -1,18 +1,15 @@
 // Tests for the /hooks/blackboard endpoint (Tier 1, issues #51 / #49 D4).
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
 import handler from "./blackboard.ts";
 
-// deno-lint-ignore no-explicit-any
 function memApp(): { app: AppApi; 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);
@@ -22,17 +19,14 @@ function memApp(): { app: AppApi; 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 app = { data: { table: (n: string, pk?: string) => tbl(n, pk) } } as any as AppApi;
   return { app, stores };
 }
@@ -53,9 +47,7 @@ async function call(
   query: Record<string, string>,
   body?: unknown,
 ) {
-  // deno-lint-ignore no-explicit-any
   const res = await handler({ req: req(method, query) as any, body }, app);
-  // deno-lint-ignore no-explicit-any
   return res as any;
 }
 
@@ -63,18 +55,18 @@ async function seedPlan(app: AppApi, planKey: string, token: string) {
   await app.data.table("plans", "plan_key").insert({ plan_key: planKey, blackboard_token: token });
 }
 
-Deno.test("missing token → 400", async () => {
+test("missing token → 400", async () => {
   const { app } = memApp();
   assertEquals((await call(app, "GET", {})).status, 400);
 });
 
-Deno.test("unknown token → 404 (does not reveal plans)", async () => {
+test("unknown token → 404 (does not reveal plans)", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "good");
   assertEquals((await call(app, "GET", { token: "bad" })).status, 404);
 });
 
-Deno.test("POST appends then GET reads back, scoped by the token's plan", async () => {
+test("POST appends then GET reads back, scoped by the token's plan", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   const post = await call(app, "POST", { token: "tok" }, {
@@ -94,13 +86,13 @@ Deno.test("POST appends then GET reads back, scoped by the token's plan", async
   assertEquals(get.body.entries[0].kind, "file-claim");
 });
 
-Deno.test("POST with a blank body → 400", async () => {
+test("POST with a blank body → 400", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   assertEquals((await call(app, "POST", { token: "tok" }, { body: "  " })).status, 400);
 });
 
-Deno.test("POST is idempotent on dedupe_key (retry → 200, not a duplicate)", async () => {
+test("POST is idempotent on dedupe_key (retry → 200, not a duplicate)", async () => {
   const { app, stores } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   const body = { author_task: "t", body: "claim", dedupe_key: "t:claim:1" };
@@ -111,7 +103,7 @@ Deno.test("POST is idempotent on dedupe_key (retry → 200, not a duplicate)", a
   assertEquals(stores["plan_blackboard"].length, 1);
 });
 
-Deno.test("GET ?since returns only newer entries", async () => {
+test("GET ?since returns only newer entries", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   await call(app, "POST", { token: "tok" }, { body: "one" });
@@ -122,7 +114,7 @@ Deno.test("GET ?since returns only newer entries", async () => {
   assertEquals(tail.body.entries.map((e: { body: string }) => e.body), ["two"]);
 });
 
-Deno.test("GET returns a cursor at the plan head for incremental polling (Tier 2)", async () => {
+test("GET returns a cursor at the plan head for incremental polling (Tier 2)", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   await call(app, "POST", { token: "tok" }, { body: "one" });
@@ -135,7 +127,7 @@ Deno.test("GET returns a cursor at the plan head for incremental polling (Tier 2
   assertEquals(caughtUp.body.cursor, all.body.cursor);
 });
 
-Deno.test("POST file-claim surfaces a sibling's prior claim as a conflict (advisory)", async () => {
+test("POST file-claim surfaces a sibling's prior claim as a conflict (advisory)", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   const first = await call(app, "POST", { token: "tok" }, {
@@ -158,7 +150,7 @@ Deno.test("POST file-claim surfaces a sibling's prior claim as a conflict (advis
   assertEquals(second.body.conflicts[0].file, "engine/state.rs");
 });
 
-Deno.test("POST file-claim without author_task does not report the caller's own prior 'system' claim as a conflict", async () => {
+test("POST file-claim without author_task does not report the caller's own prior 'system' claim as a conflict", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   // First claim omits author_task → stored as "system".
@@ -181,14 +173,14 @@ Deno.test("POST file-claim without author_task does not report the caller's own
   assertEquals(second.body.conflicts, [], "own prior 'system' claim is not a conflict");
 });
 
-Deno.test("POST a non-file-claim carries no conflicts", async () => {
+test("POST a non-file-claim carries no conflicts", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   const res = await call(app, "POST", { token: "tok" }, { author_task: "t", kind: "note", body: "fyi" });
   assertEquals(res.body.conflicts, []);
 });
 
-Deno.test("unsupported method → 405", async () => {
+test("unsupported method → 405", async () => {
   const { app } = memApp();
   await seedPlan(app, "o/r#1", "tok");
   assertEquals((await call(app, "DELETE", { token: "tok" })).status, 405);

package/app/abandon.test.ts

@@ -1,5 +1,6 @@
 // Tests for the cooperative abandon-check helpers (issue #76).
-import { assertEquals, assertNotEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals, assertNotEquals } from "#test-assert";
 import type { DataLayer } from "@nanobpm/urban";
 import {
   abandonStatusForToken,
@@ -11,26 +12,20 @@ import {
   renderAbandonBrief,
 } from "./abandon.ts";
 
-// deno-lint-ignore no-explicit-any
 function memData(): DataLayer {
-  // deno-lint-ignore no-explicit-any
   const stores: Record<string, any[]> = {};
   function tbl(name: string) {
-    // 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) {
         rows.push({ ...row });
         return row.pr_key;
       },
-      // 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
   return { table: (n: string) => tbl(n) } as any as DataLayer;
 }
 
@@ -38,7 +33,7 @@ async function seedPr(data: DataLayer, pr_key: string, abandon_token: string, st
   await data.table("pull_requests", "pr_key").insert({ pr_key, abandon_token, status });
 }
 
-Deno.test("isAbandoned is true only for the 'abandoned' status", () => {
+test("isAbandoned is true only for the 'abandoned' status", () => {
   assertEquals(isAbandoned("abandoned"), true);
   assertEquals(isAbandoned("converging"), false);
   assertEquals(isAbandoned("converged"), false);
@@ -47,7 +42,7 @@ Deno.test("isAbandoned is true only for the 'abandoned' status", () => {
   assertEquals(isAbandoned(undefined), false);
 });
 
-Deno.test("mintAbandonToken is url-safe, unpadded, and unique", () => {
+test("mintAbandonToken is url-safe, unpadded, and unique", () => {
   const a = mintAbandonToken();
   const b = mintAbandonToken();
   assertNotEquals(a, b);
@@ -55,21 +50,21 @@ Deno.test("mintAbandonToken is url-safe, unpadded, and unique", () => {
   assertEquals(a.includes("="), false);
 });
 
-Deno.test("abandonUrl carries the token on the query string (url-encoded)", () => {
+test("abandonUrl carries the token on the query string (url-encoded)", () => {
   assertEquals(
     abandonUrl("tok+/=", "https://host"),
     "https://host/hooks/abandon?token=tok%2B%2F%3D",
   );
 });
 
-Deno.test("abandonTokenFromUrl round-trips the token minted into an abandonUrl", () => {
+test("abandonTokenFromUrl round-trips the token minted into an abandonUrl", () => {
   const tok = mintAbandonToken();
   assertEquals(abandonTokenFromUrl(abandonUrl(tok, "https://host")), tok);
   // url-special tokens survive the encode/decode round-trip too.
   assertEquals(abandonTokenFromUrl(abandonUrl("tok+/=", "https://host")), "tok+/=");
 });
 
-Deno.test("abandonTokenFromUrl returns undefined for absent/tokenless/garbage input", () => {
+test("abandonTokenFromUrl returns undefined for absent/tokenless/garbage input", () => {
   assertEquals(abandonTokenFromUrl(undefined), undefined);
   assertEquals(abandonTokenFromUrl(null), undefined);
   assertEquals(abandonTokenFromUrl(""), undefined);
@@ -77,7 +72,7 @@ Deno.test("abandonTokenFromUrl returns undefined for absent/tokenless/garbage in
   assertEquals(abandonTokenFromUrl("not a url"), undefined, "unparseable input never throws");
 });
 
-Deno.test("renderAbandonBrief embeds the concrete URL and the stop contract", () => {
+test("renderAbandonBrief embeds the concrete URL and the stop contract", () => {
   const brief = renderAbandonBrief("https://host/hooks/abandon?token=tok");
   assertEquals(brief.includes("https://host/hooks/abandon?token=tok"), true);
   assertEquals(brief.includes("abandoned"), true);
@@ -87,7 +82,7 @@ Deno.test("renderAbandonBrief embeds the concrete URL and the stop contract", ()
   assertEquals(brief.includes("curl -fsS"), true);
 });
 
-Deno.test("prKeyForAbandonToken resolves a known token and rejects unknowns", async () => {
+test("prKeyForAbandonToken resolves a known token and rejects unknowns", async () => {
   const data = memData();
   await seedPr(data, "o/r#1", "tok", "converging");
   assertEquals(await prKeyForAbandonToken(data, "tok"), "o/r#1");
@@ -95,7 +90,7 @@ Deno.test("prKeyForAbandonToken resolves a known token and rejects unknowns", as
   assertEquals(await prKeyForAbandonToken(data, ""), undefined);
 });
 
-Deno.test("abandonStatusForToken derives abandoned from the row status", async () => {
+test("abandonStatusForToken derives abandoned from the row status", async () => {
   const data = memData();
   await seedPr(data, "o/r#1", "live", "converging");
   await seedPr(data, "o/r#2", "dead", "abandoned");

package/app/baseGuard.test.ts

@@ -1,5 +1,6 @@
 // Unit tests for the dead-end-base guard decision (#60).
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import { type BaseTarget, isDeadEndBase } from "./baseGuard.ts";
 
 const t = (base: string, defaultBranch: string, landed: BaseTarget["landed"]): BaseTarget => ({
@@ -8,28 +9,28 @@ const t = (base: string, defaultBranch: string, landed: BaseTarget["landed"]): B
   landed,
 });
 
-Deno.test("dead-end: a non-default base that has already landed", () => {
+test("dead-end: a non-default base that has already landed", () => {
   // The exact #54 case: base 'feat/coordination-blackboard' merged to 'main' but wasn't deleted.
   assertEquals(isDeadEndBase(t("feat/coordination-blackboard", "main", "landed")), true);
 });
 
-Deno.test("NOT a dead-end: the base IS the default branch (the common straight-to-main PR)", () => {
+test("NOT a dead-end: the base IS the default branch (the common straight-to-main PR)", () => {
   // Even if a same-named 'main' somehow reported landed, a PR targeting the default branch is the
   // normal terminal target — never a dead-end.
   assertEquals(isDeadEndBase(t("main", "main", "landed")), false);
 });
 
-Deno.test("NOT a dead-end: a live stacked base whose PR is still open", () => {
+test("NOT a dead-end: a live stacked base whose PR is still open", () => {
   assertEquals(isDeadEndBase(t("feat/tier2", "main", "open")), false);
 });
 
-Deno.test("NOT a dead-end on ambiguity: base has no PR / transport couldn't tell (unknown)", () => {
+test("NOT a dead-end on ambiguity: base has no PR / transport couldn't tell (unknown)", () => {
   // We block only on a positive `landed` signal, so a legitimately-stacked feature branch that
   // simply has no PR yet is never wrongly held.
   assertEquals(isDeadEndBase(t("feat/tier2", "main", "unknown")), false);
 });
 
-Deno.test("unknown-safe: blank base or blank default is never a dead-end", () => {
+test("unknown-safe: blank base or blank default is never a dead-end", () => {
   assertEquals(isDeadEndBase(t("", "main", "landed")), false);
   assertEquals(isDeadEndBase(t("feat/x", "", "landed")), false);
 });