backstep 0.1.29 → 0.1.31

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/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.29",
+  "version": "0.1.31",
   "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

@@ -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) => {
@@ -1251,3 +1256,112 @@ test('dismissing the question about changed files undoes nothing', { options: {
   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()
+})
+
+// Auto mode refuses Backstep's own call: pressing undo was the go-ahead, so Claude is asked to make it.
+async function refusedNotionUndo($: Parameters<Parameters<typeof test>[2]>[0], on: 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) => {
+    asked.push((e as unknown as { questions: { question: string }[] }).questions[0].question)
+    return { result: {} }
+  })
+  const env = connector(on, {
+    start: { kind: 'reversible', id: 'w1' },
+    undoable: true,
+    mcpThrows: refusal,
+    undo: { id: 'w1', tool: 'notion-create-pages', ok: true, detail: 'runs notion-delete-pages', run: { server: 'claude_ai_Notion', tool: 'notion-delete-pages', args: { page_ids: ['p1'], user_confirmed: true }, label: 'Notion: moved the pages Claude made to Trash' } },
+  })
+  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()
+  return { ...env, asked, ui }
+}
+
+test("when auto mode won't let Backstep undo a Notion change, Claude is asked to make the call, with no question and nothing shown as failed", { options: { cli: CLI } }, async ($, on) => {
+  const { runs, ran, prompts, asked, ui } = await refusedNotionUndo($, on)
+  expect(asked).toEqual([])
+  expect(runs.some((r) => r.argv.includes('--failed'))).toBe(false)
+  expect(prompts.at(-1)).toContain('mcp__claude_ai_Notion__notion-delete-pages with {"page_ids":["p1"],"user_confirmed":true}')
+  expect((await ui.find({ type: 'Text', text: /Rewound/ }))?.text).toContain('Rewound 1 change from the last turn. Claude is finishing it.')
+  expect(await ui.find({ type: 'Text', text: /Not undone/ })).toBeFalsy()
+
+  // 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'], user_confirmed: true, 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'])
+  const line = await ui.find({ type: 'Text', text: /Rewound/ })
+  expect(line?.text).toContain('Rewound 1 change from the last turn.')
+  expect(line?.text).not.toContain('Claude is finishing')
+  expect(await ui.find({ type: 'Text', text: /Claude is finishing this/ })).toBeFalsy()
+  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'
@@ -59,6 +65,8 @@ type Outcome = {
   tool: string
   ok: boolean
   detail: string
+  // Handed to Claude to finish: auto mode wouldn't let Backstep make the call.
+  pending?: boolean
   run?: { server: string; tool: string; args: Record<string, unknown>; more?: { tool: string; args: Record<string, unknown> }[]; label?: string }
   pushed?: { root: string; pushes: Pushed[] }
   github?: GhMade[]
@@ -355,29 +363,43 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   }
 
   // Opposite calls on servers only Claude Code is connected to run here, newest first.
+  // Once auto mode refuses one, it and every one after it go to Claude, in order.
+  const handoff: Handoff[] = []
   for (const o of outcomes) {
     if (!o.ok || !o.run) continue
     const run = o.run
+    const all = [{ tool: run.tool, args: run.args }, ...(run.more ?? [])]
+    const label = run.label ?? `ran ${run.tool}`
+    if (handoff.length) {
+      handoff.push({ id: o.id, server: run.server, calls: all, label })
+      o.pending = true
+      o.detail = label
+      continue
+    }
     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) }],
-      }))
+    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; the person's undo is the go-ahead, so Claude makes it.
+        if (REFUSED.test(why)) handoff.push({ id: o.id, server: run.server, calls: all.slice(i), label })
+        else failed = { tool: call.tool, why }
         break
       }
     }
+    if (handoff.length) {
+      o.pending = true
+      o.detail = label
+      continue
+    }
     if (failed) {
       o.ok = false
       o.detail = `${failed.tool} failed: ${failed.why}`
       await $.process.run(backstep(['settle', o.id, '--failed', failed.why])).catch(() => null)
       break
     }
-    o.detail = run.label ?? `ran ${run.tool}`
+    o.detail = label
     await $.process.run(backstep(['settle', o.id])).catch(() => null)
   }
   // Stop the list at the first failure, as the CLI does.
@@ -391,7 +413,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
       (o.detail || o.tool)
         .split('\n')
         .filter(Boolean)
-        .map((line) => ({ label: undoneLabel(line, short), ok: true })),
+        .map((line): RewindItem => (o.pending ? { label: undoneLabel(line, short), ok: true, pending: true, action: o.id } : { 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.
@@ -419,7 +441,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
     message: failed
       ? `Stopped after ${plural(done, 'change')}: the next one couldn't be undone.`
       : items.length
-        ? `Rewound ${plural(done, 'change')} from ${which}.${shell}`
+        ? `Rewound ${plural(done, 'change')} from ${which}.${finishing(undone)}${shell}`
         : `Nothing in ${which} could be undone.${shell}`,
   }))
   for (const t of taken) await bump($, t.id, (x) => ({ ...x, undone: !failed }))
@@ -427,7 +449,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
   // The whole account, kept in the conversation, where the band's few rows fold away.
   const report = [
     `${MARK_TEXT} Backstep undid ${plural(done, 'change')} from ${which}${taken.length === 1 ? named(target) : ''}${done ? ':' : '.'}`,
-    ...undone.map((i) => `  ◀ ${i.label}`),
+    ...undone.map((i) => `  ◀ ${i.label}${i.pending ? ' (Claude is finishing this)' : ''}`),
     ...(stopped.length || kept.length ? ["Not undone:", ...[...stopped, ...kept].map((i) => `  ✗ ${i.label}`)] : []),
   ]
   $.ui.log(report.join('\n'))
@@ -443,7 +465,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.length ? handOff($, handoff) : Promise.resolve())
+    .then(() => offerGithubUndo($, outcomes))
     .then((gone) => offerPushUndo($, outcomes, gone.size > 0))
     .then(() => offerVercelUndo($, outcomes))
 
@@ -575,6 +599,81 @@ function undoneLabel(line: string, short: (p: string) => string): string {
   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 }
+
+// Said after "Rewound …" while Claude still has some of it to finish.
+function finishing(items: RewindItem[]): string {
+  const n = items.filter((i) => i.pending).length
+  return n === 0 ? '' : n === items.length ? ' Claude is finishing it.' : ` Claude is finishing ${n} of them.`
+}
+
+// Auto mode's classifier answers only calls a request of Claude's asked for, so it
+// refuses Backstep's own. Pressing undo already said yes, so Claude is asked to make
+// exactly these calls; Backstep marks each change undone once its calls have run.
+async function handOff($: EngineInterface, list: Handoff[]) {
+  const steps: string[] = []
+  for (const h of list) {
+    const server = toolServer(h.server)
+    for (const c of h.calls) {
+      handedOver.set(undoCallKey(`mcp__${server}__${c.tool}`, c.args), h.id)
+      steps.push(`- mcp__${server}__${c.tool} with ${JSON.stringify(c.args)}`)
+    }
+  }
+  const what = list.map((h) => h.label).join('; ')
+  await $.prompt
+    .submit({
+      text: `I pressed undo, and Backstep needs you to finish it (auto mode doesn't let Backstep make these calls itself): ${what}. Make exactly ${steps.length === 1 ? 'this call' : 'these calls, in order'}, and nothing else:\n${steps.join('\n')}`,
+      wait: false,
+      origin: { kind: 'composer' },
+    } as never)
+    .catch(() => null)
+}
+
+// One of Claude's hand-over calls has run: the band's row for it says how it went.
+async function handedBack($: EngineInterface, action: string, ok: boolean, why?: string) {
+  await update($, rewind, (r) => {
+    if (!r) return r
+    const items = r.items.map((i) => (i.pending && i.action === action ? (ok ? { ...i, pending: false } : { label: `${i.label}: Claude couldn't (${why ?? 'it failed'})`, ok: false }) : i))
+    const undone = items.filter((i) => i.ok)
+    // "Rewound 2 changes from the last turn. Claude is finishing it." loses its last sentence once Claude has.
+    const [rewound, ...rest] = r.message.replace(/ Claude is finishing [^.]*\./, '').split(/(?<=\.) /)
+    return {
+      ...r,
+      items,
+      shown: items.length,
+      phase: ok ? r.phase : 'failed',
+      message: ok ? [rewound + finishing(undone), ...rest].join(' ') : `Rewound ${plural(undone.length, 'change')}. Claude couldn't finish one: listed below.`,
+    }
+  })
+}
+
+// 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 {
@@ -788,6 +887,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 }
@@ -797,6 +930,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) }))
@@ -807,9 +941,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`)
@@ -1004,6 +1138,25 @@ 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; text?: string }
+      if (!r.deny && !r.isError) {
+        handedOver.delete(handed)
+        if (![...handedOver.values()].includes(forAction)) {
+          await $.process.run(backstep(['settle', forAction])).catch(() => null)
+          await handedBack($, forAction, true)
+        }
+      } else {
+        const why = (r.deny ?? r.text ?? 'it failed').trim().split('\n')[0]
+        for (const [k, a] of handedOver) if (a === forAction) handedOver.delete(k)
+        await $.process.run(backstep(['settle', forAction, '--failed', why])).catch(() => null)
+        await handedBack($, forAction, false, why)
+      }
+      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 }
@@ -1085,6 +1238,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
@@ -1140,8 +1297,9 @@ export const register: Register = (on, options) => {
           </Text>
           {back.slice(0, 5).map((i, n) => (
             <Text key={`b${n}`} dimColor>
-              {'  ◀ '}
+              {i.pending ? '  … ' : '  ◀ '}
               {i.label}
+              {i.pending ? ' (Claude is finishing this)' : ''}
             </Text>
           ))}
           {back.length >= 5 && more > 0 ? <Text dimColor>{`  and ${more} more (all listed in the conversation)`}</Text> : null}

package/mod/types/index.d.ts

@@ -18,9 +18,13 @@ export type Turn = {
   lostItems?: string[]
 }
 
-export type RewindItem = { label: string; ok: boolean }
+// `pending`: handed to Claude to finish (auto mode wouldn't let Backstep make the call); `action`: the change it undoes.
+export type RewindItem = { label: string; ok: boolean; pending?: boolean; action?: string }
 
 // 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 +42,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.29",
+  "version": "0.1.31",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "homepage": "https://getbackstep.com",
   "scripts": {