backstep 0.1.9 → 0.1.10

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

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

@@ -13,9 +13,14 @@ const CLI = '/opt/backstep/cli.js'
 // `undo` answers with `undo`. Every argv the mod runs is recorded.
 function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: string }, shell: object = { kind: 'read', undoable: false }) {
   const runs: string[][] = []
+  const logs: string[] = []
   const prompts: { text: string; context?: readonly string[] }[] = []
   on('session.cwd', () => ({ value: '/repo' }))
   on('session.id', () => ({ value: 's1' }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
   on('process.run', (_, e) => {
     runs.push([...e.argv])
     const r = e.argv.includes('undo') ? undo : e.argv.includes('shell') ? { exitCode: 0, stdout: JSON.stringify(shell) } : { exitCode: 0, stdout: '' }
@@ -30,7 +35,7 @@ function engine(on: On, undo: { exitCode: number; stdout: string; stderr?: strin
     const { Text } = $.ui.resolve(e)
     return <Text>engine</Text>
   })
-  return { runs, prompts }
+  return { runs, prompts, logs }
 }
 
 test('an edit is snapshotted and the band offers to undo the turn', { options: { cli: CLI } }, async ($, on) => {
@@ -110,11 +115,12 @@ test('a change that cannot be undone stops the rewind and says so', { options: {
   const pressed = ui.press({ key: 'undo' })
   await clock.advance(1000)
   await pressed
+  await clock.advance(500)
   expect((await ui.find({ type: 'Text', text: /Stopped/ }))?.text).toContain('Stopped after 1 change')
   expect((await ui.find({ type: 'Text', text: /row changed since/ }))).toBeTruthy()
 
   // Still undoable once the band folds, since the turn was not fully rewound.
-  await clock.advance(10000)
+  await clock.advance(13000)
   expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
   await ui.unmount()
   expect(prompts).toHaveLength(1)
@@ -219,6 +225,7 @@ function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?:
     toasts.push(e.text)
     return { value: undefined }
   })
+  on('ui.log', () => ({ value: undefined }))
   on('session.cwd', () => ({ value: '/repo' }))
   on('session.id', () => ({ value: 's1' }))
   on('process.run', (_, e) => {
@@ -530,7 +537,7 @@ test('one press only asks; it lets go after a few seconds, or on cancel, and und
   const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
 
   await ui.press({ key: 'undo' })
-  expect((await ui.find({ type: 'Text', text: /Undo Claude's last turn\?/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /Undo Claude's last turn \("fix it"\)\?/ }))).toBeTruthy()
   expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u again to undo')
   await clock.advance(6000)
   expect((await ui.find({ type: 'Text', text: /Last turn/ }))).toBeTruthy()
@@ -606,3 +613,84 @@ test('about to change a Supabase project that is not connected, Backstep asks fi
   await $.tool.call({ tool: 'Bash', command })
   expect(asked).toHaveLength(1)
 })
+
+// An engine where each shell command's plan is given by a test, and undo answers as told.
+function shellEngine(on: On, plans: (command: string) => object, undo: object[]) {
+  const runs: string[][] = []
+  const logs: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', () => ({ value: undefined }))
+  on('ui.log', (_, e) => {
+    logs.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const command = e.argv.at(-1) ?? ''
+    const out = e.argv.includes('undo') ? undo : e.argv.includes('shell') ? plans(command) : e.argv.includes('db-check') ? { ask: null } : null
+    return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', { tool: 'AskUserQuestion' }, () => ({ result: { questions: [], answers: {} } }))
+  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, logs }
+}
+
+test('when the last turn only committed and pushed, undo offers to take back the work it saved too', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs } = shellEngine(on, () => ({ kind: 'outbound', reason: 'pushes to a remote', id: 'p1', undoable: true }), [])
+
+  await $.prompt.submit({ text: 'add the kanban board', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/board.tsx', old_string: 'a', new_string: 'b' })
+  await clock.advance(1000)
+  await $.prompt.submit({ text: 'commit and push it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'git add -A && git commit -m "board" && git push' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text', text: /Last turn \("commit and push it"\)/ }))).toBeTruthy()
+  await ui.press({ key: 'undo' })
+  expect((await ui.find({ type: 'Text', text: /only saved and pushed to git/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Button', key: 'undo' }))?.text).toBe('ctrl+u again to undo it and the turn before ("add the kanban board")')
+  expect(await ui.find({ type: 'Button', key: 'just' })).toBeTruthy()
+
+  const pressed = ui.press({ key: 'undo' })
+  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', '--json', '--via-claude-code'])
+  await ui.unmount()
+})
+
+test('after an undo, everything undone and everything that was not is listed, in the band and the conversation', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { logs } = shellEngine(
+    on,
+    (command) => (command.startsWith('curl') ? { kind: 'outbound', reason: 'sends a request', id: 'r1', undoable: true } : { kind: 'write', id: 'w1', undoable: true }),
+    [{ id: 'w1', tool: 'Bash', ok: true, detail: 'restored /repo/src/a.ts\nremoved /repo/src/b.ts' }],
+  )
+
+  await $.prompt.submit({ text: 'tidy and notify', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'rm src/a.ts' })
+  await $.tool.call({ tool: 'Bash', command: 'curl -X POST https://hooks.example.com/notify -d done' })
+
+  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(500)
+  expect((await ui.find({ type: 'Text', text: /src\/a\.ts restored/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /Not undone/ }))).toBeTruthy()
+  expect((await ui.find({ type: 'Text', text: /curl -X POST https:\/\/hooks\.example\.com\/notify -d done: sends a request/ }))).toBeTruthy()
+
+  const report = logs.find((l) => l.includes('Backstep undid'))!
+  expect(report).toContain('undid 2 changes from the last turn ("tidy and notify")')
+  expect(report).toContain('◀ src/b.ts removed')
+  expect(report).toContain('Not undone:\n  ✗ curl -X POST')
+  await ui.unmount()
+})

package/mod/hooks/register.tsx

@@ -19,6 +19,8 @@ const keys = atom({ plugin: 'backstep', key: 'keys' } as const, ['ctrl+u'] as st
 // 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'
+// The mark where only plain text goes (a transcript line).
+const MARK_TEXT = '◀◀'
 // How long the "press again to undo" question waits before it lets go.
 const CONFIRM_MS = 5000
 
@@ -71,7 +73,10 @@ async function offerPushUndo($: EngineInterface, outcomes: Outcome[]) {
           ? `Claude pushed a new branch, ${p.branch}, to ${p.host}. Delete it there too?`
           : `Claude pushed ${p.commits === 1 ? '1 commit' : `${p.commits} commits`} to ${p.branch} on ${p.host}. Undo ${p.commits === 1 ? 'it' : 'them'} there too?`
       const answer = await $.ui.ask(what, { header: 'Backstep', options: [p.before === null ? 'Delete the branch' : PUSH_ASK.yes, PUSH_ASK.no] }).catch(() => null)
-      if (!answer || answer === PUSH_ASK.no) continue
+      if (!answer || answer === PUSH_ASK.no) {
+        $.ui.log(`${MARK_TEXT} Not undone on ${p.host}: Claude's ${p.before === null ? `branch ${p.branch}` : p.commits === 1 ? 'commit' : `${p.commits} commits`} stay there (you chose to leave it).`)
+        continue
+      }
       const ran = await $.process
         .run(backstep(['revert-push', '--root', o.pushed.root]), { stdin: JSON.stringify(p), timeoutMs: 180_000 })
         .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
@@ -82,6 +87,7 @@ async function offerPushUndo($: EngineInterface, outcomes: Outcome[]) {
         // keep the error above
       }
       $.ui.toast(r.ok ? `Backstep ${r.detail}.` : `Backstep ${r.detail}. Nothing was changed on ${p.host}.`)
+      $.ui.log(r.ok ? `${MARK_TEXT} On ${p.host}: ${r.detail}.` : `${MARK_TEXT} Not undone on ${p.host}: ${r.detail}. Nothing was changed there.`)
       await update($, note, (n) =>
         n ? `${n}\n${r.ok ? `On ${p.host}: ${r.detail}.` : `${p.host} was left as it was: ${r.detail}.`}` : n,
       )
@@ -103,7 +109,8 @@ async function pressUndo($: EngineInterface) {
   const now = await $.clock.now()
   if (at !== null && now - at < CONFIRM_MS) {
     await update($, armed, () => null)
-    return undoLastTurn($)
+    const { before } = await undoTargets($)
+    return undoLastTurn($, before ? 2 : 1)
   }
   await update($, armed, () => now)
   $.clock.after(CONFIRM_MS, () => {
@@ -111,9 +118,11 @@ async function pressUndo($: EngineInterface) {
   })
 }
 
-async function undoLastTurn($: EngineInterface) {
+// Undoes the last `count` turns that changed something, newest first.
+async function undoLastTurn($: EngineInterface, count = 1) {
   if (await read($, rewind)) return
-  const target = (await read($, turns)).findLast(hasWork)
+  const taken = (await read($, turns)).filter(hasWork).slice(-count)
+  const target = taken[0]
   if (!target) return
 
   await update($, rewind, (): Rewind => ({ phase: 'running', frame: 0, shown: 0, items: [], message: '' }))
@@ -165,17 +174,28 @@ async function undoLastTurn($: EngineInterface) {
   const cut = outcomes.findIndex((o) => !o.ok)
   if (cut !== -1) outcomes = outcomes.slice(0, cut + 1)
 
-  const items: RewindItem[] = outcomes.map((o) => {
-    const first = o.detail.split('\n')[0] ?? ''
-    const what = first.replace(/^(restored|removed) (.*)$/, (_, verb: string, p: string) => `${short(p)} ${verb}`)
-    return { label: o.ok ? what || o.tool : `${o.tool}: ${first}`, ok: o.ok }
-  })
-  const done = items.filter((i) => i.ok).length
-  const failed = items.some((i) => !i.ok)
-  // A push counted as lost when it ran, but undo can now offer to take it back there.
-  const offered = outcomes.filter((o) => o.ok && o.pushed).length
-  const lost = Math.max(0, (target.lost ?? 0) - offered)
-  const shell = lost ? ` ${plural(lost, 'action')} that reached outside couldn't be undone.` : ''
+  // Every change undone, one per line, and every one that wasn't, with why.
+  const undone: RewindItem[] = outcomes
+    .filter((o) => o.ok)
+    .flatMap((o) =>
+      (o.detail || o.tool)
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => ({ label: line.replace(/^(restored|removed) (.*)$/, (_, verb: string, p: string) => `${short(p)} ${verb}`), ok: true })),
+    )
+  const stopped = outcomes.filter((o) => !o.ok).map((o) => ({ label: `${o.tool}: ${o.detail.split('\n')[0] ?? 'failed'}`, ok: false }))
+  // A push is offered back on GitHub below, so it isn't listed as lost.
+  const offered = outcomes.some((o) => o.ok && o.pushed)
+  const kept = taken
+    .flatMap((t) => t.lostItems ?? [])
+    .filter((l) => !(offered && /pushes to a remote/.test(l)))
+    .map((label) => ({ label, ok: false }))
+  const items: RewindItem[] = [...undone, ...stopped, ...kept]
+  const done = undone.length
+  const failed = stopped.length > 0
+  const lost = kept.length
+  const which = taken.length > 1 ? `the last ${taken.length} turns` : 'the last turn'
+  const shell = lost ? ` ${plural(lost, 'thing')} couldn't be undone: listed below.` : ''
 
   await update($, rewind, (): Rewind => ({
     phase: failed ? 'failed' : items.length ? 'done' : 'empty',
@@ -185,16 +205,24 @@ async function undoLastTurn($: EngineInterface) {
     message: failed
       ? `Stopped after ${plural(done, 'change')}: the next one couldn't be undone.`
       : items.length
-        ? `Rewound ${plural(done, 'change')} from the last turn.${shell}`
-        : `Nothing in the last turn could be undone.${shell}`,
+        ? `Rewound ${plural(done, 'change')} from ${which}.${shell}`
+        : `Nothing in ${which} could be undone.${shell}`,
   }))
-  await bump($, target.id, (t) => ({ ...t, undone: !failed }))
+  for (const t of taken) await bump($, t.id, (x) => ({ ...x, undone: !failed }))
+
+  // 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}`),
+    ...(stopped.length || kept.length ? ["Not undone:", ...[...stopped, ...kept].map((i) => `  ✗ ${i.label}`)] : []),
+  ]
+  $.ui.log(report.join('\n'))
 
   if (done) {
     const list = items.filter((i) => i.ok).map((i) => `- ${i.label}`).join('\n')
     const key = await keysLabel($)
     await update($, note, () =>
-      `[Backstep] The user pressed undo (${key}) on your previous turn. These changes were reverted:\n${list}\n` +
+      `[Backstep] The user pressed undo (${key}) on your ${taken.length > 1 ? `last ${taken.length} turns` : 'previous turn'}. These changes were reverted:\n${list}\n` +
         (lost ? `${plural(lost, 'action')} from that turn couldn't be undone (they reached outside this machine with no way back, or the project was too big to snapshot).\n` : '') +
         `Treat them as not having happened, re-read files before editing them, and don't redo them unless asked.`,
     )
@@ -207,7 +235,7 @@ async function undoLastTurn($: EngineInterface) {
   const reveal = $.clock.every(90, () => {
     void update($, rewind, (r) => (r && r.shown < r.items.length ? { ...r, shown: r.shown + 1 } : r))
   })
-  $.clock.after(failed ? 9000 : 4200, () => {
+  $.clock.after(failed || lost ? 12_000 : 4200, () => {
     reveal.cancel()
     void update($, rewind, () => null)
   })
@@ -257,7 +285,7 @@ async function watchMcp($: EngineInterface, e: Record<string, unknown>, next: Ne
   hint($, plan)
   // Behind Backstep, or Backstep couldn't be reached: count it as before.
   if (!plan || plan.kind === 'wrapped' || !plan.id) {
-    if (plan?.kind !== 'read') await bump($, t.id, (x) => ({ ...x, mcp: x.mcp + 1 }))
+    if (plan?.kind !== 'read') await bump($, t.id, (x) => ({ ...x, gitOnly: false, mcp: x.mcp + 1 }))
     return next(e)
   }
   const r = await next(plan.args ? { ...e, ...plan.args } : e)
@@ -274,7 +302,9 @@ async function watchMcp($: EngineInterface, e: Record<string, unknown>, next: Ne
   } catch {
     undoable = false
   }
-  if (!r.isError) await bump($, t.id, (x) => (undoable ? { ...x, mcp: x.mcp + 1 } : { ...x, lost: (x.lost ?? 0) + 1 }))
+  if (!r.isError) {
+    await bump($, t.id, (x) => (undoable ? { ...x, gitOnly: false, mcp: x.mcp + 1 } : lostOne({ ...x, gitOnly: false }, `${tool.replace(/^mcp__/, '').replace('__', ' ')}: ${plan.reason ?? 'there is no way to undo it'}`)))
+  }
   return r
 }
 
@@ -289,8 +319,40 @@ function backstep(args: string[]): string[] {
   return cli === 'backstep' ? ['backstep', ...args] : ['node', '--disable-warning=ExperimentalWarning', cli, ...args]
 }
 
-function newTurn(startedAt: number): Turn {
-  return { id: `t${startedAt}`, startedAt, edits: 0, files: [], mcp: 0, shell: 0, lost: 0, undone: false }
+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 } : {}) }
+}
+
+// A command as it reads in a list: without its leading `cd`, cut short.
+const brief = (command: string) => {
+  const c = command.replace(/^\s*cd\s+(?:"[^"]*"|'[^']*'|\S+)\s*&&\s*/, '').replace(/\s+/g, ' ').trim()
+  return c.length > 60 ? `${c.slice(0, 59)}…` : c
+}
+
+// Something in a turn that can't be undone, named, so undo can list it.
+const lostOne = (x: Turn, what: string): Turn => ({ ...x, lost: (x.lost ?? 0) + 1, lostItems: [...(x.lostItems ?? []), what].slice(-20) })
+
+// A turn named by what the person asked: ("commit and push it").
+const named = (t: Turn) => {
+  const p = (t.prompt ?? '').replace(/\s+/g, ' ').trim()
+  return p ? ` ("${p.length > 40 ? `${p.slice(0, 39)}…` : p}")` : ''
+}
+
+// Each part only saves to git (add, commit, push and friends), or only moves around.
+const GIT_SAVE = /^(git\s+(add|commit|push|status|log|diff|show|branch|remote|fetch|rev-parse|config)\b|cd\s|echo\s|true$)/
+const onlySavesToGit = (command: string) =>
+  command
+    .split(/&&|\|\||;|\n/)
+    .map((p) => p.trim())
+    .filter(Boolean)
+    .every((p) => GIT_SAVE.test(p))
+
+// What one press would take back: the last turn, and, when that turn only
+// committed and pushed, the turn whose work it saved.
+async function undoTargets($: EngineInterface): Promise<{ target: Turn | undefined; before: Turn | undefined }> {
+  const list = (await read($, turns)).filter(hasWork)
+  const target = list.at(-1)
+  return { target, before: target?.gitOnly ? list.at(-2) : undefined }
 }
 
 // The turn tool calls belong to; one opens if none is (a call before any prompt).
@@ -534,7 +596,7 @@ export const register: Register = (on, options) => {
   on('prompt.submit', async ($, e, next) => {
     if (e.command || e.isMeta || (e.origin.kind !== 'composer' && e.origin.kind !== 'bridge')) return next(e)
     const startedAt = await $.clock.now()
-    await update($, turns, (l) => [...(l ?? []), newTurn(startedAt)].slice(-KEEP_TURNS))
+    await update($, turns, (l) => [...(l ?? []), newTurn(startedAt, e.text)].slice(-KEEP_TURNS))
     const pending = await read($, note)
     if (!pending) return next(e)
     await update($, note, () => null)
@@ -560,7 +622,9 @@ export const register: Register = (on, options) => {
           .run(backstep(['snap', '--session', sid, '--tool', tool, '--cwd', cwd, '--', path]))
           .catch(() => null)
         if (snap?.exitCode === 0) {
-          await bump($, t.id, (x) => ({ ...x, edits: x.edits + 1, files: x.files.includes(path) ? x.files : [...x.files, path] }))
+          await bump($, t.id, (x) => ({ ...x, gitOnly: false, edits: x.edits + 1, files: x.files.includes(path) ? x.files : [...x.files, path] }))
+        } else {
+          await bump($, t.id, (x) => lostOne({ ...x, gitOnly: false }, `edit to ${path.split('/').pop()}: Backstep couldn't save a copy first`))
         }
       }
     } else if (tool === 'Bash') {
@@ -590,9 +654,15 @@ export const register: Register = (on, options) => {
       }
       if (plan?.kind === 'outbound') {
         // What it changed here comes back with the project snapshot; what it sent out doesn't (a push is offered back after undo).
-        await bump($, t.id, (x) => ({ ...x, shell: (x.shell ?? 0) + (plan.undoable ? 1 : 0), lost: (x.lost ?? 0) + 1 }))
+        const git = onlySavesToGit(command)
+        await bump($, t.id, (x) =>
+          lostOne({ ...x, gitOnly: x.gitOnly !== false && git, shell: (x.shell ?? 0) + (plan.undoable ? 1 : 0) }, `${brief(command)}: ${plan.reason ?? 'it reached outside this computer'}`),
+        )
       } else if (plan?.kind === 'write') {
-        await bump($, t.id, (x) => (plan.undoable ? { ...x, shell: (x.shell ?? 0) + 1 } : { ...x, lost: (x.lost ?? 0) + 1 }))
+        const git = onlySavesToGit(command)
+        await bump($, t.id, (x) =>
+          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)) {
@@ -626,33 +696,63 @@ export const register: Register = (on, options) => {
     if (r) {
       const tone = r.phase === 'failed' ? 'error' : r.phase === 'empty' ? 'warning' : undefined
       const glyph = r.phase === 'failed' ? '✗' : r.phase === 'empty' ? '!' : '✓'
-      const visible = r.items.slice(0, Math.min(r.shown, 6))
-      const more = r.items.length - 6
+      // What came back (the first few; the conversation has them all), then everything that didn't.
+      const shown = r.items.slice(0, r.shown)
+      const back = shown.filter((i) => i.ok)
+      const kept = shown.filter((i) => !i.ok)
+      const more = r.items.filter((i) => i.ok).length - 5
       return (
         <Box flexDirection="column">
           <Text color={tone} bold>
             {glyph} {r.message}
           </Text>
-          {visible.map((i, n) => (
-            <Text key={`i${n}`} color={i.ok ? undefined : 'error'} dimColor={i.ok}>
-              {'  '}
-              {i.ok ? '◀ ' : '✗ '}
+          {back.slice(0, 5).map((i, n) => (
+            <Text key={`b${n}`} dimColor>
+              {'  ◀ '}
+              {i.label}
+            </Text>
+          ))}
+          {back.length >= 5 && more > 0 ? <Text dimColor>{`  and ${more} more (all listed in the conversation)`}</Text> : null}
+          {kept.length ? <Text bold>{'  Not undone:'}</Text> : null}
+          {kept.slice(0, 6).map((i, n) => (
+            <Text key={`k${n}`} color="error">
+              {'  ✗ '}
               {i.label}
             </Text>
           ))}
-          {r.shown >= 6 && more > 0 ? <Text dimColor>{`  and ${more} more`}</Text> : null}
         </Box>
       )
     }
 
-    const target = (await read($, turns)).findLast(hasWork)
+    const { target, before } = await undoTargets($)
     const label = (await read($, keys)).map(keyLabel).join(' / ')
     if (target && (await read($, armed)) !== null) {
+      // The last turn only committed and pushed: the work it saved is what the person most likely wants back.
+      if (before) {
+        return (
+          <Box>
+            <Text bold>◀</Text>
+            <Text color={PINK} bold>◀</Text>
+            <Text color="warning" bold> That turn only saved and pushed to git. </Text>
+            <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
+              {`${label} again to undo it and the turn before${named(before)}`}
+            </Button>
+            <Text dimColor>  ·  </Text>
+            <Button key="just" plain dimColor onPress={() => void update($, armed, () => null).then(() => undoLastTurn($, 1))}>
+              just the push
+            </Button>
+            <Text dimColor>  ·  </Text>
+            <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
+              cancel
+            </Button>
+          </Box>
+        )
+      }
       return (
         <Box>
           <Text bold>◀</Text>
           <Text color={PINK} bold>◀</Text>
-          <Text color="warning" bold> Undo Claude's last turn? </Text>
+          <Text color="warning" bold>{` Undo Claude's last turn${named(target)}? `}</Text>
           <Text dimColor>{summary(target)}  </Text>
           <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
             {`${label} again to undo`}
@@ -673,7 +773,7 @@ export const register: Register = (on, options) => {
         <Text bold>◀</Text>
         <Text color={PINK} bold>◀</Text>
         <Text> </Text>
-        <Text dimColor>{target ? `Last turn: ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
+        <Text dimColor>{target ? `Last turn${named(target)}: ${summary(target)}  ` : 'Backstep is on · nothing to undo yet  '}</Text>
         <Button key="undo" action={UNDO_ACTION} plain dimColor onPress={() => void pressUndo($)}>
           {`${label} to undo`}
         </Button>

package/mod/types/index.d.ts

@@ -10,6 +10,12 @@ export type Turn = {
   // Shell commands and tool calls whose effects can't be taken back: they reached outside the machine with no undo rule, or the project was too big to snapshot.
   lost: number
   undone: boolean
+  // What the person asked for, so undo can name the turn it would take back.
+  prompt?: string
+  // Every change was a git commit or push (saving the turn before's work), so undo offers to take both.
+  gitOnly?: boolean
+  // What in this turn can't be undone, and why, so undo can say so by name.
+  lostItems?: string[]
 }
 
 export type RewindItem = { label: string; ok: boolean }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backstep",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "scripts": {
     "dev": "node src/cli.ts",