@nanobpm/nano-workforce 0.36.0 → 0.38.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,17 @@
+# [0.38.0](https://github.com/nanobpm/nano-workforce/compare/v0.37.0...v0.38.0) (2026-08-10)
+
+
+### Features
+
+* migrate hooks to OpenAPI operations, one HTTP surface (ADR 0059) ([#109](https://github.com/nanobpm/nano-workforce/issues/109)) ([493d78c](https://github.com/nanobpm/nano-workforce/commit/493d78c5b58ba18098c7d458bd9538660eb2d0f3))
+
+# [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.
@@ -214,7 +213,7 @@ the UI and the process re-arms and retries.
 ### Fleet mode: hand it an issue (plan → implement → converge)
 
 ```
- issue (UI / POST /hooks/plan) ─► plan-fanout (BPMN)
+ issue (UI / POST /app/api/actions/start/plan-fanout) ─► plan-fanout (BPMN)
     plan (senior:plan) ─► record-plan ─► implement × N (parallel, senior:feature) ─► record-results
                                                                                        │
                                           each opened PR ──► convergence-loop (above)
@@ -223,12 +222,11 @@ the UI and the process re-arms and retries.
 A planning agent decomposes the issue into tasks; a parallel multi-instance activity
 fans them out over implementation agents (one PR per task); `record-results` enrols
 every opened PR into the convergence loop. Submit from the **"Hand an issue to the
-fleet"** form, or:
+fleet"** form, or POST the same operation the form does:
 
 ```bash
-curl -sS -X POST http://localhost:3000/hooks/plan \
+curl -sS -X POST http://localhost:3000/app/api/actions/start/plan-fanout \
   -H 'content-type: application/json' \
-  -H "x-hook-secret: $NANO_PR_WEBHOOK_SECRET" \
   -d '{ "issue": "owner/repo#123" }'
 ```
 
@@ -244,8 +242,8 @@ curl -sS -X POST http://localhost:3000/hooks/plan \
 | `GITHUB_TOKEN` | — | token for the review poller / merge (or use the host `gh` CLI) |
 | `NANO_PR_GITHUB_TRANSPORT` | `auto` | how the poller reads GitHub: `gh` (host CLI), `token` (`GITHUB_TOKEN` over HTTP), or `auto` |
 | `NANO_PR_POLL_MS` | `60000` | review-ready poll interval |
-| `NANO_PR_MAX_ROUNDS` | `20` | default cap: escalate after N rounds (per-submit override via the form / webhook `maxRounds`; clamped 1–100) |
-| `NANO_PR_WEBHOOK_SECRET` | — | shared secret for `POST /hooks/submit` (`X-Hook-Secret`) |
+| `NANO_PR_MAX_ROUNDS` | `20` | default cap: escalate after N rounds (per-submit override via the form / the `maxRounds` field on `start/convergence-loop`; clamped 1–100) |
+| `NANO_PR_WEBHOOK_SECRET` | — | optional shared secret for the `POST /app/api/hooks/feature-answer` webhook operation (`X-Hook-Secret`); unset = open |
 | `NANO_PR_AUTO_MERGE` | `1` | after convergence, run the merge stage; `0` = stop at `converged` (review-only) |
 | `NANO_PR_MERGE_METHOD` | `squash` | merge method: `squash`, `merge`, or `rebase` |
 | `NANO_PR_MERGE_ADMIN` | `0` | pass `--admin` to override failing non-required checks (use with care) |
@@ -277,25 +275,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/SPEC.md

@@ -56,7 +56,7 @@ surface are proposed and open for adjustment.
 ```
 nano-workforce/
   nano.app.json               # manifest (ADR 0027): sqlite data, domain types, submit webhook trigger
-  main.ts                     # Deno entrypoint: deploy + start workers + Deno.serve (page runtime + action overrides + poller)
+  main.ts                     # Node entrypoint: deploy + start workers + start the runtime (page runtime + OpenAPI operations + poller)
   deno.json
   pages/
     home.page.json            # the screen, authored declaratively (ADR 0042 Page Composer)
@@ -263,20 +263,22 @@ row by migration `003`).
 
 The app-specific business-logic endpoints are **OpenAPI operations** mounted
 under `api.base` (`/app/api`), each implemented by a delegate module in
-`operations/`, plus a `/hooks/*` webhook. The runtime serves them all; `main.ts`
-only starts the runtime and the review-ready poller. The full, authoritative
-contract is `openapi.json` (Swagger UI at `/app/api-docs`); the OpenAPI rows
-below are the complete set of operations, `/hooks/submit` is one of the `/hooks/*`
-webhooks:
+`operations/`. The webhook endpoints are ordinary operations too (ADR 0059 — the
+`actions[]` array is retired), mounted under `/app/api/hooks/*`. The runtime
+serves them all; `main.ts` only starts the runtime and the review-ready poller.
+The full, authoritative contract is `openapi.yaml` (Swagger UI at
+`/app/api-docs`); the OpenAPI rows below are the complete set of operations:
 
 | method | route | purpose |
 |---|---|---|
 | `GET` | `/app/api/status` | list tracked PRs + count |
 | `GET` | `/app/api/version` | app + engine version |
-| `POST` | `/app/api/actions/start/convergence-loop` | parse the PR ref → create the aggregate + start the process |
-| `POST` | `/app/api/actions/start/plan-fanout` | start a plan fan-out run |
+| `POST` | `/app/api/actions/start/convergence-loop` | parse the PR ref → create the aggregate + start the process (the ONE submit door — page + external callers) |
+| `POST` | `/app/api/actions/start/plan-fanout` | parse the issue ref → start a plan fan-out run (the ONE plan door) |
 | `POST` | `/app/api/actions/message` (`escalation-answered`) | answer an open escalation → publish `escalation-answered` |
-| `POST` | `/hooks/submit` | webhook submit (shared-secret auth) → start the process |
+| `POST` | `/app/api/hooks/feature-answer` | answer an implementation-phase task escalation out of band (optional shared-secret) |
+| `GET`/`POST` | `/app/api/hooks/blackboard` | per-plan coordination blackboard (capability-token side-channel) |
+| `GET` | `/app/api/hooks/abandon` | cooperative abandon check (per-PR capability token) |
 
 Everything else (`GET /`, `GET /app/pages/*`, `GET /app/data/*`, the renderer) is
 served by the runtime — including `POST /app/actions/cancel`, which is Urban's
@@ -393,7 +395,7 @@ queries skip (`merging`), so a slow pass can't double-signal.
 | `GITHUB_TOKEN` | — | GitHub API (poller + agent) |
 | `NANO_PR_POLL_MS` | 60000 | poll interval |
 | `NANO_PR_MAX_ROUNDS` | 20 | default round cap (per-submit `maxRounds` override, clamped 1–100) |
-| `NANO_PR_WEBHOOK_SECRET` | — | HMAC for `/hooks/submit` |
+| `NANO_PR_WEBHOOK_SECRET` | — | optional shared secret for the `/app/api/hooks/feature-answer` webhook operation (`X-Hook-Secret`) |
 | `NANO_PR_AUTO_MERGE` | 1 | run the merge stage after convergence (`0` = review-only) |
 | `NANO_PR_MERGE_METHOD` | squash | `squash` \| `merge` \| `rebase` |
 | `NANO_PR_MERGE_ADMIN` | 0 | pass `--admin` on merge |
@@ -443,9 +445,9 @@ scalar-only and cannot express the `tasks`/`results` lists, so the workers self-
 **Domain model** (`db/migrations/004_planning.sql`): `plans` (one row per issue) +
 `plan_tasks` (one row per slice, tracking its `status`/`pr_key`/`summary`).
 
-**Entry points**: the page's "Hand an issue to the fleet" form
-(`startProcess plan-fanout` → `actions/plan-start.ts`), or `POST /hooks/plan`
-(`{ issue | url }`, optional `X-Hook-Secret`).
+**Entry points**: the epic page's "Hand an issue to the fleet" form or
+`POST /app/api/actions/start/plan-fanout` (`{ issue | url }`) — the same flat
+operation the form posts.
 
 **Visibility**: the home page adds a **Plans** grid (Active: planning/dispatched;
 History: done/failed/abandoned) with a `plan_tasks` child grid showing each task's

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,31 +50,31 @@ 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",
+    "https://host/app/api/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);
-  assertEquals(abandonTokenFromUrl("https://host/hooks/abandon"), undefined, "no token param");
+  assertEquals(abandonTokenFromUrl("https://host/app/api/hooks/abandon"), undefined, "no token param");
   assertEquals(abandonTokenFromUrl("not a url"), undefined, "unparseable input never throws");
 });
 
-Deno.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);
+test("renderAbandonBrief embeds the concrete URL and the stop contract", () => {
+  const brief = renderAbandonBrief("https://host/app/api/hooks/abandon?token=tok");
+  assertEquals(brief.includes("https://host/app/api/hooks/abandon?token=tok"), true);
   assertEquals(brief.includes("abandoned"), true);
   assertEquals(brief.includes("Abort"), true);
   // Must use `curl -f` so a 404 (torn-down run) fails the command instead of exiting 0 with an
@@ -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/abandon.ts

@@ -42,13 +42,13 @@ export function mintAbandonToken(): string {
 /** The capability URL for a PR's abandon check: the token rides the query string so the agent can
  * GET the exact string it was handed with no header assembly. */
 export function abandonUrl(token: string, base: string = publicBaseUrl()): string {
-  return `${base}/hooks/abandon?token=${encodeURIComponent(token)}`;
+  return `${base}/app/api/hooks/abandon?token=${encodeURIComponent(token)}`;
 }
 
 /** Recover the capability token from an abandon URL — the inverse of `abandonUrl`. Returns
  * undefined when the input is absent or carries no `token` query param. A desync-heal uses this to
  * reconstruct a missing `pull_requests` row with the SAME token the running agent was already
- * handed (via the `abandonUrl` process variable), so its `curl -f "…/hooks/abandon?token=…"` abort
+ * handed (via the `abandonUrl` process variable), so its `curl -f "…/app/api/hooks/abandon?token=…"` abort
  * check keeps resolving instead of 404-ing on a freshly-minted token and aborting a live run. */
 export function abandonTokenFromUrl(url: string | null | undefined): string | undefined {
   if (!url) return undefined;

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

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,32 +53,32 @@ 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 {
     assertEquals(publicBaseUrl(""), "http://localhost:3000");
     assertEquals(publicBaseUrl("   "), "http://localhost:3000");
-    assertEquals(blackboardUrl("t", publicBaseUrl("")), "http://localhost:3000/hooks/blackboard?token=t");
+    assertEquals(blackboardUrl("t", publicBaseUrl("")), "http://localhost:3000/app/api/hooks/blackboard?token=t");
   } finally {
     if (prev === undefined) delete process.env.NANO_PR_BASE_URL;
     else process.env.NANO_PR_BASE_URL = prev;
   }
 });
 
-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",
+    "https://h/app/api/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,8 +86,8 @@ 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", () => {
-  const url = "https://h/hooks/blackboard?token=abc";
+test("renderCoordinationBrief: leads with a separator and teaches the protocol + URL", () => {
+  const url = "https://h/app/api/hooks/blackboard?token=abc";
   const brief = renderCoordinationBrief(url);
   assert(brief.startsWith("\n\n---"), "must own a leading separator (appendPrompt adds none)");
   assertStringIncludes(brief, url);
@@ -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" })));