fix: [AI-450] auto-refresh stale files in edit and write tools instead of failing

When a file is modified externally (by a formatter, linter, or file watcher) between
a read and edit/write, the tools now auto-refresh the read timestamp and re-read the
file contents instead of throwing "modified since it was last read".

This prevents the agent from entering retry loops of hundreds of consecutive failures
when external processes modify files during editing sessions.

Changes:
- Add `FileTime.assertOrRefresh()` that returns `{ stale: boolean }` instead of throwing
- Update `EditTool` and `WriteTool` to use `assertOrRefresh()` and re-read file contents
- Update test to verify auto-refresh behavior
- Original `FileTime.assert()` preserved for backward compatibility

Closes #450

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: anandgupta42

packages/opencode/src/file/time.ts

@@ -68,4 +68,36 @@ export namespace FileTime {
       )
     }
   }
+
+  /**
+   * Check if a file has been modified since last read. Instead of throwing,
+   * returns whether the file was stale and auto-refreshes the read timestamp
+   * so the caller can re-read contents and proceed.
+   *
+   * Returns:
+   * - { stale: false } if file is up-to-date
+   * - { stale: true } if file was modified externally (timestamp refreshed)
+   *
+   * Still throws if the file was never read in this session.
+   */
+  // altimate_change start — auto-refresh stale files instead of throwing (#450)
+  export async function assertOrRefresh(
+    sessionID: string,
+    filepath: string,
+  ): Promise<{ stale: boolean }> {
+    if (Flag.OPENCODE_DISABLE_FILETIME_CHECK === true) {
+      return { stale: false }
+    }
+
+    const time = get(sessionID, filepath)
+    if (!time) throw new Error(`You must read file ${filepath} before overwriting it. Use the Read tool first`)
+    const mtime = Filesystem.stat(filepath)?.mtime
+    if (mtime && mtime.getTime() > time.getTime() + 50) {
+      log.info("stale file detected, auto-refreshing", { sessionID, filepath })
+      read(sessionID, filepath)
+      return { stale: true }
+    }
+    return { stale: false }
+  }
+  // altimate_change end
 }

packages/opencode/src/tool/edit.ts

@@ -86,7 +86,9 @@ export const EditTool = Tool.define("edit", {
       const stats = Filesystem.stat(filePath)
       if (!stats) throw new Error(`File ${filePath} not found`)
       if (stats.isDirectory()) throw new Error(`Path is a directory, not a file: ${filePath}`)
-      await FileTime.assert(ctx.sessionID, filePath)
+      // altimate_change start — auto-refresh stale files instead of failing (#450)
+      const { stale } = await FileTime.assertOrRefresh(ctx.sessionID, filePath)
+      // altimate_change end
       contentOld = await Filesystem.readText(filePath)
 
       const ending = detectLineEnding(contentOld)

packages/opencode/src/tool/write.ts

@@ -28,8 +28,10 @@ export const WriteTool = Tool.define("write", {
     await assertSensitiveWrite(ctx, filepath)
 
     const exists = await Filesystem.exists(filepath)
+    // altimate_change start — auto-refresh stale files instead of failing (#450)
+    if (exists) await FileTime.assertOrRefresh(ctx.sessionID, filepath)
+    // altimate_change end
     const contentOld = exists ? await Filesystem.readText(filepath) : ""
-    if (exists) await FileTime.assert(ctx.sessionID, filepath)
 
     const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, params.content))
     await ctx.ask({

packages/opencode/test/tool/edit.test.ts

@@ -226,7 +226,8 @@ describe("tool.edit", () => {
       })
     })
 
-    test("throws error when file has been modified since read", async () => {
+    // altimate_change start — edit now auto-refreshes stale files instead of throwing (#450)
+    test("succeeds when file has been modified since read by auto-refreshing", async () => {
       await using tmp = await tmpdir()
       const filepath = path.join(tmp.path, "file.txt")
       await fs.writeFile(filepath, "original content", "utf-8")
@@ -243,21 +244,23 @@ describe("tool.edit", () => {
           // Simulate external modification
           await fs.writeFile(filepath, "modified externally", "utf-8")
 
-          // Try to edit with the new content
+          // Edit should succeed — auto-refreshes the stale read timestamp
           const edit = await EditTool.init()
-          await expect(
-            edit.execute(
-              {
-                filePath: filepath,
-                oldString: "modified externally",
-                newString: "edited",
-              },
-              ctx,
-            ),
-          ).rejects.toThrow("modified since it was last read")
+          const result = await edit.execute(
+            {
+              filePath: filepath,
+              oldString: "modified externally",
+              newString: "edited",
+            },
+            ctx,
+          )
+          expect(result.output).toContain("Edit applied successfully")
+          const content = await fs.readFile(filepath, "utf-8")
+          expect(content).toBe("edited")
         },
       })
     })
+    // altimate_change end
 
     test("replaces all occurrences with replaceAll option", async () => {
       await using tmp = await tmpdir()