From 13680808c7204fac27a358e76b5b459dc47d7c1e Mon Sep 17 00:00:00 2001
From: Nowaker <spam@nowaker.net>
Date: Sat, 10 Oct 2026 21:11:44 -0500
Subject: [PATCH 1/2] fix(tui): delete a paste placeholder whole on word and
 line deletes

ctrl+w (or alt+backspace) right after a "[Pasted ~5 lines]" placeholder
deleted only the last word of its label, leaving "[Pasted ~5 " behind
with the pasted text detached from it; ctrl+u and ctrl+k did the same
when the line edge cut into a placeholder. Backspace and delete already
removed it whole.

The cause is in @opentui/core: its extmark controller's deleteRange,
which every word and line delete goes through, trimmed a virtual
extmark instead of treating it as one unit. The fix is upstream as
anomalyco/opentui#1628; patches/@opentui%2Fcore@0.4.5.patch backports
it to the pinned 0.4.5 until a release with it is adopted. deleteRange
now widens its range over every virtual extmark it cuts into.
---
 bun.lock                                      |  1 +
 package.json                                  |  3 +-
 .../prompt-placeholder-delete.test.tsx        | 64 +++++++++++++++++
 patches/@opentui%2Fcore@0.4.5.patch           | 72 +++++++++++++++++++
 4 files changed, 139 insertions(+), 1 deletion(-)
 create mode 100644 packages/tui/test/component/prompt-placeholder-delete.test.tsx
 create mode 100644 patches/@opentui%2Fcore@0.4.5.patch

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/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/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) {

From 8206ce472a15269d43c4331cc346fd211b861699 Mon Sep 17 00:00:00 2001
From: Nowaker <spam@nowaker.net>
Date: Sat, 10 Oct 2026 21:36:11 -0500
Subject: [PATCH 2/2] feat(tui): grouped prompt undo that survives submits and
 keeps pasted text

input_undo ran the textarea's own history, which steps back one
character at a time, so taking back a paragraph took dozens of
presses. It knew nothing of the prompt's parts: undoing the deletion
of a "[Pasted ~N lines]" placeholder brought its label back as plain
text with the pasted content gone. A submit cleared it, so text lost to
a stray submit or ctrl+u could only be found again through the
history.

The prompt now keeps its own history (src/prompt/undo.ts) and binds
input.undo and input.redo to it while focused. Typing is grouped by
word: a group ends where a new word starts, after a pause over a
second, when the caret moves, or between typing and deleting. A paste,
a word or line delete, a newline, clearing, recalling history and a
submit are each one step. Every entry records the text, the parts with
their pasted content, the mode and the caret, and undo restores them
together. The history lives outside the prompt component, so after a
submit undo brings back what was sent, even once the route has moved
to the new session, without touching the running turn.

prompt.undo_depth sets how many steps are kept (default 500). The
default keys are unchanged; keybinds.mdx shows how to move suspend off
ctrl+z and use ctrl+z / ctrl+shift+z.
---
 packages/tui/src/component/prompt/index.tsx   |  73 ++++++-
 packages/tui/src/config/index.tsx             |   6 +-
 packages/tui/src/prompt/undo.ts               | 153 ++++++++++++++
 .../tui/test/component/prompt-undo.test.tsx   | 189 ++++++++++++++++++
 packages/tui/test/config.test.tsx             |   6 +
 packages/tui/test/prompt/undo.test.ts         | 165 +++++++++++++++
 packages/web/src/content/docs/keybinds.mdx    |  19 ++
 packages/web/src/content/docs/tui.mdx         |  20 ++
 8 files changed, 629 insertions(+), 2 deletions(-)
 create mode 100644 packages/tui/src/prompt/undo.ts
 create mode 100644 packages/tui/test/component/prompt-undo.test.tsx
 create mode 100644 packages/tui/test/prompt/undo.test.ts

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-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.