@herbertgao/pi-extensions 2026.8.7 → 2026.8.9

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

@@ -3,7 +3,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasStylelintConfig, } 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 stylelint = createAvailabilityChecker("stylelint", ".cmd");
 // stylelint exit codes (its "Exit codes" docs page): 0 = no problems, 1 = a
 // fatal error, 2 = lint problems found, 78 = a configuration error.
@@ -12,11 +12,34 @@ const stylelint = createAvailabilityChecker("stylelint", ".cmd");
 // NOT a live stylelint: it is this repo's own hand-written fixture
 // (tests/clients/dispatch/runners/stylelint-fixable.test.ts), which reports
 // findings under exit 1. Rather than rewrite a fixture whose provenance is
-// unknown, the table keeps 1 permissive. That is safe because a genuinely
-// fatal stylelint under `--formatter json` writes nothing to stdout, so the
-// nothing-to-parse rule still catches it. 78 is the rejection this table
+// unknown, the table keeps 1 permissive. 78 is the rejection this table
 // exists to name.
+//
+// #1937 corrected the safety argument that used to sit here: it claimed a
+// fatal stylelint "writes nothing to stdout", which is true but useless,
+// because a stylelint that DID find problems writes nothing to stdout either.
+// `stylelintReport` below is what now separates the two.
 const STYLELINT_EXIT_CODES = { ran: [1, 2] };
+/**
+ * The JSON report out of a stylelint run, whichever stream carried it (#1937).
+ *
+ * stylelint 16+ writes the formatted report to STDERR whenever the run
+ * "errored" — which is every run that found an error-severity warning, i.e.
+ * every run with something to say. Reading stdout alone parsed nothing and
+ * called the stylesheet clean, the #1933 vale shape. Verified against
+ * stylelint 17.8.0 in tests/fixtures/runner-output/stylelint/.
+ *
+ * Only a stream that actually starts a JSON array counts. A crash's stack
+ * trace on stderr must stay "nothing to parse" so #1816's empty-result skip
+ * still fires instead of reporting a clean file.
+ */
+export function stylelintReport(stdout, stderr) {
+    for (const stream of [stdout, stderr]) {
+        if (stream?.trimStart().startsWith("["))
+            return stream;
+    }
+    return "";
+}
 // Stylelint's standard JSON output reports only aggregate fixableErrorCount /
 // fixableWarningCount per file — there is no per-warning fix flag in the CLI
 // surface. To route the actionable warnings here without a tool rewrite, we
@@ -104,7 +127,7 @@ const stylelintRunner = {
             ctx.log("stylelint: no config detected, running with default rules");
         }
         let cmd = null;
-        if (await (stylelint.isAvailableAsync(cwd))) {
+        if (await stylelint.isAvailableAsync(cwd)) {
             cmd = stylelint.getCommand(cwd);
         }
         else {
@@ -116,14 +139,13 @@ const stylelintRunner = {
         // #1816: this runner read `result.status` zero times, so an exit-78
         // config error (or an exit-1 crash) fell through parseStylelintJson's
         // catch to zero diagnostics and reported a clean stylesheet.
-        const skipped = skipUnlessToolRan("stylelint", {
-            result,
-            exitCodes: STYLELINT_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const raw = result.stdout ?? "";
-        const diagnostics = parseStylelintJson(raw, ctx.filePath);
+        const raw = stylelintReport(result.stdout, result.stderr);
+        // #1948: the stdout-vs-stderr report bug landed here as exit 2 plus a
+        // full JSON report and zero parsed warnings. That now leaves a record.
+        const run = parseToolRun("stylelint", { result, output: raw, exitCodes: STYLELINT_EXIT_CODES }, (out) => parseStylelintJson(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/swiftlint.js

@@ -2,7 +2,7 @@ import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.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 swiftlint = createAvailabilityChecker("swiftlint", ".exe");
 // SwiftLint rules whose rule class declares a `corrector` — i.e. rules that
 // `swiftlint --fix` rewrites deterministically. The JSON reporter does not
@@ -118,7 +118,7 @@ const swiftlintRunner = {
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
         let cmd = null;
-        if (await (swiftlint.isAvailableAsync(cwd))) {
+        if (await swiftlint.isAvailableAsync(cwd)) {
             cmd = swiftlint.getCommand(cwd);
         }
         else {
@@ -133,12 +133,12 @@ const swiftlintRunner = {
         // stably enough to call any of them a rejection, so classification
         // rests on the conservative rule — a nonzero exit with nothing to parse
         // never ran.
-        const skipped = skipUnlessToolRan("swiftlint", { result });
-        if (skipped)
-            return skipped;
-        // SwiftLint exits non-zero on violations — stdout still has the JSON
-        const raw = result.stdout || "";
-        const diagnostics = parseSwiftLintOutput(raw, ctx.filePath);
+        // SwiftLint exits non-zero on violations — stdout still has the JSON, so
+        // a nonzero exit whose JSON yields nothing is a parser break (#1948).
+        const run = parseToolRun("swiftlint", { result }, (out) => parseSwiftLintOutput(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/taplo.js

@@ -4,28 +4,101 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, lspPrimaryCoversFile, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const taplo = createAvailabilityChecker("taplo", ".exe");
-function parseTaploOutput(raw, filePath) {
-    try {
-        const parsed = JSON.parse(raw);
-        const errors = parsed.errors ?? [];
-        return errors.map((err, idx) => ({
-            id: `taplo-${err.kind}-${err.range?.start.line ?? idx}`,
-            message: `[${err.kind}] ${err.message}`,
+// Verified against taplo 0.10.0: 0 = clean, 1 = the file is invalid (lint
+// findings, or a schema it could not load), 2 = clap rejected the invocation.
+//
+// #1937 round 2: the parser fix alone turned the old silent-clean into a false
+// BLOCKING diagnostic. clap prints `error: unexpected argument '--output'
+// found`, which starts with the same lowercase `error:` a real taplo
+// diagnostic does, so a mistyped flag would have reddened every valid TOML
+// file. Both readings are wrong; the exit code is what separates them.
+const TAPLO_EXIT_CODES = { ran: [1] };
+/** `error: <summary>` or `warning: <summary>` at the head of a codespan block. */
+const HEADER_PATTERN = /^\s*(error|warning):(.*)$/;
+/** The box-drawing lead taplo puts on a codespan location line. */
+const LOCATION_LEAD = "┌─";
+/** The `:line:column` tail of a codespan location line. */
+const LOCATION_PATTERN = /:(\d+):(\d+)$/;
+/**
+ * Parse `taplo lint` output (#1937).
+ *
+ * This parser used to `JSON.parse` a `{ errors: [{ range, message, kind }] }`
+ * envelope that taplo has never emitted, fed by a `--output=json` flag taplo
+ * has never accepted. Real taplo rejected the flag with exit 2 and a usage
+ * error, the JSON parse threw, the catch returned [], and malformed TOML was
+ * reported clean. Same shape as the vale parser in #1933.
+ *
+ * Real taplo 0.10.0 writes codespan diagnostics to STDERR, interleaved with
+ * uppercase tracing lines:
+ *
+ *     error: invalid TOML
+ *       ┌─ /path/to/bad.toml:2:9
+ *       │
+ *     2 │   [package
+ *
+ * Verified against tests/fixtures/runner-output/taplo/real.captured.json.
+ *
+ * A header alone is NOT enough to emit a diagnostic. The codespan location
+ * line must follow it. clap's own failures start with the same lowercase
+ * `error:` and carry no location, so without that requirement a rejected
+ * invocation becomes a blocking finding on line 1 of a perfectly valid file
+ * (#1937 round 2). The exit-code table in the runner is the primary guard;
+ * this is the structural one, and each covers a case the other does not.
+ */
+export function parseTaploOutput(raw, filePath) {
+    const diagnostics = [];
+    const lines = (raw ?? "").split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        // Lowercase `error:`/`warning:` starts a diagnostic. taplo's tracing
+        // lines are uppercase (`ERROR taplo:lint_files: ...`), so a
+        // case-sensitive match keeps them out.
+        //
+        // Both patterns below trim in code rather than with a trailing `\s*`,
+        // and the location one tests for its box-drawing lead separately
+        // instead of skipping to it with `.*`. Either shape backtracks
+        // super-linearly on a long line, and this parser reads bytes a third
+        // party wrote.
+        const header = HEADER_PATTERN.exec(lines[i].trimEnd());
+        if (!header)
+            continue;
+        const severityWord = header[1];
+        const summary = header[2].trim();
+        if (!summary)
+            continue;
+        // The location arrives on a following `┌─ file:line:col` line. Scan a
+        // short window rather than assuming adjacency: taplo puts a gutter line
+        // between them in some layouts.
+        let line = null;
+        let column = 1;
+        for (let j = i + 1; j < Math.min(i + 4, lines.length); j++) {
+            if (!lines[j].includes(LOCATION_LEAD))
+                continue;
+            const location = LOCATION_PATTERN.exec(lines[j].trimEnd());
+            if (!location)
+                continue;
+            line = Number.parseInt(location[1], 10) || 1;
+            column = Number.parseInt(location[2], 10) || 1;
+            break;
+        }
+        if (line === null)
+            continue;
+        const severity = severityWord === "warning" ? "warning" : "error";
+        diagnostics.push({
+            id: `taplo-${severity}-${line}-${column}`,
+            message: summary,
             filePath,
-            line: (err.range?.start.line ?? 0) + 1,
-            column: (err.range?.start.col ?? 0) + 1,
-            severity: "error",
-            semantic: "blocking",
+            line,
+            column,
+            severity,
+            semantic: severity === "error" ? "blocking" : "warning",
             tool: "taplo",
-            rule: err.kind,
+            rule: `taplo/${severity}`,
             fixable: false,
-        }));
-    }
-    catch {
-        return [];
+        });
     }
+    return diagnostics;
 }
 const taploRunner = {
     id: "taplo",
@@ -57,7 +130,7 @@ const taploRunner = {
         // different extension, so it stays as the checker's fallback only.
         let cmd = findLocalBinUpwards("taplo", cwd) ?? null;
         if (!cmd) {
-            if (await (taplo.isAvailableAsync(cwd))) {
+            if (await taplo.isAvailableAsync(cwd)) {
                 cmd = taplo.getCommand(cwd);
             }
             else {
@@ -67,11 +140,25 @@ const taploRunner = {
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
         const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(cmd, ["check", "--output=json", absPath], { cwd, timeout: 15000 });
-        if (spawnFailedWithNoOutput(result)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseTaploOutput(result.stdout || "", ctx.filePath);
+        // #1937: `--output=json` is not a taplo flag. taplo rejected it with a
+        // usage error, so this runner never linted anything. `--colors never`
+        // keeps ANSI escapes out of the bytes the parser reads.
+        const result = await safeSpawnAsync(cmd, ["check", "--colors", "never", absPath], { cwd, timeout: 15000 });
+        // taplo reports on stderr and leaves stdout empty, so the
+        // "nothing to parse" test must read the same string the parser gets —
+        // otherwise every real run looks like a failed spawn.
+        const raw = result.stderr?.trim() ? result.stderr : (result.stdout ?? "");
+        //
+        // taplo exits 1 only when a file is INVALID, and it does not always draw
+        // a codespan block when it does: a schema it could not load is reported
+        // through its tracing output alone. Claiming that file clean would be an
+        // outright lie, so taplo opts into `skipWhenParsedNothing` (#1948). This
+        // replaces a hand-rolled per-runner copy of the same rule, which wrote
+        // its own `runner-empty-result` row with its own wording.
+        const run = parseToolRun("taplo", { result, output: raw, exitCodes: TAPLO_EXIT_CODES }, (out) => parseTaploOutput(out, ctx.filePath), { skipWhenParsedNothing: true });
+        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/tflint.js

@@ -2,9 +2,9 @@ import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { findNearestDirWithAnyBasename } from "../../workspace-topology.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
 import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const tflint = createAvailabilityChecker("tflint", ".exe");
 const TFLINT_CONFIG = ".tflint.hcl";
 /**
@@ -58,7 +58,7 @@ const tflintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (tflint.isAvailableAsync(cwd))) {
+        if (await tflint.isAvailableAsync(cwd)) {
             cmd = tflint.getCommand(cwd);
         }
         else {
@@ -82,10 +82,15 @@ const tflintRunner = {
             cwd: fileDir,
             timeout: 30000,
         });
-        if (spawnFailedWithNoOutput(result)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseTflintOutput(result.stdout || "", ctx.filePath);
+        // #1948: tflint exits nonzero and writes its JSON report to stdout, so a
+        // nonzero exit whose report yields zero diagnostics is a parser break,
+        // not a clean file. No exit-code table: tflint's nonzero codes are not
+        // verified against a real binary here, so the conservative
+        // nothing-to-parse rule stays the only discriminator.
+        const run = parseToolRun("tflint", { result }, (out) => parseTflintOutput(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/utils/tool-failure.js

@@ -29,7 +29,9 @@ export function formatToolFailure(input) {
             ? "did not run (spawn failure)"
             : `exited ${input.status}`;
     const missing = input.reportMissing ? "no report file" : "no output";
-    const detail = firstOutputLine(input.stderr) || firstOutputLine(input.stdout) || "no stderr";
+    const detail = firstOutputLine(input.stderr) ||
+        firstOutputLine(input.stdout) ||
+        "no stderr";
     return truncateForLedger(`${identity} ${what} with ${missing}: ${detail}`);
 }
 /**
@@ -70,3 +72,117 @@ export function skipUnlessToolRan(tool, input, fields) {
     });
     return { status: "skipped", diagnostics: [], semantic: "none" };
 }
+/**
+ * The record a runner leaves when its parser read NOTHING out of output the
+ * tool did produce (#1948).
+ *
+ * `skipUnlessToolRan` covers the adjacent case: the tool produced no output at
+ * all. The hole it leaves is the one that hid five parser bugs for months —
+ * vale (#1933), taplo, stylelint, phpstan (#1946), sqlfluff. Each received a
+ * real report, extracted zero diagnostics from it, and reported "succeeded, 0
+ * diagnostics", which is byte-for-byte what a genuinely clean file records.
+ * A reader could not answer "is this file clean, or did the parser fail?".
+ *
+ * THE RULE: record only when the exit status is NONZERO, the output handed to
+ * the parser is non-empty, and the parse yielded zero diagnostics. A nonzero
+ * exit is the tool asserting something is wrong; extracting nothing from that
+ * assertion means our reader disagrees with the tool, and one of the two is
+ * broken.
+ *
+ * Exit 0 with zero parsed is deliberately NOT recorded, even with non-empty
+ * output: that is the overwhelmingly common clean save. Linters print summary
+ * banners, empty JSON arrays, and progress noise on a clean run, so a row per
+ * clean save would drown the ledger and bury the real signal.
+ *
+ * FALSE NEGATIVES this rule accepts, stated plainly:
+ *   - A tool that reports findings under exit 0. `swiftlint` is the live
+ *     example among the adopters: a warning-only run exits 0 and still writes
+ *     a full JSON array, so a swiftlint parser break that never trips a
+ *     nonzero exit stays invisible here. (`vale` also exits 0 on findings by
+ *     default, but its actual #1933 break exited 1, so it is not the example.)
+ *     This gap is deliberate and is NOT closed by adding an output-length
+ *     threshold for exit 0. That class belongs to the captured-fixture lane —
+ *     `tests/clients/dispatch/runners/captured-real-output.test.ts` pins each
+ *     parser against real recorded binary output, which catches a broken
+ *     parser directly instead of guessing from output size. A length
+ *     threshold here would fire on every clean run of every tool that prints
+ *     a summary banner.
+ *   - A tool whose parser breaks only for a SUBSET of findings still reports
+ *     the ones it can read, so `parsedCount` is nonzero and nothing records.
+ *
+ * FALSE POSITIVES it accepts: a runner that legitimately parses zero
+ * diagnostics out of a failing run — `go-vet` exits nonzero for a SIBLING
+ * file's problem and then filters to the edited file, and `terragrunt` does
+ * the same across a unit directory. Such runners stay off this helper rather
+ * than being special-cased inside it; see the runner-family registries in
+ * `tests/clients/dispatch/runners/parsed-nothing-sweep.test.ts`.
+ *
+ * Bounded by `incrementDegradationCount`: one latest-reason entry per
+ * (kind, subject) with an exact tally, so a permanently broken parser costs
+ * ONE ledger row and not one per dispatched file. `subject` is the tool id
+ * because a parser break is a property of the tool and our reader of it, not
+ * of the project it ran in; aggregating on the tool keeps exactly the identity
+ * a reader needs ("which tool is stuck") while staying bounded across every
+ * workspace in the session.
+ *
+ * @returns true when a row was recorded.
+ */
+export function recordParsedNothing(input) {
+    const { tool, status, output, parsedCount } = input;
+    // Three conjuncts, one per clause of the rule above. Each is separately
+    // load-bearing and separately tested: `parsedCount` keeps a run that DID
+    // yield findings silent, `status` keeps the clean-save case silent (0 and a
+    // never-arrived null alike — neither is a tool asserting a problem), and
+    // `output` keeps "the tool said nothing at all" with `runner-empty-result`
+    // rather than double-recording it here.
+    if (parsedCount > 0)
+        return false;
+    if (!status)
+        return false;
+    const text = output ?? "";
+    if (!text.trim())
+        return false;
+    const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== undefined && value !== "");
+    const identity = entries.length
+        ? `${tool} (${entries.map(([key, value]) => `${key}=${value}`).join(", ")})`
+        : tool;
+    incrementDegradationCount({
+        kind: "runner-parsed-nothing",
+        subject: tool,
+        reason: truncateForLedger(`${identity} exited ${status} with ${text.length} chars of output but the parser read 0 diagnostics: ${firstOutputLine(text) || "no first line"}`),
+    });
+    return true;
+}
+/**
+ * The one seam a runner uses to go from a spawn result to diagnostics (#1948).
+ *
+ * It composes the two gates that must BOTH hold before a runner may claim a
+ * clean file: `skipUnlessToolRan` (the tool produced nothing — #1816) and
+ * `recordParsedNothing` (the tool produced something the parser could not
+ * read). Runners call this instead of calling `skipUnlessToolRan` and then
+ * parsing on their own, so the second gate cannot be forgotten by whoever
+ * writes runner 53. `tests/clients/dispatch/runners/parsed-nothing-sweep.test.ts`
+ * enforces that.
+ */
+export function parseToolRun(tool, input, parse, options = {}) {
+    const skipped = skipUnlessToolRan(tool, input, options.fields);
+    if (skipped)
+        return { skipped, diagnostics: [], parsedNothing: false };
+    const output = options.parseOutput ?? input.output ?? input.result.stdout ?? "";
+    const diagnostics = [...parse(output)];
+    const parsedNothing = recordParsedNothing({
+        tool,
+        status: input.result.status ?? null,
+        output,
+        parsedCount: diagnostics.length,
+        fields: options.fields,
+    });
+    if (parsedNothing && options.skipWhenParsedNothing) {
+        return {
+            skipped: { status: "skipped", diagnostics: [], semantic: "none" },
+            diagnostics: [],
+            parsedNothing,
+        };
+    }
+    return { skipped: null, diagnostics, parsedNothing };
+}

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

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.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 vale = createAvailabilityChecker("vale", ".exe");
 /**
  * Check for a .vale.ini config file in cwd or parent dirs.
@@ -24,19 +24,18 @@ function findValeConfig(cwd) {
     }
     return undefined;
 }
-function parseValeOutput(raw, filePath) {
+export function parseValeOutput(raw, filePath) {
     const diagnostics = [];
     if (!raw.trim())
         return diagnostics;
     try {
         const parsed = JSON.parse(raw);
-        const files = parsed?.Data?.Files;
-        if (!files)
+        if (!parsed || typeof parsed !== "object")
             return diagnostics;
-        for (const file of files) {
-            if (!file.Alerts)
+        for (const alerts of Object.values(parsed)) {
+            if (!Array.isArray(alerts))
                 continue;
-            for (const alert of file.Alerts) {
+            for (const alert of alerts) {
                 if (!alert.Message)
                     continue;
                 const severityMap = {
@@ -51,7 +50,7 @@ function parseValeOutput(raw, filePath) {
                     message: `[${alert.Check ?? "vale"}] ${alert.Message}`,
                     filePath,
                     line: alert.Line ?? 1,
-                    column: alert.Column ?? 1,
+                    column: alert.Span?.[0] ?? 1,
                     severity,
                     semantic: severity === "error" ? "blocking" : "warning",
                     tool: "vale",
@@ -80,7 +79,7 @@ const valeRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (vale.isAvailableAsync(cwd))) {
+        if (await vale.isAvailableAsync(cwd)) {
             cmd = vale.getCommand(cwd);
         }
         else {
@@ -95,11 +94,14 @@ const valeRunner = {
         // zero alerts, and reported clean prose. No exit-code table: Vale's
         // nonzero codes vary with --minAlertLevel, so the conservative
         // nothing-to-parse rule is the only safe discriminator here.
-        const skipped = skipUnlessToolRan("vale", { result });
-        if (skipped)
-            return skipped;
-        const raw = result.stdout || "";
-        const diagnostics = parseValeOutput(raw, ctx.filePath);
+        //
+        // #1948: `parseToolRun` adds the second gate. Vale's `Data.Files`
+        // envelope bug produced exactly this shape — exit 1, a full JSON
+        // report on stdout, zero alerts parsed — and left no record.
+        const run = parseToolRun("vale", { result }, (raw) => parseValeOutput(raw, 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/yamllint.js

@@ -2,7 +2,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasYamllintConfig } 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 yamllint = createAvailabilityChecker("yamllint", ".exe");
 export { hasYamllintConfig };
 function parseYamllintParsable(raw, filePath) {
@@ -45,7 +45,7 @@ const yamllintRunner = {
             ctx.log("yamllint: no config detected, running with default rules");
         }
         let cmd = null;
-        if (await (yamllint.isAvailableAsync(cwd))) {
+        if (await yamllint.isAvailableAsync(cwd)) {
             cmd = yamllint.getCommand(cwd);
         }
         else {
@@ -66,13 +66,12 @@ const yamllintRunner = {
         // and tracebacks. So the gate judges "nothing to parse" on stdout alone,
         // while the parser still reads both streams.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("yamllint", {
-            result,
-            output: result.stdout,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseYamllintParsable(raw, ctx.filePath);
+        // #1948: classify on stdout as before, parse both streams as before, and
+        // record when a failing run yields nothing.
+        const run = parseToolRun("yamllint", { result, output: result.stdout }, (out) => parseYamllintParsable(out, ctx.filePath), { 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/finding-delivery-gate.js

@@ -77,6 +77,28 @@
  * rendering convention every gated surface reuses — a store must not invent
  * its own "stale" wording.
  *
+ * #1944 completes the rule: demotion must change the BODY, not only the
+ * channel and the coordinate. A demoted body carries no STOP banner and no
+ * "must be fixed" imperative, and a cited line the file no longer has renders
+ * as `L<n> (line no longer exists)`. `clients/demoted-finding-render.ts`
+ * (`degradeDemotedFindingBody`) is the one implementation for surfaces that
+ * deliver a RENDERED BODY — the turn-end advisory tier. Per-row surfaces
+ * (`clients/widget-state.ts`, `tools/lens-diagnostics.ts`) have no body to
+ * degrade; they satisfy the same rule by dropping the authority marker
+ * alongside the coordinate.
+ *
+ * ── Retirement (#1944) ────────────────────────────────────────────────────
+ * Demote-not-drop assumes the agent CAN re-run to confirm. A past-EOF
+ * demotion breaks that assumption: the file shrank past the cited lines, so
+ * no re-run can ever speak to them, and the record re-served on every turn
+ * end for the life of the session. Such a record is delivered ONCE, degraded,
+ * then retired (`RuntimeCoordinator.retireDemotedPastEofBlocker`). The
+ * suppression is recorded in the degradation ledger under
+ * `demoted-finding-retired`, whose subject keeps the store and file, and the
+ * delivered payload says so in its own words — so an empty advisory section
+ * can only mean "nothing to say". Dependency-drift demotions keep in-bounds
+ * coordinates the agent can act on and are NOT retired.
+ *
  * ── Explicit lag labels (the non-gated escape hatch) ──────────────────────
  * A store that cannot afford the freshness/disposition stack — because it
  * has no cited per-file path to stat (a package-pinned finding like a trivy

package/node_modules/pi-lens/dist/clients/jscpd-client.js

@@ -115,11 +115,14 @@ export class JscpdClient {
             }
             if (!entry.isFile())
                 return "skip";
-            if (ignoreMatcher.isIgnored(fullPath, false))
-                return "skip";
+            // #1974: extension gate before isIgnored — the regex test is cheap
+            // per-call; isIgnored recompiles minimatch patterns per ancestor dir
+            // and should only run for files that already look like source.
             if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
                 if (entry.name.endsWith(".d.ts"))
                     return "skip";
+                if (ignoreMatcher.isIgnored(fullPath, false))
+                    return "skip";
                 return "stop";
             }
             return "skip";

package/node_modules/pi-lens/dist/clients/language-profile.js

@@ -285,11 +285,16 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
                 stack.push(fullPath);
             }
             else if (entry.isFile()) {
-                if (ignoreMatcher.isIgnored(fullPath, false))
-                    continue;
+                // #1974: cheap extension gate before the ignore matcher — isIgnored is
+                // O(ancestorDirs x patterns) with a per-call minimatch regex compile
+                // (0.68-0.93ms/file, measured), so pay it only for files that already
+                // pass the extension check. A large ignored-but-not-dir-prunable pile
+                // (e.g. wal/*.log) otherwise pays the full isIgnored cost per file.
                 const ext = path.extname(entry.name).toLowerCase();
                 if (!WARMUP_SOURCE_EXTS.has(ext))
                     continue;
+                if (ignoreMatcher.isIgnored(fullPath, false))
+                    continue;
                 matchedSeen += 1;
                 const bucket = WARMUP_CODE_EXTS.has(ext) ? codeOut : nonCodeOut;
                 // Per-category hard cap — language detection only needs