diff --git a/bun.lock b/bun.lock
index 6404fce15419..5b9a1fcb34ce 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1070,6 +1070,7 @@
     "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
     "@ai-sdk/amazon-bedrock@4.0.166": "patches/@ai-sdk%2Famazon-bedrock@4.0.166.patch",
     "@ai-sdk/groq@3.0.31": "patches/@ai-sdk%2Fgroq@3.0.31.patch",
+    "@opentui/core@0.4.5": "patches/@opentui%2Fcore@0.4.5.patch",
     "@ai-sdk/xai@3.0.139": "patches/@ai-sdk%2Fxai@3.0.139.patch",
     "@ai-sdk/google@3.0.73": "patches/@ai-sdk%2Fgoogle@3.0.73.patch",
     "pacote@21.5.0": "patches/pacote@21.5.0.patch",
diff --git a/package.json b/package.json
index 003e39a89fce..7eb9c166f649 100644
--- a/package.json
+++ b/package.json
@@ -164,6 +164,7 @@
     "@ai-sdk/groq@3.0.31": "patches/@ai-sdk%2Fgroq@3.0.31.patch",
     "@ai-sdk/anthropic@3.0.111": "patches/@ai-sdk%2Fanthropic@3.0.111.patch",
     "@ai-sdk/amazon-bedrock@4.0.166": "patches/@ai-sdk%2Famazon-bedrock@4.0.166.patch",
-    "@ai-sdk/openai@3.0.88": "patches/@ai-sdk%2Fopenai@3.0.88.patch"
+    "@ai-sdk/openai@3.0.88": "patches/@ai-sdk%2Fopenai@3.0.88.patch",
+    "@opentui/core@0.4.5": "patches/@opentui%2Fcore@0.4.5.patch"
   }
 }
diff --git a/packages/tui/src/component/prompt/index.tsx b/packages/tui/src/component/prompt/index.tsx
index c48c751739ce..09891a8b0ba1 100644
--- a/packages/tui/src/component/prompt/index.tsx
+++ b/packages/tui/src/component/prompt/index.tsx
@@ -33,6 +33,7 @@ import { createStore, produce, unwrap } from "solid-js/store"
 import { usePromptHistory, type PromptInfo } from "../../prompt/history"
 import { computePromptTraits } from "../../prompt/traits"
 import { expandPastedTextPlaceholders, expandTrackedPastedText } from "../../prompt/part"
+import { copyPromptParts, createPromptUndo, PromptUndoDepthDefault, type PromptUndoState } from "../../prompt/undo"
 import { usePromptStash } from "../../prompt/stash"
 import { DialogStash } from "../dialog-stash"
 import { type AutocompleteRef, Autocomplete } from "./autocomplete"
@@ -139,6 +140,10 @@ function formatEditorContext(selection: EditorSelection) {
 }
 
 let stashed: { prompt: PromptInfo; cursor: number } | undefined
+let undoDepth = PromptUndoDepthDefault
+// Shared by every prompt so that undo survives the remount after a route change, which is what
+// lets undo after a submit bring back what was sent.
+const promptUndo = createPromptUndo({ depth: () => undoDepth })
 
 export function Prompt(props: PromptProps) {
   let input: TextareaRenderable
@@ -624,6 +629,8 @@ export function Prompt(props: PromptProps) {
     }
   })
 
+  onMount(() => queueMicrotask(settleUndo))
+
   onCleanup(() => {
     if (store.prompt.input) {
       stashed = { prompt: unwrap(store.prompt), cursor: input.cursorOffset }
@@ -655,6 +662,53 @@ export function Prompt(props: PromptProps) {
     }
   })
 
+  // Edits are recorded once the change that caused them has finished, so that text, parts and caret
+  // that are updated one after another are seen together. The text and parts the prompt sets
+  // itself while mounting, and on undo and redo, are not edits.
+  let undoApplying = true
+  let undoObserveQueued = false
+  undoDepth = tuiConfig.prompt?.undo_depth ?? PromptUndoDepthDefault
+
+  function undoState(): PromptUndoState {
+    return {
+      input: store.prompt.input,
+      parts: copyPromptParts(unwrap(store.prompt.parts)),
+      mode: store.mode,
+      cursor: input.cursorOffset,
+    }
+  }
+
+  function observeUndo() {
+    if (undoObserveQueued) return
+    undoObserveQueued = true
+    queueMicrotask(() => {
+      undoObserveQueued = false
+      if (undoApplying || !input || input.isDestroyed) return
+      promptUndo.observe(undoState())
+    })
+  }
+
+  function settleUndo() {
+    undoApplying = false
+    if (!input || input.isDestroyed) return
+    promptUndo.sync(undoState())
+  }
+
+  function stepUndo(direction: "undo" | "redo") {
+    if (!input || input.isDestroyed) return
+    if (!undoApplying) promptUndo.observe(undoState())
+    const current = undoState()
+    const target = direction === "undo" ? promptUndo.undo(current) : promptUndo.redo(current)
+    if (!target) return
+    undoApplying = true
+    input.setText(target.input)
+    setStore("prompt", { input: target.input, parts: copyPromptParts(target.parts) })
+    setStore("mode", target.mode)
+    restoreExtmarksFromParts(store.prompt.parts)
+    input.cursorOffset = target.cursor
+    queueMicrotask(settleUndo)
+  }
+
   function restoreExtmarksFromParts(parts: PromptInfo["parts"]) {
     input.extmarks.clear()
     setStore("extmarkToPartIndex", new Map())
@@ -805,6 +859,19 @@ export function Prompt(props: PromptProps) {
     }
   })
 
+  // Replaces the textarea's own undo and redo, which know nothing of the prompt's attachments and
+  // pasted text, and lose everything on submit.
+  useBindings(() => {
+    return {
+      target: inputTarget,
+      enabled: inputTarget() !== undefined && !props.disabled,
+      commands: [
+        { name: "input.undo", title: "Undo in prompt", category: "Prompt", run: () => stepUndo("undo") },
+        { name: "input.redo", title: "Redo in prompt", category: "Prompt", run: () => stepUndo("redo") },
+      ],
+    }
+  })
+
   useBindings(() => {
     return {
       target: inputTarget,
@@ -1380,8 +1447,12 @@ export function Prompt(props: PromptProps) {
                 auto()?.onInput(value)
                 syncExtmarksWithPromptParts()
                 setCursorVersion((value) => value + 1)
+                observeUndo()
+              }}
+              onCursorChange={() => {
+                setCursorVersion((value) => value + 1)
+                observeUndo()
               }}
-              onCursorChange={() => setCursorVersion((value) => value + 1)}
               onKeyDown={(e: { preventDefault(): void }) => {
                 if (props.disabled) {
                   e.preventDefault()
diff --git a/packages/tui/src/config/index.tsx b/packages/tui/src/config/index.tsx
index bde0bfb0718a..79556692a9f2 100644
--- a/packages/tui/src/config/index.tsx
+++ b/packages/tui/src/config/index.tsx
@@ -56,7 +56,11 @@ export const Prompt = Schema.Struct({
   max_width: Schema.optional(Schema.Union([PromptSize, Schema.Literal("auto")])).annotate({
     description: "Home prompt max width: a positive integer for a fixed cap, or 'auto' to scale with terminal width",
   }),
-}).annotate({ description: "Prompt size settings" })
+  undo_depth: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))).annotate({
+    description:
+      "How many steps of prompt edits input_undo can take back (default: 500). Typing is grouped by word, and a paste, a line delete or a submit is one step",
+  }),
+}).annotate({ description: "Prompt settings" })
 
 export const Info = Schema.Struct({
   $schema: Schema.optional(Schema.String),
diff --git a/packages/tui/src/prompt/undo.ts b/packages/tui/src/prompt/undo.ts
new file mode 100644
index 000000000000..4377d61cc630
--- /dev/null
+++ b/packages/tui/src/prompt/undo.ts
@@ -0,0 +1,153 @@
+import type { PromptInfo } from "./history"
+
+export type PromptUndoState = {
+  input: string
+  parts: PromptInfo["parts"]
+  mode: "normal" | "shell"
+  cursor: number
+}
+
+export const PromptUndoDepthDefault = 500
+export const PromptUndoPauseMs = 1000
+
+type Change = "insert" | "delete" | "bulk"
+
+// The prompt's undo history. Each entry is the prompt as it was before a group of edits.
+//
+// Typing coalesces into groups that end where a new word starts, after a pause, when the caret
+// moves, or when typing switches between inserting and deleting. Anything else - a paste, a word
+// or line delete, a newline, clearing or submitting the prompt, recalling history - is a group of
+// its own. A long paragraph comes back a word at a time, and one ctrl+u comes back in one step.
+//
+// It lives outside any one prompt component, because the prompt is remounted when the route
+// changes, and undo after a submit brings back what was sent.
+export function createPromptUndo(options?: { depth?: () => number; now?: () => number }) {
+  const depth = () => options?.depth?.() ?? PromptUndoDepthDefault
+  const now = options?.now ?? Date.now
+  const undoStack: PromptUndoState[] = []
+  const redoStack: PromptUndoState[] = []
+  let last: PromptUndoState | undefined
+  let lastChange: Change | undefined
+  let lastTime = 0
+  let breakNext = true
+
+  function push(state: PromptUndoState) {
+    undoStack.push(state)
+    if (undoStack.length > depth()) undoStack.splice(0, undoStack.length - depth())
+    redoStack.length = 0
+  }
+
+  function restart(state: PromptUndoState) {
+    last = state
+    lastChange = undefined
+    breakNext = true
+  }
+
+  return {
+    // The prompt after an edit or a caret move.
+    observe(state: PromptUndoState) {
+      if (!last) return restart(state)
+      if (state.input === last.input && state.mode === last.mode) {
+        if (!sameParts(state.parts, last.parts)) {
+          push(last)
+          return restart(state)
+        }
+        if (state.cursor !== last.cursor) breakNext = true
+        last = state
+        return
+      }
+      const change = classify(last.input, state.input, state.mode !== last.mode)
+      const time = now()
+      if (
+        breakNext ||
+        change.kind === "bulk" ||
+        change.kind !== lastChange ||
+        time - lastTime > PromptUndoPauseMs ||
+        change.wordStart ||
+        change.newline
+      )
+        push(last)
+      last = state
+      lastChange = change.kind
+      lastTime = time
+      breakNext = change.kind === "bulk" || change.newline
+    },
+    // The prompt as it is now, without recording a change, after it was set by undo or redo.
+    sync: restart,
+    undo(current: PromptUndoState) {
+      const target = undoStack.pop()
+      if (!target) return
+      redoStack.push(current)
+      restart(target)
+      return target
+    },
+    redo(current: PromptUndoState) {
+      const target = redoStack.pop()
+      if (!target) return
+      undoStack.push(current)
+      restart(target)
+      return target
+    },
+    get size() {
+      return { undo: undoStack.length, redo: redoStack.length }
+    },
+  }
+}
+
+export type PromptUndo = ReturnType<typeof createPromptUndo>
+
+// Keys that arrive in one read, when typing outpaces a busy event loop, are recorded together.
+// Up to this many characters inserted at once still count as typing; a paste is usually longer.
+const TypingBurst = 16
+
+// Typing is one character deleted, or a short run inserted, at one point; any other difference is
+// a bulk change.
+function classify(before: string, after: string, modeChanged: boolean) {
+  const bulk = { kind: "bulk" as const, wordStart: false, newline: false }
+  if (modeChanged) return bulk
+  const limit = Math.min(before.length, after.length)
+  let start = 0
+  while (start < limit && before.charCodeAt(start) === after.charCodeAt(start)) start++
+  let end = 0
+  while (end < limit - start && before.charCodeAt(before.length - 1 - end) === after.charCodeAt(after.length - 1 - end))
+    end++
+  const inserted = after.slice(start, after.length - end)
+  const deleted = before.slice(start, before.length - end)
+  if (inserted && deleted) return bulk
+  if (deleted) {
+    if (Array.from(deleted).length !== 1) return bulk
+    return { kind: "delete" as const, wordStart: false, newline: deleted === "\n" }
+  }
+  if (inserted === "\n") return { kind: "insert" as const, wordStart: false, newline: true }
+  if (inserted.includes("\n") || Array.from(inserted).length > TypingBurst) return bulk
+  const chars = Array.from(inserted)
+  // A character that starts a word, after whitespace, begins a new group.
+  const wordStart = chars.some((char, index) => {
+    const previous = index === 0 ? after[start - 1] : chars[index - 1]
+    return !/\s/.test(char) && previous !== undefined && /\s/.test(previous)
+  })
+  return { kind: "insert" as const, wordStart, newline: false }
+}
+
+function sameParts(a: PromptInfo["parts"], b: PromptInfo["parts"]) {
+  if (a.length !== b.length) return false
+  return a.every((part, index) => {
+    const other = b[index]
+    if (part.type !== other.type) return false
+    if (part.type === "text" && other.type === "text") return part.text === other.text
+    if (part.type === "file" && other.type === "file") return part.url === other.url
+    if (part.type === "agent" && other.type === "agent") return part.name === other.name
+    return true
+  })
+}
+
+// A copy of the parts the store cannot change later. Positions are rewritten in place as the
+// text moves; the pasted text and file data are strings and are shared, not copied.
+export function copyPromptParts(parts: PromptInfo["parts"]): PromptInfo["parts"] {
+  return parts.map((part) => {
+    if (part.type === "agent") return part.source ? { ...part, source: { ...part.source } } : { ...part }
+    if (part.type === "file")
+      return part.source ? { ...part, source: { ...part.source, text: { ...part.source.text } } } : { ...part }
+    return part.source ? { ...part, source: { ...part.source, text: { ...part.source.text } } } : { ...part }
+  })
+}
diff --git a/packages/tui/test/component/prompt-placeholder-delete.test.tsx b/packages/tui/test/component/prompt-placeholder-delete.test.tsx
new file mode 100644
index 000000000000..01d6bc7d1219
--- /dev/null
+++ b/packages/tui/test/component/prompt-placeholder-delete.test.tsx
@@ -0,0 +1,64 @@
+/** @jsxImportSource @opentui/solid */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import type { TextareaRenderable } from "@opentui/core"
+import { testRender } from "@opentui/solid"
+
+// The prompt marks a paste placeholder with a virtual extmark. Word and line deletes go
+// through deleteRange, which @opentui/core 0.4.5 is patched to widen over a virtual
+// extmark it cuts into (anomalyco/opentui#1628).
+const placeholder = "[Pasted ~5 lines]"
+const text = `see ${placeholder} x`
+const start = "see ".length
+const end = start + placeholder.length
+
+let app: Awaited<ReturnType<typeof testRender>>
+let input: TextareaRenderable
+
+beforeAll(async () => {
+  const textarea = Promise.withResolvers<TextareaRenderable>()
+  app = await testRender(
+    () => (
+      <box width="100%">
+        <textarea width="100%" maxHeight={6} ref={textarea.resolve} />
+      </box>
+    ),
+    { width: 60, height: 10 },
+  )
+  await app.flush()
+  input = await textarea.promise
+})
+
+afterAll(() => app.renderer.destroy())
+
+function setup(cursor: number) {
+  input.setText(text)
+  const id = input.extmarks.create({ start, end, virtual: true })
+  input.cursorOffset = cursor
+  return id
+}
+
+describe("deleting a paste placeholder", () => {
+  test.each([
+    ["delete word backward", end, () => input.deleteWordBackward()],
+    ["delete word forward", start, () => input.deleteWordForward()],
+  ] as const)("%s removes the whole placeholder", (_, cursor, run) => {
+    const id = setup(cursor)
+    run()
+    expect(input.plainText).toBe("see  x")
+    expect(input.extmarks.get(id)).toBeNull()
+  })
+
+  test("delete to line end from inside the line removes the placeholder it reaches", () => {
+    const id = setup(2)
+    input.deleteToLineEnd()
+    expect(input.plainText).toBe("se")
+    expect(input.extmarks.get(id)).toBeNull()
+  })
+
+  test("a range ending inside the placeholder widens to the whole placeholder", () => {
+    const id = setup(0)
+    input.editBuffer.deleteRange(0, 2, 0, start + 3)
+    expect(input.plainText).toBe("se x")
+    expect(input.extmarks.get(id)).toBeNull()
+  })
+})
diff --git a/packages/tui/test/component/prompt-undo.test.tsx b/packages/tui/test/component/prompt-undo.test.tsx
new file mode 100644
index 000000000000..0084a83c0459
--- /dev/null
+++ b/packages/tui/test/component/prompt-undo.test.tsx
@@ -0,0 +1,189 @@
+import { expect, mock, test } from "bun:test"
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import { TextareaRenderable } from "@opentui/core"
+import { createTestRenderer } from "@opentui/core/testing"
+import { Effect } from "effect"
+import { Global } from "@opencode-ai/core/global"
+import { tmpdir } from "../fixture/fixture"
+import { createTuiResolvedConfig } from "../fixture/tui-runtime"
+import { createEventSource, createFetch, directory, json } from "../fixture/tui-sdk"
+
+const sessionID = "ses_prompt_undo"
+const session = {
+  id: sessionID,
+  title: "Prompt undo",
+  slug: sessionID,
+  projectID: "proj_test",
+  directory,
+  version: "0.0.0-test",
+  time: { created: 1_700_000_000_000, updated: 1_700_000_000_000 },
+}
+const model = { providerID: "test", modelID: "model" }
+
+// Upstream's default undo and redo keys, as a kitty-protocol terminal sends them.
+const UNDO = "\x1b[45;5u"
+const REDO = "\x1b[46;5u"
+const CTRL_U = "\x15"
+const CTRL_W = "\x17"
+
+async function wait(fn: () => boolean, timeout = 10_000) {
+  const start = Date.now()
+  while (!fn()) {
+    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
+    await Bun.sleep(10)
+  }
+}
+
+// Runs the TUI in a session whose turn is running, and hands the test a way to type into its prompt.
+async function withPrompt(
+  body: (rig: { press(bytes: string): Promise<void>; text(): string; parts(): number; paths: string[]; sent: string[] }) => Promise<void>,
+) {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, "{}")
+  const setup = await createTestRenderer({ width: 120, height: 24, useThread: false })
+  const core = await import("@opentui/core")
+  mock.module("@opentui/core", () => ({ ...core, createCliRenderer: async () => setup.renderer }))
+  const paths: string[] = []
+  const sent: string[] = []
+  const calls = createFetch((url) => {
+    paths.push(url.pathname)
+    if (url.pathname === "/session") return json([session])
+    if (url.pathname === "/session/status") return json({ [sessionID]: { type: "busy" } })
+    if (url.pathname === `/session/${sessionID}`) return json(session)
+    if (url.pathname === `/session/${sessionID}/message`) return url.searchParams.has("limit") ? json([]) : json({})
+    if (url.pathname.startsWith(`/session/${sessionID}/message/`))
+      return json({ name: "NotFoundError", data: { message: "Message not found" } }, { status: 404 })
+    if (url.pathname === `/session/${sessionID}/todo` || url.pathname === `/session/${sessionID}/diff`) return json([])
+    if (url.pathname === "/agent")
+      return json([{ name: "build", mode: "primary", permission: [], options: {}, hidden: false }])
+    if (url.pathname === "/config/providers")
+      return json({
+        providers: [
+          {
+            id: model.providerID,
+            name: "Test",
+            source: "config",
+            env: [],
+            options: {},
+            models: { [model.modelID]: { id: model.modelID, name: "Model", providerID: model.providerID } },
+          },
+        ],
+        default: { [model.providerID]: model.modelID },
+      })
+  })
+  const started = Promise.withResolvers<TuiPluginApi>()
+  const { run } = await import("../../src/app")
+  const render = async () => {
+    await setup.renderOnce()
+    await setup.renderOnce()
+  }
+
+  try {
+    const task = Effect.runPromise(
+      run({
+        url: "http://test",
+        directory,
+        config: createTuiResolvedConfig({ plugin_enabled: {} }),
+        fetch: (async (input: RequestInfo | URL, init?: RequestInit) => {
+          if (input instanceof Request && input.method === "POST" && input.url.endsWith("/message"))
+            sent.push(await input.clone().text())
+          return calls.fetch(input, init)
+        }) as typeof fetch,
+        events: createEventSource().source,
+        args: { continue: true },
+        pluginHost: {
+          async start(input) {
+            input.runtime.setupSlots(input.api)
+            started.resolve(input.api)
+          },
+          async dispose() {},
+        },
+      }).pipe(
+        Effect.provide(
+          Global.layerWith({
+            home: tmp.path,
+            data: tmp.path,
+            cache: tmp.path,
+            config: tmp.path,
+            state: tmp.path,
+            tmp: tmp.path,
+            bin: tmp.path,
+            log: tmp.path,
+            repos: tmp.path,
+          }),
+        ),
+      ),
+    )
+
+    const api = await started.promise
+    // The prompt is the focused editor; its placeholders are its virtual extmarks.
+    const editor = () => {
+      const focused = setup.renderer.currentFocusedEditor
+      return focused instanceof TextareaRenderable ? focused : undefined
+    }
+    await wait(() => {
+      void render()
+      return Boolean(editor())
+    })
+    const press = async (bytes: string) => {
+      setup.renderer.stdin.emit("data", Buffer.from(bytes))
+      await Bun.sleep(30)
+      await render()
+    }
+    // The prompt keeps its text across a remount, and so across the tests in this file.
+    const text = () => editor()?.plainText ?? ""
+    if (text()) await press("\x03")
+    await body({ press, text, parts: () => editor()?.extmarks.getVirtual().length ?? 0, paths, sent })
+    api.keymap.dispatchCommand("app.exit")
+    await task
+  } finally {
+    if (!setup.renderer.isDestroyed) setup.renderer.destroy()
+    mock.restore()
+  }
+}
+
+test("undo brings back a line deleted with ctrl+u, then the typing before it word by word", async () => {
+  await withPrompt(async (rig) => {
+    for (const char of "hello brave world") await rig.press(char)
+    await rig.press(CTRL_U)
+    expect(rig.text()).toBe("")
+    await rig.press(UNDO)
+    expect(rig.text()).toBe("hello brave world")
+    await rig.press(UNDO)
+    expect(rig.text()).toBe("hello brave ")
+    await rig.press(REDO)
+    expect(rig.text()).toBe("hello brave world")
+  })
+})
+
+test("undo after deleting a paste placeholder restores it with its pasted text", async () => {
+  await withPrompt(async (rig) => {
+    for (const char of "see ") await rig.press(char)
+    await rig.press("\x1b[200~one\ntwo\nthree\x1b[201~")
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(rig.parts()).toBe(1)
+    await rig.press("\x7f") // backspace the space after it
+    await rig.press(CTRL_W)
+    expect(rig.text()).toBe("see ")
+    expect(rig.parts()).toBe(0)
+    await rig.press(UNDO)
+    expect(rig.text()).toBe("see [Pasted ~3 lines]")
+    expect(rig.parts()).toBe(1)
+    await rig.press("\r")
+    await wait(() => rig.sent.length > 0)
+    expect(rig.sent[0]).toContain(JSON.stringify("see one\ntwo\nthree"))
+  })
+})
+
+test("undo after a submit brings back what was sent without aborting the running turn", async () => {
+  await withPrompt(async (rig) => {
+    for (const char of "second prompt") await rig.press(char)
+    await rig.press("\r")
+    await wait(() => rig.text() === "")
+    await rig.press(UNDO)
+    expect(rig.text()).toBe("second prompt")
+    expect(rig.paths.some((path) => path.endsWith("/abort"))).toBe(false)
+    await rig.press(REDO)
+    expect(rig.text()).toBe("")
+  })
+})
diff --git a/packages/tui/test/config.test.tsx b/packages/tui/test/config.test.tsx
index 37fc0033e561..a0bfc4d42e22 100644
--- a/packages/tui/test/config.test.tsx
+++ b/packages/tui/test/config.test.tsx
@@ -48,6 +48,12 @@ test("validates config constraints", () => {
   expect(decodeInfo({ attention: { sounds: { unknown: "sound.wav" } } })).toEqual({ attention: { sounds: {} } })
 })
 
+test("prompt.undo_depth takes a positive number of steps", () => {
+  expect(decodeInfo({ prompt: { undo_depth: 50 } }).prompt?.undo_depth).toBe(50)
+  expect(() => decodeInfo({ prompt: { undo_depth: 0 } })).toThrow()
+  expect(() => decodeInfo({ prompt: { undo_depth: 2.5 } })).toThrow()
+})
+
 test("resolves host-neutral defaults", () => {
   const config = resolve({}, { terminalSuspend: true })
 
diff --git a/packages/tui/test/prompt/undo.test.ts b/packages/tui/test/prompt/undo.test.ts
new file mode 100644
index 000000000000..553f599306f2
--- /dev/null
+++ b/packages/tui/test/prompt/undo.test.ts
@@ -0,0 +1,165 @@
+import { describe, expect, test } from "bun:test"
+import { copyPromptParts, createPromptUndo, PromptUndoPauseMs, type PromptUndoState } from "../../src/prompt/undo"
+
+function rig(depth?: number) {
+  let time = 0
+  const undo = createPromptUndo({ depth: depth === undefined ? undefined : () => depth, now: () => time })
+  let current: PromptUndoState = { input: "", parts: [], mode: "normal", cursor: 0 }
+  undo.observe(current)
+  const set = (input: string, extra: Partial<PromptUndoState> = {}) => {
+    current = { ...current, input, cursor: input.length, ...extra }
+    undo.observe(current)
+  }
+  return {
+    undo,
+    type(text: string) {
+      for (const char of text) {
+        time += 50
+        set(current.input + char)
+      }
+    },
+    backspace(count: number) {
+      for (let i = 0; i < count; i++) {
+        time += 50
+        set(current.input.slice(0, -1))
+      }
+    },
+    set,
+    wait: (ms: number) => void (time += ms),
+    moveCaret: (cursor: number) => {
+      current = { ...current, cursor }
+      undo.observe(current)
+    },
+    undoOnce() {
+      const target = undo.undo(current)
+      if (target) current = target
+      undo.sync(current)
+      return current.input
+    },
+    redoOnce() {
+      const target = undo.redo(current)
+      if (target) current = target
+      undo.sync(current)
+      return current.input
+    },
+  }
+}
+
+describe("prompt undo grouping", () => {
+  test("typing comes back a word at a time, not a letter at a time", () => {
+    const r = rig()
+    r.type("hello brave world")
+    expect(r.undoOnce()).toBe("hello brave ")
+    expect(r.undoOnce()).toBe("hello ")
+    expect(r.undoOnce()).toBe("")
+    expect(r.undoOnce()).toBe("")
+  })
+
+  test("a pause starts a new group inside a word", () => {
+    const r = rig()
+    r.type("hel")
+    r.wait(PromptUndoPauseMs + 1)
+    r.type("lo")
+    expect(r.undoOnce()).toBe("hel")
+  })
+
+  test("a newline is a group of its own", () => {
+    const r = rig()
+    r.type("one")
+    r.type("\n")
+    r.type("two")
+    expect(r.undoOnce()).toBe("one\n")
+    expect(r.undoOnce()).toBe("one")
+  })
+
+  test("a line delete such as ctrl+u is one step, separate from the typing before it", () => {
+    const r = rig()
+    r.type("twenty minutes of careful writing")
+    r.set("")
+    expect(r.undoOnce()).toBe("twenty minutes of careful writing")
+    expect(r.undoOnce()).toBe("twenty minutes of careful ")
+  })
+
+  test("keys that arrive together still group as typing, and a longer insert is a step of its own", () => {
+    const r = rig()
+    r.type("hello")
+    r.set("hello wo")
+    r.set("hello world")
+    expect(r.undoOnce()).toBe("hello")
+    r.set("hello" + "x".repeat(17))
+    expect(r.undoOnce()).toBe("hello")
+  })
+
+  test("a paste is one step", () => {
+    const r = rig()
+    r.type("see ")
+    r.set("see a pasted block")
+    expect(r.undoOnce()).toBe("see ")
+  })
+
+  test("backspaces coalesce, and switching between typing and deleting starts a group", () => {
+    const r = rig()
+    r.type("abcdef")
+    r.backspace(3)
+    r.type("xy")
+    expect(r.undoOnce()).toBe("abc")
+    expect(r.undoOnce()).toBe("abcdef")
+    expect(r.undoOnce()).toBe("")
+  })
+
+  test("moving the caret ends the group", () => {
+    const r = rig()
+    r.type("abc")
+    r.moveCaret(1)
+    r.set("aXbc", { cursor: 2 })
+    expect(r.undoOnce()).toBe("abc")
+  })
+
+  test("redo walks forward again and a new edit discards it", () => {
+    const r = rig()
+    r.type("one two")
+    r.undoOnce()
+    expect(r.redoOnce()).toBe("one two")
+    r.undoOnce()
+    r.type("x")
+    expect(r.redoOnce()).toBe("one x")
+  })
+
+  test("keeps only the configured number of steps", () => {
+    const r = rig(2)
+    r.type("a b c d")
+    expect(r.undoOnce()).toBe("a b c ")
+    expect(r.undoOnce()).toBe("a b ")
+    expect(r.undoOnce()).toBe("a b ")
+  })
+
+  test("a submit is undone back to what was sent, with its placeholder parts", () => {
+    const r = rig()
+    const part = {
+      type: "text" as const,
+      text: "pasted\ncontent\nhere",
+      source: { text: { start: 4, end: 21, value: "[Pasted ~3 lines]" } },
+    }
+    r.set("see [Pasted ~3 lines] ", { parts: [part] })
+    r.set("", { parts: [] })
+    r.undoOnce()
+    expect(r.redoOnce()).toBe("")
+    expect(r.undoOnce()).toBe("see [Pasted ~3 lines] ")
+  })
+
+  test("a placeholder's text changing alone is a step", () => {
+    const r = rig()
+    const part = (text: string) => ({ type: "text" as const, text, source: { text: { start: 0, end: 3, value: "[P]" } } })
+    r.set("[P]", { parts: [part("old")] })
+    r.set("[P]", { parts: [part("new")] })
+    const target = r.undo.undo({ input: "[P]", parts: [part("new")], mode: "normal", cursor: 3 })
+    expect(target?.parts).toEqual([part("old")])
+  })
+})
+
+test("copyPromptParts is unaffected by later edits to the positions it copied", () => {
+  const parts = [{ type: "text" as const, text: "x", source: { text: { start: 1, end: 4, value: "[P]" } } }]
+  const copy = copyPromptParts(parts)
+  parts[0].source.text.start = 9
+  expect(copy[0]).toEqual({ type: "text", text: "x", source: { text: { start: 1, end: 4, value: "[P]" } } })
+})
diff --git a/packages/web/src/content/docs/keybinds.mdx b/packages/web/src/content/docs/keybinds.mdx
index 86f67dfd73ca..b55c4ccb7089 100644
--- a/packages/web/src/content/docs/keybinds.mdx
+++ b/packages/web/src/content/docs/keybinds.mdx
@@ -187,6 +187,25 @@ On Windows, the defaults for `input_undo` and `terminal_suspend` are different:
 
 ---
 
+## Undo with ctrl+z
+
+`input_undo` and `input_redo` step through the prompt's [undo history](/docs/tui#undo-in-the-prompt). On macOS and Linux, <kbd>ctrl+z</kbd> suspends OpenCode by default. To use <kbd>ctrl+z</kbd> and <kbd>ctrl+shift+z</kbd> for undo and redo instead, unbind suspend:
+
+```json title="tui.json"
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "keybinds": {
+    "terminal_suspend": "none",
+    "input_undo": "ctrl+z,ctrl+-,super+z",
+    "input_redo": "ctrl+shift+z,ctrl+.,super+shift+z"
+  }
+}
+```
+
+<kbd>ctrl+shift+z</kbd> reaches OpenCode only in a terminal that reports it apart from <kbd>ctrl+z</kbd>, through the kitty keyboard protocol or `modifyOtherKeys`; inside tmux that also needs `extended-keys`. <kbd>ctrl+.</kbd> needs the same.
+
+---
+
 ## Leader Key
 
 OpenCode uses a `leader` key for many keybinds. This avoids conflicts in your terminal.
diff --git a/packages/web/src/content/docs/tui.mdx b/packages/web/src/content/docs/tui.mdx
index 0351c46cde10..18abd3008327 100644
--- a/packages/web/src/content/docs/tui.mdx
+++ b/packages/web/src/content/docs/tui.mdx
@@ -409,12 +409,32 @@ This is separate from `opencode.json`, which configures server/runtime behavior.
 - `scroll_acceleration.enabled` - Enable macOS-style scroll acceleration for smooth, natural scrolling. When enabled, scroll speed increases with rapid scrolling gestures and stays precise for slower movements. **This setting takes precedence over `scroll_speed` and overrides it when enabled.**
 - `scroll_speed` - Controls how fast the TUI scrolls when using scroll commands (minimum: `0.001`, supports decimal values). Defaults to `3`. **Note: This is ignored if `scroll_acceleration.enabled` is set to `true`.**
 - `diff_style` - Controls diff rendering. `"auto"` adapts to terminal width, `"stacked"` always shows a single-column layout.
+- `prompt.undo_depth` - How many steps of prompt edits undo can take back. Defaults to `500`. See [Undo in the prompt](#undo-in-the-prompt).
 - `cursor` - Controls the terminal cursor in TUI input fields. `style` defaults to `"block"`, can be `"underline"`, `"line"`, or `"default"`; `blinking` defaults to `true`. When `style` is `"default"`, the terminal default cursor is restored, so `blinking` has no effect.
 - `mouse` - Enable or disable mouse capture in the TUI (default: `true`). When disabled, the terminal's native mouse selection/scrolling behavior is preserved.
 - `attention` - Configures TUI desktop notifications and sounds. Disabled by default.
 
 Use `OPENCODE_TUI_CONFIG` to load a custom TUI config path.
 
+### Undo in the prompt
+
+`input_undo` and `input_redo` (see [Keybinds](/docs/keybinds)) step back and forward through what you did in the prompt:
+
+- Typing comes back a word at a time. A pause of more than a second, moving the caret, or switching between typing and deleting also starts a new step.
+- A paste, a word or line delete such as <kbd>ctrl+w</kbd> or <kbd>ctrl+u</kbd>, a newline, clearing the prompt and recalling a previous prompt are each one step.
+- Undo restores pasted-text placeholders and attachments with their content, not only their labels.
+- After you submit, undo brings back what you sent, as if you had pressed up to recall it. The turn it started keeps running, and redo empties the prompt again.
+
+The history is shared by the prompts in one OpenCode window and holds `prompt.undo_depth` steps, 500 by default:
+
+```json title="tui.json"
+{
+  "prompt": {
+    "undo_depth": 1000
+  }
+}
+```
+
 ### Attention
 
 The TUI can request attention for questions, permissions, session errors, and completed sessions. Enable it with `attention.enabled`; built-in events play sounds when triggered, and non-subagent events request desktop notifications only when the terminal is blurred.
diff --git a/patches/@opentui%2Fcore@0.4.5.patch b/patches/@opentui%2Fcore@0.4.5.patch
new file mode 100644
index 000000000000..4907cac38eb0
--- /dev/null
+++ b/patches/@opentui%2Fcore@0.4.5.patch
@@ -0,0 +1,72 @@
+diff --git a/chunk-bun-t2myhmwd.js b/chunk-bun-t2myhmwd.js
+index 701d70dea2174e98ab56f4d614e678e868561479..c4b73d0825c4b46a99e5ec4f2811a40a3bc4e3ae 100644
+--- a/chunk-bun-t2myhmwd.js
++++ b/chunk-bun-t2myhmwd.js
+@@ -9647,11 +9647,11 @@ class ExtmarksController {
+         return;
+       }
+       this.saveSnapshot();
+-      const startOffset = this.positionToOffset(startLine, startCol);
+-      const endOffset = this.positionToOffset(endLine, endCol);
+-      const length = endOffset - startOffset;
+-      this.originalDeleteRange(startLine, startCol, endLine, endCol);
+-      this.adjustExtmarksAfterDeletion(startOffset, length);
++      const [startOffset, endOffset] = this.expandToVirtualExtmarks(this.positionToOffset(startLine, startCol), this.positionToOffset(endLine, endCol));
++      const start = this.offsetToPosition(startOffset);
++      const end = this.offsetToPosition(endOffset);
++      this.originalDeleteRange(start.row, start.col, end.row, end.col);
++      this.adjustExtmarksAfterDeletion(startOffset, endOffset - startOffset);
+     };
+     this.editBuffer.deleteLine = () => {
+       if (this.destroyed) {
+@@ -9781,6 +9781,14 @@ class ExtmarksController {
+       this.metadata.delete(id);
+     }
+   }
++  expandToVirtualExtmarks(start, end) {
++    if (start >= end)
++      return [start, end];
++    const cut = [...this.extmarks.values()].find((extmark) => extmark.virtual && extmark.start < end && extmark.end > start && (extmark.start < start || extmark.end > end));
++    if (!cut)
++      return [start, end];
++    return this.expandToVirtualExtmarks(Math.min(start, cut.start), Math.max(end, cut.end));
++  }
+   findVirtualExtmarkContaining(offset) {
+     for (const extmark of this.extmarks.values()) {
+       if (extmark.virtual && offset >= extmark.start && offset < extmark.end) {
+diff --git a/chunk-node-q0cwyvm9.js b/chunk-node-q0cwyvm9.js
+index be7df0e11bc6eac9ac8aacacdf2a4686670f09e1..39a9a428700d041c109f4a53bb3a4fd0094e53ee 100644
+--- a/chunk-node-q0cwyvm9.js
++++ b/chunk-node-q0cwyvm9.js
+@@ -9626,11 +9626,11 @@ class ExtmarksController {
+         return;
+       }
+       this.saveSnapshot();
+-      const startOffset = this.positionToOffset(startLine, startCol);
+-      const endOffset = this.positionToOffset(endLine, endCol);
+-      const length = endOffset - startOffset;
+-      this.originalDeleteRange(startLine, startCol, endLine, endCol);
+-      this.adjustExtmarksAfterDeletion(startOffset, length);
++      const [startOffset, endOffset] = this.expandToVirtualExtmarks(this.positionToOffset(startLine, startCol), this.positionToOffset(endLine, endCol));
++      const start = this.offsetToPosition(startOffset);
++      const end = this.offsetToPosition(endOffset);
++      this.originalDeleteRange(start.row, start.col, end.row, end.col);
++      this.adjustExtmarksAfterDeletion(startOffset, endOffset - startOffset);
+     };
+     this.editBuffer.deleteLine = () => {
+       if (this.destroyed) {
+@@ -9760,6 +9760,14 @@ class ExtmarksController {
+       this.metadata.delete(id);
+     }
+   }
++  expandToVirtualExtmarks(start, end) {
++    if (start >= end)
++      return [start, end];
++    const cut = [...this.extmarks.values()].find((extmark) => extmark.virtual && extmark.start < end && extmark.end > start && (extmark.start < start || extmark.end > end));
++    if (!cut)
++      return [start, end];
++    return this.expandToVirtualExtmarks(Math.min(start, cut.start), Math.max(end, cut.end));
++  }
+   findVirtualExtmarkContaining(offset) {
+     for (const extmark of this.extmarks.values()) {
+       if (extmark.virtual && offset >= extmark.start && offset < extmark.end) {