pi-lens 4.2.0 → 4.3.0

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

@@ -5,7 +5,9 @@
  * Autofix is handled earlier by the post-write pipeline to avoid
  * mutating files mid-dispatch after LSP sync has already happened.
  */
+import * as path from "node:path";
 import { incrementDegradationCount } from "../../degradation-ledger.js";
+import { pathsEqual } from "../../path-utils.js";
 import { mapWithConcurrency } from "../../dependency-checker.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { biomeConfigArgs, getAutofixCapability, getJstsLintPolicyForCwd, } from "../../tool-policy.js";
@@ -50,35 +52,46 @@ export function biomeRuleNameFromCategory(category) {
     const parts = category.split("/");
     return parts[parts.length - 1] || undefined;
 }
-export function parseBiomeJson(raw, filePath, fixKindByRule) {
+export function parseBiomeJson(raw, filePath, cwd, fixKindByRule) {
     try {
         const result = JSON.parse(raw);
         const diagnostics = result.diagnostics || [];
         const autofix = getAutofixCapability("biome");
+        const absTarget = path.resolve(cwd, filePath);
         return {
-            diagnostics: diagnostics.map((d) => {
-                const ruleName = biomeRuleNameFromCategory(d.category);
-                const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
-                const isFixable = fixKind === "safe" || fixKind === "unsafe";
-                return {
-                    id: `biome:${d.category}:${d.location.start.line}`,
-                    message: d.message,
-                    filePath,
-                    line: d.location.start.line,
-                    column: d.location.start.column,
-                    severity: normalizeBiomeSeverity(d.severity),
-                    semantic: d.severity === "error" ? "blocking" : "warning",
-                    tool: "biome",
-                    rule: d.category,
-                    fixable: isFixable,
-                    // Mirrors `biomeClient.fixFileAsync`'s own `lint --write` call
-                    // (no `--unsafe`, clients/biome-client.ts): the pipeline only
-                    // ever applies SAFE fixes, so only "safe" earns autoFixAvailable.
-                    autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
-                    fixKind: isFixable && autofix?.fixKind !== "none"
-                        ? autofix?.fixKind
-                        : undefined,
-                };
+            diagnostics: diagnostics.flatMap((d) => {
+                // #3295: `location.path` is biome's own name for the file each
+                // diagnostic is about; `biome.json` `files.includes` can widen the
+                // run past the argv.
+                if (d.location?.path &&
+                    !pathsEqual(path.resolve(cwd, d.location.path), absTarget))
+                    return [];
+                {
+                    const ruleName = biomeRuleNameFromCategory(d.category);
+                    const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
+                    const isFixable = fixKind === "safe" || fixKind === "unsafe";
+                    return [
+                        {
+                            id: `biome:${d.category}:${d.location.start.line}`,
+                            message: d.message,
+                            filePath,
+                            line: d.location.start.line,
+                            column: d.location.start.column,
+                            severity: normalizeBiomeSeverity(d.severity),
+                            semantic: d.severity === "error" ? "blocking" : "warning",
+                            tool: "biome",
+                            rule: d.category,
+                            fixable: isFixable,
+                            // Mirrors `biomeClient.fixFileAsync`'s own `lint --write` call
+                            // (no `--unsafe`, clients/biome-client.ts): the pipeline only
+                            // ever applies SAFE fixes, so only "safe" earns autoFixAvailable.
+                            autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
+                            fixKind: isFixable && autofix?.fixKind !== "none"
+                                ? autofix?.fixKind
+                                : undefined,
+                        },
+                    ];
+                }
             }),
         };
     }
@@ -248,7 +261,7 @@ const biomeCheckJsonRunner = {
             fixKindByRule = await resolveBiomeFixKinds(cmd, cwd, categories);
         }
         const parsed = checkResult.status === 0 || checkResult.status === 1
-            ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, fixKindByRule)
+            ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, cwd, fixKindByRule)
             : { diagnostics: [] };
         if (parsed.parseError) {
             const raw = checkResult.stdout || checkResult.stderr || "";

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

@@ -1,10 +1,12 @@
 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 { probeToolAsync } from "../../tool-probe.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";
 // Per-compiler availability checkers — each one caches per-cwd and
 // dedupes concurrent --version probes, the same protections every other
 // runner gets via createAvailabilityChecker. cpp-check previously
@@ -112,16 +114,16 @@ async function resolveCompiler(absPath, cwd) {
     }
     return undefined;
 }
-function parseGccLikeOutput(raw, filePath) {
+function parseGccLikeOutput(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*(fatal error|error|warning|note):\s+(.+)$/i);
         if (!match)
             continue;
         const [, sourcePath, lineStr, colStr, severityLabel, message] = match;
-        const resolvedSource = path.resolve(sourcePath.trim());
-        const resolvedTarget = path.resolve(filePath);
-        if (resolvedSource !== resolvedTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
             continue;
         const severity = severityLabel.toLowerCase().includes("error")
             ? "error"
@@ -143,16 +145,16 @@ function parseGccLikeOutput(raw, filePath) {
     }
     return diagnostics;
 }
-function parseMsvcOutput(raw, filePath) {
+function parseMsvcOutput(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*(fatal error|error|warning)\s+([A-Z]+\d+):\s+(.+)$/i);
         if (!match)
             continue;
         const [, sourcePath, lineStr, colStr, severityLabel, rule, message] = match;
-        const resolvedSource = path.resolve(sourcePath.trim());
-        const resolvedTarget = path.resolve(filePath);
-        if (resolvedSource !== resolvedTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
             continue;
         const severity = severityLabel.toLowerCase().includes("error")
             ? "error"
@@ -173,9 +175,6 @@ function parseMsvcOutput(raw, filePath) {
     }
     return diagnostics;
 }
-function firstOutputLine(raw) {
-    return raw.trim().split(/\r?\n/, 1)[0]?.slice(0, 200) ?? "";
-}
 const cppCheckRunner = {
     id: "cpp-check",
     appliesTo: ["cxx"],
@@ -193,44 +192,28 @@ const cppCheckRunner = {
             timeout: 30000,
         });
         const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        const diagnostics = compiler.flavor === "msvc"
-            ? parseMsvcOutput(raw, ctx.filePath)
-            : parseGccLikeOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
-                return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "cpp-check-nonzero-no-diagnostics",
-                            message: firstOutputLine(raw) ||
-                                `${compiler.command} exited non-zero without structured diagnostics`,
-                            filePath: ctx.filePath,
-                            severity: "warning",
-                            semantic: "warning",
-                            tool: "cpp-check",
-                            rule: compiler.command,
-                            fixable: false,
-                        },
-                    ],
-                    semantic: "warning",
-                    rawOutput: raw,
-                };
-            }
-            return {
-                status: "succeeded",
-                diagnostics: [],
-                semantic: "none",
-                rawOutput: raw,
-            };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: "warning",
-            rawOutput: raw,
-        };
+        const parsed = parseToolRun("cpp-check", {
+            result,
+            output: raw,
+            // EXIT TABLE (gcc/clang 13 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (output) => compiler.flavor === "msvc"
+            ? parseMsvcOutput(output, ctx.filePath, cwd)
+            : parseGccLikeOutput(output, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "cpp-check",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+            classify: (diagnostics) => ({
+                status: diagnostics.some((d) => d.severity === "error")
+                    ? "failed"
+                    : "succeeded",
+                semantic: "warning",
+            }),
+        });
     },
 };
 export default cppCheckRunner;

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

@@ -3,6 +3,7 @@ import * as fs from "node:fs";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 import { createCwdCachedProbe } from "./utils/runner-helpers.js";
 const CREDO_PROBE_BUDGET_MS = 10_000;
 // Per-cwd cached `mix credo --version` probe (#120), governed by the shared
@@ -61,20 +62,21 @@ const credoRunner = {
         }
         const absPath = path.resolve(cwd, ctx.filePath);
         const result = await safeSpawnAsync("mix", ["credo", "--format", "json", "--strict", absPath], { timeout: 30000, cwd });
-        // credo exits 1 when issues found, 0 when clean
-        if (result.status === null || result.status > 1) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseCredoJson(result.stdout ?? "", ctx.filePath, cwd);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+        const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+        const parsed = parseToolRun("credo", {
+            result,
+            output,
+            // EXIT TABLE (Credo 1.7 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (raw) => parseCredoJson(raw, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "credo",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default credoRunner;

package/dist/clients/dispatch/runners/cue-vet.js

@@ -104,6 +104,7 @@
 import * as fs from "node:fs";
 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 { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
 import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
@@ -205,10 +206,24 @@ export function hasPackageClause(content) {
     }
     return false;
 }
-/** `.\bad.cue`, `./bad.cue`, and `bad.cue` all name the same file. */
-function locationMatchesFile(location, fileName) {
-    const normalized = location.file.replace(/\\/g, "/").replace(/^\.\//, "");
-    return path.posix.basename(normalized) === fileName;
+/**
+ * Is this reported location 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 and compare through `pathsEqual`.
+ *
+ * `cue` prints every position relative to its own cwd and prefixes a `./` when
+ * the result does not already start with a dot (`cue/errors/errors.go:586-596`
+ * at v0.11.0: `filepath.Rel(cfg.Cwd, s)`), which is why `.\bad.cue`,
+ * `./bad.cue` and `bad.cue` all name the vetted file — `pathsEqual` folds the
+ * separator and the `.` segment, so all three still match.
+ *
+ * What the basename compare this replaces could not do is tell those apart
+ * from `./sub/bad.cue` or `../lib/bad.cue`: an imported package's file that
+ * merely SHARES the touched file's basename was reported as the touched file's
+ * own failure (the over-merge direction, #3278 sub-shape C).
+ */
+function locationMatchesFile(location, absTarget, vetCwd) {
+    return pathsEqual(path.resolve(vetCwd, location.file), absTarget);
 }
 function toDiagnostic(id, message, fileName, line, column) {
     return {
@@ -252,16 +267,19 @@ function toDiagnostic(id, message, fileName, line, column) {
  * whole-output fallback message is used instead of one row per parsed
  * header.
  */
-export function filterToTouchedFile(errors, fileName) {
+export function filterToTouchedFile(errors, fileName, vetCwd) {
     if (errors.length === 0)
         return undefined;
+    // `cue vet` always runs in the touched file's own directory, so the vet cwd
+    // joined with the bare file name IS the dispatched file.
+    const absTarget = path.resolve(vetCwd, fileName);
     const withLocation = errors.filter((error) => error.locations.length > 0);
     const unattributable = errors.filter((error) => error.locations.length === 0);
     if (withLocation.length === 0)
         return undefined;
     const diagnostics = [];
     for (const error of withLocation) {
-        const match = error.locations.find((location) => locationMatchesFile(location, fileName));
+        const match = error.locations.find((location) => locationMatchesFile(location, absTarget, vetCwd));
         if (!match)
             continue; // sibling-only finding — surfaces when that file is touched
         diagnostics.push(toDiagnostic(`cue-vet-${diagnostics.length + 1}-${match.line}`, error.message, fileName, match.line, match.column));
@@ -364,7 +382,7 @@ const cueVetRunner = {
         // the directory-scoped path — one code path, and a single-file run
         // that somehow fails with no location at all still gets the same
         // never-silently-clean `undefined` fallback as the directory path.
-        const filtered = filterToTouchedFile(errors, fileName);
+        const filtered = filterToTouchedFile(errors, fileName, fileDir);
         if (filtered === undefined) {
             // Nonzero exit, some output, but nothing in it could be attributed to
             // ANY file — a real failure must not present as zero findings.

package/dist/clients/dispatch/runners/dart-analyze.js

@@ -1,7 +1,9 @@
 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 { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 import { PRIORITY } from "../priorities.js";
 const dart = createAvailabilityChecker("dart", ".exe");
 const flutter = createAvailabilityChecker("flutter", ".bat");
@@ -94,8 +96,9 @@ const DART_FIXABLE_RULES = new Set([
 ]);
 // dart analyze --format=machine output:
 // severity|type|code|file|line|col|length|message
-function parseDartMachineOutput(raw, filePath) {
+function parseDartMachineOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         if (!line.trim())
             continue;
@@ -106,14 +109,16 @@ function parseDartMachineOutput(raw, filePath) {
         const message = messageParts.join("|").trim();
         const lineNum = parseInt(lineStr, 10);
         const colNum = parseInt(colStr, 10);
-        // Only include diagnostics for the target file
-        if (file &&
-            !path.resolve(file).endsWith(path.resolve(filePath).replace(/\\/g, "/"))) {
-            const resolvedFile = path.resolve(file.trim());
-            const resolvedTarget = path.resolve(filePath);
-            if (resolvedFile !== resolvedTarget)
-                continue;
-        }
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        // The `endsWith` outer arm this replaces was inert on the target (a
+        // string ends with itself) and an over-merge risk everywhere else: any
+        // reported path whose TAIL spelled the absolute target attached to it.
+        // `file` is `parts[3]`, which `tsconfig.strict-indexed.json`
+        // (`noUncheckedIndexedAccess`) types as `string | undefined` even behind the
+        // `parts.length < 8` guard above — the strictness ratchet pins that, so the
+        // optional chain stays.
+        if (!pathsEqual(path.resolve(cwd, file?.trim() ?? ""), absTarget))
+            continue;
         const severity = severityStr?.trim().toLowerCase() === "error" ? "error" : "warning";
         const ruleId = code?.trim() ?? "dart";
         const fixable = DART_FIXABLE_RULES.has(ruleId);
@@ -136,12 +141,6 @@ function parseDartMachineOutput(raw, filePath) {
     }
     return diagnostics;
 }
-function firstOutputLine(result) {
-    return `${result.stderr || ""}\n${result.stdout || ""}`
-        .trim()
-        .split(/\r?\n/, 1)[0]
-        .slice(0, 200);
-}
 const dartAnalyzeRunner = {
     id: "dart-analyze",
     appliesTo: ["dart"],
@@ -162,40 +161,22 @@ const dartAnalyzeRunner = {
             ? ["analyze", "--format=machine", absPath]
             : ["analyze", "--machine", absPath];
         const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 30000 });
-        if (result.error && !result.stdout && !result.stderr) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
         // dart analyze writes diagnostics to stderr in machine format
         const raw = (result.stderr || "") + (result.stdout || "");
-        const diagnostics = parseDartMachineOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
-                return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "dart-analyze-nonzero-no-diagnostics",
-                            message: firstOutputLine(result) ||
-                                "dart analyze exited non-zero without machine diagnostics",
-                            filePath: ctx.filePath,
-                            severity: "warning",
-                            semantic: "warning",
-                            tool: "dart",
-                            rule: "dart-analyze",
-                            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: hasErrors ? "blocking" : "warning",
-        };
+        const parsed = parseToolRun("dart-analyze", {
+            result,
+            output: raw,
+            // EXIT TABLE (Dart 3.5 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseDartMachineOutput(out, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "dart-analyze",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+        });
     },
 };
 export default dartAnalyzeRunner;

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

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 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 } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
@@ -91,13 +92,14 @@ export function findDetektConfig(cwd) {
     return undefined;
 }
 // detekt text output: /path/file.kt:10:5: error: Message [RuleId]
-function parseDetektOutput(raw, filePath) {
+function parseDetektOutput(raw, filePath, cwd) {
     const diagnostics = [];
     const pattern = /^(.+?):(\d+):(\d+): (error|warning): (.+?)(?:\s+\[([^\]]+)\])?$/gm;
-    const absTarget = path.resolve(filePath);
+    const absTarget = path.resolve(cwd, filePath);
     for (const match of raw.matchAll(pattern)) {
         const [, file, lineStr, colStr, level, message, rule] = match;
-        if (path.resolve(file.trim()) !== absTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, file.trim()), absTarget))
             continue;
         const severity = level === "error" ? "error" : "warning";
         const lineNum = Number.parseInt(lineStr, 10);
@@ -150,7 +152,12 @@ const detektRunner = {
         // read the same concatenated string. A nonzero exit that yields zero
         // findings out of real output is a parser break, not clean Kotlin.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const run = parseToolRun("detekt", { result, output: raw }, (out) => parseDetektOutput(out, ctx.filePath));
+        const run = parseToolRun("detekt", {
+            result,
+            output: raw,
+            // EXIT TABLE (detekt 1.23 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (out) => parseDetektOutput(out, ctx.filePath, cwd));
         if (run.skipped)
             return run.skipped;
         const diagnostics = run.diagnostics;

package/dist/clients/dispatch/runners/dotnet-build.js

@@ -1,9 +1,11 @@
 import * as fs from "node:fs";
 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 { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const dotnet = createAvailabilityChecker("dotnet", ".exe");
 function findProjectTarget(cwd) {
     const entries = fs.readdirSync(cwd);
@@ -83,16 +85,16 @@ function parseDotnetDiagnosticLine(line) {
     }
     return { reportedFile, lineStr, colStr, severityLabel, rule, message };
 }
-function parseDotnetBuildOutput(raw, filePath) {
+function parseDotnetBuildOutput(raw, filePath, cwd) {
     const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
     for (const line of raw.split(/\r?\n/)) {
         const parsed = parseDotnetDiagnosticLine(line);
         if (!parsed)
             continue;
         const { reportedFile, lineStr, colStr, severityLabel, rule, message } = parsed;
-        const resolvedReported = path.resolve(reportedFile);
-        const resolvedTarget = path.resolve(filePath);
-        if (resolvedReported !== resolvedTarget)
+        // #3278: one seam for reported-path attribution — see javac.ts.
+        if (!pathsEqual(path.resolve(cwd, reportedFile), absTarget))
             continue;
         const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
         const lineNum = Number.parseInt(lineStr, 10) || 1;
@@ -136,24 +138,27 @@ const dotnetBuildRunner = {
             timeout: 60000,
         });
         const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        if (result.status === 0 && !raw) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseDotnetBuildOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return {
-                status: result.status === 0 ? "succeeded" : "failed",
-                diagnostics: [],
-                semantic: "warning",
-                rawOutput: raw,
-            };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+        const parsed = parseToolRun("dotnet-build", {
+            result,
+            output: raw,
+            // EXIT TABLE (.NET SDK 8 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
+            exitCodes: { ran: [1, 2] },
+        }, (output) => parseDotnetBuildOutput(output, ctx.filePath, cwd));
+        if (parsed.skipped)
+            return parsed.skipped;
+        return finishParsedRun({
+            tool: "dotnet-build",
+            ctx,
+            result,
+            diagnostics: parsed.diagnostics,
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: hasErrors ? "failed" : "succeeded",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default dotnetBuildRunner;