backstep 0.1.9 → 0.1.13

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
 
@@ -55,23 +57,76 @@ type Outcome = {
   detail: string
   run?: { server: string; tool: string; args: Record<string, unknown> }
   pushed?: { root: string; pushes: Pushed[] }
+  github?: GhMade[]
 }
 const PUSH = /\bgit\b[^;&|]*\bpush\b/
+// A gh command that makes something on GitHub: noted once it runs, so undo can offer to take it away.
+const GH_CREATE = /\bgh\s+(repo|issue|pr|release)\s+create\b/
+type GhMade = { kind: 'repo' | 'issue' | 'pr' | 'release'; repo: string; number?: number; tag?: string; url: string }
+const describeGh = (g: GhMade) =>
+  g.kind === 'repo' ? `the GitHub repository ${g.repo}` : g.kind === 'release' ? `the release ${g.tag} in ${g.repo}` : `${g.kind === 'pr' ? 'pull request' : 'issue'} #${g.number} in ${g.repo}`
+
+// Runs a Backstep command that answers with { ok, detail }, however it fails.
+async function jsonRun($: EngineInterface, args: string[], timeoutMs: number, stdin?: string): Promise<{ ok: boolean; detail: string; needs?: string }> {
+  const ran = await $.process
+    .run(backstep(args), { timeoutMs, ...(stdin !== undefined ? { stdin } : {}) })
+    .catch((err: unknown) => ({ exitCode: 1, stdout: '', stderr: err instanceof Error ? err.message : String(err) }))
+  try {
+    return JSON.parse(ran.stdout) as { ok: boolean; detail: string; needs?: string }
+  } catch {
+    return { ok: false, detail: (ran.stderr || 'it failed').trim().split('\n').at(-1) ?? 'it failed' }
+  }
+}
+
+const ghUndo = ($: EngineInterface, g: GhMade) => jsonRun($, ['gh-undo'], 120_000, JSON.stringify(g))
+
+// Asks, for each thing Claude made on GitHub in the undone turns, whether to take it away there too.
+// Returns the repositories deleted, whose pushes then need no undo of their own.
+async function offerGithubUndo($: EngineInterface, outcomes: Outcome[]): Promise<Set<string>> {
+  const gone = new Set<string>()
+  for (const g of outcomes.flatMap((o) => (o.ok && o.github ? o.github : []))) {
+    const yes = g.kind === 'repo' ? 'Delete it' : g.kind === 'issue' || g.kind === 'pr' ? 'Close it' : 'Delete it'
+    const answer = await $.ui
+      .ask(`Claude created ${describeGh(g)}. ${yes === 'Close it' ? 'Close' : 'Delete'} it on GitHub too?`, { header: 'Backstep', options: [yes, 'Leave it'] })
+      .catch(() => null)
+    if (answer !== yes) {
+      $.ui.log(`${MARK_TEXT} Not undone on GitHub: ${describeGh(g)} stays (you chose to leave it).`)
+      continue
+    }
+    let r = await ghUndo($, g)
+    // gh's sign-in needs one more permission: get it on GitHub's own page, then try again.
+    if (!r.ok && r.needs) {
+      $.ui.toast("GitHub needs your OK first. Backstep opened GitHub in your browser and copied the code: paste it there and press Authorize.", { timeoutMs: 15_000 })
+      $.ui.log(`${MARK_TEXT} GitHub needs your OK first: Backstep opened the approval page and copied the code to your clipboard. Paste it and press Authorize.`)
+      const granted = await jsonRun($, ['gh-auth', r.needs], 600_000)
+      r = granted.ok ? await ghUndo($, g) : { ok: false, detail: `GitHub didn't give the OK (${granted.detail}), so ${describeGh(g)} is still there` }
+    }
+    if (r.ok && g.kind === 'repo') gone.add(g.repo)
+    $.ui.log(r.ok ? `${MARK_TEXT} On GitHub: ${r.detail}.` : `${MARK_TEXT} Not undone on GitHub: ${r.detail}`)
+    $.ui.toast(r.ok ? `Backstep ${r.detail}.` : `Backstep ${r.detail}`)
+  }
+  return gone
+}
 
 const PUSH_ASK = { yes: 'Push the undo', no: 'Leave it as it is' }
 
 // Undo rewound the code here; this asks before taking it back on GitHub too,
 // as a new commit that undoes Claude's (never a force push).
-async function offerPushUndo($: EngineInterface, outcomes: Outcome[]) {
+async function offerPushUndo($: EngineInterface, outcomes: Outcome[], repoGone = false) {
   for (const o of outcomes) {
     if (!o.ok || !o.pushed) continue
+    // The repository it went to is deleted: nothing left there to undo.
+    if (repoGone) continue
     for (const p of o.pushed.pushes) {
       const what =
         p.before === null
           ? `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 +137,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 +159,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 +168,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 +224,29 @@ 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, 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)
+  const kept = taken
+    .flatMap((t) => t.lostItems ?? [])
+    .filter((l) => !(offered && /pushes to a remote/.test(l)) && !(offeredGh && /changes GitHub/.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,32 +256,38 @@ 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.`,
     )
   }
 
-  // Asked once the band shows what came back.
-  void offerPushUndo($, outcomes)
+  // Asked once the band shows what came back: GitHub things first, then pushes.
+  void offerGithubUndo($, outcomes).then((gone) => offerPushUndo($, outcomes, gone.size > 0))
 
-  // Reveal the restored items one by one, then fold the band away.
+  // Reveal the items one by one. The list stays until the person's next
+  // message (it's in the conversation too), so nothing is missed.
   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, () => {
-    reveal.cancel()
-    void update($, rewind, () => null)
-  })
+  $.clock.after(90 * (items.length + 2), () => reveal.cancel())
 }
 
 type Next = (e: Record<string, unknown>) => Promise<{ deny?: string; isError?: true; result?: unknown; text?: string }>
@@ -257,7 +334,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 +351,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 +368,41 @@ 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", cut to `max`.
+const quoted = (t: Turn, max = 40) => {
+  const p = (t.prompt ?? '').replace(/\s+/g, ' ').trim()
+  return p ? ` "${p.length > max ? `${p.slice(0, max - 1)}…` : p}"` : ''
+}
+const named = (t: Turn) => (t.prompt ? ` (${quoted(t).trim()})` : '')
+
+// 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).
@@ -332,7 +444,7 @@ async function checkCoverage($: EngineInterface, cwd: string) {
   const found = await $.process.run(backstep(['connect', '--dir', cwd, '--json', '--auto']), { timeoutMs: 120_000 }).catch(() => null)
   try {
     for (const c of JSON.parse(found?.stdout || '[]') as Connected[]) {
-      if (c.service === 'supabase' && c.state === 'ask') await askSupabase($, c.dir ?? cwd)
+      if (c.state === 'ask') await askDatabase($, c.dir ?? cwd, c.service)
       if (c.state === 'added') $.ui.toast('Backstep added Firebase for this project, so Claude can reach it and its changes can be undone. Restart Claude Code to use it.')
     }
   } catch {
@@ -360,36 +472,45 @@ const ASK = {
 // Projects asked about this session: "Not now" means not again until the next one.
 const asked = new Set<string>()
 
-// Asked when Claude Code opens a project that uses Supabase, or Claude is about
-// to change one, and Backstep isn't connected to it; the answer is the only
-// thing that connects it.
-async function askSupabase($: EngineInterface, cwd: string) {
-  if (asked.has(cwd)) return
-  asked.add(cwd)
+// How each database is named in the question, and what the answer connects.
+const DB_NAME: Record<string, string> = { supabase: 'Supabase', postgres: 'a Postgres database', firebase: 'Firebase' }
+
+// Asked when Claude Code opens a project that uses a database (Supabase, other
+// Postgres, Firebase), or Claude is about to change one, and Backstep isn't
+// connected to it; the answer is the only thing that connects it.
+async function askDatabase($: EngineInterface, cwd: string, service = 'supabase') {
+  const key = `${service}:${cwd}`
+  if (asked.has(key)) return
+  asked.add(key)
+  const name = DB_NAME[service] ?? service
   const answer = await $.ui
-    .ask("This project uses Supabase, but Backstep isn't connected to it, so Claude's changes to its database can't be undone. Connect it?", {
+    .ask(`This project uses ${name}, but Backstep isn't connected to it, so Claude's changes to it can't be undone. Connect it?`, {
       header: 'Backstep',
       options: [ASK.connect, ASK.later, ASK.never],
     })
     .catch(() => null)
   if (answer === ASK.never) {
-    await $.process.run(backstep(['connect', 'supabase', '--dir', cwd, '--dismiss'])).catch(() => null)
+    await $.process.run(backstep(['connect', service, '--dir', cwd, '--dismiss'])).catch(() => null)
     return
   }
   if (answer !== ASK.connect) return
-  const ran = await $.process.run(backstep(['connect', 'supabase', '--dir', cwd, '--json']), { timeoutMs: 120_000 }).catch(() => null)
-  let s: Connected | undefined
+  const ran = await $.process.run(backstep(['connect', service, '--dir', cwd, '--json']), { timeoutMs: 120_000 }).catch(() => null)
+  let all: Connected[] = []
   try {
-    s = (JSON.parse(ran?.stdout || '[]') as Connected[])[0]
+    all = JSON.parse(ran?.stdout || '[]') as Connected[]
   } catch {
-    s = undefined
+    all = []
   }
-  if (s?.state === 'connected' || s?.state === 'covered') {
-    $.ui.toast(`Backstep ${s.detail}. Claude's changes to its database can now be undone.`)
+  const s = all.find((c) => c.state === 'connected' || c.state === 'covered') ?? all.find((c) => c.state === 'needs')
+  if (s && (s.state === 'connected' || s.state === 'covered')) {
+    $.ui.toast(`Backstep ${s.detail}.`)
+    $.ui.log(`${MARK_TEXT} Backstep ${s.detail}.`)
     return
   }
-  // Nothing in the project to connect with: a sign-in is needed, and Claude walks the person through it.
-  $.ui.toast('Backstep needs a Supabase sign-in for this. Ask Claude to "connect Backstep to Supabase" and it will walk you through it.')
+  // What's still needed, said where it stays.
+  const need = s?.detail ?? `ask Claude to "connect Backstep to ${service}"`
+  $.ui.log(`${MARK_TEXT} Not connected to ${name} yet: ${need}`)
+  $.ui.toast(service === 'supabase' ? 'Backstep needs a Supabase sign-in for this. Ask Claude to "connect Backstep to Supabase" and it will walk you through it.' : `Backstep isn't connected to ${name} yet: ${need}`)
 }
 
 const UPDATE = { yes: 'Update', later: 'Not now', skip: 'Skip this version' }
@@ -534,7 +655,10 @@ 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))
+    // The last undo's list has been seen: the band goes back to the undo line.
+    const shown = await read($, rewind)
+    if (shown && shown.phase !== 'running') await update($, rewind, () => null)
+    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 +684,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') {
@@ -572,8 +698,8 @@ export const register: Register = (on, options) => {
       // so it can be saved before the command runs.
       const checked = await $.process.run(backstep(['db-check', '--cwd', cwd, '--', command])).catch(() => null)
       try {
-        const ask = (JSON.parse(checked?.stdout || '{}') as { ask?: string | null }).ask
-        if (ask) await askSupabase($, ask)
+        const { ask, service } = JSON.parse(checked?.stdout || '{}') as { ask?: string | null; service?: string | null }
+        if (ask) await askDatabase($, ask, service ?? 'supabase')
       } catch {
         // can't tell: run it as before
       }
@@ -590,14 +716,20 @@ 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)) {
+      if (plan?.id && (PUSH.test(command) || GH_CREATE.test(command))) {
         const r = await next(e)
-        await $.process.run(backstep(['shell-end', plan.id])).catch(() => null)
+        await $.process.run(backstep(['shell-end', plan.id]), { stdin: r.text ?? '' }).catch(() => null)
         return r
       }
     } else if (tool.startsWith('mcp__')) {
@@ -626,41 +758,84 @@ 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) {
+      // Laid out a line at a time, so nothing gets squeezed into columns on a narrow terminal.
+      const cancel = (
+        <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
+          cancel
+        </Button>
+      )
+      // The last turn only committed and pushed: the work it saved is what the person most likely wants back.
+      if (before) {
+        return (
+          <Box flexDirection="column">
+            <Box>
+              <Text bold>◀</Text>
+              <Text color={PINK} bold>◀</Text>
+              <Text color="warning" bold>{' That turn only saved and pushed to git.'}</Text>
+            </Box>
+            <Text dimColor>{`   Undo it and the turn before it${quoted(before, 50)}?`}</Text>
+            <Box>
+              <Text>{'   '}</Text>
+              <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
+                {`${label} again to undo both`}
+              </Button>
+              <Text dimColor>{'  ·  '}</Text>
+              <Button key="just" plain dimColor onPress={() => void update($, armed, () => null).then(() => undoLastTurn($, 1))}>
+                just the push
+              </Button>
+              <Text dimColor>{'  ·  '}</Text>
+              {cancel}
+            </Box>
+          </Box>
+        )
+      }
       return (
-        <Box>
-          <Text bold>◀</Text>
-          <Text color={PINK} bold>◀</Text>
-          <Text color="warning" bold> Undo Claude's last turn? </Text>
-          <Text dimColor>{summary(target)}  </Text>
-          <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
-            {`${label} again to undo`}
-          </Button>
-          <Text dimColor>  ·  </Text>
-          <Button key="cancel" plain dimColor onPress={() => void update($, armed, () => null)}>
-            cancel
-          </Button>
+        <Box flexDirection="column">
+          <Box>
+            <Text bold>◀</Text>
+            <Text color={PINK} bold>◀</Text>
+            <Text color="warning" bold>{" Undo Claude's last turn?"}</Text>
+          </Box>
+          <Text dimColor>{`   ${quoted(target, 50).trim() || 'That turn'} · ${summary(target)}`}</Text>
+          <Box>
+            <Text>{'   '}</Text>
+            <Button key="undo" action={UNDO_ACTION} plain onPress={() => void pressUndo($)}>
+              {`${label} again to undo`}
+            </Button>
+            <Text dimColor>{'  ·  '}</Text>
+            {cancel}
+          </Box>
         </Box>
       )
     }
@@ -673,7 +848,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:${quoted(target, 28)} · ${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.13",
   "description": "Undo for everything your agents touch: an MCP proxy that makes agent actions reversible.",
   "scripts": {
     "dev": "node src/cli.ts",