pi-lens 4.1.0 → 4.1.2

package/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)) {
@@ -76,31 +87,234 @@ 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
         // 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");
-        return {
-            status: "failed",
+        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
+        // 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 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
@@ -127,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/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/dist/clients/dispatch/runners/phpstan.js

@@ -3,6 +3,12 @@ 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";
+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.
+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 +25,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 +35,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 +74,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,18 +99,22 @@ 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);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return { status: "failed", diagnostics, semantic: "blocking" };
+        // 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;
+        return finishParsedRun({
+            tool: "phpstan",
+            ctx,
+            result,
+            diagnostics,
+            classify: () => ({ status: "failed", semantic: "blocking" }),
+        });
     },
 };
 export default phpstanRunner;

package/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/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/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/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/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/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" };
         }