@nanobpm/nano-workforce 0.36.0 → 0.38.0

package/operations/answerFeatureEscalation.test.ts

@@ -0,0 +1,100 @@
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import type { AppApi } from "@nanobpm/urban";
+
+const hadSecret = Object.prototype.hasOwnProperty.call(process.env, "NANO_PR_WEBHOOK_SECRET");
+const previousSecret = process.env.NANO_PR_WEBHOOK_SECRET;
+let answerFeatureEscalation: typeof import("./answerFeatureEscalation.ts").default;
+try {
+  process.env.NANO_PR_WEBHOOK_SECRET = " test-secret ";
+  answerFeatureEscalation = (await import("./answerFeatureEscalation.ts")).default;
+} finally {
+  if (hadSecret && previousSecret !== undefined) process.env.NANO_PR_WEBHOOK_SECRET = previousSecret;
+  else delete process.env.NANO_PR_WEBHOOK_SECRET;
+}
+
+function memTable(rows: any[], key: string) {
+  return {
+    find: (where: Record<string, unknown>) =>
+      Promise.resolve(rows.filter((row) => Object.entries(where).every(([field, value]) => row[field] === value))),
+    update: (value: unknown, patch: Record<string, unknown>) => {
+      const row = rows.find((candidate) => candidate[key] === value);
+      if (row) Object.assign(row, patch);
+      return Promise.resolve(row);
+    },
+  };
+}
+
+function memApp(escalations: any[] = []) {
+  const stores: Record<string, { rows: any[]; key: string }> = {
+    plans: { rows: [{ plan_key: "owner/repo#9" }], key: "plan_key" },
+    plan_escalations: { rows: escalations, key: "id" },
+    plan_tasks: { rows: [{ id: 1, plan_key: "owner/repo#9", task_id: "task-1" }], key: "id" },
+  };
+  const published: Record<string, unknown>[] = [];
+  const app = {
+    data: {
+      table: (name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
+    },
+    engine: {
+      publishMessage: (message: Record<string, unknown>) => {
+        published.push(message);
+        return Promise.resolve();
+      },
+    },
+  } as any as AppApi;
+  return { app, published };
+}
+
+function input(body: Record<string, unknown>, secret?: string) {
+  const headers = new Headers();
+  if (secret !== undefined) headers.set("x-hook-secret", secret);
+  return {
+    req: {
+      method: "POST",
+      path: "/app/api/hooks/feature-answer",
+      query: new URLSearchParams(),
+      headers,
+      text: async () => "",
+    } as any,
+    params: {},
+    query: {},
+    body,
+  };
+}
+
+test("rejects a request without the configured hook secret", async () => {
+  const { app } = memApp();
+  const result = await answerFeatureEscalation(input({ corrKey: "owner/repo#9:task-1", answer: "yes" }), app) as any;
+  assertEquals(result.status, 401);
+  assertEquals(result.body, { ok: false, error: "unauthorized" });
+});
+
+test("derives corrKey from plan + task and maps an answered escalation to 200", async () => {
+  const { app, published } = memApp([{
+    id: 1,
+    plan_key: "owner/repo#9",
+    task_id: "task-1",
+    corr_key: "owner/repo#9:task-1",
+    question: "Proceed?",
+    status: "open",
+  }]);
+  const result = await answerFeatureEscalation(
+    input({ plan: "owner/repo#9", task: "task-1", answer: " yes " }, "test-secret"),
+    app,
+  ) as any;
+  assertEquals(result.status, 200);
+  assertEquals(result.body.ok, true);
+  assertEquals(published[0]?.correlationKey, "owner/repo#9:task-1");
+  assertEquals((published[0]?.variables as Record<string, unknown>).answer, "yes");
+});
+
+test("maps an unmatched corrKey to 404", async () => {
+  const { app } = memApp();
+  const result = await answerFeatureEscalation(
+    input({ corrKey: "owner/repo#9:missing", answer: "yes" }, "test-secret"),
+    app,
+  ) as any;
+  assertEquals(result.status, 404);
+  assertEquals(result.body.ok, false);
+});

package/operations/answerFeatureEscalation.ts

@@ -0,0 +1,49 @@
+// POST /app/api/hooks/feature-answer → operationId `answerFeatureEscalation` (ADR 0059 webhook
+// operation; was the `/hooks/feature-answer` action). Answers an implementation-phase task
+// escalation out of band (optional shared-secret guard via X-Hook-Secret, enforced only when
+// NANO_PR_WEBHOOK_SECRET is set — mirrors the operator control surface), issue #25. Lets an
+// external system (a chat relay, a CI job, a human via curl) resume a parked implementation agent
+// without the page. Same idempotent `answerTaskEscalation` path the page's answer form uses.
+//
+// The runtime validates the body shape against openapi.yaml; this delegate keeps the semantic
+// checks (an answer is required; a correlation key must be resolvable) and the shared-secret guard.
+// Body accepts either the raw correlation key or a plan+task pair:
+//   { "corrKey": "owner/repo#12:task-3", "answer": "…" }
+//   { "plan": "owner/repo#12", "task": "task-3", "answer": "…" }
+import { defineOperation } from "@nanobpm/urban";
+import { answerTaskEscalation, featureCorrKey } from "../app/plan.ts";
+import { envVar } from "../app/version.ts";
+
+const WEBHOOK_SECRET = envVar("NANO_PR_WEBHOOK_SECRET") ?? "";
+
+const str = (v: unknown): string => (typeof v === "string" ? v.trim() : "");
+
+interface Body {
+  corrKey?: unknown;
+  plan?: unknown;
+  task?: unknown;
+  answer?: unknown;
+}
+
+export default defineOperation<
+  { params: Record<string, string>; query: Record<string, string | string[] | undefined>; body: Body },
+  { ok: boolean } & Record<string, unknown>
+>("answerFeatureEscalation", async ({ req, body }, app) => {
+  if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
+    return { status: 401, body: { ok: false, error: "unauthorized" } };
+  }
+  const b = body ?? {};
+  const answer = str(b.answer);
+  if (!answer) return { status: 400, body: { ok: false, error: "answer is required" } };
+
+  const corrKey = str(b.corrKey) || (str(b.plan) && str(b.task) ? featureCorrKey(str(b.plan), str(b.task)) : "");
+  if (!corrKey) {
+    return {
+      status: 400,
+      body: { ok: false, error: "provide corrKey, or both plan (owner/repo#N) and task" },
+    };
+  }
+
+  const r = await answerTaskEscalation(app.data, app.engine, corrKey, answer);
+  return { status: r.ok ? 200 : 404, body: r };
+});

package/operations/appendBlackboard.ts

@@ -0,0 +1,61 @@
+// POST /app/api/hooks/blackboard?token=<capabilityToken> → operationId `appendBlackboard` (ADR 0059
+// webhook operation; was the POST half of the `/hooks/blackboard` action; Tier 1, issues #51 / #49 D4).
+//
+// The per-plan capability token (query string) IS the credential (see readBlackboard). An unknown
+// token is a 404 (never leaks which plans exist).
+//
+//   POST → append one entry: { author_task?, kind?, files?, body, wave?, dedupe_key? }. Idempotent
+//          on (plan, dedupe_key). Returns { id, inserted, conflicts } — `conflicts` lists prior
+//          sibling `file-claim`s on the same file(s) (advisory first-writer-wins; never a lock).
+import { defineOperation } from "@nanobpm/urban";
+import type { ClaimConflict } from "../app/blackboard.ts";
+import {
+  appendEntry,
+  detectFileClaimConflicts,
+  normalizeKind,
+  planKeyForToken,
+} from "../app/blackboard.ts";
+
+export default defineOperation<
+  { params: Record<string, string>; query: { token?: string }; body: Record<string, unknown> },
+  { id: number; inserted: boolean; conflicts: ClaimConflict[] } | { error: string }
+>("appendBlackboard", async ({ req, body }, app) => {
+  const token = (req.query.get("token") ?? req.headers.get("x-blackboard-token") ?? "").trim();
+  if (!token) return { status: 400, body: { error: "missing blackboard token" } };
+  const planKey = await planKeyForToken(app.data, token);
+  if (!planKey) return { status: 404, body: { error: "unknown blackboard token" } };
+
+  const b = body ?? {};
+  const text = typeof b.body === "string" ? b.body.trim() : "";
+  if (!text) return { status: 400, body: { error: "'body' (the note text) is required" } };
+  const kind = normalizeKind(b.kind);
+  const files = Array.isArray(b.files) ? b.files.map(String) : [];
+  // Normalize once (trim + default to "system") so the value we send to appendEntry matches the
+  // value we send to detectFileClaimConflicts. Otherwise an omitted/blank author_task is stored as
+  // "system" but conflict detection sees "", and the caller's own prior "system" claims are wrongly
+  // reported as sibling conflicts.
+  const author_task = (typeof b.author_task === "string" ? b.author_task.trim() : "") || "system";
+  const res = await appendEntry(app.data, planKey, {
+    author_task,
+    kind,
+    files,
+    body: text,
+    wave: typeof b.wave === "number" ? b.wave : null,
+    dedupe_key: typeof b.dedupe_key === "string" ? b.dedupe_key : undefined,
+  });
+  // Advisory conflict-of-intent: surface prior sibling claims on the same file(s). Computed AFTER
+  // the append and filtered to claims strictly before ours (id < res.id), so first-writer-wins is
+  // decided by insertion order — a sibling that raced a claim in between is still caught, and our
+  // own just-written row is never reported. Never blocks the append — the agent decides how to react.
+  const conflicts = kind === "file-claim"
+    ? await detectFileClaimConflicts(app.data, planKey, {
+      author_task,
+      files,
+      beforeId: Number(res.id),
+    })
+    : [];
+  return {
+    status: res.inserted ? 201 : 200,
+    body: { id: Number(res.id), inserted: res.inserted, conflicts },
+  };
+});

package/{actions → operations}/blackboard.test.ts

@@ -1,18 +1,17 @@
-// Tests for the /hooks/blackboard endpoint (Tier 1, issues #51 / #49 D4).
-import { assertEquals } from "jsr:@std/assert@1";
+// Tests for the /app/api/hooks/blackboard operations `readBlackboard` (GET) + `appendBlackboard`
+// (POST) (ADR 0059; Tier 1, issues #51 / #49 D4).
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
-import handler from "./blackboard.ts";
+import readBlackboard from "./readBlackboard.ts";
+import appendBlackboard from "./appendBlackboard.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 +21,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 };
 }
@@ -40,7 +36,7 @@ function memApp(): { app: AppApi; stores: Record<string, any[]> } {
 function req(method: string, query: Record<string, string>) {
   return {
     method,
-    path: "/hooks/blackboard",
+    path: "/app/api/hooks/blackboard",
     query: new URLSearchParams(query),
     headers: new Headers(),
     text: async () => "",
@@ -53,9 +49,17 @@ 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
+  // Method routing is the runtime's job; here we dispatch to the delegate the spec mounts per verb.
+  // Be explicit so an unexpected method fails loudly rather than silently running the POST delegate.
+  const handler =
+    method === "GET"
+      ? readBlackboard
+      : method === "POST"
+        ? appendBlackboard
+        : (() => {
+            throw new Error(`blackboard test helper: unsupported method ${method}`);
+          })();
+  const res = await handler({ req: req(method, query) as any, params: {}, query: {}, body } as any, app);
   return res as any;
 }
 
@@ -63,18 +67,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 +98,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 +115,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 +126,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 +139,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 +162,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,15 +185,9 @@ 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 () => {
-  const { app } = memApp();
-  await seedPlan(app, "o/r#1", "tok");
-  assertEquals((await call(app, "DELETE", { token: "tok" })).status, 405);
-});

package/{actions/abandon.test.ts → operations/checkAbandon.test.ts}

@@ -1,28 +1,23 @@
-// Tests for the GET /hooks/abandon endpoint (issue #76).
-import { assertEquals } from "jsr:@std/assert@1";
+// Tests for the GET /app/api/hooks/abandon operation `checkAbandon` (ADR 0059; issue #76).
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import type { AppApi } from "@nanobpm/urban";
-import handler from "./abandon.ts";
+import handler from "./checkAbandon.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 };
 }
@@ -30,7 +25,7 @@ function memApp(): { app: AppApi } {
 function req(method: string, query: Record<string, string>) {
   return {
     method,
-    path: "/hooks/abandon",
+    path: "/app/api/hooks/abandon",
     query: new URLSearchParams(query),
     headers: new Headers(),
     text: async () => "",
@@ -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
+  const res = await handler({ req: req(method, query) as any, params: {}, query: {}, body: undefined }, app);
   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,19 +68,12 @@ 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;
+  const res = await handler({ req: r as any, params: {}, query: {}, body: undefined }, app) as any;
   assertEquals(res.status, 200);
   assertEquals(res.body.abandoned, true);
 });
-
-Deno.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/abandon.ts → operations/checkAbandon.ts}

@@ -1,4 +1,5 @@
-// GET /hooks/abandon?token=<capabilityToken> — the cooperative abandon check (issue #76).
+// GET /app/api/hooks/abandon?token=<capabilityToken> → operationId `checkAbandon` (ADR 0059
+// webhook operation; was the `/hooks/abandon` action, issue #76).
 //
 // A DIRECT side-channel for a running `senior:*` agent to learn whether its run was cancelled
 // before it performs an irreversible side effect (push / open PR / request review / merge). The
@@ -8,16 +9,16 @@
 //
 //   GET → { prKey, status, abandoned }  — `abandoned` is derived from `pull_requests.status`,
 //          which Urban's cancel primitive sets to 'abandoned' on cancel. `true` ⇒ the agent must stop.
-import type { ActionHandler } from "@nanobpm/urban";
+import { defineOperation } from "@nanobpm/urban";
 import { abandonStatusForToken } from "../app/abandon.ts";
 
-const handler: ActionHandler = async ({ req }, app) => {
-  if (req.method !== "GET") return { status: 405, body: { error: "method not allowed (use GET)" } };
+export default defineOperation<
+  { params: Record<string, string>; query: { token?: string }; body: unknown },
+  { prKey: string; status: string; abandoned: boolean } | { error: string }
+>("checkAbandon", async ({ req }, app) => {
   const token = (req.query.get("token") ?? req.headers.get("x-abandon-token") ?? "").trim();
   if (!token) return { status: 400, body: { error: "missing abandon token" } };
   const state = await abandonStatusForToken(app.data, token);
   if (!state) return { status: 404, body: { error: "unknown abandon token" } };
   return { status: 200, body: state };
-};
-
-export default handler;
+});

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