@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-lens/clients/dispatch/runners/ktlint.js

@@ -1,5 +1,7 @@
 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
@@ -9,7 +11,9 @@ import {
   createAvailabilityChecker,
   resolveToolCommandWithInstallFallback
 } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
 const ktlint = createAvailabilityChecker("ktlint", ".exe");
+const KTLINT_EXIT_CODES = { ran: [1, 2, 3] };
 function normalizeKtlintResults(parsed) {
   if (Array.isArray(parsed)) {
     return parsed;
@@ -19,14 +23,17 @@ 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) {
+      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}`,
@@ -49,16 +56,13 @@ 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"],
   priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "ktlint");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("ktlint")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -76,55 +80,20 @@ const ktlintRunner = {
       cwd,
       timeout: 30000
     });
-    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"
-    };
+    const run = parseToolRun("ktlint", {
+      result,
+      output: `${result.stdout ?? ""}
+${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/extensions/dm-lens/clients/dispatch/runners/lsp.js

@@ -1,5 +1,6 @@
 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";
@@ -18,8 +19,6 @@ import {
   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;
 export const LSP_DIAGNOSTICS_WAIT_MS = 2500;
 const MAX_CODE_ACTION_TITLES = 3;
@@ -58,16 +57,14 @@ const lspRunner = {
     let lspClientReady = true;
     let diagnosticsInconclusive = false;
     let unconfirmedServerIds = [];
+    let deferredServerIds = [];
     let usedWarmAttach = false;
     let failureReason = "";
     const content = readFileContent(ctx.filePath);
     if (!content) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
-    const sizeBytes = Buffer.byteLength(content, "utf-8");
-    const lineCount = content.split(`
-`).length;
-    if (sizeBytes > LSP_MAX_FILE_BYTES || lineCount > LSP_MAX_FILE_LINES) {
+    if (exceedsLspSyncLimits(content).tooLarge) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const auxiliaryServerIds = enabledAuxiliaryLspServerIds((f) => ctx.pi.getFlag(f));
@@ -94,6 +91,7 @@ const lspRunner = {
         lspDiags = touched.diags;
         diagnosticsInconclusive = touched.inconclusive === true;
         unconfirmedServerIds = touchCoverageGap(touched);
+        deferredServerIds = touched.deferredServerIds ?? [];
       }
     } catch (err) {
       serverFailed = true;
@@ -133,6 +131,15 @@ const lspRunner = {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     if (lspDiags.length === 0) {
+      if (deferredServerIds.length > 0) {
+        return {
+          status: "deferred",
+          diagnostics: [],
+          semantic: "none",
+          unconfirmedServerIds: [...unconfirmedServerIds],
+          deferredServerIds: [...deferredServerIds]
+        };
+      }
       if (unconfirmedServerIds.length > 0) {
         return {
           status: "skipped",
@@ -189,12 +196,15 @@ const lspRunner = {
     const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
     const resultSemantic = hasErrors ? "blocking" : keptDiagnostics.length > 0 ? "warning" : "none";
     return {
-      status: hasErrors ? "failed" : "succeeded",
+      status: hasErrors ? "failed" : deferredServerIds.length > 0 ? "deferred" : "succeeded",
       failureKind: hasErrors ? "blocking_diagnostics" : undefined,
       diagnostics: keptDiagnostics,
       semantic: resultSemantic,
       ...unconfirmedServerIds.length > 0 && {
         unconfirmedServerIds: [...unconfirmedServerIds]
+      },
+      ...deferredServerIds.length > 0 && {
+        deferredServerIds: [...deferredServerIds]
       }
     };
   }

package/extensions/dm-lens/clients/dispatch/runners/markdownlint.js

@@ -1,4 +1,7 @@
+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
@@ -51,15 +54,18 @@ const MARKDOWNLINT_FIXABLE_RULES = new Set([
   "MD053",
   "MD058"
 ]);
-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;
-    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;
+    if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
+      continue;
     const ruleName = ruleCode.split("/")[0];
     const fixable = MARKDOWNLINT_FIXABLE_RULES.has(ruleName);
     diagnostics.push({
@@ -84,7 +90,7 @@ const markdownlintRunner = {
   priority: PRIORITY.DOC_QUALITY,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "markdownlint");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("markdownlint")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -98,7 +104,7 @@ const markdownlintRunner = {
     if (!cmd)
       return { status: "skipped", diagnostics: [], semantic: "none" };
     if (isInSpawnTimeoutCooldown(cmd)) {
-      ctx.log(`markdownlint: ${cmd} is cooling down after a spawn timeout — skipping (one bounded failure budget per edit)`);
+      logRunnerAdvisoryOnce(ctx, "markdownlint", cwd, `markdownlint: ${cmd} is cooling down after a spawn timeout — skipping (one bounded failure budget per edit)`);
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const configArgs = markdownlintConfigArgs(cwd);
@@ -116,7 +122,7 @@ const markdownlintRunner = {
       });
     }
     const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    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/extensions/dm-lens/clients/dispatch/runners/mypy.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { hasMypyConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import {
@@ -43,7 +44,7 @@ const mypyRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "mypy");
     if (!hasMypyConfig(cwd)) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }

package/extensions/dm-lens/clients/dispatch/runners/oxlint.js

@@ -1,5 +1,8 @@
+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";
 import {
   getJstsLintPolicyForCwd,
@@ -41,7 +44,7 @@ const oxlintRunner = {
   priority: PRIORITY.LINT_SECONDARY,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "oxlint");
     const policy = getJstsLintPolicyForCwd(cwd);
     if (!policy.preferredRunners.includes("oxlint")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -62,6 +65,7 @@ const oxlintRunner = {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
     const result = await safeSpawnAsync(cmd, args, {
+      cwd,
       timeout: 30000,
       maxOutputBytes: MAX_OXLINT_OUTPUT_BYTES
     });
@@ -69,16 +73,20 @@ const oxlintRunner = {
     const stderr = result.stderr ?? "";
     const parsedOutput = stdout + stderr;
     const noFilesDecision = decideOxlintNoFiles(result, stdout, stderr);
-    const parsedRun = parseToolRun("oxlint", { result, output: parsedOutput }, () => {
+    const parsedRun = parseToolRun("oxlint", {
+      result,
+      output: parsedOutput,
+      exitCodes: { ran: [1, 2] }
+    }, () => {
       if (noFilesDecision.kind === "expected-no-files") {
         return [OXLINT_NO_FILES];
       }
       if (noFilesDecision.kind === "unconfirmed-no-files" && result.status === 0) {
         return [OXLINT_NO_FILES_UNCONFIRMED];
       }
-      let parsed = parseOxlintJson(stdout, ctx.filePath);
+      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 });
@@ -235,7 +243,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 [];
@@ -248,7 +256,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;
@@ -270,13 +282,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(`
 `)) {
     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/extensions/dm-lens/clients/dispatch/runners/php-lint.js

@@ -1,14 +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 { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+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);
+  const reported = messageMatch?.[2]?.trim();
+  if (reported && !pathsEqual(path.resolve(cwd, reported), path.resolve(cwd, filePath)))
+    return [];
   return [
     {
       id: `php-lint:${lineMatch?.[1] ?? "1"}`,
@@ -30,7 +37,7 @@ const phpLintRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "php-lint");
     if (!await php.isAvailableAsync(cwd)) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
@@ -43,19 +50,21 @@ const phpLintRunner = {
       timeout: 15000,
       cwd
     });
-    if (result.status === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const diagnostics = parsePhpLintOutput(`${result.stdout ?? ""}
-${result.stderr ?? ""}`, ctx.filePath);
-    if (diagnostics.length === 0) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    return {
-      status: "failed",
-      diagnostics,
-      semantic: "blocking"
-    };
+    const run = parseToolRun("php-lint", {
+      result,
+      output: `${result.stdout ?? ""}
+${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/extensions/dm-lens/clients/dispatch/runners/phpstan.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { getLinterPolicyForCwd, hasPhpstanConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import {
@@ -63,7 +64,7 @@ const phpstanRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "phpstan");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("phpstan")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };

package/extensions/dm-lens/clients/dispatch/runners/prisma-validate.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import { resolveLocalFirstAsync } from "./utils/runner-helpers.js";
 function parsePrismaValidateOutput(raw, filePath) {
@@ -30,7 +31,7 @@ const prismaValidateRunner = {
   priority: PRIORITY.GENERAL_ANALYSIS,
   skipTestFiles: false,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "prisma-validate");
     const resolved = await resolveLocalFirstAsync("prisma", cwd);
     const absPath = path.resolve(cwd, ctx.filePath);
     const result = await safeSpawnAsync(resolved.cmd, [...resolved.args, "validate", "--schema", absPath], { timeout: 20000, cwd });

package/extensions/dm-lens/clients/dispatch/runners/psscriptanalyzer.js

@@ -3,6 +3,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { incrementDegradationCount } from "../../degradation-ledger.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 {
   classifyProbeFailure,
@@ -19,8 +21,10 @@ if ($results.Count -eq 0) { Write-Output '[]'; exit 0 }
 $results | ConvertTo-Json -Depth 3 -Compress
 `.trim();
 const PS_TIMEOUT_MS = 30000;
-function spawnPs(cmd, args, timeoutMs = PS_TIMEOUT_MS) {
+function spawnPs(cmd, args, options) {
+  const { timeoutMs = PS_TIMEOUT_MS, cwd } = options;
   return safeSpawnAsync(cmd, args, {
+    cwd,
     timeout: timeoutMs,
     resourceLabel: "psscriptanalyzer"
   });
@@ -68,12 +72,7 @@ async function resolvePowerShellCmd() {
   for (const candidate of ["pwsh", "powershell"]) {
     const sampler = startHostStallSampler();
     const startedAt = Date.now();
-    const result = await spawnPs(candidate, [
-      "-NoProfile",
-      "-NonInteractive",
-      "-Command",
-      "exit 0"
-    ]);
+    const result = await probeToolAsync(candidate, ["-NoProfile", "-NonInteractive", "-Command", "exit 0"], { timeout: PS_TIMEOUT_MS, resourceLabel: "psscriptanalyzer" });
     const hostStallMs = sampler.stop();
     const elapsedMs = Date.now() - startedAt;
     elapsedTotalMs += elapsedMs;
@@ -118,12 +117,12 @@ async function checkModuleAvailable(cmd) {
     return memo;
   const sampler = startHostStallSampler();
   const startedAt = Date.now();
-  const result = await spawnPs(cmd, [
+  const result = await probeToolAsync(cmd, [
     "-NoProfile",
     "-NonInteractive",
     "-Command",
     "if (Get-Module -ListAvailable PSScriptAnalyzer) { exit 0 } else { exit 1 }"
-  ]);
+  ], { timeout: PS_TIMEOUT_MS, resourceLabel: "psscriptanalyzer" });
   const hostStallMs = sampler.stop();
   const elapsedMs = Date.now() - startedAt;
   if (!result.error && result.status === 0) {
@@ -204,7 +203,7 @@ const psScriptAnalyzerRunner = {
     if (execLatch.read() === false) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
     }
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "psscriptanalyzer");
     const absPath = path.resolve(cwd, ctx.filePath);
     const tmpScript = path.join(os.tmpdir(), `dm-lens-psa-${process.pid}.ps1`);
     await fs.writeFile(tmpScript, PS_SCRIPT, "utf-8");
@@ -218,7 +217,7 @@ const psScriptAnalyzerRunner = {
         tmpScript,
         "-FilePath",
         absPath
-      ]);
+      ], { timeoutMs: PS_TIMEOUT_MS, cwd });
       const hostStallMs = sampler.stop();
       const elapsedMs = Date.now() - startedAt;
       if (result.status === null) {

package/extensions/dm-lens/clients/dispatch/runners/pyright.js

@@ -5,6 +5,7 @@ import {
   detectPythonEnvironment
 } from "../../python-environment.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
 import {
   createAvailabilityChecker,
@@ -22,7 +23,7 @@ const pyrightRunner = {
       const lspService = getLSPService();
       await lspService.getClientForFile(ctx.filePath);
     }
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "pyright");
     let cmd = null;
     if (await pyright.isAvailableAsync(cwd)) {
       cmd = pyright.getCommand(cwd);

package/extensions/dm-lens/clients/dispatch/runners/rubocop.js

@@ -1,4 +1,7 @@
+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,
@@ -6,6 +9,7 @@ import {
 } 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",
@@ -13,12 +17,15 @@ 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) {
+      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({
@@ -47,7 +54,7 @@ const rubocopRunner = {
   appliesTo: ["ruby"],
   priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
   async run(ctx) {
-    const cwd = ctx.cwd || process.cwd();
+    const cwd = resolveRunnerCwd(ctx, "rubocop");
     const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
     if (policy && !policy.preferredRunners.includes("rubocop")) {
       return { status: "skipped", diagnostics: [], semantic: "none" };
@@ -58,22 +65,19 @@ const rubocopRunner = {
     }
     const { cmd, args } = resolved;
     const result = await safeSpawnAsync(cmd, [...args, "--format", "json", "--no-color", ctx.filePath], { timeout: 30000, cwd });
-    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"
-    };
+    const run = parseToolRun("rubocop", {
+      result,
+      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;