@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

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

@@ -0,0 +1,1630 @@
+import * as nodeCrypto from "node:crypto";
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { noteAuthoritativeContentAttachment, queueAgentAdvisory } from "./agent-nudge.js";
+import { captureFileStats, diffFileContent, getOpaqueBaselineStore, opaqueBaselineSlot, 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 { publishFormatQueued } from "./format-events-publish.js";
+import { invalidateProjectIgnoreMatcherForPath, isDmLensInternalPath, isPathIgnoredByProject } from "./file-utils.js";
+import { invalidateFormatterCacheForPath } from "./formatters.js";
+import { judgeConfirmedDelete } from "./confirmed-delete.js";
+import { deliveredLineEvidence } from "./read-guard.js";
+import { expectationFromToolInput, noteAgentCallEnd, noteAgentMutation } from "./fix-run-restore.js";
+import { getFormatService } from "./format-service.js";
+import { isExternalOrVendorFile, isVendorPath, isOutsideProjectRoot, 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, readToolResultPathField, 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 { resolveReadEvidenceCorrelationId, 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/capabilities.js";
+import { runPipeline } from "./pipeline.js";
+import { renderPostAutofixNotice } from "./post-autofix-notice.js";
+import { EXPANSION_LIMIT_LINES } from "./read-expansion.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 { recordDroppedRead, sessionFencedFixedThisTurn } from "./session-scope.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";
+import { canWriteAnalysisRoot, resolveAnalysisRoot, resolveAnalysisRootPath } from "./analysis-root.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);
+function inFlightKey(stateHash, authored) {
+  return authored ? stateHash : `${stateHash}#unauthored`;
+}
+export function clearLastAnalyzedStateCache() {
+  lastAnalyzedStateByFile.clear();
+}
+function registerInFlightPipeline(filePath, registryKey, pipeline) {
+  let filePipelines = inFlightPipelines.get(filePath);
+  if (!filePipelines) {
+    filePipelines = new Map;
+    inFlightPipelines.set(filePath, filePipelines);
+  }
+  filePipelines.set(registryKey, pipeline);
+  return filePipelines;
+}
+function releaseInFlightPipeline(filePath, registryKey, registered) {
+  registered.delete(registryKey);
+  if (registered.size === 0 && inFlightPipelines.get(filePath) === registered) {
+    inFlightPipelines.delete(filePath);
+  }
+}
+function claimPipelineDispatch(args) {
+  const { filePath, stateHash, turnIndex, authored, participantId, dbg } = args;
+  const filePipelines = inFlightPipelines.get(filePath);
+  const inFlight = filePipelines?.get(inFlightKey(stateHash, true)) ?? (authored ? undefined : filePipelines?.get(inFlightKey(stateHash, false)));
+  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 && (lastAnalyzed.authored || !authored)) {
+    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;
+}
+export function recordProjectChange(args) {
+  if (!canWriteAnalysisRoot(args.analysisRootMode))
+    return;
+  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}`)
+  });
+}
+export function recordTurnSummary(args) {
+  if (!args.resultLive)
+    return;
+  if (!canWriteAnalysisRoot(args.analysisRootMode))
+    return;
+  if (!args.getFlag("lens-turn-summary"))
+    return;
+  if (args.result.diagnostics?.length) {
+    for (const d of args.result.diagnostics) {
+      args.runtime.turnSummary.recordDiagnostic(d.filePath || args.filePath, {
+        tool: d.tool,
+        ruleId: d.rule ?? d.code,
+        severity: d.severity,
+        line: d.line,
+        description: d.message
+      });
+    }
+  }
+  if (args.result.fixedCount && args.result.fixedCount > 0) {
+    for (const label of args.result.autofixTools ?? []) {
+      const [tool, countStr] = label.split(":");
+      const count = Number.parseInt(countStr ?? "", 10);
+      args.runtime.turnSummary.recordAutofix(args.filePath, {
+        tool: tool || label,
+        description: Number.isFinite(count) && count > 0 ? `${count} issue(s) fixed` : undefined
+      });
+    }
+  }
+  if (args.result.formattersUsed?.length) {
+    for (const tool of args.result.formattersUsed) {
+      args.runtime.turnSummary.recordFormat(args.filePath, { tool });
+    }
+  }
+}
+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, analysisRootMode, autofixMode, modifiedRanges, writeIndex, writeOrderTurn, initialStateHash, readGuardCorrelationId, requestedEditIndexes, requestedEditTotal, isPartialApplyResult, toolResultStart, nativeAppliedPairs, allowAutonomousWriters, sessionGeneration, ownFileTimeStamp = true, preserveNativeAuthorship = false } = args;
+  const { event, getFlag, getFlagSource, dbg, biomeClient, ruffClient, metricsClient, resetLSPService } = deps;
+  const fixedThisTurn = sessionFencedFixedThisTurn(runtime.fixedThisTurn, sessionGeneration);
+  const pipelinePromise = runPipeline({
+    signal: deps.signal,
+    filePath,
+    cwd: dispatchCwd,
+    projectRoot: turnStateCwd,
+    analysisRootMode,
+    toolName: event.toolName,
+    autofixMode,
+    allowAutonomousWriters,
+    modifiedRanges,
+    telemetry: {
+      model: runtime.telemetryModel,
+      sessionId: runtime.telemetrySessionId,
+      turnIndex: runtime.turnIndex,
+      writeIndex,
+      orderTurn: writeOrderTurn,
+      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);
+    },
+    sessionGeneration,
+    onFixRunLoss: (notice) => queueAgentAdvisory(notice, sessionGeneration),
+    nextWriteIndex: () => ({
+      turnIndex: runtime.turnIndex,
+      orderTurn: runtime.writeOrderTurn,
+      writeIndex: runtime.nextWriteIndex()
+    })
+  }, {
+    biomeClient,
+    ruffClient,
+    metricsClient,
+    getFormatService,
+    fixedThisTurn
+  });
+  const pipelineTelemetry = {
+    promise: pipelinePromise,
+    participantIds: [...new Set(args.participantIds)].slice(0, 100),
+    participantTotal: args.participantTotal
+  };
+  const registryKey = inFlightKey(initialStateHash, allowAutonomousWriters);
+  const registeredPipelines = registerInFlightPipeline(filePath, registryKey, 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,
+        structuredContent: event.structuredContent
+      }
+    };
+  } finally {
+    releaseInFlightPipeline(filePath, registryKey, 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) {
+    sessionGeneration.guardedWrite(filePath, () => lastAnalyzedStateByFile.set(filePath, {
+      turnIndex: runtime.turnIndex,
+      stateHash: finalStateHash,
+      authored: allowAutonomousWriters
+    }));
+  }
+  if (pipelineOwnedWriteHash !== undefined) {
+    for (const pair of nativeAppliedPairs) {
+      runtime.partialApplyRecords.noteAfterWriteHash(filePath, pair.oldText, pair.newText, finalStateHash);
+    }
+  }
+  if (!getFlag("no-read-guard") && allowAutonomousWriters) {
+    const ownPath = path.resolve(filePath);
+    const changedForReadGuard = new Set([
+      ownPath,
+      ...(result.changedFiles ?? []).map((changedFile) => path.resolve(changedFile))
+    ]);
+    for (const changedFile of changedForReadGuard) {
+      if (changedFile === ownPath && pipelineOwnedWriteHash === undefined && preserveNativeAuthorship)
+        continue;
+      if (nodeFs.existsSync(changedFile)) {
+        deps.readGuard?.recordWritten(changedFile, {
+          authorship: "whole-file",
+          stampFileTime: ownFileTimeStamp || changedFile !== ownPath,
+          ...changedFile === ownPath && (!result.fileModified || pipelineOwnedWriteHash !== undefined) && {
+            contentHash: finalStateHash
+          }
+        });
+      }
+    }
+  }
+  return { crashed: false, result };
+}
+function singlePositionalEdit(input) {
+  const edits = input?.edits;
+  if (!Array.isArray(edits) || edits.length !== 1)
+    return;
+  const edit = edits[0];
+  const start = edit?.range?.start?.line;
+  return typeof start === "number" && typeof edit.newText === "string" ? { start, newText: edit.newText } : undefined;
+}
+function ownEditEvidence(filePath, edit) {
+  const full = deliveredLineEvidence(edit.newText, edit.start);
+  if (!edit.newText.endsWith(`
+`))
+    return full;
+  const certain = deliveredLineEvidence(edit.newText.slice(0, -1), edit.start);
+  try {
+    const next = nodeFs.readFileSync(filePath, "utf-8").split(/\r?\n/)[edit.start + certain.lineCount - 1];
+    return next !== undefined && next.trim() === "" ? full : certain;
+  } catch {
+    return certain;
+  }
+}
+const PI_READ_NOTICE = /\n\n\[(?:Showing lines \d+-\d+ of \d+(?: \([^)\]]+ limit\))?|\d+ more lines in file)\. Use offset=\d+ to continue\.\]$/;
+function piReadBody(text) {
+  return text.replace(PI_READ_NOTICE, "");
+}
+function logConversationRead(source, filePath, offset, evidence) {
+  logLatency({
+    type: "phase",
+    phase: "read_guard_conversation_read",
+    filePath,
+    durationMs: 0,
+    metadata: {
+      source,
+      offset,
+      lineCount: evidence.lineCount,
+      hashed: evidence.lineHashes !== undefined
+    }
+  });
+}
+function readWideningNote(widening) {
+  const { requested, shown, boundary } = widening;
+  const reason = "heading" in boundary ? `the Markdown section under the heading "${boundary.heading}" (heading boundary)` : `the enclosing ${boundary.symbol.kind} "${boundary.symbol.name}" (symbol boundary)`;
+  return `[dm-lens: read widened to ${reason}: you asked for lines ${requested.offset}-${requested.offset + requested.limit - 1}, this shows lines ${shown.offset}-${shown.offset + shown.limit - 1}. Re-request with limit > ${EXPANSION_LIMIT_LINES} for the exact range.]`;
+}
+export function handleToolExecutionEnd(event, readGuard) {
+  if (event?.isError !== true)
+    return false;
+  const toolCallId = resolveToolCallCorrelationId(event);
+  return toolCallId !== undefined ? readGuard.dropProvisionalReadByCall(toolCallId) : false;
+}
+export async function handleToolResult(deps) {
+  const { event, getFlag, dbg, runtime, cacheManager, agentBehaviorRecord, formatBehaviorWarnings } = deps;
+  const writeSession = deps._sessionGeneration ?? runtime.captureSessionGeneration();
+  const rawFilePath = readToolResultPathField(event);
+  const workspaceRoot = runtime.projectRoot || process.cwd();
+  let bashAuthorshipConfirmed = deps._allowAutonomousWriters ?? deps._readGuardAuthorship ?? event.toolName !== "bash";
+  const toolCallId = resolveToolCallCorrelationId(event);
+  const readEvidenceToolCallId = resolveReadEvidenceCorrelationId(event);
+  noteAgentCallEnd(toolCallId);
+  if (event.isError === true && toolCallId !== undefined)
+    deps.readGuard?.dropProvisionalReadByCall(toolCallId);
+  const attribution = toolCallId !== undefined ? runtime.takeToolCallAttribution(toolCallId) : undefined;
+  const readWidening = event.toolName === "read" && toolCallId !== undefined ? runtime.takeReadWidening(toolCallId) : undefined;
+  const executedRead = event.input;
+  const notedWidening = readWidening && event.isError !== true && (rawFilePath ?? executedRead.filePath) === readWidening.inputPath && executedRead.offset === readWidening.shown.offset && executedRead.limit === readWidening.shown.limit ? readWidening : undefined;
+  const readNote = notedWidening ? [{ type: "text", text: readWideningNote(notedWidening) }] : [];
+  if (notedWidening) {
+    logLatency({
+      type: "phase",
+      phase: "read_widening_note",
+      toolName: event.toolName,
+      filePath: notedWidening.filePath,
+      durationMs: 0,
+      metadata: {
+        requested: notedWidening.requested,
+        shown: notedWidening.shown,
+        boundary: "heading" in notedWidening.boundary ? "heading" : "symbol"
+      }
+    });
+  }
+  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 readNote.length > 0 ? {
+      content: [...readNote, ...event.content],
+      structuredContent: event.structuredContent
+    } : undefined;
+  } else {
+    resolutionBasis = workspaceRoot;
+  }
+  const filePath = rawFilePath ? path.isAbsolute(rawFilePath) ? rawFilePath : path.resolve(resolutionBasis, rawFilePath) : rawFilePath;
+  const analysisRootMode = resolveAnalysisRoot(filePath ?? "", workspaceRoot);
+  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)) : [];
+    let opaquePaths = [];
+    let hadOpaqueRecovery = false;
+    let observedChangedKeys;
+    let recognizedAuthored = [];
+    if (workspaceRoot && !getFlag("no-read-guard")) {
+      const scanRoot = workspaceRoot;
+      const started = Date.now();
+      const pending = getOpaqueBaselineStore().take(opaqueBaselineSlot(scanRoot, runtime.sessionGeneration), toolCallId);
+      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));
+      }
+      hadOpaqueRecovery = opaquePaths.length > 0;
+      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, {
+          authorship: hadOpaqueRecovery || opaqueSet.has(wp) ? "unknown" : "whole-file",
+          stampFileTime: false,
+          ...toolCallId !== undefined && { toolCallId }
+        });
+      const receipt = runtime.recordMutationToolReceipt;
+      const autofixMode = (receipt && writeSession.guardedWrite(wp, () => 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),
+        _ownWriteStamp: {
+          stampFileTime: false,
+          ...toolCallId !== undefined && { toolCallId }
+        },
+        _allowAutonomousWriters: recognizedAuthoredSet.has(wp),
+        _sessionGeneration: writeSession
+      });
+      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(),
+          ...readEvidenceToolCallId !== undefined && {
+            toolCallId: readEvidenceToolCallId
+          }
+        });
+      }
+    }
+    const readGuard = deps.readGuard;
+    if (event.isError !== true && readGuard !== undefined && !getFlag("no-lsp") && !getFlag("no-read-guard")) {
+      for (const dp of extractDeletedPathsFromCommand(command, workspaceRoot)) {
+        const verdict = judgeConfirmedDelete(dp, {
+          isExternalOrVendorFile: (p) => isExternalOrVendorFile(p, workspaceRoot),
+          isPathIgnoredByProject: (p) => isPathIgnoredByProject(p, workspaceRoot, false),
+          hasKnownPath: (p) => readGuard.hasKnownPath(p),
+          existsSync: (p) => nodeFs.existsSync(p)
+        });
+        if (verdict !== "confirmed")
+          continue;
+        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(),
+        ...readEvidenceToolCallId !== undefined && {
+          toolCallId: readEvidenceToolCallId
+        }
+      });
+    }
+  }
+  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 input = event.input;
+      const requestedOffset = Math.max(1, 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 raced = deps.readGuard.diskMovedSinceStamp(deliveredFilePath);
+        const deliveredText = raced ? deliveredLineEvidence(piReadBody(event.content.map((part) => part.type === "text" ? part.text ?? "" : "").join(`
+`)), requestedOffset) : undefined;
+        const capture = raced ? deps.readGuard.getReadHistory(deliveredFilePath).slice().reverse().find((candidate) => candidate.source === `native-read:${toolCallId}:provisional`) : undefined;
+        const capturedLines = capture?.lineHashes ? Object.keys(capture.lineHashes).length : 0;
+        const delivered = deliveredText && (truncation?.outputLines !== undefined ? deliveredText.lineCount <= truncation.outputLines : requestedLimit !== undefined && deliveredText.lineCount === capturedLines) ? deliveredText : undefined;
+        const shownLimit = capture ? Math.min(capture.effectiveLimit, truncation?.outputLines ?? Number.POSITIVE_INFINITY, capturedLines) : 0;
+        const captureEvidence = capture?.lineHashes && {
+          effectiveOffset: capture.effectiveOffset,
+          effectiveLimit: shownLimit,
+          lineHashes: Object.fromEntries(Object.entries(capture.lineHashes).slice(0, shownLimit))
+        };
+        if (raced) {
+          incrementDegradationCount({
+            kind: "native-read-raced-writer",
+            subject: deliveredFilePath,
+            reason: delivered ? "the file changed between pi's read and its tool_result; the read is recorded from the delivered text" : captureEvidence ? "the file changed between pi's read and its tool_result; pi's line count does not vouch for the delivered text, so the tool_call's capture is the evidence" : "the file changed between pi's read and its tool_result; pi's line count does not vouch for the delivered text and there is no hashed tool_call capture, so the read is not recorded"
+          });
+        }
+        const evidence = raced && !delivered ? captureEvidence : {
+          effectiveOffset: requestedOffset,
+          effectiveLimit: delivered?.lineCount ?? deliveredLimit,
+          lineHashes: delivered?.lineHashes
+        };
+        if (evidence) {
+          const deliveredRecord = {
+            filePath: deliveredFilePath,
+            requestedOffset,
+            requestedLimit: requestedLimit ?? deliveredLimit,
+            effectiveOffset: evidence.effectiveOffset,
+            effectiveLimit: evidence.effectiveLimit,
+            expandedByLsp: false,
+            ...evidence.lineHashes && { lineHashes: evidence.lineHashes },
+            turnIndex: runtime.turnIndex,
+            writeIndex: runtime.peekWriteIndex(),
+            timestamp: Date.now(),
+            ...readEvidenceToolCallId !== undefined && {
+              toolCallId: readEvidenceToolCallId
+            }
+          };
+          deps.readGuard.recordRead(deliveredRecord, {
+            ...toolCallId && { supersedes: { toolCallId } },
+            stampFileTime: !raced
+          });
+        }
+      }
+    }
+  }
+  const mutation = classifyMutatingTool(event, {
+    filePath: filePath || undefined,
+    sessionId: deps.sessionId,
+    recognizeOnly: true
+  });
+  if (mutation && filePath && event.isError !== true) {
+    noteAgentMutation(filePath, expectationFromToolInput(event.input, mutation.kind));
+  }
+  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.turnKey(deps.sessionId),
+      signal: getAmbientAbortSignal(),
+      record: (entry) => replayThroughMutationBridge({ ...entry, lineage: writeSession }),
+      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 = writeSession.guardedWrite(filePath, () => 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) {
+          if (writeSession.guardedWrite(observedPath, () => true) !== true)
+            continue;
+          const observedDispatchSignal = deps.signal;
+          const observedJoinSignal = deps.signal;
+          const observedStateHashForPath = getFileStateHash(observedPath);
+          const observedClaim = claimPipelineDispatch({
+            filePath: observedPath,
+            stateHash: observedStateHashForPath,
+            turnIndex: runtime.turnIndex,
+            authored: true,
+            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),
+            analysisRootMode,
+            autofixMode: observedAutofixMode,
+            modifiedRanges: undefined,
+            writeIndex: runtime.nextWriteIndex(),
+            writeOrderTurn: runtime.writeOrderTurn,
+            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,
+            sessionGeneration: writeSession,
+            ownFileTimeStamp: false
+          }), {
+            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],
+      structuredContent: event.structuredContent
+    } : undefined;
+  }
+  if (mutation === undefined) {
+    dbg(`tool_result: skipped turn tracking - toolName="${event.toolName}" is not a classified mutation`);
+    return syntheticWriteContent.length > 0 || readNote.length > 0 ? {
+      content: [...readNote, ...event.content, ...syntheticWriteContent],
+      structuredContent: event.structuredContent
+    } : undefined;
+  }
+  if (!filePath) {
+    dbg(`tool_result: skipped turn tracking - no filePath for toolName="${event.toolName}"`);
+    return;
+  }
+  if (analysisRootMode === "none") {
+    if (isOutsideProjectRoot(filePath, workspaceRoot) && !isVendorPath(filePath) && !isDmLensInternalPath(filePath, workspaceRoot)) {
+      const firstOutsideRootEdit = recordDegradationOnce({
+        kind: "tool-result-outside-project-root",
+        subject: workspaceRoot,
+        reason: `edit outside session root: ${filePath}`
+      });
+      if (firstOutsideRootEdit) {
+        queueAgentAdvisory(`dm-lens skipped analysis for the edit at ${filePath} because it is outside the session root. Start pi in that directory or add it to the workspace to get analysis.`, writeSession);
+      }
+    }
+    dbg(`tool_result: skipped pipeline - file outside project root or in node_modules: ${filePath}`);
+    return;
+  }
+  if (analysisRootMode === "adopted") {
+    const adoptedRoot = resolveAnalysisRootPath(filePath, workspaceRoot);
+    if (adoptedRoot) {
+      const firstAdoptedRoot = recordDegradationOnce({
+        kind: "tool-result-adopted-project",
+        subject: adoptedRoot,
+        reason: `analysing ${adoptedRoot} as a separate project`
+      });
+      if (firstAdoptedRoot) {
+        queueAgentAdvisory(`dm-lens is analysing ${adoptedRoot} as a separate project (LSP + global or managed php-lint/fish-indent; formatting, autofix, other dispatch runners, and automatic tests are off).`, writeSession);
+      }
+    }
+  }
+  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,
+      structuredContent: event.structuredContent
+    };
+  }
+  const postWriteStateHash = preSettleStateHash ?? getFileStateHash(filePath);
+  const nativeAppliedPairs = recordNativeAppliedPairs({
+    runtime,
+    input: event.input,
+    kind: mutation.kind,
+    filePath,
+    stateHash: postWriteStateHash
+  });
+  const ownEdit = attribution?.editInPlace ? singlePositionalEdit(event.input) : undefined;
+  const nativeAuthoredRanges = mutation.kind === "edit" && ownEdit ? (() => {
+    const evidence = ownEditEvidence(filePath, ownEdit);
+    return [
+      [ownEdit.start, ownEdit.start + evidence.lineCount - 1]
+    ];
+  })() : undefined;
+  if (ownEdit) {
+    const evidence = ownEditEvidence(filePath, ownEdit);
+    deps.readGuard?.recordRead({
+      filePath,
+      requestedOffset: ownEdit.start,
+      requestedLimit: evidence.lineCount,
+      effectiveOffset: ownEdit.start,
+      effectiveLimit: evidence.lineCount,
+      expandedByLsp: false,
+      ...evidence.lineHashes && { lineHashes: evidence.lineHashes },
+      turnIndex: runtime.turnIndex,
+      writeIndex: runtime.peekWriteIndex(),
+      timestamp: Date.now(),
+      source: "own-edit",
+      ...readEvidenceToolCallId !== undefined && {
+        toolCallId: readEvidenceToolCallId
+      }
+    }, { stampFileTime: false });
+    logConversationRead("own-edit", filePath, ownEdit.start, evidence);
+  }
+  const executedContent = event.input.content;
+  const ownWriteStamp = deps._ownWriteStamp ?? {
+    stampFileTime: attribution?.fileTimeStale !== true,
+    ...typeof executedContent === "string" && {
+      writtenContent: executedContent
+    },
+    ...toolCallId !== undefined && { toolCallId }
+  };
+  const receipt = runtime.recordMutationToolReceipt;
+  const autofixMode = deps._bypassDebounce ? deps._autofixMode ?? (mutation.kind === "edit" ? "deferred" : "immediate") : (receipt && writeSession.guardedWrite(filePath, () => 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,
+        _sessionGeneration: writeSession,
+        _autofixMode: autofixMode,
+        _ownWriteStamp: ownWriteStamp,
+        _telemetryParticipantIds: [readGuardCorrelationId],
+        _telemetryParticipantTotal: 1
+      });
+    }
+  }
+  if (bashAuthorshipConfirmed)
+    deps.readGuard?.recordWritten(filePath, {
+      authorship: mutation.kind === "write" ? "whole-file" : nativeAuthoredRanges !== undefined ? "partial" : "unknown",
+      ...nativeAuthoredRanges !== undefined && {
+        authoredRanges: nativeAuthoredRanges
+      },
+      ...ownWriteStamp,
+      contentHash: postWriteStateHash
+    });
+  refreshCachedExports(runtime, filePath);
+  const initialStateHash = postWriteStateHash;
+  const classifiedClients = ensureToolResultClients(deps);
+  const classifiedClientsReady = 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"
+  });
+  const classifiedClaim = claimPipelineDispatch({
+    filePath,
+    stateHash: initialStateHash,
+    turnIndex: runtime.turnIndex,
+    authored: bashAuthorshipConfirmed,
+    participantId: readGuardCorrelationId,
+    dbg
+  });
+  if (!classifiedClaim.proceed) {
+    if (classifiedClaim.joined) {
+      await classifiedClaim.joined;
+    }
+    return;
+  }
+  const entryLive = writeSession.guardedWrite(filePath, () => true) === true;
+  if (!getFlag("no-read-guard") && bashAuthorshipConfirmed) {
+    const readGuard = runtime.readGuard;
+    if (entryLive)
+      readGuard?.recordWritten?.(filePath, {
+        authorship: mutation.kind === "write" ? "whole-file" : nativeAuthoredRanges !== undefined ? "partial" : "unknown",
+        ...nativeAuthoredRanges !== undefined && {
+          authoredRanges: nativeAuthoredRanges
+        },
+        ...ownWriteStamp,
+        contentHash: postWriteStateHash
+      });
+    else
+      recordDroppedRead(writeSession, "tool-result", writeSession.branchEpoch);
+  }
+  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();
+  const writeOrderTurn = runtime.writeOrderTurn;
+  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;
+  const addTurnRange = (range, importsChanged) => {
+    if (entryLive)
+      cacheManager.addModifiedRange(filePath, range, importsChanged, turnStateCwd, deps.sessionId ?? runtime.telemetrySessionId, "pi", undefined, analysisRootMode);
+  };
+  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}`);
+        addTurnRange(range, importsChanged);
+      }
+      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)
+        addTurnRange(range, importsChanged);
+    } 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 }];
+      addTurnRange({ start: 1, end: lineCount }, importsChanged);
+    } 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 }];
+      addTurnRange({ start: 1, end: lineCount }, hasImports);
+    }
+  } catch (err) {
+    dbg(`turn state tracking error: ${err}`);
+    dbg(`turn state tracking error stack: ${err.stack}`);
+  }
+  recordProjectChange({
+    runtime,
+    cwd: turnStateCwd,
+    analysisRootMode,
+    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)`);
+  if (!classifiedClientsReady || !entryLive)
+    return;
+  const dispatchOutcome = await bounded(dispatchPipelineAnalysis({
+    deps,
+    runtime,
+    filePath,
+    dispatchCwd,
+    turnStateCwd,
+    analysisRootMode,
+    autofixMode,
+    modifiedRanges,
+    writeIndex,
+    writeOrderTurn,
+    initialStateHash,
+    readGuardCorrelationId,
+    requestedEditIndexes,
+    requestedEditTotal,
+    isPartialApplyResult,
+    participantIds,
+    participantTotal,
+    toolResultStart,
+    nativeAppliedPairs,
+    preserveNativeAuthorship: nativeAuthoredRanges !== undefined,
+    allowAutonomousWriters: bashAuthorshipConfirmed,
+    sessionGeneration: writeSession,
+    ownFileTimeStamp: ownWriteStamp.stampFileTime
+  }), {
+    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;
+  const resultLive = writeSession.guardedWrite(filePath, () => true) === true;
+  let autofixNewlyQueued = false;
+  if (resultLive && !result.isError && bashAuthorshipConfirmed && autofixMode === "deferred" && nodeFs.existsSync(filePath)) {
+    autofixNewlyQueued = runtime.deferMutation?.call(runtime, filePath, dispatchCwd, event.toolName, turnStateCwd, "autofix", deps.sessionId, resolutionBasis, undefined, analysisRootMode) ?? false;
+    dbg(`tool_result: queued deferred autofix for ${filePath}`);
+  }
+  let formatQueued = false;
+  if (resultLive && !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, analysisRootMode);
+    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) {
+      const identity = runtime.deferredFormatIdentity?.(filePath);
+      publishFormatQueued({
+        filePath,
+        cwd: dispatchCwd,
+        tool: mutation.kind,
+        dbg,
+        kinds: autofixMode === "deferred" ? ["autofix", "format"] : ["format"],
+        ...identity === undefined ? {} : {
+          ...identity.ownerSessionId === undefined ? {} : { ownerSessionId: identity.ownerSessionId },
+          turnIndex: identity.turnIndex,
+          batchId: identity.batchId
+        }
+      });
+    }
+  }
+  if (autofixNewlyQueued && !formatQueued) {
+    const identity = runtime.deferredFormatIdentity?.(filePath);
+    publishFormatQueued({
+      filePath,
+      cwd: dispatchCwd,
+      tool: mutation.kind,
+      kinds: ["autofix"],
+      ...identity === undefined ? {} : {
+        ...identity.ownerSessionId === undefined ? {} : { ownerSessionId: identity.ownerSessionId },
+        turnIndex: identity.turnIndex,
+        batchId: identity.batchId
+      },
+      dbg
+    });
+  }
+  for (const changedFile of result.changedFiles ?? []) {
+    const resolvedChanged = path.resolve(changedFile);
+    invalidateFormatterCacheForPath(resolvedChanged);
+    if (!nodeFs.existsSync(resolvedChanged))
+      continue;
+    recordProjectChange({
+      runtime,
+      cwd: turnStateCwd,
+      analysisRootMode,
+      filePath: resolvedChanged,
+      source: "autofix",
+      dbg
+    });
+    if (!resultLive)
+      continue;
+    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, deps.sessionId ?? runtime.telemetrySessionId, "pi", undefined, analysisRootMode);
+      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, writeSession, filePath, analysisRootMode);
+  }
+  const { actionableWarnings, codeQualityWarnings } = result;
+  if (actionableWarnings?.length) {
+    writeSession.guardedWrite(filePath, () => runtime.recordActionableWarnings(actionableWarnings, deps.sessionId));
+  }
+  if (codeQualityWarnings?.length) {
+    writeSession.guardedWrite(filePath, () => runtime.recordCodeQualityWarnings(codeQualityWarnings, deps.sessionId));
+  }
+  recordTurnSummary({
+    runtime,
+    filePath,
+    result,
+    getFlag,
+    resultLive,
+    analysisRootMode
+  });
+  let inlineVerdictApplied;
+  const { inlineBlockerSummary } = result;
+  if (inlineBlockerSummary) {
+    inlineVerdictApplied = writeSession.guardedWrite(filePath, () => runtime.recordInlineBlockers(filePath, inlineBlockerSummary, result.writeIndex ?? writeIndex, result.inlineBlockerSources, result.inlineBlockerLines, result.inlineBlockerFileContent, result.inlineBlockerDiagnostics, result.orderTurn ?? writeOrderTurn, result.analysisReadAtMs)) !== undefined;
+  } else {
+    inlineVerdictApplied = writeSession.guardedWrite(filePath, () => runtime.clearInlineBlockers(filePath, result.writeIndex ?? writeIndex, result.orderTurn ?? writeOrderTurn, {
+      authored: bashAuthorshipConfirmed,
+      sha256: result.inlineBlockerFileContent?.sha256
+    })) ?? false;
+  }
+  if (resultLive) {
+    runtime.updateGitGuardStatus(inlineVerdictApplied && result.hasBlockers, result.output);
+    if (getFlag("lens-guard")) {
+      syncGitGuardRecord(runtime, cacheManager, turnStateCwd, filePath, analysisRootMode);
+      if (result.isError && !result.hasBlockers) {
+        runtime.markGitGuardCacheUnknown("pipeline_error");
+      }
+    }
+  }
+  if (result.isError) {
+    return {
+      content: [...event.content, { type: "text", text: result.output }],
+      isError: true,
+      structuredContent: event.structuredContent
+    };
+  }
+  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);
+    if (attachAuthoritativeContent && !getFlag("no-read-guard")) {
+      const evidence = deliveredLineEvidence(postMutation.content, 1);
+      deps.readGuard?.recordRead({
+        filePath: postMutation.filePath,
+        requestedOffset: 1,
+        requestedLimit: evidence.lineCount,
+        effectiveOffset: 1,
+        effectiveLimit: evidence.lineCount,
+        expandedByLsp: false,
+        ...evidence.lineHashes && { lineHashes: evidence.lineHashes },
+        turnIndex: runtime.turnIndex,
+        writeIndex: runtime.peekWriteIndex(),
+        timestamp: Date.now(),
+        source: "autofix-attachment"
+      }, { stampFileTime: false });
+      logConversationRead("autofix-attachment", postMutation.filePath, 1, evidence);
+    }
+  }
+  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,
+    structuredContent: event.structuredContent
+  };
+}