@herbertgao/pi-extensions 2026.9.15 → 2026.9.17

package/node_modules/pi-lens/dist/clients/dispatch/runners/markdownlint.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, markdownlintConfigArgs, } from "../../tool-policy.js";
@@ -10,7 +12,7 @@ const markdownlint = createAvailabilityChecker("markdownlint-cli2", ".cmd", [
     "--no-globs",
     "-",
 ]);
-// markdownlint-cli2 exit codes (its README's "Exit Codes" section): 0 = no
+// EXIT TABLE (markdownlint-cli2 0.17 README https://github.com/DavidAnson/markdownlint-cli2#exit-codes): 0 = no
 // findings, 1 = lint findings, 2 = unexpected error (unreadable config, bad
 // glob, crash). Only 2 is a rejected invocation.
 const MARKDOWNLINT_EXIT_CODES = { ran: [1] };
@@ -59,18 +61,23 @@ const MARKDOWNLINT_FIXABLE_RULES = new Set([
 //   2. some rules carry MULTIPLE slash-separated names (e.g.
 //      `MD041/first-line-heading/first-line-h1`).
 // The severity token is optional so older/relative-path output still parses.
-function parseMarkdownlintOutput(raw, filePath) {
+function parseMarkdownlintOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         if (!line.trim())
             continue;
         // Rule code is MD### followed by one or more slash-joined names. Use a
         // single char class (`[\w/-]+`) rather than a nested quantifier
         // (`(?:/[\w-]+)+`) so there's no super-linear backtracking (S5852).
-        const match = line.match(/^.*?:(\d+)(?::(\d+))?\s+(?:error|warning)?\s*(MD\d+\/[\w/-]+)\s+(.+)$/);
+        const match = line.match(/^(.*?):(\d+)(?::(\d+))?\s+(?:error|warning)?\s*(MD\d+\/[\w/-]+)\s+(.+)$/);
         if (!match)
             continue;
-        const [, lineNum, col, ruleCode, message] = match;
+        const [, reported, lineNum, col, ruleCode, message] = match;
+        // #3295: the leading `.*?` this parser discarded IS markdownlint-cli2's
+        // reported path, and its config globs can widen the run past the argv.
+        if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
+            continue;
         const ruleName = ruleCode.split("/")[0];
         const fixable = MARKDOWNLINT_FIXABLE_RULES.has(ruleName);
         diagnostics.push({
@@ -144,7 +151,7 @@ const markdownlintRunner = {
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
         // #1948: one seam for both gates — the tool produced nothing, and the
         // tool produced something the parser could not read.
-        const run = parseToolRun("markdownlint", { result, output: raw, exitCodes: MARKDOWNLINT_EXIT_CODES }, (out) => parseMarkdownlintOutput(out, ctx.filePath));
+        const run = parseToolRun("markdownlint", { result, output: raw, exitCodes: MARKDOWNLINT_EXIT_CODES }, (out) => parseMarkdownlintOutput(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -14,7 +14,8 @@ const mypy = createAvailabilityChecker("mypy", "");
 // [syntax]`). A bad flag or unreadable config also exits 2, but writes its
 // message to STDERR and leaves stdout empty.
 //
-// So the exit code cannot separate the two, and the STREAM does: the gate below
+// EXIT TABLE (mypy 1.11 docs https://mypy.readthedocs.io/en/stable/command_line.html): 0 clean; 1 findings; 2 findings/error; other
+// nonzero rejected. The exit code cannot separate the two, and the STREAM does:
 // judges "nothing to parse" on stdout alone, while the parser still reads both.
 // The table's remaining job is to reject any OTHER nonzero status.
 const MYPY_EXIT_CODES = { ran: [1, 2] };

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

@@ -6,7 +6,9 @@
  *
  * Requires: oxlint (npm install -g oxlint)
  */
+import * as path from "node:path";
 import { findLocalBinUpwards } from "../../package-manager.js";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { truncatedByOutputCap } from "../../spawn-output-cap.js";
@@ -111,7 +113,12 @@ const oxlintRunner = {
         // 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 }, () => {
+        const parsedRun = parseToolRun("oxlint", {
+            result,
+            output: parsedOutput,
+            // EXIT TABLE (oxlint 0.8 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, () => {
             if (noFilesDecision.kind === "expected-no-files") {
                 return [OXLINT_NO_FILES];
             }
@@ -119,9 +126,9 @@ const oxlintRunner = {
                 result.status === 0) {
                 return [OXLINT_NO_FILES_UNCONFIRMED];
             }
-            let parsed = parseOxlintJson(stdout, ctx.filePath);
+            let parsed = parseOxlintJson(stdout, ctx.filePath, cwd);
             if (parsed.length === 0 && stdout.length > 0) {
-                parsed = parseOxlintUnix(parsedOutput, ctx.filePath);
+                parsed = parseOxlintUnix(parsedOutput, ctx.filePath, cwd);
             }
             return parsed;
         }, { parseOutput: parsedOutput });
@@ -334,7 +341,7 @@ function extractOxlintRule(code) {
         return code;
     return code.slice(open + 1, close);
 }
-function parseOxlintJson(raw, filePath) {
+function parseOxlintJson(raw, filePath, cwd) {
     const trimmed = raw.trim();
     if (!trimmed.startsWith("{"))
         return [];
@@ -348,7 +355,11 @@ function parseOxlintJson(raw, filePath) {
     if (!Array.isArray(parsed.diagnostics))
         return [];
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const d of parsed.diagnostics) {
+        if (!d.filename || !pathsEqual(path.resolve(cwd, d.filename), absTarget)) {
+            continue;
+        }
         const rule = extractOxlintRule(d.code);
         const label = d.labels?.[0]?.span;
         const lineNum = label?.line ?? 1;
@@ -374,13 +385,18 @@ function parseOxlintJson(raw, filePath) {
     }
     return diagnostics;
 }
-function parseOxlintUnix(raw, filePath) {
+function parseOxlintUnix(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split("\n")) {
         // Parse: file:line:column: message (rule)
         const match = line.match(/^(.+):(\d+):(\d+):\s*(.+?)\s*\(([^)]+)\)$/);
         if (match) {
-            const [, _file, lineStr, _col, message, rule] = match;
+            const [, reportedPath, lineStr, _col, message, rule] = match;
+            if (!reportedPath || !lineStr || !message || !rule)
+                continue;
+            if (!pathsEqual(path.resolve(cwd, reportedPath), absTarget))
+                continue;
             diagnostics.push({
                 id: `oxlint-${rule}-${lineStr}`,
                 message: `${message} (${rule})`,

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

@@ -1,16 +1,33 @@
 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";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+// PHP's `-l` exit contract, declared HERE rather than in the shared classifier
+// (#3291 r3): an admission is a property of this tool. The manual documents
+// `-l` as syntax-check-only with a nonzero return on failure; the captured
+// PHP 8.3.32 wire exits 1 in the usual CLI path and 255 (the shell reading of
+// PHP's documented -1) for the parse-error wire. Both are completed analyses
+// whose output must reach the parser; any other nonzero status stays a
+// rejected invocation.
+const PHP_LINT_EXIT_CODES = { ran: [1, 255] };
 const php = createAvailabilityChecker("php", ".exe");
-function parsePhpLintOutput(raw, filePath) {
+function parsePhpLintOutput(raw, filePath, cwd) {
     const output = raw.trim();
-    if (!output)
+    if (!output || !/(?:PHP )?Parse error:/i.test(output))
         return [];
     const lineMatch = output.match(/on line (\d+)/i);
-    const messageMatch = output.match(/PHP Parse error:\s*(.+?)(?:\s+in\s+.+?\s+on line \d+)?$/im) ??
-        output.match(/Parse error:\s*(.+?)(?:\s+in\s+.+?\s+on line \d+)?$/im);
+    const messageMatch = output.match(/PHP Parse error:\s*(.+?)(?:\s+in\s+(.+?)\s+on line \d+)?$/im) ??
+        output.match(/Parse error:\s*(.+?)(?:\s+in\s+(.+?)\s+on line \d+)?$/im);
+    // #3295: PHP names the file it could not parse in the same sentence. `php -l`
+    // follows no includes today, so this drops nothing under our argv — it pins
+    // the attribution the parser was asserting without asking.
+    const reported = messageMatch?.[2]?.trim();
+    if (reported &&
+        !pathsEqual(path.resolve(cwd, reported), path.resolve(cwd, filePath)))
+        return [];
     return [
         {
             id: `php-lint:${lineMatch?.[1] ?? "1"}`,
@@ -45,18 +62,24 @@ const phpLintRunner = {
             timeout: 15000,
             cwd,
         });
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parsePhpLintOutput(`${result.stdout ?? ""}\n${result.stderr ?? ""}`, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "blocking",
-        };
+        // `output` is what the classifier judges AND what the parser reads: the
+        // parse error arrives on stderr, so both streams are one wire here. The
+        // exit table rides in this same per-runner input, never in a shared
+        // option (#3291 r3).
+        const run = parseToolRun("php-lint", {
+            result,
+            output: `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
+            exitCodes: PHP_LINT_EXIT_CODES,
+        }, (output) => parsePhpLintOutput(output, ctx.filePath, cwd));
+        if (run.skipped)
+            return run.skipped;
+        return finishParsedRun({
+            tool: "php-lint",
+            ctx,
+            result,
+            diagnostics: run.diagnostics,
+            classify: () => ({ status: "failed", semantic: "blocking" }),
+        });
     },
 };
 export default phpLintRunner;

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

@@ -6,7 +6,7 @@ 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
+// EXIT TABLE (PHPStan 1.12 docs https://phpstan.org/user-guide/command-line-usage): 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] };

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

@@ -7,11 +7,14 @@
  *
  * Supports bundle exec (preferred in Bundler projects).
  */
+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 { getAutofixCapability, getLinterPolicyForCwd, getRubocopCommand, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveCommandArgsWithInstallFallback } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const SEVERITY_MAP = {
     fatal: "error",
     error: "error",
@@ -19,12 +22,17 @@ const SEVERITY_MAP = {
     convention: "warning",
     refactor: "info",
 };
-function parseRubocopJson(raw, filePath) {
+function parseRubocopJson(raw, filePath, cwd) {
     try {
         const output = JSON.parse(raw);
         const autofix = getAutofixCapability("rubocop");
         const diagnostics = [];
+        const absTarget = path.resolve(cwd, filePath);
         for (const file of output.files) {
+            // #3295: `.rubocop.yml` `Include:`/`inherit_from` can widen the run past
+            // the argv, and each result carries its own `path`.
+            if (file.path && !pathsEqual(path.resolve(cwd, file.path), absTarget))
+                continue;
             for (const offense of file.offenses) {
                 const severity = SEVERITY_MAP[offense.severity] ?? "warning";
                 diagnostics.push({
@@ -68,23 +76,24 @@ const rubocopRunner = {
         const { cmd, args } = resolved;
         // Lint only — no auto-correct (formatter handles that)
         const result = await safeSpawnAsync(cmd, [...args, "--format", "json", "--no-color", ctx.filePath], { timeout: 30000, cwd });
-        // rubocop exits 0 = no offenses, 1 = offenses found, 2 = fatal error
-        if (result.status === 2) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseRubocopJson(result.stdout, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+        // EXIT TABLE (RuboCop 1.66 docs https://docs.rubocop.org/rubocop/usage/basic_usage.html): 0 = clean, 1 = offenses/findings, 2 = fatal/error or rejected
+        // invocation. A nonzero exit with valid JSON remains findings; a nonzero
+        // exit with empty or unparsable JSON is never clean (#1816).
+        const run = parseToolRun("rubocop", {
+            result,
+            // Classify both streams so stderr-only failures reach the parse-error
+            // path, while parseOutput keeps RuboCop's native JSON parser on stdout.
+            output: `${result.stdout}${result.stderr}`,
+            exitCodes: { ran: [1, 2] },
+        }, (output) => parseRubocopJson(output, ctx.filePath, cwd), { parseOutput: result.stdout });
+        if (run.skipped)
+            return run.skipped;
+        return finishParsedRun({
+            tool: "rubocop",
+            ctx,
+            result,
+            diagnostics: run.diagnostics,
+        });
     },
 };
 export default rubocopRunner;

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

@@ -10,6 +10,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
 import { getAutofixCapability, getLinterPolicyForCwd, ruffConfigArgs, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 import { parseRuffOutput } from "./utils/diagnostic-parsers.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, resolveRunnerCwd, } from "./utils/runner-helpers.js";
 const ruff = createAvailabilityChecker("ruff", ".exe");
@@ -65,25 +66,23 @@ const ruffRunner = {
         // Step 1: Capture diagnostics (before fixing) — teaching signal for the agent
         const checkResult = await safeSpawnAsync(cmd, ["check", "--output-format", "json", ...configArgs, ctx.filePath], { cwd, timeout: 30000 });
         const raw = stripAnsi(checkResult.stdout + checkResult.stderr);
-        const diagnostics = parseRuffJson(checkResult.stdout || "", ctx.filePath);
-        const parsedDiagnostics = diagnostics.length > 0 ? diagnostics : parseRuffOutput(raw, ctx.filePath);
-        if (checkResult.status === 0 && parsedDiagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        if (parsedDiagnostics.length === 0) {
-            return {
-                status: "failed",
-                diagnostics: [],
-                semantic: "warning",
-                rawOutput: raw.slice(0, 500),
-            };
-        }
-        const hasErrors = parsedDiagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics: parsedDiagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+        // EXIT TABLE (Ruff 0.6 docs https://docs.astral.sh/ruff/linter/): 0 = clean, 1 = findings, 2 = findings/error or
+        // tool error. A nonzero exit with valid findings stays findings; empty or
+        // unparsable output must never become clean (#1816).
+        const run = parseToolRun("ruff", { result: checkResult, output: raw, exitCodes: { ran: [1, 2] } }, (output) => {
+            const diagnostics = parseRuffJson(output, ctx.filePath);
+            return diagnostics.length > 0
+                ? diagnostics
+                : parseRuffOutput(output, ctx.filePath, cwd);
+        });
+        if (run.skipped)
+            return run.skipped;
+        return finishParsedRun({
+            tool: "ruff",
+            ctx,
+            result: checkResult,
+            diagnostics: run.diagnostics,
+        });
     },
 };
 export default ruffRunner;

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

@@ -4,6 +4,7 @@
  * Runs `cargo clippy` for Rust files to catch common mistakes.
  */
 import { isAbsolute, resolve } from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { rustClient } from "../../rust-client.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { stripAnsi } from "../../sanitize.js";
@@ -125,8 +126,12 @@ const rustClippyRunner = {
         // a crate-mate's pre-existing diagnostic must NOT fail the edited file's
         // turn. Filter to the edited file like golangci-lint — if the edited file
         // is clean, this turn succeeds even when siblings carry warnings/errors.
+        // #3278: one seam for reported-path attribution — see javac.ts. This
+        // member already had the right BASE (`parseClippyOutput` resolves
+        // `span.file` against `cargoDir`); what it lacked was the on-disk
+        // identity predicate.
         const absEdited = resolve(ctx.filePath);
-        const diagnostics = allDiagnostics.filter((d) => resolve(d.filePath) === absEdited);
+        const diagnostics = allDiagnostics.filter((d) => pathsEqual(resolve(cargoDir, d.filePath), absEdited));
         const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
         return {
             status: hasErrors ? "failed" : "succeeded",

package/node_modules/pi-lens/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/node_modules/pi-lens/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/node_modules/pi-lens/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/node_modules/pi-lens/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/node_modules/pi-lens/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;