@herbertgao/pi-extensions 2026.8.7 → 2026.8.8

package/node_modules/pi-lens/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/node_modules/pi-lens/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/node_modules/pi-lens/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/node_modules/pi-lens/dist/clients/dispatch/runners/detekt.js

@@ -4,7 +4,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const detekt = createAvailabilityChecker("detekt", ".bat");
 const DETEKT_CONFIG_CANDIDATES = [
     "detekt.yml",
@@ -146,11 +146,14 @@ const detektRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         const absPath = path.resolve(cwd, ctx.filePath);
         const result = await safeSpawnAsync(cmd, ["--input", absPath, "--config", configPath], { cwd, timeout: 60000 });
+        // #1948: detekt reports across both streams, so the gate and the parser
+        // read the same concatenated string. A nonzero exit that yields zero
+        // findings out of real output is a parser break, not clean Kotlin.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        if (spawnFailedWithNoOutput(result, raw)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseDetektOutput(raw, ctx.filePath);
+        const run = parseToolRun("detekt", { result, output: raw }, (out) => parseDetektOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -163,4 +166,4 @@ const detektRunner = {
     },
 };
 export default detektRunner;
-export { parseDetektOutput, DETEKT_FIXABLE_RULES };
+export { DETEKT_FIXABLE_RULES, parseDetektOutput };

package/node_modules/pi-lens/dist/clients/dispatch/runners/hadolint.js

@@ -3,7 +3,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const hadolint = createAvailabilityChecker("hadolint", ".exe");
 function parseHadolintOutput(raw, filePath) {
     try {
@@ -43,7 +43,7 @@ const hadolintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (hadolint.isAvailableAsync(cwd))) {
+        if (await hadolint.isAvailableAsync(cwd)) {
             cmd = hadolint.getCommand(cwd);
         }
         else {
@@ -53,11 +53,13 @@ const hadolintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-fail", path.resolve(cwd, ctx.filePath)], { cwd });
-        if (spawnFailedWithNoOutput(result)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const output = result.stdout || "";
-        const diagnostics = parseHadolintOutput(output, ctx.filePath);
+        // #1948: hadolint runs with `--no-fail`, so it exits 0 even when it finds
+        // something. A nonzero exit therefore means hadolint itself failed, and
+        // zero parsed diagnostics out of whatever it printed is a parser break.
+        const run = parseToolRun("hadolint", { result }, (out) => parseHadolintOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/htmlhint.js

@@ -3,7 +3,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const htmlhint = createAvailabilityChecker("htmlhint");
 const HTMLHINT_RULES = {
     "tag-pair": true,
@@ -55,7 +55,7 @@ const htmlhintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (htmlhint.isAvailableAsync(cwd))) {
+        if (await htmlhint.isAvailableAsync(cwd)) {
             cmd = htmlhint.getCommand(cwd);
         }
         else {
@@ -72,11 +72,13 @@ const htmlhintRunner = {
             "unix",
             path.resolve(cwd, ctx.filePath),
         ], { cwd });
+        // #1948: htmlhint exits 1 when it finds errors and prints them in `unix`
+        // format on stdout. Zero parsed out of a nonzero exit is a parser break.
         const output = result.stdout || result.stderr || "";
-        if (spawnFailedWithNoOutput(result, output)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseHtmlhintOutput(output, ctx.filePath);
+        const run = parseToolRun("htmlhint", { result, output }, (out) => parseHtmlhintOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/markdownlint.js

@@ -2,7 +2,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, markdownlintConfigArgs, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const markdownlint = createAvailabilityChecker("markdownlint-cli2", ".cmd");
 // markdownlint-cli2 exit codes (its README's "Exit Codes" section): 0 = no
 // findings, 1 = lint findings, 2 = unexpected error (unreadable config, bad
@@ -98,7 +98,7 @@ const markdownlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (markdownlint.isAvailableAsync(cwd))) {
+        if (await markdownlint.isAvailableAsync(cwd)) {
             cmd = markdownlint.getCommand(cwd);
         }
         else {
@@ -118,14 +118,12 @@ const markdownlintRunner = {
         // reported as a clean Markdown file. An empty result must distinguish
         // clean from errored.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("markdownlint", {
-            result,
-            output: raw,
-            exitCodes: MARKDOWNLINT_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseMarkdownlintOutput(raw, ctx.filePath);
+        // #1948: one seam for both gates — the tool produced nothing, and the
+        // tool produced something the parser could not read.
+        const run = parseToolRun("markdownlint", { result, output: raw, exitCodes: MARKDOWNLINT_EXIT_CODES }, (out) => parseMarkdownlintOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/mypy.js

@@ -3,7 +3,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { hasMypyConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const mypy = createAvailabilityChecker("mypy", "");
 // mypy exit codes: 0 = no type errors, 1 = type errors found, 2 = a blocking
 // error. 2 is NOT a rejected invocation on its own — mypy reports a source
@@ -67,7 +67,7 @@ const mypyRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (mypy.isAvailableAsync(cwd))) {
+        if (await mypy.isAvailableAsync(cwd)) {
             cmd = mypy.getCommand(cwd);
         }
         else {
@@ -81,14 +81,14 @@ const mypyRunner = {
         // stdout only (see MYPY_EXIT_CODES) so an exit-2 SYNTAX error, which
         // does write a diagnostic there, still reaches the parser.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("mypy", {
-            result,
-            output: result.stdout,
-            exitCodes: MYPY_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseMypyOutput(raw, ctx.filePath, cwd);
+        // #1948: `parseOutput` keeps the split this runner already had — the gate
+        // judges "did it run" on stdout alone, the parser still reads both
+        // streams — so adding the parsed-nothing record does not widen the
+        // did-it-run verdict.
+        const run = parseToolRun("mypy", { result, output: result.stdout, exitCodes: MYPY_EXIT_CODES }, (out) => parseMypyOutput(out, ctx.filePath, cwd), { parseOutput: raw });
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/oxlint.js

@@ -76,10 +76,13 @@ const oxlintRunner = {
         const result = await safeSpawnAsync(cmd, args, {
             timeout: 30000,
         });
-        // Oxlint returns non-zero when issues found
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
+        // Oxlint exits 0 whenever nothing at ERROR severity was found — that
+        // includes a run that found only warnings, its own default severity
+        // (#1947). A run that found nothing at all also exits 0, but still
+        // prints a report with an empty `diagnostics` array, so parsing
+        // unconditionally and branching on the parsed count (below) tells the
+        // two apart instead of the exit code discarding the warning case.
+        //
         // Parse JSON output. Fall back to the unix-format parser if JSON parsing
         // fails (older oxlint versions, malformed stderr noise, etc.) — keeps the
         // runner producing diagnostics even when the structured-fix metadata is
@@ -94,8 +97,20 @@ const oxlintRunner = {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
         const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+        // A warning-only result on exit 0 is oxlint's normal outcome, not a
+        // failure: exit 0 means nothing hit ERROR severity. `status: "failed"`
+        // here would stop this arm from reporting "succeeded", which breaks two
+        // things downstream — plan.ts's ["eslint", "oxlint", "biome-check-json"]
+        // fallback group only stops at the first `status: "succeeded"` runner
+        // (dispatcher.ts's `runGroup`), so biome-check-json would run again on
+        // every warning-only save (extra spawns, a possible install, duplicate
+        // findings); and it would mismatch the sibling convention (biome-check,
+        // golangci-lint, rubocop) of keying `status` off blocking severity, not
+        // off the tool's raw exit code. The findings themselves still reach the
+        // delivery pipeline regardless of `status` — dispatcher.ts buckets by
+        // each diagnostic's own `semantic`, so a warning stays a warning.
         return {
-            status: "failed",
+            status: !hasBlocking && result.status === 0 ? "succeeded" : "failed",
             diagnostics,
             semantic: hasBlocking ? "blocking" : "warning",
         };

package/node_modules/pi-lens/dist/clients/dispatch/runners/phpstan.js

@@ -3,6 +3,11 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasPhpstanConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveVendorToolCommand, } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+// phpstan's documented exit codes: 0 = no errors, 1 = errors found, 2 = a
+// fatal/internal error that stopped the analysis. Only 1 is a run that carries
+// findings.
+const PHPSTAN_EXIT_CODES = { ran: [1] };
 const phpstan = createAvailabilityChecker("phpstan", ".phar");
 // phpstan analyses the target file PLUS its dependency closure and keys errors
 // by the real file in `output.files`. Attribute each diagnostic to that key
@@ -19,7 +24,7 @@ export function parsePhpstanJson(raw, fallbackPath, cwd) {
                     ? file
                     : path.resolve(cwd, file)
                 : fallbackPath;
-            for (const err of fileErrors.errors ?? []) {
+            for (const err of fileErrors?.messages ?? []) {
                 diagnostics.push({
                     id: `phpstan:${err.line ?? 1}:${err.message.slice(0, 40)}`,
                     message: err.message,
@@ -29,11 +34,38 @@ export function parsePhpstanJson(raw, fallbackPath, cwd) {
                     severity: "error",
                     semantic: "blocking",
                     tool: "phpstan",
-                    rule: "phpstan",
+                    rule: err.identifier || "phpstan",
                     fixable: false,
                 });
             }
         }
+        // #1937 round 2: the top-level `errors[]` array carries phpstan's
+        // FILE-INDEPENDENT findings — internal errors, and ignore patterns that
+        // matched nothing. A run can report `totals.errors: 1` with `files: {}`
+        // and exit 1, and reading only `files` turned that into zero
+        // diagnostics: the same defect class as the `errors`-vs-`messages` bug
+        // above, one level up. Pinned by
+        // tests/fixtures/runner-output/phpstan/top-level-errors.captured.json.
+        //
+        // These have no file or line, so they attach to the edited file at line
+        // 1. That is the honest placement: the reader needs to see them, and
+        // there is nowhere truer to put them.
+        for (const message of output.errors ?? []) {
+            if (typeof message !== "string" || !message.trim())
+                continue;
+            diagnostics.push({
+                id: `phpstan:global:${message.slice(0, 40)}`,
+                message,
+                filePath: fallbackPath,
+                line: 1,
+                column: 1,
+                severity: "error",
+                semantic: "blocking",
+                tool: "phpstan",
+                rule: "phpstan/analysis",
+                fixable: false,
+            });
+        }
         return diagnostics;
     }
     catch {
@@ -41,7 +73,7 @@ export function parsePhpstanJson(raw, fallbackPath, cwd) {
     }
 }
 async function resolvePhpstan(cwd) {
-    if (await (phpstan.isAvailableAsync(cwd)))
+    if (await phpstan.isAvailableAsync(cwd))
         return phpstan.getCommand(cwd);
     return resolveVendorToolCommand(cwd, "phpstan", ".bat");
 }
@@ -66,14 +98,15 @@ const phpstanRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         const absPath = path.resolve(cwd, ctx.filePath);
         const result = await safeSpawnAsync(cmd, ["analyse", "--error-format=json", "--no-progress", absPath], { timeout: 30000, cwd });
-        // phpstan exits 0 = no errors, 1 = errors found, 2 = fatal
-        if (result.status === 2 || result.error) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parsePhpstanJson(result.stdout ?? "", ctx.filePath, cwd);
+        // phpstan exits 0 = no errors, 1 = errors found, 2 = fatal. The fatal
+        // case used to return `skipped` silently; routing it through the shared
+        // seam keeps that verdict and adds the bounded `runner-empty-result` row
+        // (#1816), and the exit-1 case now also records when the JSON report
+        // parses to nothing (#1948) — the shape the error-count-as-array bug had.
+        const run = parseToolRun("phpstan", { result, exitCodes: PHPSTAN_EXIT_CODES }, (out) => parsePhpstanJson(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/spellcheck.js

@@ -18,10 +18,10 @@
  * Install: cargo install typos-cli
  * Or: npm install -g typos-cli (if wrapped)
  */
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const typos = createAvailabilityChecker("typos", ".exe");
 // typos-cli exit codes: 0 = no typos, 2 = typos found, 1 = an error that
 // stopped the scan. Anything nonzero outside {2} is a rejected invocation.
@@ -98,20 +98,15 @@ const spellcheckRunner = {
         // (unreadable config, bad argument). The `status === 2 || stdout` test
         // below is false for exit 1 with an empty stdout, so a failed run was
         // reported as a clean file. Only 0 and 2 are runs.
-        const skipped = skipUnlessToolRan("spellcheck", {
-            result,
-            exitCodes: TYPOS_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        // typos-cli exits with code 2 if typos found, 0 if clean
-        const hasTypos = result.status === 2 || result.stdout?.trim();
-        if (!hasTypos) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse diagnostics
-        const raw = result.stdout + result.stderr;
-        const diagnostics = parseTyposOutput(raw, ctx.filePath);
+        //
+        // #1948: parse through the shared seam so an exit-2 run whose JSON lines
+        // yield nothing leaves a record. `parseOutput` keeps the historical
+        // split: the gate judges "did it run" on stdout, the parser reads both
+        // streams.
+        const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/node_modules/pi-lens/dist/clients/dispatch/runners/sqlfluff.js

@@ -2,7 +2,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasSqlfluffConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const sqlfluff = createAvailabilityChecker("sqlfluff", ".exe");
 // sqlfluff exit codes (its CLI docs): 0 = clean, 1 = violations found, 2 = a
 // user error that stopped the lint (unknown dialect, unreadable config).
@@ -127,7 +127,7 @@ const sqlfluffRunner = {
             ctx.log("sqlfluff: no config detected, using ANSI dialect defaults");
         }
         let cmd = null;
-        if (await (sqlfluff.isAvailableAsync(cwd))) {
+        if (await sqlfluff.isAvailableAsync(cwd)) {
             cmd = sqlfluff.getCommand(cwd);
         }
         else {
@@ -135,10 +135,19 @@ const sqlfluffRunner = {
         }
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
-        const args = ["lint", "--format", "json", ctx.filePath];
+        // #1937: this used to be `args.splice(2, 0, "--dialect", "ansi")` on
+        // `["lint", "--format", "json", file]`, which inserts BETWEEN the flag
+        // and its value and yields `lint --format --dialect ansi json file`.
+        // sqlfluff rejects `--dialect` as the value of `--format` and exits 2,
+        // so every SQL project WITHOUT a .sqlfluff — exactly the case this
+        // dialect default exists to serve — was never linted. Built in order
+        // rather than patched by index, and pinned by the argv-tie assertion
+        // in runners/captured-real-output.test.ts.
+        const args = ["lint", "--format", "json"];
         if (!hasConfig) {
-            args.splice(2, 0, "--dialect", "ansi");
+            args.push("--dialect", "ansi");
         }
+        args.push(ctx.filePath);
         const result = await safeSpawnAsync(cmd, args, {
             timeout: 20000,
             cwd,
@@ -146,13 +155,12 @@ const sqlfluffRunner = {
         // #1816: this runner read `result.status` zero times, so a user error
         // fell through `parseSqlfluffOutput`'s JSON catch to zero violations and
         // reported the SQL file as clean.
-        const skipped = skipUnlessToolRan("sqlfluff", {
-            result,
-            exitCodes: SQLFLUFF_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseSqlfluffOutput(result.stdout ?? "", ctx.filePath);
+        // #1948: sqlfluff exit 1 with a JSON report we read nothing out of is a
+        // parser break, not a clean file.
+        const run = parseToolRun("sqlfluff", { result, exitCodes: SQLFLUFF_EXIT_CODES }, (out) => parseSqlfluffOutput(out, ctx.filePath), { parseOutput: result.stdout ?? "" });
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }