pi-lens 4.1.0 → 4.1.2

package/dist/clients/degradation-ledger.js

@@ -2,6 +2,7 @@
 import { logExtension } from "./extension-log.js";
 import { LEDGER_FIELD_MAX, truncateForLedger } from "./ledger-bounds.js";
 import { logLatency } from "./latency-logger.js";
+import { getSinkWriteFailures, resetSinkWriteFailures, } from "./ndjson-logger.js";
 // Re-exported so existing importers keep one name for the ledger's bound.
 export { LEDGER_FIELD_MAX, truncateForLedger };
 const ENTRIES_PER_KIND = 20;
@@ -143,12 +144,28 @@ function boundedKind(value) {
     return groups.size < MAX_DISTINCT_KINDS - 1 ? kind : OVERFLOW_KIND;
 }
 export function getDegradationSummary() {
-    return [...groups.entries()].map(([kind, group]) => ({
+    const summary = [...groups.entries()].map(([kind, group]) => ({
         kind,
         count: group.count,
         droppedCount: group.count - group.entries.length,
         latestReasons: group.entries.map((entry) => ({ ...entry })),
     }));
+    // Folded in at read time, not written into `groups` (#1970) — see the
+    // `log-sink-write-failure` doc comment on `DegradationKind` for why this
+    // kind never goes through `recordDegradation`.
+    const sinkFailures = getSinkWriteFailures();
+    if (sinkFailures.length > 0) {
+        summary.push({
+            kind: "log-sink-write-failure",
+            count: sinkFailures.reduce((total, sink) => total + sink.droppedCount, 0),
+            droppedCount: 0,
+            latestReasons: sinkFailures.map((sink) => ({
+                subject: truncateForLedger(sink.file),
+                reason: truncateForLedger(`${sink.droppedCount} dropped write(s) after reopen-retry failed`),
+            })),
+        });
+    }
+    return summary;
 }
 function isRenderableSummary(value) {
     if (!Array.isArray(value))
@@ -197,6 +214,10 @@ export function resetDegradationLedger() {
     onceKeys.clear();
     tallies.clear();
     ledgerGeneration++;
+    // #1970, catalog shape 17: the sink write-failure tally is a
+    // process-lifetime latch too — it re-arms alongside the rest of the
+    // ledger rather than surviving past the session that observed it.
+    resetSinkWriteFailures();
 }
 export const DEGRADATION_ENTRIES_PER_KIND = ENTRIES_PER_KIND;
 export const DEGRADATION_MAX_DISTINCT_KINDS = MAX_DISTINCT_KINDS;

package/dist/clients/demoted-finding-render.js

@@ -0,0 +1,155 @@
+/**
+ * Body degradation for a DEMOTED finding (#1944).
+ *
+ * The demotion gates (#1631 dependency-drift, #1641 past-EOF) move a record
+ * out of the authoritative blocker channel and into the advisory channel.
+ * Until this module existed they changed the CHANNEL and nothing else: the
+ * advisory embedded the blocker body verbatim, so the agent still read
+ * "🔴 STOP — 11 issue(s) must be fixed" with dead line numbers under two
+ * hedge lines it ignored. Live evidence (session 01a0234c, 2026-08-21): the
+ * agent spent four re-run detours and about 7.4k tokens on a record whose
+ * coordinates no longer existed, then explained an unrelated REAL blocker
+ * away as "mid-edit state" in the same session.
+ *
+ * The rule this module owns, once, for every gated surface: a demoted body
+ * loses its authority vocabulary and its dead coordinates, and it says so in
+ * its own words. `clients/finding-delivery-gate.ts` documents the surrounding
+ * contract; this is the one implementation of its "Demotion rendering" arm
+ * for surfaces that carry a RENDERED BODY rather than a per-diagnostic row.
+ * Per-row surfaces (`widget-state.ts`, `tools/lens-diagnostics.ts`) already
+ * swap the coordinate for `PAST_EOF_STALE_MARKER` at render time and have no
+ * body to degrade.
+ *
+ * Pure and leaf: no store, no coordinator, no I/O. The caller supplies the
+ * dead lines it already computed while deciding to demote, so this module
+ * never re-derives a verdict from rendered prose (the
+ * re-derivation-vs-correlation screen).
+ */
+/** Suffix that replaces a cited coordinate the file no longer has. */
+export const DEAD_LINE_ANNOTATION = "(line no longer exists)";
+/**
+ * Authority vocabulary a demoted body must not carry, with its degraded
+ * replacement. Ordered: the full banner rewrite runs first so the narrower
+ * fallbacks only ever see text the banner rule did not already cover.
+ *
+ * This table is the single source of truth for the rule. A surface must not
+ * hand-roll its own "strip the STOP" pass — that is how #1631, #1641, and
+ * #1664 each ended up with a different answer to the same question.
+ *
+ * POSITION-ANCHORED (#1944 review F1). These patterns run over the BANNER
+ * region only, never the whole body. Diagnostic messages are arbitrary text
+ * from arbitrary runners, and they legitimately contain both tokens: the
+ * reviewer's probe turned ts(2304) `Cannot find name 'STOP'` into `Cannot
+ * find name 'Previously flagged'`, and mangled an English "must be fixed"
+ * inside a rule message. Rewriting a finding's own words is a worse defect
+ * than the banner it was cleaning up. See `splitBannerRegion`.
+ */
+const AUTHORITY_REWRITES = [
+    [
+        /[^\S\n]*(?:🔴|⛔|❌)?[^\S\n]*STOP[^\S\n]*[—–-][^\S\n]*(\d+)[^\S\n]+issue\(s\)[^\S\n]+must be fixed:?/g,
+        "$1 issue(s) were flagged before this file changed; the coordinates below may no longer exist:",
+    ],
+    [/(?:🔴|⛔|❌)[^\S\n]*STOP\b[^\S\n]*[—–-]?/g, "Previously flagged —"],
+    [/\bSTOP\b/g, "Previously flagged"],
+    [/\bmust be fixed\b/g, "were flagged"],
+];
+/** `  L310: message` / `L310 message` at the head of a rendered row. */
+const CITED_LINE_RE = /^([^\S\n]*)L(\d+)\b/;
+/**
+ * Split a rendered body into its BANNER region and its CONTENT region
+ * (#1944 review F1).
+ *
+ * The body this module degrades is `InlineBlockerRecord.summary`, and its one
+ * producer is `formatDiagnostics(inlineBlockers, "blocking")`
+ * (`clients/dispatch/utils/format-utils.ts`), reaching the store as
+ * `dispatchResult.blockerOutput` -> `PipelineResult.inlineBlockerSummary` ->
+ * `recordInlineBlockers`. (`buildEnrichedBlockerOutput` in
+ * `clients/pipeline.ts` renders the same shape with code snippets, but it
+ * feeds the TOOL-RESULT output shown inline during the write, not this
+ * stored summary. #1944 review round: naming it here as a producer was
+ * wrong.) The shape is a header, then one `  L<n>: <message>` row per
+ * diagnostic, then indented continuations (`💡 Fix: …`) and an optional
+ * `… and N more` tail. So the first cited-line row is the boundary:
+ * everything above it is ours to rewrite, everything from it down is the
+ * findings' own words.
+ *
+ * A body with no cited row at all — `formatDiagnostics` omits `L<n>` for a
+ * lineless diagnostic — falls back to the first NON-BLANK line. Leading
+ * blanks must be skipped rather than counted (#1944 verify round, Edge-D):
+ * `formatDiagnostics` opens its output with a newline, so a naive "first
+ * line is the banner" rule degrades an empty string and leaves the real
+ * header at full authority. Production is currently saved from that only by
+ * an undocumented `.trim()` at `clients/pipeline.ts` (`inlineBlockerSummary`),
+ * and this module claims to own the rule, so it must hold on its own input.
+ */
+function splitBannerRegion(lines) {
+    const firstCitedRow = lines.findIndex((line) => CITED_LINE_RE.test(line));
+    if (firstCitedRow !== -1)
+        return { bannerEnd: firstCitedRow };
+    const firstNonBlank = lines.findIndex((line) => line.trim() !== "");
+    return { bannerEnd: firstNonBlank === -1 ? 0 : firstNonBlank + 1 };
+}
+/**
+ * Degrade one demoted finding's rendered body.
+ *
+ * Two independent transforms, deliberately separable so each can be proven by
+ * its own test (and so deleting either one reds a different assertion):
+ *
+ *   1. Authority vocabulary: the STOP banner and the "must be fixed"
+ *      imperative are rewritten to past-tense, non-directive wording.
+ *   2. Dead coordinates: every cited `L<n>` whose line the file no longer has
+ *      renders as `L<n> (line no longer exists)`. The message text stays —
+ *      demote, never drop (#1419).
+ */
+export function degradeDemotedFindingBody(summary, options = {}) {
+    const deadLines = new Set(options.deadLines ?? []);
+    let authorityMarkersRemoved = 0;
+    const sourceLines = summary.split("\n");
+    const { bannerEnd } = splitBannerRegion(sourceLines);
+    const degradedLines = sourceLines.map((line, index) => {
+        // Content rows keep every character. Only the banner region is ours.
+        if (index >= bannerEnd)
+            return line;
+        let rewritten = line;
+        for (const [pattern, replacement] of AUTHORITY_REWRITES) {
+            rewritten = rewritten.replace(pattern, (...args) => {
+                authorityMarkersRemoved += 1;
+                // Expand `$n` against this match's capture groups by hand. A nested
+                // `String.replace` with the SAME global regex would clobber the
+                // outer call's `lastIndex` mid-iteration.
+                return replacement.replace(/\$(\d)/g, (_, digit) => String(args[Number(digit)] ?? ""));
+            });
+        }
+        return rewritten;
+    });
+    let body = degradedLines.join("\n");
+    const deadLinesAnnotated = [];
+    if (deadLines.size > 0) {
+        body = degradedLines
+            .map((line) => {
+            const hit = CITED_LINE_RE.exec(line);
+            if (!hit)
+                return line;
+            const cited = Number.parseInt(hit[2] ?? "", 10);
+            if (!Number.isFinite(cited) || !deadLines.has(cited))
+                return line;
+            deadLinesAnnotated.push(cited);
+            return `${hit[1] ?? ""}L${cited} ${DEAD_LINE_ANNOTATION}${line.slice(hit[0].length)}`;
+        })
+            .join("\n");
+    }
+    return { body, authorityMarkersRemoved, deadLinesAnnotated };
+}
+/**
+ * The one-line note a surface appends when it RETIRES a demoted finding after
+ * its single degraded delivery. Rendered inside the advisory itself, so an
+ * empty advisory section can only ever mean "nothing to say" — if something
+ * was dropped, this line is in the payload (#1944 AC3).
+ */
+export function formatRetirementNote(deadLines) {
+    const cited = deadLines.length > 0
+        ? ` (cited ${deadLines.length === 1 ? "line" : "lines"} ${deadLines.join(", ")})`
+        : "";
+    return (`Retired after this delivery${cited}: the file no longer has these lines, ` +
+        "so this finding cannot be re-confirmed and will not be served again.");
+}

package/dist/clients/dependency-checker.js

@@ -55,8 +55,7 @@ export function parseMadgeSkips(stderr) {
     const headerIdx = lines.findIndex((l) => /Skipped\s+\d+\s+file/i.test(l));
     if (headerIdx === -1)
         return { total: 0, local: [] };
-    const total = Number.parseInt(lines[headerIdx].match(/Skipped\s+(\d+)/i)?.[1] ?? "0", 10) ||
-        0;
+    const total = Number.parseInt(lines[headerIdx].match(/Skipped\s+(\d+)/i)?.[1] ?? "0", 10) || 0;
     const specifiers = lines
         .slice(headerIdx + 1)
         .map((l) => l.trim())
@@ -203,9 +202,7 @@ export class DependencyChecker {
     // next time the registry is walked.
     static instances = new Set();
     constructor(verbose = false) {
-        this.log = verbose
-            ? createSubsystemLogger("deps")
-            : () => { };
+        this.log = verbose ? createSubsystemLogger("deps") : () => { };
         DependencyChecker.instances.add(new WeakRef(this));
     }
     /** Drop this instance's memoized madge resolution for every project root. */
@@ -435,7 +432,9 @@ export class DependencyChecker {
         const cached = this.importCache.get(normalized);
         // Fast path: neither mtime NOR size moved (#1105 — size guards the
         // mtime-preserving content change that mtime alone would miss).
-        if (cached && cached.timestamp >= stat.mtimeMs && cached.size === stat.size) {
+        if (cached &&
+            cached.timestamp >= stat.mtimeMs &&
+            cached.size === stat.size) {
             return false;
         }
         // Compare actual imports
@@ -567,7 +566,12 @@ export class DependencyChecker {
             if (skips.local.length > 0) {
                 this.log(`madge skipped ${skips.local.length} local file(s) (possible silent cycle-miss): ${skips.local.slice(0, 5).join(", ")}`);
             }
-            return { ok: true, circular, circularFiles, localSkips: skips.local.length };
+            return {
+                ok: true,
+                circular,
+                circularFiles,
+                localSkips: skips.local.length,
+            };
         }
         catch (err) {
             this.log(`Check error: ${err.message}`);

package/dist/clients/deps/pi-tui.js

@@ -1,6 +1,12 @@
 /**
- * Centralized accessor for `@earendil-works/pi-tui`. See ./typescript.ts for the
- * rationale. (pi-tui is a pi-bundled core package, host-provided at runtime.)
+ * Centralized accessor for `@earendil-works/pi-tui`, routed through here for a
+ * uniform dep surface. pi-tui is a pi-bundled core package: the host resolves
+ * the bare specifier from its own runtime, so pi-lens declares it as an OPTIONAL
+ * peer plus a devDependency and never as a runtime dependency. A runtime
+ * dependency makes `npm install --omit=dev` vendor a private second copy that
+ * Node evaluates at import — ~97ms of the 838ms git-install module import in
+ * #1926. `scripts/lib/host-provided-deps.mjs` holds the list, and
+ * `tests/packaging.test.ts` pins the declaration.
  *
  * Re-export named bindings, not `export *`: with the package kept external, a
  * wildcard re-export leaves the namespace undefined at runtime under the bundle.

package/dist/clients/deps/typebox.js

@@ -1,7 +1,12 @@
 /**
- * Centralized accessor for `typebox`. See ./typescript.ts for the rationale.
- * (typebox is a pi-bundled core package, so it resolves from the host at
- * runtime -- but it's still routed through here for a uniform dep surface.)
+ * Centralized accessor for `typebox`, routed through here for a uniform dep
+ * surface. typebox is a pi-bundled core package: the host resolves the bare
+ * specifier from its own runtime, so pi-lens declares it as an OPTIONAL peer
+ * plus a devDependency and never as a runtime dependency. A runtime dependency
+ * makes `npm install --omit=dev` vendor a private second copy that Node
+ * evaluates at import — 688 files, ~400ms of the 838ms git-install module
+ * import in #1926. `scripts/lib/host-provided-deps.mjs` holds the list, and
+ * `tests/packaging.test.ts` pins the declaration.
  *
  * Re-export named bindings, not `export *`: with the package kept external, a
  * wildcard re-export leaves the namespace undefined at runtime under the bundle.

package/dist/clients/diagnostic-dispositions.js

@@ -171,6 +171,35 @@ export function _setBeforeDispositionCacheRefreshForTests(hook) {
 export function _setDispositionStatForTests(statSync) {
     dispositionStatSync = statSync ?? fs.statSync;
 }
+/**
+ * Zero-I/O guard for cache-only callers (lens_diagnostics delta/all): true
+ * when ANY disposition mark or session defer exists, so a caller can skip its
+ * whole strict/weak filter — including every file stat/read the strict branch
+ * would need — in the overwhelmingly common no-marks case. Same hoist shape as
+ * applyDispositionsMultiFile's #1625 F2 empty-store early return; `readState`
+ * is mtime+size stat-cached, so repeated calls cost one stat.
+ */
+export function hasAnyDispositionMarks(cwd) {
+    return Boolean(readState(cwd).dispositions) || deferredThisSession.size > 0;
+}
+/**
+ * True when the project's disposition store holds at least one STRICT-anchored
+ * `false-positive` mark — the only disposition kind whose immediate application
+ * needs file content. A store with only weak suppress/defer marks can never
+ * produce a strict-anchor match, so cache-only callers can serve them through
+ * the zero-I/O weak filter and skip every stat/read the strict path would
+ * charge.
+ */
+export function hasStrictDispositionMarks(cwd) {
+    const dispositions = readState(cwd).dispositions;
+    if (!dispositions)
+        return false;
+    for (const key of Object.keys(dispositions)) {
+        if (dispositions[key]?.disposition === "false-positive")
+            return true;
+    }
+    return false;
+}
 // Test seam for `applyDispositionsMultiFile`'s per-group content read (#1625
 // F2) — Vitest can't `vi.spyOn` a bare ESM `node:fs` named export directly
 // ("Module namespace is not configurable in ESM"), so the F2 regression test
@@ -191,7 +220,13 @@ function readState(cwd) {
             return stateCache.state;
         }
         const empty = {};
-        stateCache = { path: p, missing: true, mtimeMs: -1, size: -1, state: empty };
+        stateCache = {
+            path: p,
+            missing: true,
+            mtimeMs: -1,
+            size: -1,
+            state: empty,
+        };
         return empty;
     }
     if (stateCache &&
@@ -205,7 +240,9 @@ function readState(cwd) {
     try {
         const parsed = JSON.parse(fs.readFileSync(p, "utf-8"));
         state =
-            parsed && typeof parsed === "object" ? parsed : {};
+            parsed && typeof parsed === "object"
+                ? parsed
+                : {};
     }
     catch {
         // Now that writeState is tmp+rename atomic, a torn read (another process

package/dist/clients/diagnostic-line-freshness.js

@@ -228,7 +228,11 @@ export function demotePastEofDiagnostics(args) {
             return d; // no transition either direction
         if (isPastEof)
             risingEdgeLines.push(d.line);
-        return { ...d, stale: isPastEof, staleReason: isPastEof ? "past-eof" : undefined };
+        return {
+            ...d,
+            stale: isPastEof,
+            staleReason: isPastEof ? "past-eof" : undefined,
+        };
     });
     if (risingEdgeLines.length === 0) {
         return { diagnostics: out, demotedCount: 0 };

package/dist/clients/dispatch/auxiliary-lsp.js

@@ -55,8 +55,7 @@ export function isNosemgrepSuppressed(d, content) {
             .includes(ruleId);
     };
     // The finding's own line (inline OK), then the line above (standalone comment only).
-    return (checkLine(lines[startLine], false) ||
-        checkLine(lines[startLine - 1], true));
+    return (checkLine(lines[startLine], false) || checkLine(lines[startLine - 1], true));
 }
 /**
  * zizmor's own native inline suppression: `# zizmor: ignore[audit-id[,audit-id]]`
@@ -91,7 +90,7 @@ export function isZizmorIgnoreSuppressed(d, content) {
 // findings block only when the workspace opted into curated/authored rules;
 // everything else stays advisory) — shared here instead of copy-pasted per
 // profile so a future policy change (e.g. a WARNING-blocking tier) is one edit.
-const blockOnErrorWhenAllowed = (d, { blockingAllowed }) => (blockingAllowed && d.severity === 1 ? "blocking" : "warning");
+const blockOnErrorWhenAllowed = (d, { blockingAllowed }) => blockingAllowed && d.severity === 1 ? "blocking" : "warning";
 export const AUXILIARY_LSP_PROFILES = [
     {
         serverId: "opengrep",

package/dist/clients/dispatch/dispatcher.js

@@ -36,6 +36,7 @@ import { getToolPlan } from "./plan.js";
 import { resolveRunnerPath } from "./runner-context.js";
 import { applyRulePolicy, rulePolicyMapFromConfig } from "./rule-policy.js";
 import { getToolProfile } from "./tool-profile.js";
+import { isRunnerSkipReason } from "./types.js";
 import { formatDiagnostics } from "./utils/format-utils.js";
 // --- Runner Registry ---
 export class RunnerRegistry {
@@ -606,6 +607,12 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
         onRunnerResult?.(runnerId, result);
         const runnerEnd = Date.now();
         const duration = runnerEnd - runnerStart;
+        // Runner definitions are a typed API, but embedders/plugins can still
+        // return untyped objects at runtime. Admit only the closed taxonomy and
+        // only on actual skips so free text cannot enter durable latency metadata.
+        const skipReason = result.status === "skipped" && isRunnerSkipReason(result.skipReason)
+            ? result.skipReason
+            : undefined;
         latencies.push({
             runnerId,
             startTime: runnerStart,
@@ -614,6 +621,9 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
             status: result.status,
             diagnosticCount: result.diagnostics.length,
             semantic: result.semantic ?? semantic,
+            ...(skipReason !== undefined && {
+                skipReason,
+            }),
             ...(result.unconfirmedServerIds !== undefined && {
                 unconfirmedServerIds: result.unconfirmedServerIds,
             }),
@@ -640,7 +650,9 @@ async function runGroup(ctx, group, registry, onRunnerResult) {
                     failureKind: result.failureKind,
                     failureMessage: result.failureMessage,
                 }
-                : undefined,
+                : skipReason
+                    ? { skipReason }
+                    : undefined,
         });
         recordRunner(ctx.filePath, runnerId, result.status, result.diagnostics.length, duration, ctx.writeIndex);
         diagnostics.push(...result.diagnostics);

package/dist/clients/dispatch/facts/function-facts.js

@@ -76,7 +76,9 @@ function parameterName(param) {
     // JavaScript's grammar keeps a leaf parameter as the identifier itself;
     // there is no named child to unwrap. TypeScript parameter wrapper nodes still
     // use their first named child (type annotation/default/rest target).
-    return param.type === "identifier" ? param.text : firstNamedChild(param)?.text ?? "";
+    return param.type === "identifier"
+        ? param.text
+        : (firstNamedChild(param)?.text ?? "");
 }
 function getFunctionName(node) {
     if (node.type === "function_declaration") {

package/dist/clients/dispatch/facts/import-facts.js

@@ -122,7 +122,8 @@ export const importFactProvider = {
                     if (callee?.type === "import") {
                         dynamicRaw.push({ source, kind: "import" });
                     }
-                    else if (callee?.type === "identifier" && callee.text === "require") {
+                    else if (callee?.type === "identifier" &&
+                        callee.text === "require") {
                         dynamicRaw.push({ source, kind: "require" });
                         hasCjs = true;
                     }

package/dist/clients/dispatch/facts/tree-sitter-facts.js

@@ -8,7 +8,7 @@
  * shell.
  */
 import { childrenOfType, firstChildOfType, withTreeSitterRoot, walk, } from "../../tree-sitter-shared.js";
-export { childrenOfType, firstChildOfType, walk, };
+export { childrenOfType, firstChildOfType, walk };
 export const withFactTree = withTreeSitterRoot;
 /**
  * Provider shell for tree-sitter-backed fact extractors: read `file.content`,

package/dist/clients/dispatch/integration.js

@@ -789,7 +789,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                         action: "reused_unchanged",
                         savedToSnapshot: reverseDepsSaved,
                         importsFileCount: Object.keys(reverseDepsIndex.imports).length,
-                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy).length,
+                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy)
+                            .length,
                     },
                 });
             }
@@ -841,7 +842,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                         action: "refresh_from_review_graph",
                         savedToSnapshot: reverseDepsSaved,
                         importsFileCount: Object.keys(reverseDepsIndex.imports).length,
-                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy).length,
+                        importedByFileCount: Object.keys(reverseDepsIndex.importedBy)
+                            .length,
                         importEdgeCount: Object.values(reverseDepsIndex.imports).reduce((total, imports) => total + imports.length, 0),
                     },
                 });
@@ -1517,7 +1519,9 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
                 // #1179: `.filter()` here operates on `rawDiags.diags`; the
                 // `inconclusive`/`binding` flags read above stay on the `rawDiags`
                 // wrapper and are unaffected by this copy (the shape-5 fix).
-                const diags = convertLspDiagnostics(rawDiags.diags.filter((d) => d.severity === 1).slice(0, MAX_PER_FILE), neighborPath);
+                const diags = convertLspDiagnostics(rawDiags.diags
+                    .filter((d) => d.severity === 1)
+                    .slice(0, MAX_PER_FILE), neighborPath);
                 const durationMs = Date.now() - neighborStart;
                 // #1899: the A5 same-write cache write stood here.
                 if (diags.length === 0) {
@@ -1827,7 +1831,8 @@ export async function computeCascadeForFile(filePath, cwd, options = {}) {
             if (entry.idleTimer !== undefined)
                 clearTimeout(entry.idleTimer);
             entry.idleTimer = undefined;
-            if (!reverseDepsTimersToRelease.has(key) && reverseDepsEntriesAtStart.has(entry)) {
+            if (!reverseDepsTimersToRelease.has(key) &&
+                reverseDepsEntriesAtStart.has(entry)) {
                 reverseDepsTimersToRelease.add(key);
             }
         }

package/dist/clients/dispatch/rules/error-swallowing.js

@@ -10,7 +10,9 @@ export const errorSwallowingRule = {
             return [];
         const diagnostics = [];
         for (const s of summaries) {
-            if (s.isEmpty && !s.isDocumentedLocalFallback && s.boundaryCategory !== "fs") {
+            if (s.isEmpty &&
+                !s.isDocumentedLocalFallback &&
+                s.boundaryCategory !== "fs") {
                 diagnostics.push({
                     id: `error-swallowing:${ctx.filePath}:${s.line}:${s.column}`,
                     tool: "fact-rules",

package/dist/clients/dispatch/rules/pass-through-wrappers.js

@@ -1,7 +1,9 @@
 import { isTestFile } from "../../file-utils.js";
 const ALIAS_COMMENT_RE = /\b(alias|backward\s*compat|backwards\s*compat|compatibility|shim|adapter)\b/i;
 function hasAliasCommentNear(line, comments) {
-    return comments.some((comment) => comment.line >= line - 2 && comment.line <= line && ALIAS_COMMENT_RE.test(comment.text));
+    return comments.some((comment) => comment.line >= line - 2 &&
+        comment.line <= line &&
+        ALIAS_COMMENT_RE.test(comment.text));
 }
 export const passThroughWrappersRule = {
     id: "pass-through-wrappers",
@@ -16,7 +18,9 @@ export const passThroughWrappersRule = {
             return [];
         const diagnostics = [];
         for (const fn of summaries) {
-            if (!fn.isPassThroughWrapper || fn.statementCount !== 1 || fn.isBoundaryWrapper) {
+            if (!fn.isPassThroughWrapper ||
+                fn.statementCount !== 1 ||
+                fn.isBoundaryWrapper) {
                 continue;
             }
             if (hasAliasCommentNear(fn.line, comments))

package/dist/clients/dispatch/rules/unsafe-boundary.js

@@ -10,16 +10,40 @@
 // All other entries are exact callee names — prevents e.g. "spawn" matching "spawned.map"
 // or "fetch" matching "fetchWithRetry".
 const IO_NAMESPACE_PREFIXES = [
-    "db.", "prisma.", "knex.", "mongoose.", "sequelize.",
-    "http.", "https.", "net.", "dns.",
-    "redis.", "mongo.", "pg.", "mysql.",
-    "s3.", "storage.", "bucket.",
+    "db.",
+    "prisma.",
+    "knex.",
+    "mongoose.",
+    "sequelize.",
+    "http.",
+    "https.",
+    "net.",
+    "dns.",
+    "redis.",
+    "mongo.",
+    "pg.",
+    "mysql.",
+    "s3.",
+    "storage.",
+    "bucket.",
     "fs.promises.",
 ];
 const IO_EXACT_CALLEES = new Set([
-    "fetch", "axios", "got", "request",
-    "spawn", "exec", "execSync", "spawnSync",
-    "readFile", "writeFile", "appendFile", "readdir", "mkdir", "unlink", "stat",
+    "fetch",
+    "axios",
+    "got",
+    "request",
+    "spawn",
+    "exec",
+    "execSync",
+    "spawnSync",
+    "readFile",
+    "writeFile",
+    "appendFile",
+    "readdir",
+    "mkdir",
+    "unlink",
+    "stat",
 ]);
 const CC_THRESHOLD = 6; // raised from 4 — avoids flagging simple async wrappers with one IO call
 function callsToBoundary(outgoingCalls) {

package/dist/clients/dispatch/runners/actionlint.js

@@ -12,7 +12,10 @@ function toDiagnostic(issue, filePath) {
     const column = issue.column && issue.column > 0 ? issue.column : 1;
     const rule = issue.kind || "actionlint";
     const message = issue.message || "GitHub Actions workflow issue";
-    const idMessage = message.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 80);
+    const idMessage = message
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .slice(0, 80);
     return {
         id: `actionlint-${rule}-${line}-${column}-${idMessage}`,
         message,
@@ -66,7 +69,7 @@ const actionlintRunner = {
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
         let cmd = null;
-        if (await (actionlint.isAvailableAsync(cwd))) {
+        if (await actionlint.isAvailableAsync(cwd)) {
             cmd = actionlint.getCommand(cwd);
         }
         else {

package/dist/clients/dispatch/runners/biome-check.js

@@ -12,6 +12,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { biomeConfigArgs, getAutofixCapability, getJstsLintPolicyForCwd, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 /**
  * Map biome's own severity vocabulary onto the four-tier `Diagnostic.severity`
  * (clients/dispatch/types.ts), the same way `normalizeRuleSeverity` does for
@@ -254,7 +255,9 @@ const biomeCheckJsonRunner = {
                 diagnostics: [
                     {
                         id: "biome:parse-error:1",
-                        message: "Biome JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : ""),
+                        message: "Biome JSON parse failed: " +
+                            parsed.parseError +
+                            (preview ? " (output preview: " + preview + ")" : ""),
                         filePath: ctx.filePath,
                         line: 1,
                         column: 1,
@@ -266,19 +269,12 @@ const biomeCheckJsonRunner = {
                 semantic: "warning",
             };
         }
-        const diagnostics = parsed.diagnostics;
-        let semantic = "none";
-        if (diagnostics.some((d) => d.semantic === "blocking")) {
-            semantic = "blocking";
-        }
-        else if (diagnostics.length > 0) {
-            semantic = "warning";
-        }
-        return {
-            status: semantic === "blocking" ? "failed" : "succeeded",
-            diagnostics,
-            semantic,
-        };
+        return finishParsedRun({
+            tool: "biome",
+            ctx,
+            result: checkResult,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default biomeCheckJsonRunner;