@nanobpm/nano-workforce 0.36.0 → 0.37.0

package/app/mergeProtocol.test.ts

@@ -3,8 +3,9 @@
 // extractor must find the fenced ```merge-protocol JSON, and the fresh-head-run decision must fire
 // exactly once per landing attempt — only in the frugal-CI stuck state (no head run + waiting) —
 // so a converged PR is nudged into a fresh CI run without disturbing a run already in flight.
-// Run with `deno test -A`.
-import { assertEquals } from "jsr:@std/assert@1";
+// Run with `node --test`.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import {
   DEFAULT_MERGE_PROTOCOL,
   extractProtocolBlock,
@@ -13,14 +14,14 @@ import {
   parseMergeProtocol,
 } from "./mergeProtocol.ts";
 
-Deno.test("parseMergeProtocol: non-object / junk → defaults (total, never throws)", () => {
+test("parseMergeProtocol: non-object / junk → defaults (total, never throws)", () => {
   assertEquals(parseMergeProtocol(undefined), { ...DEFAULT_MERGE_PROTOCOL });
   assertEquals(parseMergeProtocol(null), { ...DEFAULT_MERGE_PROTOCOL });
   assertEquals(parseMergeProtocol("nope"), { ...DEFAULT_MERGE_PROTOCOL });
   assertEquals(parseMergeProtocol([1, 2]), { ...DEFAULT_MERGE_PROTOCOL });
 });
 
-Deno.test("parseMergeProtocol: full nano-bpm-style descriptor", () => {
+test("parseMergeProtocol: full nano-bpm-style descriptor", () => {
   const got = parseMergeProtocol({
     autoMerge: false,
     freshHeadRun: "ready-or-reopen",
@@ -37,7 +38,7 @@ Deno.test("parseMergeProtocol: full nano-bpm-style descriptor", () => {
   assertEquals(got.doc, "AGENTS.md#merging-prs");
 });
 
-Deno.test("parseMergeProtocol: invalid enums / wrong types fall back per-field", () => {
+test("parseMergeProtocol: invalid enums / wrong types fall back per-field", () => {
   const got = parseMergeProtocol({
     autoMerge: "yes", // not a boolean → default
     freshHeadRun: "sometimes", // not in the enum → default (none)
@@ -50,12 +51,12 @@ Deno.test("parseMergeProtocol: invalid enums / wrong types fall back per-field",
   assertEquals(got.requiredChecks, ["ok"]);
 });
 
-Deno.test("parseMergeProtocol: comment dropped when absent", () => {
+test("parseMergeProtocol: comment dropped when absent", () => {
   const got = parseMergeProtocol({ land: { method: "admin" } });
   assertEquals(got.land, { method: "admin" });
 });
 
-Deno.test("extractProtocolBlock: finds the fenced merge-protocol JSON (with info word)", () => {
+test("extractProtocolBlock: finds the fenced merge-protocol JSON (with info word)", () => {
   const md = [
     "## Merging PRs",
     "Some prose about how to merge.",
@@ -73,7 +74,7 @@ Deno.test("extractProtocolBlock: finds the fenced merge-protocol JSON (with info
   assertEquals(p.land.method, "mergify-queue");
 });
 
-Deno.test("extractProtocolBlock: none present → null", () => {
+test("extractProtocolBlock: none present → null", () => {
   assertEquals(extractProtocolBlock("# Doc\n```json\n{}\n```\n"), null);
 });
 
@@ -82,14 +83,14 @@ const NANO: MergeProtocol = parseMergeProtocol({
   land: { method: "mergify-queue" },
 });
 
-Deno.test("freshHeadRunAction: fires in the frugal-CI stuck state (no run + waiting)", () => {
+test("freshHeadRunAction: fires in the frugal-CI stuck state (no run + waiting)", () => {
   // ready PR, no head run at all → reopen (ready-or-reopen, not a draft)
   assertEquals(freshHeadRunAction(NANO, "waiting", 0, false), "reopen");
   // draft PR, no head run → mark ready
   assertEquals(freshHeadRunAction(NANO, "waiting", 0, true), "ready");
 });
 
-Deno.test("freshHeadRunAction: fires once per landing-attempt head, then re-fires after rebase", () => {
+test("freshHeadRunAction: fires once per landing-attempt head, then re-fires after rebase", () => {
   assertEquals(
     freshHeadRunAction(NANO, "waiting", 0, false, { headRefOid: "h1", lastActionHeadRefOid: null }),
     "reopen",
@@ -104,7 +105,7 @@ Deno.test("freshHeadRunAction: fires once per landing-attempt head, then re-fire
   );
 });
 
-Deno.test("freshHeadRunAction: never fires once a run exists, or when not waiting", () => {
+test("freshHeadRunAction: never fires once a run exists, or when not waiting", () => {
   assertEquals(freshHeadRunAction(NANO, "waiting", 1, false), null); // run already in flight
   assertEquals(freshHeadRunAction(NANO, "waiting", -1, false), null); // token mode (unknown) → conservative
   assertEquals(freshHeadRunAction(NANO, "ready", 0, false), null); // already landable
@@ -113,11 +114,11 @@ Deno.test("freshHeadRunAction: never fires once a run exists, or when not waitin
   assertEquals(freshHeadRunAction(NANO, "conflict", 0, false), null); // conflict → rebase arm (#42)
 });
 
-Deno.test("freshHeadRunAction: protocol.freshHeadRun=none is a no-op (default repos unchanged)", () => {
+test("freshHeadRunAction: protocol.freshHeadRun=none is a no-op (default repos unchanged)", () => {
   assertEquals(freshHeadRunAction(DEFAULT_MERGE_PROTOCOL, "waiting", 0, false), null);
 });
 
-Deno.test("freshHeadRunAction: mode=ready only acts on drafts", () => {
+test("freshHeadRunAction: mode=ready only acts on drafts", () => {
   const readyOnly = parseMergeProtocol({ freshHeadRun: "ready", land: { method: "gh-merge" } });
   assertEquals(freshHeadRunAction(readyOnly, "waiting", 0, true), "ready");
   assertEquals(freshHeadRunAction(readyOnly, "waiting", 0, false), null); // not a draft → nothing to ready

package/app/mergeRebaseArm.test.ts

@@ -10,9 +10,11 @@
 // way it originally shipped. It is a pure text assertion over the BPMN (no engine), matching the
 // repo's lightweight model-guard style.
 
-import { assert, assertStringIncludes } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assert, assertStringIncludes } from "#test-assert";
+import { readFileSync } from "node:fs";
 
-const bpmn = await Deno.readTextFile("resources/processes/merge-loop.bpmn");
+const bpmn = readFileSync("resources/processes/merge-loop.bpmn", "utf8");
 
 // Collapse whitespace so attribute-order / line-wrapping churn doesn't make the assertions brittle.
 const flat = bpmn.replace(/\s+/g, " ");
@@ -27,14 +29,14 @@ function hasFlow(source: string, target: string): boolean {
   return re.test(flat);
 }
 
-Deno.test("conflict routes to the rebase budget gate, not straight to a human", () => {
+test("conflict routes to the rebase budget gate, not straight to a human", () => {
   // The conflict verdict must reach the auto-rebase gate…
   assert(hasFlow("gw-mergeable", "gw-rebase"), "gw-mergeable → gw-rebase (conflict) missing");
   // …guarded by the exact conflict condition (DIRTY → mergeState = "conflict").
   assertStringIncludes(flat, 'mergeState = "conflict"');
 });
 
-Deno.test("rebase arm mirrors the fix-ci arm: budget gate → agent → result gate", () => {
+test("rebase arm mirrors the fix-ci arm: budget gate → agent → result gate", () => {
   // Budget gate: within budget → the agent; exhausted → the (existing) conflict escalation.
   assert(hasFlow("gw-rebase", "rebase"), "gw-rebase → rebase (within budget) missing");
   assert(hasFlow("gw-rebase", "merge-esc-conflict"), "gw-rebase → merge-esc-conflict (budget exhausted) missing");
@@ -49,7 +51,7 @@ Deno.test("rebase arm mirrors the fix-ci arm: budget gate → agent → result g
   assertStringIncludes(flat, "=rebaseRound + 1");
 });
 
-Deno.test("rebase result: success re-arms the poller; unresolved escalates to a human", () => {
+test("rebase result: success re-arms the poller; unresolved escalates to a human", () => {
   // Success loops back to re-attempt the merge — forward progress, no human needed.
   assert(hasFlow("gw-rebase-result", "arm-merge"), "gw-rebase-result → arm-merge (rebased) missing");
   assertStringIncludes(flat, 'status = "rebased"');
@@ -60,7 +62,7 @@ Deno.test("rebase result: success re-arms the poller; unresolved escalates to a
   );
 });
 
-Deno.test("regression: the conflict verdict passes through the rebase actor, not straight to escalation", () => {
+test("regression: the conflict verdict passes through the rebase actor, not straight to escalation", () => {
   // The original #42 livelock had the conflict verdict escalate to a human with no remediation
   // actor. The primary target of the conflict verdict must now be the rebase gate.
   assert(

package/app/mergeTrain.test.ts

@@ -1,5 +1,6 @@
 // Red/green regression for D6's pure merge-train lane planner.
-import { assertEquals } from "jsr:@std/assert@1";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
 import { planLane, planPrLane, taskDependencyDepths } from "./mergeTrain.ts";
 
 const taskToPr = new Map([
@@ -9,7 +10,7 @@ const taskToPr = new Map([
   ["gap-10", "o/r#10"],
 ]);
 
-Deno.test("planLane: dependency depth then task id picks the single lane head", () => {
+test("planLane: dependency depth then task id picks the single lane head", () => {
   const depth = new Map([["gap-8", 2], ["gap-2", 0], ["gap-9", 0]]);
   assertEquals(planLane(["gap-8", "gap-9", "gap-2"], taskToPr, new Set(), depth), {
     headTaskId: "gap-2",
@@ -19,7 +20,7 @@ Deno.test("planLane: dependency depth then task id picks the single lane head",
   });
 });
 
-Deno.test("taskDependencyDepths: longest dependency path determines landing order depth", () => {
+test("taskDependencyDepths: longest dependency path determines landing order depth", () => {
   const depths = taskDependencyDepths([
     { task_id: "b", depends_on_task_id: "a" },
     { task_id: "c", depends_on_task_id: "b" },
@@ -36,7 +37,7 @@ Deno.test("taskDependencyDepths: longest dependency path determines landing orde
   ]);
 });
 
-Deno.test("planLane: task id is the deterministic tiebreaker", () => {
+test("planLane: task id is the deterministic tiebreaker", () => {
   assertEquals(planLane(["gap-9", "gap-2", "gap-8"], taskToPr, new Set()), {
     headTaskId: "gap-2",
     headPrKey: "o/r#2",
@@ -45,7 +46,7 @@ Deno.test("planLane: task id is the deterministic tiebreaker", () => {
   });
 });
 
-Deno.test("planLane: already-merged head advances to the next unmerged member", () => {
+test("planLane: already-merged head advances to the next unmerged member", () => {
   assertEquals(planLane(["gap-2", "gap-8", "gap-9"], taskToPr, new Set(["o/r#2"])), {
     headTaskId: "gap-8",
     headPrKey: "o/r#8",
@@ -54,7 +55,7 @@ Deno.test("planLane: already-merged head advances to the next unmerged member",
   });
 });
 
-Deno.test("planLane: single-member lanes never hold their PR", () => {
+test("planLane: single-member lanes never hold their PR", () => {
   assertEquals(planLane(["gap-10"], taskToPr, new Set()), {
     headTaskId: null,
     headPrKey: null,
@@ -63,7 +64,7 @@ Deno.test("planLane: single-member lanes never hold their PR", () => {
   });
 });
 
-Deno.test("planLane: tasks without PR keys do not block PR-backed members", () => {
+test("planLane: tasks without PR keys do not block PR-backed members", () => {
   assertEquals(planLane(["scaffold", "gap-2", "gap-8"], taskToPr, new Set()), {
     headTaskId: "gap-2",
     headPrKey: "o/r#2",
@@ -72,7 +73,7 @@ Deno.test("planLane: tasks without PR keys do not block PR-backed members", () =
   });
 });
 
-Deno.test("planPrLane: held PRs point at the current lane head", () => {
+test("planPrLane: held PRs point at the current lane head", () => {
   assertEquals(
     planPrLane([["gap-2", "gap-8"], ["gap-10"]], taskToPr, new Set(), "o/r#8"),
     {
@@ -84,7 +85,7 @@ Deno.test("planPrLane: held PRs point at the current lane head", () => {
   );
 });
 
-Deno.test("planPrLane: lane head and PRs outside exclusion lanes are not held", () => {
+test("planPrLane: lane head and PRs outside exclusion lanes are not held", () => {
   assertEquals(planPrLane([["gap-2", "gap-8"], ["gap-10"]], taskToPr, new Set(), "o/r#2").isHeld, false);
   assertEquals(planPrLane([["gap-2", "gap-8"], ["gap-10"]], taskToPr, new Set(), "o/r#10").isHeld, false);
   assertEquals(planPrLane([["gap-2", "gap-8"]], taskToPr, new Set(), "o/r#404").isHeld, false);

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: {
@@ -171,10 +152,8 @@ Deno.test("persist-escalation heals from the prKey when repo/prNumber are absent
       abandonUrl: "https://host/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,38 +70,33 @@ 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: {
@@ -117,10 +106,8 @@ Deno.test("persist-round heals from the prKey when repo/prNumber are absent", as
       abandonUrl: "https://host/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);