backstep 0.1.30 → 0.1.32

package/dist/adapters/tree.js

@@ -195,6 +195,7 @@ function projectGit(root, actionId, pushes) {
 // Returns null when the folder can't be snapshotted: the home folder or the
 // whole disk, or a folder too big to stage in time.
 export function snapshotTree(actionId, cwd, opts = {}) {
+    lastTreeError = null;
     const root = projectRoot(cwd);
     if (isDiskRoot(root) || root === homedir() || root === resolve(homeDir()))
         return null;
@@ -206,10 +207,13 @@ export function snapshotTree(actionId, cwd, opts = {}) {
         git(["update-ref", `refs/backstep/${actionId}`, commit], { gitDir, workTree: root });
         return { adapter: "tree", root, gitDir, commit, git: projectGit(root, actionId, opts.pushes === true) };
     }
-    catch {
+    catch (err) {
+        lastTreeError = (err instanceof Error ? err.stderr || err.message : String(err)).trim().split("\n").find(Boolean) ?? null;
         return null;
     }
 }
+// Why the last snapshot couldn't be made, in git's words: null when it was too big or the folder is off limits.
+export let lastTreeError = 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);

package/dist/cli.js

@@ -6,7 +6,7 @@ import { startUi } from "./ui/server.js";
 import { Store, snapshotDir } from "./store.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 { lastTreeError, 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";
@@ -520,13 +520,14 @@ async function main() {
         const kind = plan.kind === "outbound" && saved && /database|request/.test(plan.reason ?? "") ? "write" : plan.kind;
         if (kind !== plan.kind)
             store.updateAction(a.id, { kind: "reversible", reason: null });
+        const unsaved = lastTreeError ? `Backstep couldn't save a copy first (${lastTreeError})` : "Backstep couldn't save a copy first (the folder is too big, or it's your whole home folder)";
         if (!undo && kind !== "outbound")
-            store.updateAction(a.id, { kind: "write", reason: "project too large to snapshot" });
+            store.updateAction(a.id, { kind: "write", reason: unsaved });
         if (missed.length)
             store.updateAction(a.id, { reason: `couldn't save the database first: ${missed[0]}` });
         if (dbs.length)
             await pruneDatabaseCopies(store).catch(() => { });
-        console.log(JSON.stringify({ kind, reason: kind === plan.kind ? plan.reason : undefined, id: a.id, undoable: undo !== null, db: saved }));
+        console.log(JSON.stringify({ kind, reason: !undo && kind !== "outbound" ? unsaved : kind === plan.kind ? plan.reason : undefined, id: a.id, undoable: undo !== null, db: saved }));
         return;
     }
     // Before a shell command, from the Claude Code mod: does it reach a Supabase project Backstep

package/dist/shell.js

@@ -10,6 +10,8 @@ const READ_PROGRAMS = new Set([
     "cut", "tr", "column", "jq", "yq", "date", "whoami", "id", "uname", "env", "printenv", "ps", "top", "uptime",
     "basename", "dirname", "realpath", "readlink", "md5", "md5sum", "shasum", "sha256sum", "true", "false", "test", "[",
     "sleep", "man", "tldr", "history", "lsof", "hostname", "cal", "nproc",
+    // Opening a page, a file or an app in it changes nothing here by itself.
+    "open", "xdg-open",
 ]);
 const READ_GIT = new Set([
     "status", "log", "diff", "show", "blame", "grep", "ls-files", "ls-tree", "rev-parse", "describe", "shortlog",

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

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.30",
+  "version": "0.1.32",
   "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

@@ -373,9 +373,14 @@ test('a Notion move: the pages are read first, and undo runs every opposite call
   await ui.unmount()
 })
 
-test('when the opposite call fails, the rewind says so', { options: { cli: CLI } }, async ($, on) => {
+test('when the opposite call fails, the rewind says so, plainly', { options: { cli: CLI } }, async ($, on) => {
   const clock = mock.clock(on, { now: 5000 })
-  const { runs } = connector(on, { start: { kind: 'reversible', id: 'w1' }, undoable: true, mcpFails: true })
+  const { runs } = connector(on, {
+    start: { kind: 'reversible', id: 'w1' },
+    undoable: true,
+    mcpFails: true,
+    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'] }, 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__create-page', title: 'Plan' } as never)
@@ -385,7 +390,8 @@ test('when the opposite call fails, the rewind says so', { options: { cli: CLI }
   await clock.advance(1000)
   await pressed
   expect(runs.at(-1)?.argv.slice(3)).toEqual(['settle', 'w1', '--failed', 'no such page'])
-  expect((await ui.find({ type: 'Text', text: /no such page/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /no such page/ }))?.text).toContain(`Couldn't move the pages Claude made to Trash: Notion said "no such page"`)
+  expect(await ui.find({ type: 'Text', text: /notion-delete-pages failed/ })).toBeFalsy()
   await ui.unmount()
 })
 
@@ -1317,24 +1323,23 @@ test('an update that reloads the mod partway is finished by the reloaded mod: it
   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) => {
+// 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) => {
-    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' } } }
+    asked.push((e as unknown as { questions: { question: string }[] }).questions[0].question)
+    return { result: {} }
   })
-  const { runs, ran, prompts } = connector(on, {
+  const env = 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' } },
+    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' })
@@ -1342,16 +1347,28 @@ test("when auto mode won't let Backstep undo a Notion change, Claude is asked to
   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"]}')
+  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'], tool_use_id: 'tu2' } as never)
+  // Claude adds an argument of its own (Notion's telemetry): still the same call.
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__notion-delete-pages', page_ids: ['p1'], user_confirmed: true, telemetry: { intent: 'undo' }, 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

@@ -65,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[]
@@ -361,32 +363,43 @@ 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
+  // 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).
-    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'
-        // 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 }
+        // 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}`
+      o.detail = couldnt(run.label, failed.why, `undo ${o.tool}`)
       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.
@@ -400,9 +413,9 @@ 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 }))
+  const stopped = outcomes.filter((o) => !o.ok).map((o) => { const line = o.detail.split('\n')[0] ?? 'failed'; return { label: line.startsWith("Couldn't ") ? line : `${o.tool}: ${line}`, ok: false } })
   // A push, or something made on GitHub, is offered back below, so it isn't listed as lost.
   const offered = outcomes.some((o) => o.ok && o.pushed)
   const offeredGh = outcomes.some((o) => o.ok && o.github?.length)
@@ -428,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 }))
@@ -436,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'))
@@ -453,7 +466,7 @@ async function undoLastTurn($: EngineInterface, count = 1) {
 
   // Asked once the band shows what came back: GitHub things first, then pushes, then Vercel.
   // A change auto mode wouldn't let Backstep make comes first of all: it's where undo stopped.
-  void (handoff ? offerHandoff($, handoff) : Promise.resolve())
+  void (handoff.length ? handOff($, handoff) : Promise.resolve())
     .then(() => offerGithubUndo($, outcomes))
     .then((gone) => offerPushUndo($, outcomes, gone.size > 0))
     .then(() => offerVercelUndo($, outcomes))
@@ -586,34 +599,77 @@ 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>()
+// Opposite calls handed to Claude to make after the person pressed undo: the call
+// and the action it undoes. Not recorded as Claude's own, and once all of an
+// action's have run, it counts as undone.
+type Handed = { tool: string; args: Record<string, unknown>; action: string }
+const handedOver: Handed[] = []
+
+// Claude's call is the one handed over when it's the same tool with the same
+// values for every argument Backstep gave; Claude adds its own (Notion's telemetry, say).
+function handedCall(tool: string, args: Record<string, unknown>): Handed | undefined {
+  return handedOver.find((h) => h.tool === tool && Object.entries(h.args).every(([k, v]) => undoCallKey('', v) === undoCallKey('', args[k])))
+}
 
 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
+
+// A change that didn't come back, said plainly: "Notion: moved the pages Claude made to Trash"
+// that failed reads "Couldn't move the pages Claude made to Trash: Notion said "no such page"".
+const INFINITIVE: Record<string, string> = { moved: 'move', restored: 'restore', put: 'put', archived: 'archive', deleted: 'delete', removed: 'remove', ran: 'run', closed: 'close', reopened: 'reopen', set: 'set' }
+function couldnt(label: string | undefined, why: string, fallback: string): string {
+  const reason = why.replace(/^(backstep|error):\s*/i, '').split(/(?<=\.)\s/)[0].slice(0, 140)
+  const m = label?.match(/^(?:([A-Z][\w.]*(?: [A-Z][\w.]*)*): )?(\w+)\s(.*)$/)
+  const verb = m ? INFINITIVE[m[2]] : undefined
+  const what = m && verb ? `${verb} ${m[3]}` : fallback
+  return m?.[1] ? `Couldn't ${what}: ${m[1]} said "${reason}"` : `Couldn't ${what}: ${reason}`
+}
+
+// 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. 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')
+// 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.push({ tool: `mcp__${server}__${c.tool}`, args: c.args, action: 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: `Undo this with Backstep: ${h.label}. Make exactly ${h.calls.length === 1 ? 'this call' : 'these calls, in order'}, and nothing else:\n${steps}`,
+      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: couldnt(i.label, why ?? 'it failed', 'finish undoing it'), 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) => ({
@@ -1101,13 +1157,24 @@ 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 }
+    const handed = handedOver.length ? handedCall(tool, Object.fromEntries(Object.entries(e).filter(([k]) => !RESERVED.has(k)))) : undefined
+    if (handed) {
+      const forAction = handed.action
+      const r = (await next(e)) as { deny?: string; isError?: boolean; text?: string }
+      const drop = (which: (h: Handed) => boolean) => {
+        for (let i = handedOver.length - 1; i >= 0; i--) if (which(handedOver[i])) handedOver.splice(i, 1)
+      }
       if (!r.deny && !r.isError) {
-        handedOver.delete(handed)
-        if (![...handedOver.values()].includes(forAction)) await $.process.run(backstep(['settle', forAction])).catch(() => null)
+        drop((h) => h === handed)
+        if (!handedOver.some((h) => h.action === 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]
+        drop((h) => h.action === forAction)
+        await $.process.run(backstep(['settle', forAction, '--failed', why])).catch(() => null)
+        await handedBack($, forAction, false, why)
       }
       return r as never
     }
@@ -1251,8 +1318,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,7 +18,8 @@ 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.

package/package.json

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