@nanobpm/nano-workforce 0.36.0 → 0.37.0

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

package/app/retro.test.ts

@@ -1,5 +1,6 @@
 // Unit tests for the epic retrospective stage (app/retro.ts, 016_plan_retro.sql).
-import { assert, assertEquals, assertStringIncludes } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertEquals, assertStringIncludes } from "#test-assert";
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
 import { appendEntry } from "./blackboard.ts";
 import { recordTaskDelta } from "./taskDelta.ts";
@@ -15,18 +16,13 @@ import {
 } from "./retro.ts";
 
 // In-memory record gateway matching the Table<T> subset retro.ts uses: insert/find/findOne/get/update.
-// 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[]);
-    // deno-lint-ignore no-explicit-any
     const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
     return {
-      // deno-lint-ignore no-explicit-any require-await
       async insert(row: any) {
         if (pk !== "id" && rows.some((r) => r[pk] === row[pk])) {
           throw new Error(`UNIQUE constraint failed: ${name}.${pk}`);
@@ -35,26 +31,21 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
         rows.push(pk === "id" ? { id, ...row } : { ...row });
         return pk === "id" ? id : row[pk];
       },
-      // deno-lint-ignore no-explicit-any require-await
       async find(where: any = {}) {
         return rows.filter((r) => match(r, where));
       },
-      // deno-lint-ignore no-explicit-any require-await
       async findOne(where: any = {}) {
         return rows.find((r) => match(r, where));
       },
-      // deno-lint-ignore no-explicit-any require-await
       async get(id: any) {
         return rows.find((row) => row[pk] === id);
       },
-      // deno-lint-ignore no-explicit-any require-await
       async update(id: any, patch: any) {
         const r = rows.find((row) => row[pk] === id);
         if (r) Object.assign(r, patch);
       },
     };
   }
-  // deno-lint-ignore no-explicit-any
   const data = { table: (n: string, pk?: string) => tbl(n, pk) } as any as DataLayer;
   return { data, stores };
 }
@@ -62,21 +53,17 @@ function memData(): { data: DataLayer; stores: Record<string, any[]> } {
 // A fake engine recording createInstance calls.
 function fakeEngine(): { engine: EngineClient; started: { processDefinitionId: string; variables: Record<string, unknown> }[] } {
   const started: { processDefinitionId: string; variables: Record<string, unknown> }[] = [];
-  // deno-lint-ignore no-explicit-any
   const engine = {
-    // deno-lint-ignore no-explicit-any require-await
     async createInstance(req: any) {
       started.push({ processDefinitionId: req.processDefinitionId, variables: req.variables });
       return { processInstanceKey: `PI-${started.length}` };
     },
-    // deno-lint-ignore no-explicit-any require-await
   } as any as EngineClient;
   return { engine, started };
 }
 
 const PLAN = "acme/widgets#7";
 
-// deno-lint-ignore no-explicit-any
 function seedPlan(stores: Record<string, any[]>, over: Record<string, unknown> = {}) {
   stores["plans"] = [{
     plan_key: PLAN,
@@ -89,20 +76,17 @@ function seedPlan(stores: Record<string, any[]>, over: Record<string, unknown> =
   }];
 }
 
-// deno-lint-ignore no-explicit-any
 function seedTask(stores: Record<string, any[]>, task: Record<string, unknown>) {
   (stores["plan_tasks"] ??= []).push({ plan_key: PLAN, ...task });
 }
-// deno-lint-ignore no-explicit-any
 function seedPr(stores: Record<string, any[]>, pr_key: string, status: string) {
   (stores["pull_requests"] ??= []).push({ pr_key, status });
 }
-// deno-lint-ignore no-explicit-any
 function seedReview(stores: Record<string, any[]>, round: number, approved: number, findings: string | null) {
   (stores["plan_reviews"] ??= []).push({ plan_key: PLAN, round, approved, findings, created_at: `t${round}`, job_key: null });
 }
 
-Deno.test("autoRetroEnabled: on by default; disabled by 0/false/off/no", () => {
+test("autoRetroEnabled: on by default; disabled by 0/false/off/no", () => {
   const prev = process.env.NANO_AUTO_RETRO;
   try {
     delete process.env.NANO_AUTO_RETRO;
@@ -119,7 +103,7 @@ Deno.test("autoRetroEnabled: on by default; disabled by 0/false/off/no", () => {
   }
 });
 
-Deno.test("planKeyForPr: resolves the plan a PR's task belongs to; undefined when unlinked", async () => {
+test("planKeyForPr: resolves the plan a PR's task belongs to; undefined when unlinked", async () => {
   const { data, stores } = memData();
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
   assertEquals(await planKeyForPr(data, "acme/widgets#10"), PLAN);
@@ -127,7 +111,7 @@ Deno.test("planKeyForPr: resolves the plan a PR's task belongs to; undefined whe
   assertEquals(await planKeyForPr(data, ""), undefined);
 });
 
-Deno.test("isPlanComplete: false while any task is still in flight", async () => {
+test("isPlanComplete: false while any task is still in flight", async () => {
   const { data, stores } = memData();
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
   seedTask(stores, { id: "t2", status: "pending", pr_key: null });
@@ -136,14 +120,14 @@ Deno.test("isPlanComplete: false while any task is still in flight", async () =>
   assertEquals(await isPlanComplete(data, PLAN), false);
 });
 
-Deno.test("isPlanComplete: false when an opened task's PR is not yet terminal", async () => {
+test("isPlanComplete: false when an opened task's PR is not yet terminal", async () => {
   const { data, stores } = memData();
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
   seedPr(stores, "acme/widgets#10", "waiting_deps"); // in the merge stage, not terminal
   assertEquals(await isPlanComplete(data, PLAN), false);
 });
 
-Deno.test("isPlanComplete: true when every task is settled (terminal PR or skipped/blocked)", async () => {
+test("isPlanComplete: true when every task is settled (terminal PR or skipped/blocked)", async () => {
   const { data, stores } = memData();
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
   seedTask(stores, { id: "t2", status: "skipped", pr_key: null });
@@ -153,12 +137,12 @@ Deno.test("isPlanComplete: true when every task is settled (terminal PR or skipp
   assertEquals(await isPlanComplete(data, PLAN), true);
 });
 
-Deno.test("isPlanComplete: an empty plan has nothing to retrospect", async () => {
+test("isPlanComplete: an empty plan has nothing to retrospect", async () => {
   const { data } = memData();
   assertEquals(await isPlanComplete(data, PLAN), false);
 });
 
-Deno.test("gatherRetro: separates learnings from notes and folds in deltas", async () => {
+test("gatherRetro: separates learnings from notes and folds in deltas", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   await appendEntry(data, PLAN, { author_task: "t1", kind: "learning", body: "regen the API surface before building" });
@@ -181,7 +165,7 @@ Deno.test("gatherRetro: separates learnings from notes and folds in deltas", asy
   assertEquals(d.repo, "acme/widgets");
 });
 
-Deno.test("gatherRetro: folds in the plan-review trace and task-outcome shape", async () => {
+test("gatherRetro: folds in the plan-review trace and task-outcome shape", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", task_id: "t1", status: "opened", pr_key: "acme/widgets#10" });
@@ -201,7 +185,7 @@ Deno.test("gatherRetro: folds in the plan-review trace and task-outcome shape",
   assertEquals(d.taskOutcomes.byStatus, { opened: 2, skipped: 1 });
 });
 
-Deno.test("gatherRetro: no reviews → zero rounds, not approved, empty rejections", async () => {
+test("gatherRetro: no reviews → zero rounds, not approved, empty rejections", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   const d = await gatherRetro(data, PLAN);
@@ -211,7 +195,7 @@ Deno.test("gatherRetro: no reviews → zero rounds, not approved, empty rejectio
   assertEquals(d.taskOutcomes, { total: 0, byStatus: {} });
 });
 
-Deno.test("renderRetroBrief: renders learnings + constraints; states 'none' with no learnings", () => {
+test("renderRetroBrief: renders learnings + constraints; states 'none' with no learnings", () => {
   const empty = renderRetroBrief({
     planKey: PLAN, repo: "acme/widgets", issueUrl: "", title: null,
     learnings: [], touchedFiles: [], contractChanges: [], constraints: [], notes: [],
@@ -243,7 +227,7 @@ Deno.test("renderRetroBrief: renders learnings + constraints; states 'none' with
   assertStringIncludes(brief, "Task outcomes");
 });
 
-Deno.test("isDigestEmpty: empty only with no learnings/deltas/notes AND no review rejections", () => {
+test("isDigestEmpty: empty only with no learnings/deltas/notes AND no review rejections", () => {
   const base = { planKey: PLAN, repo: "", issueUrl: "", title: null, learnings: [], touchedFiles: [], contractChanges: [], constraints: [], notes: [], reviewRounds: 0, reviewRejections: [], planApproved: false, taskOutcomes: { total: 0, byStatus: {} } };
   assert(isDigestEmpty({ ...base, counts: { learnings: 0, deltas: 0, notes: 0 } }));
   assert(!isDigestEmpty({ ...base, counts: { learnings: 1, deltas: 0, notes: 0 } }));
@@ -255,7 +239,7 @@ Deno.test("isDigestEmpty: empty only with no learnings/deltas/notes AND no revie
   assert(isDigestEmpty({ ...base, reviewRounds: 1, planApproved: true, taskOutcomes: { total: 3, byStatus: { opened: 3 } }, counts: { learnings: 0, deltas: 0, notes: 0 } }));
 });
 
-Deno.test("recordRetro: inserts then updates the same plan_key row in place", async () => {
+test("recordRetro: inserts then updates the same plan_key row in place", async () => {
   const { data, stores } = memData();
   await recordRetro(data, PLAN, { status: "filed", prKey: "acme/widgets#20", learnings: 3, summary: "promoted 2" });
   assertEquals(stores["plan_retros"].length, 1);
@@ -268,25 +252,21 @@ Deno.test("recordRetro: inserts then updates the same plan_key row in place", as
   assertEquals(stores["plan_retros"][0].pr_key, null);
 });
 
-Deno.test("recordRetro: rethrows a non-unique (FOREIGN KEY) constraint error instead of swallowing it", async () => {
+test("recordRetro: rethrows a non-unique (FOREIGN KEY) constraint error instead of swallowing it", async () => {
   // A FK failure (e.g. plan_key missing in plans) must NOT be treated as a benign duplicate and
   // fall through to a silent update — that would make the write look successful while doing nothing.
   let updated = false;
   const table = {
-    // deno-lint-ignore require-await
     async insert() {
       throw new Error("FOREIGN KEY constraint failed");
     },
-    // deno-lint-ignore require-await
     async update() {
       updated = true;
     },
-    // deno-lint-ignore require-await
     async get() {
       return undefined;
     },
   };
-  // deno-lint-ignore no-explicit-any
   const data = { table: () => table } as any as DataLayer;
   let threw = false;
   try {
@@ -299,7 +279,7 @@ Deno.test("recordRetro: rethrows a non-unique (FOREIGN KEY) constraint error ins
   assertEquals(updated, false, "must not silently fall back to update on a non-unique error");
 });
 
-Deno.test("maybeStartRetro: starts the retro exactly once when the last PR lands with material", async () => {
+test("maybeStartRetro: starts the retro exactly once when the last PR lands with material", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
@@ -325,13 +305,12 @@ Deno.test("maybeStartRetro: starts the retro exactly once when the last PR lands
   assertEquals(started.length, 1, "fire-once guard");
 });
 
-Deno.test("maybeStartRetro: a createInstance failure records a blocked retro (fire-once guard already consumed)", async () => {
+test("maybeStartRetro: a createInstance failure records a blocked retro (fire-once guard already consumed)", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
   seedPr(stores, "acme/widgets#10", "merged");
   await appendEntry(data, PLAN, { author_task: "t1", kind: "learning", body: "regen first" });
-  // deno-lint-ignore no-explicit-any require-await
   const engine = { async createInstance() { throw new Error("gateway down"); } } as any as EngineClient;
 
   const r = await maybeStartRetro(data, engine, "acme/widgets#10");
@@ -346,19 +325,16 @@ Deno.test("maybeStartRetro: a createInstance failure records a blocked retro (fi
   assertStringIncludes(String(stores["plan_retros"][0].summary), "gateway down");
 });
 
-Deno.test("maybeStartRetro: a secondary blocked-retro persistence failure still returns start-failed (not error)", async () => {
+test("maybeStartRetro: a secondary blocked-retro persistence failure still returns start-failed (not error)", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
   seedPr(stores, "acme/widgets#10", "merged");
   await appendEntry(data, PLAN, { author_task: "t1", kind: "learning", body: "regen first" });
-  // deno-lint-ignore no-explicit-any require-await
   const engine = { async createInstance() { throw new Error("gateway down"); } } as any as EngineClient;
   // recordRetro rethrows non-unique DB errors; simulate the blocked-retro insert hitting a
   // FOREIGN KEY failure so the persistence in the createInstance-failure handler throws.
-  // deno-lint-ignore no-explicit-any
   const failingData = {
-    // deno-lint-ignore no-explicit-any
     table: (name: string, pk?: string) => {
       const t = (data as any).table(name, pk);
       if (name !== "plan_retros") return t;
@@ -374,7 +350,7 @@ Deno.test("maybeStartRetro: a secondary blocked-retro persistence failure still
   assertEquals(stores["plan_retros"].length, 0);
 });
 
-Deno.test("maybeStartRetro: a pre-claimed retro start does not start a duplicate process", async () => {
+test("maybeStartRetro: a pre-claimed retro start does not start a duplicate process", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
@@ -389,7 +365,7 @@ Deno.test("maybeStartRetro: a pre-claimed retro start does not start a duplicate
   assertEquals(stores["plans"][0].retro_started_at, null);
 });
 
-Deno.test("maybeStartRetro: bails while the plan is incomplete", async () => {
+test("maybeStartRetro: bails while the plan is incomplete", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
@@ -404,7 +380,7 @@ Deno.test("maybeStartRetro: bails while the plan is incomplete", async () => {
   assertEquals(stores["plans"][0].retro_started_at, null, "must not stamp an incomplete plan");
 });
 
-Deno.test("maybeStartRetro: complete but empty → records a skipped retro, does not start the process", async () => {
+test("maybeStartRetro: complete but empty → records a skipped retro, does not start the process", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
@@ -419,7 +395,7 @@ Deno.test("maybeStartRetro: complete but empty → records a skipped retro, does
   assertEquals(stores["plan_retros"][0].status, "skipped");
 });
 
-Deno.test("maybeStartRetro: a rejected review round alone is enough to fire the retro", async () => {
+test("maybeStartRetro: a rejected review round alone is enough to fire the retro", async () => {
   const { data, stores } = memData();
   seedPlan(stores);
   seedTask(stores, { id: "t1", status: "opened", pr_key: "acme/widgets#10" });
@@ -436,7 +412,7 @@ Deno.test("maybeStartRetro: a rejected review round alone is enough to fire the
   assert(stores["plans"][0].retro_started_at, "retro_started_at must be stamped");
 });
 
-Deno.test("maybeStartRetro: a PR not part of any plan is a no-op", async () => {
+test("maybeStartRetro: a PR not part of any plan is a no-op", async () => {
   const { data } = memData();
   const { engine, started } = fakeEngine();
   const r = await maybeStartRetro(data, engine, "acme/widgets#99");
@@ -445,7 +421,7 @@ Deno.test("maybeStartRetro: a PR not part of any plan is a no-op", async () => {
   assertEquals(started.length, 0);
 });
 
-Deno.test("maybeStartRetro: honours NANO_AUTO_RETRO=0", async () => {
+test("maybeStartRetro: honours NANO_AUTO_RETRO=0", async () => {
   const prev = process.env.NANO_AUTO_RETRO;
   process.env.NANO_AUTO_RETRO = "0";
   try {