@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/pipeline.js

@@ -1,1091 +0,0 @@
-import { createHash } from "node:crypto";
-import * as nodeFs from "node:fs";
-import * as nodeCrypto from "node:crypto";
-import * as path from "node:path";
-import { findNearestContaining, normalizeEphemeralMapKey } from "./path-utils.js";
-import { recordFromDispatchDiagnostic } from "./actionable-warnings.js";
-import { recordFromCodeQualityDiagnostic } from "./code-quality-warnings.js";
-import { admitWidgetDiagnosticsWrite, recordDiagnostics } from "./widget-state.js";
-import { getDiagnosticLogger } from "./diagnostic-logger.js";
-import { getDiagnosticTracker } from "./diagnostic-tracker.js";
-import { loadDispatchIntegration } from "./dispatch/lazy.js";
-import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
-import { classifyProbeFailure, createAvailabilityChecker, createAvailabilityLatch, describeProbeEvidence, logAvailabilityDecision, startHostStallSampler, resolveAvailableOrInstall, resolveCommandArgsWithInstallFallback, resolveToolCommand, resolveToolCommandWithInstallFallback } from "./dispatch/runners/utils/runner-helpers.js";
-import { findDetektConfig } from "./dispatch/runners/detekt.js";
-import { formatDiagnostics } from "./dispatch/utils/format-utils.js";
-import { detectFileKind, getFileKindLabel } from "./file-kinds.js";
-import { detectFileChangedAfterCommand, getProjectIgnoreMatcher, isExcludedDirName } from "./file-utils.js";
-import { logLatency } from "./latency-logger.js";
-import { emitLensAnalysisComplete } from "./lens-events.js";
-import { publishFilesTouched } from "./bus-publish.js";
-import { publishDiagnostics, wasPreviouslyReportedDirty } from "./diagnostics-publish.js";
-import { loadLspService } from "./lsp-lazy.js";
-import { clearGraphCache } from "./review-graph/builder.js";
-import { BoundedLruCache } from "./bounded-cache.js";
-import { RUNTIME_CONFIG } from "./runtime-config.js";
-import { getAmbientAbortSignal, safeSpawnAsync } from "./safe-spawn.js";
-import { probeToolAsync } from "./tool-probe.js";
-import { bounded } from "./deadline-utils.js";
-import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
-import { enabledAuxiliaryLspServerIds } from "./dispatch/auxiliary-lsp.js";
-import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
-import { establishToolAgreement } from "./tool-agreement.js";
-import { dropFindingsForMissingPaths } from "./advisory-provenance.js";
-import { getAutofixPolicyForFile, getPreferredAutofixTools, getRubocopCommand, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasKtlintConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, markdownlintConfigArgs } from "./tool-policy.js";
-import { exceedsLspSyncLimits } from "./lsp/content-limits.js";
-const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
-const AUTOFIX_CHANGED_FILE_SCAN_LIMIT = 5000;
-function lspSyncBudgetMs() {
-  const raw = Number(process.env.DM_LENS_LSP_SYNC_BUDGET_MS);
-  return Number.isFinite(raw) && raw > 0 ? raw : 3000;
-}
-const SNAPSHOT_YIELD_EVERY = 500;
-async function snapshotDirInto(dir, ignoreMatcher, stack, snapshot, counter) {
-  let entries;
-  try {
-    entries = await nodeFs.promises.readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (!isExcludedDirName(entry.name) && !ignoreMatcher.isIgnored(fullPath, true)) {
-        stack.push(fullPath);
-      }
-      continue;
-    }
-    if (!entry.isFile())
-      continue;
-    if (ignoreMatcher.isIgnored(fullPath, false))
-      continue;
-    try {
-      const stat = await nodeFs.promises.stat(fullPath);
-      snapshot.set(path.resolve(fullPath), {
-        mtimeMs: stat.mtimeMs,
-        size: stat.size
-      });
-    } catch {}
-    if (++counter.n % SNAPSHOT_YIELD_EVERY === 0) {
-      await new Promise((resolve) => setImmediate(resolve));
-    }
-  }
-}
-export async function snapshotProjectFiles(root) {
-  const snapshot = new Map;
-  const projectRoot = path.resolve(root);
-  const ignoreMatcher = getProjectIgnoreMatcher(projectRoot);
-  await ignoreMatcher.ensureTrackedIndex();
-  const stack = [projectRoot];
-  const counter = { n: 0 };
-  while (stack.length > 0 && snapshot.size < AUTOFIX_CHANGED_FILE_SCAN_LIMIT) {
-    await snapshotDirInto(stack.pop(), ignoreMatcher, stack, snapshot, counter);
-  }
-  return snapshot;
-}
-async function diffProjectSnapshot(root, before) {
-  const after = await snapshotProjectFiles(root);
-  const changed = new Set;
-  for (const [filePath, next] of after) {
-    const prev = before.get(filePath);
-    if (prev?.mtimeMs !== next.mtimeMs || prev?.size !== next.size) {
-      changed.add(filePath);
-    }
-  }
-  for (const filePath of before.keys()) {
-    if (!after.has(filePath))
-      changed.add(filePath);
-  }
-  return [...changed].sort((a, b) => a.localeCompare(b));
-}
-function createPhaseTracker(toolName, filePath) {
-  const phases = [];
-  return {
-    start(name) {
-      phases.push({ name, startTime: Date.now(), ended: false });
-    },
-    end(name, metadata) {
-      const p = phases.find((x) => x.name === name && !x.ended);
-      if (p) {
-        p.ended = true;
-        logLatency({
-          type: "phase",
-          toolName,
-          filePath,
-          phase: name,
-          durationMs: Date.now() - p.startTime,
-          metadata
-        });
-      }
-    }
-  };
-}
-
-export { hasEslintConfig, hasSqlfluffConfig, hasStylelintConfig };
-const ESLINT_FIX_PROBE_BUDGET_MS = 5000;
-const _eslintCache = new BoundedLruCache(32);
-async function tryEslintFix(filePath, cwd) {
-  const userHasConfig = hasEslintConfig(cwd);
-  if (!userHasConfig)
-    return 0;
-  const cacheKey = `${path.resolve(cwd)}|${process.env.PATH ?? ""}`;
-  let cached = _eslintCache.get(cacheKey);
-  if (!cached) {
-    cached = { latch: createAvailabilityLatch(), bin: null };
-    _eslintCache.set(cacheKey, cached);
-  }
-  if (cached.latch.read() === null) {
-    const candidate = resolveToolCommand(cwd, "eslint") ?? "eslint";
-    const stallSampler = startHostStallSampler();
-    const startedAt = Date.now();
-    let check;
-    let hostStallMs;
-    try {
-      check = await safeSpawnAsync(candidate, ["--version"], {
-        timeout: ESLINT_FIX_PROBE_BUDGET_MS,
-        cwd
-      });
-    } finally {
-      hostStallMs = stallSampler.stop();
-    }
-    const elapsedMs = Date.now() - startedAt;
-    const decisionCwd = path.resolve(cwd);
-    if (!check.error && check.status === 0) {
-      cached.bin = candidate;
-      cached.latch.noteAvailable();
-      logAvailabilityDecision({
-        tool: "eslint",
-        verdict: "available",
-        outcome: "success",
-        cause: "ok",
-        elapsedMs,
-        latched: true,
-        hostStallMs,
-        budgetMs: ESLINT_FIX_PROBE_BUDGET_MS,
-        classifiedBy: "probe",
-        evidence: describeProbeEvidence(check, "eslint")
-      }, decisionCwd);
-    } else {
-      cached.bin = null;
-      const { outcome, cause, evidence } = classifyProbeFailure(check, {
-        hostStallMs,
-        command: "eslint"
-      });
-      const retryAfterMs = cached.latch.noteUnavailable(outcome, cause);
-      logAvailabilityDecision({
-        tool: "eslint",
-        verdict: "unavailable",
-        outcome,
-        cause,
-        elapsedMs,
-        latched: retryAfterMs === 0,
-        hostStallMs,
-        ...retryAfterMs > 0 && { retryAfterMs },
-        budgetMs: ESLINT_FIX_PROBE_BUDGET_MS,
-        classifiedBy: "probe",
-        evidence
-      }, decisionCwd);
-    }
-  }
-  if (cached.latch.read() !== true || !cached.bin)
-    return 0;
-  const cmd = cached.bin;
-  return detectFileChangedAfterCommand(filePath, cmd, ["--fix", "--no-error-on-unmatched-pattern", filePath], cwd, [1]);
-}
-async function tryStylelintFix(filePath, cwd) {
-  const cmd = await resolveToolCommandWithInstallFallback(cwd, "stylelint");
-  if (!cmd)
-    return 0;
-  return detectFileChangedAfterCommand(filePath, cmd, ["--fix", "--allow-empty-input", filePath], cwd, [2]);
-}
-async function trySqlfluffFix(filePath, cwd) {
-  const cmd = await resolveToolCommandWithInstallFallback(cwd, "sqlfluff");
-  if (!cmd)
-    return 0;
-  const args = ["fix", "--force", filePath];
-  if (!hasSqlfluffConfig(cwd)) {
-    args.splice(2, 0, "--dialect", "ansi");
-  }
-  return detectFileChangedAfterCommand(filePath, cmd, args, cwd);
-}
-async function tryRubocopFix(filePath, cwd) {
-  const resolved = await resolveCommandArgsWithInstallFallback(getRubocopCommand(cwd), "rubocop", cwd, ["--version"], 1e4);
-  if (!resolved)
-    return 0;
-  return detectFileChangedAfterCommand(filePath, resolved.cmd, [...resolved.args, "-a", "--no-color", filePath], cwd, [1]);
-}
-async function tryKtlintFix(filePath, cwd) {
-  const cmd = await resolveToolCommandWithInstallFallback(cwd, "ktlint");
-  if (!cmd)
-    return 0;
-  return detectFileChangedAfterCommand(filePath, cmd, ["-F", filePath], cwd, [1]);
-}
-const golangciAutofixChecker = createAvailabilityChecker("golangci-lint", ".exe");
-const detektAutofixChecker = createAvailabilityChecker("detekt", ".bat");
-const ktfmtAutofixChecker = createAvailabilityChecker("ktfmt", ".bat");
-async function tryKtfmtFix(filePath, cwd) {
-  const cmd = await resolveAvailableOrInstall(ktfmtAutofixChecker, "ktfmt", cwd);
-  if (!cmd)
-    return 0;
-  const absPath = path.resolve(cwd, filePath);
-  return detectFileChangedAfterCommand(filePath, cmd, [absPath], cwd, [0]);
-}
-async function tryGolangciLintFix(filePath, cwd) {
-  const cmd = await resolveAvailableOrInstall(golangciAutofixChecker, "golangci-lint", cwd);
-  if (!cmd)
-    return 0;
-  return detectFileChangedAfterCommand(filePath, cmd, ["run", "--fix", filePath], cwd, [1, 7]);
-}
-async function tryDetektFix(filePath, cwd) {
-  const configPath = findDetektConfig(cwd);
-  if (!configPath)
-    return 0;
-  if (!await detektAutofixChecker.isAvailableAsync(cwd))
-    return 0;
-  const cmd = detektAutofixChecker.getCommand(cwd);
-  if (!cmd)
-    return 0;
-  const absPath = path.resolve(cwd, filePath);
-  return detectFileChangedAfterCommand(filePath, cmd, ["--auto-correct", "--input", absPath, "--config", configPath], cwd, [1, 2]);
-}
-async function tryMarkdownlintFix(filePath, cwd) {
-  const cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
-  if (!cmd)
-    return 0;
-  return detectFileChangedAfterCommand(filePath, cmd, [...markdownlintConfigArgs(cwd), "--fix", filePath], cwd, [1]);
-}
-async function tryOxlintFix(filePath, cwd) {
-  const cmd = await resolveToolCommandWithInstallFallback(cwd, "oxlint");
-  if (!cmd)
-    return 0;
-  return detectFileChangedAfterCommand(filePath, cmd, ["--fix", filePath], cwd, [1]);
-}
-async function tryRustClippyFix(filePath) {
-  const check = await probeToolAsync("cargo", ["--version"], { timeout: 5000 });
-  if (check.error || check.status !== 0)
-    return [];
-  const cargoDir = findNearestContaining(path.dirname(path.resolve(filePath)), [
-    "Cargo.toml"
-  ]);
-  if (!cargoDir)
-    return [];
-  const before = await snapshotProjectFiles(cargoDir);
-  const result = await safeSpawnAsync("cargo", ["clippy", "--fix", "--allow-dirty", "--allow-staged", "-q"], { timeout: 30000, cwd: cargoDir });
-  if (result.error || result.status !== 0)
-    return [];
-  return diffProjectSnapshot(cargoDir, before);
-}
-async function tryDartFix(filePath) {
-  const check = await probeToolAsync("dart", ["--version"], { timeout: 5000 });
-  if (check.error || check.status !== 0)
-    return [];
-  const pubspecDir = findNearestContaining(path.dirname(path.resolve(filePath)), ["pubspec.yaml"]);
-  if (!pubspecDir)
-    return [];
-  const before = await snapshotProjectFiles(pubspecDir);
-  const result = await safeSpawnAsync("dart", ["fix", "--apply"], {
-    timeout: 30000,
-    cwd: pubspecDir
-  });
-  if (result.error || result.status !== 0)
-    return [];
-  return diffProjectSnapshot(pubspecDir, before);
-}
-export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource) {
-  const { biomeClient, ruffClient, fixedThisTurn } = deps;
-  const noAutofix = getFlag("no-autofix", filePath);
-  let fixedCount = 0;
-  const autofixTools = [];
-  const attemptedTools = [];
-  const changedFiles = new Set;
-  const markTargetChanged = () => changedFiles.add(path.resolve(filePath));
-  let needsContentRefresh = false;
-  if (fixedThisTurn.has(filePath)) {
-    dbg(`autofix: skipped for ${filePath} (already fixed this turn)`);
-    return {
-      fixedCount,
-      autofixTools,
-      attemptedTools,
-      changedFiles: [],
-      needsContentRefresh,
-      skipReason: "already_fixed_this_turn"
-    };
-  }
-  if (noAutofix) {
-    const source = getFlagSource?.("no-autofix", filePath);
-    dbg(`autofix: skipped for ${filePath} (--no-autofix${source ? `, source=${source}` : ""})`);
-    return {
-      fixedCount,
-      autofixTools,
-      attemptedTools,
-      changedFiles: [],
-      needsContentRefresh,
-      skipReason: "disabled_by_flag"
-    };
-  }
-  const autofixContext = {
-    hasEslintConfig: hasEslintConfig(cwd),
-    hasStylelintConfig: hasStylelintConfig(cwd),
-    hasSqlfluffConfig: hasSqlfluffConfig(cwd),
-    hasRubocopConfig: hasRubocopConfig(cwd),
-    hasBiomeConfig: hasBiomeConfig(cwd),
-    hasGolangciConfig: hasGolangciConfig(cwd),
-    hasDetektConfig: hasDetektConfig(cwd),
-    hasKtfmtConfig: hasKtfmtConfig(cwd),
-    hasKtlintConfig: hasKtlintConfig(cwd),
-    hasOxlintConfig: hasOxlintConfig(cwd)
-  };
-  const autofixPolicy = getAutofixPolicyForFile(filePath, autofixContext);
-  const preferredAutofixTools = autofixPolicy?.safe ? getPreferredAutofixTools(filePath, autofixContext) : [];
-  dbg(`autofix: policy for ${filePath} -> ${autofixPolicy?.defaultTool ?? "none"} ` + `(preferred: ${preferredAutofixTools.join(",") || "none"}, gate: ${autofixPolicy?.gate ?? "none"}, safe: ${autofixPolicy?.safe ? "yes" : "no"})`);
-  if (!autofixPolicy) {
-    dbg(`autofix: no policy for ${filePath}`);
-    return {
-      fixedCount,
-      autofixTools,
-      attemptedTools,
-      changedFiles: [],
-      needsContentRefresh,
-      skipReason: "no_policy"
-    };
-  }
-  if (!autofixPolicy.safe || preferredAutofixTools.length === 0) {
-    dbg(`autofix: no safe preferred tools for ${filePath}`);
-    return {
-      fixedCount,
-      autofixTools,
-      attemptedTools,
-      changedFiles: [],
-      needsContentRefresh,
-      skipReason: "no_safe_tools"
-    };
-  }
-  for (const toolName of preferredAutofixTools) {
-    attemptedTools.push(toolName);
-    const agreement = establishToolAgreement(toolName, cwd);
-    if (agreement.decision === "decline") {
-      const reason = agreement.reason;
-      dbg(`autofix: ${toolName} declined (${reason})`);
-      recordDegradationOnce({
-        kind: "autofix-agreement-unavailable",
-        subject: agreement.subject,
-        reason
-      });
-      continue;
-    }
-    if (toolName === "ruff") {
-      const ruffReady = ruffClient.isPythonFile(filePath) ? await ruffClient.ensureAvailable() : false;
-      if (!ruffReady) {
-        dbg(`autofix: ruff unavailable for ${filePath}`);
-        continue;
-      }
-      const result = await ruffClient.fixFileAsync(filePath, cwd);
-      if (result.success && result.fixed > 0) {
-        fixedCount += result.fixed;
-        autofixTools.push(`ruff:${result.fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: ruff fixed ${result.fixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "biome") {
-      const biomeReady = biomeClient.isSupportedFile(filePath) ? await biomeClient.ensureAvailable() : false;
-      if (!biomeReady) {
-        dbg(`autofix: biome unavailable or unsupported for ${filePath}`);
-        continue;
-      }
-      const result = await biomeClient.fixFileAsync(filePath, cwd);
-      if (result.success && result.fixed > 0) {
-        fixedCount += result.fixed;
-        autofixTools.push(`biome:${result.fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: biome fixed ${result.fixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "eslint") {
-      const eslintFixed = await tryEslintFix(filePath, cwd);
-      if (eslintFixed > 0) {
-        fixedCount += eslintFixed;
-        autofixTools.push(`eslint:${eslintFixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: eslint fixed ${eslintFixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "stylelint") {
-      const stylelintFixed = await tryStylelintFix(filePath, cwd);
-      if (stylelintFixed > 0) {
-        fixedCount += stylelintFixed;
-        autofixTools.push(`stylelint:${stylelintFixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: stylelint fixed ${stylelintFixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "sqlfluff") {
-      const sqlfluffFixed = await trySqlfluffFix(filePath, cwd);
-      if (sqlfluffFixed > 0) {
-        fixedCount += sqlfluffFixed;
-        autofixTools.push(`sqlfluff:${sqlfluffFixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: sqlfluff fixed ${sqlfluffFixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "rubocop") {
-      const rubocopFixed = await tryRubocopFix(filePath, cwd);
-      if (rubocopFixed > 0) {
-        fixedCount += rubocopFixed;
-        autofixTools.push(`rubocop:${rubocopFixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: rubocop fixed ${rubocopFixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "ktlint") {
-      const ktlintFixed = await tryKtlintFix(filePath, cwd);
-      if (ktlintFixed > 0) {
-        fixedCount += ktlintFixed;
-        autofixTools.push(`ktlint:${ktlintFixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: ktlint fixed ${ktlintFixed} issue(s) in ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "rust-clippy") {
-      const clippyChangedFiles = await tryRustClippyFix(filePath);
-      if (clippyChangedFiles.length > 0) {
-        fixedCount += clippyChangedFiles.length;
-        autofixTools.push(`rust-clippy:${clippyChangedFiles.length}`);
-        fixedThisTurn.add(filePath);
-        for (const changedFile of clippyChangedFiles)
-          changedFiles.add(changedFile);
-        dbg(`autofix: rust-clippy changed ${clippyChangedFiles.length} file(s) from ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "dart-analyze") {
-      const dartChangedFiles = await tryDartFix(filePath);
-      if (dartChangedFiles.length > 0) {
-        fixedCount += dartChangedFiles.length;
-        autofixTools.push(`dart-analyze:${dartChangedFiles.length}`);
-        fixedThisTurn.add(filePath);
-        for (const changedFile of dartChangedFiles)
-          changedFiles.add(changedFile);
-        dbg(`autofix: dart fix changed ${dartChangedFiles.length} file(s) from ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "golangci-lint") {
-      const fixed = await tryGolangciLintFix(filePath, cwd);
-      if (fixed > 0) {
-        fixedCount += fixed;
-        autofixTools.push(`golangci-lint:${fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: golangci-lint fixed ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "detekt") {
-      const fixed = await tryDetektFix(filePath, cwd);
-      if (fixed > 0) {
-        fixedCount += fixed;
-        autofixTools.push(`detekt:${fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: detekt --auto-correct fixed ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "ktfmt") {
-      const fixed = await tryKtfmtFix(filePath, cwd);
-      if (fixed > 0) {
-        fixedCount += fixed;
-        autofixTools.push(`ktfmt:${fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: ktfmt formatted ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "markdownlint") {
-      const fixed = await tryMarkdownlintFix(filePath, cwd);
-      if (fixed > 0) {
-        fixedCount += fixed;
-        autofixTools.push(`markdownlint:${fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: markdownlint --fix fixed ${filePath}`);
-        needsContentRefresh = true;
-      }
-      continue;
-    }
-    if (toolName === "oxlint") {
-      const fixed = await tryOxlintFix(filePath, cwd);
-      if (fixed > 0) {
-        fixedCount += fixed;
-        autofixTools.push(`oxlint:${fixed}`);
-        fixedThisTurn.add(filePath);
-        markTargetChanged();
-        dbg(`autofix: oxlint --fix fixed ${filePath}`);
-        needsContentRefresh = true;
-      }
-    }
-  }
-  if (attemptedTools.length > 0 && autofixTools.length === 0) {
-    dbg(`autofix: attempted ${attemptedTools.join(",")} for ${filePath}, but no fixes were applied`);
-  }
-  return {
-    fixedCount,
-    autofixTools,
-    attemptedTools,
-    changedFiles: [...changedFiles],
-    needsContentRefresh
-  };
-}
-export async function resyncLspFile(filePath, fileContent, needsContentRefresh, lspSyncCompleted, getFlag, dbg) {
-  if (getFlag("no-lsp"))
-    return;
-  if (!needsContentRefresh && lspSyncCompleted)
-    return;
-  const limitCheck = exceedsLspSyncLimits(fileContent);
-  if (limitCheck.tooLarge)
-    return;
-  try {
-    const lspService = (await loadLspService()).getLSPService();
-    if (lspService.supportsLSP(filePath)) {
-      const budgetMs = lspSyncBudgetMs();
-      const abort = getAmbientAbortSignal();
-      if (abort?.aborted)
-        return;
-      const startedAt = Date.now();
-      const touch = lspService.touchFile(filePath, fileContent, {
-        diagnostics: "none",
-        source: "lsp_sync",
-        clientScope: "primary",
-        maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
-        saved: true
-      }).then(() => "done").catch((err) => {
-        dbg(`LSP resync after autofix error: ${err}`);
-        return "done";
-      });
-      const auxServerIds = enabledAuxiliaryLspServerIds(getFlag);
-      if (auxServerIds.length > 0) {
-        (async () => lspService.getAuxiliaryClientsForFile(filePath, new Set(auxServerIds), undefined, LSP_SPAWN_BUDGET_MS, abort, "tool_result_edit"))().catch(() => {});
-      }
-      const outcome = await bounded(touch, {
-        ms: budgetMs,
-        signal: abort,
-        hook: "tool_result_edit",
-        label: "resyncLspFile"
-      });
-      if (outcome === undefined) {
-        const spawnInFlight = !abort?.aborted && lspService.isSpawnInFlight(filePath);
-        const reason = abort?.aborted ? "aborted" : spawnInFlight ? "spawn-in-flight" : "timeout";
-        logLatency({
-          type: "phase",
-          phase: "lsp_sync_abandoned",
-          filePath,
-          durationMs: Date.now() - startedAt,
-          metadata: {
-            source: "lsp_sync",
-            reason,
-            budgetMs
-          }
-        });
-        const cause = abort?.aborted ? "aborted (Escape)" : spawnInFlight ? `timed out after ${budgetMs}ms; reason: spawn-in-flight (server still cold-spawning)` : `timed out after ${budgetMs}ms; server slow/wedged`;
-        dbg(`LSP resync ${cause} for ${filePath}`);
-      }
-    }
-  } catch (err) {
-    dbg(`LSP resync after autofix error: ${err}`);
-  }
-}
-function toPilensDiagnosticEntry(d) {
-  const entry = {
-    severity: d.severity,
-    message: d.message,
-    tool: d.tool
-  };
-  if (d.rule !== undefined)
-    entry.ruleId = d.rule;
-  if (d.line !== undefined)
-    entry.line = d.line;
-  if (d.column !== undefined)
-    entry.col = d.column;
-  if (d.fixable !== undefined)
-    entry.fixable = d.fixable;
-  return entry;
-}
-function buildAllClearOutput(_dispatchResult, elapsed, filePath) {
-  const kind = detectFileKind(filePath);
-  const langLabel = kind ? getFileKindLabel(kind) : path.extname(filePath);
-  const parts = [];
-  if (kind) {
-    parts.push(`${langLabel} clean`);
-  }
-  parts.push(`${elapsed}ms`);
-  return `checkmark ${parts.join(" · ")}`.replace("checkmark", "✓");
-}
-export async function runFormatPhase(filePath, getFormatService, dbg, signal, budgetMs = HOOK_WALL_BUDGET_MS.tool_result_edit, hook = "tool_result_edit") {
-  let formatChanged = false;
-  let formattersUsed = [];
-  const formatFailures = [];
-  const formatUnavailable = [];
-  let fileContent;
-  const formatService = getFormatService();
-  try {
-    formatService.recordRead(filePath);
-    const result = await formatService.formatFile(filePath, {
-      signal,
-      budgetMs,
-      hook
-    });
-    for (const f of result.formatters) {
-      if (f.outcome !== "unavailable")
-        continue;
-      if (f.error?.includes("project tool agreement could not be established"))
-        continue;
-      const reason = f.error ?? "formatter executable not found";
-      formatUnavailable.push({ formatter: f.name, reason });
-      recordDegradationOnce({
-        kind: "formatter-unavailable",
-        subject: `${f.name}:${path.basename(filePath)}`,
-        reason
-      });
-    }
-    formattersUsed = result.formatters.filter((f) => f.outcome !== "unavailable").map((f) => f.name);
-    if (result.anyChanged) {
-      formatChanged = true;
-      dbg("autoformat: " + result.formatters.map((f) => f.name + "(" + (f.changed ? "changed" : "unchanged") + ")").join(", "));
-    }
-    if (!result.allSucceeded) {
-      const failures = result.formatters.filter((f) => !f.success);
-      for (const failure of failures) {
-        recordDegradationOnce({
-          kind: "formatter-failure",
-          subject: `${failure.name}:${path.basename(filePath)}`,
-          reason: failure.error ?? "unknown error"
-        });
-      }
-      formatFailures.push(...failures.map((f) => `${f.name}: ${f.error ?? "unknown error"}`));
-      dbg("autoformat: " + failures.map((f) => f.name + " failed: " + (f.error ?? "unknown error")).join("; "));
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    recordDegradationOnce({
-      kind: "formatter-failure",
-      subject: `format-service:${path.basename(filePath)}`,
-      reason: message
-    });
-    formatFailures.push(message);
-    dbg(`autoformat error: ${err}`);
-  }
-  try {
-    fileContent = nodeFs.readFileSync(filePath, "utf-8");
-  } catch {
-    fileContent = undefined;
-  }
-  return {
-    formatChanged,
-    formattersUsed,
-    formatFailures,
-    formatUnavailable,
-    fileContent
-  };
-}
-function buildEnrichedBlockerOutput(blockers, fileContent = "") {
-  if (blockers.length === 0)
-    return "";
-  const fileLines = fileContent ? fileContent.split(`
-`) : [];
-  const MAX_SNIPPET = 120;
-  let out = `
-
-\uD83D\uDD34 STOP — ${blockers.length} issue(s) must be fixed:
-`;
-  const shown = blockers.slice(0, 10);
-  for (const d of shown) {
-    const lineNo = d.line ?? 1;
-    const nodeCtx = d.astNodeType ? ` (${d.astNodeType})` : "";
-    out += `  L${lineNo}: ${d.message}${nodeCtx}
-`;
-    const snippet = d.matchedText ? d.matchedText.trim().split(`
-`)[0]?.slice(0, MAX_SNIPPET) : fileLines[lineNo - 1]?.trim().slice(0, MAX_SNIPPET);
-    if (snippet)
-      out += `      → ${snippet}
-`;
-    if (d.fixSuggestion)
-      out += `      \uD83D\uDCA1 ${d.fixSuggestion}
-`;
-  }
-  if (blockers.length > 10) {
-    out += `  ... and ${blockers.length - 10} more
-`;
-  }
-  return out;
-}
-export async function runPipeline(ctx, deps) {
-  const { filePath, cwd, toolName, getFlag, getFlagSource, dbg } = ctx;
-  const { getFormatService } = deps;
-  const allowAutonomousWriters = ctx.allowAutonomousWriters !== false;
-  if (!allowAutonomousWriters) {
-    incrementDegradationCount({
-      kind: "opaque-mutation-ownership-boundary",
-      subject: "pipeline",
-      reason: `observed mutation is not evidence of agent authorship (${filePath})`
-    });
-  }
-  admitWidgetDiagnosticsWrite(filePath, ctx.telemetry?.writeIndex);
-  const phase = createPhaseTracker(toolName, filePath);
-  const pipelineStart = Date.now();
-  clearGraphCache();
-  phase.start("total");
-  phase.start("read_file");
-  let fileContent;
-  try {
-    fileContent = nodeFs.readFileSync(filePath, "utf-8");
-  } catch {}
-  phase.end("read_file");
-  phase.start("format");
-  let formatChanged = false;
-  let formattersUsed = [];
-  let formatFailures = [];
-  const piChangedFiles = new Set;
-  const autoformatDisabled = !!getFlag("no-autoformat", filePath);
-  const immediateFormat = !!getFlag("immediate-format");
-  const formatDeferred = allowAutonomousWriters && !autoformatDisabled && !immediateFormat && !!fileContent;
-  if (allowAutonomousWriters && !autoformatDisabled && immediateFormat && fileContent) {
-    const formatResult = await runFormatPhase(filePath, getFormatService, dbg, ctx.signal);
-    formatChanged = formatResult.formatChanged;
-    formattersUsed = formatResult.formattersUsed;
-    formatFailures = formatResult.formatFailures;
-    fileContent = formatResult.fileContent;
-    if (formatChanged) {
-      const absPath = path.resolve(filePath);
-      piChangedFiles.add(absPath);
-      publishFilesTouched({
-        reason: "format",
-        paths: [absPath],
-        cwd,
-        dbg,
-        fixes: formattersUsed.map((tool) => ({
-          path: absPath,
-          tool,
-          kind: "format"
-        }))
-      });
-    }
-  } else if (formatDeferred) {
-    dbg(`autoformat: deferred until agent_end for ${filePath}`);
-  } else if (!allowAutonomousWriters) {
-    dbg(`autoformat: skipped for ${filePath} (mutation ownership is unproven)`);
-  } else if (autoformatDisabled) {
-    const source = getFlagSource?.("no-autoformat", filePath);
-    dbg(`autoformat: skipped for ${filePath} (--no-autoformat${source ? `, source=${source}` : ""})`);
-  }
-  phase.end("format", {
-    formattersUsed,
-    formatChanged,
-    deferred: formatDeferred
-  });
-  phase.start("autofix");
-  let fixedCount = 0;
-  let autofixTools = [];
-  let attemptedTools = [];
-  let autofixChangedFiles = [];
-  let fixRefresh = false;
-  let autofixSkipReason;
-  if (!allowAutonomousWriters) {
-    autofixSkipReason = "mutation_ownership_unproven";
-    dbg(`autofix: skipped for ${filePath} (mutation ownership is unproven)`);
-  } else if (ctx.autofixMode === "deferred") {
-    autofixSkipReason = "deferred_to_agent_end";
-    dbg(`autofix: deferred until agent_end for ${filePath}`);
-  } else
-    ({
-      fixedCount,
-      autofixTools,
-      attemptedTools,
-      changedFiles: autofixChangedFiles,
-      needsContentRefresh: fixRefresh,
-      skipReason: autofixSkipReason
-    } = await runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource));
-  for (const changedFile of autofixChangedFiles) {
-    piChangedFiles.add(path.resolve(changedFile));
-  }
-  if (autofixChangedFiles.length > 0) {
-    const absChangedFiles = autofixChangedFiles.map((f) => path.resolve(f));
-    const toolNames = autofixTools.map((t) => t.split(":")[0]);
-    publishFilesTouched({
-      reason: "autofix",
-      paths: absChangedFiles,
-      cwd,
-      dbg,
-      fixes: absChangedFiles.flatMap((p) => toolNames.map((tool) => ({ path: p, tool, kind: "autofix" })))
-    });
-  }
-  if (fixRefresh) {
-    try {
-      fileContent = nodeFs.readFileSync(filePath, "utf-8");
-    } catch {
-      fileContent = undefined;
-    }
-  }
-  phase.end("autofix", {
-    fixedCount,
-    tools: autofixTools,
-    attemptedTools,
-    skipReason: autofixSkipReason
-  });
-  const fileModified = formatChanged || fixedCount > 0;
-  const targetFileModified = piChangedFiles.has(path.resolve(filePath));
-  const postWriteStateHash = fileModified && targetFileModified ? (() => {
-    try {
-      return nodeCrypto.createHash("sha256").update(nodeFs.readFileSync(filePath)).digest("hex");
-    } catch (error) {
-      recordDegradationOnce({
-        kind: "pipeline-post-write-hash-unavailable",
-        subject: filePath,
-        reason: error instanceof Error ? error.message : String(error)
-      });
-      return;
-    }
-  })() : undefined;
-  phase.start("lsp_sync");
-  let lspSyncCompleted = false;
-  if (fileContent) {
-    await resyncLspFile(filePath, fileContent, true, false, getFlag, dbg);
-    lspSyncCompleted = true;
-  }
-  phase.end("lsp_sync", { completed: lspSyncCompleted, finalContent: true });
-  phase.start("dispatch_lint");
-  dbg(`dispatch: running lint tools for ${filePath}`);
-  const piApi = {
-    getFlag
-  };
-  const { dispatchLintWithResult, computeCascadeForFile } = await loadDispatchIntegration();
-  const inlineBlockerFileContent = fileContent ? (() => {
-    const content = Buffer.from(fileContent, "utf8");
-    return content.byteLength <= 2 * 1024 * 1024 ? {
-      size: content.byteLength,
-      sha256: createHash("sha256").update(content).digest("hex")
-    } : undefined;
-  })() : undefined;
-  const dispatchResult = await dispatchLintWithResult(filePath, cwd, piApi, ctx.modifiedRanges, {
-    model: ctx.telemetry?.model ?? "unknown",
-    sessionId: ctx.telemetry?.sessionId ?? "unknown",
-    turnIndex: ctx.telemetry?.turnIndex ?? 0,
-    writeIndex: ctx.telemetry?.writeIndex ?? 0
-  }, {
-    projectRoot: ctx.projectRoot,
-    writeIndex: ctx.telemetry?.writeIndex,
-    telemetryModel: ctx.telemetry?.modelId,
-    telemetryProvider: ctx.telemetry?.provider
-  });
-  recordDiagnostics(filePath, dispatchResult.diagnostics, ctx.telemetry?.writeIndex);
-  {
-    const absPath = path.resolve(filePath);
-    const wasDirty = wasPreviouslyReportedDirty(absPath);
-    if (dispatchResult.diagnostics.length > 0 || wasDirty) {
-      publishDiagnostics({
-        cwd,
-        files: [
-          {
-            path: absPath,
-            diagnostics: dispatchResult.diagnostics.map(toPilensDiagnosticEntry)
-          }
-        ],
-        dbg
-      });
-    }
-  }
-  const hasBlockers = allowAutonomousWriters && dispatchResult.hasBlockers;
-  const actionableWarnings = allowAutonomousWriters ? dispatchResult.warnings.map((diagnostic) => recordFromDispatchDiagnostic(diagnostic, cwd)).filter((warning) => Boolean(warning)) : [];
-  const codeQualityWarnings = dispatchResult.warnings.map((diagnostic) => recordFromCodeQualityDiagnostic(diagnostic, cwd)).filter((warning) => Boolean(warning));
-  if (dispatchResult.diagnostics.length > 0) {
-    const tracker = getDiagnosticTracker();
-    tracker.trackShown(dispatchResult.diagnostics);
-  }
-  if (fixedCount > 0)
-    getDiagnosticTracker().trackAutoFixed(fixedCount);
-  if (dispatchResult.resolvedCount > 0)
-    getDiagnosticTracker().trackAgentFixed(dispatchResult.resolvedCount);
-  let output = "";
-  const deliverableBlockers = hasBlockers ? dropFindingsForMissingPaths({
-    store: "stop-blocker",
-    findings: dispatchResult.blockers,
-    cwd,
-    citedPath: (b) => b.filePath || undefined
-  }) : [];
-  const hasDeliverableBlockers = deliverableBlockers.length > 0;
-  if (dispatchResult.diagnostics.length > 0) {
-    const logger = getDiagnosticLogger();
-    const toKey = (d) => [
-      d.tool || "",
-      d.id || "",
-      d.rule || "",
-      d.filePath || "",
-      d.line || 0,
-      d.column || 0
-    ].join("|");
-    const inlineKeys = new Set([...deliverableBlockers, ...dispatchResult.fixed].map(toKey));
-    for (const d of dispatchResult.diagnostics) {
-      logger.logCaught(d, {
-        model: ctx.telemetry?.model ?? "unknown",
-        sessionId: ctx.telemetry?.sessionId ?? "unknown",
-        turnIndex: ctx.telemetry?.turnIndex ?? 0,
-        writeIndex: ctx.telemetry?.writeIndex ?? 0
-      }, inlineKeys.has(toKey(d)));
-    }
-  }
-  const deliveredOutput = !allowAutonomousWriters && dispatchResult.hasBlockers ? dispatchResult.output.slice(dispatchResult.blockerOutput.length) : dispatchResult.output;
-  if (hasBlockers && fileContent) {
-    if (deliverableBlockers.length > 0) {
-      output += buildEnrichedBlockerOutput(deliverableBlockers, fileContent);
-    }
-    const rest = dispatchResult.output.slice(dispatchResult.blockerOutput.length);
-    if (rest)
-      output += rest;
-  } else if (deliveredOutput) {
-    if (hasBlockers && deliverableBlockers.length !== dispatchResult.blockers.length) {
-      let gatedOut = buildEnrichedBlockerOutput(deliverableBlockers);
-      const rest = dispatchResult.output.slice(dispatchResult.blockerOutput.length);
-      if (rest)
-        gatedOut += rest;
-      if (gatedOut)
-        output += `
-
-${gatedOut}`;
-    } else {
-      output += `
-
-${deliveredOutput}`;
-    }
-  }
-  if (fixedCount > 0) {
-    const detail = autofixTools.length > 0 ? ` (${autofixTools.join(", ")})` : "";
-    output += `
-
-✅ Auto-fixed ${fixedCount} issue(s)${detail}`;
-  }
-  if (formatFailures.length > 0) {
-    const details = formatFailures.slice(0, 3).join("; ");
-    const suffix = formatFailures.length > 3 ? `; ... and ${formatFailures.length - 3} more` : "";
-    output += `
-
-⚠️ Auto-format failed: ${details}${suffix}`;
-  }
-  const postAutofixNotice = formatChanged || fixedCount > 0 ? {
-    targetPath: toRunnerDisplayPath(cwd, filePath),
-    changedFiles: [...piChangedFiles].map((changedFile) => toRunnerDisplayPath(cwd, changedFile))
-  } : undefined;
-  phase.end("dispatch_lint", {
-    hasOutput: !!dispatchResult.output,
-    diagnosticCount: dispatchResult.diagnostics.length
-  });
-  const cascadeOrigin = {
-    turnSeq: ctx.telemetry?.turnIndex,
-    writeSeq: ctx.telemetry?.writeIndex,
-    projectSeq: ctx.seqState?.projectSeq()
-  };
-  const cascadePromise = getFlag("no-lsp") ? undefined : computeCascadeForFile(filePath, cwd, {
-    hasBlockers,
-    dbg,
-    turnSeq: ctx.telemetry?.turnIndex,
-    writeSeq: ctx.telemetry?.writeIndex,
-    projectRoot: ctx.projectRoot,
-    seqState: ctx.seqState,
-    turnEndCascadeSettleStart: ctx.turnEndCascadeSettleStart,
-    fileContent,
-    wordIndex: ctx.wordIndex,
-    onWordIndexUpdated: ctx.onWordIndexUpdated
-  }).then((run) => ({ ...run, origin: cascadeOrigin })).catch((err) => {
-    dbg(`cascade compute failed for ${filePath}: ${err}`);
-    return {
-      filePath,
-      origin: cascadeOrigin,
-      result: undefined,
-      neighborCount: 0,
-      diagnosticCount: 0,
-      skipReason: "error",
-      indeterminate: {
-        reason: "error",
-        detail: "cascade computation failed"
-      }
-    };
-  });
-  const elapsed = Date.now() - pipelineStart;
-  if (!output && !postAutofixNotice) {
-    output = buildAllClearOutput(dispatchResult, elapsed, filePath);
-  }
-  phase.end("total", { hasOutput: !!output });
-  const changedFiles = [...piChangedFiles];
-  emitLensAnalysisComplete({
-    cwd,
-    filePath,
-    toolName,
-    model: ctx.telemetry?.model ?? "unknown",
-    sessionId: ctx.telemetry?.sessionId ?? "unknown",
-    turnIndex: ctx.telemetry?.turnIndex ?? 0,
-    writeIndex: ctx.telemetry?.writeIndex ?? 0,
-    diagnostics: dispatchResult.diagnostics,
-    blockers: hasBlockers ? dispatchResult.blockers : [],
-    warnings: dispatchResult.warnings,
-    fixed: dispatchResult.fixed,
-    resolvedCount: dispatchResult.resolvedCount,
-    hasBlockers,
-    fileModified,
-    changedFiles,
-    durationMs: elapsed
-  });
-  return {
-    output,
-    hasBlockers: hasDeliverableBlockers,
-    cascadePromise,
-    isError: false,
-    fileModified,
-    postWriteStateHash,
-    changedFiles,
-    inlineBlockerSummary: hasDeliverableBlockers ? formatDiagnostics(deliverableBlockers, "blocking").trim() || undefined : undefined,
-    inlineBlockerSources: hasDeliverableBlockers ? [
-      ...new Set(deliverableBlockers.map((d) => d.tool?.trim() || "unknown"))
-    ] : undefined,
-    inlineBlockerLines: hasDeliverableBlockers ? deliverableBlockers.filter((d) => normalizeEphemeralMapKey(d.filePath) === normalizeEphemeralMapKey(filePath)).map((d) => d.line).filter((line) => typeof line === "number") : undefined,
-    actionableWarnings,
-    codeQualityWarnings,
-    diagnostics: dispatchResult.diagnostics,
-    formattersUsed,
-    fixedCount,
-    autofixTools,
-    postAutofixNotice,
-    postMutation: ctx.autofixMode !== "deferred" && autofixChangedFiles.some((f) => path.resolve(f) === path.resolve(filePath)) && fileContent !== undefined ? {
-      filePath: path.resolve(filePath),
-      content: fileContent,
-      source: "autofix"
-    } : undefined,
-    inlineBlockerFileContent: hasBlockers ? inlineBlockerFileContent : undefined,
-    inlineBlockerDiagnostics: hasDeliverableBlockers ? deliverableBlockers : undefined
-  };
-}