pi-lens 4.2.0 → 4.3.0

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

@@ -21,6 +21,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
@@ -61,8 +62,9 @@ function findShellcheckConfig(cwd) {
  *
  * Levels: "error", "warning", "info", "style"
  */
-function parseShellcheckOutput(raw, filePath) {
+function parseShellcheckOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     if (!raw.trim()) {
         return diagnostics;
     }
@@ -74,6 +76,8 @@ function parseShellcheckOutput(raw, filePath) {
         for (const item of parsed) {
             if (!item.message || !item.line)
                 continue;
+            if (!item.file || !pathsEqual(path.resolve(cwd, item.file), absTarget))
+                continue;
             // Map shellcheck levels to our severity
             const severityMap = {
                 error: "error",
@@ -157,7 +161,7 @@ const shellcheckRunner = {
         }
         // Parse diagnostics
         const raw = result.stdout + result.stderr;
-        const diagnostics = parseShellcheckOutput(raw, ctx.filePath);
+        const diagnostics = parseShellcheckOutput(raw, ctx.filePath, cwd);
         return finishParsedRun({
             tool: "shellcheck",
             ctx,

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

@@ -18,12 +18,14 @@
  * Install: cargo install typos-cli
  * Or: npm install -g typos-cli (if wrapped)
  */
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveRunnerCwd, } 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
+// EXIT TABLE (typos-cli 1.29 docs https://github.com/crate-ci/typos): 0 = no typos, 2 = typos found, 1 = an error that
 // stopped the scan. Anything nonzero outside {2} is a rejected invocation.
 const TYPOS_EXIT_CODES = { ran: [2] };
 /**
@@ -38,8 +40,9 @@ const TYPOS_EXIT_CODES = { ran: [2] };
  *   "corrections": ["receive"]
  * }
  */
-function parseTyposOutput(raw, filePath) {
+function parseTyposOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     if (!raw.trim()) {
         return diagnostics;
     }
@@ -52,6 +55,10 @@ function parseTyposOutput(raw, filePath) {
             const parsed = JSON.parse(line);
             if (!parsed.typo || !parsed.line_num)
                 continue;
+            // #3295: every typos JSONL record names its own `path`; a `typos.toml`
+            // `files.extend-exclude` or a directory argv makes that a second file.
+            if (parsed.path && !pathsEqual(path.resolve(cwd, parsed.path), absTarget))
+                continue;
             const corrections = parsed.corrections?.join(", ") || "no suggestions";
             const message = `Typo: "${parsed.typo}" → ${corrections}`;
             diagnostics.push({
@@ -104,7 +111,7 @@ const spellcheckRunner = {
         // 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 ?? ""}` });
+        const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath, cwd), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,3 +1,5 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { logRunnerAdvisoryOnce, resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd, hasSqlfluffConfig } from "../../tool-policy.js";
@@ -11,6 +13,7 @@ const sqlfluff = createAvailabilityChecker("sqlfluff", ".exe");
 // Only 2 is a rejected invocation.
 //
 // The exit TABLE is what protects this runner, not the nothing-to-parse rule:
+// EXIT TABLE (SQLFluff 3.1 docs https://docs.sqlfluff.com/en/stable/production.html): 0 clean; 1 findings/error; other nonzero rejected.
 // sqlfluff writes its user errors to STDOUT, not stderr (live: an unknown
 // dialect prints the error there), so stdout is non-empty and the fallback
 // rule would read the failed run as a run that found nothing.
@@ -73,7 +76,7 @@ const SQLFLUFF_FIXABLE_RULES = new Set([
     "ST01",
     "ST02",
 ]);
-function parseSqlfluffOutput(raw, filePath) {
+function parseSqlfluffOutput(raw, filePath, cwd) {
     if (!raw.trim())
         return [];
     try {
@@ -81,7 +84,13 @@ function parseSqlfluffOutput(raw, filePath) {
         if (!Array.isArray(parsed))
             return [];
         const diagnostics = [];
+        const absTarget = path.resolve(cwd, filePath);
         for (const item of parsed) {
+            // #3295: sqlfluff's JSON is an array of FILES; a jinja `{% include %}`
+            // or a directory argv puts a second one in it.
+            if (item.filepath &&
+                !pathsEqual(path.resolve(cwd, item.filepath), absTarget))
+                continue;
             for (const v of item.violations ?? []) {
                 if (!v.description)
                     continue;
@@ -158,7 +167,7 @@ const sqlfluffRunner = {
         // reported the SQL file as clean.
         // #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 ?? "" });
+        const run = parseToolRun("sqlfluff", { result, exitCodes: SQLFLUFF_EXIT_CODES }, (out) => parseSqlfluffOutput(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { logRunnerAdvisoryOnce, resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd, hasStylelintConfig, } from "../../tool-policy.js";
@@ -18,6 +19,7 @@ const stylelint = createAvailabilityChecker("stylelint", ".cmd");
 // exists to name.
 //
 // #1937 corrected the safety argument that used to sit here: it claimed a
+// EXIT TABLE (Stylelint 16 docs https://stylelint.io/user-guide/cli): 0 clean; 1 findings; 2 fatal/error; other nonzero rejected.
 // 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.
@@ -80,11 +82,17 @@ const STYLELINT_FIXABLE_RULES = new Set([
     "string-quotes",
     "value-no-vendor-prefix",
 ]);
-function parseStylelintJson(raw, filePath) {
+function parseStylelintJson(raw, filePath, cwd) {
     try {
         const results = JSON.parse(raw);
         const diagnostics = [];
+        const absTarget = path.resolve(cwd, filePath);
         for (const result of results) {
+            // #3295: stylelint keys each result by its own `source`; a config
+            // `files`/`overrides` entry or an `@import` makes that a DIFFERENT file.
+            if (result.source &&
+                !pathsEqual(path.resolve(cwd, result.source), absTarget))
+                continue;
             for (const w of result.warnings) {
                 const severity = w.severity === "error" ? "error" : "warning";
                 const fixable = STYLELINT_FIXABLE_RULES.has(w.rule);
@@ -143,7 +151,7 @@ const stylelintRunner = {
         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));
+        const run = parseToolRun("stylelint", { result, output: raw, exitCodes: STYLELINT_EXIT_CODES }, (out) => parseStylelintJson(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
@@ -68,10 +69,11 @@ const SWIFTLINT_FIXABLE_RULES = new Set([
     "void_return",
     "yoda_condition",
 ]);
-function parseSwiftLintOutput(raw, filePath) {
+function parseSwiftLintOutput(raw, filePath, cwd) {
     const diagnostics = [];
     if (!raw.trim())
         return diagnostics;
+    const absTarget = path.resolve(cwd, filePath);
     try {
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed))
@@ -79,6 +81,9 @@ function parseSwiftLintOutput(raw, filePath) {
         for (const item of parsed) {
             if (!item.reason)
                 continue;
+            // #3295: `.swiftlint.yml` `included:` widens the run past the argv.
+            if (item.file && !pathsEqual(path.resolve(cwd, item.file), absTarget))
+                continue;
             const severityMap = {
                 error: "error",
                 warning: "warning",
@@ -135,7 +140,11 @@ const swiftlintRunner = {
         // never ran.
         // 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));
+        const run = parseToolRun("swiftlint", {
+            result,
+            // EXIT TABLE (SwiftLint 0.56 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseSwiftLintOutput(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,5 +1,7 @@
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { findLocalBinUpwards } from "../../package-manager.js";
+import { stripAnsi } from "../../sanitize.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
@@ -12,6 +14,7 @@ const taplo = createAvailabilityChecker("taplo", ".exe");
 //
 // #1937 round 2: the parser fix alone turned the old silent-clean into a false
 // BLOCKING diagnostic. clap prints `error: unexpected argument '--output'
+// EXIT TABLE (taplo 0.9 measured fixture): 0 clean; 1 findings; other nonzero rejected/error.
 // 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.
@@ -21,7 +24,7 @@ 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+)$/;
+const LOCATION_PATTERN = /^\s*┌─\s+(.+?):(\d+):(\d+)$/;
 /**
  * Parse `taplo lint` output (#1937).
  *
@@ -48,9 +51,10 @@ const LOCATION_PATTERN = /:(\d+):(\d+)$/;
  * (#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) {
+export function parseTaploOutput(raw, filePath, cwd) {
     const diagnostics = [];
-    const lines = (raw ?? "").split(/\r?\n/);
+    const absTarget = path.resolve(cwd, filePath);
+    const lines = stripAnsi(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
@@ -79,8 +83,10 @@ export function parseTaploOutput(raw, filePath) {
             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;
+            if (!pathsEqual(path.resolve(cwd, location[1].trim()), absTarget))
+                continue;
+            line = Number.parseInt(location[2], 10) || 1;
+            column = Number.parseInt(location[3], 10) || 1;
             break;
         }
         if (line === null)
@@ -155,7 +161,7 @@ const taploRunner = {
         // 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 });
+        const run = parseToolRun("taplo", { result, output: raw, exitCodes: TAPLO_EXIT_CODES }, (out) => parseTaploOutput(out, ctx.filePath, cwd), { skipWhenParsedNothing: true });
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,4 +1,5 @@
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
@@ -23,24 +24,34 @@ function findTflintConfig(fileDir) {
     const dir = findNearestDirWithAnyBasename(fileDir, [TFLINT_CONFIG]);
     return dir ? path.join(dir, TFLINT_CONFIG) : null;
 }
-function parseTflintOutput(raw, filePath) {
+function parseTflintOutput(raw, filePath, toolCwd) {
     try {
         const parsed = JSON.parse(raw);
         const issues = parsed.issues ?? [];
-        return issues.map((issue) => {
+        // #3295: tflint loads EVERY `*.tf` in its working directory — `--filter` is
+        // best-effort — and names each issue's own `range.filename`, relative to
+        // the directory it ran in (`toolCwd`, which is the file's dir, not the
+        // runner cwd).
+        const absTarget = path.resolve(toolCwd, filePath);
+        return issues.flatMap((issue) => {
+            if (issue.range?.filename &&
+                !pathsEqual(path.resolve(toolCwd, issue.range.filename), absTarget))
+                return [];
             const severity = issue.rule.severity === "error" ? "error" : "warning";
-            return {
-                id: `tflint-${issue.rule.name}-${issue.range.start.line}`,
-                message: `[${issue.rule.name}] ${issue.message}`,
-                filePath,
-                line: issue.range.start.line,
-                column: issue.range.start.column,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "tflint",
-                rule: issue.rule.name,
-                fixable: false,
-            };
+            return [
+                {
+                    id: `tflint-${issue.rule.name}-${issue.range.start.line}`,
+                    message: `[${issue.rule.name}] ${issue.message}`,
+                    filePath,
+                    line: issue.range.start.line,
+                    column: issue.range.start.column,
+                    severity,
+                    semantic: severity === "error" ? "blocking" : "warning",
+                    tool: "tflint",
+                    rule: issue.rule.name,
+                    fixable: false,
+                },
+            ];
         });
     }
     catch {
@@ -88,7 +99,11 @@ const tflintRunner = {
         // 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));
+        const run = parseToolRun("tflint", {
+            result,
+            // EXIT TABLE (TFLint 0.52 measured fixture): 0 clean; 1 error; 2 findings; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseTflintOutput(out, absPath, fileDir));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -585,6 +585,29 @@ const treeSitterRunner = {
             }
         }
         if (diagnostics.length === 0) {
+            // #3409: zero diagnostics because the language's GRAMMAR never loaded is
+            // not a clean file, and `runQueriesOnFile` returns [] for both. The
+            // honest discriminator, once the run has already demanded the language,
+            // is the client's own loaded-language map: a grammar that could not be
+            // resolved, fetched, or decoded is absent from it. Reported through this
+            // runner's existing "the analysis did not run" arm (the same
+            // `runner_skip` + `status: "skipped"` shape as client-unavailable,
+            // init-failed and unsupported-extension) instead of as a pass with
+            // nothing found — which is what made a degraded language on a compiled
+            // host indistinguishable from a clean file in `runner_complete`.
+            //
+            // The abort term keeps a mid-run WASM abort (#402, its own
+            // `runtime_abort` record) from being misreported as a missing grammar.
+            if (!isTreeSitterWasmAborted() && !client.getLanguage(languageId)) {
+                logTreeSitter({
+                    phase: "runner_skip",
+                    filePath,
+                    languageId,
+                    reason: "grammar_unavailable",
+                    status: "skipped",
+                });
+                return { status: "skipped", diagnostics: [], semantic: "none" };
+            }
             logTreeSitter({
                 phase: "runner_complete",
                 filePath,

package/dist/clients/dispatch/runners/trivy-config.js

@@ -38,6 +38,7 @@
 import { formatToolFailure } from "./utils/tool-failure.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { incrementDegradationCount } from "../../degradation-ledger.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
@@ -89,7 +90,7 @@ function normalizeSeverity(raw) {
  * CauseMetadata: { StartLine } }] }] }`. CRITICAL → blocking, the rest advisory.
  * Defensive: malformed input returns `[]`. Exported for unit tests.
  */
-export function parseTrivyConfigOutput(raw, filePath) {
+export function parseTrivyConfigOutput(raw, filePath, cwd = process.cwd()) {
     if (!raw.trim())
         return [];
     let parsed;
@@ -103,9 +104,14 @@ export function parseTrivyConfigOutput(raw, filePath) {
     if (!Array.isArray(results))
         return [];
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const resultEntry of results) {
         if (!resultEntry || typeof resultEntry !== "object")
             continue;
+        const target = resultEntry.Target;
+        if (typeof target !== "string" ||
+            !pathsEqual(path.resolve(cwd, target), absTarget))
+            continue;
         const rows = resultEntry
             .Misconfigurations;
         if (!Array.isArray(rows))
@@ -232,7 +238,7 @@ const trivyConfigRunner = {
             });
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const diagnostics = parseTrivyConfigOutput(result.stdout || "", ctx.filePath);
+        const diagnostics = parseTrivyConfigOutput(result.stdout || "", ctx.filePath, cwd);
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/dist/clients/dispatch/runners/utils/diagnostic-parsers.js

@@ -4,6 +4,8 @@
  * Common patterns for parsing tool output into standardized diagnostics.
  * Supports the common `file:line:col: message` format used by most linters.
  */
+import * as path from "node:path";
+import { pathsEqual } from "../../../path-utils.js";
 import { stripAnsi } from "../../../sanitize.js";
 import { getAutofixCapability } from "../../../tool-policy.js";
 /**
@@ -11,8 +13,13 @@ import { getAutofixCapability } from "../../../tool-policy.js";
  * Common format: file:line:col: message (with variations)
  */
 function createLineParser(config) {
-    return (raw, filePath) => {
+    return (raw, filePath, cwd) => {
         const diagnostics = [];
+        // #3295: `config.regex` is documented above as capturing the FILE in group
+        // 1, and every parser built here then dropped it and stamped the dispatched
+        // path on every line. This is the shared factory, so the predicate lives
+        // here once rather than in each `createLineParser` caller.
+        const absTarget = path.resolve(cwd, filePath);
         // Optionally strip ANSI codes (for tools that output colored text)
         const clean = config.stripAnsi !== false ? stripAnsi(raw) : raw;
         const lines = clean.split("\n").filter((l) => l.trim());
@@ -20,6 +27,9 @@ function createLineParser(config) {
             const match = line.match(config.regex);
             if (!match)
                 continue;
+            const reported = match[1];
+            if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
+                continue;
             const lineNum = parseInt(match[2], 10);
             const colNum = parseInt(match[3], 10);
             const severity = config.getSeverity

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

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
@@ -25,17 +26,24 @@ function findValeConfig(cwd) {
     }
     return undefined;
 }
-export function parseValeOutput(raw, filePath) {
+export function parseValeOutput(raw, filePath, cwd) {
     const diagnostics = [];
     if (!raw.trim())
         return diagnostics;
+    const absTarget = path.resolve(cwd, filePath);
     try {
         const parsed = JSON.parse(raw);
         if (!parsed || typeof parsed !== "object")
             return diagnostics;
-        for (const alerts of Object.values(parsed)) {
+        // #3295: vale's top level is keyed BY the linted file's path — the only
+        // place the reported path appears. `Object.values` dropped it, so a
+        // `.vale.ini` glob or a directory argv charged a second file's alerts to
+        // the dispatched one.
+        for (const [reported, alerts] of Object.entries(parsed)) {
             if (!Array.isArray(alerts))
                 continue;
+            if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
+                continue;
             for (const alert of alerts) {
                 if (!alert.Message)
                     continue;
@@ -98,7 +106,11 @@ const valeRunner = {
         // #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));
+        const run = parseToolRun("vale", {
+            result,
+            // EXIT TABLE (Vale 3.9.6 docs https://vale.sh/docs/topics/metrics/): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (raw) => parseValeOutput(raw, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,3 +1,5 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { logRunnerAdvisoryOnce } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd, hasYamllintConfig } from "../../tool-policy.js";
@@ -7,14 +9,17 @@ import { parseToolRun } from "./utils/tool-failure.js";
 import { finishParsedRun } from "./utils/tool-failure.js";
 const yamllint = createAvailabilityChecker("yamllint", ".exe");
 export { hasYamllintConfig };
-function parseYamllintParsable(raw, filePath) {
+function parseYamllintParsable(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         if (!line.trim())
             continue;
         const match = line.match(/^(.*?):(\d+):(\d+):\s*\[(error|warning)\]\s*(.*?)\s*\(([^)]+)\)\s*$/i);
         if (!match)
             continue;
+        if (!pathsEqual(path.resolve(cwd, match[1]), absTarget))
+            continue;
         const severity = match[4].toLowerCase() === "error" ? "error" : "warning";
         diagnostics.push({
             id: `yamllint-${match[2]}-${match[3]}-${match[6]}`,
@@ -70,7 +75,12 @@ const yamllintRunner = {
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
         // #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 });
+        const run = parseToolRun("yamllint", {
+            result,
+            output: result.stdout,
+            // EXIT TABLE (yamllint 1.35 docs https://yamllint.readthedocs.io/en/stable/): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseYamllintParsable(out, ctx.filePath, cwd), { parseOutput: raw });
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

package/dist/clients/dispatch/runners/zig-check.js

@@ -1,21 +1,23 @@
 import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 // zig rejects `--version`; the version subcommand is `zig version`. Using the
 // default probe would make this runner skip on every machine.
 const zig = createAvailabilityChecker("zig", ".exe", ["version"]);
-function parseZigOutput(raw, filePath) {
+function parseZigOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         const match = line.match(/^(.*?):(\d+):(\d+):\s*(error|warning|note):\s*(.+)$/);
         if (!match)
             continue;
         const [, rawFile, lineStr, colStr, level, message] = match;
-        const resolvedSource = path.resolve(rawFile.trim());
-        const resolvedTarget = path.resolve(filePath);
-        if (resolvedSource !== resolvedTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, rawFile.trim()), absTarget))
             continue;
         const severity = level === "error" ? "error" : "warning";
         diagnostics.push({
@@ -35,12 +37,6 @@ function parseZigOutput(raw, filePath) {
     }
     return diagnostics;
 }
-function firstOutputLine(result) {
-    return `${result.stderr || ""}\n${result.stdout || ""}`
-        .trim()
-        .split(/\r?\n/, 1)[0]
-        .slice(0, 200);
-}
 const zigCheckRunner = {
     id: "zig-check",
     appliesTo: ["zig"],
@@ -57,35 +53,27 @@ const zigCheckRunner = {
         if (result.error && !result.stdout && !result.stderr) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const diagnostics = parseZigOutput(`${result.stderr || ""}\n${result.stdout || ""}`, ctx.filePath);
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
-                return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "zig-check-nonzero-no-diagnostics",
-                            message: firstOutputLine(result) ||
-                                "zig build-exe exited non-zero without structured diagnostics",
-                            filePath: ctx.filePath,
-                            severity: "warning",
-                            semantic: "warning",
-                            tool: "zig",
-                            rule: "zig-check",
-                            fixable: false,
-                        },
-                    ],
-                    semantic: "warning",
-                };
-            }
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: "warning",
-        };
+        const raw = `${result.stdout || ""}\n${result.stderr || ""}`;
+        const parsed = parseToolRun("zig-check", {
+            result,
+            output: raw,
+            // EXIT TABLE (Zig 0.13 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (output) => parseZigOutput(output, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "zig-check",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+            classify: (diagnostics) => ({
+                status: diagnostics.some((d) => d.severity === "error")
+                    ? "failed"
+                    : "succeeded",
+                semantic: "warning",
+            }),
+        });
     },
 };
 export default zigCheckRunner;