@nanobpm/nano-workforce 0.35.2 → 0.36.0

package/.github/workflows/ci.yml

@@ -25,6 +25,9 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Lint (Biome)
+        run: npm run lint
+
       - name: Typecheck (Node / tsc)
         run: npm run typecheck
 

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [0.36.0](https://github.com/nanobpm/nano-workforce/compare/v0.35.2...v0.36.0) (2026-08-10)
+
+
+### Features
+
+* adopt Biome + GritQL ban-`as` lint gate ([#107](https://github.com/nanobpm/nano-workforce/issues/107)) ([38c16fb](https://github.com/nanobpm/nano-workforce/commit/38c16fb319e8c5d6b8c20faf95318de39b948a96)), closes [#105](https://github.com/nanobpm/nano-workforce/issues/105)
+
 ## [0.35.2](https://github.com/nanobpm/nano-workforce/compare/v0.35.1...v0.35.2) (2026-08-10)
 
 

package/actions/blackboard.ts

@@ -35,6 +35,7 @@ const handler: ActionHandler = async ({ req, body }, app) => {
   }
 
   if (req.method === "POST") {
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const b = (body ?? {}) as Record<string, unknown>;
     const text = typeof b.body === "string" ? b.body.trim() : "";
     if (!text) return { status: 400, body: { error: "'body' (the note text) is required" } };

package/actions/feature-answer-hook.ts

@@ -20,6 +20,7 @@ const handler: ActionHandler = async ({ req, body }, app) => {
   if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
     return { status: 401, body: { error: "unauthorized" } };
   }
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const b = (body ?? {}) as {
     corrKey?: unknown;
     plan?: unknown;

package/actions/plan-hook.ts

@@ -10,8 +10,9 @@ const handler: ActionHandler = async ({ req, body }, app) => {
   if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
     return { status: 401, body: { error: "unauthorized" } };
   }
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const b = (body ?? {}) as { url?: unknown; issue?: unknown };
-  const parsed = parseIssue(String((b.issue ?? b.url ?? "") as string));
+  const parsed = parseIssue(String(b.issue ?? b.url ?? ""));
   if (!parsed) return { status: 400, body: { error: "could not parse issue (use owner/repo#123 or an issue URL)" } };
   return { status: 202, body: await startPlan(app.data, app.engine, parsed) };
 };

package/actions/webhook-submit.ts

@@ -10,8 +10,9 @@ const handler: ActionHandler = async ({ req, body }, app) => {
   if (WEBHOOK_SECRET && req.headers.get("x-hook-secret") !== WEBHOOK_SECRET) {
     return { status: 401, body: { error: "unauthorized" } };
   }
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const b = (body ?? {}) as { url?: unknown; pr?: unknown; dependsOn?: unknown; maxRounds?: unknown };
-  const parsed = parsePr(String((b.url ?? b.pr ?? "") as string));
+  const parsed = parsePr(String(b.url ?? b.pr ?? ""));
   if (!parsed) return { status: 400, body: { error: "could not parse PR url" } };
   const dependsOn = Array.isArray(b.dependsOn) ? b.dependsOn.map((d) => String(d)) : [];
   const maxRounds = clampRounds(b.maxRounds, MAX_ROUNDS);

package/app/blackboard.ts

@@ -58,11 +58,9 @@ export interface BlackboardInput {
   dedupe_key?: string;
 }
 
-const KIND_SET = new Set<string>(BLACKBOARD_KINDS);
-
 /** Coerce an arbitrary `kind` to a known value, defaulting to "note" for anything unrecognised. */
 export function normalizeKind(kind: unknown): BlackboardKind {
-  return typeof kind === "string" && KIND_SET.has(kind) ? (kind as BlackboardKind) : "note";
+  return BLACKBOARD_KINDS.find((k) => k === kind) ?? "note";
 }
 
 /** A URL-safe, unguessable capability token (192 bits of randomness, base64url, no padding). */
@@ -79,9 +77,10 @@ export function mintBlackboardToken(): string {
 export function publicBaseUrl(env: string | undefined = process.env.NANO_PR_PUBLIC_BASE_URL): string {
   // Cascade through the fallback chain, skipping any value that is unset OR blank/whitespace, so an
   // explicitly-set-but-empty NANO_PR_PUBLIC_BASE_URL can't yield a malformed capability URL.
-  const base = [env, process.env.NANO_PR_BASE_URL, "http://localhost:3000"]
-    .map((v) => v?.trim())
-    .find((v) => v) as string;
+  const base =
+    [env, process.env.NANO_PR_BASE_URL, "http://localhost:3000"]
+      .map((v) => v?.trim())
+      .find((v): v is string => Boolean(v)) ?? "http://localhost:3000";
   return base.replace(/\/+$/, "");
 }
 
@@ -313,8 +312,10 @@ export async function appendEntry(
  * corruption, not a benign duplicate) is always rethrown rather than silently swallowed. */
 export function isUniqueViolation(err: unknown): boolean {
   if (!err || typeof err !== "object") return false;
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const code = (err as { code?: unknown }).code;
   if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") return true;
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const message = (err as { message?: unknown }).message;
   return typeof message === "string" &&
     /(unique|primary key) constraint failed|duplicate/i.test(message);

package/app/github.ts

@@ -37,6 +37,7 @@ interface DenoCommandCtor {
  * `repo`/`number` from the datastore cannot inject a command). Resolves stdout, rejects on a
  * non-zero exit with stderr as the message. */
 async function runGh(args: string[]): Promise<string> {
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const g = globalThis as { Deno?: { Command?: DenoCommandCtor } };
   if (g.Deno?.Command) {
     const { code, stdout, stderr } = await new g.Deno.Command("gh", {
@@ -66,7 +67,10 @@ async function runGh(args: string[]): Promise<string> {
 let ghAvailable: Promise<boolean> | undefined;
 /** Whether the host `gh` CLI is present (memoized — probed at most once per process). */
 function isGhAvailable(): Promise<boolean> {
-  return (ghAvailable ??= runGh(["--version"]).then(() => true, () => false));
+  if (!ghAvailable) {
+    ghAvailable = runGh(["--version"]).then(() => true, () => false);
+  }
+  return ghAvailable;
 }
 
 /** Fetch the reviews for one PR via the configured transport. Throws on transport failure so
@@ -81,6 +85,7 @@ export async function fetchPrReviews(
   const path = `repos/${repo}/pulls/${number}/reviews?per_page=100`;
   if (useGh) {
     const out = await runGh(["api", path, "-H", "Accept: application/vnd.github+json"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     return JSON.parse(out) as GhReview[];
   }
   if (!token) return null; // token mode with no token → poller idles
@@ -88,6 +93,7 @@ export async function fetchPrReviews(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   return (await r.json()) as GhReview[];
 }
 
@@ -122,6 +128,7 @@ export async function hasPendingCopilotReviewer(
   let users: { login?: string }[];
   if (await useGh()) {
     const out = await runGh(["api", path, "-H", "Accept: application/vnd.github+json"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     users = (JSON.parse(out) as { users?: { login?: string }[] }).users ?? [];
   } else {
     if (!token) return null;
@@ -129,6 +136,7 @@ export async function hasPendingCopilotReviewer(
       headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
     });
     if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     users = ((await r.json()) as { users?: { login?: string }[] }).users ?? [];
   }
   return users.some((u) => isCopilot(u.login));
@@ -198,6 +206,7 @@ export async function fetchPrMeta(
 ): Promise<PrMeta | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "title,body"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { title?: string; body?: string };
     return { title: j.title ?? null, body: j.body ?? "" };
   }
@@ -206,6 +215,7 @@ export async function fetchPrMeta(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as { title?: string; body?: string };
   return { title: j.title ?? null, body: j.body ?? "" };
 }
@@ -273,6 +283,7 @@ export async function fetchPrState(
       "--json",
       "state,mergedAt,mergeStateStatus,statusCheckRollup,isDraft,headRefOid",
     ]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as {
       state?: string;
       mergedAt?: string | null;
@@ -298,6 +309,7 @@ export async function fetchPrState(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as {
     merged?: boolean;
     merged_at?: string | null;
@@ -328,6 +340,7 @@ export async function fetchPrFiles(
 ): Promise<string[] | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "files"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { files?: { path?: string }[] };
     return (j.files ?? []).map((f) => f.path ?? "").filter((p) => p !== "");
   }
@@ -341,6 +354,7 @@ export async function fetchPrFiles(
       { headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" } },
     );
     if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const batch = (await r.json()) as { filename?: string }[];
     for (const f of batch) if (f.filename) paths.push(f.filename);
     // A short final page means we've read every file — the list is complete.
@@ -367,6 +381,7 @@ export async function fetchPrHead(
 ): Promise<{ headRef: string | null; headSha: string | null } | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "headRefName,headRefOid"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { headRefName?: string | null; headRefOid?: string | null };
     return { headRef: j.headRefName ?? null, headSha: j.headRefOid ?? null };
   }
@@ -375,6 +390,7 @@ export async function fetchPrHead(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as { head?: { ref?: string | null; sha?: string | null } };
   return { headRef: j.head?.ref ?? null, headSha: j.head?.sha ?? null };
 }
@@ -389,6 +405,7 @@ export async function fetchPrBase(
 ): Promise<string | null> {
   if (await useGh()) {
     const out = await runGh(["pr", "view", String(number), "--repo", repo, "--json", "baseRefName"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { baseRefName?: string };
     return j.baseRefName ?? null;
   }
@@ -397,6 +414,7 @@ export async function fetchPrBase(
     headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
   });
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const j = (await r.json()) as { base?: { ref?: string } };
   return j.base?.ref ?? null;
 }
@@ -413,6 +431,7 @@ export async function fetchDefaultBranch(repo: string, token: string): Promise<s
   let name: string | null = null;
   if (await useGh()) {
     const out = await runGh(["repo", "view", repo, "--json", "defaultBranchRef"]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = JSON.parse(out) as { defaultBranchRef?: { name?: string } };
     name = j.defaultBranchRef?.name ?? null;
   } else if (token) {
@@ -420,6 +439,7 @@ export async function fetchDefaultBranch(repo: string, token: string): Promise<s
       headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
     });
     if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const j = (await r.json()) as { default_branch?: string };
     name = j.default_branch ?? null;
   } else {
@@ -455,6 +475,7 @@ export async function baseBranchLanded(
       "--limit",
       "20",
     ]);
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const arr = JSON.parse(out) as { state?: string }[];
     if (arr.some((p) => (p.state ?? "").toUpperCase() === "MERGED")) return "landed";
     if (arr.some((p) => (p.state ?? "").toUpperCase() === "OPEN")) return "open";
@@ -467,6 +488,7 @@ export async function baseBranchLanded(
     { headers: { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" } },
   );
   if (!r.ok) throw new Error(`github ${r.status} ${r.statusText}`.trim());
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const arr = (await r.json()) as { state?: string; merged_at?: string | null }[];
   if (arr.some((p) => p.merged_at || (p.state ?? "").toUpperCase() === "MERGED")) return "landed";
   if (arr.some((p) => (p.state ?? "").toLowerCase() === "open")) return "open";
@@ -491,7 +513,6 @@ export function classifyMergeability(s: PrState): Mergeability {
       // A required check failed -> a human must act. Pending checks / awaiting review -> wait.
       // When we can't enumerate checks (failingChecks < 0, token mode) stay conservative: wait.
       return s.failingChecks > 0 ? "blocked" : "waiting";
-    case "DRAFT":
     default: // UNKNOWN / "" — GitHub is still computing mergeability
       return "waiting";
   }
@@ -550,6 +571,7 @@ export async function mergePr(
     // in this pass. Trust `merged` when true; otherwise verify the PR's actual state and report
     // `queued` when it hasn't landed yet, so the merge-loop waits for `merge-landed` rather than
     // marking it merged prematurely.
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     const body = (await r.json().catch(() => ({}))) as { merged?: boolean };
     if (body.merged) return { outcome: "merged", detail: "merged" };
     const st = await fetchPrState(repo, number, token).catch(() => null);

package/app/mergeExclusion.ts

@@ -169,12 +169,17 @@ export async function clearExclusions(data: DataLayer, planKey: string): Promise
 export function mergeLanes(edges: ExclusionEdge[], allTasks: Iterable<string> = []): string[][] {
   const parent = new Map<string, string>();
   const find = (x: string): string => {
+    const parentOf = (node: string): string => {
+      const p = parent.get(node);
+      if (p === undefined) throw new Error(`missing union-find parent for ${node}`);
+      return p;
+    };
     let root = x;
-    while (parent.get(root) !== root) root = parent.get(root)!;
+    while (parentOf(root) !== root) root = parentOf(root);
     // Path-compress so repeated finds stay near-flat.
     let cur = x;
-    while (parent.get(cur) !== root) {
-      const next = parent.get(cur)!;
+    while (parentOf(cur) !== root) {
+      const next = parentOf(cur);
       parent.set(cur, root);
       cur = next;
     }

package/app/mergeProtocol.ts

@@ -72,6 +72,7 @@ function strArray(v: unknown): string[] | undefined {
 }
 function oneOf<T extends string>(v: unknown, allowed: ReadonlySet<string>): T | undefined {
   const s = str(v);
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   return s !== undefined && allowed.has(s) ? (s as T) : undefined;
 }
 

package/app/plan.ts

@@ -11,8 +11,8 @@
 // hand-written SQL — matching app/service.ts.
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
 import { blackboardUrl, mintBlackboardToken, renderCoordinationBrief } from "./blackboard.ts";
-import { clearTaskDeltas } from "./taskDelta.ts";
 import { clearExclusions } from "./mergeExclusion.ts";
+import { clearTaskDeltas } from "./taskDelta.ts";
 
 /** The BPMN process this module drives (resources/processes/plan-fanout.bpmn). */
 export const PLAN_PROCESS_ID = "plan-fanout";

package/app/retro.ts

@@ -14,16 +14,17 @@
 // Data access goes through the record gateway (`data.table`), never hand-written SQL — matching
 // app/plan.ts, app/blackboard.ts, and app/taskDelta.ts.
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
-import { planReviews, planTasks } from "./plan.ts";
 import { isUniqueViolation, readBlackboard } from "./blackboard.ts";
-import { aggregateEpicDeltas } from "./taskDelta.ts";
+import { planReviews, planTasks } from "./plan.ts";
 import { TERMINAL_STATUSES } from "./service.ts";
+import { aggregateEpicDeltas } from "./taskDelta.ts";
 
 export const RETRO_PROCESS_ID = "retro";
 
 /** Opt-out env toggle. Retro runs by default; set NANO_AUTO_RETRO=0/false to disable (e.g. in a
  * review-only deployment that doesn't want the fleet opening promotion PRs). */
 export function autoRetroEnabled(): boolean {
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const v = (globalThis as { process?: { env?: Record<string, string | undefined> } })
     .process?.env?.NANO_AUTO_RETRO;
   if (v == null) return true;
@@ -128,6 +129,7 @@ export async function gatherRetro(data: DataLayer, planKey: string): Promise<Ret
     .sort((a, b) => a.round - b.round);
   const reviewRejections = reviews
     .filter((r) => r.approved === 0 && (r.findings ?? "").trim() !== "")
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     .map((r) => ({ round: r.round, findings: r.findings as string }));
   const planApproved = reviews.length > 0 && reviews[reviews.length - 1].approved === 1;
 

package/app/service.ts

@@ -8,6 +8,7 @@
 // Data access goes through the record-oriented gateway (`data.table<T>(name, pk)` — the RAD
 // `Table<T>` surface), not hand-written SQL. Row shapes are declared inline here.
 import type { DataLayer, EngineClient } from "@nanobpm/urban";
+import { abandonUrl, mintAbandonToken, renderAbandonBrief } from "./abandon.ts";
 import {
   classifyMergeability,
   ensureFreshHeadRun,
@@ -18,13 +19,12 @@ import {
   type MergeMethod,
   requestCopilotReview,
 } from "./github.ts";
-import { planTaskDeps, planTasks, plans } from "./plan.ts";
-import { abandonUrl, mintAbandonToken, renderAbandonBrief } from "./abandon.ts";
+import { mergeLanes, readExclusions } from "./mergeExclusion.ts";
 import { freshHeadRunAction, loadMergeProtocol } from "./mergeProtocol.ts";
+import { type PrLaneDecision, planPrLane, taskDependencyDepths } from "./mergeTrain.ts";
+import { plans, planTaskDeps, planTasks } from "./plan.ts";
 import { clampNudgeMinutes, reviewWaitTimeout } from "./reviewWait.ts";
 import { waveMergeTargets } from "./waves.ts";
-import { mergeLanes, readExclusions } from "./mergeExclusion.ts";
-import { planPrLane, type PrLaneDecision, taskDependencyDepths } from "./mergeTrain.ts";
 
 /** The BPMN process that drives review convergence (`resources/processes/convergence-loop.bpmn`). */
 export const PROCESS_ID = "convergence-loop";
@@ -34,10 +34,12 @@ export const MERGE_PROCESS_ID = "merge-loop";
  * in convergence-loop.bpmn). Deliberately NOT hosted here — an external harness services it; the
  * activation poll keys off it to tell "agent working" from "queued". */
 const REVIEW_JOB_TYPE = "senior:pr-review";
+
 /** Default round cap before the loop escalates to a human. A per-submit override (submit form /
  * webhook / start action) takes precedence; this env var sets the fleet-wide default. The cap
  * coercion + ceiling live in the pure `./rounds.ts` module (re-exported for callers). */
 export { clampCiFixBudget, clampRounds, MAX_CI_FIX_CEILING, MAX_ROUNDS_CEILING } from "./rounds.ts";
+
 import { clampCiFixBudget, clampRounds } from "./rounds.ts";
 export const MAX_ROUNDS = clampRounds(process.env.NANO_PR_MAX_ROUNDS, 20);
 
@@ -830,6 +832,7 @@ async function pollJobActivation(
         }),
       });
       if (!res.ok) continue; // engine unhappy → keep last-known, retry next pass
+      // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
       const body = (await res.json()) as { items?: JobSearchItem[] };
       // An open job with a leasing worker means an agent has activated it. Prefer the one with
       // the latest deadline if several are open (there is normally at most one).
@@ -929,6 +932,7 @@ export async function pollIncidentsImpl(
         }),
       });
       if (!res.ok) continue; // engine unhappy → keep last-known, retry next pass
+      // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
       const body = (await res.json()) as { items?: IncidentSearchItem[] };
       // Surface the oldest ACTIVE incident (the first thing that broke — a stable choice if the
       // instance somehow parks more than one). Re-filter on state defensively in case the wire

package/app/taskDelta.ts

@@ -71,6 +71,7 @@ function decodeArray(raw: string | null): string[] {
  * nothing actionable (so callers persist/broadcast only real deltas, never empty noise). */
 export function parseTaskDelta(raw: unknown): TaskDelta | null {
   if (!raw || typeof raw !== "object") return null;
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const o = raw as Record<string, unknown>;
   const delta: TaskDelta = {
     contractChange: trimStr(o.contractChange),

package/app/version.ts

@@ -11,8 +11,8 @@
 // Every probe is best-effort: a missing file or unavailable `.git` yields `null` for that field
 // rather than throwing, so `/app/api/version` never fails just because one source is absent.
 import { readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { dirname, join, resolve, isAbsolute } from "node:path";
 
 // Captured once, at module load — i.e. when the running process booted this code.
 const STARTED_AT = new Date();
@@ -31,6 +31,7 @@ function readJson(path: string): Record<string, unknown> | null {
   const text = readText(path);
   if (text == null) return null;
   try {
+    // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
     return JSON.parse(text) as Record<string, unknown>;
   } catch {
     return null;
@@ -44,6 +45,7 @@ function readJson(path: string): Record<string, unknown> | null {
 export function envVar(name: string): string | null {
   const fromProcess = globalThis.process?.env?.[name];
   if (typeof fromProcess === "string" && fromProcess.trim()) return fromProcess.trim();
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const deno = (globalThis as { Deno?: { env?: { get?(k: string): string | undefined } } }).Deno;
   try {
     const fromDeno = deno?.env?.get?.(name);
@@ -129,7 +131,7 @@ function gitSha(): string | null {
   const refPath = ref.slice(4).trim(); // e.g. "refs/heads/main"
   // A loose ref may live in the per-worktree dir or the common dir; check both.
   const loose = readText(join(dirs.gitDir, refPath)) ?? readText(join(dirs.commonDir, refPath));
-  if (loose != null && loose.trim()) return loose.trim();
+  if (loose?.trim()) return loose.trim();
 
   // Packed refs fallback (always in the common dir): lines of "<sha> <refname>".
   const packed = readText(join(dirs.commonDir, "packed-refs"));
@@ -159,6 +161,7 @@ function gitBranch(): string | null {
 function runtime(): string {
   const proc = globalThis.process;
   // Deno exposes `Deno.version.deno`; Node exposes `process.version` (e.g. "v24.15.0").
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const deno = (globalThis as { Deno?: { version?: { deno?: string } } }).Deno;
   if (deno?.version?.deno) return `deno ${deno.version.deno}`;
   if (proc?.version) return `node ${proc.version}`;

package/biome.json

@@ -0,0 +1,143 @@
+{
+  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+  "files": {
+    "includes": [
+      "app/**/*.ts",
+      "operations/**/*.ts",
+      "actions/**/*.ts",
+      "workers/**/*.ts",
+      "pages/**/*.ts",
+      "components/**/*.ts",
+      "scripts/**/*.ts",
+      "main.ts",
+      "!**/*.test.ts",
+      "!nano-generated/**",
+      "!node_modules/**"
+    ]
+  },
+  "linter": {
+    "enabled": true,
+    "includes": [
+      "app/**/*.ts",
+      "operations/**/*.ts",
+      "actions/**/*.ts",
+      "workers/**/*.ts",
+      "pages/**/*.ts",
+      "components/**/*.ts",
+      "scripts/**/*.ts",
+      "main.ts",
+      "!**/*.test.ts",
+      "!nano-generated/**",
+      "!node_modules/**"
+    ],
+    "rules": {
+      "recommended": true,
+      "complexity": {
+        "noAdjacentSpacesInRegex": "error",
+        "noArguments": "error",
+        "noBannedTypes": "error",
+        "noCommaOperator": "error",
+        "noEmptyTypeParameters": "error",
+        "noExtraBooleanCast": "error",
+        "noFlatMapIdentity": "error",
+        "noImportantStyles": "error",
+        "noStaticOnlyClass": "error",
+        "noThisInStatic": "error",
+        "noUselessCatch": "error",
+        "noUselessConstructor": "error",
+        "noUselessContinue": "error",
+        "noUselessEmptyExport": "error",
+        "noUselessEscapeInRegex": "error",
+        "noUselessFragments": "error",
+        "noUselessLabel": "error",
+        "noUselessLoneBlockStatements": "error",
+        "noUselessRename": "error",
+        "noUselessStringRaw": "error",
+        "noUselessSwitchCase": "error",
+        "noUselessTernary": "error",
+        "noUselessThisAlias": "error",
+        "noUselessTypeConstraint": "error",
+        "noUselessUndefinedInitialization": "error",
+        "useArrowFunction": "error",
+        "useDateNow": "error",
+        "useFlatMap": "error",
+        "useIndexOf": "error",
+        "useLiteralKeys": "error",
+        "useNumericLiterals": "error",
+        "useOptionalChain": "error",
+        "useRegexLiterals": "error",
+        "useSimpleNumberKeys": "error"
+      },
+      "correctness": {
+        "noUnusedFunctionParameters": "error",
+        "noUnusedImports": "error",
+        "noUnusedLabels": "error",
+        "noUnusedPrivateClassMembers": "error",
+        "noUnusedVariables": "error",
+        "useParseIntRadix": "error"
+      },
+      "performance": {
+        "noAccumulatingSpread": "error",
+        "noDynamicNamespaceImportAccess": "error"
+      },
+      "style": {
+        "noDescendingSpecificity": "error",
+        "noNonNullAssertion": "error",
+        "useArrayLiterals": "error",
+        "useConst": "error",
+        "useDeprecatedReason": "error",
+        "useExponentiationOperator": "error",
+        "useExportType": "error",
+        "useImportType": "error",
+        "useLiteralEnumMembers": "error",
+        "useNodejsImportProtocol": "error",
+        "useShorthandFunctionType": "error",
+        "useTemplate": "error"
+      },
+      "suspicious": {
+        "noApproximativeNumericConstant": "error",
+        "noCatchAssign": "error",
+        "noConfusingLabels": "error",
+        "noConfusingVoidType": "error",
+        "noConstEnum": "error",
+        "noDocumentCookie": "error",
+        "noDuplicateFields": "error",
+        "noEmptyBlock": "error",
+        "noEvolvingTypes": "error",
+        "noExplicitAny": "error",
+        "noExtraNonNullAssertion": "error",
+        "noGlobalIsFinite": "error",
+        "noGlobalIsNan": "error",
+        "noImplicitAnyLet": "error",
+        "noIrregularWhitespace": "error",
+        "noOctalEscape": "error",
+        "noPrototypeBuiltins": "error",
+        "noQuickfixBiome": "error",
+        "noRedundantUseStrict": "error",
+        "noSuspiciousSemicolonInJsx": "error",
+        "noTemplateCurlyInString": "error",
+        "noTsIgnore": "error",
+        "noUselessEscapeInString": "error",
+        "noUselessRegexBackrefs": "error",
+        "useAdjacentOverloadSignatures": "error",
+        "useBiomeIgnoreFolder": "error",
+        "useDefaultSwitchClauseLast": "error",
+        "useGoogleFontDisplay": "error",
+        "useIsArray": "error"
+      }
+    },
+    "domains": {
+      "react": "none",
+      "solid": "none",
+      "next": "none",
+      "qwik": "none",
+      "vue": "none"
+    }
+  },
+  "plugins": [
+    "./plugins/no-unsafe-type-assertion.grit"
+  ],
+  "formatter": {
+    "enabled": false
+  }
+}

package/deno.lock

@@ -1760,6 +1760,7 @@
     ],
     "packageJson": {
       "dependencies": [
+        "npm:@biomejs/biome@^2.4.11",
         "npm:@nanobpm/urban@0.33",
         "npm:@semantic-release/changelog@^6.0.3",
         "npm:@semantic-release/git@^10.0.1",

package/operations/postMessage.ts

@@ -9,8 +9,8 @@
 // for free); this delegate keeps the message-name dispatch — the discriminator + downstream behavior
 // is app logic, not something the JSON schema can express.
 import { defineOperation } from "@nanobpm/urban";
-import { answerEscalation } from "../app/service.ts";
 import { answerTaskEscalation, FEATURE_ESCALATION_MESSAGE } from "../app/plan.ts";
+import { answerEscalation } from "../app/service.ts";
 
 interface Body {
   name?: unknown;
@@ -28,7 +28,7 @@ export default defineOperation<
 
   if (name === "escalation-answered") {
     const prKey = String(b.correlationKey ?? "");
-    const answer = String((b.variables?.answer ?? "") as string).trim();
+    const answer = String(b.variables?.answer ?? "").trim();
     if (!prKey) return { status: 400, body: { error: "correlationKey is required" } };
     if (!answer) return { status: 400, body: { error: "answer is required" } };
     const r = await answerEscalation(app.data, app.engine, prKey, answer);
@@ -40,7 +40,7 @@ export default defineOperation<
     // `<plan_key>:<task_id>`; record the answer, resume the parked child, and re-surface the next
     // open escalation.
     const corrKey = String(b.correlationKey ?? "");
-    const answer = String((b.variables?.answer ?? "") as string).trim();
+    const answer = String(b.variables?.answer ?? "").trim();
     if (!corrKey) return { status: 400, body: { error: "correlationKey is required" } };
     if (!answer) return { status: 400, body: { error: "answer is required" } };
     const r = await answerTaskEscalation(app.data, app.engine, corrKey, answer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.35.2",
+  "version": "0.36.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",
@@ -37,12 +37,15 @@
     "layout:check": "node --experimental-strip-types scripts/layout-bpmn.ts --check",
     "dev": "urban dev",
     "compile": "deno task compile",
-    "test": "deno test -A"
+    "test": "deno test -A",
+    "lint": "biome check app operations actions workers pages components scripts main.ts",
+    "lint:fix": "biome check --write app operations actions workers pages components scripts main.ts"
   },
   "dependencies": {
     "@nanobpm/urban": "^0.33.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.11",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/npm": "^13.1.5",

package/plugins/no-unsafe-type-assertion.grit

@@ -0,0 +1,12 @@
+engine biome(1.0)
+language js(typescript)
+
+`$expr as $type` as $assertion where {
+    $type <: not r"^const$",
+    $assertion <: not within JsImport(),
+    register_diagnostic(
+        span = $assertion,
+        message = "Type assertions (`as T`) bypass the type system. Use a type guard or `satisfies` instead. If unavoidable, add `// biome-ignore lint/plugin: <reason>` above.",
+        severity = "error"
+    )
+}

package/scripts/check-agent-prompts.ts

@@ -64,9 +64,10 @@ function templateMap(root: string, patterns: string[]): Record<string, string> {
 // signal can't see (an empty value carries no `{{token}}` to be unresolved).
 function hasBlankAgentPromptHeader(bpmn: string): boolean {
   const re = /<zeebe:header\s+key="([^"]*)"\s+value="([^"]*)"\s*\/?>/g;
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(bpmn)) !== null) {
+  let m = re.exec(bpmn);
+  while (m !== null) {
     if (m[1] === AGENT_PROMPT_HEADER && m[2].trim() === "") return true;
+    m = re.exec(bpmn);
   }
   return false;
 }
@@ -86,6 +87,7 @@ export function checkAgentPrompts(root: string): CheckResult {
   if (!existsSync(manifestPath)) {
     return { ok: false, errors: [`nano.app.json not found under ${root}`], resolved: [] };
   }
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as AppManifest;
   const models = manifest.models ?? {};
   const templates = templateMap(root, models.templates ?? []);

package/scripts/layout-bpmn.ts

@@ -12,9 +12,11 @@ import { layoutBpmn } from "@nanobpm/urban";
 
 // Host-agnostic file I/O: Deno inside a compiled binary, else node:fs under Node — mirrors
 // app/plan.ts's readAsset seam so this runs the same under `npm run` and `deno task`.
+// biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
 const g = globalThis as {
   Deno?: {
     args: string[];
+    exit(c: number): never;
     readDir(p: string): AsyncIterable<{ name: string; isFile: boolean }>;
     readTextFile(p: string): Promise<string>;
     writeTextFile(p: string, s: string): Promise<void>;
@@ -52,7 +54,7 @@ const countDi = (xml: string) => ({
 });
 
 function exit(code: number): never {
-  if (g.Deno) return (globalThis as { Deno?: { exit(c: number): never } }).Deno!.exit(code);
+  if (g.Deno) return g.Deno.exit(code);
   process.exit(code);
 }
 

package/scripts/purge-db.ts

@@ -51,7 +51,8 @@ for (const suffix of ["", "-wal", "-shm"]) {
     rmSync(path + suffix);
     console.log(`removed ${path}${suffix}`);
   } catch (err) {
-    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+    const code = typeof err === "object" && err !== null ? Reflect.get(err, "code") : undefined;
+    if (code !== "ENOENT") throw err;
   }
 }
 console.log("app db purged");

package/scripts/upgrade-from-pack.ts

@@ -29,6 +29,8 @@
 //                       (skips `npm pack`; --version/--package are ignored)
 //   --force             overlay even if the cwd doesn't look like this app
 //   -h, --help          show this help
+
+import { execFileSync } from "node:child_process";
 import {
   cpSync,
   existsSync,
@@ -39,7 +41,6 @@ import {
   rmSync,
   statSync,
 } from "node:fs";
-import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 
@@ -199,10 +200,12 @@ function runTar(tarArgs: string[], tgz: string): string {
   try {
     return execFileSync("tar", tarArgs, { encoding: "utf8" });
   } catch (e) {
-    if ((e as NodeJS.ErrnoException).code === "ENOENT") {
+    const code = typeof e === "object" && e !== null ? Reflect.get(e, "code") : undefined;
+    if (code === "ENOENT") {
       throw new Error(`'tar' not found on PATH — install it to extract ${tgz}`, { cause: e });
     }
-    throw new Error(`tar failed on ${tgz}: ${(e as Error).message}`, { cause: e });
+    const message = e instanceof Error ? e.message : String(e);
+    throw new Error(`tar failed on ${tgz}: ${message}`, { cause: e });
   }
 }
 
@@ -329,6 +332,7 @@ function report(label: string, files: string[]): void {
 try {
   main();
 } catch (err) {
-  console.error(`upgrade failed: ${(err as Error).message}`);
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`upgrade failed: ${message}`);
   process.exit(1);
 }

package/workers/finalize/worker.ts

@@ -2,9 +2,9 @@
 // merge stage (start the `merge-loop` process and park the PR in `waiting_deps`) when auto-merge
 // is on, or (b) close the PR out as `converged` (review-only mode).
 import type { AppJobHandler } from "@nanobpm/urban";
-import { AUTO_MERGE, ensurePr, startMerge } from "../../app/service.ts";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
 import { maybeStartRetro } from "../../app/retro.ts";
+import { AUTO_MERGE, ensurePr, startMerge } from "../../app/service.ts";
 
 // Extends Record so the declared fields are typed while the job may still carry
 // other process variables (e.g. io.nanobpm.agentResult, read by transcriptOf).
@@ -22,6 +22,7 @@ interface In extends Record<string, unknown> {
 
 const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
 function transcriptOf(vars: Record<string, unknown>): string | null {
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const env = vars[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
   return typeof env?.output === "string" ? env.output : null;
 }

package/workers/merge/worker.ts

@@ -9,11 +9,11 @@
 // calls live in app/github.ts; this worker records the attempt in the `merges` audit table and
 // shapes the escalation payload on a block.
 import type { AppJobHandler } from "@nanobpm/urban";
-import { enqueueViaComment, mergePr } from "../../app/github.ts";
-import { MERGE_ADMIN, MERGE_METHOD, ensurePr } from "../../app/service.ts";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
-import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
 import { checkBaseTarget } from "../../app/baseGuard.ts";
+import { enqueueViaComment, mergePr } from "../../app/github.ts";
+import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
+import { ensurePr, MERGE_ADMIN, MERGE_METHOD } from "../../app/service.ts";
 
 interface In extends Record<string, unknown> {
   prKey: string;

package/workers/persist-escalation/worker.ts

@@ -3,8 +3,8 @@
 // and the MAX_ROUNDS guard (status = blocked, question set by the process). Returns
 // `escalationId` for the UI.
 import type { AppJobHandler } from "@nanobpm/urban";
-import { ensurePr, parsePr } from "../../app/service.ts";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
+import { ensurePr, parsePr } from "../../app/service.ts";
 
 // Extends Record so the declared fields are typed while the job may still carry
 // other process variables (e.g. io.nanobpm.agentResult, read by transcriptOf).
@@ -39,6 +39,7 @@ function nonBlank(v: unknown): string | undefined {
 
 const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
 function transcriptOf(vars: Record<string, unknown>): string | null {
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const env = vars[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
   return typeof env?.output === "string" ? env.output : null;
 }

package/workers/persist-round/worker.ts

@@ -5,8 +5,8 @@
 // Data access goes through the injected app datasource gateway (`app.data.table<T>`), the RAD
 // `Table<T>` surface — `rounds.insert(...)` / `pull_requests.update(...)`, not hand-written SQL.
 import type { AppJobHandler } from "@nanobpm/urban";
-import { ensurePr, parsePr } from "../../app/service.ts";
 import { abandonTokenFromUrl } from "../../app/abandon.ts";
+import { ensurePr, parsePr } from "../../app/service.ts";
 
 // Extends Record so the declared fields are typed while the job may still carry
 // other process variables (e.g. io.nanobpm.agentResult, read by transcriptOf).
@@ -29,6 +29,7 @@ interface In extends Record<string, unknown> {
 // for audit so a human can see what the agent did this round.
 const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
 function transcriptOf(vars: Record<string, unknown>): string | null {
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const env = vars[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
   return typeof env?.output === "string" ? env.output : null;
 }

package/workers/record-plan-review/worker.ts

@@ -16,8 +16,9 @@
 // the whole epic complete GREEN having done nothing. The cap still bounds the loop; it now bounds
 // it into an incident, not a silent proceed. A missing/ambiguous `approved` is treated as NOT
 // approved (revise until the cap).
-import { BpmnError } from "@nanobpm/urban";
+
 import type { AppJobHandler } from "@nanobpm/urban";
+import { BpmnError } from "@nanobpm/urban";
 import { MAX_PLAN_REVIEW_ROUNDS, type PlanReview, planReviews } from "../../app/plan.ts";
 
 interface In extends Record<string, unknown> {

package/workers/record-results/worker.ts

@@ -10,8 +10,9 @@
 //   • zero PRs opened → record a `failed` outcome for observability, then throw the non-retryable
 //     `NO_WORK_DISPATCHED` BpmnError so the engine parks the instance on an incident instead of
 //     completing green (issue #86). The `failed` status is terminal, so `startPlan` can re-plan it.
-import { BpmnError } from "@nanobpm/urban";
+
 import type { AppJobHandler } from "@nanobpm/urban";
+import { BpmnError } from "@nanobpm/urban";
 import { planTasks } from "../../app/plan.ts";
 
 interface In extends Record<string, unknown> {

package/workers/record-trial-merge/worker.ts

@@ -4,9 +4,9 @@
 import type { AppJobHandler } from "@nanobpm/urban";
 import {
   recordTrialMergeAudit,
+  type TrialMergeResult,
   trialMergeDecision,
   trialMergeTaskId,
-  type TrialMergeResult,
 } from "../../app/trialMerge.ts";
 
 interface In extends Record<string, unknown> {
@@ -26,7 +26,6 @@ interface Out extends Record<string, unknown> {
   summary?: string;
 }
 
-const RESULTS = new Set<TrialMergeResult>(["clean", "merge-conflict", "suite-failed"]);
 const str = (v: unknown): string | undefined =>
   typeof v === "string" && v.trim().length > 0 ? v.trim() : undefined;
 const waveNo = (v: unknown): number => {
@@ -43,7 +42,8 @@ const safeJson = (v: unknown): string => {
 
 function parseResult(v: unknown): TrialMergeResult {
   const s = typeof v === "string" ? v.trim() : "";
-  return RESULTS.has(s as TrialMergeResult) ? (s as TrialMergeResult) : "suite-failed";
+  if (s === "clean" || s === "merge-conflict" || s === "suite-failed") return s;
+  return "suite-failed";
 }
 
 const handler: AppJobHandler<In, Out> = async (job, app) => {
@@ -52,8 +52,8 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const result = parseResult(job.variables.result);
   const summary = str(job.variables.summary) ??
     (result === "suite-failed" ? "Trial merge suite failed or returned no machine-readable result" : result);
-  const rawJobKey = (job as { key?: unknown }).key;
-  const jobKey = rawJobKey == null ? null : String(rawJobKey);
+  const legacyJobKey = Reflect.get(job, "key");
+  const jobKey = job.jobKey ?? (legacyJobKey == null ? null : String(legacyJobKey));
 
   try {
     await recordTrialMergeAudit(app.data, {
@@ -80,7 +80,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
     trialMergeRed,
     summary,
     task: { id: trialMergeTaskId(wave), title: `Trial merge gate for wave ${wave}` },
-    question: `${summary}${failing}\n\nD3 needs a human decision: either the PR heads merged cleanly and the combined suite failed, or the trial-merge agent did not return a valid machine-readable result. Decide the design/infrastructure fix, update the PR heads if needed, then answer to rerun the trial merge; answer exactly \"proceed\" only to override and continue without rerunning.`,
+    question: `${summary}${failing}\n\nD3 needs a human decision: either the PR heads merged cleanly and the combined suite failed, or the trial-merge agent did not return a valid machine-readable result. Decide the design/infrastructure fix, update the PR heads if needed, then answer to rerun the trial merge; answer exactly "proceed" only to override and continue without rerunning.`,
   };
 };
 

package/workers/record-wave/worker.ts

@@ -14,19 +14,19 @@
 // Enrollment lives here (not in the finalizer) so a PR is enrolled the moment its wave lands —
 // and, crucially, so a later wave's `dependsOn` can reference the PR keys earlier waves produced.
 import type { AppJobHandler } from "@nanobpm/urban";
+import { appendEntry } from "../../app/blackboard.ts";
+import { fetchPrFiles, fetchPrHead } from "../../app/github.ts";
+import { deriveExclusions, recordExclusions } from "../../app/mergeExclusion.ts";
+import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
 import {
   type PlanTask,
   type PlanTaskStatus,
+  plans,
   planTaskDeps,
   planTasks,
-  plans,
 } from "../../app/plan.ts";
 import { parsePr, submitPr } from "../../app/service.ts";
 import { parseTaskDelta, readTaskDeltas, recordTaskDelta } from "../../app/taskDelta.ts";
-import { appendEntry } from "../../app/blackboard.ts";
-import { deriveExclusions, recordExclusions } from "../../app/mergeExclusion.ts";
-import { fetchPrFiles, fetchPrHead } from "../../app/github.ts";
-import { loadMergeProtocol } from "../../app/mergeProtocol.ts";
 import { shouldRunTrialMerge, type TrialMergeHead } from "../../app/trialMerge.ts";
 
 interface Result {
@@ -61,9 +61,8 @@ const str = (v: unknown): string | undefined =>
 // including a missing status — is treated as `blocked`: we must not assume a PR was opened,
 // and we only hand off / persist a PR when the status is `opened`.
 type WaveResultStatus = Extract<PlanTaskStatus, "opened" | "blocked" | "skipped">;
-const ALLOWED_STATUSES = new Set<WaveResultStatus>(["opened", "blocked", "skipped"]);
 const isWaveResultStatus = (s: string): s is WaveResultStatus =>
-  ALLOWED_STATUSES.has(s as WaveResultStatus);
+  s === "opened" || s === "blocked" || s === "skipped";
 
 // Coerce a wave index/count to a non-negative integer, falling back to 0. A NaN here would make
 // `nextWave < waveCount` mis-evaluate and end the loop early, leaving tasks `pending`.
@@ -103,7 +102,7 @@ const handler: AppJobHandler<In, Out> = async (job, app) => {
   const readyHeadsThisWave: { repo: string; number: number | string }[] = [];
 
   for (let i = 0; i < waveTasks.length; i++) {
-    const taskId = str((waveTasks[i] ?? {}).id);
+    const taskId = str(waveTasks[i]?.id);
     if (!taskId) continue;
     const res = results[i] ?? {};
     const rawStatus = str(res.status);

package/workers/retro-record/worker.ts

@@ -10,7 +10,6 @@ import type { AppJobHandler } from "@nanobpm/urban";
 import { recordRetro } from "../../app/retro.ts";
 
 const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
-const VALID_STATUSES = new Set(["filed", "skipped", "blocked"]);
 
 interface In extends Record<string, unknown> {
   planKey: string;
@@ -26,9 +25,9 @@ function asStr(v: unknown): string | null {
 
 function asStatus(v: unknown, hasPr: boolean): "filed" | "skipped" | "blocked" {
   const s = asStr(v);
-  if (s && VALID_STATUSES.has(s)) {
+  if (s === "filed" || s === "skipped" || s === "blocked") {
     if (s === "filed" && !hasPr) return "skipped";
-    return s as "filed" | "skipped" | "blocked";
+    return s;
   }
   return hasPr ? "filed" : "skipped";
 }
@@ -42,6 +41,7 @@ const handler: AppJobHandler<In> = async (job, app) => {
   const prKey = status === "filed" ? rawPrKey : null;
   const summary = asStr(job.variables.summary);
 
+  // biome-ignore lint/plugin: runtime/framework contract boundary for external data shape
   const env = job.variables[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
   const report = typeof env?.output === "string" ? env.output : null;