@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,1317 +0,0 @@
-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
-  };
-}