@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/runtime-tool-result.js

@@ -0,0 +1,1317 @@
+import * as nodeCrypto from "node:crypto";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { noteAuthoritativeContentAttachment } from "./agent-nudge.js";
+import { captureFileStats, diffFileContent, getOpaqueBaselineStore, recoverOpaqueChangesViaGit } from "./opaque-mutation-scan.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { detectFileKind } from "./file-kinds.js";
+import { extractReadPathsFromCommand, extractDeletedPathsFromCommand, extractGrepSearchReadsFromOutput, extractWrittenPathsFromCommand, tokenizeShellCommand } from "./bash-file-access.js";
+import { registerSearchReads } from "./search-read-registration.js";
+import { createFileTime } from "./file-time.js";
+import { publishFormatQueued } from "./format-events-publish.js";
+import { invalidateProjectIgnoreMatcherForPath, isPathIgnoredByProject } from "./file-utils.js";
+import { invalidateFormatterCacheForPath } from "./formatters.js";
+import { getFormatService } from "./format-service.js";
+import { isExternalOrVendorFile, normalizeEphemeralMapKey, pathsEqual } from "./path-utils.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
+import { resolveLanguageRootForFile } from "./language-profile.js";
+import { logLatency } from "./latency-logger.js";
+import { classifyMutatingTool, DM_LENS_SYNTHETIC_MUTATION_FIELD } from "./mutating-tool.js";
+import { hasPendingObservation, noteMutationHandled, settleObservedMutation } from "./observed-mutation.js";
+import { replayThroughMutationBridge, storedLineHashesFor } from "./observed-mutation-sources.js";
+import { getAmbientAbortSignal } from "./safe-spawn.js";
+import { resolveToolCallCorrelationId } from "./tool-event.js";
+import { boundedIndexesForCount, createReadGuardEditBatchSummary, getReadGuardCorrelationId, logReadGuardEvent } from "./read-guard-logger.js";
+import { countFileLines } from "./read-guard-tool-lines.js";
+import { notifyExternalFileChange, resyncGitChangedFiles } from "./lsp/index.js";
+import { runPipeline } from "./pipeline.js";
+import { renderPostAutofixNotice } from "./post-autofix-notice.js";
+import { syncGitGuardRecord } from "./git-guard.js";
+import { scheduleWordIndexPersist } from "./word-index.js";
+import { RUNTIME_CONFIG } from "./runtime-config.js";
+import { getActiveSessionId } from "./session-lifecycle.js";
+import { requestBootstrapClients } from "./bootstrap.js";
+import { bounded } from "./deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
+import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
+const AUTHORITATIVE_CONTENT_MAX_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
+const OBSERVED_DISPATCH_MAX_PATHS = 32;
+const GIT_INTEGRATION_SUBCOMMANDS = new Set([
+  "merge",
+  "rebase",
+  "cherry-pick",
+  "pull",
+  "revert",
+  "am"
+]);
+const GIT_GLOBAL_OPTIONS_WITH_VALUE = new Set([
+  "-C",
+  "-c",
+  "--config-env",
+  "--git-dir",
+  "--namespace",
+  "--work-tree"
+]);
+export function isFailedGitIntegrationCommand(command, isError) {
+  if (isError !== true)
+    return false;
+  return tokenizeShellCommand(command).some(({ tokens, unsupported }) => {
+    if (unsupported)
+      return false;
+    const executable = path.win32.basename(tokens[0] ?? "").toLowerCase().replace(/\.(?:cmd|exe)$/, "");
+    if (executable !== "git")
+      return false;
+    for (let index = 1;index < tokens.length; index += 1) {
+      const token = tokens[index] ?? "";
+      if (GIT_GLOBAL_OPTIONS_WITH_VALUE.has(token)) {
+        index += 1;
+        continue;
+      }
+      if (token.startsWith("-"))
+        continue;
+      return GIT_INTEGRATION_SUBCOMMANDS.has(token);
+    }
+    return false;
+  });
+}
+function ensureToolResultClients(deps) {
+  if (deps.biomeClient && deps.ruffClient && deps.metricsClient)
+    return true;
+  const request = {
+    reason: "tool-result-analysis",
+    hook: "tool_result_edit",
+    timeoutMs: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    ...deps.signal === undefined ? {} : { signal: deps.signal }
+  };
+  return bounded(requestBootstrapClients(request), {
+    ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    signal: deps.signal,
+    hook: "tool_result_edit",
+    label: "tool-result-bootstrap-demand"
+  }).then((clients) => {
+    if (!clients)
+      return false;
+    deps.biomeClient = clients.biomeClient;
+    deps.ruffClient = clients.ruffClient;
+    deps.metricsClient = clients.metricsClient;
+    return true;
+  });
+}
+function parseDiffRanges(diff) {
+  const changedLines = [];
+  for (const line of diff.split(`
+`)) {
+    const match = line.match(/^[+-]\s*(\d+)\s/);
+    if (match) {
+      changedLines.push(Number.parseInt(match[1], 10));
+    }
+  }
+  if (changedLines.length === 0)
+    return [];
+  const sorted = [...new Set(changedLines)].sort((a, b) => a - b);
+  const ranges = [];
+  let rangeStart = sorted[0];
+  let rangeEnd = sorted[0];
+  for (const line of sorted.slice(1)) {
+    if (line <= rangeEnd + 1) {
+      rangeEnd = line;
+    } else {
+      ranges.push({ start: rangeStart, end: rangeEnd });
+      rangeStart = line;
+      rangeEnd = line;
+    }
+  }
+  ranges.push({ start: rangeStart, end: rangeEnd });
+  return ranges;
+}
+const inFlightPipelines = new PathKeyedMap(normalizeEphemeralMapKey);
+const lastAnalyzedStateByFile = new PathKeyedMap(normalizeEphemeralMapKey);
+export function clearLastAnalyzedStateCache() {
+  lastAnalyzedStateByFile.clear();
+}
+function registerInFlightPipeline(filePath, stateHash, pipeline) {
+  let filePipelines = inFlightPipelines.get(filePath);
+  if (!filePipelines) {
+    filePipelines = new Map;
+    inFlightPipelines.set(filePath, filePipelines);
+  }
+  filePipelines.set(stateHash, pipeline);
+  return filePipelines;
+}
+function releaseInFlightPipeline(filePath, stateHash, registered) {
+  registered.delete(stateHash);
+  if (registered.size === 0 && inFlightPipelines.get(filePath) === registered) {
+    inFlightPipelines.delete(filePath);
+  }
+}
+function claimPipelineDispatch(args) {
+  const { filePath, stateHash, turnIndex, participantId, dbg } = args;
+  const inFlight = inFlightPipelines.get(filePath)?.get(stateHash);
+  if (inFlight) {
+    dbg(`tool_result: skipping duplicate concurrent state for ${filePath}`);
+    if (inFlight.participantIds.length < 100) {
+      inFlight.participantIds.push(participantId);
+    }
+    inFlight.participantTotal += 1;
+    return { proceed: false, joined: inFlight.promise };
+  }
+  const lastAnalyzed = lastAnalyzedStateByFile.get(filePath);
+  if (lastAnalyzed?.turnIndex === turnIndex && lastAnalyzed.stateHash === stateHash) {
+    dbg(`tool_result: skipping already-analyzed file state this turn for ${filePath}`);
+    return { proceed: false, joined: undefined };
+  }
+  return { proceed: true };
+}
+const debouncedPipelines = new PathKeyedMap(normalizeEphemeralMapKey);
+const DEFAULT_DEBOUNCE_MS = 0;
+const MAX_DEBOUNCE_MS = 1000;
+function getDebounceMs() {
+  const raw = Number(process.env.DM_LENS_TOOL_RESULT_DEBOUNCE_MS);
+  if (!Number.isFinite(raw) || raw < 0)
+    return DEFAULT_DEBOUNCE_MS;
+  return Math.min(raw, MAX_DEBOUNCE_MS);
+}
+export async function flushDebouncedToolResults(filePath) {
+  const entries = filePath ? debouncedPipelines.has(filePath) ? [
+    [
+      filePath,
+      debouncedPipelines.get(filePath)
+    ]
+  ] : [] : [...debouncedPipelines.entries()];
+  for (const [key, entry] of entries) {
+    clearTimeout(entry.timer);
+    debouncedPipelines.delete(key);
+    handleToolResult({ ...entry.latestDeps, _bypassDebounce: true }).then(entry.resolve, entry.reject);
+  }
+  if (entries.length > 0) {
+    await Promise.all(entries.map(([, entry]) => entry.promise.catch(() => {
+      return;
+    })));
+  }
+}
+function scheduleDebounced(filePath, debounceMs, deps) {
+  const existing = debouncedPipelines.get(filePath);
+  if (existing) {
+    clearTimeout(existing.timer);
+    const incomingId = deps._telemetryParticipantIds?.[0] ?? getReadGuardCorrelationId(deps.event);
+    const priorIds = existing.latestDeps._telemetryParticipantIds ?? [];
+    existing.latestDeps = {
+      ...deps,
+      _telemetryParticipantIds: [...priorIds, incomingId].slice(0, 100),
+      _telemetryParticipantTotal: (existing.latestDeps._telemetryParticipantTotal ?? priorIds.length) + 1
+    };
+    existing.coalescedCount += 1;
+    existing.timer = setTimeout(() => {
+      debouncedPipelines.delete(filePath);
+      deps.dbg(`tool_result: debounce fired after ${existing.coalescedCount} coalesced calls for ${filePath}`);
+      handleToolResult({ ...existing.latestDeps, _bypassDebounce: true }).then(existing.resolve, existing.reject);
+    }, debounceMs);
+    deps.dbg(`tool_result: coalesced into pending debounce for ${filePath} (count=${existing.coalescedCount})`);
+    return existing.promise;
+  }
+  let resolveFn;
+  let rejectFn;
+  const promise = new Promise((res, rej) => {
+    resolveFn = res;
+    rejectFn = rej;
+  });
+  const initialParticipantIds = deps._telemetryParticipantIds ?? [
+    getReadGuardCorrelationId(deps.event)
+  ];
+  const entry = {
+    timer: setTimeout(() => {
+      debouncedPipelines.delete(filePath);
+      handleToolResult({ ...entry.latestDeps, _bypassDebounce: true }).then(entry.resolve, entry.reject);
+    }, debounceMs),
+    promise,
+    resolve: resolveFn,
+    reject: rejectFn,
+    latestDeps: {
+      ...deps,
+      _telemetryParticipantIds: initialParticipantIds.slice(0, 100),
+      _telemetryParticipantTotal: deps._telemetryParticipantTotal ?? initialParticipantIds.length
+    },
+    scheduledAt: Date.now(),
+    coalescedCount: 1
+  };
+  debouncedPipelines.set(filePath, entry);
+  return promise;
+}
+function getFileStateHash(filePath) {
+  try {
+    const content = nodeFs.readFileSync(filePath);
+    return nodeCrypto.createHash("sha256").update(content).digest("hex");
+  } catch (err) {
+    const code = err.code ?? "unknown";
+    return `unreadable:${code}`;
+  }
+}
+function getRequestedEditCount(event, kind) {
+  if (kind === "write")
+    return 1;
+  const edits = event.input?.edits;
+  return Array.isArray(edits) && edits.length > 0 ? edits.length : 1;
+}
+function getRequestedEditIndexes(event, kind) {
+  return boundedIndexesForCount(getRequestedEditCount(event, kind));
+}
+function sourceForMutation(classification, details) {
+  if (details?.piLensPartialApply) {
+    return "partial-apply";
+  }
+  if (classification.provenance === "builtin" || classification.provenance === "bash-derived") {
+    return classification.kind === "write" ? "agent-write" : "agent-edit";
+  }
+  return `agent-tool:${classification.toolName}`;
+}
+function singleRange(ranges) {
+  return ranges?.length === 1 ? ranges[0] : undefined;
+}
+function recordProjectChange(args) {
+  args.runtime.recordProjectMutation?.({
+    filePath: args.filePath,
+    source: args.source,
+    cwd: args.cwd,
+    changedRange: args.changedRange,
+    onAppendError: (err) => args.dbg(`project change log append failed for ${args.filePath}: ${err}`)
+  });
+}
+function recordNativeAppliedPairs(args) {
+  const pairs = [];
+  if (args.kind !== "edit")
+    return pairs;
+  const appliedInput = args.input;
+  const record = (oldText, newText) => {
+    if (typeof oldText === "string" && oldText.length > 0) {
+      args.runtime.partialApplyRecords.record(args.filePath, oldText, newText, args.stateHash);
+      pairs.push({ oldText, newText });
+    }
+  };
+  if (Array.isArray(appliedInput.edits)) {
+    for (const edit of appliedInput.edits)
+      record(edit.oldText, edit.newText);
+  } else {
+    record(appliedInput.oldText, appliedInput.newText);
+  }
+  return pairs;
+}
+function refreshCachedExports(runtime, filePath) {
+  if (runtime.cachedExports.size === 0 || !nodeFs.existsSync(filePath))
+    return;
+  const exportRe = new RegExp("export\\s+(?:async\\s+)?(?:function|class|const|let|type|interface)\\s+(\\w+)", "g");
+  for (const [name, file] of runtime.cachedExports) {
+    if (path.resolve(file) === path.resolve(filePath)) {
+      runtime.cachedExports.delete(name);
+    }
+  }
+  try {
+    const freshContent = nodeFs.readFileSync(filePath, "utf-8");
+    for (const match of freshContent.matchAll(exportRe)) {
+      const name = match[1];
+      if (!runtime.cachedExports.has(name)) {
+        runtime.cachedExports.set(name, filePath);
+      }
+    }
+  } catch {}
+}
+async function dispatchPipelineAnalysis(args) {
+  const { deps, runtime, filePath, dispatchCwd, turnStateCwd, autofixMode, modifiedRanges, writeIndex, initialStateHash, readGuardCorrelationId, requestedEditIndexes, requestedEditTotal, isPartialApplyResult, toolResultStart, nativeAppliedPairs, allowAutonomousWriters } = args;
+  const { event, getFlag, getFlagSource, dbg, biomeClient, ruffClient, metricsClient, resetLSPService } = deps;
+  const pipelinePromise = runPipeline({
+    signal: deps.signal,
+    filePath,
+    cwd: dispatchCwd,
+    projectRoot: turnStateCwd,
+    toolName: event.toolName,
+    autofixMode,
+    allowAutonomousWriters,
+    modifiedRanges,
+    telemetry: {
+      model: runtime.telemetryModel,
+      sessionId: runtime.telemetrySessionId,
+      turnIndex: runtime.turnIndex,
+      writeIndex,
+      modelId: runtime.telemetryModelId,
+      provider: runtime.telemetryProviderId
+    },
+    getFlag,
+    getFlagSource,
+    dbg,
+    seqState: {
+      projectSeq: () => runtime.projectSeq,
+      getFilesChangedSince: (seq) => runtime.getFilesChangedSince(seq)
+    },
+    turnEndCascadeSettleStart: () => runtime.getTurnEndCascadeSettleStart(),
+    wordIndex: runtime.wordIndex,
+    onWordIndexUpdated: (index) => {
+      scheduleWordIndexPersist(dispatchCwd, index, dbg);
+    }
+  }, {
+    biomeClient,
+    ruffClient,
+    metricsClient,
+    getFormatService,
+    fixedThisTurn: runtime.fixedThisTurn
+  });
+  const pipelineTelemetry = {
+    promise: pipelinePromise,
+    participantIds: [...new Set(args.participantIds)].slice(0, 100),
+    participantTotal: args.participantTotal
+  };
+  const registeredPipelines = registerInFlightPipeline(filePath, initialStateHash, pipelineTelemetry);
+  let result;
+  try {
+    result = await pipelinePromise;
+  } catch (pipelineErr) {
+    if (getFlag("lens-guard")) {
+      runtime.markGitGuardCacheUnknown("pipeline_crash");
+    }
+    dbg(`runPipeline crashed: ${pipelineErr}`);
+    logReadGuardEvent({
+      event: "edit_post_edit_pipeline_failed",
+      correlationId: readGuardCorrelationId,
+      filePath,
+      metadata: {
+        tool: event.toolName,
+        commitStatus: "committed",
+        reasonCode: "pipeline_failed"
+      }
+    });
+    logReadGuardEvent({
+      event: "edit_batch_summary",
+      correlationId: readGuardCorrelationId,
+      filePath,
+      metadata: {
+        tool: event.toolName,
+        editBatchSummary: createReadGuardEditBatchSummary({
+          requestedIndexes: requestedEditIndexes,
+          requestedTotal: requestedEditTotal,
+          resolvedIndexes: requestedEditIndexes,
+          resolvedTotal: requestedEditTotal,
+          appliedIndexes: requestedEditIndexes,
+          appliedTotal: requestedEditTotal,
+          participantIds: pipelineTelemetry.participantIds,
+          participantTotal: pipelineTelemetry.participantTotal,
+          commitStatus: "committed",
+          postEditStatus: "failed",
+          terminalStatus: "failed",
+          durationMs: Date.now() - toolResultStart
+        })
+      }
+    });
+    dbg(`runPipeline crash stack: ${pipelineErr.stack}`);
+    const activePrimarySessionId = getActiveSessionId();
+    const crashBelongsToPrimary = activePrimarySessionId === undefined || activePrimarySessionId === runtime.telemetrySessionId;
+    if (!getFlag("no-lsp") && crashBelongsToPrimary) {
+      resetLSPService({ fast: true, reason: "pipeline_crash" });
+    }
+    logLatency({
+      type: "tool_result",
+      toolName: event.toolName,
+      filePath,
+      durationMs: Date.now() - toolResultStart,
+      result: "pipeline_crash"
+    });
+    const notice = runtime.formatPipelineCrashNotice(filePath, pipelineErr);
+    return {
+      crashed: true,
+      response: {
+        content: notice ? [...event.content, { type: "text", text: notice }] : event.content,
+        isError: true
+      }
+    };
+  } finally {
+    releaseInFlightPipeline(filePath, initialStateHash, registeredPipelines);
+  }
+  if (!isPartialApplyResult) {
+    const postEditStatus = result.isError ? "failed" : "succeeded";
+    if (result.isError) {
+      logReadGuardEvent({
+        event: "edit_post_edit_pipeline_failed",
+        correlationId: readGuardCorrelationId,
+        filePath,
+        metadata: {
+          tool: event.toolName,
+          commitStatus: "committed",
+          reasonCode: "pipeline_failed"
+        }
+      });
+    }
+    logReadGuardEvent({
+      event: "edit_batch_summary",
+      correlationId: readGuardCorrelationId,
+      filePath,
+      metadata: {
+        tool: event.toolName,
+        editBatchSummary: createReadGuardEditBatchSummary({
+          requestedIndexes: requestedEditIndexes,
+          requestedTotal: requestedEditTotal,
+          resolvedIndexes: requestedEditIndexes,
+          resolvedTotal: requestedEditTotal,
+          appliedIndexes: requestedEditIndexes,
+          appliedTotal: requestedEditTotal,
+          participantIds: pipelineTelemetry.participantIds,
+          participantTotal: pipelineTelemetry.participantTotal,
+          commitStatus: "committed",
+          postEditStatus,
+          terminalStatus: postEditStatus === "failed" ? "failed" : "success",
+          durationMs: Date.now() - toolResultStart
+        })
+      }
+    });
+  }
+  const pipelineOwnedWriteHash = result.fileModified ? result.postWriteStateHash : undefined;
+  const finalStateHash = pipelineOwnedWriteHash ?? initialStateHash;
+  if (!result.fileModified || pipelineOwnedWriteHash !== undefined) {
+    lastAnalyzedStateByFile.set(filePath, {
+      turnIndex: runtime.turnIndex,
+      stateHash: finalStateHash
+    });
+  }
+  if (pipelineOwnedWriteHash !== undefined) {
+    for (const pair of nativeAppliedPairs) {
+      runtime.partialApplyRecords.noteAfterWriteHash(filePath, pair.oldText, pair.newText, finalStateHash);
+    }
+  }
+  if (!getFlag("no-read-guard") && allowAutonomousWriters) {
+    const changedForReadGuard = new Set([
+      path.resolve(filePath),
+      ...(result.changedFiles ?? []).map((changedFile) => path.resolve(changedFile))
+    ]);
+    for (const changedFile of changedForReadGuard) {
+      if (nodeFs.existsSync(changedFile)) {
+        deps.readGuard?.recordWritten(changedFile);
+      }
+    }
+  }
+  return { crashed: false, result };
+}
+export async function handleToolResult(deps) {
+  const { event, getFlag, dbg, runtime, cacheManager, agentBehaviorRecord, formatBehaviorWarnings } = deps;
+  const rawFilePath = event.input.path;
+  const workspaceRoot = runtime.projectRoot || process.cwd();
+  let bashAuthorshipConfirmed = deps._allowAutonomousWriters ?? deps._readGuardAuthorship ?? event.toolName !== "bash";
+  const toolCallId = resolveToolCallCorrelationId(event);
+  const attribution = toolCallId !== undefined ? runtime.takeToolCallAttribution(toolCallId) : undefined;
+  let resolutionBasis;
+  if (attribution) {
+    resolutionBasis = attribution.originCwd;
+  } else if (toolCallId !== undefined && rawFilePath && !path.isAbsolute(rawFilePath)) {
+    const guessedPath = path.resolve(workspaceRoot, rawFilePath);
+    dbg(`path_attribution_missing: no recorded resolution basis for toolCallId=${toolCallId}, refusing relative path ${rawFilePath} (would have guessed ${guessedPath})`);
+    logLatency({
+      type: "phase",
+      toolName: event.toolName,
+      filePath: guessedPath,
+      phase: "path_attribution_missing",
+      durationMs: 0,
+      metadata: { toolCallId, rawFilePath, guessedPath }
+    });
+    return;
+  } else {
+    resolutionBasis = workspaceRoot;
+  }
+  const filePath = rawFilePath ? path.isAbsolute(rawFilePath) ? rawFilePath : path.resolve(resolutionBasis, rawFilePath) : rawFilePath;
+  if (filePath) {
+    invalidateProjectIgnoreMatcherForPath(filePath);
+    invalidateFormatterCacheForPath(filePath);
+  }
+  if (attribution?.skipped && filePath && attribution.resolvedPath && !pathsEqual(filePath, attribution.resolvedPath)) {
+    const message = `path_attribution_refused: call target ${attribution.resolvedPath} (originCwd=${attribution.originCwd}) vs tool_result resolved ${filePath}`;
+    dbg(message);
+    logLatency({
+      type: "phase",
+      toolName: event.toolName,
+      filePath,
+      phase: "path_attribution_refused",
+      durationMs: 0,
+      metadata: {
+        callTarget: attribution.resolvedPath,
+        resolvedPath: filePath,
+        originCwd: attribution.originCwd
+      }
+    });
+  }
+  const behaviorWarnings = agentBehaviorRecord(event.toolName, filePath);
+  const syntheticWriteContent = [];
+  const syntheticAttachmentBudget = {
+    remaining: AUTHORITATIVE_CONTENT_MAX_BYTES
+  };
+  if (event.toolName === "bash" && typeof event.input.command === "string") {
+    const command = event.input.command;
+    const recognized = extractWrittenPathsFromCommand(command, workspaceRoot);
+    let recognizedWritten = event.isError !== true ? recognized.filter((wp) => !isExternalOrVendorFile(wp, workspaceRoot) && !isPathIgnoredByProject(wp, workspaceRoot, false)) : [];
+    if (!getFlag("no-read-guard")) {
+      for (const recognizedPath of recognizedWritten)
+        deps.readGuard?.recordUnchanged?.(recognizedPath);
+    }
+    let opaquePaths = [];
+    let observedChangedKeys;
+    let recognizedAuthored = [];
+    if (workspaceRoot && !getFlag("no-read-guard")) {
+      const scanRoot = workspaceRoot;
+      const started = Date.now();
+      const pending = getOpaqueBaselineStore().take(`${normalizeMapKey(path.resolve(scanRoot))}:${runtime.sessionGeneration}`);
+      let unknownReason;
+      if (!pending && recognized.length > 0) {
+        unknownReason = "partial-recognition-no-baseline";
+      } else if (!pending) {
+        unknownReason = "no-pending-snapshot";
+      } else if (pending.strategy === "git") {
+        const recovery = await recoverOpaqueChangesViaGit(scanRoot, pending.startedAt, {
+          excludeIndexOnlyWhenUnmerged: isFailedGitIntegrationCommand(command, event.isError)
+        });
+        if (recovery.verdict === "recovered") {
+          opaquePaths = recovery.paths.filter((p) => !isExternalOrVendorFile(p, scanRoot) && !isPathIgnoredByProject(p, scanRoot, false));
+          observedChangedKeys = new Set(opaquePaths);
+        } else if (recovery.verdict === "unknown") {
+          unknownReason = recovery.unknownReason;
+        } else {
+          observedChangedKeys = new Set;
+        }
+        if ((recovery.excludedIncomingCount ?? 0) > 0) {
+          logLatency({
+            type: "phase",
+            phase: "opaque_mutation_incoming_excluded",
+            filePath: command.slice(0, 80),
+            durationMs: Date.now() - started,
+            result: `excluded:${recovery.excludedIncomingCount}`
+          });
+        }
+        if ((recovery.unknownStatusCount ?? 0) > 0) {
+          logLatency({
+            type: "phase",
+            phase: "opaque_mutation_status_pair_unknown",
+            filePath: command.slice(0, 80),
+            durationMs: Date.now() - started,
+            result: `kept:${recovery.unknownStatusCount}`
+          });
+        }
+      } else if (pending.stats) {
+        const outcome = await captureFileStats(scanRoot, {
+          withHashes: true,
+          ...deps._opaqueCaptureOptions
+        });
+        if (outcome.snapshot && !outcome.unknownReason) {
+          opaquePaths = diffFileContent(pending.stats, outcome.snapshot);
+          observedChangedKeys = new Set(opaquePaths);
+        } else {
+          unknownReason = outcome.unknownReason ?? pending.statsUnknownReason ?? "walk-failed";
+        }
+      } else {
+        unknownReason = pending.statsUnknownReason ?? "walk-failed";
+      }
+      if (opaquePaths.length > 0 && recognizedWritten.length > 0) {
+        const survivingKeys = new Set(recognizedWritten.map((p) => normalizeMapKey(path.resolve(p))));
+        opaquePaths = opaquePaths.filter((p) => !survivingKeys.has(p));
+      }
+      if (observedChangedKeys) {
+        recognizedAuthored = recognizedWritten.filter((file) => observedChangedKeys.has(normalizeMapKey(path.resolve(file))));
+        if (recognizedAuthored.length === 0)
+          recognizedWritten = [];
+      } else if (unknownReason) {
+        recognizedAuthored = [];
+      }
+      if (unknownReason) {
+        logLatency({
+          type: "phase",
+          phase: "opaque_mutation_coverage_unknown",
+          filePath: command.slice(0, 80),
+          durationMs: Date.now() - started,
+          result: unknownReason
+        });
+      }
+      if (opaquePaths.length > 0) {
+        logLatency({
+          type: "phase",
+          phase: "opaque_mutation_recovered",
+          filePath: opaquePaths.slice(0, 5).join(","),
+          durationMs: Date.now() - started,
+          result: `changed:${opaquePaths.length}`
+        });
+        resyncGitChangedFiles(opaquePaths).catch((err) => {
+          dbg(`git-change LSP resync failed: ${err}`);
+        });
+      }
+    }
+    const opaqueSet = new Set(opaquePaths);
+    const written = [...recognizedWritten, ...opaquePaths];
+    const recognizedAuthoredSet = new Set(recognizedAuthored);
+    bashAuthorshipConfirmed = recognizedAuthored.length > 0;
+    for (const wp of written) {
+      if (!getFlag("no-read-guard") && recognizedAuthoredSet.has(wp))
+        deps.readGuard?.recordWritten(wp);
+      else if (!getFlag("no-read-guard") && recognizedWritten.includes(wp))
+        deps.readGuard?.recordUnchanged?.(wp);
+      const receipt = runtime.recordMutationToolReceipt;
+      const autofixMode = receipt ? receipt.call(runtime, wp, "write").autofixMode : "immediate";
+      const isOpaque = opaqueSet.has(wp);
+      const syntheticEvent = {
+        ...event,
+        toolName: "write",
+        input: { path: wp },
+        isError: false,
+        [DM_LENS_SYNTHETIC_MUTATION_FIELD]: "bash"
+      };
+      const syntheticResult = await handleToolResult({
+        ...deps,
+        event: syntheticEvent,
+        _bypassDebounce: true,
+        _autofixMode: autofixMode,
+        _attachmentBudget: syntheticAttachmentBudget,
+        _mutationSourceOverride: isOpaque ? "opaque-script" : undefined,
+        _readGuardAuthorship: recognizedAuthoredSet.has(wp),
+        _allowAutonomousWriters: recognizedAuthoredSet.has(wp)
+      });
+      if (syntheticResult) {
+        syntheticWriteContent.push(...syntheticResult.content.slice(event.content.length));
+      }
+    }
+    if (event.isError !== true && !getFlag("no-read-guard")) {
+      const truncation = event.details?.truncation;
+      const parsedSpans = extractReadPathsFromCommand(command, workspaceRoot);
+      let spans = parsedSpans;
+      if (truncation?.truncated === true && typeof truncation.outputLines === "number") {
+        if (parsedSpans.length === 1) {
+          const span = parsedSpans[0];
+          if (span) {
+            const hasTrailingNewline = nodeFs.readFileSync(span.filePath, "utf8").endsWith(`
+`);
+            const spanLineCount = hasTrailingNewline ? Math.max(1, span.limit - 1) : span.limit;
+            const shown = Math.min(truncation.outputLines, spanLineCount);
+            spans = shown > 0 ? [
+              {
+                ...span,
+                offset: span.offset + spanLineCount - shown,
+                limit: shown
+              }
+            ] : [];
+          }
+        } else if (parsedSpans.length > 1) {
+          recordDegradationOnce({
+            kind: "bash-view-clipped",
+            subject: "multi-span",
+            reason: "truncated bash view contained multiple spans"
+          });
+          spans = [];
+        }
+        if (parsedSpans.length === 1 && spans.length === 1 && (spans[0]?.offset !== parsedSpans[0]?.offset || spans[0]?.limit !== parsedSpans[0]?.limit)) {
+          recordDegradationOnce({
+            kind: "bash-view-clipped",
+            subject: parsedSpans[0]?.filePath ?? "unknown",
+            reason: "truncated bash view narrowed a single span"
+          });
+        }
+      }
+      for (const span of spans) {
+        if (isExternalOrVendorFile(span.filePath, workspaceRoot))
+          continue;
+        if (isPathIgnoredByProject(span.filePath, workspaceRoot, false))
+          continue;
+        deps.readGuard?.recordRead({
+          filePath: span.filePath,
+          requestedOffset: span.offset,
+          requestedLimit: span.limit,
+          effectiveOffset: span.offset,
+          effectiveLimit: span.limit,
+          expandedByLsp: false,
+          turnIndex: runtime.turnIndex,
+          writeIndex: runtime.peekWriteIndex(),
+          timestamp: Date.now()
+        });
+      }
+    }
+    if (event.isError !== true && !getFlag("no-lsp") && !getFlag("no-read-guard")) {
+      for (const dp of extractDeletedPathsFromCommand(command, workspaceRoot)) {
+        if (isExternalOrVendorFile(dp, workspaceRoot))
+          continue;
+        if (isPathIgnoredByProject(dp, workspaceRoot, false))
+          continue;
+        if (!deps.readGuard || !deps.readGuard.hasKnownPath(dp))
+          continue;
+        if (nodeFs.existsSync(dp))
+          continue;
+        deps.readGuard.forgetPath(dp);
+        notifyExternalFileChange(dp, 3).catch((err) => {
+          dbg(`tool_result: external-delete notify failed for ${dp}: ${err}`);
+        });
+      }
+    }
+  }
+  if (deps.readGuard && event.isError !== true && !getFlag("no-read-guard")) {
+    const searchReads = [];
+    const detailSearchReads = event.details?.searchReads;
+    if (Array.isArray(detailSearchReads))
+      searchReads.push(...detailSearchReads);
+    if (event.toolName === "bash" && typeof event.input.command === "string") {
+      const command = event.input.command;
+      const output = event.content.map((part) => typeof part.text === "string" ? part.text : "").join(`
+`);
+      searchReads.push(...extractGrepSearchReadsFromOutput(command, workspaceRoot, output));
+    }
+    if (searchReads.length > 0) {
+      registerSearchReads(deps.readGuard, searchReads, {
+        projectRoot: workspaceRoot,
+        turnIndex: runtime.turnIndex,
+        writeIndex: runtime.peekWriteIndex()
+      });
+    }
+  }
+  if (deps.readGuard && event.toolName === "read" && event.isError !== true && filePath && !getFlag("no-read-guard") && !isExternalOrVendorFile(filePath, workspaceRoot)) {
+    const deliveredFilePath = attribution?.resolvedPath && nodeFs.existsSync(attribution.resolvedPath) ? attribution.resolvedPath : filePath;
+    if (nodeFs.existsSync(deliveredFilePath)) {
+      const nativeReadToolCallId = resolveToolCallCorrelationId(event);
+      const input = event.input;
+      const requestedOffset = input.offset ?? 1;
+      const requestedLimit = input.limit;
+      const truncation = event.details?.truncation;
+      const available = Math.max(0, countFileLines(deliveredFilePath) - requestedOffset + 1);
+      const deliveredLimit = Math.min(available, truncation?.outputLines ?? requestedLimit ?? available);
+      if (deliveredLimit > 0) {
+        if (truncation?.truncated === true && deliveredLimit < available) {
+          recordDegradationOnce({
+            kind: "native-read-clipped",
+            subject: deliveredFilePath,
+            reason: "native read result was clipped before delivery"
+          });
+        }
+        logReadGuardEvent({
+          event: "read_pattern",
+          sessionId: runtime.telemetrySessionId,
+          filePath: deliveredFilePath,
+          requestedOffset,
+          requestedLimit: requestedLimit ?? deliveredLimit,
+          effectiveOffset: requestedOffset,
+          effectiveLimit: deliveredLimit,
+          metadata: {
+            totalLines: countFileLines(deliveredFilePath),
+            isPartial: deliveredLimit < available,
+            fileKind: detectFileKind(deliveredFilePath) ?? "unknown",
+            fractionRead: available > 0 ? Math.round(deliveredLimit / available * 100) / 100 : 1,
+            expandedByTs: false
+          }
+        });
+        const deliveredRecord = {
+          filePath: deliveredFilePath,
+          requestedOffset,
+          requestedLimit: requestedLimit ?? deliveredLimit,
+          effectiveOffset: requestedOffset,
+          effectiveLimit: deliveredLimit,
+          expandedByLsp: false,
+          turnIndex: runtime.turnIndex,
+          writeIndex: runtime.peekWriteIndex(),
+          timestamp: Date.now()
+        };
+        if (nativeReadToolCallId) {
+          deps.readGuard.recordRead(deliveredRecord, {
+            supersedes: { toolCallId: nativeReadToolCallId }
+          });
+        } else {
+          deps.readGuard.recordRead(deliveredRecord);
+        }
+      }
+    }
+  }
+  const mutation = classifyMutatingTool(event, {
+    filePath: filePath || undefined,
+    sessionId: deps.sessionId,
+    recognizeOnly: true
+  });
+  const observationPending = !getFlag("no-read-guard") && hasPendingObservation(resolveToolCallCorrelationId(event));
+  const preSettleStateHash = observationPending && filePath ? getFileStateHash(filePath) : undefined;
+  let observedReplayed = 0;
+  let observedChangedPaths = [];
+  if (observationPending) {
+    const observed = await settleObservedMutation({
+      toolCallId: resolveToolCallCorrelationId(event),
+      toolName: event.toolName,
+      sessionGeneration: runtime.sessionGeneration,
+      turnIndex: runtime.turnIndex,
+      signal: getAmbientAbortSignal(),
+      record: replayThroughMutationBridge,
+      getStoredLineHashes: (candidate) => storedLineHashesFor(deps.readGuard, candidate),
+      isRecordable: (candidate) => !isExternalOrVendorFile(candidate, workspaceRoot) && !isPathIgnoredByProject(candidate, workspaceRoot, false),
+      dbg
+    });
+    observedReplayed = observed.replayed;
+    observedChangedPaths = observed.changedPaths;
+    if (observed.replayed > 0) {
+      dbg(`tool_result: observed ${observed.replayed} mutation(s) from tool "${event.toolName}"`);
+    } else if (observed.reason) {
+      dbg(`tool_result: observation for "${event.toolName}" did not settle: ${observed.reason}`);
+    }
+  }
+  const toolResultStart = Date.now();
+  if (observedReplayed > 0) {
+    if (filePath && !isExternalOrVendorFile(filePath, workspaceRoot)) {
+      const observedKind = mutation?.kind ?? "edit";
+      const observedStateHash = preSettleStateHash ?? getFileStateHash(filePath);
+      const observedAppliedPairs = recordNativeAppliedPairs({
+        runtime,
+        input: event.input,
+        kind: observedKind,
+        filePath,
+        stateHash: observedStateHash
+      });
+      const receiptOutcome = runtime.recordMutationToolReceipt?.call(runtime, filePath, observedKind);
+      refreshCachedExports(runtime, filePath);
+      const observedAutofixMode = receiptOutcome?.autofixMode ?? (observedKind === "edit" ? "deferred" : "immediate");
+      const observedDispatchPaths = observedChangedPaths.filter((candidate) => {
+        try {
+          return !nodeFs.statSync(candidate).isDirectory();
+        } catch {
+          return false;
+        }
+      }).slice(0, OBSERVED_DISPATCH_MAX_PATHS);
+      const observedDispatchDropped = observedChangedPaths.length - observedDispatchPaths.length;
+      if (observedDispatchDropped > 0) {
+        incrementDegradationCount({
+          kind: "observed-mutation-dispatch-cap",
+          subject: event.toolName,
+          reason: `observed mutation dispatch capped at ${OBSERVED_DISPATCH_MAX_PATHS}; ${observedDispatchDropped} path(s) not dispatched`
+        });
+      }
+      if (observedDispatchPaths.length > 0) {
+        const observedClients = ensureToolResultClients(deps);
+        if (observedClients !== true && !await bounded(Promise.resolve(observedClients), {
+          ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+          signal: deps.signal ?? undefined,
+          hook: "tool_result_edit",
+          label: "observed-tool-result-analysis"
+        }))
+          return;
+        const observedReadGuardCorrelationId = getReadGuardCorrelationId(event);
+        for (const observedPath of observedDispatchPaths) {
+          const observedDispatchSignal = deps.signal;
+          const observedJoinSignal = deps.signal;
+          const observedStateHashForPath = getFileStateHash(observedPath);
+          const observedClaim = claimPipelineDispatch({
+            filePath: observedPath,
+            stateHash: observedStateHashForPath,
+            turnIndex: runtime.turnIndex,
+            participantId: observedReadGuardCorrelationId,
+            dbg
+          });
+          if (!observedClaim.proceed) {
+            if (observedClaim.joined) {
+              await bounded(observedClaim.joined, {
+                ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+                signal: observedJoinSignal,
+                hook: "tool_result_edit",
+                label: "observed-tool-result-join"
+              });
+            }
+            continue;
+          }
+          const observedDispatchOutcome = await bounded(dispatchPipelineAnalysis({
+            deps,
+            runtime,
+            filePath: observedPath,
+            dispatchCwd: resolveLanguageRootForFile(observedPath, workspaceRoot),
+            turnStateCwd: path.resolve(workspaceRoot),
+            autofixMode: observedAutofixMode,
+            modifiedRanges: undefined,
+            writeIndex: runtime.nextWriteIndex(),
+            initialStateHash: observedStateHashForPath,
+            readGuardCorrelationId: observedReadGuardCorrelationId,
+            requestedEditIndexes: getRequestedEditIndexes(event, observedKind),
+            requestedEditTotal: getRequestedEditCount(event, observedKind),
+            isPartialApplyResult: (event.details ?? {}).piLensPartialApply === true,
+            participantIds: [observedReadGuardCorrelationId],
+            participantTotal: 1,
+            toolResultStart,
+            nativeAppliedPairs: observedAppliedPairs,
+            allowAutonomousWriters: true
+          }), {
+            ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+            signal: observedDispatchSignal,
+            hook: "tool_result_edit",
+            label: "observed-tool-result-analysis"
+          });
+          if (observedDispatchOutcome?.crashed) {
+            dbg(`tool_result: pipeline analysis crashed for the observed mutation on ${observedPath}; the recorded edit stands, analysis did not run this turn`);
+            return observedDispatchOutcome.response;
+          }
+        }
+        dbg(`tool_result: the observational settle already recorded ${observedReplayed} mutation(s) for "${event.toolName}"; kept the applied-edit records, mutation receipt, cachedExports refresh, and ran the pipeline dispatch (#2464); skipped the bridge-covered staleness stamp / turn-state ranges / change-log receipt / deferred autofix+format`);
+      } else {
+        dbg(`tool_result: the observational settle recorded ${observedReplayed} mutation(s) for "${event.toolName}", but no dispatchable changed paths remained`);
+      }
+    }
+    return syntheticWriteContent.length > 0 ? { content: [...event.content, ...syntheticWriteContent] } : undefined;
+  }
+  if (mutation === undefined) {
+    dbg(`tool_result: skipped turn tracking - toolName="${event.toolName}" is not a classified mutation`);
+    return syntheticWriteContent.length > 0 ? { content: [...event.content, ...syntheticWriteContent] } : undefined;
+  }
+  if (!filePath) {
+    dbg(`tool_result: skipped turn tracking - no filePath for toolName="${event.toolName}"`);
+    return;
+  }
+  if (isExternalOrVendorFile(filePath, workspaceRoot)) {
+    dbg(`tool_result: skipped pipeline - file outside project root or in node_modules: ${filePath}`);
+    return;
+  }
+  noteMutationHandled(filePath);
+  const readGuardCorrelationId = getReadGuardCorrelationId(event);
+  const resultDetails = event.details ?? {};
+  const isPartialApplyResult = resultDetails.piLensPartialApply === true;
+  const requestedEditIndexes = getRequestedEditIndexes(event, mutation.kind);
+  const requestedEditTotal = getRequestedEditCount(event, mutation.kind);
+  const participantIds = [
+    ...deps._telemetryParticipantIds ?? [],
+    readGuardCorrelationId
+  ].slice(0, 100);
+  const participantTotal = (deps._telemetryParticipantTotal ?? 0) + (deps._telemetryParticipantIds?.includes(readGuardCorrelationId) ? 0 : 1);
+  const hostToolResultFailed = event.isError === true || resultDetails.isError === true;
+  if (hostToolResultFailed) {
+    logReadGuardEvent({
+      event: "edit_batch_summary",
+      correlationId: readGuardCorrelationId,
+      filePath,
+      metadata: {
+        tool: event.toolName,
+        source: "host_tool_result",
+        editBatchSummary: createReadGuardEditBatchSummary({
+          requestedIndexes: requestedEditIndexes,
+          requestedTotal: requestedEditTotal,
+          rejectedReasons: requestedEditIndexes.map((index) => ({
+            index,
+            code: "write_failed"
+          })),
+          rejectedTotal: requestedEditTotal,
+          participantIds: [readGuardCorrelationId],
+          participantTotal: 1,
+          commitStatus: "failed",
+          terminalStatus: "failed"
+        })
+      }
+    });
+    return { content: event.content, isError: true };
+  }
+  const postWriteStateHash = preSettleStateHash ?? getFileStateHash(filePath);
+  const nativeAppliedPairs = recordNativeAppliedPairs({
+    runtime,
+    input: event.input,
+    kind: mutation.kind,
+    filePath,
+    stateHash: postWriteStateHash
+  });
+  const receipt = runtime.recordMutationToolReceipt;
+  const autofixMode = deps._bypassDebounce ? deps._autofixMode ?? (mutation.kind === "edit" ? "deferred" : "immediate") : receipt ? receipt.call(runtime, filePath, mutation.kind).autofixMode : mutation.kind === "edit" ? "deferred" : "immediate";
+  if (!deps._bypassDebounce) {
+    const debounceMs = getDebounceMs();
+    if (debounceMs > 0) {
+      return scheduleDebounced(filePath, debounceMs, {
+        ...deps,
+        _autofixMode: autofixMode,
+        _telemetryParticipantIds: [readGuardCorrelationId],
+        _telemetryParticipantTotal: 1
+      });
+    }
+  }
+  if (bashAuthorshipConfirmed)
+    deps.readGuard?.recordWritten(filePath);
+  refreshCachedExports(runtime, filePath);
+  const initialStateHash = postWriteStateHash;
+  const classifiedClaim = claimPipelineDispatch({
+    filePath,
+    stateHash: initialStateHash,
+    turnIndex: runtime.turnIndex,
+    participantId: readGuardCorrelationId,
+    dbg
+  });
+  if (!classifiedClaim.proceed) {
+    if (classifiedClaim.joined) {
+      await classifiedClaim.joined;
+    }
+    return;
+  }
+  const sessionFileTime = createFileTime("default");
+  sessionFileTime.read(filePath);
+  if (!getFlag("no-read-guard") && bashAuthorshipConfirmed) {
+    const readGuard = runtime.readGuard;
+    readGuard?.recordWritten?.(filePath);
+  }
+  dbg(`tool_result: tracking turn state for ${event.toolName} on ${filePath}`);
+  if (isPathIgnoredByProject(filePath, workspaceRoot, false)) {
+    dbg(`tool_result: skipping gitignored file ${filePath}`);
+    return;
+  }
+  const dispatchCwd = resolveLanguageRootForFile(filePath, workspaceRoot);
+  const turnStateCwd = path.resolve(workspaceRoot);
+  dbg(`tool_result: resolved dispatch cwd ${dispatchCwd} for ${filePath} (turnState cwd ${turnStateCwd})`);
+  const writeIndex = runtime.nextWriteIndex();
+  let modifiedRanges;
+  const adapterRanges = mutation.editRanges && mutation.editRanges.length > 0 ? mutation.editRanges.map(([start, end]) => ({ start, end })) : mutation.touchedLines ? [{ start: mutation.touchedLines[0], end: mutation.touchedLines[1] }] : undefined;
+  try {
+    const details = event.details;
+    dbg(`tool_result: details.diff=${details?.diff ? "present" : "missing"}, details keys: ${Object.keys(event.details || {}).join(", ")}`);
+    if (mutation.kind === "edit" && details?.diff) {
+      const diff = details.diff;
+      dbg(`tool_result: diff content (first 500 chars): ${diff.substring(0, 500)}`);
+      const ranges = parseDiffRanges(diff);
+      modifiedRanges = ranges;
+      const importsChanged = /import\s/.test(diff) || /from\s+['"]/.test(diff);
+      dbg(`tool_result: parsed ${ranges.length} ranges, importsChanged=${importsChanged}`);
+      for (const range of ranges) {
+        dbg(`tool_result: adding range ${range.start}-${range.end} for ${filePath}`);
+        cacheManager.addModifiedRange(filePath, range, importsChanged, turnStateCwd, runtime.telemetrySessionId);
+      }
+      dbg(`tool_result: turn state after add: ${JSON.stringify(cacheManager.readTurnState(turnStateCwd))}`);
+    } else if (mutation.kind === "edit" && adapterRanges && nodeFs.existsSync(filePath)) {
+      const content = nodeFs.readFileSync(filePath, "utf-8");
+      const importsChanged = /^import\s/m.test(content);
+      modifiedRanges = adapterRanges;
+      for (const range of adapterRanges) {
+        cacheManager.addModifiedRange(filePath, range, importsChanged, turnStateCwd, runtime.telemetrySessionId);
+      }
+    } else if (mutation.kind === "edit" && mutation.provenance === "declared" && nodeFs.existsSync(filePath)) {
+      const content = nodeFs.readFileSync(filePath, "utf-8");
+      const lineCount = content.split(`
+`).length;
+      const importsChanged = /^import\s/m.test(content);
+      modifiedRanges = [{ start: 1, end: lineCount }];
+      cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, importsChanged, turnStateCwd, runtime.telemetrySessionId);
+    } else if (mutation.kind === "write" && nodeFs.existsSync(filePath)) {
+      const content = nodeFs.readFileSync(filePath, "utf-8");
+      const lineCount = content.split(`
+`).length;
+      const hasImports = /^import\s/m.test(content);
+      modifiedRanges = [{ start: 1, end: lineCount }];
+      cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, hasImports, turnStateCwd, runtime.telemetrySessionId);
+    }
+  } catch (err) {
+    dbg(`turn state tracking error: ${err}`);
+    dbg(`turn state tracking error stack: ${err.stack}`);
+  }
+  recordProjectChange({
+    runtime,
+    cwd: turnStateCwd,
+    filePath,
+    source: deps._mutationSourceOverride ?? sourceForMutation(mutation, event.details),
+    changedRange: singleRange(modifiedRanges),
+    dbg
+  });
+  const turnStateMs = Date.now() - toolResultStart;
+  logLatency({
+    type: "phase",
+    toolName: event.toolName,
+    filePath,
+    phase: "turn_state_tracking",
+    durationMs: turnStateMs
+  });
+  dbg(`tool_result fired for: ${filePath} (turn_state: ${turnStateMs}ms)`);
+  const classifiedClients = ensureToolResultClients(deps);
+  if (classifiedClients !== true && !await bounded(Promise.resolve(classifiedClients), {
+    ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    signal: deps.signal,
+    hook: "tool_result_edit",
+    label: "classified-tool-result-analysis"
+  }))
+    return;
+  const dispatchOutcome = await bounded(dispatchPipelineAnalysis({
+    deps,
+    runtime,
+    filePath,
+    dispatchCwd,
+    turnStateCwd,
+    autofixMode,
+    modifiedRanges,
+    writeIndex,
+    initialStateHash,
+    readGuardCorrelationId,
+    requestedEditIndexes,
+    requestedEditTotal,
+    isPartialApplyResult,
+    participantIds,
+    participantTotal,
+    toolResultStart,
+    nativeAppliedPairs,
+    allowAutonomousWriters: bashAuthorshipConfirmed
+  }), {
+    ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    signal: deps.signal || undefined,
+    hook: "tool_result_edit",
+    label: "pipeline-analysis"
+  });
+  if (!dispatchOutcome)
+    return;
+  if (dispatchOutcome.crashed) {
+    return dispatchOutcome.response;
+  }
+  const result = dispatchOutcome.result;
+  let autofixNewlyQueued = false;
+  if (!result.isError && bashAuthorshipConfirmed && autofixMode === "deferred" && nodeFs.existsSync(filePath)) {
+    autofixNewlyQueued = runtime.deferMutation?.call(runtime, filePath, dispatchCwd, event.toolName, turnStateCwd, "autofix", deps.sessionId, resolutionBasis) ?? false;
+    dbg(`tool_result: queued deferred autofix for ${filePath}`);
+  }
+  let formatQueued = false;
+  if (!result.isError && bashAuthorshipConfirmed && !getFlag("no-autoformat", filePath) && (autofixMode === "deferred" || !getFlag("immediate-format")) && nodeFs.existsSync(filePath)) {
+    const isNewlyQueued = runtime.deferFormat(filePath, dispatchCwd, event.toolName, turnStateCwd, deps.sessionId, resolutionBasis);
+    formatQueued = true;
+    dbg(`tool_result: queued deferred format for ${filePath}`);
+    logLatency({
+      type: "phase",
+      toolName: event.toolName,
+      filePath,
+      phase: "deferred_format_queued",
+      durationMs: 0,
+      metadata: { cwd: dispatchCwd }
+    });
+    if (isNewlyQueued || autofixNewlyQueued) {
+      publishFormatQueued({
+        filePath,
+        cwd: dispatchCwd,
+        tool: mutation.kind,
+        dbg,
+        kinds: autofixMode === "deferred" ? ["autofix", "format"] : ["format"]
+      });
+    }
+  }
+  if (autofixNewlyQueued && !formatQueued) {
+    publishFormatQueued({
+      filePath,
+      cwd: dispatchCwd,
+      tool: mutation.kind,
+      kinds: ["autofix"],
+      dbg
+    });
+  }
+  for (const changedFile of result.changedFiles ?? []) {
+    const resolvedChanged = path.resolve(changedFile);
+    invalidateFormatterCacheForPath(resolvedChanged);
+    if (!nodeFs.existsSync(resolvedChanged))
+      continue;
+    recordProjectChange({
+      runtime,
+      cwd: turnStateCwd,
+      filePath: resolvedChanged,
+      source: "autofix",
+      dbg
+    });
+    if (pathsEqual(path.resolve(turnStateCwd, changedFile), path.resolve(filePath)))
+      continue;
+    try {
+      const content = nodeFs.readFileSync(resolvedChanged, "utf-8");
+      const lineCount = content.split(`
+`).length;
+      const hasImports = /^import\s/m.test(content);
+      cacheManager.addModifiedRange(resolvedChanged, { start: 1, end: lineCount }, hasImports, turnStateCwd);
+      dbg(`tool_result: tracking dm-lens side-effect change for ${resolvedChanged}`);
+    } catch (err) {
+      dbg(`tool_result: side-effect tracking failed for ${resolvedChanged}: ${err}`);
+    }
+  }
+  if (result.cascadePromise) {
+    runtime.appendCascadePromise(result.cascadePromise);
+  }
+  if (result.actionableWarnings?.length) {
+    runtime.recordActionableWarnings(result.actionableWarnings);
+  }
+  if (result.codeQualityWarnings?.length) {
+    runtime.recordCodeQualityWarnings(result.codeQualityWarnings);
+  }
+  if (getFlag("lens-turn-summary")) {
+    if (result.diagnostics?.length) {
+      for (const d of result.diagnostics) {
+        runtime.turnSummary.recordDiagnostic(d.filePath || filePath, {
+          tool: d.tool,
+          ruleId: d.rule ?? d.code,
+          severity: d.severity,
+          line: d.line,
+          description: d.message
+        });
+      }
+    }
+    if (result.fixedCount && result.fixedCount > 0) {
+      for (const label of result.autofixTools ?? []) {
+        const [tool, countStr] = label.split(":");
+        const count = Number.parseInt(countStr ?? "", 10);
+        runtime.turnSummary.recordAutofix(filePath, {
+          tool: tool || label,
+          description: Number.isFinite(count) && count > 0 ? `${count} issue(s) fixed` : undefined
+        });
+      }
+    }
+    if (result.formattersUsed?.length) {
+      for (const tool of result.formattersUsed) {
+        runtime.turnSummary.recordFormat(filePath, { tool });
+      }
+    }
+  }
+  if (result.inlineBlockerSummary) {
+    runtime.recordInlineBlockers(filePath, result.inlineBlockerSummary, writeIndex, result.inlineBlockerSources, result.inlineBlockerLines, result.inlineBlockerFileContent, result.inlineBlockerDiagnostics);
+  } else {
+    runtime.clearInlineBlockers(filePath);
+  }
+  runtime.updateGitGuardStatus(result.hasBlockers, result.output);
+  if (getFlag("lens-guard")) {
+    syncGitGuardRecord(runtime, cacheManager, turnStateCwd, filePath);
+    if (result.isError && !result.hasBlockers) {
+      runtime.markGitGuardCacheUnknown("pipeline_error");
+    }
+  }
+  if (result.isError) {
+    return {
+      content: [...event.content, { type: "text", text: result.output }],
+      isError: true
+    };
+  }
+  let output = result.output;
+  if (behaviorWarnings.length > 0 && !result.hasBlockers) {
+    output += `
+
+${formatBehaviorWarnings(behaviorWarnings)}`;
+  }
+  const totalMs = Date.now() - toolResultStart;
+  logLatency({
+    type: "tool_result",
+    toolName: event.toolName,
+    filePath,
+    durationMs: totalMs,
+    result: output ? "completed" : "no_output"
+  });
+  runtime.reportedThisTurn.add(filePath);
+  const postMutation = result.postMutation;
+  const attachmentText = postMutation ? `dm-lens applied autofix to ${postMutation.filePath}. The following full content is authoritative for subsequent edits:
+
+${postMutation.content}` : "";
+  const contentBytes = postMutation ? Buffer.byteLength(postMutation.content, "utf-8") : 0;
+  const withinPerFileCap = contentBytes <= AUTHORITATIVE_CONTENT_MAX_BYTES;
+  const budget = deps._attachmentBudget;
+  const withinSharedBudget = !budget || Buffer.byteLength(attachmentText, "utf-8") <= budget.remaining;
+  const attachAuthoritativeContent = postMutation !== undefined && withinPerFileCap && withinSharedBudget;
+  const attachmentDecision = !postMutation ? "none" : attachAuthoritativeContent ? "attached" : withinPerFileCap ? "aggregate-budget-degraded" : "size-capped";
+  const notice = result.postAutofixNotice ?? (postMutation ? { targetPath: postMutation.filePath, changedFiles: [] } : undefined);
+  if (postMutation && attachAuthoritativeContent && budget) {
+    budget.remaining -= Buffer.byteLength(attachmentText, "utf-8");
+  }
+  if (postMutation || notice) {
+    logLatency({
+      type: "phase",
+      phase: "authoritative_content_attachment_decision",
+      filePath: postMutation?.filePath ?? filePath,
+      durationMs: 0,
+      metadata: {
+        path: postMutation?.filePath ?? filePath,
+        bytes: contentBytes,
+        decision: attachmentDecision
+      }
+    });
+  }
+  if (postMutation) {
+    noteAuthoritativeContentAttachment(postMutation.filePath, attachAuthoritativeContent);
+  }
+  const returnedContent = attachAuthoritativeContent ? [...event.content, { type: "text", text: attachmentText }] : event.content;
+  if (notice) {
+    output = `${output ? `${output}
+
+` : ""}${renderPostAutofixNotice(notice, attachmentDecision)}`;
+  }
+  if (!output && !result.postMutation)
+    return;
+  return {
+    content: output ? [...returnedContent, { type: "text", text: output }] : returnedContent
+  };
+}