@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/dispatch/runners/index.js

@@ -0,0 +1,100 @@
+import actionlintRunner from "./actionlint.js";
+import astGrepNapiRunner from "./ast-grep-napi.js";
+import biomeCheckJsonRunner from "./biome-check.js";
+import cppCheckRunner from "./cpp-check.js";
+import credoRunner from "./credo.js";
+import cueVetRunner from "./cue-vet.js";
+import dartAnalyzeRunner from "./dart-analyze.js";
+import detektRunner from "./detekt.js";
+import dotnetBuildRunner from "./dotnet-build.js";
+import elixirCheckRunner from "./elixir-check.js";
+import eslintRunner from "./eslint.js";
+import factRulesRunner from "./fact-rules.js";
+import gleamCheckRunner from "./gleam-check.js";
+import goVetRunner from "./go-vet.js";
+import golangciRunner from "./golangci-lint.js";
+import hadolintRunner from "./hadolint.js";
+import helmLintRunner from "./helm-lint.js";
+import helmRenderRunner from "./helm-render.js";
+import htmlhintRunner from "./htmlhint.js";
+import javacRunner from "./javac.js";
+import ktlintRunner from "./ktlint.js";
+import lspRunner from "./lsp.js";
+import markdownlintRunner from "./markdownlint.js";
+import mypyRunner from "./mypy.js";
+import oxlintRunner from "./oxlint.js";
+import phpLintRunner from "./php-lint.js";
+import phpstanRunner from "./phpstan.js";
+import prismaValidateRunner from "./prisma-validate.js";
+import psScriptAnalyzerRunner from "./psscriptanalyzer.js";
+import pyrightRunner from "./pyright.js";
+import rubocopRunner from "./rubocop.js";
+import ruffRunner from "./ruff.js";
+import rustClippyRunner from "./rust-clippy.js";
+import spotbugsRunner from "./spotbugs.js";
+import shellcheckRunner from "./shellcheck.js";
+import fishIndentRunner from "./fish-indent.js";
+import shfmtRunner from "./shfmt.js";
+import spellcheckRunner from "./spellcheck.js";
+import sqlfluffRunner from "./sqlfluff.js";
+import stylelintRunner from "./stylelint.js";
+import swiftlintRunner from "./swiftlint.js";
+import taploRunner from "./taplo.js";
+import terragruntRunner from "./terragrunt.js";
+import tflintRunner from "./tflint.js";
+import trivyConfigRunner from "./trivy-config.js";
+import valeRunner from "./vale.js";
+import treeSitterRunner from "./tree-sitter.js";
+import yamllintRunner from "./yamllint.js";
+import zigCheckRunner from "./zig-check.js";
+export function registerDefaultRunners(registry) {
+  registry.register(lspRunner);
+  registry.register(pyrightRunner);
+  registry.register(biomeCheckJsonRunner);
+  registry.register(astGrepNapiRunner);
+  registry.register(treeSitterRunner);
+  registry.register(ruffRunner);
+  registry.register(shellcheckRunner);
+  registry.register(spotbugsRunner);
+  registry.register(eslintRunner);
+  registry.register(oxlintRunner);
+  registry.register(golangciRunner);
+  registry.register(rubocopRunner);
+  registry.register(spellcheckRunner);
+  registry.register(yamllintRunner);
+  registry.register(actionlintRunner);
+  registry.register(sqlfluffRunner);
+  registry.register(goVetRunner);
+  registry.register(rustClippyRunner);
+  registry.register(markdownlintRunner);
+  registry.register(mypyRunner);
+  registry.register(stylelintRunner);
+  registry.register(swiftlintRunner);
+  registry.register(shfmtRunner);
+  registry.register(fishIndentRunner);
+  registry.register(factRulesRunner);
+  registry.register(htmlhintRunner);
+  registry.register(hadolintRunner);
+  registry.register(helmLintRunner);
+  registry.register(helmRenderRunner);
+  registry.register(valeRunner);
+  registry.register(phpLintRunner);
+  registry.register(psScriptAnalyzerRunner);
+  registry.register(prismaValidateRunner);
+  registry.register(ktlintRunner);
+  registry.register(detektRunner);
+  registry.register(tflintRunner);
+  registry.register(terragruntRunner);
+  registry.register(trivyConfigRunner);
+  registry.register(taploRunner);
+  registry.register(dartAnalyzeRunner);
+  registry.register(javacRunner);
+  registry.register(dotnetBuildRunner);
+  registry.register(cppCheckRunner);
+  registry.register(zigCheckRunner);
+  registry.register(gleamCheckRunner);
+  registry.register(credoRunner);
+  registry.register(elixirCheckRunner);
+  registry.register(phpstanRunner);
+  registry.register(cueVetRunner);
+}

package/extensions/dm-lens/dist/clients/dispatch/runners/javac.js

@@ -0,0 +1,82 @@
+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, 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;
+    if (!pathsEqual(path.resolve(cwd, reportedFile.trim()), absTarget))
+      continue;
+    const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
+    const lineNum = Number.parseInt(lineStr, 10) || 1;
+    diagnostics.push({
+      id: `javac-${severity}-${lineNum}-${message}`,
+      message: message.trim(),
+      filePath,
+      line: lineNum,
+      column: 1,
+      severity,
+      semantic: "warning",
+      tool: "javac",
+      rule: "compile",
+      fixable: false
+    });
+  }
+  return diagnostics;
+}
+const javacRunner = {
+  id: "javac",
+  appliesTo: ["java"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "javac");
+    const absPath = path.resolve(cwd, ctx.filePath);
+    if (hasJavaBuildDescriptor(path.dirname(absPath), ctx.projectRoot ?? ctx.cwd)) {
+      ctx.log?.("javac: skipped — file is inside a Maven/Gradle project; a classpath-less compile would emit false positives");
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (!await javac.isAvailableAsync(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = javac.getCommand(cwd);
+    if (!cmd) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const result = await safeSpawnAsync(cmd, ["-Xlint:none", "-proc:none", absPath], {
+      cwd,
+      timeout: 30000
+    });
+    const raw = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+    const parsed = parseToolRun("javac", {
+      result,
+      output: raw,
+      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"
+      })
+    });
+  }
+};
+export default javacRunner;

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

@@ -0,0 +1,93 @@
+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");
+const KTLINT_EXIT_CODES = { ran: [1, 2, 3] };
+function normalizeKtlintResults(parsed) {
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.errors)) {
+    return [parsed];
+  }
+  return null;
+}
+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}`,
+          message: `[${err.ruleId}] ${err.detail}`,
+          filePath,
+          line: err.line,
+          column: err.col,
+          severity: "warning",
+          semantic: "warning",
+          tool: "ktlint",
+          rule: err.ruleId,
+          fixable: true,
+          autoFixAvailable: autofix?.safePipelineAutofix ?? false,
+          fixKind: autofix?.fixKind === "none" ? undefined : autofix?.fixKind
+        });
+      }
+    }
+    return diagnostics;
+  } catch {
+    return null;
+  }
+}
+const ktlintRunner = {
+  id: "ktlint",
+  appliesTo: ["kotlin"],
+  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "ktlint");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("ktlint")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    if (await ktlint.isAvailableAsync(cwd)) {
+      cmd = ktlint.getCommand(cwd);
+    } else {
+      cmd = await resolveToolCommandWithInstallFallback(cwd, "ktlint");
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync(cmd, ["--reporter=json", absPath], {
+      cwd,
+      timeout: 30000
+    });
+    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/dist/clients/dispatch/runners/lsp.js

@@ -0,0 +1,226 @@
+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/capabilities.js";
+import { LSP_SERVERS } from "../../lsp/server.js";
+import { RUNTIME_CONFIG } from "../../runtime-config.js";
+import { PRIORITY } from "../priorities.js";
+import { resolveRunnerPath } from "../runner-context.js";
+import { findingsResult } from "../types.js";
+import { convertLspDiagnostics } from "../utils/lsp-diagnostics.js";
+import { demoteInferredProjectDiagnostics } from "../../lsp/inferred-project.js";
+import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics } from "../auxiliary-lsp.js";
+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_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
+export const LSP_DIAGNOSTICS_WAIT_MS = 2500;
+const MAX_CODE_ACTION_TITLES = 3;
+const LSP_COLD_SPAWN_MARGIN_MS = 5000;
+export const LSP_RUNNER_TIMEOUT_MS = Math.max(LSP_SPAWN_BUDGET_MS, ...LSP_SERVERS.map((server) => server.clientWaitTimeoutMs ?? 0)) + LSP_DIAGNOSTICS_WAIT_MS + LSP_COLD_SPAWN_MARGIN_MS;
+function normalizeActionTitle(title) {
+  return title.replace(/\s+/g, " ").trim();
+}
+function buildCodeActionSuggestion(actions) {
+  if (!actions.length)
+    return;
+  const quickFixes = actions.filter((action) => action.kind?.startsWith("quickfix"));
+  if (!quickFixes.length)
+    return;
+  const titles = Array.from(new Set(quickFixes.map((action) => normalizeActionTitle(action.title)).filter((title) => title.length > 0))).slice(0, MAX_CODE_ACTION_TITLES);
+  if (!titles.length)
+    return;
+  return `LSP quick fixes: ${titles.join("; ")}`;
+}
+const lspRunner = {
+  id: "lsp",
+  appliesTo: getLspCapableKinds(),
+  priority: PRIORITY.LSP_PRIMARY,
+  timeoutMs: LSP_RUNNER_TIMEOUT_MS,
+  async run(ctx) {
+    const diagnosticPath = resolveRunnerPath(ctx.cwd, ctx.filePath);
+    if (ctx.pi.getFlag("no-lsp")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const lspService = getLSPService();
+    if (!lspService.supportsLSP(ctx.filePath)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let lspDiags = [];
+    let serverFailed = false;
+    let lspClientReady = true;
+    let diagnosticsInconclusive = false;
+    let inconclusiveServerIds = [];
+    let unconfirmedServerIds = [];
+    let deferredServerIds = [];
+    let usedWarmAttach = false;
+    let failureReason = "";
+    const readStamp = performance.now();
+    const content = readFileContent(ctx.filePath);
+    if (!content) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (exceedsLspSyncLimits(content).tooLarge) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const auxiliaryServerIds = enabledAuxiliaryLspServerIds((f) => ctx.pi.getFlag(f));
+    try {
+      const attached = await tryWarmAttachedDiagnostics(ctx.filePath, content, Math.max(LSP_SPAWN_BUDGET_MS, LSP_DIAGNOSTICS_WAIT_MS));
+      usedWarmAttach = attached?.available === true;
+      const touched = attached?.available ? {
+        diags: attached.response.diagnostics,
+        ...attached.response.unconfirmedServerIds !== undefined && {
+          unconfirmedServerIds: attached.response.unconfirmedServerIds
+        }
+      } : await lspService.touchFile(ctx.filePath, content, {
+        diagnostics: "document",
+        collectDiagnostics: true,
+        clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
+        auxiliaryServerIds,
+        maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+        maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
+        source: "dispatch-lsp-runner",
+        readStamp
+      });
+      if (touched === undefined) {
+        lspClientReady = false;
+      } else {
+        lspDiags = touched.diags;
+        diagnosticsInconclusive = touched.inconclusive === true;
+        inconclusiveServerIds = touched.inconclusiveServerIds ?? [];
+        unconfirmedServerIds = [
+          ...new Set([
+            ...touchCoverageGap(touched),
+            ...diagnosticsInconclusive ? inconclusiveServerIds : []
+          ])
+        ];
+        deferredServerIds = touched.deferredServerIds ?? [];
+        if (diagnosticsInconclusive && touched.binding?.boundToCurrentDisk === false) {
+          const unconfirmed = new Set(unconfirmedServerIds);
+          const currentContentDiags = [];
+          for (const diagnostic of lspDiags) {
+            if (diagnostic.serverId !== undefined && !unconfirmed.has(diagnostic.serverId)) {
+              currentContentDiags.push(diagnostic);
+            }
+          }
+          lspDiags = currentContentDiags;
+        }
+      }
+    } catch (err) {
+      serverFailed = true;
+      failureReason = err instanceof Error ? err.message : String(err);
+      if (failureReason.includes("spawn") || failureReason.includes("exited") || failureReason.includes("connection") || failureReason.includes("JSON RPC")) {
+        logExtension({
+          subsystem: "lsp-runner",
+          message: `LSP server failed for ${diagnosticPath}: ${failureReason}`,
+          metadata: { filePath: diagnosticPath }
+        });
+      }
+    }
+    if (serverFailed) {
+      return {
+        status: "failed",
+        failureKind: "server_error",
+        failureMessage: failureReason.slice(0, 200),
+        diagnostics: [
+          {
+            id: `lsp:server-error:0`,
+            message: `LSP server failed: ${failureReason}`,
+            filePath: diagnosticPath,
+            line: 1,
+            column: 1,
+            severity: "error",
+            semantic: "warning",
+            tool: "lsp"
+          }
+        ],
+        semantic: "warning"
+      };
+    }
+    if (!lspClientReady) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (diagnosticsInconclusive && lspDiags.length === 0) {
+      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",
+          diagnostics: [],
+          semantic: "none",
+          unconfirmedServerIds: [...unconfirmedServerIds]
+        };
+      }
+      return {
+        status: "succeeded",
+        diagnostics: [],
+        semantic: "none",
+        rawOutput: "no-diagnostics"
+      };
+    }
+    const rawValidLspDiags = lspDiags.filter((d) => d.range?.start?.line !== undefined);
+    const validLspDiags = usedWarmAttach ? rawValidLspDiags : await demoteInferredProjectDiagnostics(rawValidLspDiags, {
+      filePath: diagnosticPath,
+      cwd: ctx.cwd,
+      service: lspService
+    });
+    const fixSuggestionByIndex = new Map;
+    const blockingDiagIndexes = rawValidLspDiags.map((d, idx) => ({ d, idx })).filter(({ d }) => d.severity === 1).slice(0, WARM_CODE_ACTION_LOOKUP_LIMIT);
+    if (usedWarmAttach) {
+      const ranges = blockingDiagIndexes.map(({ d }) => ({
+        start: d.range.start,
+        end: d.range.end ?? d.range.start
+      }));
+      const result = await tryWarmAttachedCodeActions(ctx.filePath, contentHash(content), ranges, LSP_DIAGNOSTICS_WAIT_MS);
+      if (result?.available) {
+        result.response.actions.forEach((actions, responseIndex) => {
+          const diagnosticIndex = blockingDiagIndexes[responseIndex]?.idx;
+          const suggestion = buildCodeActionSuggestion(actions);
+          if (diagnosticIndex !== undefined && suggestion) {
+            fixSuggestionByIndex.set(diagnosticIndex, suggestion);
+          }
+        });
+      }
+    } else {
+      await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
+        try {
+          const start = d.range.start;
+          const end = d.range.end ?? d.range.start;
+          const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
+          const suggestion = buildCodeActionSuggestion(actions);
+          if (suggestion) {
+            fixSuggestionByIndex.set(idx, suggestion);
+          }
+        } catch {}
+      }));
+    }
+    const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
+    const keptDiagnostics = retagAuxiliaryDiagnostics(diagnostics, validLspDiags, content, { cwd: ctx.cwd, fileRole: ctx.fileRole });
+    const hasErrors = keptDiagnostics.some((d) => d.semantic === "blocking");
+    const resultSemantic = hasErrors ? "blocking" : keptDiagnostics.length > 0 ? "warning" : "none";
+    return {
+      ...findingsResult(keptDiagnostics, {
+        status: hasErrors ? "failed" : deferredServerIds.length > 0 ? "deferred" : "succeeded",
+        semantic: resultSemantic
+      }),
+      ...unconfirmedServerIds.length > 0 && {
+        unconfirmedServerIds: [...unconfirmedServerIds]
+      },
+      ...deferredServerIds.length > 0 && {
+        deferredServerIds: [...deferredServerIds]
+      }
+    };
+  }
+};
+export default lspRunner;

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

@@ -0,0 +1,129 @@
+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";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { isInSpawnTimeoutCooldown, noteSpawnTimeout } from "../../spawn-timeout-cooldown.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const markdownlint = createAvailabilityChecker("markdownlint-cli2", ".cmd", [
+  "--no-globs",
+  "-"
+]);
+const MARKDOWNLINT_EXIT_CODES = { ran: [1] };
+const MARKDOWNLINT_FIXABLE_RULES = new Set([
+  "MD001",
+  "MD004",
+  "MD005",
+  "MD007",
+  "MD009",
+  "MD010",
+  "MD011",
+  "MD012",
+  "MD014",
+  "MD018",
+  "MD019",
+  "MD020",
+  "MD021",
+  "MD022",
+  "MD023",
+  "MD026",
+  "MD027",
+  "MD030",
+  "MD031",
+  "MD032",
+  "MD034",
+  "MD037",
+  "MD038",
+  "MD039",
+  "MD044",
+  "MD047",
+  "MD049",
+  "MD050",
+  "MD053",
+  "MD058"
+]);
+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+(.+)$/);
+    if (!match)
+      continue;
+    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({
+      id: `markdownlint-${lineNum}-${ruleName}`,
+      message: `[${ruleCode}] ${message}`,
+      filePath,
+      line: Number(lineNum),
+      column: col ? Number(col) : 1,
+      severity: "warning",
+      semantic: "warning",
+      tool: "markdownlint",
+      rule: ruleName,
+      fixable,
+      fixSuggestion: fixable ? "Run `markdownlint-cli2 --fix` to apply the deterministic auto-correction for this rule." : undefined
+    });
+  }
+  return diagnostics;
+}
+const markdownlintRunner = {
+  id: "markdownlint",
+  appliesTo: ["markdown"],
+  priority: PRIORITY.DOC_QUALITY,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "markdownlint");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("markdownlint")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    if (await markdownlint.isAvailableAsync(cwd)) {
+      cmd = markdownlint.getCommand(cwd);
+    } else {
+      cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    if (isInSpawnTimeoutCooldown(cmd)) {
+      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);
+    const result = await safeSpawnAsync(cmd, [...configArgs, ctx.filePath], {
+      timeout: 15000,
+      cwd
+    });
+    if (result.failure === "timeout") {
+      noteSpawnTimeout({
+        tool: "markdownlint",
+        command: cmd,
+        phase: "lint",
+        durationMs: 15000,
+        teardown: result.timeoutTeardown
+      });
+    }
+    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    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;
+    return finishParsedRun({
+      tool: "markdownlint",
+      ctx,
+      result,
+      diagnostics,
+      classify: () => ({ status: "succeeded", semantic: "warning" })
+    });
+  }
+};
+export default markdownlintRunner;