backstep 0.1.28 → 0.1.29

package/README.md

@@ -19,6 +19,7 @@ Undo for everything your agents touch. Backstep sits between your agent (Claude
 - **Things that can't be undone** (sending email, payments, deploys, `ALTER TABLE`…) run as normal and are marked in the journal, so you know what an undo didn't cover.
 - **Anything else, by rule:** a rules file maps a tool to its opposite (`create_issue` → close the issue, `send_message` → retract it), filled in from the call and its result. See [Undo rules](#undo-rules).
 - **Conflicts:** undoing an action first undoes any later action that touched the same file or table, so nothing gets silently thrown away.
+- **Your own edits:** Backstep notes how Claude left each file. If a file changed after that (you typed in it, or a formatter or `git pull` touched it), undo names it and asks first: **Keep my changes** undoes Claude's change and keeps yours (or leaves the file as you had it, where both changed the same lines), and **Undo them too** puts it back as it was before Claude's turn.
 
 ## Install
 

package/dist/adapters/fs.js

@@ -1,7 +1,7 @@
 // File undo: copy every path a tool is about to touch, then put it all back.
 // Restoring "the state each path was in" handles writes, edits, deletes,
 // creates and moves with one rule.
-import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { snapshotDir } from "../store.js";
 import { insidePath, resolveIn } from "../paths.js";
@@ -52,6 +52,22 @@ export function snapshotPaths(actionId, paths, cwd) {
     }
     return { adapter: "fs", entries };
 }
+// Once the tool has run: a copy of each file as it left it.
+export function recordAfter(actionId, undo) {
+    const dir = join(snapshotDir(actionId), "after");
+    const entries = undo.entries.map((e, i) => {
+        if (!existsSync(e.path))
+            return { ...e, after: { copy: null } };
+        const st = lstatSync(e.path);
+        if (!st.isFile() || st.size > MAX_BYTES)
+            return e;
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const copy = join(dir, String(i));
+        copyFileSync(e.path, copy);
+        return { ...e, after: { copy } };
+    });
+    return { ...undo, entries };
+}
 export function undoPaths(undo) {
     const restored = [];
     for (const e of undo.entries) {

package/dist/adapters/tree.js

@@ -210,6 +210,31 @@ export function snapshotTree(actionId, cwd, opts = {}) {
         return null;
     }
 }
+// Once the command has run: the folder as it left it, kept like the snapshot before it.
+export function recordTreeAfter(u, actionId) {
+    const tree = stage(u.gitDir, u.root);
+    const after = git(["commit-tree", tree, "-m", `${actionId} after`], { gitDir: u.gitDir, workTree: u.root });
+    git(["update-ref", `refs/backstep/${actionId}-after`, after], { gitDir: u.gitDir, workTree: u.root });
+    return { ...u, after };
+}
+// Files that differ now from how the command left them: [status, path from the root],
+// A made since, D deleted since, M changed since.
+export function changedSinceAfter(u) {
+    if (!u.after)
+        return [];
+    const now = stage(u.gitDir, u.root);
+    const out = git(["diff-tree", "-r", "-z", "--no-renames", "--name-status", u.after, now], { gitDir: u.gitDir, workTree: u.root });
+    const parts = out.split("\0").filter(Boolean);
+    const rows = [];
+    for (let i = 0; i + 1 < parts.length; i += 2)
+        rows.push([parts[i], parts[i + 1]]);
+    return rows;
+}
+// A file's bytes as the command left it.
+export function afterBlob(u, path) {
+    const pre = ["-c", "core.fsmonitor=false", "--git-dir", u.gitDir];
+    return execFileSync("git", [...pre, "cat-file", "blob", `${u.after}:${path}`], { env: ENV, timeout: TIMEOUT_MS, maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"] });
+}
 // After a command that pushes: each remote branch that moved, and how far.
 export function notePushed(u) {
     const before = u.git?.remotes;
@@ -240,6 +265,8 @@ export function undoTree(u, actionId) {
     const before = git(["diff", "--cached", "--name-status", u.commit], { gitDir, workTree: root });
     git(["read-tree", "--reset", "-u", u.commit], { gitDir, workTree: root });
     git(["update-ref", "-d", `refs/backstep/${actionId}`], { gitDir, workTree: root });
+    if (u.after)
+        git(["update-ref", "-d", `refs/backstep/${actionId}-after`], { gitDir, workTree: root });
     const lines = [];
     for (const row of before.split("\n").filter(Boolean)) {
         const [status, path] = row.split("\t");

package/dist/cli.js

@@ -4,9 +4,9 @@ import { fileURLToPath } from "node:url";
 import { runProxy } from "./proxy.js";
 import { startUi } from "./ui/server.js";
 import { Store, snapshotDir } from "./store.js";
-import { pruneDatabaseCopies, undoAction, undoRun, undoSince } from "./undo.js";
-import { insideDir, snapshotPaths } from "./adapters/fs.js";
-import { notePushed, snapshotSqlite, snapshotTree } from "./adapters/tree.js";
+import { pendingManual, pruneDatabaseCopies, undoAction, undoRun, undoSince } from "./undo.js";
+import { insideDir, recordAfter, snapshotPaths } from "./adapters/fs.js";
+import { notePushed, recordTreeAfter, snapshotSqlite, snapshotTree } from "./adapters/tree.js";
 import { revertPush } from "./push.js";
 import { ghMade, grantScope, openPage, undoGh } from "./github.js";
 import { accessNow, accessOnline, currentNote, login, logout, requireAccess } from "./account.js";
@@ -121,8 +121,10 @@ const HELP = `backstep: undo for everything your agents touch
   backstep log [--limit 30]    print recent actions
   backstep undo <action-id>    undo one action (and later ones that touched the same things)
   backstep undo --run <run-id> undo everything a run did
-  backstep undo --since <ms> [--until <ms>] [--json] [--via-claude-code]
-                               undo everything any agent did in that window
+  backstep undo --since <ms> [--until <ms>] [--json] [--via-claude-code] [--manual ask|undo|keep]
+                               undo everything any agent did in that window; files changed since
+                               (often by hand) are undone too, kept, or named first with ask
+  backstep after <action-id>   note how a tool left the files, once it ran (used by the Claude Code mod)
   backstep snap --session <id> --tool <name> [--cwd <dir>] -- <paths...>
                                save paths before Claude Code's own tools change them (used by the Claude Code mod)
   backstep revert-push --root <repo>
@@ -620,6 +622,18 @@ async function main() {
         return;
     }
     // Claude Code ran an opposite call `undo --via-claude-code` handed it.
+    // Once a tool Claude ran has finished (run by the Claude Code mod): notes how it
+    // left the files, so undo can tell changes made since apart from Claude's.
+    if (cmd === "after") {
+        const store = new Store();
+        const a = store.getAction(rest[0] ?? "");
+        const u = a?.undo ? JSON.parse(a.undo) : null;
+        if (a && u?.adapter === "fs")
+            store.updateAction(a.id, { undo: JSON.stringify(recordAfter(a.id, u)) });
+        if (a && u?.adapter === "tree")
+            store.updateAction(a.id, { undo: JSON.stringify(recordTreeAfter(u, a.id)) });
+        return;
+    }
     if (cmd === "settle") {
         const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: { failed: { type: "string" } } });
         const store = new Store();
@@ -655,11 +669,25 @@ async function main() {
                 json: { type: "boolean", default: false },
                 "via-claude-code": { type: "boolean", default: false },
                 session: { type: "string" },
+                manual: { type: "string" },
             },
         });
         const store = new Store();
+        const manual = values.manual ?? "undo";
+        if (manual !== "ask" && manual !== "undo" && manual !== "keep")
+            throw new Error("--manual is ask, undo or keep");
+        const window = { viaClaudeCode: values["via-claude-code"], session: values.session };
+        const until = values.until ? Number(values.until) : undefined;
+        // Asked first: files changed since Claude left them are named, and nothing is undone yet.
+        if (manual === "ask" && values.since) {
+            const files = pendingManual(store, Number(values.since), until, window);
+            if (files.length) {
+                console.log(values.json ? JSON.stringify({ manual: files }) : `These files changed since Claude's turn:\n  ${files.join("\n  ")}\nRun again with --manual keep (keep those changes) or --manual undo (undo them too).`);
+                return;
+            }
+        }
         const outcomes = values.since
-            ? await undoSince(store, Number(values.since), values.until ? Number(values.until) : undefined, { viaClaudeCode: values["via-claude-code"], session: values.session })
+            ? await undoSince(store, Number(values.since), until, { ...window, manual: manual === "keep" ? "keep" : "undo" })
             : values.run
                 ? await undoRun(store, values.run)
                 : await undoAction(store, positionals[0] ?? "");

package/dist/manual.js

@@ -0,0 +1,127 @@
+// Changes made since Claude's: usually a person typing, sometimes a formatter or
+// a git pull. Undo puts files back as they were before Claude's turn, which
+// would take these along, so they're found first and the person asked.
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterBlob, changedSinceAfter } from "./adapters/tree.js";
+import { insidePath } from "./paths.js";
+function readNow(path) {
+    if (!existsSync(path))
+        return null;
+    // A folder isn't compared: undefined says "can't tell".
+    return lstatSync(path).isFile() ? readFileSync(path) : undefined;
+}
+const same = (a, b) => (a === null || b === null ? a === b : a.equals(b));
+// The chain undo is about to run, newest first. Each file is checked against the
+// newest of Claude's actions that touched it: that's how Claude last left it.
+export function manualChanges(chain) {
+    const ordered = [...chain].sort((x, y) => y.created_at - x.created_at || y.seq - x.seq);
+    const files = new Set();
+    const roots = [];
+    const found = [];
+    const covered = (p) => files.has(p) || roots.some((r) => insidePath(p, r));
+    for (const a of ordered) {
+        const u = a.undo ? JSON.parse(a.undo) : null;
+        if (!u)
+            continue;
+        if (u.adapter === "fs") {
+            for (const e of u.entries) {
+                if (covered(e.path))
+                    continue;
+                files.add(e.path);
+                // Noted before this version, or a folder: nothing to compare with.
+                if (!e.after)
+                    continue;
+                const now = readNow(e.path);
+                if (now === undefined)
+                    continue;
+                const claude = e.after.copy && existsSync(e.after.copy) ? readFileSync(e.after.copy) : null;
+                if (e.after.copy && claude === null)
+                    continue;
+                if (!same(claude, now))
+                    found.push({ path: e.path, claude, now });
+            }
+        }
+        else if (u.adapter === "tree") {
+            const t = u;
+            if (roots.some((r) => insidePath(t.root, r)))
+                continue;
+            roots.push(t.root);
+            let rows = [];
+            try {
+                rows = changedSinceAfter(t);
+            }
+            catch {
+                continue;
+            }
+            for (const [status, rel] of rows) {
+                const path = join(t.root, rel);
+                // A newer edit of Claude's to this file is what it's compared with instead.
+                if (files.has(path))
+                    continue;
+                try {
+                    const now = status === "D" ? null : readNow(path);
+                    if (now === undefined)
+                        continue;
+                    found.push({ path, claude: status === "A" ? null : afterBlob(t, rel), now });
+                }
+                catch {
+                    // unreadable: leave it out rather than guess
+                }
+            }
+        }
+    }
+    return found;
+}
+function put(path, content) {
+    if (content === null) {
+        rmSync(path, { force: true });
+        return;
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+}
+// Undo has put Claude's files back as they were before; now each changed file
+// gets its later changes back. Where both edited different lines, Claude's
+// change stays undone and theirs is kept; where they overlap, the file is left
+// exactly as it was before undo, rather than guessed at.
+// Returns each file's line verb: kept (merged), left (as it was), overlap (as it was, lines clash).
+export function keepManual(changes) {
+    const result = new Map();
+    for (const c of changes) {
+        const before = existsSync(c.path) && lstatSync(c.path).isFile() ? readFileSync(c.path) : null;
+        const text = (b) => b !== null && !b.includes(0);
+        if (c.now === null || c.claude === null || before === null || !text(c.now) || !text(c.claude) || !text(before)) {
+            put(c.path, c.now);
+            result.set(c.path, "left");
+            continue;
+        }
+        const dir = mkdtempSync(join(tmpdir(), "backstep-merge-"));
+        try {
+            const [mine, base, theirs] = ["now", "claude", "before"].map((n) => join(dir, n));
+            writeFileSync(mine, c.now);
+            writeFileSync(base, c.claude);
+            writeFileSync(theirs, before);
+            let merged = null;
+            try {
+                merged = execFileSync("git", ["merge-file", "-p", mine, base, theirs], { stdio: ["ignore", "pipe", "pipe"], timeout: 20_000 });
+            }
+            catch {
+                // a clash (git exits with the number of them) or no git: keep theirs as is
+            }
+            put(c.path, merged ?? c.now);
+            result.set(c.path, merged ? "kept" : "overlap");
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    }
+    return result;
+}
+// Puts each changed file back exactly as it was before undo started.
+export function restoreManual(changes) {
+    for (const c of changes)
+        put(c.path, c.now);
+}

package/dist/undo.js

@@ -9,6 +9,7 @@ import { dbKey, firebaseConn, freshUrl, restKey } from "./supabase.js";
 import { undoFirebase } from "./adapters/firestore.js";
 import { undoRest } from "./adapters/rest.js";
 import { insidePath } from "./paths.js";
+import { keepManual, manualChanges, restoreManual } from "./manual.js";
 const INVERSE_TIMEOUT_MS = 20_000;
 // Database copies sit in the person's own database, so only the newest few per
 // database are kept; older commands keep their file undo but not their database undo.
@@ -208,14 +209,16 @@ export async function undoRun(store, runId) {
 }
 // Everything any agent did in a window of time: what one turn of a chat did,
 // across Claude's own edits and every server wrapped by Backstep.
-export async function undoSince(store, since, until = Date.now(), opts = {}) {
-    let inWindow = store.db
+// What one turn of a chat did, in a window of time, across Claude's own edits and
+// every server wrapped by Backstep: only this Claude Code session's, when it says which.
+function inWindow(store, since, until, opts) {
+    let found = store.db
         .prepare("SELECT * FROM actions WHERE created_at >= ? AND created_at <= ? ORDER BY created_at, seq")
         .all(since, until);
     if (opts.session) {
         const mine = `session:${opts.session}`;
         const commands = new Map();
-        inWindow = inWindow.filter((a) => {
+        found = found.filter((a) => {
             if (!commands.has(a.run_id))
                 commands.set(a.run_id, store.getRun(a.run_id)?.command);
             const command = commands.get(a.run_id);
@@ -224,11 +227,18 @@ export async function undoSince(store, since, until = Date.now(), opts = {}) {
             return !(command?.startsWith("session:") && command !== mine);
         });
     }
-    return undoAll(store, inWindow.filter(undoable), opts);
+    return found.filter(undoable);
 }
-async function undoAll(store, actions, opts = {}) {
-    if (actions.length === 0)
-        return [];
+export async function undoSince(store, since, until = Date.now(), opts = {}) {
+    return undoAll(store, inWindow(store, since, until, opts), opts);
+}
+// Files undoing this window would also take changes made since out of, without undoing anything.
+export function pendingManual(store, since, until = Date.now(), opts = {}) {
+    const actions = inWindow(store, since, until, opts);
+    return actions.length ? [...new Set(manualChanges(chainOf(store, actions)).map((c) => c.path))] : [];
+}
+// Every action to undo, newest first: these, and every later one touching the same things.
+function chainOf(store, actions) {
     // Start from the oldest, which pulls in every later conflict across runs too.
     const chain = [];
     const seen = new Set();
@@ -240,6 +250,42 @@ async function undoAll(store, actions, opts = {}) {
             }
         }
     }
-    chain.sort((x, y) => y.created_at - x.created_at || y.seq - x.seq);
-    return runChain(store, chain, opts);
+    return chain.sort((x, y) => y.created_at - x.created_at || y.seq - x.seq);
+}
+async function undoAll(store, actions, opts = {}) {
+    if (actions.length === 0)
+        return [];
+    const chain = chainOf(store, actions);
+    if (opts.manual !== "keep")
+        return runChain(store, chain, opts);
+    const changes = manualChanges(chain);
+    const out = await runChain(store, chain, opts);
+    if (!changes.length)
+        return out;
+    // Stopped partway: those files go back to how they were before undo started.
+    if (out.some((o) => !o.ok)) {
+        restoreManual(changes);
+        return out;
+    }
+    const verbs = keepManual(changes);
+    // Each file's line says what became of it: "restored x" turns into "kept x", "left x" or "overlap x".
+    const said = new Set();
+    for (const o of out) {
+        o.detail = o.detail
+            .split("\n")
+            .map((line) => {
+            const m = line.match(/^(restored|removed) (.*)$/);
+            const verb = m && verbs.get(m[2]);
+            if (!verb)
+                return line;
+            said.add(m[2]);
+            return `${verb} ${m[2]}`;
+        })
+            .join("\n");
+    }
+    const unsaid = [...verbs].filter(([p]) => !said.has(p)).map(([p, v]) => `${v} ${p}`);
+    const last = out.findLast((o) => o.ok);
+    if (unsaid.length && last)
+        last.detail = [last.detail, ...unsaid].filter(Boolean).join("\n");
+    return out;
 }

package/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Press ctrl+z to rewind everything Claude did in its last turn: file edits, shell commands, and database and tool changes.",
   "types": "./types/index.d.ts",
   "userConfig": {

package/mod/hooks/register.test.tsx

@@ -127,7 +127,7 @@ test('pressing undo rewinds the turn and tells Claude on the next prompt', { opt
   const pressed = ui.press({ key: 'undo' })
   await clock.settle()
   expect((await ui.find({ type: 'Text', text: /Rewinding/ }))?.text).toBeTruthy()
-  expect(runs.at(-1)).toEqual(['node', '--disable-warning=ExperimentalWarning', CLI, 'undo', '--since', '5000', '--session', 's1', '--json', '--via-claude-code'])
+  expect(runs.at(-1)).toEqual(['node', '--disable-warning=ExperimentalWarning', CLI, 'undo', '--since', '5000', '--session', 's1', '--json', '--via-claude-code', '--manual', 'ask'])
 
   await clock.advance(1000)
   await pressed
@@ -552,8 +552,9 @@ test('after undoing a turn that pushed, Backstep asks and pushes the undo', { op
 
   await $.prompt.submit({ text: 'ship it', wait: false, origin: { kind: 'composer' } })
   await $.tool.call({ tool: 'Bash', command: 'git push' })
-  // The push is noted once it has run.
-  expect(runs.at(-1)?.argv.slice(3)).toEqual(['shell-end', 'p1', '--cwd', '/repo'])
+  // The push is noted once it has run, then how it left the project.
+  expect(runs.at(-2)?.argv.slice(3)).toEqual(['shell-end', 'p1', '--cwd', '/repo'])
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['after', 'p1'])
 
   const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
   await ui.press({ key: 'undo' })
@@ -744,7 +745,7 @@ test('about to change a Supabase project that is not connected, Backstep asks fi
   await $.tool.call({ tool: 'Bash', command })
   expect(asked).toHaveLength(1)
   const order = runs.map((r) => r[3])
-  expect(order).toEqual(['db-check', 'connect', 'shell'])
+  expect(order).toEqual(['db-check', 'connect', 'shell', 'after'])
   expect(runs[1].slice(3)).toEqual(['connect', 'supabase', '--dir', '/work/taskflow', '--json'])
 
   // Asked once a session per project, whatever the answer.
@@ -801,7 +802,7 @@ test('when the last turn only committed and pushed, undo offers to take back the
   await clock.advance(1000)
   await pressed
   // Both turns: everything since the first one started.
-  expect(runs.find((r) => r.includes('undo'))?.slice(3)).toEqual(['undo', '--since', '5000', '--session', 's1', '--json', '--via-claude-code'])
+  expect(runs.find((r) => r.includes('undo'))?.slice(3)).toEqual(['undo', '--since', '5000', '--session', 's1', '--json', '--via-claude-code', '--manual', 'ask'])
   await ui.unmount()
 })
 
@@ -1176,3 +1177,77 @@ test('in the desktop app, the update is offered the same way and says not to clo
   expect(statuses[0]).toContain("don't close Claude Code")
   expect(said).not.toContain('terminal')
 })
+
+// Files changed after Claude's turn: undo asks before taking those changes too.
+function handEdited(on: On, answer: string | null) {
+  const runs: string[][] = []
+  const asked: string[] = []
+  const toasts: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.log', () => ({ value: undefined }))
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    const argv = [...e.argv]
+    runs.push(argv)
+    const manual = argv.includes('undo') ? argv[argv.indexOf('--manual') + 1] : null
+    const stdout =
+      argv.includes('snap') ? JSON.stringify({ id: 'c1', undoable: true })
+      : manual === 'ask' ? JSON.stringify({ manual: ['/repo/src/a.ts'] })
+      : manual === 'keep' ? JSON.stringify([{ id: 'c1', tool: 'Edit', ok: true, detail: 'kept /repo/src/a.ts' }])
+      : manual === 'undo' ? JSON.stringify([{ id: 'c1', tool: 'Edit', ok: true, detail: 'restored /repo/src/a.ts' }])
+      : ''
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    asked.push(questions[0].question)
+    return { result: { questions, answers: answer ? { [questions[0].question]: answer } : {} } }
+  })
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+  return { runs, asked, toasts }
+}
+
+test('an edit is noted once it has run, and undo asks about files changed since, keeping them on Keep my changes', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, asked } = handEdited(on, 'Keep my changes')
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/a.ts', old_string: 'a', new_string: 'b' })
+  expect(runs.at(-1)?.slice(3)).toEqual(['after', 'c1'])
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(3000)
+  await pressed
+  await clock.advance(500)
+  expect(asked).toEqual(["src/a.ts was changed after Claude's turn (by you, or by another tool). Undo those changes too?"])
+  const undos = runs.filter((r) => r.includes('undo')).map((r) => r.at(-1))
+  expect(undos).toEqual(['ask', 'keep'])
+  expect(await ui.find({ type: 'Text', text: /src\/a\.ts: Claude's changes undone, yours kept/ })).toBeTruthy()
+  await ui.unmount()
+})
+
+test('dismissing the question about changed files undoes nothing', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, toasts } = handEdited(on, null)
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/a.ts', old_string: 'a', new_string: 'b' })
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(3000)
+  await pressed
+  expect(runs.filter((r) => r.includes('undo')).map((r) => r.at(-1))).toEqual(['ask'])
+  expect(toasts).toContain('Undo cancelled. Nothing was changed.')
+  expect(await ui.find({ type: 'Text', text: /Rewinding|Rewound/ })).toBeFalsy()
+  await ui.unmount()
+})

package/mod/hooks/register.tsx

@@ -301,23 +301,49 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   if (!target) return
 
   await update($, rewind, (): Rewind => ({ phase: 'running', frame: 0, shown: 0, items: [], message: '' }))
-  const ticker = $.clock.every(55, () => {
-    void update($, rewind, (r) => (r && r.phase === 'running' ? { ...r, frame: r.frame + 1 } : r))
-  })
+  const spin = () =>
+    $.clock.every(55, () => {
+      void update($, rewind, (r) => (r && r.phase === 'running' ? { ...r, frame: r.frame + 1 } : r))
+    })
+  let ticker = spin()
 
   const cwd = await $.session.cwd()
   const short = (p: string) => relPath(p, cwd)
-  const [ran] = await Promise.all([
-    $.process.run(backstep(['undo', '--since', String(target.startedAt), '--session', await $.session.id(), '--json', '--via-claude-code'])).catch((err: unknown) => ({
-      exitCode: 1,
-      stdout: '',
-      stderr: err instanceof Error ? err.message : String(err),
-    })),
-    // Long enough to read as a rewind, short enough to never feel slow.
-    $.clock.sleep(700),
-  ])
+  const sid = await $.session.id()
+  const undo = (manual: 'ask' | 'keep' | 'undo') =>
+    Promise.all([
+      $.process.run(backstep(['undo', '--since', String(target.startedAt), '--session', sid, '--json', '--via-claude-code', '--manual', manual])).catch((err: unknown) => ({
+        exitCode: 1,
+        stdout: '',
+        stderr: err instanceof Error ? err.message : String(err),
+      })),
+      // Long enough to read as a rewind, short enough to never feel slow.
+      $.clock.sleep(700),
+    ]).then(([r]) => r)
+  let ran = await undo('ask')
   ticker.cancel()
 
+  // Files changed since Claude left them, usually by hand: nothing was undone yet, so ask first.
+  const changed = manualFiles(ran.stdout)
+  if (changed) {
+    const names = changed.map(short)
+    const list = names.length > 3 ? `${names.slice(0, 3).join(', ')} and ${plural(names.length - 3, 'more file')}` : names.length === 1 ? names[0] : `${names.slice(0, -1).join(', ')} and ${names.at(-1)}`
+    const answer = await $.ui
+      .ask(`${list} ${names.length === 1 ? 'was' : 'were'} changed after Claude's turn (by you, or by another tool). Undo those changes too?`, {
+        header: 'Backstep',
+        options: [MANUAL.keep, MANUAL.undo],
+      })
+      .catch(() => null)
+    if (answer !== MANUAL.keep && answer !== MANUAL.undo) {
+      await update($, rewind, () => null)
+      $.ui.toast('Undo cancelled. Nothing was changed.')
+      return
+    }
+    ticker = spin()
+    ran = await undo(answer === MANUAL.keep ? 'keep' : 'undo')
+    ticker.cancel()
+  }
+
   let outcomes: Outcome[] = []
   try {
     outcomes = JSON.parse(ran.stdout || '[]') as Outcome[]
@@ -365,7 +391,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
       (o.detail || o.tool)
         .split('\n')
         .filter(Boolean)
-        .map((line) => ({ label: line.replace(/^(restored|removed) (.*)$/, (_, verb: string, p: string) => `${short(p)} ${verb}`), ok: true })),
+        .map((line) => ({ label: undoneLabel(line, short), ok: true })),
     )
   const stopped = outcomes.filter((o) => !o.ok).map((o) => ({ label: `${o.tool}: ${o.detail.split('\n')[0] ?? 'failed'}`, ok: false }))
   // A push, or something made on GitHub, is offered back below, so it isn't listed as lost.
@@ -525,6 +551,40 @@ function backstep(args: string[]): string[] {
   return cli === 'backstep' ? ['backstep', ...args] : ['node', '--disable-warning=ExperimentalWarning', cli, ...args]
 }
 
+// The two answers when files changed after Claude's turn; keeping them comes first, so a quick Enter loses nothing.
+const MANUAL = { keep: 'Keep my changes', undo: 'Undo them too' } as const
+
+// The files `backstep undo --manual ask` named, when it stopped to ask.
+function manualFiles(stdout: string): string[] | null {
+  try {
+    const r = JSON.parse(stdout || 'null') as unknown
+    return r && !Array.isArray(r) && Array.isArray((r as { manual?: unknown }).manual) && (r as { manual: unknown[] }).manual.length ? (r as { manual: string[] }).manual : null
+  } catch {
+    return null
+  }
+}
+
+// One line of what undo did, as the band and the conversation show it.
+function undoneLabel(line: string, short: (p: string) => string): string {
+  const m = line.match(/^(restored|removed|kept|left|overlap) (.*)$/)
+  if (!m) return line
+  const p = short(m[2])
+  if (m[1] === 'kept') return `${p}: Claude's changes undone, yours kept`
+  if (m[1] === 'left') return `${p} left as you had it`
+  if (m[1] === 'overlap') return `${p} left as you had it: your changes overlap Claude's`
+  return `${p} ${m[1]}`
+}
+
+// The action id `backstep snap` printed.
+function savedId(stdout: string): string | null {
+  try {
+    const { id } = JSON.parse(stdout || '{}') as { id?: unknown }
+    return typeof id === 'string' ? id : null
+  } catch {
+    return null
+  }
+}
+
 function newTurn(startedAt: number, prompt?: string): Turn {
   return { id: `t${startedAt}`, startedAt, edits: 0, files: [], mcp: 0, shell: 0, lost: 0, undone: false, ...(prompt ? { prompt } : {}) }
 }
@@ -960,6 +1020,13 @@ export const register: Register = (on, options) => {
           .catch(() => null)
         if (snap?.exitCode === 0) {
           await bump($, t.id, (x) => ({ ...x, gitOnly: false, edits: x.edits + 1, files: x.files.includes(path) ? x.files : [...x.files, path] }))
+          // Once the edit has run: how it left the file, so undo can tell later changes (often by hand) apart.
+          const id = savedId(snap.stdout)
+          if (id) {
+            const r = await next(e)
+            await $.process.run(backstep(['after', id])).catch(() => null)
+            return r
+          }
         } else {
           await bump($, t.id, (x) => lostOne({ ...x, gitOnly: false }, `edit to ${path.split(/[\\/]/).pop()}: Backstep couldn't save a copy first`))
         }
@@ -1001,10 +1068,14 @@ export const register: Register = (on, options) => {
           plan.undoable ? { ...x, gitOnly: x.gitOnly !== false && git, shell: (x.shell ?? 0) + 1 } : lostOne({ ...x, gitOnly: false }, `${brief(command)}: ${plan.reason ?? "Backstep couldn't save a copy first"}`),
         )
       }
-      // A push: once it's run, note what it sent, so undo can offer to take it back there.
-      if (plan?.id && (PUSH.test(command) || GH_CREATE.test(command) || VERCEL.test(command))) {
+      if (plan?.id) {
         const r = await next(e)
-        await $.process.run(backstep(['shell-end', plan.id, '--cwd', cwd]), { stdin: r.text ?? '', timeoutMs: 60_000 }).catch(() => null)
+        // A push: once it's run, note what it sent, so undo can offer to take it back there.
+        if (PUSH.test(command) || GH_CREATE.test(command) || VERCEL.test(command)) {
+          await $.process.run(backstep(['shell-end', plan.id, '--cwd', cwd]), { stdin: r.text ?? '', timeoutMs: 60_000 }).catch(() => null)
+        }
+        // How the command left the project, so undo can tell later changes (often by hand) apart.
+        if (plan.undoable) await $.process.run(backstep(['after', plan.id]), { timeoutMs: 60_000 }).catch(() => null)
         return r
       }
     } else if (tool.startsWith('mcp__')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "homepage": "https://getbackstep.com",
   "scripts": {