backstep 0.1.30 → 0.1.31

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

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

@@ -1317,24 +1317,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 +1341,27 @@ 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)
+  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

@@ -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}`
       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,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.
@@ -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))
@@ -592,28 +605,53 @@ function undoneLabel(line: string, short: (p: string) => string): string {
 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
+
+// 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.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: `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: `${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) => ({
@@ -1104,10 +1142,18 @@ export const register: Register = (on, options) => {
     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 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)
+        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
     }
@@ -1251,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,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.31",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "homepage": "https://getbackstep.com",
   "scripts": {