@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/dispatch/runners/utils/spawn-outcome.js

@@ -0,0 +1,40 @@
+import { LEDGER_FIELD_MAX } from "../../../ledger-bounds.js";
+import { truncatedByOutputCap } from "../../../spawn-output-cap.js";
+export function firstOutputLine(text, max = LEDGER_FIELD_MAX) {
+  for (const line of String(text ?? "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+  }
+  return "";
+}
+export function classifyRunOutcome(input) {
+  const { result, exitCodes, reportMissing } = input;
+  const status = result.status ?? null;
+  const signal = result.signal ?? null;
+  const output = input.output ?? result.stdout;
+  const base = {
+    status,
+    signal,
+    firstOutputLine: firstOutputLine(result.stderr) || firstOutputLine(result.stdout) || firstOutputLine(result.error?.message),
+    outputCapped: truncatedByOutputCap(result)
+  };
+  if (result.error || signal)
+    return { kind: "did-not-run", ...base };
+  if (status === null)
+    return { kind: "did-not-run", ...base };
+  if (reportMissing) {
+    return status === 0 ? { kind: "ran", ...base } : { kind: "report-missing", ...base };
+  }
+  if (status !== 0 && exitCodes && !exitCodes.ran.includes(status)) {
+    return { kind: "rejected-invocation", ...base };
+  }
+  if (status !== 0 && !output?.trim()) {
+    return { kind: "did-not-run", ...base };
+  }
+  return { kind: "ran", ...base };
+}
+export function spawnFailedWithNoOutput(result, output = result.stdout) {
+  return classifyRunOutcome({ result, output }).kind !== "ran" && !output?.trim();
+}

package/extensions/dm-lens/dist/clients/dispatch/runners/utils/tool-failure.js

@@ -0,0 +1,120 @@
+import { incrementDegradationCount } from "../../../degradation-ledger.js";
+import { truncateForLedger } from "../../../ledger-bounds.js";
+import { findingsResult } from "../../types.js";
+import { classifyRunOutcome, firstOutputLine } from "./spawn-outcome.js";
+function describeEnding(input) {
+  if (input.outputCapped)
+    return "was stopped at its output cap";
+  if (input.signal)
+    return `was killed by ${input.signal}`;
+  if (input.status === null)
+    return "did not run (spawn failure)";
+  return `exited ${input.status}`;
+}
+export function formatToolFailure(input) {
+  const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== undefined && value !== "");
+  const identity = entries.length ? `${input.tool} (${entries.map(([key, value]) => `${key}=${value}`).join(", ")})` : input.tool;
+  const what = describeEnding(input);
+  const missing = input.reportMissing ? "no report file" : "no output";
+  const detail = firstOutputLine(input.stderr) || firstOutputLine(input.stdout) || "no stderr";
+  return truncateForLedger(`${identity} ${what} with ${missing}: ${detail}`);
+}
+export function formatRunOutcomeFailure(tool, outcome, fields) {
+  return formatToolFailure({
+    tool,
+    status: outcome.status,
+    signal: outcome.signal,
+    outputCapped: outcome.outputCapped,
+    stderr: outcome.firstOutputLine,
+    reportMissing: outcome.kind === "report-missing",
+    fields: { outcome: outcome.kind, ...fields }
+  });
+}
+export function skipUnlessToolRan(tool, input, fields) {
+  const outcome = classifyRunOutcome(input);
+  if (outcome.kind === "ran")
+    return null;
+  incrementDegradationCount({
+    kind: "runner-empty-result",
+    subject: tool,
+    reason: formatRunOutcomeFailure(tool, outcome, fields)
+  });
+  return { status: "skipped", diagnostics: [], semantic: "none" };
+}
+export function recordParsedNothing(input) {
+  const { tool, status, output, parsedCount } = input;
+  if (parsedCount > 0)
+    return false;
+  if (!status)
+    return false;
+  const text = output ?? "";
+  if (!text.trim())
+    return false;
+  const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== undefined && value !== "");
+  const identity = entries.length ? `${tool} (${entries.map(([key, value]) => `${key}=${value}`).join(", ")})` : tool;
+  incrementDegradationCount({
+    kind: "runner-parsed-nothing",
+    subject: tool,
+    reason: truncateForLedger(`${identity} exited ${status} with ${text.length} chars of output but the parser read 0 diagnostics: ${firstOutputLine(text) || "no first line"}`)
+  });
+  return true;
+}
+export function parseToolRun(tool, input, parse, options = {}) {
+  const skipped = skipUnlessToolRan(tool, input, options.fields);
+  if (skipped)
+    return { skipped, diagnostics: [], parsedNothing: false };
+  const output = options.parseOutput ?? input.output ?? input.result.stdout ?? "";
+  const diagnostics = [...parse(output)];
+  const parsedNothing = recordParsedNothing({
+    tool,
+    status: input.result.status ?? null,
+    output,
+    parsedCount: diagnostics.length,
+    fields: options.fields
+  });
+  if (parsedNothing && options.skipWhenParsedNothing) {
+    return {
+      skipped: { status: "skipped", diagnostics: [], semantic: "none" },
+      diagnostics: [],
+      parsedNothing
+    };
+  }
+  return { skipped: null, diagnostics, parsedNothing };
+}
+export function finishParsedRun(input) {
+  const raw = `${input.result.stdout ?? ""}${input.result.stderr ?? ""}`;
+  const status = input.result.status ?? null;
+  if (input.diagnostics.length === 0) {
+    if (status !== 0 && raw.trim().length > 0) {
+      const message = `${input.tool} exited ${status} but its output could not be parsed`;
+      return {
+        status: "failed",
+        diagnostics: [
+          {
+            id: `${input.tool}:parse-error:1`,
+            message,
+            filePath: input.ctx.filePath,
+            line: 1,
+            column: 1,
+            severity: "warning",
+            semantic: "warning",
+            tool: input.tool
+          }
+        ],
+        semantic: "warning",
+        failureKind: "parser_error",
+        failureMessage: message
+      };
+    }
+    return { status: "succeeded", diagnostics: [], semantic: "none" };
+  }
+  const mapped = input.classify?.(input.diagnostics);
+  if (mapped) {
+    return findingsResult(input.diagnostics, mapped);
+  }
+  const hasBlocking = input.diagnostics.some((d) => d.semantic === "blocking");
+  return findingsResult(input.diagnostics, {
+    status: hasBlocking ? "failed" : "succeeded",
+    semantic: hasBlocking ? "blocking" : "warning"
+  });
+}

package/extensions/dm-lens/dist/clients/dispatch/runners/utils/toolchain-availability.js

@@ -0,0 +1,88 @@
+import { createAvailabilityLatch, logAvailabilityDecision } from "./availability-policy.js";
+import { probeAvailabilityCandidates } from "./candidate-probe.js";
+import { createAvailabilityProbeFlight } from "../../../availability-probe-flight.js";
+import { createGenerationSource } from "../../../generation-guard.js";
+import { createSingleFlight } from "../../../single-flight.js";
+const toolchainGenerations = createGenerationSource("toolchain-availability");
+const toolchainProbeFlights = createAvailabilityProbeFlight({ generation: toolchainGenerations.current });
+export function createToolchainAvailability(config) {
+  const availabilityLatch = createAvailabilityLatch();
+  let toolPath = null;
+  let sweepSawTransient = false;
+  let sweepTransientCause = "probe-timeout";
+  let sweepHostStallMs = 0;
+  let sweepEvidence;
+  const ensureFlight = createSingleFlight({
+    generation: toolchainGenerations.current
+  });
+  async function findPath() {
+    if (toolPath)
+      return toolPath;
+    const paths = process.platform === "win32" ? config.windowsPaths : config.unixPaths;
+    const handle = toolchainGenerations.capture();
+    const shared = toolchainProbeFlights.run(`toolchain:${config.tool}|${config.probeArgs.join("|")}|${config.windowsPaths.join("|")}|${config.unixPaths.join("|")}`, () => probeAvailabilityCandidates(paths, config.probeArgs, config.budgetMs));
+    const sweep = await shared.promise;
+    handle.guardedWrite(`findPath:${config.tool}`, () => {
+      sweepSawTransient = sweep.sawTransient;
+      sweepTransientCause = sweep.transientCause;
+      sweepHostStallMs = sweep.hostStallMs;
+      sweepEvidence = sweep.evidence;
+      if (sweep.foundPath)
+        toolPath = sweep.foundPath;
+    });
+    return sweep.foundPath;
+  }
+  async function resolveAvailability() {
+    const startedAt = Date.now();
+    const handle = toolchainGenerations.capture();
+    const resolvedPath = await findPath();
+    const found = resolvedPath !== null;
+    const superseded = !handle.isCurrent();
+    if (found) {
+      handle.guardedWrite(`latch:${config.tool}`, () => availabilityLatch.noteAvailable());
+      config.log(`${config.label} found: ${resolvedPath}`);
+      logAvailabilityDecision({
+        tool: config.tool,
+        verdict: "available",
+        outcome: "success",
+        cause: "ok",
+        elapsedMs: Date.now() - startedAt,
+        latched: !superseded,
+        hostStallMs: sweepHostStallMs,
+        budgetMs: config.budgetMs,
+        classifiedBy: "probe",
+        ...sweepEvidence !== undefined && { evidence: sweepEvidence }
+      });
+      return true;
+    }
+    const outcome = sweepSawTransient ? "transient" : "missing";
+    const cause = sweepSawTransient ? sweepTransientCause : "not-found";
+    const retryAfterMs = handle.guardedWrite(`latch:${config.tool}`, () => availabilityLatch.noteUnavailable(outcome, cause)) ?? 0;
+    logAvailabilityDecision({
+      tool: config.tool,
+      verdict: "unavailable",
+      outcome,
+      cause,
+      elapsedMs: Date.now() - startedAt,
+      latched: !superseded && outcome !== "transient",
+      hostStallMs: sweepHostStallMs,
+      ...retryAfterMs > 0 && { retryAfterMs },
+      budgetMs: config.budgetMs,
+      classifiedBy: "probe",
+      ...sweepEvidence !== undefined && { evidence: sweepEvidence }
+    });
+    return false;
+  }
+  async function isAvailable() {
+    const memo = availabilityLatch.read();
+    if (memo !== null)
+      return memo;
+    return ensureFlight.run("availability", resolveAvailability);
+  }
+  function reset() {
+    toolPath = null;
+    availabilityLatch.reset();
+    toolchainGenerations.bump();
+  }
+  return { findPath, isAvailable, reset };
+}

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

@@ -0,0 +1,8 @@
+import * as fs from "node:fs";
+export function readFileContent(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return;
+  }
+}

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

@@ -0,0 +1,106 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { findingsResult } from "../types.js";
+import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+const vale = createAvailabilityChecker("vale", ".exe");
+function findValeConfig(cwd) {
+  const local = path.join(cwd, ".vale.ini");
+  if (fs.existsSync(local))
+    return local;
+  let current = path.resolve(cwd);
+  while (true) {
+    const candidate = path.join(current, ".vale.ini");
+    if (fs.existsSync(candidate))
+      return candidate;
+    const parent = path.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return;
+}
+export function parseValeOutput(raw, filePath, cwd) {
+  const diagnostics = [];
+  if (!raw.trim())
+    return diagnostics;
+  const absTarget = path.resolve(cwd, filePath);
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return diagnostics;
+    for (const [reported, alerts] of Object.entries(parsed)) {
+      if (!Array.isArray(alerts))
+        continue;
+      if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
+        continue;
+      for (const alert of alerts) {
+        if (!alert.Message)
+          continue;
+        const severityMap = {
+          error: "error",
+          warning: "warning",
+          info: "info",
+          suggestion: "info"
+        };
+        const severity = severityMap[alert.Severity?.toLowerCase() ?? ""] ?? "warning";
+        diagnostics.push({
+          id: `vale-${alert.Line}-${alert.Check ?? "unknown"}`,
+          message: `[${alert.Check ?? "vale"}] ${alert.Message}`,
+          filePath,
+          line: alert.Line ?? 1,
+          column: alert.Span?.[0] ?? 1,
+          severity,
+          semantic: severity === "error" ? "blocking" : "warning",
+          tool: "vale",
+          rule: alert.Check ?? "vale",
+          fixable: false
+        });
+      }
+    }
+  } catch {
+    return diagnostics;
+  }
+  return diagnostics;
+}
+const valeRunner = {
+  id: "vale",
+  appliesTo: ["markdown"],
+  priority: PRIORITY.DOC_QUALITY,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "vale");
+    if (!findValeConfig(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    if (await vale.isAvailableAsync(cwd)) {
+      cmd = vale.getCommand(cwd);
+    } else {
+      cmd = await resolveToolCommandWithInstallFallback(cwd, "vale");
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const result = await safeSpawnAsync(cmd, ["--output", "JSON", ctx.filePath], { cwd, timeout: 15000 });
+    const run = parseToolRun("vale", {
+      result,
+      exitCodes: { ran: [1, 2] }
+    }, (raw) => parseValeOutput(raw, ctx.filePath, cwd));
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    if (diagnostics.length === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+    return findingsResult(diagnostics, {
+      status: hasBlocking ? "failed" : "succeeded",
+      semantic: hasBlocking ? "blocking" : "warning"
+    });
+  }
+};
+export default valeRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/yaml-rule-parser.js

@@ -0,0 +1,170 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import yaml from "../../deps/js-yaml.js";
+import { BoundedLruCache } from "../../bounded-cache.js";
+import { compareOrdinal } from "../../string-utils.js";
+import { recordDegradationOnce } from "../../degradation-ledger.js";
+const OVERLY_BROAD_PATTERNS = ["$NAME", "$FIELD", "$_", "$X", "$VAR", "$EXPR"];
+export const MAX_BLOCKING_RULE_COMPLEXITY = 8;
+export const RULES_CACHE_FRESHNESS_CADENCE_MS = 2000;
+const rulesCache = new BoundedLruCache(64);
+const blockingRulesCache = new BoundedLruCache(64);
+const contentRulesCache = new BoundedLruCache(64);
+const contentBlockingRulesCache = new BoundedLruCache(64);
+export function loadYamlRules(ruleDir, severityFilter) {
+  return getCachedRules(ruleDir, severityFilter);
+}
+function findYamlRuleFiles(ruleDir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(ruleDir, { withFileTypes: true }).sort((a, b) => compareOrdinal(a.name, b.name));
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const full = path.join(ruleDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findYamlRuleFiles(full));
+    } else if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+function loadYamlRuleFiles(files, severityFilter) {
+  const rules = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = fs.readFileSync(file, "utf-8");
+    } catch {
+      continue;
+    }
+    const documents = content.split(/^---\s*$/m).filter((doc) => doc.trim());
+    for (const document of documents) {
+      const rule = parseSimpleYaml(document.trim());
+      if (!rule?.id) {
+        recordDegradationOnce({
+          kind: "ast-grep-rule-invalid",
+          subject: file,
+          reason: "ast-grep rule could not be parsed"
+        });
+        continue;
+      }
+      if (severityFilter && rule.severity !== severityFilter)
+        continue;
+      rules.push(rule);
+    }
+  }
+  return rules;
+}
+export function loadYamlRulesUncached(ruleDir, severityFilter) {
+  return loadYamlRuleFiles(findYamlRuleFiles(ruleDir), severityFilter);
+}
+export function loadYamlRulesFresh(ruleDir, severityFilter) {
+  const files = findYamlRuleFiles(ruleDir);
+  const hash = createHash("sha256");
+  for (const file of files) {
+    hash.update(path.relative(ruleDir, file));
+    hash.update("\x00");
+    try {
+      hash.update(fs.readFileSync(file));
+    } catch {
+      hash.update("missing");
+    }
+    hash.update("\x00");
+  }
+  const signature = hash.digest("hex");
+  const cache = severityFilter === "error" ? contentBlockingRulesCache : contentRulesCache;
+  const cached = cache.get(ruleDir);
+  if (cached?.signature === signature)
+    return cached.rules;
+  const rules = loadYamlRuleFiles(files, severityFilter);
+  cache.set(ruleDir, { rules, signature });
+  return rules;
+}
+function getCachedRules(ruleDir, severityFilter) {
+  if (!fs.existsSync(ruleDir)) {
+    return [];
+  }
+  const cache = severityFilter === "error" ? blockingRulesCache : rulesCache;
+  const cached = cache.get(ruleDir);
+  const now = Date.now();
+  if (cached && now - cached.checkedAtMs < RULES_CACHE_FRESHNESS_CADENCE_MS) {
+    return cached.rules;
+  }
+  const files = findYamlRuleFiles(ruleDir);
+  const fileStamps = files.flatMap((file) => {
+    try {
+      const stat = fs.statSync(file);
+      return [{ path: file, mtimeMs: stat.mtimeMs, size: stat.size }];
+    } catch {
+      return [];
+    }
+  });
+  const metadataMatches = cached?.files.length === fileStamps.length && cached.files.every((file, index) => file.path === fileStamps[index].path && file.mtimeMs === fileStamps[index].mtimeMs && file.size === fileStamps[index].size);
+  if (cached && metadataMatches) {
+    cached.checkedAtMs = now;
+    return cached.rules;
+  }
+  const rules = loadYamlRuleFiles(files, severityFilter);
+  cache.set(ruleDir, { rules, files: fileStamps, checkedAtMs: now });
+  return rules;
+}
+export function isOverlyBroadPattern(pattern) {
+  if (!pattern)
+    return false;
+  if (typeof pattern !== "string")
+    return false;
+  if (OVERLY_BROAD_PATTERNS.includes(pattern.trim()))
+    return true;
+  return /^\$[A-Z_]+$/i.test(pattern.trim());
+}
+export function isStructuredRule(rule) {
+  if (!rule.rule)
+    return false;
+  const hasRichPattern = typeof rule.rule.pattern === "object" && rule.rule.pattern !== null;
+  return !!(hasRichPattern || rule.rule.has || rule.rule.any || rule.rule.all || rule.rule.not || rule.rule.regex);
+}
+export function calculateRuleComplexity(condition) {
+  if (!condition)
+    return 0;
+  let score = 0;
+  if (condition.has)
+    score += 3;
+  if (condition.not)
+    score += 2;
+  if (condition.regex)
+    score += 2;
+  if (condition.any)
+    score += condition.any.length * 2;
+  if (condition.all)
+    score += condition.all.length * 3;
+  if (condition.has)
+    score += calculateRuleComplexity(condition.has);
+  if (condition.not)
+    score += calculateRuleComplexity(condition.not);
+  if (condition.any) {
+    for (const sub of condition.any)
+      score += calculateRuleComplexity(sub);
+  }
+  if (condition.all) {
+    for (const sub of condition.all)
+      score += calculateRuleComplexity(sub);
+  }
+  return score;
+}
+export function parseSimpleYaml(content) {
+  let parsed;
+  try {
+    parsed = yaml.load(content);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const rule = parsed;
+  return rule.id ? rule : null;
+}

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

@@ -0,0 +1,83 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { logRunnerAdvisoryOnce } from "../../tool-cwd.js";
+import { getLinterPolicyForCwd, hasYamllintConfig } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveRunnerCwd, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const yamllint = createAvailabilityChecker("yamllint", ".exe");
+
+export { hasYamllintConfig };
+function parseYamllintParsable(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*(.*?)\s*\(([^)]+)\)\s*$/i);
+    if (!match)
+      continue;
+    if (!pathsEqual(path.resolve(cwd, match[1]), absTarget))
+      continue;
+    const severity = match[4].toLowerCase() === "error" ? "error" : "warning";
+    diagnostics.push({
+      id: `yamllint-${match[2]}-${match[3]}-${match[6]}`,
+      message: `[${match[6]}] ${match[5]}`,
+      filePath,
+      line: Number(match[2]),
+      column: Number(match[3]),
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "yamllint",
+      rule: match[6]
+    });
+  }
+  return diagnostics;
+}
+const yamllintRunner = {
+  id: "yamllint",
+  appliesTo: ["yaml"],
+  priority: PRIORITY.YAML_LINT,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "yamllint");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("yamllint")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const hasConfig = hasYamllintConfig(cwd);
+    if (!hasConfig) {
+      logRunnerAdvisoryOnce(ctx, "yamllint", cwd, "yamllint: no config detected, running with default rules");
+    }
+    let cmd = null;
+    if (await yamllint.isAvailableAsync(cwd)) {
+      cmd = yamllint.getCommand(cwd);
+    } else {
+      cmd = await resolveToolCommandWithInstallFallback(cwd, "yamllint");
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const result = await safeSpawnAsync(cmd, ["-f", "parsable", ctx.filePath], {
+      cwd,
+      timeout: 15000
+    });
+    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const run = parseToolRun("yamllint", {
+      result,
+      output: result.stdout,
+      exitCodes: { ran: [1, 2] }
+    }, (out) => parseYamllintParsable(out, ctx.filePath, cwd), { parseOutput: raw });
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    return finishParsedRun({
+      tool: "yamllint",
+      ctx,
+      result,
+      diagnostics
+    });
+  }
+};
+export default yamllintRunner;

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

@@ -0,0 +1,72 @@
+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 { createAvailabilityChecker } from "./utils/runner-helpers.js";
+import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const zig = createAvailabilityChecker("zig", ".exe", ["version"]);
+function parseZigOutput(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*(error|warning|note):\s*(.+)$/);
+    if (!match)
+      continue;
+    const [, rawFile, lineStr, colStr, level, message] = match;
+    if (!pathsEqual(path.resolve(cwd, rawFile.trim()), absTarget))
+      continue;
+    const severity = level === "error" ? "error" : "warning";
+    diagnostics.push({
+      id: `zig-${level}-${lineStr}-${colStr}`,
+      message,
+      filePath,
+      line: Number.parseInt(lineStr, 10) || 1,
+      column: Number.parseInt(colStr, 10) || 1,
+      severity,
+      semantic: "warning",
+      tool: "zig",
+      rule: `zig-${level}`,
+      fixable: false
+    });
+  }
+  return diagnostics;
+}
+const zigCheckRunner = {
+  id: "zig-check",
+  appliesTo: ["zig"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "zig-check");
+    if (!await zig.isAvailableAsync(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = zig.getCommand(cwd);
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync(cmd, ["build-exe", absPath, "-fno-emit-bin"], { cwd, timeout: 30000 });
+    if (result.error && !result.stdout && !result.stderr) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const raw = `${result.stdout || ""}
+${result.stderr || ""}`;
+    const parsed = parseToolRun("zig-check", {
+      result,
+      output: raw,
+      exitCodes: { ran: [1, 2] }
+    }, (output) => parseZigOutput(output, ctx.filePath, cwd));
+    if (parsed.skipped)
+      return parsed.skipped;
+    return finishParsedRun({
+      tool: "zig-check",
+      ctx,
+      result,
+      diagnostics: parsed.diagnostics,
+      classify: (diagnostics) => ({
+        status: diagnostics.some((d) => d.severity === "error") ? "failed" : "succeeded",
+        semantic: "warning"
+      })
+    });
+  }
+};
+export default zigCheckRunner;