backstep 0.1.28 → 0.1.30

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/setup.js

@@ -76,6 +76,15 @@ export async function setup() {
     const cli = join(root, "dist", "cli.js");
     // Without `backstep` on the PATH, the commands printed below go through npx.
     const bs = onPath ? "backstep" : "npx -y backstep";
+    // Only a problem is worth a line here; the summary below says the rest.
+    const bound = ensureUndoKey();
+    if (bound)
+        console.log(`  ${white("!")} ${bound}`);
+    // Servers point at the copy just put in place, which is whole by now.
+    autoWrap(true);
+    wrapServers(cli);
+    // The mod last: installing it makes Claude Code reload Backstep there, which
+    // ends the code that ran this update, so everything else is done first.
     const install = () => run("claude", ["plugin", "install", "backstep", "--marketplace", join(root, "mod"), "--config", `cli=${cli}`]);
     let r = install();
     // Installed before from another copy (the file a person was given, or ~/.backstep before npm worked):
@@ -90,19 +99,14 @@ export async function setup() {
     // was; re-reading the folder and updating brings the mod up to this version.
     run("claude", ["plugin", "marketplace", "update", "backstep"]);
     run("claude", ["plugin", "update", "backstep@backstep"]);
-    // Only a problem is worth a line here; the summary below says the rest.
-    const bound = ensureUndoKey();
-    if (bound)
-        console.log(`  ${white("!")} ${bound}`);
-    // Wrap last, so a failed install never leaves servers pointing at a Backstep that isn't there.
-    autoWrap(true);
-    wrapServers(cli);
     // What's covered and what isn't, said once here and kept up to date by `backstep status`.
     const key = (undoKeys().length ? undoKeys() : defaultKeys()).map(keyLabel).join(" or ");
     console.log(`\n  ${pink("✓")} ${white("Backstep is ready.")} Restart Claude Code, then press ${white(key)} after any turn to undo it.`);
     console.log(dim(`    Want a different key? Just ask Claude: "change my Backstep undo key to ctrl+q"`));
     console.log(dim(`    To remove Backstep, type /uninstall-backstep in Claude Code, or ask Claude to uninstall it.`));
-    printCheck(check(process.cwd()), bs);
+    // An update runs this out of sight, so the summary (a few seconds of checks) is skipped there.
+    if (process.env.BACKSTEP_UPDATING !== "1")
+        printCheck(check(process.cwd()), bs);
     if (telemetryOn()) {
         console.log(dim("  Sends an anonymous install count. Turn it off with BACKSTEP_TELEMETRY=0.\n"));
         await sendInstall();

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/dist/update.js

@@ -80,7 +80,7 @@ export function runUpdate(v, tries = 4) {
         const r = spawnSync("npx", ["-y", "--prefer-online", `backstep@${v}`, "setup"], {
             encoding: "utf8",
             timeout: 5 * 60 * 1000,
-            env: { ...process.env, NO_COLOR: "1", BACKSTEP_TELEMETRY: "0" },
+            env: { ...process.env, NO_COLOR: "1", BACKSTEP_TELEMETRY: "0", BACKSTEP_UPDATING: "1" },
             stdio: ["ignore", "pipe", "pipe"],
             cwd: tmpdir(),
         });

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

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "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
@@ -271,7 +271,8 @@ test('servers added since setup are wrapped as a session starts', { options: { c
 
 // A claude.ai connector: Backstep can't sit in front of it, so the mod reports
 // the call and, on undo, runs the rule's opposite call through Claude Code.
-function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean; undo?: object }) {
+function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean; mcpThrows?: string; undo?: object }) {
+  const prompts: string[] = []
   const runs: { argv: string[]; stdin?: string }[] = []
   const calls: { server: string; tool: string; args: Record<string, unknown> }[] = []
   const ran: Record<string, unknown>[] = []
@@ -295,6 +296,7 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
   })
   on('mcp.call', (_, e) => {
+    if (opts.mcpThrows) return { value: { content: [{ type: 'text', text: opts.mcpThrows }], isError: true } }
     calls.push({ server: e.server, tool: e.tool, args: e.args })
     if (e.tool === 'notion-fetch') return { value: { content: [{ type: 'text', text: `page ${String(e.args.id)} as it was` }], isError: false } }
     return { value: { content: [{ type: 'text', text: opts.mcpFails ? 'no such page' : 'archived' }], isError: opts.mcpFails === true } }
@@ -303,12 +305,15 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     ran.push({ ...e })
     return { result: { content: [{ type: 'text', text: '{"id":"p1"}' }] }, text: '{"id":"p1"}' }
   })
-  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('prompt.submit', (_, e) => {
+    prompts.push(e.text)
+    return { text: e.text, context: e.context }
+  })
   on('ui.render', ($, e) => {
     const { Text } = $.ui.resolve(e)
     return <Text>engine</Text>
   })
-  return { runs, calls, ran, toasts }
+  return { runs, calls, ran, toasts, prompts }
 }
 
 test('a connector call with an undo rule is undone through Claude Code', { options: { cli: CLI } }, async ($, on) => {
@@ -552,8 +557,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 +750,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 +807,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 +1182,176 @@ 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()
+})
+
+test('an update that reloads the mod partway is finished by the reloaded mod: it says done and takes the warning down', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  let started = false
+  const logs: string[] = []
+  const statuses: (string | undefined)[] = []
+  on('process.run', (_, e) => {
+    const argv = [...e.argv]
+    // The update itself never answers: installing it reloaded the mod that was waiting on it.
+    if (argv.includes('update') && argv.includes('--json')) {
+      started = true
+      return new Promise(() => {})
+    }
+    const stdout = argv.includes('update-check')
+      ? JSON.stringify({ current: started ? '0.2.0' : '0.1.2', latest: '0.2.0', available: !started })
+      : argv.includes('status')
+        ? JSON.stringify({ items: [], suggest: [] })
+        : '[]'
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('ui.status', (_, e) => {
+    statuses.push(e.text)
+    return { value: undefined }
+  })
+  on('tool.register', (_, e) => ({ value: { tool: `mcp__backstep__${e.name}` } }))
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    return { result: { questions, answers: { [questions[0].question]: 'Update' } } }
+  })
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('tool.call', () => ({ result: {} }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+
+  void $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  for (let i = 0; i < 10 && !started; i++) {
+    await settle()
+    await clock.advance(1000)
+  }
+  expect(started).toBe(true)
+  expect(statuses.at(-1)).toContain("don't close this terminal")
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  for (let i = 0; i < 5; i++) {
+    await clock.advance(5000)
+    await settle()
+  }
+  expect(statuses.at(-1)).toBeUndefined()
+  expect(logs.join('\n')).toContain('Backstep is updated to 0.2.0 (you had 0.1.2). It\'s safe to close this terminal now.')
+  await ui.unmount()
+})
+
+test("when auto mode won't let Backstep undo a Notion change, Claude is asked to, and the change counts as undone once it has", { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const refusal = "backstep: $.mcp.call(claude_ai_Notion, notion-delete-pages) refused: The server-side auto mode classifier gave no verdict for mcp__claude_ai_Notion__notion-delete-pages"
+  const asked: string[] = []
+  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: { [questions[0].question]: 'Ask Claude to do it' } } }
+  })
+  const { runs, ran, prompts } = connector(on, {
+    start: { kind: 'reversible', id: 'w1' },
+    undoable: true,
+    mcpThrows: refusal,
+    undo: { id: 'w1', tool: 'notion-create-pages', ok: true, detail: 'Notion: deleted the page', run: { server: 'claude_ai_Notion', tool: 'notion-delete-pages', args: { page_ids: ['p1'] }, label: 'Notion: delete the page Claude made' } },
+  })
+  await $.prompt.submit({ text: 'make a page', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-create-pages', pages: [{ title: 'Test' }], tool_use_id: 'tu1' } as never)
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  await ui.press({ key: 'undo' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  await clock.advance(1000)
+  await settle()
+  expect(runs.some((r) => r.argv.includes('settle') && r.argv.includes('--failed'))).toBe(true)
+  expect(asked).toEqual(["Claude Code's auto mode didn't let Backstep undo this by itself: Notion: delete the page Claude made. Ask Claude to undo it?"])
+  expect(prompts.at(-1)).toContain('mcp__claude_ai_Notion__notion-delete-pages with {"page_ids":["p1"]}')
+
+  // Claude makes the call: it isn't recorded as a change of its own, and the change is marked undone.
+  const before = ran.length
+  const watched = runs.filter((r) => r.argv.includes('watch-start')).length
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-delete-pages', page_ids: ['p1'], tool_use_id: 'tu2' } as never)
+  expect(ran.length).toBe(before + 1)
+  expect(runs.filter((r) => r.argv.includes('watch-start')).length).toBe(watched)
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['settle', 'w1'])
+  await ui.unmount()
+})

package/mod/hooks/register.tsx

@@ -7,7 +7,7 @@
 import { atom, read, update } from 'claude-code'
 import type { EngineInterface, Register } from 'claude-code'
 
-import type { GithubCode, Rewind, RewindItem, Turn } from '../types'
+import type { GithubCode, Rewind, RewindItem, Turn, Updating } from '../types'
 
 const turns = atom({ plugin: 'backstep', key: 'turns' } as const, [] as Turn[])
 const rewind = atom({ plugin: 'backstep', key: 'rewind' } as const, null as Rewind | null)
@@ -20,6 +20,12 @@ const keys = atom({ plugin: 'backstep', key: 'keys' } as const, ['ctrl+u'] as st
 const githubCode = atom({ plugin: 'backstep', key: 'githubCode' } as const, null as GithubCode | null)
 // Why ctrl+u can't run here, when getbackstep.com says so (a version too old, or no sign-in when one is needed).
 const blocked = atom({ plugin: 'backstep', key: 'blocked' } as const, null as string | null)
+// An update under way. Installing it reloads this mod partway through, which
+// ends the code waiting on it, so the reloaded mod finishes the job: it says
+// the update is done and takes the "don't close" line down.
+const updating = atom({ plugin: 'backstep', key: 'updating' } as const, null as Updating | null)
+// Whether this load of the mod has looked for an update the last one left running.
+let resumed = false
 // Backstep's mark, as on the logo: the front rewind triangle in the terminal's
 // own black or white, the one behind it in the logo's pink.
 const PINK = '#ee7bb6'
@@ -301,23 +307,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[]
@@ -329,19 +361,22 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   }
 
   // Opposite calls on servers only Claude Code is connected to run here, newest first.
+  let handoff: Handoff | null = null
   for (const o of outcomes) {
     if (!o.ok || !o.run) continue
     const run = o.run
     let failed: { tool: string; why: string } | null = null
     // The first opposite call, then any more on the same server (a move back to several places).
-    for (const call of [{ tool: run.tool, args: run.args }, ...(run.more ?? [])]) {
-      const done = await $.mcp.call(run.server, call.tool, call.args).catch((err: unknown) => ({
-        isError: true,
-        content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }],
-      }))
+    const all = [{ tool: run.tool, args: run.args }, ...(run.more ?? [])]
+    for (const [i, call] of all.entries()) {
+      const done = await undoCall($, run.server, call.tool, call.args)
       if (done.isError) {
         const why = done.content.map((c) => (c.type === 'text' ? c.text : '')).join(' ').trim().split('\n')[0] || 'failed'
-        failed = { tool: call.tool, why }
+        // Claude Code's auto mode won't let Backstep make it alone: Claude can, if the person says so.
+        if (REFUSED.test(why)) {
+          handoff = { id: o.id, server: run.server, calls: all.slice(i), label: run.label ?? `${o.tool}: ${call.tool}` }
+          failed = { tool: call.tool, why: "Claude Code's auto mode didn't let Backstep make this change itself" }
+        } else failed = { tool: call.tool, why }
         break
       }
     }
@@ -365,7 +400,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.
@@ -417,7 +452,9 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   }
 
   // Asked once the band shows what came back: GitHub things first, then pushes, then Vercel.
-  void offerGithubUndo($, outcomes)
+  // A change auto mode wouldn't let Backstep make comes first of all: it's where undo stopped.
+  void (handoff ? offerHandoff($, handoff) : Promise.resolve())
+    .then(() => offerGithubUndo($, outcomes))
     .then((gone) => offerPushUndo($, outcomes, gone.size > 0))
     .then(() => offerVercelUndo($, outcomes))
 
@@ -525,6 +562,90 @@ 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]}`
+}
+
+// Opposite calls handed to Claude to make, after the person said yes: the call,
+// by tool and arguments, to the action it undoes. Not recorded as Claude's own,
+// and once all of an action's have run, it counts as undone.
+const handedOver = new Map<string, string>()
+
+type Handoff = { id: string; server: string; calls: { tool: string; args: Record<string, unknown> }[]; label: string }
+const HANDOFF = { yes: 'Ask Claude to do it', no: 'Leave it' } as const
+
+// Auto mode's classifier answers only calls a request of Claude's asked for, so it
+// refuses Backstep's own. With the person's yes, the request is theirs: Claude is
+// asked to make exactly these calls, and Backstep marks the change undone once it has.
+async function offerHandoff($: EngineInterface, h: Handoff) {
+  const answer = await $.ui
+    .ask(`Claude Code's auto mode didn't let Backstep undo this by itself: ${h.label}. Ask Claude to undo it?`, { header: 'Backstep', options: [HANDOFF.yes, HANDOFF.no] })
+    .catch(() => null)
+  if (answer !== HANDOFF.yes) return
+  const server = toolServer(h.server)
+  for (const c of h.calls) handedOver.set(undoCallKey(`mcp__${server}__${c.tool}`, c.args), h.id)
+  const steps = h.calls.map((c) => `- mcp__${server}__${c.tool} with ${JSON.stringify(c.args)}`).join('\n')
+  await $.prompt
+    .submit({
+      text: `Undo this with Backstep: ${h.label}. Make exactly ${h.calls.length === 1 ? 'this call' : 'these calls, in order'}, and nothing else:\n${steps}`,
+      wait: false,
+      origin: { kind: 'composer' },
+    } as never)
+    .catch(() => null)
+}
+
+// One opposite call, through Claude Code's own connection to the server.
+async function undoCall($: EngineInterface, server: string, tool: string, args: Record<string, unknown>): Promise<{ isError: boolean; content: { type: string; text?: string }[] }> {
+  return $.mcp.call(server, tool, args).catch((err: unknown) => ({
+    isError: true,
+    content: [{ type: 'text' as const, text: err instanceof Error ? err.message : String(err) }],
+  }))
+}
+
+// Claude Code's permission check refused the call (auto mode's classifier
+// answers only calls a request of Claude's asked for), not the server.
+const REFUSED = /\$\.mcp\.call\([^)]*\) refused|auto mode classifier/i
+
+// A server's name as tool names spell it: "claude.ai Notion" is claude_ai_Notion.
+const toolServer = (server: string) => server.replace(/[^A-Za-z0-9_-]/g, '_')
+
+// A call by tool and arguments, the arguments' keys in order, so the same call always reads the same.
+function undoCallKey(tool: string, args: unknown): string {
+  const sorted = (v: unknown): unknown =>
+    Array.isArray(v) ? v.map(sorted) : v && typeof v === 'object' ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => (a < b ? -1 : 1)).map(([k, x]) => [k, sorted(x)])) : v
+  return `${tool} ${JSON.stringify(sorted(args ?? {}))}`
+}
+
+// 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 } : {}) }
 }
@@ -728,6 +849,40 @@ async function offerUpdate($: EngineInterface) {
   await installUpdate($, u.current, u.latest)
 }
 
+function updated($: EngineInterface, u: Updating) {
+  $.ui.log(`${MARK_TEXT} Backstep is updated to ${u.to}${u.from ? ` (you had ${u.from})` : ''}. It's safe to close ${u.win} now. Restart Claude Code to start using ${u.to}.`)
+  $.ui.toast(`Backstep is updated to ${u.to}. Restart Claude Code to use it.`)
+}
+
+// After a reload in the middle of an update: once the new version is in place,
+// say so and take the "don't close" line down. Setup may still be finishing,
+// so it looks again for a while before giving up.
+async function finishUpdate($: EngineInterface) {
+  const u = await read($, updating)
+  if (!u) return
+  for (let i = 0; i < 60; i++) {
+    const ran = await $.process.run(backstep(['update-check']), { timeoutMs: 15_000 }).catch(() => null)
+    let installed: string | undefined
+    try {
+      installed = (JSON.parse(ran?.stdout || '{}') as { current?: string }).current
+    } catch {
+      installed = undefined
+    }
+    if (installed === u.to) {
+      // Setup may still be wrapping servers: a moment more before saying it's safe to close.
+      await $.clock.sleep(5000)
+      $.ui.status(undefined)
+      await update($, updating, () => null)
+      updated($, u)
+      return
+    }
+    await $.clock.sleep(5000)
+  }
+  $.ui.status(undefined)
+  await update($, updating, () => null)
+  $.ui.log(`${MARK_TEXT} Backstep couldn't confirm the update to ${u.to} finished. If undo doesn't work after restarting Claude Code, run: npx backstep@latest setup`)
+}
+
 // Installs a version, saying not to close the terminal while it runs and which version it ended on.
 async function installUpdate($: EngineInterface, current: string | undefined, latest: string, forced = false): Promise<boolean> {
   const u = { current, latest }
@@ -737,6 +892,7 @@ async function installUpdate($: EngineInterface, current: string | undefined, la
   $.ui.log(`${MARK_TEXT} Updating Backstep${from} to ${u.latest}… Don't close ${win} until it says it's done (about a minute).`)
   $.ui.toast(`Updating Backstep to ${u.latest}. Don't close ${win} until it's done.`, { timeoutMs: 15_000 })
   $.ui.status(`◀◀ Updating Backstep to ${u.latest}… don't close ${win}`)
+  await update($, updating, () => ({ ...(u.current ? { from: u.current } : {}), to: latest, win }))
   const done = await $.process
     .run(backstep(['update', '--version', u.latest, '--json']), { timeoutMs: 600_000 })
     .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
@@ -747,9 +903,9 @@ async function installUpdate($: EngineInterface, current: string | undefined, la
     // keep the error above
   }
   $.ui.status(undefined)
+  await update($, updating, () => null)
   if (r.ok) {
-    $.ui.log(`${MARK_TEXT} Backstep is updated to ${u.latest}${u.current ? ` (you had ${u.current})` : ''}. It's safe to close ${win} now. Restart Claude Code to start using ${u.latest}.`)
-    $.ui.toast(`Backstep is updated to ${u.latest}. Restart Claude Code to use it.`)
+    updated($, { ...(u.current ? { from: u.current } : {}), to: latest, win })
     return true
   } else {
     $.ui.log(`${MARK_TEXT} Backstep couldn't update to ${u.latest}: ${r.detail}. You're still on ${u.current ?? 'the version you had'}${forced ? '' : ', which keeps working'}. To try again, run: npx backstep@latest setup`)
@@ -944,6 +1100,17 @@ export const register: Register = (on, options) => {
 
   on('tool.call', async ($, e, next) => {
     const tool = String(e.tool)
+    // An opposite call Claude is making for undo, as the person asked: not recorded as a change of its own.
+    const handed = handedOver.size ? undoCallKey(tool, Object.fromEntries(Object.entries(e).filter(([k]) => !RESERVED.has(k)))) : ''
+    const forAction = handed ? handedOver.get(handed) : undefined
+    if (forAction) {
+      const r = (await next(e)) as { deny?: string; isError?: boolean }
+      if (!r.deny && !r.isError) {
+        handedOver.delete(handed)
+        if (![...handedOver.values()].includes(forAction)) await $.process.run(backstep(['settle', forAction])).catch(() => null)
+      }
+      return r as never
+    }
     if (tool === CONNECT || tool === KEY || tool === UNINSTALL) return next(e)
     if (EDIT_TOOLS.has(tool)) {
       const input = e as { file_path?: string; notebook_path?: string }
@@ -960,6 +1127,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 +1175,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__')) {
@@ -1014,6 +1192,10 @@ export const register: Register = (on, options) => {
   })
 
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
+    if (!resumed) {
+      resumed = true
+      void finishUpdate($)
+    }
     if (e.props.hasSurvey) return next(e)
     const { Box, Button, Text } = $.ui.resolve(e)
     // The logo keeps its own box with a fixed gap after it: a space inside the

package/mod/types/index.d.ts

@@ -21,6 +21,9 @@ export type Turn = {
 export type RewindItem = { label: string; ok: boolean }
 
 // The animation above the prompt while a turn is being rewound.
+// An update under way, kept across the reload it causes, so the reloaded mod can say it's done.
+export type Updating = { from?: string; to: string; win: string }
+
 export type Rewind = {
   phase: 'running' | 'done' | 'failed' | 'empty'
   frame: number
@@ -38,6 +41,6 @@ declare module 'claude-code' {
     // keys: the keys bound to undo, kept here so the band redraws when they change.
     // githubCode: the code GitHub's approval page wants, shown on the band until GitHub answers.
     // blocked: why ctrl+u can't run, when getbackstep.com says this version is too old or a sign-in is needed.
-    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[]; githubCode: GithubCode | null; blocked: string | null }
+    backstep: { turns: Turn[]; rewind: Rewind | null; note: string | null; armed: number | null; keys: string[]; githubCode: GithubCode | null; blocked: string | null; updating: Updating | null }
   }
 }

package/package.json

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