@nanobpm/nano-workforce 0.36.0 → 0.38.0

package/app/persist-escalation.test.ts

@@ -6,7 +6,8 @@
 // passes `recordRound=false`, which must suppress the round insert while still opening the
 // escalation. The agent-raised / max-rounds arms omit the flag (no prior round row) and must
 // still record the round.
-import { assert, assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
 import handler from "../workers/persist-escalation/worker.ts";
 
 function fakeApp() {
@@ -18,19 +19,15 @@ function fakeApp() {
       table(name: string, _key: string) {
         const store = (rows[name] ??= new Map());
         return {
-          // deno-lint-ignore require-await
           async get(key: string) {
             return store.get(key);
           },
-          // deno-lint-ignore require-await
           async insert(row: unknown) {
             (inserts[name] ??= []).push(row);
             const pk = name === "escalations" ? "id" : name === "rounds" ? "id" : "pr_key";
-            // deno-lint-ignore no-explicit-any
             store.set((row as any)[pk], row);
             return name === "escalations" ? 42 : 1;
           },
-          // deno-lint-ignore require-await
           async update(key: string, patch: unknown) {
             (updates[name] ??= []).push({ key, patch });
           },
@@ -41,33 +38,29 @@ function fakeApp() {
   return { app, inserts, updates, rows };
 }
 
-Deno.test("stalled arm (recordRound=false) does not insert a duplicate rounds row", async () => {
+test("stalled arm (recordRound=false) does not insert a duplicate rounds row", async () => {
   const { app, inserts } = fakeApp();
   const job = {
     variables: { prKey: "o/r#1", round: 3, status: "blocked", question: "stalled", recordRound: false },
   };
-  // deno-lint-ignore no-explicit-any
   const out = await handler(job as any, app as any);
   assertEquals(inserts.rounds.length, 0, "no round row when the round was already recorded");
   assertEquals(inserts.escalations.length, 1, "escalation is still opened");
-  // deno-lint-ignore no-explicit-any
   assertEquals((out as any).escalationId, 42);
 });
 
-Deno.test("escalation arm without the flag still records the round", async () => {
+test("escalation arm without the flag still records the round", async () => {
   const { app, inserts } = fakeApp();
   const job = { variables: { prKey: "o/r#1", round: 3, status: "blocked", question: "max rounds" } };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
   assertEquals(inserts.rounds.length, 1);
-  // deno-lint-ignore no-explicit-any
   assertEquals((inserts.rounds[0] as any).round_no, 3);
 });
 
 // When the convergence-loop passes repo/prNumber and the FK parent is missing (engine/app.db
 // desync), persist-escalation reconstructs the `pull_requests` row before the rounds/escalations
 // inserts so opening an escalation never dies with an opaque FOREIGN KEY constraint failure.
-Deno.test("persist-escalation heals a missing pull_requests parent before recording", async () => {
+test("persist-escalation heals a missing pull_requests parent before recording", async () => {
   const { app, inserts, updates } = fakeApp();
   const job = {
     variables: {
@@ -79,32 +72,26 @@ Deno.test("persist-escalation heals a missing pull_requests parent before record
       prNumber: 8,
     },
   };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
   assertEquals(inserts.pull_requests?.length, 1, "the missing parent is reconstructed");
   // Assert against the reconstruction insert payload (ensurePr) rather than the stored row: the
   // fake update() doesn't apply patches, so the row would otherwise still read the insert's
   // "converging" status and mask the worker's real final state.
-  // deno-lint-ignore no-explicit-any
   const healed = inserts.pull_requests![0] as any;
   assertEquals(healed.status, "converging", "the healed parent starts in the converging aggregate");
   assertEquals(inserts.rounds.length, 1, "the round is still recorded");
   assertEquals(inserts.escalations.length, 1, "the escalation is still opened");
   // And the worker still moves the (now-present) PR to escalated as its final state.
   assertEquals(updates.pull_requests!.length, 1, "the PR is updated once after the heal");
-  // deno-lint-ignore no-explicit-any
   assertEquals((updates.pull_requests![0] as any).patch.status, "escalated");
 });
 
 
-Deno.test("a padded question is persisted trimmed (no whitespace drift)", async () => {
+test("a padded question is persisted trimmed (no whitespace drift)", async () => {
   const { app, inserts, updates } = fakeApp();
   const job = { variables: { prKey: "o/r#1", round: 4, status: "needs_input", question: "  needs a decision  " } };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
-  // deno-lint-ignore no-explicit-any
   assertEquals((inserts.escalations[0] as any).question, "needs a decision", "escalation stores the trimmed question");
-  // deno-lint-ignore no-explicit-any
   assertEquals((updates.pull_requests![0] as any).patch.open_escalation_question, "needs a decision", "denormalised question is trimmed too");
 });
 
@@ -113,7 +100,7 @@ Deno.test("a padded question is persisted trimmed (no whitespace drift)", async
 // on Magikcraft/nano-bpm #597/#599) must NOT throw (which parked an un-remediable JobNoRetries
 // incident). It now opens an *answerable* escalation with a fabricated, concrete question and the
 // agent's transcript attached, so a human can unblock the loop entirely from the UI.
-Deno.test("blank question fabricates an answerable escalation (no throw, no incident)", async () => {
+test("blank question fabricates an answerable escalation (no throw, no incident)", async () => {
   for (const question of [undefined, "", "   "]) {
     const { app, inserts, updates } = fakeApp();
     const job = {
@@ -124,12 +111,9 @@ Deno.test("blank question fabricates an answerable escalation (no throw, no inci
         "io.nanobpm.agentResult": { output: "the agent's prose review, no result file" },
       },
     };
-    // deno-lint-ignore no-explicit-any
     const out = await handler(job as any, app as any);
-    // deno-lint-ignore no-explicit-any
     assertEquals((out as any).escalationId, 42, "an escalation is opened, not refused");
     assertEquals(inserts.escalations.length, 1, "escalation row written");
-    // deno-lint-ignore no-explicit-any
     const esc = inserts.escalations[0] as any;
     assert(esc.question.trim().length > 0, "fabricated question is concrete/non-blank");
     assert(
@@ -139,7 +123,6 @@ Deno.test("blank question fabricates an answerable escalation (no throw, no inci
     assertEquals(esc.transcript, "the agent's prose review, no result file", "transcript attached");
     // Default status for an unclassified escalation is a question needing input.
     assertEquals(esc.kind, "question");
-    // deno-lint-ignore no-explicit-any
     const pr = updates.pull_requests![0] as any;
     assertEquals(pr.patch.open_escalation_question, esc.question, "denormalised question set");
   }
@@ -147,12 +130,10 @@ Deno.test("blank question fabricates an answerable escalation (no throw, no inci
 
 // When a non-empty-but-unclassified status arrives with no question, the fabricated question
 // names the status so the human sees what the agent reported.
-Deno.test("unclassified status without a question names the status in the fabricated question", async () => {
+test("unclassified status without a question names the status in the fabricated question", async () => {
   const { app, inserts } = fakeApp();
   const job = { variables: { prKey: "o/r#1", round: 3, status: "in_progress" } };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
-  // deno-lint-ignore no-explicit-any
   const esc = inserts.escalations[0] as any;
   assert(esc.question.includes("in_progress"), "fabricated question references the raw status");
   assertEquals(esc.kind, "blocker", "a non needs_input status is a blocker escalation");
@@ -160,7 +141,7 @@ Deno.test("unclassified status without a question names the status in the fabric
 
 // When repo/prNumber process variables are absent the heal still runs by parsing the canonical
 // `owner/repo#N` prKey, so the escalation's FK parent is never left unguarded.
-Deno.test("persist-escalation heals from the prKey when repo/prNumber are absent", async () => {
+test("persist-escalation heals from the prKey when repo/prNumber are absent", async () => {
   const { app, inserts } = fakeApp();
   const job = {
     variables: {
@@ -168,13 +149,11 @@ Deno.test("persist-escalation heals from the prKey when repo/prNumber are absent
       round: 2,
       status: "needs_input",
       question: "decide",
-      abandonUrl: "https://host/hooks/abandon?token=TOK-en_123",
+      abandonUrl: "https://host/app/api/hooks/abandon?token=TOK-en_123",
     },
   };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
   assertEquals(inserts.pull_requests?.length, 1, "the parent is reconstructed from the prKey");
-  // deno-lint-ignore no-explicit-any
   const healed = inserts.pull_requests![0] as any;
   assertEquals(healed.repo, "o/r");
   assertEquals(healed.number, 12);

package/app/persist-round.test.ts

@@ -6,7 +6,8 @@
 // PR in `waiting_review` so the deterministic poller (app/service.ts) starts soliciting a review.
 // A `waiting` round is what replaced the old failure mode where an agent with nothing to do
 // re-requested the review destructively and escalated `blocked`.
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import handler from "../workers/persist-round/worker.ts";
 
 function fakeApp() {
@@ -18,19 +19,15 @@ function fakeApp() {
       table(name: string, _key: string) {
         const store = (rows[name] ??= new Map());
         return {
-          // deno-lint-ignore require-await
           async get(key: string) {
             return store.get(key);
           },
-          // deno-lint-ignore require-await
           async insert(row: unknown) {
             (inserts[name] ??= []).push(row);
             const pk = name === "rounds" ? "id" : "pr_key";
-            // deno-lint-ignore no-explicit-any
             store.set((row as any)[pk], row);
             return 1;
           },
-          // deno-lint-ignore require-await
           async update(key: string, patch: unknown) {
             (updates[name] ??= []).push({ key, patch });
           },
@@ -42,20 +39,17 @@ function fakeApp() {
 }
 
 for (const status of ["addressed", "waiting"]) {
-  Deno.test(`persist-round records a '${status}' round and parks the PR in waiting_review`, async () => {
+  test(`persist-round records a '${status}' round and parks the PR in waiting_review`, async () => {
     const { app, inserts, updates } = fakeApp();
     const job = { variables: { prKey: "o/r#1", round: 1, status, summary: `round was ${status}` } };
-    // deno-lint-ignore no-explicit-any
     await handler(job as any, app as any);
 
     assertEquals(inserts.rounds.length, 1, "the round is recorded");
-    // deno-lint-ignore no-explicit-any
     const round = inserts.rounds[0] as any;
     assertEquals(round.status, status, "the round carries the agent's status");
     assertEquals(round.round_no, 1);
 
     assertEquals(updates.pull_requests!.length, 1, "the PR is updated once");
-    // deno-lint-ignore no-explicit-any
     const patch = (updates.pull_requests![0] as any).patch;
     assertEquals(patch.status, "waiting_review", "the PR parks in waiting_review for the poller");
     assertEquals(patch.current_round, 1);
@@ -65,7 +59,7 @@ for (const status of ["addressed", "waiting"]) {
 // When the convergence-loop passes repo/prNumber and the FK parent is missing (engine/app.db
 // desync), persist-round reconstructs the `pull_requests` row before recording the round so the
 // insert never dies with an opaque FOREIGN KEY constraint failure.
-Deno.test("persist-round heals a missing pull_requests parent before recording the round", async () => {
+test("persist-round heals a missing pull_requests parent before recording the round", async () => {
   const { app, inserts, updates } = fakeApp();
   const job = {
     variables: {
@@ -76,51 +70,44 @@ Deno.test("persist-round heals a missing pull_requests parent before recording t
       prNumber: 7,
     },
   };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
 
   assertEquals(inserts.pull_requests?.length, 1, "the missing parent is reconstructed");
   // Assert against the reconstruction insert payload (ensurePr) rather than the stored row: the
   // fake update() doesn't apply patches, so the row would otherwise still read the insert's
   // "converging" status and mask the worker's real final state.
-  // deno-lint-ignore no-explicit-any
   const healed = inserts.pull_requests![0] as any;
   assertEquals(healed.status, "converging", "the healed parent starts in the converging aggregate");
   assertEquals(healed.url, "https://github.com/o/r/pull/7", "URL is derived canonically");
   assertEquals(inserts.rounds.length, 1, "the round is still recorded after the heal");
   // And the worker still parks the (now-present) PR in waiting_review as its final state.
   assertEquals(updates.pull_requests!.length, 1, "the PR is updated once after the heal");
-  // deno-lint-ignore no-explicit-any
   assertEquals((updates.pull_requests![0] as any).patch.status, "waiting_review");
 });
 
 // rather than writing a NULL status — the round history stays readable.
-Deno.test("persist-round defaults a missing status to 'addressed'", async () => {
+test("persist-round defaults a missing status to 'addressed'", async () => {
   const { app, inserts } = fakeApp();
   const job = { variables: { prKey: "o/r#1", round: 2 } };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
-  // deno-lint-ignore no-explicit-any
   assertEquals((inserts.rounds[0] as any).status, "addressed");
 });
 
 // When repo/prNumber process variables are absent (an older in-flight instance, or a regression)
 // the heal still runs by parsing the canonical `owner/repo#N` prKey, so the FK-child insert is
 // never left unguarded.
-Deno.test("persist-round heals from the prKey when repo/prNumber are absent", async () => {
+test("persist-round heals from the prKey when repo/prNumber are absent", async () => {
   const { app, inserts } = fakeApp();
   const job = {
     variables: {
       prKey: "o/r#12",
       round: 2,
       status: "addressed",
-      abandonUrl: "https://host/hooks/abandon?token=TOK-en_123",
+      abandonUrl: "https://host/app/api/hooks/abandon?token=TOK-en_123",
     },
   };
-  // deno-lint-ignore no-explicit-any
   await handler(job as any, app as any);
   assertEquals(inserts.pull_requests?.length, 1, "the parent is reconstructed from the prKey");
-  // deno-lint-ignore no-explicit-any
   const healed = inserts.pull_requests![0] as any;
   assertEquals(healed.repo, "o/r");
   assertEquals(healed.number, 12);

package/app/plan.test.ts

@@ -4,47 +4,48 @@
 // `NaN`/`0` (e.g. unset, "", "abc"), the cap check `round + 1 >= cap` would never fire and the
 // planner could revise forever. `positiveIntEnv` must fall back to the default on any value that
 // is not a positive integer, so the loop is always bounded.
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import { positiveIntEnv } from "./plan.ts";
 
 const KEY = "NANO_PLAN_REVIEW_ROUNDS_TEST";
 
 function withEnv(value: string | undefined, run: () => void) {
-  const had = Object.prototype.hasOwnProperty.call(Deno.env.toObject(), KEY);
-  const prev = Deno.env.get(KEY);
+  const had = Object.prototype.hasOwnProperty.call(process.env, KEY);
+  const prev = process.env[KEY];
   try {
-    if (value === undefined) Deno.env.delete(KEY);
-    else Deno.env.set(KEY, value);
+    if (value === undefined) delete process.env[KEY];
+    else process.env[KEY] = value;
     run();
   } finally {
-    if (had && prev !== undefined) Deno.env.set(KEY, prev);
-    else Deno.env.delete(KEY);
+    if (had && prev !== undefined) process.env[KEY] = prev;
+    else delete process.env[KEY];
   }
 }
 
-Deno.test("unset → fallback (bounded loop, never NaN)", () => {
+test("unset → fallback (bounded loop, never NaN)", () => {
   withEnv(undefined, () => assertEquals(positiveIntEnv(KEY, 3), 3));
 });
 
-Deno.test("blank/whitespace → fallback, not 0", () => {
+test("blank/whitespace → fallback, not 0", () => {
   withEnv("", () => assertEquals(positiveIntEnv(KEY, 3), 3));
   withEnv("   ", () => assertEquals(positiveIntEnv(KEY, 3), 3));
 });
 
-Deno.test("non-numeric → fallback, not NaN", () => {
+test("non-numeric → fallback, not NaN", () => {
   withEnv("abc", () => assertEquals(positiveIntEnv(KEY, 3), 3));
 });
 
-Deno.test("zero and negatives → fallback (cap must be >= 1)", () => {
+test("zero and negatives → fallback (cap must be >= 1)", () => {
   withEnv("0", () => assertEquals(positiveIntEnv(KEY, 3), 3));
   withEnv("-2", () => assertEquals(positiveIntEnv(KEY, 3), 3));
 });
 
-Deno.test("non-integer → fallback", () => {
+test("non-integer → fallback", () => {
   withEnv("2.5", () => assertEquals(positiveIntEnv(KEY, 3), 3));
 });
 
-Deno.test("valid positive integer → honoured", () => {
+test("valid positive integer → honoured", () => {
   withEnv("5", () => assertEquals(positiveIntEnv(KEY, 3), 5));
   withEnv("1", () => assertEquals(positiveIntEnv(KEY, 3), 1));
 });
@@ -58,28 +59,22 @@ Deno.test("valid positive integer → honoured", () => {
 // asserts the `plan_reviews` rows for the plan key are gone after a re-plan.
 import { startPlan } from "./plan.ts";
 
-// deno-lint-ignore no-explicit-any
 function memTable(rows: any[], key: string) {
   return {
-    // deno-lint-ignore no-explicit-any
     get: (k: any) => Promise.resolve(rows.find((r) => r[key] === k) ?? null),
-    // deno-lint-ignore no-explicit-any
     find: (q: any) =>
       Promise.resolve(
         rows.filter((r) => Object.entries(q).every(([f, v]) => r[f] === v)),
       ),
-    // deno-lint-ignore no-explicit-any
     insert: (r: any) => {
       rows.push(r);
       return Promise.resolve(r);
     },
-    // deno-lint-ignore no-explicit-any
     update: (k: any, patch: any) => {
       const r = rows.find((x) => x[key] === k);
       if (r) Object.assign(r, patch);
       return Promise.resolve(r);
     },
-    // deno-lint-ignore no-explicit-any
     delete: (k: any) => {
       for (let i = rows.length - 1; i >= 0; i--) {
         if (rows[i][key] === k) rows.splice(i, 1);
@@ -89,7 +84,7 @@ function memTable(rows: any[], key: string) {
   };
 }
 
-Deno.test("re-plan of a finished issue clears stale plan_reviews rows", async () => {
+test("re-plan of a finished issue clears stale plan_reviews rows", async () => {
   const PLAN_KEY = "owner/repo#7";
   const stores: Record<string, { rows: unknown[]; key: string }> = {
     plans: {
@@ -112,11 +107,9 @@ Deno.test("re-plan of a finished issue clears stale plan_reviews rows", async ()
   const data = {
     table: (name: string, key: string) =>
       memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
-    // deno-lint-ignore no-explicit-any
   } as any;
   const engine = {
     createInstance: () => Promise.resolve({ processInstanceKey: "PI-1" }),
-    // deno-lint-ignore no-explicit-any
   } as any;
 
   await startPlan(data, engine, {
@@ -139,7 +132,7 @@ Deno.test("re-plan of a finished issue clears stale plan_reviews rows", async ()
 // `refreshOpenTaskEscalation` re-surfaces a dead question in the answer form — the same
 // stale-row class as `plan_reviews` above. This drives `startPlan` against the in-memory data
 // layer and asserts both the escalation rows and the denormalised pointer are cleared.
-Deno.test("re-plan of a finished issue clears stale open escalations and the denormalised open_task_* pointer", async () => {
+test("re-plan of a finished issue clears stale open escalations and the denormalised open_task_* pointer", async () => {
   const PLAN_KEY = "owner/repo#8";
   const stores: Record<string, { rows: unknown[]; key: string }> = {
     plans: {
@@ -172,11 +165,9 @@ Deno.test("re-plan of a finished issue clears stale open escalations and the den
   const data = {
     table: (name: string, key: string) =>
       memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
-    // deno-lint-ignore no-explicit-any
   } as any;
   const engine = {
     createInstance: () => Promise.resolve({ processInstanceKey: "PI-1" }),
-    // deno-lint-ignore no-explicit-any
   } as any;
 
   await startPlan(data, engine, {
@@ -214,16 +205,14 @@ function escalationStores(rows: unknown[]): Record<string, { rows: unknown[]; ke
   };
 }
 
-// deno-lint-ignore no-explicit-any
 function memData(stores: Record<string, { rows: any[]; key: string }>) {
   return {
     table: (name: string, key: string) =>
       memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key),
-    // deno-lint-ignore no-explicit-any
   } as any;
 }
 
-Deno.test("refreshOpenTaskEscalation surfaces the OLDEST open escalation, then clears when none remain", async () => {
+test("refreshOpenTaskEscalation surfaces the OLDEST open escalation, then clears when none remain", async () => {
   const stores = escalationStores([
     { id: 2, plan_key: "owner/repo#9", task_id: "b", corr_key: "owner/repo#9:b", question: "Q-b", status: "open" },
     { id: 1, plan_key: "owner/repo#9", task_id: "a", corr_key: "owner/repo#9:a", question: "Q-a", status: "open" },
@@ -231,7 +220,6 @@ Deno.test("refreshOpenTaskEscalation surfaces the OLDEST open escalation, then c
   const data = memData(stores);
 
   await refreshOpenTaskEscalation(data, "owner/repo#9");
-  // deno-lint-ignore no-explicit-any
   let plan = stores.plans.rows[0] as any;
   assertEquals(plan.open_task_escalation_id, 1);
   assertEquals(plan.open_task_question, "Q-a");
@@ -239,19 +227,15 @@ Deno.test("refreshOpenTaskEscalation surfaces the OLDEST open escalation, then c
   assertEquals(plan.open_task_id, "a");
 
   // Once the oldest is answered, the next-oldest is surfaced.
-  // deno-lint-ignore no-explicit-any
   (stores.plan_escalations.rows.find((r: any) => r.id === 1) as any).status = "answered";
   await refreshOpenTaskEscalation(data, "owner/repo#9");
-  // deno-lint-ignore no-explicit-any
   plan = stores.plans.rows[0] as any;
   assertEquals(plan.open_task_escalation_id, 2);
   assertEquals(plan.open_task_id, "b");
 
   // With nothing open the denormalised fields clear.
-  // deno-lint-ignore no-explicit-any
   (stores.plan_escalations.rows.find((r: any) => r.id === 2) as any).status = "answered";
   await refreshOpenTaskEscalation(data, "owner/repo#9");
-  // deno-lint-ignore no-explicit-any
   plan = stores.plans.rows[0] as any;
   assertEquals(plan.open_task_escalation_id, null);
   assertEquals(plan.open_task_question, null);
@@ -259,7 +243,7 @@ Deno.test("refreshOpenTaskEscalation surfaces the OLDEST open escalation, then c
   assertEquals(plan.open_task_id, null);
 });
 
-Deno.test("answerTaskEscalation records the answer, mirrors it onto the task, publishes the resume message, and re-surfaces the next escalation", async () => {
+test("answerTaskEscalation records the answer, mirrors it onto the task, publishes the resume message, and re-surfaces the next escalation", async () => {
   const stores = escalationStores([
     { id: 1, plan_key: "owner/repo#9", task_id: "a", corr_key: "owner/repo#9:a", question: "Q-a", status: "open", answer: null },
     { id: 2, plan_key: "owner/repo#9", task_id: "b", corr_key: "owner/repo#9:b", question: "Q-b", status: "open", answer: null },
@@ -267,15 +251,12 @@ Deno.test("answerTaskEscalation records the answer, mirrors it onto the task, pu
   stores.plan_tasks.rows.push({ id: 10, plan_key: "owner/repo#9", task_id: "a", answer: null });
   const data = memData(stores);
 
-  // deno-lint-ignore no-explicit-any
   const published: any[] = [];
   const engine = {
-    // deno-lint-ignore no-explicit-any
     publishMessage: (m: any) => {
       published.push(m);
       return Promise.resolve();
     },
-    // deno-lint-ignore no-explicit-any
   } as any;
 
   const r = await answerTaskEscalation(data, engine, "owner/repo#9:a", "do it");
@@ -285,13 +266,11 @@ Deno.test("answerTaskEscalation records the answer, mirrors it onto the task, pu
   assertEquals(r.taskId, "a");
 
   // Escalation row marked answered with the recorded answer.
-  // deno-lint-ignore no-explicit-any
   const esc = stores.plan_escalations.rows.find((x: any) => x.id === 1) as any;
   assertEquals(esc.status, "answered");
   assertEquals(esc.answer, "do it");
 
   // Answer mirrored onto the task row.
-  // deno-lint-ignore no-explicit-any
   assertEquals((stores.plan_tasks.rows[0] as any).answer, "do it");
 
   // Correlated resume message published on the shared constant channel.
@@ -301,16 +280,14 @@ Deno.test("answerTaskEscalation records the answer, mirrors it onto the task, pu
   assertEquals(published[0].variables.answer, "do it");
 
   // Next-oldest open escalation re-surfaced on the plan row.
-  // deno-lint-ignore no-explicit-any
   assertEquals((stores.plans.rows[0] as any).open_task_escalation_id, 2);
 });
 
-Deno.test("answerTaskEscalation is a no-op when no open escalation matches the correlation key", async () => {
+test("answerTaskEscalation is a no-op when no open escalation matches the correlation key", async () => {
   const stores = escalationStores([]);
   const data = memData(stores);
   const engine = {
     publishMessage: () => Promise.reject(new Error("should not publish")),
-    // deno-lint-ignore no-explicit-any
   } as any;
   const r = await answerTaskEscalation(data, engine, "owner/repo#9:missing", "x");
   assertEquals(r.ok, false);

package/app/record-plan-review.test.ts

@@ -4,35 +4,36 @@
 // re-emitted as `planFindings`. `JSON.stringify` can THROW (BigInt, circular refs) or return
 // `undefined` (functions/symbols); either would fail the whole job and wedge the process in a
 // retry loop. `str()` must never throw and must always yield a string.
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import { str } from "../workers/record-plan-review/worker.ts";
 
-Deno.test("strings pass through unchanged", () => {
+test("strings pass through unchanged", () => {
   assertEquals(str("hello"), "hello");
   assertEquals(str(""), "");
 });
 
-Deno.test("null/undefined → empty string", () => {
+test("null/undefined → empty string", () => {
   assertEquals(str(null), "");
   assertEquals(str(undefined), "");
 });
 
-Deno.test("plain objects/arrays → JSON", () => {
+test("plain objects/arrays → JSON", () => {
   assertEquals(str({ a: 1 }), '{"a":1}');
   assertEquals(str([1, 2]), "[1,2]");
 });
 
-Deno.test("BigInt does not throw (JSON.stringify would) → String fallback", () => {
+test("BigInt does not throw (JSON.stringify would) → String fallback", () => {
   assertEquals(str(10n), "10");
 });
 
-Deno.test("circular structure does not throw → String fallback", () => {
+test("circular structure does not throw → String fallback", () => {
   const circular: Record<string, unknown> = {};
   circular.self = circular;
   const out = str(circular);
   assertEquals(typeof out, "string");
 });
 
-Deno.test("value JSON.stringify renders as undefined → String fallback", () => {
+test("value JSON.stringify renders as undefined → String fallback", () => {
   assertEquals(str(() => 1), String(() => 1));
 });