Reverting a message restores the whole worktree and discards other sessions' uncommitted changes #54026

Activity

1. github-actions

   assigned

   nexxeln

   on Oct 8, 2026
2. opencode-agent commented on Oct 8, 2026

   

   opencode-agentBot

   on Oct 8, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report. I was able to reproduce this on 2.0.23, and it still happens on the latest v2 (b5c43a44).

   What I ran (script below):

   1. A session runs a step that only calls a read-only shell command (ls).
   2. While that step is running, something else (here a separate writer standing in for your Session A) changes a tracked file and creates a new file in the same worktree.
   3. Reverting the message through POST /session/:id/revert/stage, with no files (the same call the web UI makes), puts the edited file back to its old content and deletes the new file, with no warning.

   The revert isn't restoring the whole worktree. It only restores the files recorded for each step. The problem is that this file list comes from comparing snapshots of the whole worktree taken at the start and end of the step, so anything another session changed during that step gets counted as this session's change and is then rolled back.

   Related issues:

   • v2: redesign filesystem snapshots around mutation epochs #44511: the v2 snapshot redesign, which names this exact cause (changes from another session during a step being attributed to the assistant and overwritten by revert)
   • Undo in one session reverts all sessions #33940: the same symptom reported on v1
   • Session snapshot "restore/revert" bulk-overwrites the whole worktree with a stale baseline tree that is never rotated #49732, /undo destroyed 227 files, /restore destroyed 15,232 files. Several HUNDREDS OF THOUSANDS OF DOLLARS OF DAMAGE #53560, Snapshot restore from a subdirectory can overwrite sibling files #39513: other cases of snapshot restore overwriting files a session never touched

   Until this is fixed, the safest option is not to revert in one session while another session is editing the same worktree, or to give each session its own git worktree.

   Reproduction script (drive.ts)

   // Repro for #54026: reverting a message in session B rolls back edits that
   // another session (or any writer) made to the shared worktree while B's step ran.
   import { Effect } from "effect"
   import * as fs from "node:fs"
   import * as path from "node:path"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       project: {
         git: true,
         files: {
           "a.txt": "session A original\n",
           "untouched.txt": "never changed\n",
         },
       },
       // Drive disables snapshots by default; OpenCode enables them by default.
       config: { snapshots: true } as any,
       tools: ["shell"],
       tui: { recording: true },
     },
     ({ ui, llm, tools, opencode, artifacts }) =>
       Effect.gen(function* () {
         const dir = path.join(artifacts, "files")
         const shells = yield* tools.control("shell")
   
         // Session B: a step that only runs a read-only shell command.
         yield* llm.queue(
           Llm.toolCall({ index: 0, id: "call_ls", name: "shell", input: { command: "ls", description: "list" } }),
           Llm.finish("tool-calls"),
         )
         yield* llm.queue(Llm.text("Done listing files."))
         yield* ui.submit("list the files (sent by mistake)")
         const shell = yield* shells.take("call_ls")
   
         // Meanwhile "session A" edits a tracked file and creates a new one.
         fs.writeFileSync(path.join(dir, "a.txt"), "session A EDITED (uncommitted work)\n")
         fs.writeFileSync(path.join(dir, "a.test.ts"), "// new test written by session A\n")
         yield* Effect.log("before step end: a.txt=" + JSON.stringify(fs.readFileSync(path.join(dir, "a.txt"), "utf8")))
   
         yield* shell.succeed({ output: "a.txt\nuntouched.txt\n", exit: 0 })
         yield* ui.waitFor("Done listing files.")
         yield* Effect.sleep(1000)
   
         const sessions: any = yield* opencode.session.list()
         const session = (sessions.items ?? sessions.data ?? sessions)[0]
         const messages: any = yield* opencode.message.list({ sessionID: session.id } as any)
         const list: any[] = messages.items ?? messages.data ?? messages
         for (const m of list) yield* Effect.log(`msg ${m.id} ${m.type} snapshot=${JSON.stringify(m.snapshot)}`)
         const user = list.find((m) => m.type === "user")
   
         yield* Effect.log(`before revert: a.txt=${JSON.stringify(fs.readFileSync(path.join(dir, "a.txt"), "utf8"))} a.test.ts exists=${fs.existsSync(path.join(dir, "a.test.ts"))}`)
         // Same call the web UI makes: stage a revert of the mistaken message, no `files` flag.
         const revert = yield* opencode.session.revert.stage({ sessionID: session.id, messageID: user.id } as any)
         yield* Effect.log("revert staged: " + JSON.stringify(revert))
         yield* Effect.sleep(1500)
         const after = fs.readFileSync(path.join(dir, "a.txt"), "utf8")
         const exists = fs.existsSync(path.join(dir, "a.test.ts"))
         yield* Effect.log(`AFTER revert: a.txt=${JSON.stringify(after)} a.test.ts exists=${exists}`)
         yield* ui.screenshot("after-revert")
         yield* Effect.log(after.includes("EDITED") && exists ? "RESULT: other session's work preserved" : "RESULT: BUG - other session's work discarded")
       }),
   )

   Run it with opencode-drive: opencode-drive run ./drive.ts. It drives opencode from your PATH; set OC_DEV to the path of an OpenCode checkout to run that from source instead.
3. opencode-agent

   added

   reproduced

   severity:high

   on Oct 8, 2026
4. neriousy

   marked Running UNDO command reverts changes done by hand #55121 as a duplicate of this issue on Oct 20, 2026
5. AtomicFS commented on Oct 20, 2026

   

   AtomicFS

   on Oct 20, 2026

   More actions

   Related to #55121, where a LLM only reading a file will cause undo command to revert user-made changes.

   Steps to reproduce:

   1. Ask LLM to read file without making any changes
   2. Make manual change by hand
   3. Run /undo command
   4. Your manual changes were undone
6. Jackdrakes commented on Oct 25, 2026

   

   Jackdrakes

   on Oct 25, 2026

   More actions

   I’d like to investigate and implement a fix for this. I plan to reproduce the race between an active turn, an external file edit, and /undo, then add a regression test ensuring user-authored changes are not reverted. I’ll first inspect the undo snapshot/patch tracking logic and propose the smallest conflict-safe fix.