@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,1279 @@
+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 } from "./path-utils.js";
+import { inlineBlockerLines, inlineBlockerSources } from "./inline-blocker-fields.js";
+import { recordFromDispatchDiagnostic } from "./actionable-warnings.js";
+import { recordFromCodeQualityDiagnostic } from "./code-quality-warnings.js";
+import { admitWidgetDiagnosticsWrite, recordDiagnostics } from "./widget-state.js";
+import { writeOrderToken } from "./write-ordering-guard.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, formatPromotionNotes } from "./dispatch/utils/format-utils.js";
+import { detectFileKind, getFileKindLabel } from "./file-kinds.js";
+import { detectFileChangedAfterCommand, getProjectIgnoreMatcher, isExcludedDirName } from "./file-utils.js";
+import { resolveAnalysisRoot } from "./analysis-root.js";
+import { emitBounded } from "./bounded-telemetry.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 { classifyTreeSitterWasmError } from "./tree-sitter-client.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 { renderFixRunLoss, runWithFixRestore } from "./fix-run-restore.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 { holdFileMutationQueue } from "./file-mutation-queue.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";
+import { surfaceHandlerCrash } from "./session-event-guard.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, writeHold) {
+  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;
+  if (writeHold)
+    await writeHold.acquire();
+  return detectFileChangedAfterCommand(filePath, cmd, ["--fix", "--no-error-on-unmatched-pattern", filePath], cwd, [1]);
+}
+async function tryStylelintFix(filePath, cwd, writeHold) {
+  const cmd = await resolveToolCommandWithInstallFallback(cwd, "stylelint");
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  return detectFileChangedAfterCommand(filePath, cmd, ["--fix", "--allow-empty-input", filePath], cwd, [2]);
+}
+async function trySqlfluffFix(filePath, cwd, writeHold) {
+  const cmd = await resolveToolCommandWithInstallFallback(cwd, "sqlfluff");
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  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, writeHold) {
+  const resolved = await resolveCommandArgsWithInstallFallback(getRubocopCommand(cwd), "rubocop", cwd, ["--version"], 1e4);
+  if (!resolved)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  return detectFileChangedAfterCommand(filePath, resolved.cmd, [...resolved.args, "-a", "--no-color", filePath], cwd, [1]);
+}
+async function tryKtlintFix(filePath, cwd, writeHold) {
+  const cmd = await resolveToolCommandWithInstallFallback(cwd, "ktlint");
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  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, writeHold) {
+  const cmd = await resolveAvailableOrInstall(ktfmtAutofixChecker, "ktfmt", cwd);
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  const absPath = path.resolve(cwd, filePath);
+  return detectFileChangedAfterCommand(filePath, cmd, [absPath], cwd, [0]);
+}
+async function tryGolangciLintFix(filePath, cwd, writeHold) {
+  const cmd = await resolveAvailableOrInstall(golangciAutofixChecker, "golangci-lint", cwd);
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  return detectFileChangedAfterCommand(filePath, cmd, ["run", "--fix", filePath], cwd, [1, 7]);
+}
+async function tryDetektFix(filePath, cwd, writeHold) {
+  const configPath = findDetektConfig(cwd);
+  if (!configPath)
+    return 0;
+  if (!await detektAutofixChecker.isAvailableAsync(cwd))
+    return 0;
+  const cmd = detektAutofixChecker.getCommand(cwd);
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  const absPath = path.resolve(cwd, filePath);
+  return detectFileChangedAfterCommand(filePath, cmd, ["--auto-correct", "--input", absPath, "--config", configPath], cwd, [1, 2]);
+}
+async function tryMarkdownlintFix(filePath, cwd, writeHold) {
+  const cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  return detectFileChangedAfterCommand(filePath, cmd, [...markdownlintConfigArgs(cwd), "--fix", filePath], cwd, [1]);
+}
+async function tryOxlintFix(filePath, cwd, writeHold) {
+  const cmd = await resolveToolCommandWithInstallFallback(cwd, "oxlint");
+  if (!cmd)
+    return 0;
+  if (writeHold)
+    await writeHold.acquire();
+  return detectFileChangedAfterCommand(filePath, cmd, ["--fix", filePath], cwd, [1]);
+}
+function displayLoss(cwd, restoring) {
+  return restoring.then((report) => ({
+    lost: report.lost.map((f) => toRunnerDisplayPath(cwd, f)),
+    possiblyLost: report.possiblyLost.map((f) => toRunnerDisplayPath(cwd, f))
+  }));
+}
+function deliverFixRunLoss(restoring, ctx) {
+  restoring.then((loss) => {
+    if (loss.lost.length > 0 || loss.possiblyLost.length > 0)
+      ctx.onFixRunLoss?.(renderFixRunLoss(loss));
+  }).catch((failure) => ctx.dbg(`fix-run loss notice failed: ${failure instanceof Error ? failure.message : String(failure)}`));
+}
+async function wholePackageChangedFiles(root, before, result, agentEdited) {
+  if (result.error || result.status !== 0)
+    return [];
+  const edited = new Set(agentEdited);
+  const changed = await diffProjectSnapshot(root, before);
+  return changed.flatMap((file) => edited.has(file) ? [] : [file]);
+}
+async function tryRustClippyFix(filePath, writeHold) {
+  const none = { changedFiles: [] };
+  const check = await probeToolAsync("cargo", ["--version"], { timeout: 5000 });
+  if (check.error || check.status !== 0)
+    return none;
+  const cargoDir = findNearestContaining(path.dirname(path.resolve(filePath)), [
+    "Cargo.toml"
+  ]);
+  if (!cargoDir)
+    return none;
+  if (writeHold)
+    await writeHold.acquire();
+  const before = await snapshotProjectFiles(cargoDir);
+  const { result: changedFiles, restoring } = await runWithFixRestore({ tool: "rust-clippy", extension: ".rs", candidates: before.keys() }, () => safeSpawnAsync("cargo", ["clippy", "--fix", "--allow-dirty", "--allow-staged", "-q"], { timeout: 30000, cwd: cargoDir }), (result, agentEdited) => wholePackageChangedFiles(cargoDir, before, result, agentEdited));
+  return { changedFiles, restoring };
+}
+async function tryDartFix(filePath, writeHold) {
+  const none = { changedFiles: [] };
+  const check = await probeToolAsync("dart", ["--version"], { timeout: 5000 });
+  if (check.error || check.status !== 0)
+    return none;
+  const pubspecDir = findNearestContaining(path.dirname(path.resolve(filePath)), ["pubspec.yaml"]);
+  if (!pubspecDir)
+    return none;
+  if (writeHold)
+    await writeHold.acquire();
+  const before = await snapshotProjectFiles(pubspecDir);
+  const { result: changedFiles, restoring } = await runWithFixRestore({ tool: "dart-analyze", extension: ".dart", candidates: before.keys() }, () => safeSpawnAsync("dart", ["fix", "--apply"], {
+    timeout: 30000,
+    cwd: pubspecDir
+  }), (result, agentEdited) => wholePackageChangedFiles(pubspecDir, before, result, agentEdited));
+  return { changedFiles, restoring };
+}
+export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource, writeHold, sessionRoot = cwd) {
+  if (resolveAnalysisRoot(filePath, sessionRoot) === "adopted") {
+    emitBounded("adopted_root_writer_skipped", `${filePath}:autofix`, {
+      filePath,
+      durationMs: 0,
+      metadata: { writer: "autofix" }
+    }, { ledgerKind: "adopted-root-writer-skipped", risingEdgePer: "identity" });
+    return {
+      fixedCount: 0,
+      autofixTools: [],
+      attemptedTools: [],
+      changedFiles: [],
+      needsContentRefresh: false,
+      skipReason: "adopted_root"
+    };
+  }
+  const { biomeClient, ruffClient, fixedThisTurn } = deps;
+  const noAutofix = getFlag("no-autofix", filePath);
+  let fixedCount = 0;
+  const autofixTools = [];
+  const attemptedTools = [];
+  const changedFiles = new Set;
+  const restorings = [];
+  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;
+      }
+      if (writeHold)
+        await writeHold.acquire();
+      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;
+      }
+      if (writeHold)
+        await writeHold.acquire();
+      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, writeHold);
+      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, writeHold);
+      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, writeHold);
+      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, writeHold);
+      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, writeHold);
+      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 clippy = await tryRustClippyFix(filePath, writeHold);
+      const clippyChangedFiles = clippy.changedFiles;
+      if (clippy.restoring)
+        restorings.push(displayLoss(cwd, clippy.restoring));
+      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 dart = await tryDartFix(filePath, writeHold);
+      const dartChangedFiles = dart.changedFiles;
+      if (dart.restoring)
+        restorings.push(displayLoss(cwd, dart.restoring));
+      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, writeHold);
+      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, writeHold);
+      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, writeHold);
+      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, writeHold);
+      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, writeHold);
+      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,
+    restoring: restorings.length > 0 ? Promise.all(restorings).then((losses) => ({
+      lost: losses.flatMap((loss) => loss.lost),
+      possiblyLost: losses.flatMap((loss) => loss.possiblyLost)
+    })) : undefined
+  };
+}
+export async function resyncHeldLspDocument(filePath) {
+  const service = (await loadLspService()).peekLSPService();
+  if (!service)
+    return "no-service";
+  const dispositions = await service.resyncGitChangedFiles([filePath], {
+    saved: true
+  });
+  return dispositions.get(filePath) ?? "no-service";
+}
+export function chainLateFormatResync(settled, which, row, dbg) {
+  const inband = which === "inband";
+  const logLate = (outcome) => {
+    const common = {
+      type: "phase",
+      toolName: row.toolName,
+      filePath: row.filePath,
+      durationMs: Date.now() - row.startedAt,
+      metadata: { outcome }
+    };
+    if (inband)
+      logLatency({ ...common, phase: "inband_format_late_resync" });
+    else
+      logLatency({ ...common, phase: "deferred_format_late_resync" });
+  };
+  logLatency({
+    type: "phase",
+    phase: "format_late_resync_chained",
+    toolName: row.toolName,
+    filePath: row.filePath,
+    durationMs: Date.now() - row.startedAt,
+    metadata: { which }
+  });
+  return settled.then(async () => {
+    logLate(await resyncHeldLspDocument(row.filePath));
+  }).catch((err) => {
+    surfaceHandlerCrash(inband ? "inband-format-late-resync" : "deferred-format-late-resync", err, { dbg, rethrow: false });
+    logLate("failed");
+  });
+}
+export async function resyncLspFile(filePath, fileContent, needsContentRefresh, lspSyncCompleted, getFlag, dbg, readStamp) {
+  if (getFlag("no-lsp"))
+    return "no-lsp";
+  if (!needsContentRefresh && lspSyncCompleted)
+    return "up-to-date";
+  const limitCheck = exceedsLspSyncLimits(fileContent);
+  if (limitCheck.tooLarge)
+    return "too-large";
+  try {
+    const lspService = (await loadLspService()).getLSPService();
+    if (lspService.supportsLSP(filePath)) {
+      const budgetMs = lspSyncBudgetMs();
+      const abort = getAmbientAbortSignal();
+      if (abort?.aborted)
+        return "aborted";
+      const startedAt = Date.now();
+      const touch = lspService.touchFile(filePath, fileContent, {
+        diagnostics: "none",
+        source: "lsp_sync",
+        clientScope: "primary",
+        maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+        saved: true,
+        readStamp
+      }).then((result) => {
+        if (result === undefined)
+          return "not-sent";
+        return result.supersededServerIds?.length ? "superseded" : "synced";
+      }).catch((err) => {
+        dbg(`LSP resync after autofix error: ${err}`);
+        return "failed";
+      });
+      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}`);
+        return "abandoned";
+      }
+      return outcome;
+    }
+    return "unsupported";
+  } catch (err) {
+    dbg(`LSP resync after autofix error: ${err}`);
+    return "failed";
+  }
+}
+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", writeHold, sessionRoot) {
+  let formatChanged = false;
+  let formattersUsed = [];
+  const formatFailures = [];
+  const formatUnavailable = [];
+  let fileContent;
+  let abandoned;
+  const adopted = sessionRoot !== undefined && resolveAnalysisRoot(filePath, sessionRoot) === "adopted";
+  if (adopted)
+    emitBounded("adopted_root_writer_skipped", `${filePath}:format`, {
+      filePath,
+      durationMs: 0,
+      metadata: { writer: "format" }
+    }, { ledgerKind: "adopted-root-writer-skipped", risingEdgePer: "identity" });
+  if (!adopted) {
+    const formatService = getFormatService();
+    try {
+      formatService.recordRead(filePath);
+      const result = await formatService.formatFile(filePath, {
+        signal,
+        budgetMs,
+        hook,
+        ...writeHold ? { writeHold } : {}
+      });
+      abandoned = result.abandoned;
+      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}`);
+    }
+  }
+  const fileReadStamp = performance.now();
+  const fileReadAtMs = Date.now();
+  let fileBytes;
+  try {
+    fileBytes = nodeFs.readFileSync(filePath);
+    fileContent = fileBytes.toString("utf-8");
+  } catch {
+    fileContent = undefined;
+  }
+  return {
+    formatChanged,
+    formattersUsed,
+    formatFailures,
+    formatUnavailable,
+    fileContent,
+    fileBytes,
+    fileReadStamp,
+    ...abandoned === undefined ? {} : { abandoned },
+    fileReadAtMs
+  };
+}
+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
+`;
+  }
+  out += formatPromotionNotes(blockers);
+  return out;
+}
+export async function runPipeline(ctx, deps) {
+  const writeHold = holdFileMutationQueue(ctx.filePath);
+  try {
+    return await analysePipeline(ctx, deps, writeHold);
+  } finally {
+    writeHold?.release();
+  }
+}
+async function analysePipeline(ctx, deps, writeHold) {
+  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})`
+    });
+  }
+  const widgetOrder = () => writeOrderToken(ctx.telemetry?.orderTurn, ctx.telemetry?.writeIndex);
+  admitWidgetDiagnosticsWrite(filePath, widgetOrder());
+  const phase = createPhaseTracker(toolName, filePath);
+  const pipelineStart = Date.now();
+  clearGraphCache();
+  phase.start("total");
+  phase.start("read_file");
+  let fileContent;
+  let fileReadStamp = performance.now();
+  let analysisReadAtMs = Date.now();
+  let fileBytes;
+  try {
+    fileBytes = nodeFs.readFileSync(filePath);
+    fileContent = fileBytes.toString("utf-8");
+  } catch {}
+  const readContent = fileContent;
+  phase.end("read_file");
+  phase.start("format");
+  let formatChanged = false;
+  let formattersUsed = [];
+  let formatFailures = [];
+  const piChangedFiles = new Set;
+  const autoformatDisabled = resolveAnalysisRoot(filePath, ctx.projectRoot ?? cwd) === "adopted" || !!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, undefined, undefined, writeHold, ctx.projectRoot ?? cwd);
+    if (formatResult.abandoned)
+      chainLateFormatResync(formatResult.abandoned, "inband", { toolName, filePath, startedAt: pipelineStart }, dbg);
+    formatChanged = formatResult.formatChanged;
+    formattersUsed = formatResult.formattersUsed;
+    formatFailures = formatResult.formatFailures;
+    fileContent = formatResult.fileContent;
+    fileBytes = formatResult.fileBytes;
+    fileReadStamp = formatResult.fileReadStamp;
+    analysisReadAtMs = formatResult.fileReadAtMs;
+    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 autofixRestoring;
+  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,
+      restoring: autofixRestoring,
+      skipReason: autofixSkipReason
+    } = await runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource, writeHold, ctx.projectRoot ?? cwd));
+  if (autofixRestoring)
+    deliverFixRunLoss(autofixRestoring, ctx);
+  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) {
+    fileReadStamp = performance.now();
+    analysisReadAtMs = Date.now();
+    try {
+      fileBytes = nodeFs.readFileSync(filePath);
+      fileContent = fileBytes.toString("utf-8");
+    } catch {
+      fileBytes = undefined;
+      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;
+  if (fileContent !== readContent && ctx.telemetry && ctx.nextWriteIndex) {
+    ctx.telemetry = { ...ctx.telemetry, ...ctx.nextWriteIndex() };
+  }
+  writeHold?.release();
+  phase.start("lsp_sync");
+  let lspSyncCompleted = false;
+  if (fileContent) {
+    await resyncLspFile(filePath, fileContent, true, false, getFlag, dbg, fileReadStamp);
+    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 = fileBytes?.byteLength ? (() => {
+    const content = fileBytes;
+    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,
+    analysisRootMode: ctx.analysisRootMode,
+    writeIndex: widgetOrder(),
+    sessionGeneration: ctx.sessionGeneration,
+    sessionId: ctx.telemetry?.sessionId,
+    telemetryModel: ctx.telemetry?.modelId,
+    telemetryProvider: ctx.telemetry?.provider
+  });
+  recordDiagnostics(filePath, dispatchResult.diagnostics, widgetOrder(), analysisReadAtMs);
+  {
+    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,
+    orderTurn: ctx.telemetry?.orderTurn,
+    writeSeq: ctx.telemetry?.writeIndex,
+    projectRoot: ctx.projectRoot,
+    seqState: ctx.seqState,
+    turnEndCascadeSettleStart: ctx.turnEndCascadeSettleStart,
+    fileContent,
+    wordIndex: ctx.wordIndex,
+    onWordIndexUpdated: ctx.onWordIndexUpdated,
+    sessionGeneration: ctx.sessionGeneration
+  }).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: classifyTreeSitterWasmError(err) ? {
+        reason: "graph_degraded",
+        detail: "review graph degraded — tree-sitter wasm runtime failure"
+      } : {
+        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,
+    writeIndex: ctx.telemetry?.writeIndex,
+    orderTurn: ctx.telemetry?.orderTurn,
+    analysisReadAtMs,
+    changedFiles,
+    inlineBlockerSummary: hasDeliverableBlockers ? formatDiagnostics(deliverableBlockers, "blocking").trim() || undefined : undefined,
+    inlineBlockerSources: hasDeliverableBlockers ? inlineBlockerSources(deliverableBlockers) : undefined,
+    inlineBlockerLines: hasDeliverableBlockers ? inlineBlockerLines(deliverableBlockers, filePath) : 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,
+    inlineBlockerDiagnostics: hasDeliverableBlockers ? deliverableBlockers : undefined
+  };
+}