pi-lens 4.1.0 → 4.1.2

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

@@ -2,7 +2,8 @@ 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";
+import { finishParsedRun } 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 +128,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 +136,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,21 +156,19 @@ 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", {
+        // #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;
+        return finishParsedRun({
+            tool: "sqlfluff",
+            ctx,
             result,
-            exitCodes: SQLFLUFF_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseSqlfluffOutput(result.stdout ?? "", ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
             diagnostics,
-            semantic: "warning",
-        };
+            classify: () => ({ status: "failed", semantic: "warning" }),
+        });
     },
 };
 export default sqlfluffRunner;

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

@@ -3,7 +3,8 @@ 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";
+import { finishParsedRun } 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 +13,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 +128,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,23 +140,19 @@ 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", {
+        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;
+        return finishParsedRun({
+            tool: "stylelint",
+            ctx,
             result,
-            exitCodes: STYLELINT_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const raw = result.stdout ?? "";
-        const diagnostics = parseStylelintJson(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
             diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+        });
     },
 };
 export default stylelintRunner;

package/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/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/dist/clients/dispatch/runners/terragrunt.js

@@ -5,6 +5,7 @@ import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
 import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const terragrunt = createAvailabilityChecker("terragrunt", ".exe");
 function normalizeSeverity(raw) {
     if (typeof raw === "number")
@@ -149,15 +150,19 @@ const terragruntRunner = {
         if (spawnFailedWithNoOutput(result))
             return SKIPPED;
         const diagnostics = parseTerragruntOutput(result.stdout || "", ctx.filePath, absPath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
+        return finishParsedRun({
+            tool: "terragrunt",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: hasErrors ? "failed" : "succeeded",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default terragruntRunner;

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

@@ -2,9 +2,10 @@ 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";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const tflint = createAvailabilityChecker("tflint", ".exe");
 const TFLINT_CONFIG = ".tflint.hcl";
 /**
@@ -58,7 +59,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,19 +83,28 @@ const tflintRunner = {
             cwd: fileDir,
             timeout: 30000,
         });
-        if (spawnFailedWithNoOutput(result)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseTflintOutput(result.stdout || "", ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
+        // #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;
+        return finishParsedRun({
+            tool: "tflint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: hasErrors ? "failed" : "succeeded",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default tflintRunner;

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

@@ -300,7 +300,9 @@ const ENTITY_EXTRACTION_LINE_THRESHOLD = 5;
  */
 function relativeForIgnoreGlob(filePath, root) {
     const rel = path.relative(root, filePath);
-    const normalized = (rel.startsWith("..") ? filePath : rel).split(path.sep).join("/");
+    const normalized = (rel.startsWith("..") ? filePath : rel)
+        .split(path.sep)
+        .join("/");
     return normalized;
 }
 function matchesIgnorePaths(filePath, root, patterns) {
@@ -311,7 +313,17 @@ function matchesIgnorePaths(filePath, root, patterns) {
 }
 const treeSitterRunner = {
     id: "tree-sitter",
-    appliesTo: ["jsts", "python", "go", "rust", "ruby", "cxx", "csharp", "php", "css"],
+    appliesTo: [
+        "jsts",
+        "python",
+        "go",
+        "rust",
+        "ruby",
+        "cxx",
+        "csharp",
+        "php",
+        "css",
+    ],
     priority: PRIORITY.STRUCTURAL_ANALYSIS,
     enabledByDefault: true,
     skipTestFiles: false, // Run on test files too (structural issues matter there)
@@ -323,7 +335,9 @@ const treeSitterRunner = {
             logTreeSitter({
                 phase: "runner_skip",
                 filePath: ctx.filePath,
-                reason: isTreeSitterWasmAborted() ? "wasm_aborted" : "client_unavailable",
+                reason: isTreeSitterWasmAborted()
+                    ? "wasm_aborted"
+                    : "client_unavailable",
                 status: "skipped",
             });
             return { status: "skipped", diagnostics: [], semantic: "none" };

package/dist/clients/dispatch/runners/utils/candidate-probe.js

@@ -80,5 +80,11 @@ export async function probeAvailabilityCandidates(candidates, probeArgs, timeout
             // above rather than through a thrown spawn.
         }
     }
-    return { foundPath: null, sawTransient, transientCause, hostStallMs, evidence };
+    return {
+        foundPath: null,
+        sawTransient,
+        transientCause,
+        hostStallMs,
+        evidence,
+    };
 }

package/dist/clients/dispatch/runners/utils/runner-helpers.js

@@ -19,6 +19,7 @@ import { getServersForFileWithConfig, isServerDisabled, } from "../../../lsp/con
 import { findGlobalBinary } from "../../../package-manager.js";
 import { safeSpawnAsync } from "../../../safe-spawn.js";
 import { getToolCommandSpec, shouldAutoInstallTool, } from "../../../tool-policy.js";
+import { isInSpawnTimeoutCooldown } from "../../../spawn-timeout-cooldown.js";
 import { classifyProbeFailure, createAvailabilityLatch, describeInstallAttempt, describeProbeEvidence, isLatchingOutcome, logAvailabilityDecision, startHostStallSampler, transientRetryDelayMs, } from "./availability-policy.js";
 export { createAvailabilityLatch, classifyProbeFailure, describeProbeEvidence, describeUnavailability, isTransientDecision, logAvailabilityDecision, startHostStallSampler, } from "./availability-policy.js";
 /**
@@ -777,6 +778,27 @@ export function createAvailabilityChecker(command, windowsExt = "", versionArgs
                 return false;
             }
             const cmd = await findCommand(resolvedCwd);
+            // #1995: a command cooling down after a RUNTIME timeout (lint or
+            // autofix lane blew its real budget) must not re-probe on every
+            // edit - the positive verdict is effectively cooled. Consult-only:
+            // probe timeouts do NOT arm the cooldown here, because a single
+            // slow --version under host stall (#1467) is transient evidence,
+            // and session-long suppression from it would contradict the
+            // #1494 retry ladder this classification exists for.
+            if (isInSpawnTimeoutCooldown(cmd)) {
+                noteDecision(cache, resolvedCwd, {
+                    available: false,
+                    outcome: "transient",
+                    cause: "probe-timeout",
+                    elapsedMs: 0,
+                    classifiedBy: "caller",
+                    evidence: {
+                        command: cmd,
+                        status: null,
+                    },
+                });
+                return false;
+            }
             const env = await options.environment?.(resolvedCwd);
             // The probe budget is enforced by a HOST-side timer, so host event-loop
             // stalls are charged to the child. Measure the stall that overlapped the
@@ -856,7 +878,8 @@ export function createAvailabilityChecker(command, windowsExt = "", versionArgs
             outcome: cache.outcome,
             cause: cache.cause,
             elapsedMs: cache.elapsedMs,
-            latched: cache.available !== false || isLatchingOutcome(cache.outcome ?? "missing"),
+            latched: cache.available !== false ||
+                isLatchingOutcome(cache.outcome ?? "missing"),
             retryAtMs: cache.retryAtMs,
         };
     }