backstep 0.0.0-stage → 0.1.0

package/mod/hooks/register.test.tsx

@@ -0,0 +1,432 @@
+import { expect, mock, test } from 'claude-code/testing'
+import type { On } from 'claude-code'
+
+const BAND = {
+  plugin: 'backstep',
+  component: 'AbovePrompt',
+  props: { hasSurvey: false, isWorking: false, maxRows: 10, bodyColumns: 100, scroll: { offset: 0, bodyRows: 10 }, view: {} },
+} as const
+
+const CLI = '/opt/backstep/cli.js'
+
+// The engine beneath the mod: a repo at /repo, and a Backstep CLI whose
+// `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 prompts: { text: string; context?: readonly string[] }[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  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: '' }
+    return { value: { exitCode: r.exitCode, stdout: r.stdout, stderr: r.stderr ?? '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('tool.call', () => ({ result: {} }))
+  on('prompt.submit', (_, e) => {
+    prompts.push({ text: e.text, context: e.context })
+    return { text: e.text, context: e.context }
+  })
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+  return { runs, prompts }
+}
+
+test('an edit is snapshotted and the band offers to undo the turn', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { runs } = engine(on, { exitCode: 0, stdout: '[]' })
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/a.ts', old_string: 'a', new_string: 'b' })
+  await $.tool.call({ tool: 'Bash', command: 'ls' })
+
+  expect(runs).toEqual([
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'snap', '--session', 's1', '--tool', 'Edit', '--cwd', '/repo', '--', '/repo/src/a.ts'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'shell', '--session', 's1', '--cwd', '/repo', '--', 'ls'],
+  ])
+
+  for (const surface of ['terminal', 'desktop'] as const) {
+    const ui = await $.ui.mount({ ...BAND, surface })
+    expect((await ui.find({ type: 'Text', text: /Last turn/ }))?.text).toContain('1 edit to 1 file')
+    expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
+    await ui.unmount()
+  }
+})
+
+test('pressing undo rewinds the turn and tells Claude on the next prompt', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, prompts } = engine(on, {
+    exitCode: 0,
+    stdout: JSON.stringify([{ id: 'c1', tool: 'Edit', ok: true, detail: 'restored /repo/src/a.ts' }]),
+  })
+
+  await $.prompt.submit({ text: 'fix it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Edit', file_path: '/repo/src/a.ts', old_string: 'a', new_string: 'b' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.settle()
+  expect((await ui.find({ type: 'Text', text: /Rewinding/ }))?.text).toBeTruthy()
+  expect(runs.at(-1)).toEqual(['node', '--disable-warning=ExperimentalWarning', CLI, 'undo', '--since', '5000', '--json', '--via-claude-code'])
+
+  await clock.advance(1000)
+  await pressed
+  expect((await ui.find({ type: 'Text', text: /Rewound/ }))?.text).toContain('Rewound 1 change from the last turn.')
+  expect((await ui.find({ type: 'Text', text: /src\/a\.ts restored/ }))).toBeTruthy()
+
+  // The band folds away, and with the turn undone nothing is left to offer.
+  await clock.advance(5000)
+  expect(await ui.find({ type: 'Button', key: 'undo' })).toBeFalsy()
+  await ui.unmount()
+
+  await $.prompt.submit({ text: 'try again', wait: false, origin: { kind: 'composer' } })
+  const note = prompts.at(-1)?.context?.at(-1) ?? ''
+  expect(note).toContain('These changes were reverted:\n- src/a.ts restored')
+
+  // The note rides along once.
+  await $.prompt.submit({ text: 'and again', wait: false, origin: { kind: 'composer' } })
+  expect(prompts.at(-1)?.context ?? []).toEqual([])
+})
+
+test('a change that cannot be undone stops the rewind and says so', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { prompts } = engine(on, {
+    exitCode: 1,
+    stdout: JSON.stringify([
+      { id: 'c2', tool: 'mcp__db__query', ok: true, detail: 'restored row 4' },
+      { id: 'c1', tool: 'mcp__db__query', ok: false, detail: 'row changed since' },
+    ]),
+  })
+
+  await $.prompt.submit({ text: 'migrate', wait: false, origin: { kind: 'composer' } })
+  // A server wrapped by backstep; its name isn't among this machine's connected tools.
+  await $.tool.call({ tool: 'mcp__db__query', sql: 'update t set x = 1' } as never)
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'desktop' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  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)
+  expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
+  await ui.unmount()
+  expect(prompts).toHaveLength(1)
+})
+
+test('with nothing to undo the band leaves the space to the engine', async ($, on) => {
+  engine(on, { exitCode: 0, stdout: '[]' })
+
+  await $.prompt.submit({ text: 'hi', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'ls' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text' }))?.text).toBe('engine')
+  await ui.unmount()
+})
+
+test('a shell command is snapshotted and counts toward the turn', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  engine(on, { exitCode: 0, stdout: '[]' }, { kind: 'write', id: 'a1', undoable: true })
+
+  await $.prompt.submit({ text: 'clean up', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'rm -rf build' })
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text', text: /Last turn/ }))?.text).toContain('1 shell command')
+  expect(await ui.find({ type: 'Button', key: 'undo' })).toBeTruthy()
+  await ui.unmount()
+})
+
+test('a command that reaches outside runs right away', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { runs } = engine(on, { exitCode: 0, stdout: '[]' }, { kind: 'outbound', reason: 'pushes to a remote', id: 'a2', undoable: true })
+
+  await $.prompt.submit({ text: 'ship', wait: false, origin: { kind: 'composer' } })
+  const result = await $.tool.call({ tool: 'Bash', command: 'git push' })
+  expect(result.deny).toBeUndefined()
+  expect(runs.some((r) => r.includes('cancel'))).toBe(false)
+})
+
+test('servers added since setup are wrapped as a session starts', { options: { cli: CLI } }, async ($, on) => {
+  const runs: string[][] = []
+  const toasts: string[] = []
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const stdout = e.argv.includes('connect')
+      ? JSON.stringify([{ service: 'supabase', state: 'covered', detail: 'already connected' }])
+      : e.argv.includes('status')
+      ? JSON.stringify({ items: [{ name: 'Supabase', level: 'connect', detail: 'not connected' }, { name: 'Notion', level: 'recorded', detail: 'x' }], suggest: [] })
+      : JSON.stringify([{ name: 'linear', done: true }, { name: 'youtube', done: false }])
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  const tools: string[] = []
+  on('tool.register', (_, e) => {
+    tools.push(e.name)
+    return { value: { tool: `mcp__backstep__${e.name}` } }
+  })
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await new Promise((r) => setTimeout(r, 10))
+  expect(tools).toEqual(['connect'])
+  expect(runs).toEqual([
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'wrap-servers', '--project', '/repo', '--json'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'connect', '--dir', '/repo', '--json', '--auto'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'ping'],
+    ['node', '--disable-warning=ExperimentalWarning', CLI, 'status', '--quick', '--json', '--dir', '/repo'],
+  ])
+  expect(toasts.find((t) => t.includes('linear is now behind Backstep'))).toBeTruthy()
+  // Supabase gets its own question, and only in a project that uses it.
+  expect(toasts.find((t) => t.includes('Supabase'))).toBeFalsy()
+})
+
+// A claude.ai connector: Backstep can't sit in front of it, so the mod reports
+// the call and, on undo, runs the rule's opposite call through Claude Code.
+function connector(on: On, opts: { start: object; undoable: boolean; mcpFails?: boolean }) {
+  const runs: { argv: string[]; stdin?: string }[] = []
+  const calls: { server: string; tool: string; args: Record<string, unknown> }[] = []
+  const ran: Record<string, unknown>[] = []
+  const toasts: string[] = []
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('process.run', (_, e) => {
+    runs.push({ argv: [...e.argv], stdin: e.init?.stdin })
+    const out = e.argv.includes('watch-start')
+      ? opts.start
+      : e.argv.includes('watch-end')
+        ? { undoable: opts.undoable }
+        : e.argv.includes('undo')
+          ? [{ id: 'w1', tool: 'create-page', ok: true, detail: 'runs archive-page', run: { server: 'claude_ai_Notion', tool: 'archive-page', args: { id: 'p1' } } }]
+          : null
+    return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('mcp.call', (_, e) => {
+    calls.push({ server: e.server, tool: e.tool, args: e.args })
+    return { value: { content: [{ type: 'text', text: opts.mcpFails ? 'no such page' : 'archived' }], isError: opts.mcpFails === true } }
+  })
+  on('tool.call', (_, e) => {
+    ran.push({ ...e })
+    return { result: { content: [{ type: 'text', text: '{"id":"p1"}' }] }, text: '{"id":"p1"}' }
+  })
+  on('prompt.submit', (_, e) => ({ text: e.text, context: e.context }))
+  on('ui.render', ($, e) => {
+    const { Text } = $.ui.resolve(e)
+    return <Text>engine</Text>
+  })
+  return { runs, calls, ran, toasts }
+}
+
+test('a connector call with an undo rule is undone through Claude Code', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const { runs, calls } = connector(on, { start: { kind: 'reversible', id: 'w1' }, undoable: true })
+
+  await $.prompt.submit({ text: 'make a page', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'mcp__claude_ai_Notion__create-page', title: 'Plan', tool_use_id: 'tu1' } as never)
+
+  expect(runs[0].argv.slice(3)).toEqual(['watch-start', '--session', 's1', '--cwd', '/repo', '--', 'mcp__claude_ai_Notion__create-page'])
+  expect(JSON.parse(runs[0].stdin ?? '')).toEqual({ title: 'Plan' })
+  expect(runs[1].argv.slice(3)).toEqual(['watch-end', 'w1'])
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  expect((await ui.find({ type: 'Text', text: /Last turn/ }))?.text).toContain('1 tool action')
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  expect(runs.find((r) => r.argv.includes('undo'))?.argv).toContain('--via-claude-code')
+  expect(calls).toEqual([{ server: 'claude_ai_Notion', tool: 'archive-page', args: { id: 'p1' } }])
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['settle', 'w1'])
+  expect((await ui.find({ type: 'Text', text: /Rewound/ }))?.text).toContain('Rewound 1 change')
+  await ui.unmount()
+})
+
+test('when the opposite call fails, the rewind says so', { 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 })
+
+  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)
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  const pressed = ui.press({ key: 'undo' })
+  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()
+  await ui.unmount()
+})
+
+test('a connector delete runs right away and is recorded', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { runs } = connector(on, { start: { kind: 'irreversible', id: 'w2', reason: "deletes something Backstep can't bring back" }, undoable: false })
+
+  await $.prompt.submit({ text: 'tidy', wait: false, origin: { kind: 'composer' } })
+  const result = await $.tool.call({ tool: 'mcp__claude_ai_Notion__delete-page', id: 'p1' } as never)
+  expect(result.deny).toBeUndefined()
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['watch-end', 'w2'])
+})
+
+test('a Supabase drop runs as Backstep rewrote it', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const moved = 'ALTER TABLE "public"."customers" RENAME TO "w3_0_customers"'
+  const { ran } = connector(on, { start: { kind: 'reversible', id: 'w3', args: { query: moved } }, undoable: true })
+
+  await $.prompt.submit({ text: 'clean up', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'mcp__claude_ai_Supabase__execute_sql', project_id: 'abc', query: 'DROP TABLE customers' } as never)
+  expect(ran[0]).toMatchObject({ project_id: 'abc', query: moved })
+})
+
+test('an unconnected Supabase change says how to fix it, once', { options: { cli: CLI } }, async ($, on) => {
+  mock.clock(on, { now: 5000 })
+  const { toasts } = connector(on, { start: { kind: 'write', id: 'w4', hint: 'supabase' }, undoable: false })
+
+  await $.prompt.submit({ text: 'clean up', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'mcp__claude_ai_Supabase__execute_sql', project_id: 'abc', query: 'DELETE FROM t' } as never)
+  await $.tool.call({ tool: 'mcp__claude_ai_Supabase__execute_sql', project_id: 'abc', query: 'DELETE FROM u' } as never)
+  expect(toasts).toHaveLength(1)
+  expect(toasts[0]).toContain('Ask Claude to connect Backstep to Supabase')
+})
+
+test('asking Claude to connect runs backstep connect, with the connection string on stdin', { options: { cli: CLI } }, async ($, on) => {
+  const runs: { argv: string[]; stdin?: string }[] = []
+  const toasts: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    runs.push({ argv: [...e.argv], stdin: e.init?.stdin })
+    const stdout = JSON.stringify([{ service: 'supabase', state: 'connected', detail: 'connected project abc' }])
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+
+  const url = 'postgresql://postgres:secret@db.abcdefghijklmnopqrst.supabase.co:5432/postgres'
+  const r = await $.tool.call({ tool: 'mcp__backstep__connect', service: 'supabase', connection_string: url } as never)
+  expect(runs).toHaveLength(1)
+  expect(runs[0].argv.slice(3)).toEqual(['connect', 'supabase', '--dir', '/repo', '--json', '--stdin'])
+  expect(runs[0].argv.join(' ')).not.toContain('secret')
+  expect(runs[0].stdin).toBe(url)
+  expect(r.result).toBe('Supabase (connected): connected project abc')
+  expect(toasts).toHaveLength(1)
+})
+
+// A project that uses Supabase, not connected: Backstep asks, and only the answer connects it.
+function supabaseProject(on: On, answer: string, connectResult: object) {
+  const runs: string[][] = []
+  const toasts: string[] = []
+  const asked: string[] = []
+  on('process.run', (_, e) => {
+    runs.push([...e.argv])
+    const stdout = e.argv.includes('--auto')
+      ? JSON.stringify([{ service: 'supabase', state: 'ask', detail: "this project uses Supabase, but Backstep isn't connected to it" }])
+      : e.argv.includes('status')
+        ? JSON.stringify({ items: [], suggest: [] })
+        : e.argv.includes('connect') && e.argv.includes('--json')
+          ? JSON.stringify([connectResult])
+          : '[]'
+    return { value: { exitCode: 0, stdout, stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('tool.register', (_, e) => ({ value: { tool: `mcp__backstep__${e.name}` } }))
+  on('tool.call', { tool: 'AskUserQuestion' }, (_, e) => {
+    const questions = (e as unknown as { questions: { question: string }[] }).questions
+    asked.push(questions[0].question)
+    return { result: { questions, answers: { [questions[0].question]: answer } } }
+  })
+  on('session.start', (_, e) => ({ cwd: e.cwd }))
+  return { runs, toasts, asked }
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 20))
+
+test('a Supabase project that is not connected is asked about, and Connect connects it', { options: { cli: CLI } }, async ($, on) => {
+  const { runs, toasts, asked } = supabaseProject(on, 'Connect', { service: 'supabase', state: 'connected', detail: 'connected project abc' })
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await settle()
+  expect(asked).toHaveLength(1)
+  expect(runs.some((r) => r.slice(3).join(' ') === 'connect supabase --dir /repo --json')).toBe(true)
+  expect(toasts.find((t) => t.includes('connected project abc'))).toBeTruthy()
+})
+
+test('Not now connects nothing', { options: { cli: CLI } }, async ($, on) => {
+  const { runs } = supabaseProject(on, 'Not now', {})
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await settle()
+  expect(runs.filter((r) => r.includes('connect') && !r.includes('--auto'))).toHaveLength(0)
+})
+
+test("Don't ask for this project remembers it", { options: { cli: CLI } }, async ($, on) => {
+  const { runs } = supabaseProject(on, "Don't ask for this project", {})
+  await $.session.start({ cwd: '/repo', surface: 'terminal', hasPerson: true } as never)
+  await settle()
+  expect(runs.some((r) => r.slice(3).join(' ') === 'connect supabase --dir /repo --dismiss')).toBe(true)
+})
+
+test('after undoing a turn that pushed, Backstep asks and pushes the undo', { options: { cli: CLI } }, async ($, on) => {
+  const clock = mock.clock(on, { now: 5000 })
+  const push = { remote: 'origin', branch: 'main', before: 'aaa', after: 'bbb', commits: 2, host: 'GitHub' }
+  const runs: { argv: string[]; stdin?: string }[] = []
+  const toasts: string[] = []
+  const asked: string[] = []
+  on('session.cwd', () => ({ value: '/repo' }))
+  on('session.id', () => ({ value: 's1' }))
+  on('ui.toast', (_, e) => {
+    toasts.push(e.text)
+    return { value: undefined }
+  })
+  on('process.run', (_, e) => {
+    runs.push({ argv: [...e.argv], stdin: e.init?.stdin })
+    const out = e.argv.includes('shell')
+      ? { kind: 'outbound', reason: 'pushes to a remote', id: 'p1', undoable: true }
+      : e.argv.includes('undo')
+        ? [{ id: 'p1', tool: 'Bash', ok: true, detail: 'restored main', pushed: { root: '/repo', pushes: [push] } }]
+        : e.argv.includes('revert-push')
+          ? { ok: true, detail: "pushed a commit to origin/main that undoes Claude's 2 commits" }
+          : null
+    return { value: { exitCode: 0, stdout: out ? JSON.stringify(out) : '', stderr: '', isStdoutTruncated: false, isStderrTruncated: false } }
+  })
+  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]: 'Push the undo' } } }
+  })
+  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>
+  })
+
+  await $.prompt.submit({ text: 'ship it', wait: false, origin: { kind: 'composer' } })
+  await $.tool.call({ tool: 'Bash', command: 'git push' })
+  // The push is noted once it has run.
+  expect(runs.at(-1)?.argv.slice(3)).toEqual(['shell-end', 'p1'])
+
+  const ui = await $.ui.mount({ ...BAND, surface: 'terminal' })
+  const pressed = ui.press({ key: 'undo' })
+  await clock.advance(1000)
+  await pressed
+  await clock.settle()
+  expect(asked[0]).toBe('Claude pushed 2 commits to main on GitHub. Undo them there too?')
+  const revert = runs.find((r) => r.argv.includes('revert-push'))
+  expect(revert?.argv.slice(3)).toEqual(['revert-push', '--root', '/repo'])
+  expect(JSON.parse(revert?.stdin ?? '{}')).toEqual(push)
+  expect(toasts.find((t) => t.includes('undoes Claude'))).toBeTruthy()
+  // The band doesn't call the push lost while it's being offered back.
+  expect((await ui.find({ type: 'Text', text: /Rewound/ }))?.text).not.toContain("couldn't be undone")
+  await ui.unmount()
+})