@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -4,11 +4,12 @@ import * as path from "node:path";
 import { noteAuthoritativeContentAttachment } from "./agent-nudge.js";
 import {
   captureFileStats,
-  diffFileStats,
+  diffFileContent,
   getOpaqueBaselineStore,
   recoverOpaqueChangesViaGit
 } from "./opaque-mutation-scan.js";
 import { normalizeMapKey } from "./path-utils.js";
+import { detectFileKind } from "./file-kinds.js";
 import {
   extractReadPathsFromCommand,
   extractDeletedPathsFromCommand,
@@ -56,7 +57,11 @@ import {
   getReadGuardCorrelationId,
   logReadGuardEvent
 } from "./read-guard-logger.js";
-import { notifyExternalFileChange } from "./lsp/index.js";
+import { countFileLines } from "./read-guard-tool-lines.js";
+import {
+  notifyExternalFileChange,
+  resyncGitChangedFiles
+} from "./lsp/index.js";
 import { runPipeline } from "./pipeline.js";
 import {
   renderPostAutofixNotice
@@ -65,7 +70,15 @@ import { syncGitGuardRecord } from "./git-guard.js";
 import { scheduleWordIndexPersist } from "./word-index.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { getActiveSessionId } from "./session-lifecycle.js";
+import { requestBootstrapClients } from "./bootstrap.js";
+import { bounded } from "./deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
+import {
+  incrementDegradationCount,
+  recordDegradationOnce
+} from "./degradation-ledger.js";
 const AUTHORITATIVE_CONTENT_MAX_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
+const OBSERVED_DISPATCH_MAX_PATHS = 32;
 const GIT_INTEGRATION_SUBCOMMANDS = new Set([
   "merge",
   "rebase",
@@ -104,6 +117,29 @@ export function isFailedGitIntegrationCommand(command, isError) {
     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(`
@@ -136,7 +172,7 @@ const lastAnalyzedStateByFile = new PathKeyedMap(normalizeEphemeralMapKey);
 export function clearLastAnalyzedStateCache() {
   lastAnalyzedStateByFile.clear();
 }
-export function registerInFlightPipeline(filePath, stateHash, pipeline) {
+function registerInFlightPipeline(filePath, stateHash, pipeline) {
   let filePipelines = inFlightPipelines.get(filePath);
   if (!filePipelines) {
     filePipelines = new Map;
@@ -145,13 +181,13 @@ export function registerInFlightPipeline(filePath, stateHash, pipeline) {
   filePipelines.set(stateHash, pipeline);
   return filePipelines;
 }
-export function releaseInFlightPipeline(filePath, stateHash, registered) {
+function releaseInFlightPipeline(filePath, stateHash, registered) {
   registered.delete(stateHash);
   if (registered.size === 0 && inFlightPipelines.get(filePath) === registered) {
     inFlightPipelines.delete(filePath);
   }
 }
-export function claimPipelineDispatch(args) {
+function claimPipelineDispatch(args) {
   const { filePath, stateHash, turnIndex, participantId, dbg } = args;
   const inFlight = inFlightPipelines.get(filePath)?.get(stateHash);
   if (inFlight) {
@@ -337,7 +373,8 @@ async function dispatchPipelineAnalysis(args) {
     requestedEditTotal,
     isPartialApplyResult,
     toolResultStart,
-    nativeAppliedPairs
+    nativeAppliedPairs,
+    allowAutonomousWriters
   } = args;
   const {
     event,
@@ -350,11 +387,13 @@ async function dispatchPipelineAnalysis(args) {
     resetLSPService
   } = deps;
   const pipelinePromise = runPipeline({
+    signal: deps.signal,
     filePath,
     cwd: dispatchCwd,
     projectRoot: turnStateCwd,
     toolName: event.toolName,
     autofixMode,
+    allowAutonomousWriters,
     modifiedRanges,
     telemetry: {
       model: runtime.telemetryModel,
@@ -490,17 +529,20 @@ async function dispatchPipelineAnalysis(args) {
       }
     });
   }
-  const finalStateHash = getFileStateHash(filePath);
-  lastAnalyzedStateByFile.set(filePath, {
-    turnIndex: runtime.turnIndex,
-    stateHash: finalStateHash
-  });
-  if (finalStateHash !== initialStateHash) {
+  const pipelineOwnedWriteHash = result.fileModified ? result.postWriteStateHash : undefined;
+  const finalStateHash = pipelineOwnedWriteHash ?? initialStateHash;
+  if (!result.fileModified || pipelineOwnedWriteHash !== undefined) {
+    lastAnalyzedStateByFile.set(filePath, {
+      turnIndex: runtime.turnIndex,
+      stateHash: finalStateHash
+    });
+  }
+  if (pipelineOwnedWriteHash !== undefined) {
     for (const pair of nativeAppliedPairs) {
       runtime.partialApplyRecords.noteAfterWriteHash(filePath, pair.oldText, pair.newText, finalStateHash);
     }
   }
-  if (!getFlag("no-read-guard")) {
+  if (!getFlag("no-read-guard") && allowAutonomousWriters) {
     const changedForReadGuard = new Set([
       path.resolve(filePath),
       ...(result.changedFiles ?? []).map((changedFile) => path.resolve(changedFile))
@@ -525,6 +567,7 @@ export async function handleToolResult(deps) {
   } = deps;
   const rawFilePath = event.input.path;
   const workspaceRoot = runtime.projectRoot || process.cwd();
+  let bashAuthorshipConfirmed = deps._allowAutonomousWriters ?? deps._readGuardAuthorship ?? event.toolName !== "bash";
   const toolCallId = resolveToolCallCorrelationId(event);
   const attribution = toolCallId !== undefined ? runtime.takeToolCallAttribution(toolCallId) : undefined;
   let resolutionBasis;
@@ -574,8 +617,14 @@ export async function handleToolResult(deps) {
   if (event.toolName === "bash" && typeof event.input.command === "string") {
     const command = event.input.command;
     const recognized = extractWrittenPathsFromCommand(command, workspaceRoot);
-    const recognizedWritten = event.isError !== true ? recognized.filter((wp) => !isExternalOrVendorFile(wp, workspaceRoot) && !isPathIgnoredByProject(wp, workspaceRoot, false)) : [];
+    let recognizedWritten = event.isError !== true ? recognized.filter((wp) => !isExternalOrVendorFile(wp, workspaceRoot) && !isPathIgnoredByProject(wp, workspaceRoot, false)) : [];
+    if (!getFlag("no-read-guard")) {
+      for (const recognizedPath of recognizedWritten)
+        deps.readGuard?.recordUnchanged?.(recognizedPath);
+    }
     let opaquePaths = [];
+    let observedChangedKeys;
+    let recognizedAuthored = [];
     if (workspaceRoot && !getFlag("no-read-guard")) {
       const scanRoot = workspaceRoot;
       const started = Date.now();
@@ -591,8 +640,11 @@ export async function handleToolResult(deps) {
         });
         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({
@@ -614,10 +666,12 @@ export async function handleToolResult(deps) {
         }
       } else if (pending.stats) {
         const outcome = await captureFileStats(scanRoot, {
-          withHashes: true
+          withHashes: true,
+          ...deps._opaqueCaptureOptions
         });
         if (outcome.snapshot && !outcome.unknownReason) {
-          opaquePaths = diffFileStats(pending.stats, outcome.snapshot);
+          opaquePaths = diffFileContent(pending.stats, outcome.snapshot);
+          observedChangedKeys = new Set(opaquePaths);
         } else {
           unknownReason = outcome.unknownReason ?? pending.statsUnknownReason ?? "walk-failed";
         }
@@ -628,6 +682,13 @@ export async function handleToolResult(deps) {
         const survivingKeys = new Set(recognizedWritten.map((p) => normalizeMapKey(path.resolve(p))));
         opaquePaths = opaquePaths.filter((p) => !survivingKeys.has(p));
       }
+      if (observedChangedKeys) {
+        recognizedAuthored = recognizedWritten.filter((file) => observedChangedKeys.has(normalizeMapKey(path.resolve(file))));
+        if (recognizedAuthored.length === 0)
+          recognizedWritten = [];
+      } else if (unknownReason) {
+        recognizedAuthored = [];
+      }
       if (unknownReason) {
         logLatency({
           type: "phase",
@@ -645,13 +706,20 @@ export async function handleToolResult(deps) {
           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"))
+      if (!getFlag("no-read-guard") && recognizedAuthoredSet.has(wp))
         deps.readGuard?.recordWritten(wp);
+      else if (!getFlag("no-read-guard") && recognizedWritten.includes(wp))
+        deps.readGuard?.recordUnchanged?.(wp);
       const receipt = runtime.recordMutationToolReceipt;
       const autofixMode = receipt ? receipt.call(runtime, wp, "write").autofixMode : "immediate";
       const isOpaque = opaqueSet.has(wp);
@@ -668,14 +736,51 @@ export async function handleToolResult(deps) {
         _bypassDebounce: true,
         _autofixMode: autofixMode,
         _attachmentBudget: syntheticAttachmentBudget,
-        _mutationSourceOverride: isOpaque ? "opaque-script" : undefined
+        _mutationSourceOverride: isOpaque ? "opaque-script" : undefined,
+        _readGuardAuthorship: recognizedAuthoredSet.has(wp),
+        _allowAutonomousWriters: recognizedAuthoredSet.has(wp)
       });
       if (syntheticResult) {
         syntheticWriteContent.push(...syntheticResult.content.slice(event.content.length));
       }
     }
     if (event.isError !== true && !getFlag("no-read-guard")) {
-      for (const span of extractReadPathsFromCommand(command, workspaceRoot)) {
+      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))
@@ -729,6 +834,61 @@ export async function handleToolResult(deps) {
       });
     }
   }
+  if (deps.readGuard && event.toolName === "read" && event.isError !== true && filePath && !getFlag("no-read-guard") && !isExternalOrVendorFile(filePath, workspaceRoot)) {
+    const deliveredFilePath = attribution?.resolvedPath && nodeFs.existsSync(attribution.resolvedPath) ? attribution.resolvedPath : filePath;
+    if (nodeFs.existsSync(deliveredFilePath)) {
+      const nativeReadToolCallId = resolveToolCallCorrelationId(event);
+      const input = event.input;
+      const requestedOffset = input.offset ?? 1;
+      const requestedLimit = input.limit;
+      const truncation = event.details?.truncation;
+      const available = Math.max(0, countFileLines(deliveredFilePath) - requestedOffset + 1);
+      const deliveredLimit = Math.min(available, truncation?.outputLines ?? requestedLimit ?? available);
+      if (deliveredLimit > 0) {
+        if (truncation?.truncated === true && deliveredLimit < available) {
+          recordDegradationOnce({
+            kind: "native-read-clipped",
+            subject: deliveredFilePath,
+            reason: "native read result was clipped before delivery"
+          });
+        }
+        logReadGuardEvent({
+          event: "read_pattern",
+          sessionId: runtime.telemetrySessionId,
+          filePath: deliveredFilePath,
+          requestedOffset,
+          requestedLimit: requestedLimit ?? deliveredLimit,
+          effectiveOffset: requestedOffset,
+          effectiveLimit: deliveredLimit,
+          metadata: {
+            totalLines: countFileLines(deliveredFilePath),
+            isPartial: deliveredLimit < available,
+            fileKind: detectFileKind(deliveredFilePath) ?? "unknown",
+            fractionRead: available > 0 ? Math.round(deliveredLimit / available * 100) / 100 : 1,
+            expandedByTs: false
+          }
+        });
+        const deliveredRecord = {
+          filePath: deliveredFilePath,
+          requestedOffset,
+          requestedLimit: requestedLimit ?? deliveredLimit,
+          effectiveOffset: requestedOffset,
+          effectiveLimit: deliveredLimit,
+          expandedByLsp: false,
+          turnIndex: runtime.turnIndex,
+          writeIndex: runtime.peekWriteIndex(),
+          timestamp: Date.now()
+        };
+        if (nativeReadToolCallId) {
+          deps.readGuard.recordRead(deliveredRecord, {
+            supersedes: { toolCallId: nativeReadToolCallId }
+          });
+        } else {
+          deps.readGuard.recordRead(deliveredRecord);
+        }
+      }
+    }
+  }
   const mutation = classifyMutatingTool(event, {
     filePath: filePath || undefined,
     sessionId: deps.sessionId,
@@ -773,47 +933,86 @@ export async function handleToolResult(deps) {
       const receiptOutcome = runtime.recordMutationToolReceipt?.call(runtime, filePath, observedKind);
       refreshCachedExports(runtime, filePath);
       const observedAutofixMode = receiptOutcome?.autofixMode ?? (observedKind === "edit" ? "deferred" : "immediate");
-      if (observedChangedPaths.some((candidate) => pathsEqual(candidate, filePath))) {
-        const observedReadGuardCorrelationId = getReadGuardCorrelationId(event);
-        const observedClaim = claimPipelineDispatch({
-          filePath,
-          stateHash: observedStateHash,
-          turnIndex: runtime.turnIndex,
-          participantId: observedReadGuardCorrelationId,
-          dbg
-        });
-        if (!observedClaim.proceed) {
-          if (observedClaim.joined) {
-            await observedClaim.joined;
-          }
-          return syntheticWriteContent.length > 0 ? { content: [...event.content, ...syntheticWriteContent] } : undefined;
+      const observedDispatchPaths = observedChangedPaths.filter((candidate) => {
+        try {
+          return !nodeFs.statSync(candidate).isDirectory();
+        } catch {
+          return false;
         }
-        const observedDispatchOutcome = await dispatchPipelineAnalysis({
-          deps,
-          runtime,
-          filePath,
-          dispatchCwd: resolveLanguageRootForFile(filePath, workspaceRoot),
-          turnStateCwd: path.resolve(workspaceRoot),
-          autofixMode: observedAutofixMode,
-          modifiedRanges: undefined,
-          writeIndex: runtime.nextWriteIndex(),
-          initialStateHash: observedStateHash,
-          readGuardCorrelationId: observedReadGuardCorrelationId,
-          requestedEditIndexes: getRequestedEditIndexes(event, observedKind),
-          requestedEditTotal: getRequestedEditCount(event, observedKind),
-          isPartialApplyResult: (event.details ?? {}).piLensPartialApply === true,
-          participantIds: [observedReadGuardCorrelationId],
-          participantTotal: 1,
-          toolResultStart,
-          nativeAppliedPairs: observedAppliedPairs
+      }).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 (observedDispatchOutcome.crashed) {
-          dbg(`tool_result: pipeline analysis crashed for the observed mutation on ${filePath}; the recorded edit stands, analysis did not run this turn`);
-          return observedDispatchOutcome.response;
+      }
+      if (observedDispatchPaths.length > 0) {
+        const observedClients = ensureToolResultClients(deps);
+        if (observedClients !== true && !await bounded(Promise.resolve(observedClients), {
+          ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+          signal: deps.signal ?? undefined,
+          hook: "tool_result_edit",
+          label: "observed-tool-result-analysis"
+        }))
+          return;
+        const observedReadGuardCorrelationId = getReadGuardCorrelationId(event);
+        for (const observedPath of observedDispatchPaths) {
+          const observedDispatchSignal = deps.signal;
+          const observedJoinSignal = deps.signal;
+          const observedStateHashForPath = getFileStateHash(observedPath);
+          const observedClaim = claimPipelineDispatch({
+            filePath: observedPath,
+            stateHash: observedStateHashForPath,
+            turnIndex: runtime.turnIndex,
+            participantId: observedReadGuardCorrelationId,
+            dbg
+          });
+          if (!observedClaim.proceed) {
+            if (observedClaim.joined) {
+              await bounded(observedClaim.joined, {
+                ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+                signal: observedJoinSignal,
+                hook: "tool_result_edit",
+                label: "observed-tool-result-join"
+              });
+            }
+            continue;
+          }
+          const observedDispatchOutcome = await bounded(dispatchPipelineAnalysis({
+            deps,
+            runtime,
+            filePath: observedPath,
+            dispatchCwd: resolveLanguageRootForFile(observedPath, workspaceRoot),
+            turnStateCwd: path.resolve(workspaceRoot),
+            autofixMode: observedAutofixMode,
+            modifiedRanges: undefined,
+            writeIndex: runtime.nextWriteIndex(),
+            initialStateHash: observedStateHashForPath,
+            readGuardCorrelationId: observedReadGuardCorrelationId,
+            requestedEditIndexes: getRequestedEditIndexes(event, observedKind),
+            requestedEditTotal: getRequestedEditCount(event, observedKind),
+            isPartialApplyResult: (event.details ?? {}).piLensPartialApply === true,
+            participantIds: [observedReadGuardCorrelationId],
+            participantTotal: 1,
+            toolResultStart,
+            nativeAppliedPairs: observedAppliedPairs,
+            allowAutonomousWriters: true
+          }), {
+            ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+            signal: observedDispatchSignal,
+            hook: "tool_result_edit",
+            label: "observed-tool-result-analysis"
+          });
+          if (observedDispatchOutcome?.crashed) {
+            dbg(`tool_result: pipeline analysis crashed for the observed mutation on ${observedPath}; the recorded edit stands, analysis did not run this turn`);
+            return observedDispatchOutcome.response;
+          }
         }
         dbg(`tool_result: the observational settle already recorded ${observedReplayed} mutation(s) for "${event.toolName}"; kept the applied-edit records, mutation receipt, cachedExports refresh, and ran the pipeline dispatch (#2464); skipped the bridge-covered staleness stamp / turn-state ranges / change-log receipt / deferred autofix+format`);
       } else {
-        dbg(`tool_result: the observational settle recorded ${observedReplayed} mutation(s) for "${event.toolName}", none of them ${filePath} — nothing to analyse under the named path`);
+        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;
@@ -888,7 +1087,8 @@ export async function handleToolResult(deps) {
       });
     }
   }
-  deps.readGuard?.recordWritten(filePath);
+  if (bashAuthorshipConfirmed)
+    deps.readGuard?.recordWritten(filePath);
   refreshCachedExports(runtime, filePath);
   const initialStateHash = postWriteStateHash;
   const classifiedClaim = claimPipelineDispatch({
@@ -906,7 +1106,7 @@ export async function handleToolResult(deps) {
   }
   const sessionFileTime = createFileTime("default");
   sessionFileTime.read(filePath);
-  if (!getFlag("no-read-guard")) {
+  if (!getFlag("no-read-guard") && bashAuthorshipConfirmed) {
     const readGuard = runtime.readGuard;
     readGuard?.recordWritten?.(filePath);
   }
@@ -979,7 +1179,15 @@ export async function handleToolResult(deps) {
     durationMs: turnStateMs
   });
   dbg(`tool_result fired for: ${filePath} (turn_state: ${turnStateMs}ms)`);
-  const dispatchOutcome = await dispatchPipelineAnalysis({
+  const classifiedClients = ensureToolResultClients(deps);
+  if (classifiedClients !== true && !await bounded(Promise.resolve(classifiedClients), {
+    ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    signal: deps.signal,
+    hook: "tool_result_edit",
+    label: "classified-tool-result-analysis"
+  }))
+    return;
+  const dispatchOutcome = await bounded(dispatchPipelineAnalysis({
     deps,
     runtime,
     filePath,
@@ -996,19 +1204,27 @@ export async function handleToolResult(deps) {
     participantIds,
     participantTotal,
     toolResultStart,
-    nativeAppliedPairs
+    nativeAppliedPairs,
+    allowAutonomousWriters: bashAuthorshipConfirmed
+  }), {
+    ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+    signal: deps.signal || undefined,
+    hook: "tool_result_edit",
+    label: "pipeline-analysis"
   });
+  if (!dispatchOutcome)
+    return;
   if (dispatchOutcome.crashed) {
     return dispatchOutcome.response;
   }
   const result = dispatchOutcome.result;
   let autofixNewlyQueued = false;
-  if (!result.isError && autofixMode === "deferred" && nodeFs.existsSync(filePath)) {
+  if (!result.isError && bashAuthorshipConfirmed && autofixMode === "deferred" && nodeFs.existsSync(filePath)) {
     autofixNewlyQueued = runtime.deferMutation?.call(runtime, filePath, dispatchCwd, event.toolName, turnStateCwd, "autofix", deps.sessionId, resolutionBasis) ?? false;
     dbg(`tool_result: queued deferred autofix for ${filePath}`);
   }
   let formatQueued = false;
-  if (!result.isError && !getFlag("no-autoformat", filePath) && (autofixMode === "deferred" || !getFlag("immediate-format")) && nodeFs.existsSync(filePath)) {
+  if (!result.isError && bashAuthorshipConfirmed && !getFlag("no-autoformat", filePath) && (autofixMode === "deferred" || !getFlag("immediate-format")) && nodeFs.existsSync(filePath)) {
     const isNewlyQueued = runtime.deferFormat(filePath, dispatchCwd, event.toolName, turnStateCwd, deps.sessionId, resolutionBasis);
     formatQueued = true;
     dbg(`tool_result: queued deferred format for ${filePath}`);
@@ -1051,7 +1267,7 @@ export async function handleToolResult(deps) {
       source: "autofix",
       dbg
     });
-    if (resolvedChanged === path.resolve(filePath))
+    if (pathsEqual(path.resolve(turnStateCwd, changedFile), path.resolve(filePath)))
       continue;
     try {
       const content = nodeFs.readFileSync(resolvedChanged, "utf-8");
@@ -1102,7 +1318,7 @@ export async function handleToolResult(deps) {
     }
   }
   if (result.inlineBlockerSummary) {
-    runtime.recordInlineBlockers(filePath, result.inlineBlockerSummary, writeIndex, result.inlineBlockerSources, result.inlineBlockerLines);
+    runtime.recordInlineBlockers(filePath, result.inlineBlockerSummary, writeIndex, result.inlineBlockerSources, result.inlineBlockerLines, result.inlineBlockerFileContent, result.inlineBlockerDiagnostics);
   } else {
     runtime.clearInlineBlockers(filePath);
   }