@herbertgao/pi-extensions 2026.9.14 → 2026.9.16

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

@@ -1,28 +1,108 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { stripAnsi } from "../../sanitize.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
 import { PRIORITY } from "../priorities.js";
 const gleam = createAvailabilityChecker("gleam", ".exe");
-function parseGleamOutput(raw, filePath) {
+/**
+ * gleam renders every located diagnostic through
+ * `codespan_reporting::term::emit` (v1.18.1
+ * `compiler-core/src/diagnostic.rs:92-133`, unchanged since v1.6.3), so its
+ * location line is codespan's LOCUS line, not a bare `path:line:col`:
+ *
+ * ```text
+ * error: Type mismatch
+ *   ┌─ /abs/proj/src/app.gleam:1:8
+ * ```
+ *
+ * `<outer gutter spaces> ┌─ <name>:<line>:<column>` —
+ * codespan-reporting 0.13.1 `src/term/renderer.rs:379-396` (the gutter, then
+ * `chars().snippet_start`, then one space, then the locus) and `:869-878`
+ * (`{name}:{line_number}:{column_number}`), with `snippet_start` = `┌─` in the
+ * default box-drawing set (`src/term/config.rs:419-429`, reached because gleam
+ * passes `Config::default()`, whose display style is Rich).
+ *
+ * `name` is `location.path` verbatim (`diagnostic.rs:92-94`,
+ * `files.add(main_location_path, …)`), and the CLI builds that path by walking
+ * UP from the absolute `std::env::current_dir()` to the nearest `gleam.toml`
+ * (`compiler-cli/src/fs.rs:32-62`) and joining `src`/`test`
+ * (`compiler-core/src/paths.rs:42-48`) before enumerating the directory — so it
+ * is ABSOLUTE, with host-native separators. Resolving it against the cwd the
+ * tool ran in is therefore a no-op today and the ADR 0009 shape for the
+ * hypothetical relative spelling.
+ *
+ * Capturing the path REQUIRES matching the gutter: the pre-#3285 regex
+ * `/^(.+?):(\d+):(\d+)$/` captured `  ┌─ /abs/proj/src/app.gleam`, gutter
+ * included, and only an `endsWith` compare tolerated that. An equality
+ * predicate (the seam every other runner now uses) drops every gleam diagnostic
+ * unless the gutter is out of the capture — which is why PR #3284 reverted its
+ * own fold here and filed #3285.
+ */
+const GLEAM_LOCUS = /^\s*┌─\s+(.+?):(\d+):(\d+)$/;
+const GLEAM_HEADER = /^\s*(error|warning):\s*(.+?)\s*$/;
+const GLEAM_LABEL = /^\s*│\s*\^+\s*(.*?)\s*$/;
+/**
+ * codespan writes ONE title line per diagnostic and then everything that
+ * belongs to it — locus, borders, snippet, labels, notes — before the next
+ * title (`codespan-reporting` 0.13.1 `src/term/renderer.rs:141-210`). Splitting
+ * on the title is therefore the diagnostic boundary, and it is what keeps an
+ * adjacent diagnostic's label out of its predecessor's message. Lines before
+ * the first title are gleam's own progress output (`Compiling demo`), which
+ * belongs to no diagnostic.
+ */
+function gleamBlocks(lines) {
+    const blocks = [];
+    for (const line of lines) {
+        const header = line.match(GLEAM_HEADER);
+        if (header)
+            blocks.push({ header, body: [] });
+        else
+            blocks.at(-1)?.body.push(line);
+    }
+    return blocks;
+}
+function gleamMessage(title, body) {
+    const labels = body.flatMap((line) => line.match(GLEAM_LABEL)?.[1]?.trim() || []);
+    return labels.length > 0 ? `${title} — ${labels.join(" ")}` : title;
+}
+function parseGleamOutput(raw, filePath, cwd) {
     const diagnostics = [];
-    const lines = raw.split(/\r?\n/);
-    for (let i = 0; i < lines.length; i++) {
-        const location = lines[i].match(/^(.+?):(\d+):(\d+)$/);
+    const absTarget = path.resolve(cwd, filePath);
+    // `stripAnsi` (the seam `ruff.ts`, `go-vet.ts` and `rust-clippy.ts` already
+    // use): gleam colours the gutter whenever `FORCE_COLOR` is set non-empty,
+    // whatever stderr is (`compiler-cli/src/cli.rs:194-207` — `ColorChoice::Never`
+    // only when it is neither forced nor a terminal), and the SGR bytes sit
+    // between the line start and `┌─`. The old suffix compare never saw the
+    // prefix; an anchored capture would drop every diagnostic in that
+    // environment.
+    const lines = stripAnsi(raw).split(/\r?\n/);
+    for (const { header, body } of gleamBlocks(lines)) {
+        const severity = header[1] === "warning" ? "warning" : "error";
+        const title = `${header[1]}: ${header[2]}`;
+        // A Gleam diagnostic with NO locus describes the whole project: `check`
+        // receives no file argument (`Diagnostic::write_title`, no codespan emit).
+        // Leave it for the nonzero-without-diagnostics fallback instead of
+        // charging it to whichever file happened to trigger dispatch — ADR 0009:
+        // without a reported path there is no evidence it is about this file.
+        const location = body
+            .find((line) => GLEAM_LOCUS.test(line))
+            ?.match(GLEAM_LOCUS);
         if (!location)
             continue;
         const [, sourcePath, lineStr, colStr] = location;
-        if (!sourcePath.replace(/\\/g, "/").endsWith(filePath.replace(/\\/g, "/"))) {
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
             continue;
-        }
-        const message = lines.slice(i + 1).find((line) => line.trim().length > 0);
         diagnostics.push({
             id: `gleam-check-${lineStr}-${colStr}`,
-            message: message?.trim() || "gleam check reported an error",
+            message: gleamMessage(title, body),
             filePath,
             line: Number.parseInt(lineStr, 10) || 1,
             column: Number.parseInt(colStr, 10) || 1,
-            severity: "error",
-            semantic: "blocking",
+            severity,
+            semantic: severity === "error" ? "blocking" : "warning",
             tool: "gleam",
             rule: "gleam-check",
             fixable: false,
@@ -54,7 +134,7 @@ const gleamCheckRunner = {
         if (result.error && !result.stdout && !result.stderr) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const diagnostics = parseGleamOutput(`${result.stderr || ""}\n${result.stdout || ""}`, ctx.filePath);
+        const diagnostics = parseGleamOutput(`${result.stderr || ""}\n${result.stdout || ""}`, ctx.filePath, cwd);
         if (diagnostics.length === 0) {
             if (result.status && result.status !== 0) {
                 return {

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

@@ -5,6 +5,7 @@
  */
 import { relative, resolve, sep, posix } from "node:path";
 import { goClient } from "../../go-client.js";
+import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { stripAnsi } from "../../sanitize.js";
@@ -71,15 +72,28 @@ const goVetRunner = {
         // cwd before comparing, so go's path FORM (a leading `./` for the
         // module-root package, an absolute path, `.` segments) can't cause the
         // edited file's OWN diagnostics to be silently dropped.
+        //
+        // #3277: resolving is not enough — the two sides are SPELLED by
+        // different actors. `ctx.filePath` is `normalizeMapKey`-canonical
+        // (#2016) while go prints its own spelling: `cmd/go` rewrites the
+        // package-dir prefix to a cwd-relative one only when the rewrite
+        // matches byte-for-byte (`replacePrefix`), even though the check that
+        // authorized it (`filepath.Rel`) compares case-insensitively on
+        // Windows, so a differently-cased ABSOLUTE path reaches this filter.
+        // A bare `===` then drops every line for the edited file and the run
+        // is reported clean — the #209 defect. `pathsEqual` asks the
+        // filesystem instead of a platform list, so it is also right on a
+        // case-folding POSIX mount. It does NOT resolve symlinks on POSIX
+        // (`clients/path-utils.ts:181`); nothing here relies on that.
         const absTarget = resolve(ctx.filePath);
         const relevant = raw
             .split("\n")
             .filter((line) => {
             const m = line.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
-            return m != null && resolve(cwd, m[1].trim()) === absTarget;
+            return m != null && pathsEqual(resolve(cwd, m[1].trim()), absTarget);
         })
             .join("\n");
-        const diagnostics = parseGoVetOutput(relevant, ctx.filePath);
+        const diagnostics = parseGoVetOutput(relevant, ctx.filePath, cwd);
         // Edited file clean → succeeded: a sibling-file error no longer flags
         // the edited file's turn (it surfaces when that file is itself edited).
         return diagnostics.length > 0

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

@@ -11,10 +11,12 @@
  */
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { pathsEqual } from "../../path-utils.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd, hasGolangciConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const golangci = createAvailabilityChecker("golangci-lint", ".exe");
 /**
  * Summarize a golangci-lint Replacement into a single-line fixSuggestion.
@@ -39,13 +41,21 @@ function describeReplacement(replacement) {
     }
     return "Apply golangci-lint suggested fix";
 }
-function parseGolangciJson(raw, filePath) {
+function parseGolangciJson(raw, filePath, cwd) {
     try {
         const output = JSON.parse(raw);
         if (!output.Issues)
             return [];
-        const absFile = path.resolve(filePath);
-        return output.Issues.filter((issue) => path.resolve(issue.Pos.Filename) === absFile).map((issue) => {
+        const absFile = path.resolve(cwd, filePath);
+        // #3278: one seam for reported-path attribution — see javac.ts. The base
+        // matters here more than anywhere else in the family: golangci-lint's
+        // `PathPrettifier` OVERWRITES `Pos.Filename` with `filepath.Rel(basePath,
+        // …)` before the JSON printer sees it (v1.64.8,
+        // `pkg/result/processors/path_prettifier.go:31` +
+        // `path_relativity.go:43`), so the spelling is relative to the child's
+        // base path — the `cwd` we spawned it in — and `path.resolve` with no
+        // base resolved it against the EXTENSION's cwd instead.
+        return output.Issues.filter((issue) => pathsEqual(path.resolve(cwd, issue.Pos.Filename), absFile)).map((issue) => {
             const severity = issue.Severity === "error" ? "error" : "warning";
             // golangci-lint's --out-format=json emits a Replacement object per
             // issue when `golangci-lint run --fix` would deterministically
@@ -95,26 +105,31 @@ const golangciRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         // Run on the specific file. golangci-lint accepts file paths directly.
         const result = await safeSpawnAsync(cmd, ["run", "--out-format=json", ctx.filePath], { timeout: 60000, cwd });
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseGolangciJson(result.stdout, ctx.filePath);
-        let semantic = "none";
-        if (diagnostics.some((d) => d.semantic === "blocking")) {
-            semantic = "blocking";
-        }
-        else if (diagnostics.length > 0) {
-            semantic = "warning";
-        }
-        if (semantic === "none") {
-            // Non-zero exit but no parseable issues — likely a config/tool error
-            return { status: "skipped", diagnostics: [], semantic };
-        }
-        return {
-            status: semantic === "blocking" ? "failed" : "succeeded",
-            diagnostics,
-            semantic,
-        };
+        // Exit table: 0 is clean-or-findings; 1 means issues, 3 failure,
+        // 4 timeout, and 5 missing config. Every nonzero code is a ran outcome
+        // whose parser decides: JSON issues remain findings, while emitted
+        // non-JSON text becomes a parse-error diagnostic and no output stays
+        // skipped. Keep stderr as the parse input when stdout is absent so tool
+        // errors cannot be mistaken for a clean file.
+        const raw = (result.stdout ?? "").length > 0
+            ? (result.stdout ?? "")
+            : result.status !== 0
+                ? result.stderr || ""
+                : "";
+        const parsed = parseToolRun("golangci-lint", {
+            result,
+            output: raw,
+            // EXIT TABLE (golangci-lint 1.60 docs https://golangci-lint.run/docs/welcome/quick-start/): 0 clean; 1 findings; 2 error; 3 error; 4 error; 5 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2, 3, 4, 5] },
+        }, (raw) => parseGolangciJson(raw, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "golangci-lint",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default golangciRunner;

package/node_modules/pi-lens/dist/clients/dispatch/runners/hadolint.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";
@@ -7,25 +8,32 @@ import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } fro
 import { parseToolRun } from "./utils/tool-failure.js";
 import { finishParsedRun } from "./utils/tool-failure.js";
 const hadolint = createAvailabilityChecker("hadolint", ".exe");
-function parseHadolintOutput(raw, filePath) {
+function parseHadolintOutput(raw, filePath, cwd) {
     try {
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed))
             return [];
-        return parsed.map((item) => {
+        const absTarget = path.resolve(cwd, filePath);
+        return parsed.flatMap((item) => {
+            // #3295: hadolint takes a LIST of Dockerfiles and names each finding's
+            // own `file`.
+            if (item.file && !pathsEqual(path.resolve(cwd, item.file), absTarget))
+                return [];
             const severity = item.level === "error" ? "error" : "warning";
-            return {
-                id: `hadolint-${item.code}-${item.line}`,
-                message: `[${item.code}] ${item.message}`,
-                filePath,
-                line: item.line,
-                column: item.column ?? 1,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "hadolint",
-                rule: item.code,
-                fixable: false,
-            };
+            return [
+                {
+                    id: `hadolint-${item.code}-${item.line}`,
+                    message: `[${item.code}] ${item.message}`,
+                    filePath,
+                    line: item.line,
+                    column: item.column ?? 1,
+                    severity,
+                    semantic: severity === "error" ? "blocking" : "warning",
+                    tool: "hadolint",
+                    rule: item.code,
+                    fixable: false,
+                },
+            ];
         });
     }
     catch {
@@ -57,7 +65,11 @@ const hadolintRunner = {
         // #1948: hadolint runs with `--no-fail`, so it exits 0 even when it finds
         // something. A nonzero exit therefore means hadolint itself failed, and
         // zero parsed diagnostics out of whatever it printed is a parser break.
-        const run = parseToolRun("hadolint", { result }, (out) => parseHadolintOutput(out, ctx.filePath));
+        const run = parseToolRun("hadolint", {
+            result,
+            // EXIT TABLE (Hadolint 2.12 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseHadolintOutput(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

package/node_modules/pi-lens/dist/clients/dispatch/runners/htmlhint.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";
@@ -15,19 +16,22 @@ const HTMLHINT_RULES = {
     "spec-char-escape": true,
     "id-unique": true,
 };
-function parseHtmlhintOutput(raw, filePath) {
+function parseHtmlhintOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     // unix format: "file:line:col: message [severity/rule]"
-    const lineRe = /^.+?:(\d+):(\d+): (.+?) \[(error|warning)\/([^\]]+)\]/;
+    const lineRe = /^(.+?):(\d+):(\d+): (.+?) \[(error|warning)\/([^\]]+)\]/;
     for (const line of raw.split("\n")) {
         const match = line.match(lineRe);
         if (!match)
             continue;
-        const lineNum = parseInt(match[1], 10);
-        const col = parseInt(match[2], 10);
-        const message = match[3].trim();
-        const level = match[4];
-        const rule = match[5].trim();
+        if (!pathsEqual(path.resolve(cwd, match[1]), absTarget))
+            continue;
+        const lineNum = parseInt(match[2], 10);
+        const col = parseInt(match[3], 10);
+        const message = match[4].trim();
+        const level = match[5];
+        const rule = match[6].trim();
         const severity = level === "error" ? "error" : "warning";
         diagnostics.push({
             id: `htmlhint-${rule}-${lineNum}`,
@@ -86,7 +90,12 @@ const htmlhintRunner = {
         // #1948: htmlhint exits 1 when it finds errors and prints them in `unix`
         // format on stdout. Zero parsed out of a nonzero exit is a parser break.
         const output = result.stdout || result.stderr || "";
-        const run = parseToolRun("htmlhint", { result, output }, (out) => parseHtmlhintOutput(out, ctx.filePath));
+        const run = parseToolRun("htmlhint", {
+            result,
+            output,
+            // EXIT TABLE (HTMLHint 1.1 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseHtmlhintOutput(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

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

@@ -1,21 +1,29 @@
 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 { hasJavaBuildDescriptor } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const javac = createAvailabilityChecker("javac", ".exe");
-function parseJavacOutput(raw, filePath) {
+function parseJavacOutput(raw, filePath, cwd) {
     const diagnostics = [];
     const lines = raw.split(/\r?\n/);
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of lines) {
         const match = line.match(/^(.*?\.java):(\d+):\s+(error|warning):\s+(.+)$/i);
         if (!match)
             continue;
         const [, reportedFile, lineStr, severityLabel, message] = match;
-        const resolvedReported = path.resolve(reportedFile.trim());
-        const resolvedTarget = path.resolve(filePath);
-        if (resolvedReported !== resolvedTarget)
+        // Is this reported diagnostic about the file we dispatched for? ONE seam
+        // answers that for every runner (#3278): resolve the tool's spelling against
+        // the cwd the tool RAN in — never `process.cwd()`, which is the extension's,
+        // not the runner's — and compare through `pathsEqual`, the repo's on-disk
+        // identity predicate. A bare `===` treats a spelling that differs only in
+        // case (the same file on Windows and on a case-folding POSIX mount) as a
+        // different file and drops every finding for the edited file (#209, #3277).
+        if (!pathsEqual(path.resolve(cwd, reportedFile.trim()), absTarget))
             continue;
         const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
         const lineNum = Number.parseInt(lineStr, 10) || 1;
@@ -66,24 +74,26 @@ const javacRunner = {
             timeout: 30000,
         });
         const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        if (result.status === 0 && !raw) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseJavacOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return {
-                status: result.status === 0 ? "succeeded" : "failed",
-                diagnostics: [],
+        const parsed = parseToolRun("javac", {
+            result,
+            output: raw,
+            // EXIT TABLE (javac 21 docs https://docs.oracle.com/en/java/javase/21/docs/specs/man/javac.html): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (output) => parseJavacOutput(output, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "javac",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+            classify: (diagnostics) => ({
+                status: diagnostics.some((d) => d.severity === "error")
+                    ? "failed"
+                    : "succeeded",
                 semantic: "warning",
-                rawOutput: raw,
-            };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: "warning",
-        };
+            }),
+        });
     },
 };
 export default javacRunner;

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

@@ -1,10 +1,21 @@
 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, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const ktlint = createAvailabilityChecker("ktlint", ".exe");
+// KtLint's exit contract, declared HERE rather than in the shared classifier:
+// an admission is a property of this tool, and #3291 round 2 shipped it through
+// a shared `parseToolRun` option that silently erased every OTHER runner's
+// table. KtLint 1.8.0's CLI page documents the JSON reporter and a nonzero exit
+// on violations, but does not enumerate numeric classes; 1, 2 and 3 are the
+// statuses this runner observes carrying a valid reporter payload, and a valid
+// payload is the evidence that analysis was reached. Any other nonzero status
+// stays a rejected invocation.
+const KTLINT_EXIT_CODES = { ran: [1, 2, 3] };
 function normalizeKtlintResults(parsed) {
     if (Array.isArray(parsed)) {
         return parsed;
@@ -16,14 +27,19 @@ function normalizeKtlintResults(parsed) {
     }
     return null;
 }
-function parseKtlintOutput(raw, filePath) {
+function parseKtlintOutput(raw, filePath, cwd) {
     try {
         const parsed = normalizeKtlintResults(JSON.parse(raw));
         if (!parsed)
             return null;
         const autofix = getAutofixCapability("ktlint");
         const diagnostics = [];
+        const absTarget = path.resolve(cwd, filePath);
         for (const result of parsed) {
+            // #3295: ktlint's JSON reporter is an array of FILES; `.editorconfig`
+            // globs put more than the argv in it.
+            if (result.file && !pathsEqual(path.resolve(cwd, result.file), absTarget))
+                continue;
             for (const err of result.errors ?? []) {
                 diagnostics.push({
                     id: `ktlint-${err.ruleId}-${err.line}-${err.col}`,
@@ -47,12 +63,6 @@ function parseKtlintOutput(raw, filePath) {
         return null;
     }
 }
-function firstOutputLine(result) {
-    return (result.stderr || result.stdout || "")
-        .trim()
-        .split(/\r?\n/, 1)[0]
-        .slice(0, 200);
-}
 const ktlintRunner = {
     id: "ktlint",
     appliesTo: ["kotlin"],
@@ -78,59 +88,23 @@ const ktlintRunner = {
             cwd,
             timeout: 30000,
         });
-        // Ktlint exits non-zero when issues are found, so only treat a total lack
-        // of output as a hard skip. Any non-empty but unparseable output should
-        // surface as runner failure instead of a false clean result.
-        if (result.error && !result.stdout) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseKtlintOutput(result.stdout || "", ctx.filePath);
-        if (diagnostics === null) {
-            const detail = firstOutputLine(result) || "Unknown ktlint output";
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: "ktlint-output-unparseable",
-                        message: `Unable to parse ktlint output: ${detail}`,
-                        filePath: ctx.filePath,
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "ktlint",
-                        fixable: false,
-                        autoFixAvailable: false,
-                    },
-                ],
-                semantic: "warning",
-            };
-        }
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
-                return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "ktlint-nonzero-no-diagnostics",
-                            message: firstOutputLine(result) ||
-                                "ktlint exited non-zero without JSON diagnostics",
-                            filePath: ctx.filePath,
-                            severity: "warning",
-                            semantic: "warning",
-                            tool: "ktlint",
-                            fixable: false,
-                            autoFixAvailable: false,
-                        },
-                    ],
-                    semantic: "warning",
-                };
-            }
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: result.status && result.status !== 0 ? "failed" : "succeeded",
-            diagnostics,
-            semantic: "warning",
-        };
+        // `output` is what the classifier judges AND what the parser reads: ktlint
+        // writes its reporter payload to stdout and its errors to stderr, so both
+        // are one wire here. The exit table rides in this same per-runner input,
+        // never in a shared option (#3291 r3).
+        const run = parseToolRun("ktlint", {
+            result,
+            output: `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
+            exitCodes: KTLINT_EXIT_CODES,
+        }, (output) => parseKtlintOutput(output, ctx.filePath, cwd) ?? []);
+        if (run.skipped)
+            return run.skipped;
+        return finishParsedRun({
+            tool: "ktlint",
+            ctx,
+            result,
+            diagnostics: run.diagnostics,
+        });
     },
 };
 export default ktlintRunner;

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

@@ -13,6 +13,7 @@
  */
 import { logExtension } from "../../extension-log.js";
 import { getLspCapableKinds } from "../../language-policy.js";
+import { exceedsLspSyncLimits } from "../../lsp/content-limits.js";
 import { touchCoverageGap } from "../../lsp/diagnostic-binding.js";
 import { getLSPService } from "../../lsp/index.js";
 import { LSP_SERVERS } from "../../lsp/server.js";
@@ -25,8 +26,6 @@ import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../aux
 import { readFileContent } from "./utils.js";
 import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics, } from "../../warm-attach.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;
 // Diagnostics-wait cap for the dispatch lsp-runner. Bounded so a slow LSP
 // (typescript-language-server on large monorepos has been observed >7 s)
@@ -133,9 +132,11 @@ const lspRunner = {
         if (!content) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const sizeBytes = Buffer.byteLength(content, "utf-8");
-        const lineCount = content.split("\n").length;
-        if (sizeBytes > LSP_MAX_FILE_BYTES || lineCount > LSP_MAX_FILE_LINES) {
+        // #3405 r2: was an inline second copy of the pipeline's byte/line
+        // predicate. One module owns the bound now (M3406-1's root cause was that
+        // a third writer could be added with neither copy); the SKIP is still this
+        // runner's own policy.
+        if (exceedsLspSyncLimits(content).tooLarge) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         // Cross-cutting auxiliary scanners (opengrep, …) attach alongside the