@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -2,10 +2,11 @@ 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 {
-  findNearestContaining,
-  normalizeEphemeralMapKey
-} from "./path-utils.js";
+  inlineBlockerLines,
+  inlineBlockerSources
+} from "./inline-blocker-fields.js";
 import {
   recordFromDispatchDiagnostic
 } from "./actionable-warnings.js";
@@ -16,6 +17,7 @@ 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";
@@ -33,13 +35,18 @@ import {
   resolveToolCommandWithInstallFallback
 } from "./dispatch/runners/utils/runner-helpers.js";
 import { findDetektConfig } from "./dispatch/runners/detekt.js";
-import { formatDiagnostics } from "./dispatch/utils/format-utils.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";
@@ -49,10 +56,15 @@ import {
 } 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";
@@ -60,6 +72,9 @@ 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 {
@@ -79,6 +94,7 @@ import {
   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() {
@@ -170,7 +186,7 @@ function createPhaseTracker(toolName, filePath) {
 export { hasEslintConfig, hasSqlfluffConfig, hasStylelintConfig };
 const ESLINT_FIX_PROBE_BUDGET_MS = 5000;
 const _eslintCache = new BoundedLruCache(32);
-async function tryEslintFix(filePath, cwd) {
+async function tryEslintFix(filePath, cwd, writeHold) {
   const userHasConfig = hasEslintConfig(cwd);
   if (!userHasConfig)
     return 0;
@@ -236,53 +252,67 @@ async function tryEslintFix(filePath, cwd) {
   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) {
+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) {
+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) {
+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) {
+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) {
+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) {
+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) {
+async function tryDetektFix(filePath, cwd, writeHold) {
   const configPath = findDetektConfig(cwd);
   if (!configPath)
     return 0;
@@ -291,59 +321,102 @@ async function tryDetektFix(filePath, cwd) {
   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) {
+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) {
+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]);
 }
-async function tryRustClippyFix(filePath) {
+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 [];
+    return none;
   const cargoDir = findNearestContaining(path.dirname(path.resolve(filePath)), [
     "Cargo.toml"
   ]);
   if (!cargoDir)
-    return [];
+    return none;
+  if (writeHold)
+    await writeHold.acquire();
   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);
+  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) {
+async function tryDartFix(filePath, writeHold) {
+  const none = { changedFiles: [] };
   const check = await probeToolAsync("dart", ["--version"], { timeout: 5000 });
   if (check.error || check.status !== 0)
-    return [];
+    return none;
   const pubspecDir = findNearestContaining(path.dirname(path.resolve(filePath)), ["pubspec.yaml"]);
   if (!pubspecDir)
-    return [];
+    return none;
+  if (writeHold)
+    await writeHold.acquire();
   const before = await snapshotProjectFiles(pubspecDir);
-  const result = await safeSpawnAsync("dart", ["fix", "--apply"], {
+  const { result: changedFiles, restoring } = await runWithFixRestore({ tool: "dart-analyze", extension: ".dart", candidates: before.keys() }, () => safeSpawnAsync("dart", ["fix", "--apply"], {
     timeout: 30000,
     cwd: pubspecDir
-  });
-  if (result.error || result.status !== 0)
-    return [];
-  return diffProjectSnapshot(pubspecDir, before);
+  }), (result, agentEdited) => wholePackageChangedFiles(pubspecDir, before, result, agentEdited));
+  return { changedFiles, restoring };
 }
-export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource) {
+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)) {
@@ -425,6 +498,8 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
         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;
@@ -442,6 +517,8 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
         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;
@@ -454,7 +531,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "eslint") {
-      const eslintFixed = await tryEslintFix(filePath, cwd);
+      const eslintFixed = await tryEslintFix(filePath, cwd, writeHold);
       if (eslintFixed > 0) {
         fixedCount += eslintFixed;
         autofixTools.push(`eslint:${eslintFixed}`);
@@ -466,7 +543,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "stylelint") {
-      const stylelintFixed = await tryStylelintFix(filePath, cwd);
+      const stylelintFixed = await tryStylelintFix(filePath, cwd, writeHold);
       if (stylelintFixed > 0) {
         fixedCount += stylelintFixed;
         autofixTools.push(`stylelint:${stylelintFixed}`);
@@ -478,7 +555,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "sqlfluff") {
-      const sqlfluffFixed = await trySqlfluffFix(filePath, cwd);
+      const sqlfluffFixed = await trySqlfluffFix(filePath, cwd, writeHold);
       if (sqlfluffFixed > 0) {
         fixedCount += sqlfluffFixed;
         autofixTools.push(`sqlfluff:${sqlfluffFixed}`);
@@ -490,7 +567,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "rubocop") {
-      const rubocopFixed = await tryRubocopFix(filePath, cwd);
+      const rubocopFixed = await tryRubocopFix(filePath, cwd, writeHold);
       if (rubocopFixed > 0) {
         fixedCount += rubocopFixed;
         autofixTools.push(`rubocop:${rubocopFixed}`);
@@ -502,7 +579,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "ktlint") {
-      const ktlintFixed = await tryKtlintFix(filePath, cwd);
+      const ktlintFixed = await tryKtlintFix(filePath, cwd, writeHold);
       if (ktlintFixed > 0) {
         fixedCount += ktlintFixed;
         autofixTools.push(`ktlint:${ktlintFixed}`);
@@ -514,7 +591,10 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "rust-clippy") {
-      const clippyChangedFiles = await tryRustClippyFix(filePath);
+      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}`);
@@ -527,7 +607,10 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "dart-analyze") {
-      const dartChangedFiles = await tryDartFix(filePath);
+      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}`);
@@ -540,7 +623,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "golangci-lint") {
-      const fixed = await tryGolangciLintFix(filePath, cwd);
+      const fixed = await tryGolangciLintFix(filePath, cwd, writeHold);
       if (fixed > 0) {
         fixedCount += fixed;
         autofixTools.push(`golangci-lint:${fixed}`);
@@ -552,7 +635,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "detekt") {
-      const fixed = await tryDetektFix(filePath, cwd);
+      const fixed = await tryDetektFix(filePath, cwd, writeHold);
       if (fixed > 0) {
         fixedCount += fixed;
         autofixTools.push(`detekt:${fixed}`);
@@ -564,7 +647,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "ktfmt") {
-      const fixed = await tryKtfmtFix(filePath, cwd);
+      const fixed = await tryKtfmtFix(filePath, cwd, writeHold);
       if (fixed > 0) {
         fixedCount += fixed;
         autofixTools.push(`ktfmt:${fixed}`);
@@ -576,7 +659,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "markdownlint") {
-      const fixed = await tryMarkdownlintFix(filePath, cwd);
+      const fixed = await tryMarkdownlintFix(filePath, cwd, writeHold);
       if (fixed > 0) {
         fixedCount += fixed;
         autofixTools.push(`markdownlint:${fixed}`);
@@ -588,7 +671,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
       continue;
     }
     if (toolName === "oxlint") {
-      const fixed = await tryOxlintFix(filePath, cwd);
+      const fixed = await tryOxlintFix(filePath, cwd, writeHold);
       if (fixed > 0) {
         fixedCount += fixed;
         autofixTools.push(`oxlint:${fixed}`);
@@ -607,34 +690,82 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
     autofixTools,
     attemptedTools,
     changedFiles: [...changedFiles],
-    needsContentRefresh
+    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 resyncLspFile(filePath, fileContent, needsContentRefresh, lspSyncCompleted, getFlag, dbg) {
+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;
+    return "no-lsp";
   if (!needsContentRefresh && lspSyncCompleted)
-    return;
+    return "up-to-date";
   const limitCheck = exceedsLspSyncLimits(fileContent);
   if (limitCheck.tooLarge)
-    return;
+    return "too-large";
   try {
     const lspService = (await loadLspService()).getLSPService();
     if (lspService.supportsLSP(filePath)) {
       const budgetMs = lspSyncBudgetMs();
       const abort = getAmbientAbortSignal();
       if (abort?.aborted)
-        return;
+        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
-      }).then(() => "done").catch((err) => {
+        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 "done";
+        return "failed";
       });
       const auxServerIds = enabledAuxiliaryLspServerIds(getFlag);
       if (auxServerIds.length > 0) {
@@ -662,10 +793,14 @@ export async function resyncLspFile(filePath, fileContent, needsContentRefresh,
         });
         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) {
@@ -694,62 +829,78 @@ function buildAllClearOutput(_dispatchResult, elapsed, filePath) {
   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") {
+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;
-  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
+  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 } : {}
       });
-    }
-    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) {
+      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-failure",
-          subject: `${failure.name}:${path.basename(filePath)}`,
-          reason: failure.error ?? "unknown error"
+          kind: "formatter-unavailable",
+          subject: `${f.name}:${path.basename(filePath)}`,
+          reason
         });
       }
-      formatFailures.push(...failures.map((f) => `${f.name}: ${f.error ?? "unknown error"}`));
-      dbg("autoformat: " + failures.map((f) => f.name + " failed: " + (f.error ?? "unknown error")).join("; "));
+      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}`);
     }
-  } 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 {
-    fileContent = nodeFs.readFileSync(filePath, "utf-8");
+    fileBytes = nodeFs.readFileSync(filePath);
+    fileContent = fileBytes.toString("utf-8");
   } catch {
     fileContent = undefined;
   }
@@ -758,7 +909,11 @@ export async function runFormatPhase(filePath, getFormatService, dbg, signal, bu
     formattersUsed,
     formatFailures,
     formatUnavailable,
-    fileContent
+    fileContent,
+    fileBytes,
+    fileReadStamp,
+    ...abandoned === undefined ? {} : { abandoned },
+    fileReadAtMs
   };
 }
 function buildEnrichedBlockerOutput(blockers, fileContent = "") {
@@ -790,9 +945,18 @@ function buildEnrichedBlockerOutput(blockers, fileContent = "") {
     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;
@@ -803,31 +967,42 @@ export async function runPipeline(ctx, deps) {
       reason: `observed mutation is not evidence of agent authorship (${filePath})`
     });
   }
-  admitWidgetDiagnosticsWrite(filePath, ctx.telemetry?.writeIndex);
+  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 {
-    fileContent = nodeFs.readFileSync(filePath, "utf-8");
+    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 = !!getFlag("no-autoformat", filePath);
+  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);
+    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);
@@ -861,6 +1036,7 @@ export async function runPipeline(ctx, deps) {
   let autofixTools = [];
   let attemptedTools = [];
   let autofixChangedFiles = [];
+  let autofixRestoring;
   let fixRefresh = false;
   let autofixSkipReason;
   if (!allowAutonomousWriters) {
@@ -876,8 +1052,11 @@ export async function runPipeline(ctx, deps) {
       attemptedTools,
       changedFiles: autofixChangedFiles,
       needsContentRefresh: fixRefresh,
+      restoring: autofixRestoring,
       skipReason: autofixSkipReason
-    } = await runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSource));
+    } = 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));
   }
@@ -893,9 +1072,13 @@ export async function runPipeline(ctx, deps) {
     });
   }
   if (fixRefresh) {
+    fileReadStamp = performance.now();
+    analysisReadAtMs = Date.now();
     try {
-      fileContent = nodeFs.readFileSync(filePath, "utf-8");
+      fileBytes = nodeFs.readFileSync(filePath);
+      fileContent = fileBytes.toString("utf-8");
     } catch {
+      fileBytes = undefined;
       fileContent = undefined;
     }
   }
@@ -919,10 +1102,14 @@ export async function runPipeline(ctx, deps) {
       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);
+    await resyncLspFile(filePath, fileContent, true, false, getFlag, dbg, fileReadStamp);
     lspSyncCompleted = true;
   }
   phase.end("lsp_sync", { completed: lspSyncCompleted, finalContent: true });
@@ -932,8 +1119,8 @@ export async function runPipeline(ctx, deps) {
     getFlag
   };
   const { dispatchLintWithResult, computeCascadeForFile } = await loadDispatchIntegration();
-  const inlineBlockerFileContent = fileContent ? (() => {
-    const content = Buffer.from(fileContent, "utf8");
+  const inlineBlockerFileContent = fileBytes?.byteLength ? (() => {
+    const content = fileBytes;
     return content.byteLength <= 2 * 1024 * 1024 ? {
       size: content.byteLength,
       sha256: createHash("sha256").update(content).digest("hex")
@@ -946,11 +1133,14 @@ export async function runPipeline(ctx, deps) {
     writeIndex: ctx.telemetry?.writeIndex ?? 0
   }, {
     projectRoot: ctx.projectRoot,
-    writeIndex: ctx.telemetry?.writeIndex,
+    analysisRootMode: ctx.analysisRootMode,
+    writeIndex: widgetOrder(),
+    sessionGeneration: ctx.sessionGeneration,
+    sessionId: ctx.telemetry?.sessionId,
     telemetryModel: ctx.telemetry?.modelId,
     telemetryProvider: ctx.telemetry?.provider
   });
-  recordDiagnostics(filePath, dispatchResult.diagnostics, ctx.telemetry?.writeIndex);
+  recordDiagnostics(filePath, dispatchResult.diagnostics, widgetOrder(), analysisReadAtMs);
   {
     const absPath = path.resolve(filePath);
     const wasDirty = wasPreviouslyReportedDirty(absPath);
@@ -1060,13 +1250,15 @@ ${deliveredOutput}`;
     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
+    onWordIndexUpdated: ctx.onWordIndexUpdated,
+    sessionGeneration: ctx.sessionGeneration
   }).then((run) => ({ ...run, origin: cascadeOrigin })).catch((err) => {
     dbg(`cascade compute failed for ${filePath}: ${err}`);
     return {
@@ -1076,7 +1268,10 @@ ${deliveredOutput}`;
       neighborCount: 0,
       diagnosticCount: 0,
       skipReason: "error",
-      indeterminate: {
+      indeterminate: classifyTreeSitterWasmError(err) ? {
+        reason: "graph_degraded",
+        detail: "review graph degraded — tree-sitter wasm runtime failure"
+      } : {
         reason: "error",
         detail: "cascade computation failed"
       }
@@ -1113,12 +1308,13 @@ ${deliveredOutput}`;
     isError: false,
     fileModified,
     postWriteStateHash,
+    writeIndex: ctx.telemetry?.writeIndex,
+    orderTurn: ctx.telemetry?.orderTurn,
+    analysisReadAtMs,
     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,
+    inlineBlockerSources: hasDeliverableBlockers ? inlineBlockerSources(deliverableBlockers) : undefined,
+    inlineBlockerLines: hasDeliverableBlockers ? inlineBlockerLines(deliverableBlockers, filePath) : undefined,
     actionableWarnings,
     codeQualityWarnings,
     diagnostics: dispatchResult.diagnostics,
@@ -1131,7 +1327,7 @@ ${deliveredOutput}`;
       content: fileContent,
       source: "autofix"
     } : undefined,
-    inlineBlockerFileContent: hasBlockers ? inlineBlockerFileContent : undefined,
+    inlineBlockerFileContent,
     inlineBlockerDiagnostics: hasDeliverableBlockers ? deliverableBlockers : undefined
   };
 }