@herbertgao/pi-extensions 2026.8.10 → 2026.8.12

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

@@ -54,7 +54,7 @@ const javacRunner = {
             ctx.log?.("javac: skipped — file is inside a Maven/Gradle project; a classpath-less compile would emit false positives");
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        if (!(await (javac.isAvailableAsync(cwd)))) {
+        if (!(await javac.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const cmd = javac.getCommand(cwd);

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

@@ -65,7 +65,7 @@ const ktlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (ktlint.isAvailableAsync(cwd))) {
+        if (await ktlint.isAvailableAsync(cwd)) {
             cmd = ktlint.getCommand(cwd);
         }
         else {

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

@@ -23,7 +23,7 @@ import { demoteInferredProjectDiagnostics } from "../../lsp/inferred-project.js"
 import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../auxiliary-lsp.js";
 import { readFileContent } from "./utils.js";
 import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics, } from "../../warm-attach.js";
-import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT, } from "../../mcp/ipc.js";
+import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT } from "../../mcp/ipc.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;

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

@@ -3,6 +3,8 @@ import { getLinterPolicyForCwd, markdownlintConfigArgs, } from "../../tool-polic
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
 import { parseToolRun } from "./utils/tool-failure.js";
+import { isInSpawnTimeoutCooldown, noteSpawnTimeout, } from "../../spawn-timeout-cooldown.js";
+import { finishParsedRun } 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
@@ -106,6 +108,13 @@ const markdownlintRunner = {
         }
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
+        // #1995: a command cooling down after a spawn timeout already consumed
+        // its budget in another lane (availability verify, autofix --fix). Skip
+        // without spawning — "not checked", never re-reported as clean.
+        if (isInSpawnTimeoutCooldown(cmd)) {
+            ctx.log(`markdownlint: ${cmd} is cooling down after a spawn timeout — skipping (one bounded failure budget per edit)`);
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
         // Shared config-args seam (#1247): the autofix path consumes the same
         // builder, so the package-owned fallback config can never drift.
         const configArgs = markdownlintConfigArgs(cwd);
@@ -113,6 +122,18 @@ const markdownlintRunner = {
             timeout: 15000,
             cwd,
         });
+        // #1995: a timeout is negative runtime evidence. Arm the cooldown so
+        // the autofix and availability lanes cannot hand this command a second
+        // budget within the same session.
+        if (result.failure === "timeout") {
+            noteSpawnTimeout({
+                tool: "markdownlint",
+                command: cmd,
+                phase: "lint",
+                durationMs: 15000,
+                teardown: result.timeoutTeardown,
+            });
+        }
         // #1816: this runner read `result.status` zero times, so an exit-2
         // config error with an empty stdout parsed to zero diagnostics and was
         // reported as a clean Markdown file. An empty result must distinguish
@@ -124,10 +145,13 @@ const markdownlintRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return { status: "succeeded", diagnostics, semantic: "warning" };
+        return finishParsedRun({
+            tool: "markdownlint",
+            ctx,
+            result,
+            diagnostics,
+            classify: () => ({ status: "succeeded", semantic: "warning" }),
+        });
     },
 };
 export default markdownlintRunner;

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

@@ -4,6 +4,7 @@ import { hasMypyConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
 import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } 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
@@ -89,15 +90,12 @@ const mypyRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
+        return finishParsedRun({
+            tool: "mypy",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+        });
     },
 };
 export default mypyRunner;

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

@@ -13,6 +13,17 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getJstsLintPolicyForCwd, hasVitePlusConfig, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveToolCommand, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const OXLINT_NO_FILES = Symbol("oxlint-no-files");
+const OXLINT_NO_FILES_UNCONFIRMED = Symbol("oxlint-no-files-unconfirmed");
+const OXLINT_NO_FILES_BANNER = "No files found to lint. Please check your paths and ignore patterns.";
+const OXLINT_NO_FILES_REPORT_KEYS = new Set([
+    "diagnostics",
+    "number_of_files",
+    "number_of_rules",
+    "threads_count",
+    "start_time",
+]);
 function resolveLocalVp(cwd) {
     const isWin = process.platform === "win32";
     for (const dir of walkUpDirs(cwd)) {
@@ -89,14 +100,71 @@ const oxlintRunner = {
         // unavailable.
         const stdout = result.stdout ?? "";
         const stderr = result.stderr ?? "";
-        let diagnostics = parseOxlintJson(stdout, ctx.filePath);
-        if (diagnostics.length === 0 && stdout.length > 0) {
-            diagnostics = parseOxlintUnix(stdout + stderr, ctx.filePath);
+        const parsedOutput = stdout + stderr;
+        const noFilesDecision = decideOxlintNoFiles(result, stdout, stderr);
+        // #1994's shared gate classifies invocation and parsed-output failures.
+        // The private markers preserve one legitimate nonzero/empty shape and
+        // force a status-0 lookalike away from clean. Neither escapes this runner.
+        // parseToolRun checks process failures before invoking this parser, so
+        // spawn/timeout/killed/signal precedence remains owned by #1994.
+        const parsedRun = parseToolRun("oxlint", { result, output: parsedOutput }, () => {
+            if (noFilesDecision.kind === "expected-no-files") {
+                return [OXLINT_NO_FILES];
+            }
+            if (noFilesDecision.kind === "unconfirmed-no-files" &&
+                result.status === 0) {
+                return [OXLINT_NO_FILES_UNCONFIRMED];
+            }
+            let parsed = parseOxlintJson(stdout, ctx.filePath);
+            if (parsed.length === 0 && stdout.length > 0) {
+                parsed = parseOxlintUnix(parsedOutput, ctx.filePath);
+            }
+            return parsed;
+        }, { parseOutput: parsedOutput });
+        if (parsedRun.skipped)
+            return parsedRun.skipped;
+        if (parsedRun.diagnostics.includes(OXLINT_NO_FILES)) {
+            // Real captured bytes show oxlint exits
+            // 1 with "No files found" + number_of_files: 0 when a config excludes
+            // the target, so "nonzero exit" alone cannot mean "unreadable report
+            // of problems" until the no-files shape is ruled out.
+            // Read BEFORE reporting "succeeded" — a config (root's or a nested
+            // one nearer the file, per oxlint's own discovery) that ignores this
+            // file reports the same empty diagnostics array a clean file does.
+            // "succeeded"/"none" would say "we checked, it's clean"; this file
+            // was never checked at all.
+            return {
+                status: "skipped",
+                diagnostics: [],
+                semantic: "none",
+                skipReason: "no-files-matched",
+            };
         }
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        if (parsedRun.diagnostics.includes(OXLINT_NO_FILES_UNCONFIRMED)) {
+            const reason = noFilesDecision.kind === "unconfirmed-no-files"
+                ? noFilesDecision.reason
+                : "status-zero";
+            return {
+                status: "failed",
+                diagnostics: [
+                    {
+                        id: `oxlint:no-files-unconfirmed:${reason}`,
+                        message: `oxlint no-files report was not canonical (${reason})`,
+                        filePath: ctx.filePath,
+                        line: 1,
+                        column: 1,
+                        severity: "warning",
+                        semantic: "warning",
+                        tool: "oxlint",
+                    },
+                ],
+                semantic: "warning",
+                failureKind: "unconfirmed_output",
+                failureMessage: `no-files-${reason}`,
+            };
         }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+        const diagnostics = parsedRun.diagnostics.filter((diagnostic) => diagnostic !== OXLINT_NO_FILES &&
+            diagnostic !== OXLINT_NO_FILES_UNCONFIRMED);
         // 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
@@ -109,13 +177,144 @@ const oxlintRunner = {
         // 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: !hasBlocking && result.status === 0 ? "succeeded" : "failed",
+        return finishParsedRun({
+            tool: "oxlint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+                return {
+                    status: !hasBlocking && result.status === 0 ? "succeeded" : "failed",
+                    semantic: hasBlocking ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
+function oxlintProcessState(result) {
+    const failureKind = result.spawnFailure?.kind;
+    if (result.signal || result.failure === "signal")
+        return "signal";
+    if (result.failure === "timeout" || failureKind === "timeout")
+        return "timeout";
+    if (result.failure === "aborted" || failureKind === "killed")
+        return "killed";
+    if (result.failure === "spawn" || result.error)
+        return "spawn";
+    if (result.outputTruncated)
+        return "truncated";
+    return "normal";
+}
+function isNonnegativeInteger(value) {
+    return Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && value >= 1;
+}
+function isNonnegativeFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+/**
+ * One decision seam for every oxlint no-files axis (#1998).
+ *
+ * Real oxlint 1.79.0 establishes the only expected shape: a normal completed
+ * process, exit 1, empty stderr, the exact no-files banner, and a JSON object
+ * containing exactly the five captured summary fields with canonical types
+ * and ranges. Diagnostics must be empty and `number_of_files` must be zero.
+ *
+ * Any process-control evidence wins before report bytes. Any no-files
+ * lookalike that differs on status, stderr, banner, JSON syntax/schema,
+ * diagnostics, or file count is unconfirmed rather than clean. A report with
+ * no no-files evidence remains an ordinary oxlint report for the normal parser.
+ */
+export function decideOxlintNoFiles(result, stdout, stderr) {
+    const processState = oxlintProcessState(result);
+    if (processState !== "normal") {
+        return {
+            kind: "unconfirmed-no-files",
+            reason: `process-${processState}`,
+        };
+    }
+    const jsonStart = stdout.indexOf("{");
+    const bannerText = (jsonStart === -1 ? stdout : stdout.slice(0, jsonStart)).trim();
+    const banner = bannerText === OXLINT_NO_FILES_BANNER
+        ? "exact"
+        : /no files found.+lint/i.test(bannerText)
+            ? "near"
+            : "missing";
+    let report;
+    let jsonMalformed = jsonStart === -1;
+    if (jsonStart !== -1) {
+        try {
+            const parsed = JSON.parse(stdout.slice(jsonStart));
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed)) {
+                report = parsed;
+            }
+            else {
+                jsonMalformed = true;
+            }
+        }
+        catch {
+            jsonMalformed = true;
+        }
+    }
+    const hasFileCount = report !== undefined &&
+        Object.prototype.hasOwnProperty.call(report, "number_of_files");
+    const fileCount = report?.number_of_files;
+    const hasNoFilesEvidence = banner !== "missing" ||
+        (hasFileCount && (fileCount === 0 || !isNonnegativeInteger(fileCount)));
+    if (!hasNoFilesEvidence)
+        return { kind: "ordinary-report" };
+    if (result.status == null) {
+        return { kind: "unconfirmed-no-files", reason: "status-null" };
+    }
+    if (result.status === 0) {
+        return { kind: "unconfirmed-no-files", reason: "status-zero" };
+    }
+    if (result.status !== 1) {
+        return { kind: "unconfirmed-no-files", reason: "status-other" };
+    }
+    if (stderr.trim().length > 0) {
+        return { kind: "unconfirmed-no-files", reason: "stderr-nonempty" };
+    }
+    if (banner === "near") {
+        return { kind: "unconfirmed-no-files", reason: "banner-near" };
+    }
+    if (banner === "missing") {
+        return { kind: "unconfirmed-no-files", reason: "banner-missing" };
+    }
+    if (jsonMalformed || !report) {
+        return { kind: "unconfirmed-no-files", reason: "json-malformed" };
+    }
+    const keys = Object.keys(report);
+    if (keys.some((key) => !OXLINT_NO_FILES_REPORT_KEYS.has(key))) {
+        return { kind: "unconfirmed-no-files", reason: "json-unknown-key" };
+    }
+    if (OXLINT_NO_FILES_REPORT_KEYS.size !== keys.length ||
+        [...OXLINT_NO_FILES_REPORT_KEYS].some((key) => !Object.prototype.hasOwnProperty.call(report, key))) {
+        return { kind: "unconfirmed-no-files", reason: "json-missing-key" };
+    }
+    if (!Array.isArray(report.diagnostics) ||
+        !isNonnegativeInteger(report.number_of_files) ||
+        !isNonnegativeInteger(report.number_of_rules) ||
+        !isPositiveInteger(report.threads_count) ||
+        !isNonnegativeFinite(report.start_time)) {
+        return {
+            kind: "unconfirmed-no-files",
+            reason: "json-known-field-invalid",
+        };
+    }
+    if (report.diagnostics.length > 0) {
+        return { kind: "unconfirmed-no-files", reason: "diagnostics-nonempty" };
+    }
+    if (report.number_of_files !== 0) {
+        return { kind: "unconfirmed-no-files", reason: "files-nonzero" };
+    }
+    return { kind: "expected-no-files" };
+}
 // Oxlint codes look like "eslint(no-debugger)" or "oxc(approx-constant)".
 // Strip the plugin prefix so the rule lines up with what users expect.
 // indexOf-based extraction avoids a regex hot-spot Sonar flagged for
@@ -142,8 +341,10 @@ function parseOxlintJson(raw, filePath) {
     catch {
         return [];
     }
+    if (!Array.isArray(parsed.diagnostics))
+        return [];
     const diagnostics = [];
-    for (const d of parsed.diagnostics ?? []) {
+    for (const d of parsed.diagnostics) {
         const rule = extractOxlintRule(d.code);
         const label = d.labels?.[0]?.span;
         const lineNum = label?.line ?? 1;

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

@@ -33,7 +33,7 @@ const phpLintRunner = {
     skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
-        if (!(await (php.isAvailableAsync(cwd)))) {
+        if (!(await php.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const cmd = php.getCommand(cwd);

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

@@ -4,6 +4,7 @@ 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";
+import { finishParsedRun } 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.
@@ -107,10 +108,13 @@ const phpstanRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return { status: "failed", diagnostics, semantic: "blocking" };
+        return finishParsedRun({
+            tool: "phpstan",
+            ctx,
+            result,
+            diagnostics,
+            classify: () => ({ status: "failed", semantic: "blocking" }),
+        });
     },
 };
 export default phpstanRunner;

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

@@ -244,7 +244,11 @@ function parsePSAnalyzerOutput(raw, filePath) {
         .filter((item) => item.Message && item.Line)
         .map((item) => {
         const sev = (item.Severity ?? "Warning").toLowerCase();
-        const severity = (sev === "error" || sev === "parseerror") ? "error" : (sev === "information" ? "info" : "warning");
+        const severity = sev === "error" || sev === "parseerror"
+            ? "error"
+            : sev === "information"
+                ? "info"
+                : "warning";
         const rule = item.RuleName ?? "PSScriptAnalyzer";
         return {
             id: `psscriptanalyzer-${rule}-${item.Line}`,
@@ -295,8 +299,10 @@ const psScriptAnalyzerRunner = {
             const result = await spawnPs(cmd, [
                 "-NoProfile",
                 "-NonInteractive",
-                "-File", tmpScript,
-                "-FilePath", absPath,
+                "-File",
+                tmpScript,
+                "-FilePath",
+                absPath,
             ]);
             const hostStallMs = sampler.stop();
             const elapsedMs = Date.now() - startedAt;
@@ -396,9 +402,7 @@ const psScriptAnalyzerRunner = {
                 // than latched. It must still never be read as a clean file
                 // (#1598): empty/malformed stdout on a successful exit is a lost
                 // or truncated write, not evidence of zero diagnostics.
-                const unreadableReason = result.stdout.trim()
-                    ? "unparseable"
-                    : "empty";
+                const unreadableReason = result.stdout.trim() ? "unparseable" : "empty";
                 logAvailabilityDecision({
                     tool: "psscriptanalyzer-stdout",
                     verdict: "unavailable",

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

@@ -11,6 +11,7 @@ import { getLSPService } from "../../lsp/index.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const pyright = createAvailabilityChecker("pyright", ".exe");
 const pyrightRunner = {
     id: "pyright",
@@ -31,7 +32,7 @@ const pyrightRunner = {
         // Get pyright command - try multiple strategies
         let cmd = null;
         // Strategy 1: Check cached availability (fast path)
-        if (await (pyright.isAvailableAsync(cwd))) {
+        if (await pyright.isAvailableAsync(cwd)) {
             cmd = pyright.getCommand(cwd);
         }
         // Strategy 2: use the shared availability taxonomy and install suppression.
@@ -64,24 +65,32 @@ const pyrightRunner = {
         }
         const output = (result.stdout || "").trim();
         if (!output) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
+            // Empty stdout with a nonzero exit and stderr chatter is an unreadable
+            // report of problems, never clean (#1839). The helper turns that into
+            // failed + parse-error; exit 0 stays clean.
+            return finishParsedRun({
+                tool: "pyright",
+                ctx,
+                result,
+                diagnostics: [],
+            });
         }
         try {
             const data = JSON.parse(output);
             const diagnostics = parsePyrightOutput(data, 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",
+            return finishParsedRun({
+                tool: "pyright",
+                ctx,
+                result,
                 diagnostics,
-                semantic: hasErrors
-                    ? "blocking"
-                    : diagnostics.length > 0
-                        ? "warning"
-                        : "none",
-            };
+                classify: (diagnostics) => {
+                    const hasErrors = diagnostics.some((d) => d.severity === "error");
+                    return {
+                        status: hasErrors ? "failed" : "succeeded",
+                        semantic: hasErrors ? "blocking" : "warning",
+                    };
+                },
+            });
             // pi-lens-ignore: missing-error-propagation
         }
         catch {

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

@@ -32,7 +32,7 @@ const makeClippyProbe = (cargoExe) => createCwdCachedProbe((cwd) => safeSpawnAsy
 }), { tool: "clippy", budgetMs: CLIPPY_PROBE_BUDGET_MS });
 const clippyAvailabilityByCargo = new Map();
 function getClippyProbe(cargoExe) {
-    return clippyAvailabilityByCargo.get(cargoExe) ?? refreshClippyProbe(cargoExe);
+    return (clippyAvailabilityByCargo.get(cargoExe) ?? refreshClippyProbe(cargoExe));
 }
 /** Replace the cached probe so a post-install state is observed. */
 function refreshClippyProbe(cargoExe) {

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

@@ -24,6 +24,7 @@ import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, lspPrimaryCoversFile, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const shellcheck = createAvailabilityChecker("shellcheck", ".exe");
 function findShellcheckConfig(cwd) {
     const local = path.join(cwd, ".shellcheckrc");
@@ -122,7 +123,7 @@ const shellcheckRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (shellcheck.isAvailableAsync(cwd))) {
+        if (await shellcheck.isAvailableAsync(cwd)) {
             cmd = shellcheck.getCommand(cwd);
         }
         else {
@@ -157,15 +158,12 @@ const shellcheckRunner = {
         // Parse diagnostics
         const raw = result.stdout + result.stderr;
         const diagnostics = parseShellcheckOutput(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",
+        return finishParsedRun({
+            tool: "shellcheck",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+        });
     },
 };
 export default shellcheckRunner;

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

@@ -34,7 +34,7 @@ const shfmtRunner = {
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
         let cmd = null;
-        if (await (shfmt.isAvailableAsync(cwd))) {
+        if (await shfmt.isAvailableAsync(cwd)) {
             cmd = shfmt.getCommand(cwd);
         }
         else {
@@ -79,7 +79,10 @@ const shfmtRunner = {
         // .editorconfig — otherwise this nags on every shell write against shfmt's
         // defaults (#211). Parse errors (above) are always reported.
         if (!hasEditorConfig(cwd)) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
+            // #211: without project opt-in, do not nag about formatting. But
+            // shfmt DID exit 1 — differences exist — so this is "chose not to
+            // check", reported as skipped, never as a clean result (#1839).
+            return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         // Extract first changed line from diff if possible
         const diffOutput = result.stdout ?? result.stderr ?? "";

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

@@ -3,6 +3,7 @@ import { getLinterPolicyForCwd, hasSqlfluffConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.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).
@@ -161,14 +162,13 @@ const sqlfluffRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
+        return finishParsedRun({
+            tool: "sqlfluff",
+            ctx,
+            result,
             diagnostics,
-            semantic: "warning",
-        };
+            classify: () => ({ status: "failed", semantic: "warning" }),
+        });
     },
 };
 export default sqlfluffRunner;

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

@@ -4,6 +4,7 @@ import { getLinterPolicyForCwd, hasStylelintConfig, } from "../../tool-policy.js
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.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.
@@ -146,15 +147,12 @@ const stylelintRunner = {
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
+        return finishParsedRun({
+            tool: "stylelint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+        });
     },
 };
 export default stylelintRunner;