@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -1,11 +1,15 @@
 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 {
+  noteAuthoritativeContentAttachment,
+  queueAgentAdvisory
+} from "./agent-nudge.js";
 import {
   captureFileStats,
   diffFileContent,
   getOpaqueBaselineStore,
+  opaqueBaselineSlot,
   recoverOpaqueChangesViaGit
 } from "./opaque-mutation-scan.js";
 import { normalizeMapKey } from "./path-utils.js";
@@ -20,16 +24,25 @@ import {
 import {
   registerSearchReads
 } from "./search-read-registration.js";
-import { createFileTime } from "./file-time.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";
@@ -38,6 +51,7 @@ 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 {
@@ -50,7 +64,10 @@ import {
   storedLineHashesFor
 } from "./observed-mutation-sources.js";
 import { getAmbientAbortSignal } from "./safe-spawn.js";
-import { resolveToolCallCorrelationId } from "./tool-event.js";
+import {
+  resolveReadEvidenceCorrelationId,
+  resolveToolCallCorrelationId
+} from "./tool-event.js";
 import {
   boundedIndexesForCount,
   createReadGuardEditBatchSummary,
@@ -61,15 +78,20 @@ import { countFileLines } from "./read-guard-tool-lines.js";
 import {
   notifyExternalFileChange,
   resyncGitChangedFiles
-} from "./lsp/index.js";
+} 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";
@@ -77,6 +99,11 @@ 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([
@@ -169,27 +196,31 @@ function parseDiffRanges(diff) {
 }
 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, stateHash, pipeline) {
+function registerInFlightPipeline(filePath, registryKey, pipeline) {
   let filePipelines = inFlightPipelines.get(filePath);
   if (!filePipelines) {
     filePipelines = new Map;
     inFlightPipelines.set(filePath, filePipelines);
   }
-  filePipelines.set(stateHash, pipeline);
+  filePipelines.set(registryKey, pipeline);
   return filePipelines;
 }
-function releaseInFlightPipeline(filePath, stateHash, registered) {
-  registered.delete(stateHash);
+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, participantId, dbg } = args;
-  const inFlight = inFlightPipelines.get(filePath)?.get(stateHash);
+  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) {
@@ -199,7 +230,7 @@ function claimPipelineDispatch(args) {
     return { proceed: false, joined: inFlight.promise };
   }
   const lastAnalyzed = lastAnalyzedStateByFile.get(filePath);
-  if (lastAnalyzed?.turnIndex === turnIndex && lastAnalyzed.stateHash === stateHash) {
+  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 };
   }
@@ -310,7 +341,9 @@ function sourceForMutation(classification, details) {
 function singleRange(ranges) {
   return ranges?.length === 1 ? ranges[0] : undefined;
 }
-function recordProjectChange(args) {
+export function recordProjectChange(args) {
+  if (!canWriteAnalysisRoot(args.analysisRootMode))
+    return;
   args.runtime.recordProjectMutation?.({
     filePath: args.filePath,
     source: args.source,
@@ -319,6 +352,40 @@ function recordProjectChange(args) {
     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")
@@ -364,9 +431,11 @@ async function dispatchPipelineAnalysis(args) {
     filePath,
     dispatchCwd,
     turnStateCwd,
+    analysisRootMode,
     autofixMode,
     modifiedRanges,
     writeIndex,
+    writeOrderTurn,
     initialStateHash,
     readGuardCorrelationId,
     requestedEditIndexes,
@@ -374,7 +443,10 @@ async function dispatchPipelineAnalysis(args) {
     isPartialApplyResult,
     toolResultStart,
     nativeAppliedPairs,
-    allowAutonomousWriters
+    allowAutonomousWriters,
+    sessionGeneration,
+    ownFileTimeStamp = true,
+    preserveNativeAuthorship = false
   } = args;
   const {
     event,
@@ -386,11 +458,13 @@ async function dispatchPipelineAnalysis(args) {
     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,
@@ -400,6 +474,7 @@ async function dispatchPipelineAnalysis(args) {
       sessionId: runtime.telemetrySessionId,
       turnIndex: runtime.turnIndex,
       writeIndex,
+      orderTurn: writeOrderTurn,
       modelId: runtime.telemetryModelId,
       provider: runtime.telemetryProviderId
     },
@@ -414,20 +489,28 @@ async function dispatchPipelineAnalysis(args) {
     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: runtime.fixedThisTurn
+    fixedThisTurn
   });
   const pipelineTelemetry = {
     promise: pipelinePromise,
     participantIds: [...new Set(args.participantIds)].slice(0, 100),
     participantTotal: args.participantTotal
   };
-  const registeredPipelines = registerInFlightPipeline(filePath, initialStateHash, pipelineTelemetry);
+  const registryKey = inFlightKey(initialStateHash, allowAutonomousWriters);
+  const registeredPipelines = registerInFlightPipeline(filePath, registryKey, pipelineTelemetry);
   let result;
   try {
     result = await pipelinePromise;
@@ -486,11 +569,12 @@ async function dispatchPipelineAnalysis(args) {
       crashed: true,
       response: {
         content: notice ? [...event.content, { type: "text", text: notice }] : event.content,
-        isError: true
+        isError: true,
+        structuredContent: event.structuredContent
       }
     };
   } finally {
-    releaseInFlightPipeline(filePath, initialStateHash, registeredPipelines);
+    releaseInFlightPipeline(filePath, registryKey, registeredPipelines);
   }
   if (!isPartialApplyResult) {
     const postEditStatus = result.isError ? "failed" : "succeeded";
@@ -532,10 +616,11 @@ async function dispatchPipelineAnalysis(args) {
   const pipelineOwnedWriteHash = result.fileModified ? result.postWriteStateHash : undefined;
   const finalStateHash = pipelineOwnedWriteHash ?? initialStateHash;
   if (!result.fileModified || pipelineOwnedWriteHash !== undefined) {
-    lastAnalyzedStateByFile.set(filePath, {
+    sessionGeneration.guardedWrite(filePath, () => lastAnalyzedStateByFile.set(filePath, {
       turnIndex: runtime.turnIndex,
-      stateHash: finalStateHash
-    });
+      stateHash: finalStateHash,
+      authored: allowAutonomousWriters
+    }));
   }
   if (pipelineOwnedWriteHash !== undefined) {
     for (const pair of nativeAppliedPairs) {
@@ -543,18 +628,77 @@ async function dispatchPipelineAnalysis(args) {
     }
   }
   if (!getFlag("no-read-guard") && allowAutonomousWriters) {
+    const ownPath = path.resolve(filePath);
     const changedForReadGuard = new Set([
-      path.resolve(filePath),
+      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);
+        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,
@@ -565,11 +709,34 @@ export async function handleToolResult(deps) {
     agentBehaviorRecord,
     formatBehaviorWarnings
   } = deps;
-  const rawFilePath = event.input.path;
+  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;
@@ -584,11 +751,15 @@ export async function handleToolResult(deps) {
       durationMs: 0,
       metadata: { toolCallId, rawFilePath, guessedPath }
     });
-    return;
+    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);
@@ -618,17 +789,14 @@ export async function handleToolResult(deps) {
     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 hadOpaqueRecovery = false;
     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}`);
+      const pending = getOpaqueBaselineStore().take(opaqueBaselineSlot(scanRoot, runtime.sessionGeneration), toolCallId);
       let unknownReason;
       if (!pending && recognized.length > 0) {
         unknownReason = "partial-recognition-no-baseline";
@@ -682,6 +850,7 @@ export async function handleToolResult(deps) {
         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)
@@ -717,11 +886,13 @@ export async function handleToolResult(deps) {
     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);
+        deps.readGuard?.recordWritten(wp, {
+          authorship: hadOpaqueRecovery || opaqueSet.has(wp) ? "unknown" : "whole-file",
+          stampFileTime: false,
+          ...toolCallId !== undefined && { toolCallId }
+        });
       const receipt = runtime.recordMutationToolReceipt;
-      const autofixMode = receipt ? receipt.call(runtime, wp, "write").autofixMode : "immediate";
+      const autofixMode = (receipt && writeSession.guardedWrite(wp, () => receipt.call(runtime, wp, "write"))?.autofixMode) ?? "immediate";
       const isOpaque = opaqueSet.has(wp);
       const syntheticEvent = {
         ...event,
@@ -738,7 +909,12 @@ export async function handleToolResult(deps) {
         _attachmentBudget: syntheticAttachmentBudget,
         _mutationSourceOverride: isOpaque ? "opaque-script" : undefined,
         _readGuardAuthorship: recognizedAuthoredSet.has(wp),
-        _allowAutonomousWriters: 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));
@@ -794,21 +970,25 @@ export async function handleToolResult(deps) {
           expandedByLsp: false,
           turnIndex: runtime.turnIndex,
           writeIndex: runtime.peekWriteIndex(),
-          timestamp: Date.now()
+          timestamp: Date.now(),
+          ...readEvidenceToolCallId !== undefined && {
+            toolCallId: readEvidenceToolCallId
+          }
         });
       }
     }
-    if (event.isError !== true && !getFlag("no-lsp") && !getFlag("no-read-guard")) {
+    const readGuard = deps.readGuard;
+    if (event.isError !== true && readGuard !== undefined && !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))
+        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;
-        deps.readGuard.forgetPath(dp);
+        readGuard.forgetPath(dp);
         notifyExternalFileChange(dp, 3).catch((err) => {
           dbg(`tool_result: external-delete notify failed for ${dp}: ${err}`);
         });
@@ -830,16 +1010,18 @@ export async function handleToolResult(deps) {
       registerSearchReads(deps.readGuard, searchReads, {
         projectRoot: workspaceRoot,
         turnIndex: runtime.turnIndex,
-        writeIndex: runtime.peekWriteIndex()
+        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 nativeReadToolCallId = resolveToolCallCorrelationId(event);
       const input = event.input;
-      const requestedOffset = input.offset ?? 1;
+      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);
@@ -868,23 +1050,50 @@ export async function handleToolResult(deps) {
             expandedByTs: false
           }
         });
-        const deliveredRecord = {
-          filePath: deliveredFilePath,
-          requestedOffset,
-          requestedLimit: requestedLimit ?? deliveredLimit,
+        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: deliveredLimit,
-          expandedByLsp: false,
-          turnIndex: runtime.turnIndex,
-          writeIndex: runtime.peekWriteIndex(),
-          timestamp: Date.now()
+          effectiveLimit: delivered?.lineCount ?? deliveredLimit,
+          lineHashes: delivered?.lineHashes
         };
-        if (nativeReadToolCallId) {
+        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, {
-            supersedes: { toolCallId: nativeReadToolCallId }
+            ...toolCallId && { supersedes: { toolCallId } },
+            stampFileTime: !raced
           });
-        } else {
-          deps.readGuard.recordRead(deliveredRecord);
         }
       }
     }
@@ -894,6 +1103,9 @@ export async function handleToolResult(deps) {
     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;
@@ -903,9 +1115,9 @@ export async function handleToolResult(deps) {
       toolCallId: resolveToolCallCorrelationId(event),
       toolName: event.toolName,
       sessionGeneration: runtime.sessionGeneration,
-      turnIndex: runtime.turnIndex,
+      turnIndex: runtime.turnKey(deps.sessionId),
       signal: getAmbientAbortSignal(),
-      record: replayThroughMutationBridge,
+      record: (entry) => replayThroughMutationBridge({ ...entry, lineage: writeSession }),
       getStoredLineHashes: (candidate) => storedLineHashesFor(deps.readGuard, candidate),
       isRecordable: (candidate) => !isExternalOrVendorFile(candidate, workspaceRoot) && !isPathIgnoredByProject(candidate, workspaceRoot, false),
       dbg
@@ -930,7 +1142,7 @@ export async function handleToolResult(deps) {
         filePath,
         stateHash: observedStateHash
       });
-      const receiptOutcome = runtime.recordMutationToolReceipt?.call(runtime, filePath, observedKind);
+      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) => {
@@ -959,6 +1171,8 @@ export async function handleToolResult(deps) {
           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);
@@ -966,6 +1180,7 @@ export async function handleToolResult(deps) {
             filePath: observedPath,
             stateHash: observedStateHashForPath,
             turnIndex: runtime.turnIndex,
+            authored: true,
             participantId: observedReadGuardCorrelationId,
             dbg
           });
@@ -986,9 +1201,11 @@ export async function handleToolResult(deps) {
             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),
@@ -998,7 +1215,9 @@ export async function handleToolResult(deps) {
             participantTotal: 1,
             toolResultStart,
             nativeAppliedPairs: observedAppliedPairs,
-            allowAutonomousWriters: true
+            allowAutonomousWriters: true,
+            sessionGeneration: writeSession,
+            ownFileTimeStamp: false
           }), {
             ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
             signal: observedDispatchSignal,
@@ -1015,20 +1234,49 @@ export async function handleToolResult(deps) {
         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;
+    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 ? { content: [...event.content, ...syntheticWriteContent] } : undefined;
+    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 (isExternalOrVendorFile(filePath, workspaceRoot)) {
+  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 ?? {};
@@ -1064,7 +1312,11 @@ export async function handleToolResult(deps) {
         })
       }
     });
-    return { content: event.content, isError: true };
+    return {
+      content: event.content,
+      isError: true,
+      structuredContent: event.structuredContent
+    };
   }
   const postWriteStateHash = preSettleStateHash ?? getFileStateHash(filePath);
   const nativeAppliedPairs = recordNativeAppliedPairs({
@@ -1074,27 +1326,79 @@ export async function handleToolResult(deps) {
     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 ? receipt.call(runtime, filePath, mutation.kind).autofixMode : mutation.kind === "edit" ? "deferred" : "immediate";
+  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);
+    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
   });
@@ -1104,11 +1408,20 @@ export async function handleToolResult(deps) {
     }
     return;
   }
-  const sessionFileTime = createFileTime("default");
-  sessionFileTime.read(filePath);
+  const entryLive = writeSession.guardedWrite(filePath, () => true) === true;
   if (!getFlag("no-read-guard") && bashAuthorshipConfirmed) {
     const readGuard = runtime.readGuard;
-    readGuard?.recordWritten?.(filePath);
+    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)) {
@@ -1119,8 +1432,13 @@ export async function handleToolResult(deps) {
   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(", ")}`);
@@ -1133,30 +1451,29 @@ export async function handleToolResult(deps) {
       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);
+        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) {
-        cacheManager.addModifiedRange(filePath, range, importsChanged, turnStateCwd, runtime.telemetrySessionId);
-      }
+      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 }];
-      cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, importsChanged, turnStateCwd, runtime.telemetrySessionId);
+      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 }];
-      cacheManager.addModifiedRange(filePath, { start: 1, end: lineCount }, hasImports, turnStateCwd, runtime.telemetrySessionId);
+      addTurnRange({ start: 1, end: lineCount }, hasImports);
     }
   } catch (err) {
     dbg(`turn state tracking error: ${err}`);
@@ -1165,6 +1482,7 @@ export async function handleToolResult(deps) {
   recordProjectChange({
     runtime,
     cwd: turnStateCwd,
+    analysisRootMode,
     filePath,
     source: deps._mutationSourceOverride ?? sourceForMutation(mutation, event.details),
     changedRange: singleRange(modifiedRanges),
@@ -1179,13 +1497,7 @@ export async function handleToolResult(deps) {
     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"
-  }))
+  if (!classifiedClientsReady || !entryLive)
     return;
   const dispatchOutcome = await bounded(dispatchPipelineAnalysis({
     deps,
@@ -1193,9 +1505,11 @@ export async function handleToolResult(deps) {
     filePath,
     dispatchCwd,
     turnStateCwd,
+    analysisRootMode,
     autofixMode,
     modifiedRanges,
     writeIndex,
+    writeOrderTurn,
     initialStateHash,
     readGuardCorrelationId,
     requestedEditIndexes,
@@ -1205,7 +1519,10 @@ export async function handleToolResult(deps) {
     participantTotal,
     toolResultStart,
     nativeAppliedPairs,
-    allowAutonomousWriters: bashAuthorshipConfirmed
+    preserveNativeAuthorship: nativeAuthoredRanges !== undefined,
+    allowAutonomousWriters: bashAuthorshipConfirmed,
+    sessionGeneration: writeSession,
+    ownFileTimeStamp: ownWriteStamp.stampFileTime
   }), {
     ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
     signal: deps.signal || undefined,
@@ -1218,14 +1535,15 @@ export async function handleToolResult(deps) {
     return dispatchOutcome.response;
   }
   const result = dispatchOutcome.result;
+  const resultLive = writeSession.guardedWrite(filePath, () => true) === true;
   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;
+  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 (!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);
+  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({
@@ -1237,21 +1555,33 @@ export async function handleToolResult(deps) {
       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"]
+        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
     });
   }
@@ -1263,10 +1593,13 @@ export async function handleToolResult(deps) {
     recordProjectChange({
       runtime,
       cwd: turnStateCwd,
+      analysisRootMode,
       filePath: resolvedChanged,
       source: "autofix",
       dbg
     });
+    if (!resultLive)
+      continue;
     if (pathsEqual(path.resolve(turnStateCwd, changedFile), path.resolve(filePath)))
       continue;
     try {
@@ -1274,65 +1607,54 @@ export async function handleToolResult(deps) {
       const lineCount = content.split(`
 `).length;
       const hasImports = /^import\s/m.test(content);
-      cacheManager.addModifiedRange(resolvedChanged, { start: 1, end: lineCount }, hasImports, turnStateCwd);
+      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);
+    runtime.appendCascadePromise(result.cascadePromise, writeSession, filePath, analysisRootMode);
   }
-  if (result.actionableWarnings?.length) {
-    runtime.recordActionableWarnings(result.actionableWarnings);
+  const { actionableWarnings, codeQualityWarnings } = result;
+  if (actionableWarnings?.length) {
+    writeSession.guardedWrite(filePath, () => runtime.recordActionableWarnings(actionableWarnings, deps.sessionId));
   }
-  if (result.codeQualityWarnings?.length) {
-    runtime.recordCodeQualityWarnings(result.codeQualityWarnings);
+  if (codeQualityWarnings?.length) {
+    writeSession.guardedWrite(filePath, () => runtime.recordCodeQualityWarnings(codeQualityWarnings, deps.sessionId));
   }
-  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);
+  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 {
-    runtime.clearInlineBlockers(filePath);
+    inlineVerdictApplied = writeSession.guardedWrite(filePath, () => runtime.clearInlineBlockers(filePath, result.writeIndex ?? writeIndex, result.orderTurn ?? writeOrderTurn, {
+      authored: bashAuthorshipConfirmed,
+      sha256: result.inlineBlockerFileContent?.sha256
+    })) ?? false;
   }
-  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 (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
+      isError: true,
+      structuredContent: event.structuredContent
     };
   }
   let output = result.output;
@@ -1379,6 +1701,23 @@ ${postMutation.content}` : "";
   }
   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) {
@@ -1389,6 +1728,7 @@ ${postMutation.content}` : "";
   if (!output && !result.postMutation)
     return;
   return {
-    content: output ? [...returnedContent, { type: "text", text: output }] : returnedContent
+    content: output ? [...returnedContent, { type: "text", text: output }] : returnedContent,
+    structuredContent: event.structuredContent
   };
 }