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/app.tsx b/packages/tui/src/app.tsx
index 1b21aafade52..1e9ac048f45a 100644
--- a/packages/tui/src/app.tsx
+++ b/packages/tui/src/app.tsx
@@ -9,7 +9,7 @@ import { ClipboardProvider, useClipboard } from "./context/clipboard"
 import { ExitProvider, useExit } from "./context/exit"
 import { EpilogueProvider } from "./context/epilogue"
 import * as Selection from "./util/selection"
-import { createCliRenderer, MouseButton } from "@opentui/core"
+import { createCliRenderer, MouseButton, type MouseEvent } from "@opentui/core"
 import { RouteProvider, useRoute } from "./context/route"
 import {
   Switch,
@@ -66,6 +66,8 @@ import { openUrl } from "@opencode-ai/core/open"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { TuiConfigProvider, useTuiConfig, type TuiConfig } from "./config"
 import { createTuiApiAdapters } from "./plugin/adapters"
+import { copyText, onClick } from "./ui/click"
+import { idUnder } from "./ui/id-click"
 import { createTuiApi } from "./plugin/api"
 import { createPluginRuntime, PluginRuntimeProvider, usePluginRuntime, type TuiPluginHost } from "./plugin/runtime"
 import { CommandPaletteDialog } from "./component/command-palette"
@@ -372,6 +374,14 @@ function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPlugi
   const attention = createTuiAttention({ renderer, config: tuiConfig, kv })
   const clipboard = useClipboard()
   const update = useUpdateNotification()
+  // A click on a session or message ID outside a dialog copies it.
+  const idClick = onClick((evt: MouseEvent) => {
+    if (dialog.stack.length > 0) return false
+    const found = idUnder(renderer.currentRenderBuffer, evt)
+    if (!found) return false
+    copyText(clipboard, toast.show, found.value)
+    return true
+  })
 
   const api = createTuiApi(
     createTuiApiAdapters({
@@ -1042,6 +1052,7 @@ function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPlugi
       flexDirection="column"
       backgroundColor={theme.background}
       onMouseDown={(evt) => {
+        idClick.onMouseDown(evt)
         if (!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT) return
         if (evt.button !== MouseButton.RIGHT) return
 
@@ -1049,11 +1060,10 @@ function App(props: { onSnapshot?: () => Promise<string[]>; pluginHost: TuiPlugi
         evt.preventDefault()
         evt.stopPropagation()
       }}
-      onMouseUp={
-        !Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT
-          ? () => Selection.copy(renderer, toast, clipboard)
-          : undefined
-      }
+      onMouseUp={(evt) => {
+        if (idClick.onMouseUp(evt)) return
+        if (!Flag.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT) Selection.copy(renderer, toast, clipboard)
+      }}
     >
       <Show when={Flag.OPENCODE_SHOW_TTFD}>
         <TimeToFirstDraw />
diff --git a/packages/tui/src/component/dialog-mcp.tsx b/packages/tui/src/component/dialog-mcp.tsx
index c48c0f8ee188..d2f1ca1f6022 100644
--- a/packages/tui/src/component/dialog-mcp.tsx
+++ b/packages/tui/src/component/dialog-mcp.tsx
@@ -5,7 +5,6 @@ import { map, pipe, entries, sortBy } from "remeda"
 import { DialogSelect, type DialogSelectRef, type DialogSelectOption } from "../ui/dialog-select"
 import { useTheme } from "../context/theme"
 import { TextAttributes } from "@opentui/core"
-import { useSDK } from "../context/sdk"
 
 function Status(props: { enabled: boolean; loading: boolean }) {
   const { theme } = useTheme()
@@ -21,14 +20,12 @@ function Status(props: { enabled: boolean; loading: boolean }) {
 export function DialogMcp() {
   const local = useLocal()
   const sync = useSync()
-  const sdk = useSDK()
   const [, setRef] = createSignal<DialogSelectRef<unknown>>()
-  const [loading, setLoading] = createSignal<string | null>(null)
 
   const options = createMemo(() => {
     // Track sync data and loading state to trigger re-render when they change
     const mcpData = sync.data.mcp
-    const loadingMcp = loading()
+    const loadingMcp = local.mcp.pending()
 
     return pipe(
       mcpData ?? {},
@@ -48,26 +45,7 @@ export function DialogMcp() {
     {
       command: "dialog.mcp.toggle",
       title: "toggle",
-      onTrigger: async (option: DialogSelectOption<string>) => {
-        // Prevent toggling while an operation is already in progress
-        if (loading() !== null) return
-
-        setLoading(option.value)
-        try {
-          await local.mcp.toggle(option.value)
-          // Refresh MCP status from server
-          const status = await sdk.client.mcp.status()
-          if (status.data) {
-            sync.set("mcp", status.data)
-          } else {
-            console.error("Failed to refresh MCP status: no data returned")
-          }
-        } catch (error) {
-          console.error("Failed to toggle MCP:", error)
-        } finally {
-          setLoading(null)
-        }
-      },
+      onTrigger: (option: DialogSelectOption<string>) => local.mcp.toggle(option.value),
     },
   ])
 
diff --git a/packages/tui/src/component/dialog-model.tsx b/packages/tui/src/component/dialog-model.tsx
index 38db569aaa24..1b7f0897841c 100644
--- a/packages/tui/src/component/dialog-model.tsx
+++ b/packages/tui/src/component/dialog-model.tsx
@@ -9,7 +9,9 @@ import * as fuzzysort from "fuzzysort"
 import { useConnected } from "./use-connected"
 import { useSync } from "../context/sync"
 
-export function DialogModel(props: { providerID?: string }) {
+// `current` puts the cursor on another model than the selected one, e.g. the
+// model a past turn ran on.
+export function DialogModel(props: { providerID?: string; current?: { providerID: string; modelID: string } }) {
   const local = useLocal()
   const sync = useSync()
   const dialog = useDialog()
@@ -178,7 +180,7 @@ export function DialogModel(props: { providerID?: string }) {
       flat={true}
       skipFilter={true}
       title={title()}
-      current={local.model.current()}
+      current={props.current ?? local.model.current()}
     />
   )
 }
diff --git a/packages/tui/src/component/dialog-paste-options.tsx b/packages/tui/src/component/dialog-paste-options.tsx
new file mode 100644
index 000000000000..88c376c93af5
--- /dev/null
+++ b/packages/tui/src/component/dialog-paste-options.tsx
@@ -0,0 +1,284 @@
+import { ScrollBoxRenderable, TextareaRenderable, TextAttributes, type RGBA } from "@opentui/core"
+import { useTerminalDimensions } from "@opentui/solid"
+import { createEffect, createSignal, For, onMount } from "solid-js"
+import { useTheme } from "../context/theme"
+import { useKV } from "../context/kv"
+import { useTuiConfig } from "../config"
+import { useBindings } from "../keymap"
+import { useDialog } from "../ui/dialog"
+import { onClick } from "../ui/click"
+import { pasteLabel } from "../prompt/paste"
+import {
+  cleanPaste,
+  pasteOptionDisabled,
+  PasteOptionList,
+  PasteOptionsDefault,
+  PasteOptionsKVKey,
+  togglePasteOption,
+  unwrapPaste,
+  wrapPaste,
+  type PasteOptionKey,
+  type PasteOptions,
+} from "../prompt/paste-options"
+import { PromptFrame, promptFrameRows } from "./prompt/frame"
+
+// A paste as it came in and what was chosen for it. `body` is the text inside the wraps once it was
+// edited by hand; until then it is the source with the cleanups applied, and they can be undone.
+export type PasteOrigin = { source: string; options: PasteOptions; body?: string }
+export type PasteResult = { text: string; inline: boolean; origin: PasteOrigin }
+
+// The paste dialog of prompt.paste_mode 'dialog': the options on the left, and on the right the
+// paste as it will go in, in the prompt's own editor and box, updated as options change and
+// editable. Space toggles the selected option, enter pastes, esc cancels. Right or tab moves from the
+// options to the editor, where space and arrows work as usual and enter still pastes; tab goes back.
+export function DialogPasteOptions(props: { origin: PasteOrigin; color: RGBA; onPaste(result: PasteResult): void }) {
+  const dialog = useDialog()
+  const { theme, syntax } = useTheme()
+  const tuiConfig = useTuiConfig()
+  const kv = useKV()
+  const dimensions = useTerminalDimensions()
+  const [options, setOptions] = createSignal(props.origin.options)
+  const [body, setBody] = createSignal(props.origin.body ?? cleanPaste(props.origin.source, props.origin.options))
+  const [text, setText] = createSignal(wrapPaste(body(), options()))
+  const [focus, setFocus] = createSignal<"options" | "editor">("options")
+  const [selected, setSelected] = createSignal(0)
+  const [rows, setRows] = createSignal(1)
+  const [target, setTarget] = createSignal<TextareaRenderable>()
+  let edited = props.origin.body !== undefined
+  let textarea: TextareaRenderable
+  let list: ScrollBoxRenderable | undefined
+
+  // The dialog starts a quarter of the way down the screen (ui/dialog.tsx). Around the editor it has
+  // 6 rows: its top padding, the title, a gap, the hint row under the box, its bottom padding and a
+  // one-row margin, plus the prompt box's own rows. The editor is as tall as the paste once wrapped,
+  // and at least as tall as the options beside it, up to the room left; longer text scrolls.
+  const editorHeight = () => {
+    const room = dimensions().height - Math.ceil(dimensions().height / 4) - 6 - promptFrameRows(true)
+    const beside = listHeight() - promptFrameRows(true) - 1
+    return Math.max(1, Math.min(room, Math.max(beside, rows())))
+  }
+
+  // The options get the same rows as the editor's column; on a short screen they scroll, following
+  // the selection.
+  const listHeight = () =>
+    Math.max(1, Math.min(PasteOptionList.length, dimensions().height - Math.ceil(dimensions().height / 4) - 6))
+
+  createEffect(() => {
+    const index = selected()
+    const height = listHeight()
+    if (!list || list.isDestroyed) return
+    if (index < list.scrollTop) list.scrollTo(index)
+    if (index >= list.scrollTop + height) list.scrollTo(index - height + 1)
+  })
+
+  function measure() {
+    if (!textarea || textarea.isDestroyed) return
+    setRows(textarea.editorView.getTotalVirtualLineCount())
+  }
+
+  function show() {
+    setText(wrapPaste(body(), options()))
+    if (!textarea || textarea.isDestroyed) return
+    textarea.setText(text())
+    measure()
+  }
+
+  // Before an edit, a cleanup turned off brings back the source; after one, only turning a cleanup
+  // on can change the text, since what the edit replaced is gone.
+  function toggle(key: PasteOptionKey) {
+    if (pasteOptionDisabled(key, body(), options())) return
+    const next = togglePasteOption(options(), key)
+    setOptions(next)
+    kv.set(PasteOptionsKVKey, next)
+    if (!edited) setBody(cleanPaste(props.origin.source, next))
+    if (edited && next[key]) setBody(cleanPaste(body(), { ...PasteOptionsDefault, [key]: true }))
+    show()
+  }
+
+  // The editor reports a change a microtask after it happened, so the dialog's own setText reaches
+  // here too, once the dialog is done; a flag set around setText would already be cleared. A change
+  // is a hand edit only when the editor no longer holds the text the dialog last showed.
+  function adoptEdit() {
+    measure()
+    if (textarea.plainText === text()) return
+    setText(textarea.plainText)
+    const unwrapped = unwrapPaste(textarea.plainText, options())
+    setBody(unwrapped.body)
+    setOptions(unwrapped.options)
+    edited = true
+  }
+
+  function focusOn(next: "options" | "editor") {
+    setFocus(next)
+    if (!textarea || textarea.isDestroyed) return
+    if (next === "editor") return textarea.focus()
+    textarea.blur()
+  }
+
+  function paste() {
+    props.onPaste({
+      text: text(),
+      inline: options().inline,
+      origin: { source: props.origin.source, options: options(), body: edited ? body() : undefined },
+    })
+    dialog.clear()
+  }
+
+  const checked = (key: PasteOptionKey) => options()[key] && !pasteOptionDisabled(key, body(), options())
+
+  useBindings(() => ({
+    priority: 1,
+    bindings: [
+      { key: "tab", desc: "Options or editor", group: "Dialog", cmd: () => focusOn(focus() === "editor" ? "options" : "editor") },
+      {
+        key: "shift+tab",
+        desc: "Options or editor",
+        group: "Dialog",
+        cmd: () => focusOn(focus() === "editor" ? "options" : "editor"),
+      },
+    ],
+  }))
+
+  useBindings(() => ({
+    target,
+    enabled: target() !== undefined,
+    priority: 1,
+    commands: [{ name: "input.submit", title: "Paste", category: "Dialog", run: paste }],
+  }))
+
+  // While the options have focus the editor does not, so these keys are not tied to it.
+  useBindings(() => ({
+    enabled: focus() === "options",
+    priority: 1,
+    commands: [{ name: "dialog.paste.paste", title: "Paste", category: "Dialog", run: paste }],
+    bindings: [
+      ...tuiConfig.keybinds.get("input.submit").map((binding) => ({ ...binding, cmd: "dialog.paste.paste" })),
+      { key: "right", desc: "To the editor", group: "Dialog", cmd: () => focusOn("editor") },
+      {
+        key: "space",
+        desc: "Toggle paste option",
+        group: "Dialog",
+        cmd: () => toggle(PasteOptionList[selected()].key),
+      },
+      {
+        key: "up",
+        desc: "Previous paste option",
+        group: "Dialog",
+        cmd: () => setSelected((index) => (index + PasteOptionList.length - 1) % PasteOptionList.length),
+      },
+      {
+        key: "down",
+        desc: "Next paste option",
+        group: "Dialog",
+        cmd: () => setSelected((index) => (index + 1) % PasteOptionList.length),
+      },
+    ],
+  }))
+
+  onMount(() => {
+    dialog.setSize("xlarge")
+    textarea.gotoBufferHome()
+    setTimeout(measure, 1)
+  })
+
+  return (
+    <box paddingLeft={2} paddingRight={2} paddingBottom={1} gap={1}>
+      <box flexDirection="row" justifyContent="space-between" gap={2}>
+        <text attributes={TextAttributes.BOLD} fg={theme.text} flexShrink={0}>
+          Paste <span style={{ fg: theme.textMuted }}>{text().split("\n").length} lines</span>
+        </text>
+        <text fg={theme.textMuted} wrapMode="none">
+          {options().inline ? "goes in as text" : `goes in as ${pasteLabel(text(), tuiConfig.prompt?.paste_summary)}`}
+        </text>
+      </box>
+      <box flexDirection="row" gap={2}>
+        {/* A scroll box grows to fill the row unless told otherwise; this one is as wide as its rows:
+            the widest label, its checkbox and its padding. */}
+        <scrollbox
+          flexGrow={0}
+          flexShrink={0}
+          width={Math.max(...PasteOptionList.map((option) => option.label.length)) + 6}
+          height={listHeight()}
+          scrollbarOptions={{ visible: false }}
+          ref={(value: ScrollBoxRenderable) => (list = value)}
+        >
+          <For each={PasteOptionList}>
+            {(option, index) => {
+              const current = () => selected() === index()
+              const disabled = () => pasteOptionDisabled(option.key, body(), options())
+              return (
+                <box
+                  paddingLeft={1}
+                  paddingRight={1}
+                  backgroundColor={
+                    current() ? (focus() === "options" ? theme.primary : theme.backgroundElement) : undefined
+                  }
+                  {...onClick(() => {
+                    setSelected(index())
+                    focusOn("options")
+                    toggle(option.key)
+                  })}
+                >
+                  <text
+                    fg={
+                      current() && focus() === "options"
+                        ? theme.selectedListItemText
+                        : disabled()
+                          ? theme.textMuted
+                          : theme.text
+                    }
+                    wrapMode="none"
+                  >
+                    {checked(option.key) ? "[x] " : "[ ] "}
+                    {option.label}
+                  </text>
+                </box>
+              )
+            }}
+          </For>
+        </scrollbox>
+        <box flexGrow={1} flexShrink={1}>
+          <PromptFrame color={props.color} padBottom>
+            <textarea
+              width="100%"
+              height={editorHeight()}
+              initialValue={text()}
+              ref={(value: TextareaRenderable) => {
+                textarea = value
+                setTarget(value)
+              }}
+              onContentChange={adoptEdit}
+              onSizeChange={measure}
+              onMouseDown={() => focusOn("editor")}
+              textColor={theme.text}
+              focusedTextColor={theme.text}
+              backgroundColor={theme.backgroundElement}
+              focusedBackgroundColor={theme.backgroundElement}
+              cursorColor={theme.text}
+              cursorStyle={tuiConfig.cursor}
+              syntaxStyle={syntax()}
+            />
+          </PromptFrame>
+          {/* Placed like the prompt's own hints under its box, such as ctrl+p commands. */}
+          <box flexDirection="row" justifyContent="flex-end" gap={2}>
+            {focus() === "options" ? (
+              <text fg={theme.text}>
+                space <span style={{ fg: theme.textMuted }}>toggle</span>
+              </text>
+            ) : undefined}
+            <text fg={theme.text} {...onClick(() => focusOn(focus() === "editor" ? "options" : "editor"))}>
+              {focus() === "editor" ? "tab" : "→/tab"}{" "}
+              <span style={{ fg: theme.textMuted }}>{focus() === "editor" ? "options" : "edit"}</span>
+            </text>
+            <text fg={theme.text} {...onClick(paste)}>
+              enter <span style={{ fg: theme.textMuted }}>paste</span>
+            </text>
+            <text fg={theme.text} {...onClick(() => dialog.clear())}>
+              esc <span style={{ fg: theme.textMuted }}>cancel</span>
+            </text>
+          </box>
+        </box>
+      </box>
+    </box>
+  )
+}
diff --git a/packages/tui/src/component/dialog-paste.tsx b/packages/tui/src/component/dialog-paste.tsx
new file mode 100644
index 000000000000..46801ee28150
--- /dev/null
+++ b/packages/tui/src/component/dialog-paste.tsx
@@ -0,0 +1,229 @@
+import { TextareaRenderable, TextAttributes, type RGBA } from "@opentui/core"
+import { useTerminalDimensions } from "@opentui/solid"
+import { createSignal, onCleanup, onMount } from "solid-js"
+import { useTheme } from "../context/theme"
+import { useTuiConfig } from "../config"
+import { useBindings } from "../keymap"
+import { createPromptUndo } from "../prompt/undo"
+import { useDialog } from "../ui/dialog"
+import { PromptFrame, promptFrameRows } from "./prompt/frame"
+import { onClick } from "../ui/click"
+
+export type DialogPasteProps = {
+  text: string
+  // The prompt's bar color, so the editor's box matches the prompt's.
+  color: RGBA
+  onChange(text: string): void
+  onInline(): void
+}
+
+// The text behind a paste placeholder, in the prompt's own editor and box: the same textarea,
+// input keybinds, mouse caret placement and grouped undo, without the agent line. Enter saves and
+// closes, as Esc does, and the prompt's newline keys add a line. Above the editor, Keep as block
+// does the same as Enter and Insert inline replaces the placeholder with the text. Tab and
+// shift+tab move between the editor and the two buttons wherever the caret is; Up on the editor's
+// first row also reaches them, Enter presses the focused one and Down goes back to the text.
+export function DialogPaste(props: DialogPasteProps) {
+  const dialog = useDialog()
+  const { theme, syntax } = useTheme()
+  const tuiConfig = useTuiConfig()
+  const dimensions = useTerminalDimensions()
+  const [target, setTarget] = createSignal<TextareaRenderable>()
+  const [lines, setLines] = createSignal(props.text.split("\n").length)
+  const [rows, setRows] = createSignal(props.text.split("\n").length)
+  const [focus, setFocus] = createSignal<Focus>("editor")
+  const [pressed, setPressed] = createSignal<Exclude<Focus, "editor">>()
+  const undo = createPromptUndo({ depth: () => tuiConfig.prompt?.undo_depth ?? 500 })
+  let textarea: TextareaRenderable
+  let applying = false
+  let pressing: ReturnType<typeof setTimeout> | undefined
+  onCleanup(() => clearTimeout(pressing))
+
+  // The dialog starts a quarter of the way down the screen (ui/dialog.tsx), and around the editor
+  // it has 7 rows: its top padding, the title, two gaps, the button row, the hint row under the
+  // box and its bottom padding, plus the prompt box's own rows. The editor is as tall as the text
+  // once wrapped at its width, up to what is left above a one-row margin; longer text scrolls
+  // inside it.
+  const editorHeight = () => {
+    const room = dimensions().height - Math.ceil(dimensions().height / 4) - 8 - promptFrameRows(true)
+    return Math.max(1, Math.min(room, Math.max(3, rows())))
+  }
+
+  function measure() {
+    if (!textarea || textarea.isDestroyed) return
+    setRows(textarea.editorView.getTotalVirtualLineCount())
+  }
+
+  function focusOn(next: Focus) {
+    setFocus(next)
+    if (!textarea || textarea.isDestroyed) return
+    if (next === "editor") return textarea.focus()
+    textarea.blur()
+  }
+
+  function cycle(offset: number) {
+    focusOn(order[(order.indexOf(focus()) + offset + order.length) % order.length])
+  }
+
+  // Shown pressed for a moment, so a key press reads as one before the dialog closes.
+  function press(button: Exclude<Focus, "editor">) {
+    if (pressed()) return
+    focusOn(button)
+    setPressed(button)
+    pressing = setTimeout(() => {
+      if (button === "inline") props.onInline()
+      dialog.clear()
+    }, 120)
+  }
+
+  const state = () => ({ input: textarea.plainText, parts: [], mode: "normal" as const, cursor: textarea.cursorOffset })
+
+  function step(direction: "undo" | "redo") {
+    undo.observe(state())
+    const next = direction === "undo" ? undo.undo(state()) : undo.redo(state())
+    if (!next) return
+    applying = true
+    textarea.setText(next.input)
+    textarea.cursorOffset = next.cursor
+    applying = false
+    undo.sync(state())
+    props.onChange(next.input)
+  }
+
+  useBindings(() => ({
+    target,
+    enabled: target() !== undefined,
+    priority: 1,
+    commands: [
+      { name: "input.submit", title: "Save and close", category: "Dialog", run: () => dialog.clear() },
+      { name: "input.undo", title: "Undo", category: "Dialog", run: () => step("undo") },
+      { name: "input.redo", title: "Redo", category: "Dialog", run: () => step("redo") },
+      {
+        name: "input.move.up",
+        title: "Up, or to the buttons from the first row",
+        category: "Dialog",
+        run: () => {
+          if (textarea.scrollY + textarea.visualCursor.visualRow === 0) return focusOn("keep")
+          textarea.moveCursorUp()
+        },
+      },
+    ],
+  }))
+
+  // Not tied to the editor, so they work from the buttons too, and before the prompt's own Tab.
+  useBindings(() => ({
+    priority: 1,
+    bindings: [
+      { key: "tab", desc: "Next in the paste dialog", group: "Dialog", cmd: () => cycle(1) },
+      { key: "shift+tab", desc: "Previous in the paste dialog", group: "Dialog", cmd: () => cycle(-1) },
+    ],
+  }))
+
+  // While a button has focus the editor does not, so these keys are not tied to it.
+  useBindings(() => ({
+    enabled: focus() !== "editor",
+    priority: 1,
+    commands: [
+      {
+        name: "dialog.paste.press",
+        title: "Press the focused button",
+        category: "Dialog",
+        run: () => {
+          const current = focus()
+          if (current !== "editor") press(current)
+        },
+      },
+      { name: "dialog.paste.editor", title: "Back to the text", category: "Dialog", run: () => focusOn("editor") },
+    ],
+    bindings: [
+      ...tuiConfig.keybinds.get("input.submit").map((binding) => ({ ...binding, cmd: "dialog.paste.press" })),
+      ...tuiConfig.keybinds.get("input.move.down").map((binding) => ({ ...binding, cmd: "dialog.paste.editor" })),
+      { key: "left", desc: "Previous button", group: "Dialog", cmd: () => focusOn("keep") },
+      { key: "right", desc: "Next button", group: "Dialog", cmd: () => focusOn("inline") },
+    ],
+  }))
+
+  onMount(() => {
+    dialog.setSize("xlarge")
+    textarea.gotoBufferHome()
+    undo.sync(state())
+    setTimeout(() => {
+      if (!textarea || textarea.isDestroyed) return
+      textarea.focus()
+      measure()
+    }, 1)
+  })
+
+  const button = (name: Exclude<Focus, "editor">, label: string) => (
+    <box
+      paddingLeft={1}
+      paddingRight={1}
+      backgroundColor={focus() === name ? theme.primary : theme.backgroundElement}
+      {...onClick(() => press(name))}
+    >
+      <text
+        fg={focus() === name ? theme.selectedListItemText : theme.text}
+        attributes={pressed() === name ? TextAttributes.BOLD | TextAttributes.INVERSE : 0}
+      >
+        {label}
+      </text>
+    </box>
+  )
+
+  return (
+    <box paddingLeft={2} paddingRight={2} paddingBottom={1} gap={1}>
+      <text attributes={TextAttributes.BOLD} fg={theme.text}>
+        Pasted text <span style={{ fg: theme.textMuted }}>{lines()} lines</span>
+      </text>
+      <box flexDirection="row" gap={2}>
+        {button("keep", "Keep as block")}
+        {button("inline", "Insert inline")}
+      </box>
+      <box>
+        <PromptFrame color={props.color} padBottom>
+          <textarea
+            width="100%"
+            height={editorHeight()}
+            initialValue={props.text}
+            ref={(value: TextareaRenderable) => {
+              textarea = value
+              setTarget(value)
+            }}
+            onContentChange={() => {
+              const text = textarea.plainText
+              setLines(text.split("\n").length)
+              measure()
+              props.onChange(text)
+              if (!applying) undo.observe(state())
+            }}
+            onCursorChange={() => {
+              if (!applying) undo.observe(state())
+            }}
+            onSizeChange={measure}
+            onMouseDown={() => focusOn("editor")}
+            textColor={theme.text}
+            focusedTextColor={theme.text}
+            backgroundColor={theme.backgroundElement}
+            focusedBackgroundColor={theme.backgroundElement}
+            cursorColor={theme.text}
+            cursorStyle={tuiConfig.cursor}
+            syntaxStyle={syntax()}
+          />
+        </PromptFrame>
+        {/* Placed like the prompt's own hints under its box, such as ctrl+p commands. */}
+        <box flexDirection="row" justifyContent="flex-end" gap={2}>
+          <text fg={theme.text} {...onClick(() => cycle(1))}>
+            tab <span style={{ fg: theme.textMuted }}>switch</span>
+          </text>
+          <text fg={theme.text} {...onClick(() => dialog.clear())}>
+            {focus() === "inline" ? "esc" : "esc/enter"} <span style={{ fg: theme.textMuted }}>save</span>
+          </text>
+        </box>
+      </box>
+    </box>
+  )
+}
+
+type Focus = "editor" | "keep" | "inline"
+
+const order: Focus[] = ["editor", "keep", "inline"]
diff --git a/packages/tui/src/component/prompt/frame.tsx b/packages/tui/src/component/prompt/frame.tsx
new file mode 100644
index 000000000000..a404ca3368e0
--- /dev/null
+++ b/packages/tui/src/component/prompt/frame.tsx
@@ -0,0 +1,71 @@
+import type { RGBA } from "@opentui/core"
+import type { JSX } from "solid-js"
+import { useTheme } from "../../context/theme"
+import { EmptyBorder, SplitBorder } from "../../ui/border"
+
+const paddingX = 2
+const paddingY = 1
+
+// The prompt's box: a bar in `color` down its left edge, its content padded on the element
+// background, and a half-row edge below. The prompt and the paste dialog's editor both use it.
+// `padBottom` pads below the content as much as above it, for a box with no footer row.
+export function PromptFrame(props: { color: RGBA; padBottom?: boolean; children: JSX.Element }) {
+  const { theme } = useTheme()
+  return (
+    <box width="100%">
+      <box
+        width="100%"
+        border={["left"]}
+        borderColor={props.color}
+        customBorderChars={{
+          ...SplitBorder.customBorderChars,
+          bottomLeft: "╹",
+        }}
+      >
+        <box
+          paddingLeft={paddingX}
+          paddingRight={paddingX}
+          paddingTop={paddingY}
+          paddingBottom={props.padBottom ? paddingY : 0}
+          flexShrink={0}
+          backgroundColor={theme.backgroundElement}
+          flexGrow={1}
+          width="100%"
+        >
+          {props.children}
+        </box>
+      </box>
+      <box
+        height={1}
+        border={["left"]}
+        borderColor={props.color}
+        customBorderChars={{
+          ...EmptyBorder,
+          vertical: theme.backgroundElement.a !== 0 ? "╹" : " ",
+        }}
+      >
+        <box
+          height={1}
+          border={["bottom"]}
+          borderColor={theme.backgroundElement}
+          customBorderChars={
+            theme.backgroundElement.a !== 0
+              ? {
+                  ...EmptyBorder,
+                  horizontal: "▀",
+                }
+              : {
+                  ...EmptyBorder,
+                  horizontal: " ",
+                }
+          }
+        />
+      </box>
+    </box>
+  )
+}
+
+// Rows the frame adds around its content: the padding above, below with `padBottom`, and the edge.
+export function promptFrameRows(padBottom: boolean) {
+  return paddingY * (padBottom ? 2 : 1) + 1
+}
diff --git a/packages/tui/src/component/prompt/index.tsx b/packages/tui/src/component/prompt/index.tsx
index c48c751739ce..4a78ca81b052 100644
--- a/packages/tui/src/component/prompt/index.tsx
+++ b/packages/tui/src/component/prompt/index.tsx
@@ -16,7 +16,7 @@ import { fileURLToPath } from "url"
 import { useLocal } from "../../context/local"
 import { Flag } from "@opencode-ai/core/flag/flag"
 import { tint, useTheme } from "../../context/theme"
-import { EmptyBorder, SplitBorder } from "../../ui/border"
+import { PromptFrame } from "./frame"
 import { useTuiPaths, useTuiTerminalEnvironment } from "../../context/runtime"
 import { useClipboard } from "../../context/clipboard"
 import { Spinner } from "../spinner"
@@ -33,8 +33,13 @@ 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 { pasteLabel, pasteSummary } from "../../prompt/paste"
+import { copyPromptParts, createPromptUndo, PromptUndoDepthDefault, type PromptUndoState } from "../../prompt/undo"
 import { usePromptStash } from "../../prompt/stash"
 import { DialogStash } from "../dialog-stash"
+import { DialogPaste } from "../dialog-paste"
+import { DialogPasteOptions, type PasteOrigin, type PasteResult } from "../dialog-paste-options"
+import { PasteOptionsDefault, PasteOptionsKVKey, readPasteOptions } from "../../prompt/paste-options"
 import { type AutocompleteRef, Autocomplete } from "./autocomplete"
 import { useRenderer, useTerminalDimensions, type JSX } from "@opentui/solid"
 import type { AssistantMessage, FilePart, UserMessage } from "@opencode-ai/sdk/v2"
@@ -57,6 +62,7 @@ import { usePromptWorkspace } from "./workspace"
 import { usePromptMove } from "./move"
 import { readLocalAttachment } from "./local-attachment"
 import { useLocation } from "../../context/location"
+import { copyText, onClick } from "../../ui/click"
 
 registerOpencodeSpinner()
 
@@ -75,6 +81,11 @@ export type PromptProps = {
   }
 }
 
+// Replace CRLF first, then any remaining CR.
+function normalizeLineEndings(text: string) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
+}
+
 function pastedFilepath(value: string, platform: string) {
   const raw = value.replace(/^['"]+|['"]+$/g, "")
   if (raw.startsWith("file://")) {
@@ -139,6 +150,16 @@ 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 })
+// What each placeholder from the paste dialog came from, by its text, so a click on it reopens the
+// dialog with the same source and options. Shared for the same reason as the undo history.
+const pasteOrigins = new Map<string, PasteOrigin>()
+// The last paste from the paste dialog and the prompt text right after it: undo while the prompt is
+// still that takes the paste back and reopens the dialog with it, without reading the clipboard.
+let lastPaste: { input: string; origin: PasteOrigin } | undefined
 
 export function Prompt(props: PromptProps) {
   let input: TextareaRenderable
@@ -624,6 +645,8 @@ export function Prompt(props: PromptProps) {
     }
   })
 
+  onMount(() => queueMicrotask(settleUndo))
+
   onCleanup(() => {
     if (store.prompt.input) {
       stashed = { prompt: unwrap(store.prompt), cursor: input.cursorOffset }
@@ -655,6 +678,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 +875,29 @@ 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: () => {
+            const reopen = lastPaste?.input === store.prompt.input ? lastPaste.origin : undefined
+            lastPaste = undefined
+            stepUndo("undo")
+            if (reopen) queueMicrotask(() => openPasteDialog(reopen))
+          },
+        },
+        { name: "input.redo", title: "Redo in prompt", category: "Prompt", run: () => stepUndo("redo") },
+      ],
+    }
+  })
+
   useBindings(() => {
     return {
       target: inputTarget,
@@ -1146,12 +1239,12 @@ export function Prompt(props: PromptProps) {
     return true
   }
 
-  function pasteText(text: string, virtualText: string) {
+  function pasteText(text: string, virtualText: string, after = " ") {
     const currentOffset = input.cursorOffset
     const extmarkStart = currentOffset
     const extmarkEnd = extmarkStart + promptOffsetWidth(virtualText)
 
-    input.insertText(virtualText + " ")
+    input.insertText(virtualText + after)
 
     const extmarkId = input.extmarks.create({
       start: extmarkStart,
@@ -1203,16 +1296,22 @@ export function Prompt(props: PromptProps) {
       }
     }
 
-    const lineCount = (pastedContent.match(/\n/g)?.length ?? 0) + 1
-    if (
-      (lineCount >= 3 || pastedContent.length > 150) &&
-      kv.get("paste_summary_enabled", !sync.data.config.experimental?.disable_paste_summary)
-    ) {
-      pasteText(pastedContent, `[Pasted ~${lineCount} lines]`)
+    if (tuiConfig.prompt?.paste_mode === "dialog") {
+      openPasteDialog({ source: normalizedText, options: readPasteOptions(kv.get(PasteOptionsKVKey)) })
       return
     }
 
-    input.insertText(normalizedText)
+    const summary = pasteSummary(pastedContent, tuiConfig.prompt?.paste_summary)
+    if (summary && kv.get("paste_summary_enabled", !sync.data.config.experimental?.disable_paste_summary)) {
+      pasteText(pastedContent, summary)
+      return
+    }
+
+    insertPastedText(normalizedText)
+  }
+
+  function insertPastedText(text: string) {
+    input.insertText(text)
 
     setTimeout(() => {
       if (!input || input.isDestroyed) return
@@ -1269,6 +1368,108 @@ export function Prompt(props: PromptProps) {
     return
   }
 
+  // The paste placeholder the caret is on, as a click inside one leaves it.
+  function pasteAtCaret() {
+    const offset = input.cursorOffset
+    return input.extmarks.getAllForTypeId(promptPartTypeId).find((extmark) => {
+      if (offset < extmark.start || offset >= extmark.end) return false
+      const partIndex = store.extmarkToPartIndex.get(extmark.id)
+      return partIndex !== undefined && store.prompt.parts[partIndex]?.type === "text"
+    })
+  }
+
+  function openPaste() {
+    const extmark = pasteAtCaret()
+    if (!extmark) return false
+    const part = store.prompt.parts[store.extmarkToPartIndex.get(extmark.id)!]
+    if (part?.type !== "text") return false
+    input.cursorOffset = extmark.end
+    if (tuiConfig.prompt?.paste_mode === "dialog") {
+      openPasteDialog(
+        pasteOrigins.get(part.text) ?? { source: part.text, options: { ...PasteOptionsDefault } },
+        extmark.id,
+      )
+      return true
+    }
+    const original = part.text
+    let text = original
+    let inline = false
+    dialog.replace(
+      () => (
+        <DialogPaste
+          text={original}
+          color={borderHighlight()}
+          onChange={(value) => (text = value)}
+          onInline={() => (inline = true)}
+        />
+      ),
+      () => {
+        if (inline || text !== original) replacePaste(extmark.id, text, inline)
+      },
+    )
+    return true
+  }
+
+  // The paste dialog, for a new paste or for the placeholder `extmarkId`, which its result replaces.
+  function openPasteDialog(origin: PasteOrigin, extmarkId?: number) {
+    let result: PasteResult | undefined
+    dialog.replace(
+      () => <DialogPasteOptions origin={origin} color={borderHighlight()} onPaste={(value) => (result = value)} />,
+      () => {
+        if (result) placePaste(result, extmarkId)
+      },
+    )
+  }
+
+  function placePaste(result: PasteResult, extmarkId?: number) {
+    if (!input || input.isDestroyed) return
+    const text = normalizeLineEndings(result.text)
+    if (!result.inline && text) pasteOrigins.set(text, result.origin)
+    if (pasteOrigins.size > 100) pasteOrigins.delete(pasteOrigins.keys().next().value!)
+    if (extmarkId !== undefined) return replacePaste(extmarkId, text, result.inline)
+    if (!text) return
+    if (!undoApplying) promptUndo.observe(undoState())
+    promptUndo.split()
+    if (result.inline) insertPastedText(text)
+    else pasteText(text, pasteLabel(text, tuiConfig.prompt?.paste_summary))
+    // After the prompt's own observer has recorded the paste, which it does in a microtask.
+    queueMicrotask(() => {
+      if (!input || input.isDestroyed) return
+      if (!undoApplying) promptUndo.observe(undoState())
+      promptUndo.split()
+      lastPaste = { input: store.prompt.input, origin: result.origin }
+    })
+  }
+
+  // Writes an edited paste back: its text, and its label when the text changed it. Inline, or an
+  // emptied paste, replaces the placeholder with the text itself.
+  function replacePaste(extmarkId: number, text: string, inline: boolean) {
+    if (!input || input.isDestroyed) return
+    const extmark = input.extmarks.get(extmarkId)
+    const partIndex = store.extmarkToPartIndex.get(extmarkId)
+    const part = partIndex === undefined ? undefined : store.prompt.parts[partIndex]
+    if (!extmark || partIndex === undefined || part?.type !== "text" || !part.source) return
+    const content = normalizeLineEndings(text)
+    const label = pasteLabel(content, tuiConfig.prompt?.paste_summary)
+    if (!inline && content && label === part.source.text.value) {
+      setStore(
+        produce((draft) => {
+          const target = draft.prompt.parts[partIndex]
+          if (target?.type === "text") target.text = content
+        }),
+      )
+      observeUndo()
+      return
+    }
+    const start = input.editBuffer.offsetToPosition(extmark.start)
+    const end = input.editBuffer.offsetToPosition(extmark.end)
+    if (!start || !end) return
+    input.editBuffer.deleteRange(start.row, start.col, end.row, end.col)
+    input.cursorOffset = extmark.start
+    if (inline || !content) insertPastedText(content)
+    else pasteText(content, label, "")
+  }
+
   function clearPrompt() {
     if (store.prompt.input.trim().length >= DRAFT_RETENTION_MIN_CHARS || store.prompt.parts.length > 0) {
       history.append({
@@ -1343,118 +1544,117 @@ export function Prompt(props: PromptProps) {
     }
   })
   const maxHeight = createMemo(() => tuiConfig.prompt?.max_height ?? Math.max(6, Math.floor(dimensions().height / 3)))
+  // A click on a paste placeholder opens its text; the press has already put the caret there.
+  const pasteClick = onClick(() => {
+    if (!props.disabled) openPaste()
+  })
   const moveLabelWidth = createMemo(() => Math.max(12, Math.min(44, dimensions().width - 48)))
 
   return (
     <>
       <box ref={(r: BoxRenderable) => (anchor = r)} visible={props.visible !== false} width="100%">
-        <box
-          width="100%"
-          border={["left"]}
-          borderColor={borderHighlight()}
-          customBorderChars={{
-            ...SplitBorder.customBorderChars,
-            bottomLeft: "╹",
-          }}
-        >
-          <box
-            paddingLeft={2}
-            paddingRight={2}
-            paddingTop={1}
-            flexShrink={0}
-            backgroundColor={theme.backgroundElement}
-            flexGrow={1}
+        <PromptFrame color={borderHighlight()}>
+          <textarea
             width="100%"
-          >
-            <textarea
-              width="100%"
-              placeholder={placeholderText()}
-              placeholderColor={theme.textMuted}
-              textColor={leader() ? theme.textMuted : theme.text}
-              focusedTextColor={leader() ? theme.textMuted : theme.text}
-              minHeight={1}
-              maxHeight={maxHeight()}
-              onContentChange={() => {
-                const value = input.plainText
-                setStore("prompt", "input", value)
-                auto()?.onInput(value)
-                syncExtmarksWithPromptParts()
-                setCursorVersion((value) => value + 1)
-              }}
-              onCursorChange={() => setCursorVersion((value) => value + 1)}
-              onKeyDown={(e: { preventDefault(): void }) => {
-                if (props.disabled) {
-                  e.preventDefault()
-                  return
-                }
-              }}
-              onSubmit={() => {
-                // IME: double-defer so the last composed character (e.g. Korean
-                // hangul) is flushed to plainText before we read it for submission.
-                setTimeout(() => setTimeout(() => submit(), 0), 0)
-              }}
-              onPaste={async (event: PasteEvent) => {
-                if (props.disabled) {
-                  event.preventDefault()
-                  return
-                }
-
-                // Normalize line endings at the boundary
-                // Windows ConPTY/Terminal often sends CR-only newlines in bracketed paste
-                // Replace CRLF first, then any remaining CR
-                const normalizedText = decodePasteBytes(event.bytes).replace(/\r\n/g, "\n").replace(/\r/g, "\n")
-                const pastedContent = normalizedText.trim()
-
-                // Windows Terminal <1.25 can surface image-only clipboard as an
-                // empty bracketed paste. Windows Terminal 1.25+ does not.
-                if (!pastedContent) {
-                  keymap.dispatchCommand("prompt.paste")
-                  return
-                }
-
-                // Once we cross an async boundary below, the terminal may perform its
-                // default paste unless we suppress it first and handle insertion ourselves.
+            placeholder={placeholderText()}
+            placeholderColor={theme.textMuted}
+            textColor={leader() ? theme.textMuted : theme.text}
+            focusedTextColor={leader() ? theme.textMuted : theme.text}
+            minHeight={1}
+            maxHeight={maxHeight()}
+            onContentChange={() => {
+              const value = input.plainText
+              setStore("prompt", "input", value)
+              auto()?.onInput(value)
+              syncExtmarksWithPromptParts()
+              setCursorVersion((value) => value + 1)
+              observeUndo()
+            }}
+            onCursorChange={() => {
+              setCursorVersion((value) => value + 1)
+              observeUndo()
+            }}
+            onKeyDown={(e: { preventDefault(): void }) => {
+              if (props.disabled) {
+                e.preventDefault()
+                return
+              }
+            }}
+            onSubmit={() => {
+              // IME: double-defer so the last composed character (e.g. Korean
+              // hangul) is flushed to plainText before we read it for submission.
+              setTimeout(() => setTimeout(() => submit(), 0), 0)
+            }}
+            onPaste={async (event: PasteEvent) => {
+              if (props.disabled) {
                 event.preventDefault()
+                return
+              }
 
-                await pasteInputText(normalizedText)
-              }}
-              ref={(r: TextareaRenderable) => {
-                input = r
-                Object.assign(r, {
-                  getClipboardText: (text: string) => expandPastedTextPlaceholders(text, store.prompt.parts),
-                })
-                setInputTarget(r)
-                if (promptPartTypeId === 0) {
-                  promptPartTypeId = input.extmarks.registerType("prompt-part")
-                }
-                props.ref?.(ref)
-                setTimeout(() => {
-                  // setTimeout is a workaround and needs to be addressed properly
-                  if (!input || input.isDestroyed) return
-                  input.cursorColor = theme.text
-                  if (tuiConfig.cursor) input.cursorStyle = tuiConfig.cursor
-                }, 0)
-              }}
-              onMouseDown={(r: MouseEvent) => r.target?.focus()}
-              focusedBackgroundColor={theme.backgroundElement}
-              cursorColor={props.disabled ? theme.backgroundElement : theme.text}
-              cursorStyle={tuiConfig.cursor}
-              syntaxStyle={syntax()}
-            />
-            <box flexDirection="row" flexShrink={0} paddingTop={1} gap={1} justifyContent="space-between">
-              <box flexDirection="row" gap={1}>
-                <Show when={local.agent.current()} fallback={<box height={1} />}>
-                  {(agent) => (
-                    <>
-                      <text fg={fadeColor(highlight(), agentMetaAlpha())}>
-                        {store.mode === "shell" ? "Shell" : Locale.titlecase(agent().name)}
-                      </text>
-                      <Show when={store.mode === "normal" && local.permission.mode === "auto"}>
-                        <text fg={fadeColor(theme.textMuted, agentMetaAlpha())}>auto</text>
-                      </Show>
-                      <Show when={store.mode === "normal"}>
-                        <box flexDirection="row" gap={1}>
-                          <text fg={fadeColor(theme.textMuted, modelMetaAlpha())}>·</text>
+              // Normalize line endings at the boundary
+              // Windows ConPTY/Terminal often sends CR-only newlines in bracketed paste
+              // Replace CRLF first, then any remaining CR
+              const normalizedText = decodePasteBytes(event.bytes).replace(/\r\n/g, "\n").replace(/\r/g, "\n")
+              const pastedContent = normalizedText.trim()
+
+              // Windows Terminal <1.25 can surface image-only clipboard as an
+              // empty bracketed paste. Windows Terminal 1.25+ does not.
+              if (!pastedContent) {
+                keymap.dispatchCommand("prompt.paste")
+                return
+              }
+
+              // Once we cross an async boundary below, the terminal may perform its
+              // default paste unless we suppress it first and handle insertion ourselves.
+              event.preventDefault()
+
+              await pasteInputText(normalizedText)
+            }}
+            ref={(r: TextareaRenderable) => {
+              input = r
+              Object.assign(r, {
+                getClipboardText: (text: string) => expandPastedTextPlaceholders(text, store.prompt.parts),
+              })
+              setInputTarget(r)
+              if (promptPartTypeId === 0) {
+                promptPartTypeId = input.extmarks.registerType("prompt-part")
+              }
+              props.ref?.(ref)
+              setTimeout(() => {
+                // setTimeout is a workaround and needs to be addressed properly
+                if (!input || input.isDestroyed) return
+                input.cursorColor = theme.text
+                if (tuiConfig.cursor) input.cursorStyle = tuiConfig.cursor
+              }, 0)
+            }}
+            onMouseDown={(r: MouseEvent) => {
+              r.target?.focus()
+              pasteClick.onMouseDown(r)
+            }}
+            onMouseUp={pasteClick.onMouseUp}
+            focusedBackgroundColor={theme.backgroundElement}
+            cursorColor={props.disabled ? theme.backgroundElement : theme.text}
+            cursorStyle={tuiConfig.cursor}
+            syntaxStyle={syntax()}
+          />
+          <box flexDirection="row" flexShrink={0} paddingTop={1} gap={1} justifyContent="space-between">
+            <box flexDirection="row" gap={1}>
+              <Show when={local.agent.current()} fallback={<box height={1} />}>
+                {(agent) => (
+                  <>
+                    <text
+                      fg={fadeColor(highlight(), agentMetaAlpha())}
+                      {...onClick(() => keymap.dispatchCommand("agent.list"))}
+                    >
+                      {store.mode === "shell" ? "Shell" : Locale.titlecase(agent().name)}
+                    </text>
+                    <Show when={store.mode === "normal" && local.permission.mode === "auto"}>
+                      <text fg={fadeColor(theme.textMuted, agentMetaAlpha())}>auto</text>
+                    </Show>
+                    <Show when={store.mode === "normal"}>
+                      <box flexDirection="row" gap={1}>
+                        <text fg={fadeColor(theme.textMuted, modelMetaAlpha())}>·</text>
+                        <box flexDirection="row" gap={1} {...onClick(() => keymap.dispatchCommand("model.list"))}>
                           <text
                             flexShrink={0}
                             fg={fadeColor(leader() ? theme.textMuted : theme.text, modelMetaAlpha())}
@@ -1462,54 +1662,28 @@ export function Prompt(props: PromptProps) {
                             {local.model.parsed().model}
                           </text>
                           <text fg={fadeColor(theme.textMuted, modelMetaAlpha())}>{currentProviderLabel()}</text>
-                          <Show when={showVariant()}>
-                            <text fg={fadeColor(theme.textMuted, variantMetaAlpha())}>·</text>
-                            <text>
-                              <span style={{ fg: fadeColor(theme.warning, variantMetaAlpha()), bold: true }}>
-                                {local.model.variant.current()}
-                              </span>
-                            </text>
-                          </Show>
                         </box>
-                      </Show>
-                    </>
-                  )}
-                </Show>
-              </box>
-              <Show when={hasRightContent()}>
-                <box flexDirection="row" gap={1} alignItems="center">
-                  {props.right}
-                </box>
+                        <Show when={showVariant()}>
+                          <text fg={fadeColor(theme.textMuted, variantMetaAlpha())}>·</text>
+                          <text {...onClick(() => keymap.dispatchCommand("variant.list"))}>
+                            <span style={{ fg: fadeColor(theme.warning, variantMetaAlpha()), bold: true }}>
+                              {local.model.variant.current()}
+                            </span>
+                          </text>
+                        </Show>
+                      </box>
+                    </Show>
+                  </>
+                )}
               </Show>
             </box>
+            <Show when={hasRightContent()}>
+              <box flexDirection="row" gap={1} alignItems="center">
+                {props.right}
+              </box>
+            </Show>
           </box>
-        </box>
-        <box
-          height={1}
-          border={["left"]}
-          borderColor={borderHighlight()}
-          customBorderChars={{
-            ...EmptyBorder,
-            vertical: theme.backgroundElement.a !== 0 ? "╹" : " ",
-          }}
-        >
-          <box
-            height={1}
-            border={["bottom"]}
-            borderColor={theme.backgroundElement}
-            customBorderChars={
-              theme.backgroundElement.a !== 0
-                ? {
-                    ...EmptyBorder,
-                    horizontal: "▀",
-                  }
-                : {
-                    ...EmptyBorder,
-                    horizontal: " ",
-                  }
-            }
-          />
-        </box>
+        </PromptFrame>
         <box width="100%" flexDirection="row" justifyContent="space-between">
           <Switch>
             <Match when={status().type !== "idle"}>
@@ -1584,7 +1758,10 @@ export function Prompt(props: PromptProps) {
                     })()}
                   </box>
                 </box>
-                <text fg={store.interrupt > 0 ? theme.primary : theme.text}>
+                <text
+                  fg={store.interrupt > 0 ? theme.primary : theme.text}
+                  {...onClick(() => keymap.dispatchCommand("session.interrupt"))}
+                >
                   esc{" "}
                   <span style={{ fg: store.interrupt > 0 ? theme.primary : theme.textMuted }}>
                     {store.interrupt > 0 ? "again to interrupt" : "interrupt"}
@@ -1646,7 +1823,12 @@ export function Prompt(props: PromptProps) {
               {props.hint ?? (
                 <Show when={props.sessionID} fallback={<text />}>
                   <box marginLeft={1}>
-                    <text fg={theme.textMuted}>{location()?.directory ?? paths.cwd}</text>
+                    <text
+                      fg={theme.textMuted}
+                      {...onClick(() => copyText(clipboard, toast.show, location()?.directory ?? paths.cwd))}
+                    >
+                      {location()?.directory ?? paths.cwd}
+                    </text>
                   </box>
                 </Show>
               )}
@@ -1664,18 +1846,22 @@ export function Prompt(props: PromptProps) {
                   <Switch>
                     <Match when={usage()}>
                       {(item) => (
-                        <text fg={theme.textMuted} wrapMode="none">
+                        <text
+                          fg={theme.textMuted}
+                          wrapMode="none"
+                          {...onClick(() => keymap.dispatchCommand("opencode.status"))}
+                        >
                           {[item().context, item().cost].filter(Boolean).join(" · ")}
                         </text>
                       )}
                     </Match>
                     <Match when={true}>
-                      <text fg={theme.text}>
+                      <text fg={theme.text} {...onClick(() => keymap.dispatchCommand("agent.cycle"))}>
                         {agentShortcut()} <span style={{ fg: theme.textMuted }}>agents</span>
                       </text>
                     </Match>
                   </Switch>
-                  <text fg={theme.text}>
+                  <text fg={theme.text} {...onClick(() => keymap.dispatchCommand("command.palette.show"))}>
                     {paletteShortcut()} <span style={{ fg: theme.textMuted }}>commands</span>
                   </text>
                 </Match>
diff --git a/packages/tui/src/config/index.tsx b/packages/tui/src/config/index.tsx
index bde0bfb0718a..3b6d3e004b17 100644
--- a/packages/tui/src/config/index.tsx
+++ b/packages/tui/src/config/index.tsx
@@ -50,13 +50,51 @@ export const Attention = Schema.Struct({
   sounds: Schema.optional(AttentionSounds),
 }).annotate({ description: "Attention notification and sound settings" })
 
+export const PasteSummaryDefaults = {
+  lines: 3,
+  characters: 150,
+  format: "[Pasted ~{lines} lines]",
+  excerpt: 30,
+}
+export const PasteSummary = Schema.Struct({
+  lines: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))).annotate({
+    description: "A paste of at least this many lines is summarized (default: 3)",
+  }),
+  characters: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))).annotate({
+    description: "A paste longer than this many characters is summarized (default: 150)",
+  }),
+  format: Schema.optional(Schema.String.check(Schema.isMinLength(1))).annotate({
+    description: [
+      "The placeholder a summarized paste shows (default: '[Pasted ~{lines} lines]').",
+      "{lines} is its line count, {characters} its length, {bytes} its size in UTF-8 bytes,",
+      "{excerpt} its start with line breaks and repeated spaces collapsed",
+    ].join(" "),
+  }),
+  excerpt: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))).annotate({
+    description: "Characters {excerpt} shows before it is cut with '…' (default: 30)",
+  }),
+}).annotate({ description: "When a paste is replaced by a placeholder, and what the placeholder says" })
+export type PasteSummary = Schema.Schema.Type<typeof PasteSummary>
+
 const PromptSize = Schema.Int.check(Schema.isGreaterThan(0))
 export const Prompt = Schema.Struct({
   max_height: Schema.optional(PromptSize).annotate({ description: "Prompt textarea max height" }),
   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" })
+  paste_summary: Schema.optional(PasteSummary),
+  paste_mode: Schema.optional(Schema.Literals(["direct", "dialog"])).annotate({
+    description: [
+      "What pasting text into the prompt does: 'direct' (default) puts it in, as a placeholder once it is",
+      "long (paste_summary); 'dialog' opens the paste dialog first, to clean it up, wrap or quote it and",
+      "choose between its text and a placeholder, with the choices remembered for the next paste",
+    ].join(" "),
+  }),
+  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/context/local.tsx b/packages/tui/src/context/local.tsx
index a05d315166ed..90d21198e01a 100644
--- a/packages/tui/src/context/local.tsx
+++ b/packages/tui/src/context/local.tsx
@@ -1,6 +1,6 @@
 import { createStore } from "solid-js/store"
 import { createSimpleContext } from "./helper"
-import { batch, createEffect, createMemo } from "solid-js"
+import { batch, createEffect, createMemo, createSignal } from "solid-js"
 import { useSync } from "./sync"
 import { useEvent } from "./event"
 import path from "path"
@@ -48,7 +48,11 @@ export function recentModels(
     .map((item) => ({ providerID: item.providerID, modelID: item.modelID }))
 }
 
-export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
+export const {
+  use: useLocal,
+  provider: LocalProvider,
+  context: LocalContext,
+} = createSimpleContext({
   name: "Local",
   init: () => {
     const sync = useSync()
@@ -502,19 +506,33 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
 
     const session = createSession()
 
+    const [mcpPending, setMcpPending] = createSignal<string>()
     const mcp = {
       isEnabled(name: string) {
         const status = sync.data.mcp[name]
         return status?.status === "connected"
       },
+      // The MCP being toggled; a toggle while one is in progress is ignored.
+      pending: mcpPending,
       async toggle(name: string) {
-        const status = sync.data.mcp[name]
-        if (status?.status === "connected") {
-          // Disable: disconnect the MCP
-          await sdk.client.mcp.disconnect({ name })
-        } else {
-          // Enable/Retry: connect the MCP (handles disabled, failed, and other states)
-          await sdk.client.mcp.connect({ name })
+        if (mcpPending() !== undefined) return
+        setMcpPending(name)
+        try {
+          const status = sync.data.mcp[name]
+          if (status?.status === "connected") {
+            // Disable: disconnect the MCP
+            await sdk.client.mcp.disconnect({ name })
+          } else {
+            // Enable/Retry: connect the MCP (handles disabled, failed, and other states)
+            await sdk.client.mcp.connect({ name })
+          }
+          const next = await sdk.client.mcp.status()
+          if (next.data) sync.set("mcp", next.data)
+          else console.error("Failed to refresh MCP status: no data returned")
+        } catch (error) {
+          console.error("Failed to toggle MCP:", error)
+        } finally {
+          setMcpPending(undefined)
         }
       },
     }
diff --git a/packages/tui/src/context/prompt.tsx b/packages/tui/src/context/prompt.tsx
index efbb050645ef..3476e2e3b929 100644
--- a/packages/tui/src/context/prompt.tsx
+++ b/packages/tui/src/context/prompt.tsx
@@ -1,7 +1,11 @@
 import { createSimpleContext } from "./helper"
 import type { PromptRef } from "../component/prompt"
 
-export const { use: usePromptRef, provider: PromptRefProvider } = createSimpleContext({
+export const {
+  use: usePromptRef,
+  provider: PromptRefProvider,
+  context: PromptRefContext,
+} = createSimpleContext({
   name: "PromptRef",
   init: () => {
     let current: PromptRef | undefined
diff --git a/packages/tui/src/feature-plugins/home/footer.tsx b/packages/tui/src/feature-plugins/home/footer.tsx
index 41bee5da5a49..4a99d211583a 100644
--- a/packages/tui/src/feature-plugins/home/footer.tsx
+++ b/packages/tui/src/feature-plugins/home/footer.tsx
@@ -4,6 +4,8 @@ import { createMemo, Match, Show, Switch } from "solid-js"
 import { abbreviateHome } from "../../runtime"
 import { useTuiPaths } from "../../context/runtime"
 import { useHomeSessionDestination } from "../../routes/home/session-destination"
+import { copyText, onClick } from "../../ui/click"
+import { useClipboard } from "../../context/clipboard"
 
 const id = "internal:home-footer"
 
@@ -11,17 +13,30 @@ function Directory(props: { api: TuiPluginApi }) {
   const theme = () => props.api.theme.current
   const destination = useHomeSessionDestination()
   const paths = useTuiPaths()
-  const dir = createMemo(() => {
+  const clipboard = useClipboard()
+  const directory = createMemo(() => {
     const selected = destination?.destination()
     if (!selected || selected.type === "new") return
-    const out = abbreviateHome(selected.directory, paths.home)
-    const branch =
-      selected.directory === (props.api.state.path.directory || paths.cwd) ? props.api.state.vcs?.branch : undefined
+    return selected.directory
+  })
+  const dir = createMemo(() => {
+    const value = directory()
+    if (!value) return
+    const out = abbreviateHome(value, paths.home)
+    const branch = value === (props.api.state.path.directory || paths.cwd) ? props.api.state.vcs?.branch : undefined
     if (branch) return out + ":" + branch
     return out
   })
 
-  return <Show when={dir()}>{(value) => <text fg={theme().textMuted}>{value()}</text>}</Show>
+  return (
+    <Show when={dir()}>
+      {(value) => (
+        <text fg={theme().textMuted} {...onClick(() => copyText(clipboard, props.api.ui.toast, directory()!))}>
+          {value()}
+        </text>
+      )}
+    </Show>
+  )
 }
 
 function Mcp(props: { api: TuiPluginApi }) {
@@ -33,7 +48,12 @@ function Mcp(props: { api: TuiPluginApi }) {
 
   return (
     <Show when={has()}>
-      <box gap={1} flexDirection="row" flexShrink={0}>
+      <box
+        gap={1}
+        flexDirection="row"
+        flexShrink={0}
+        {...onClick(() => props.api.keymap.dispatchCommand("opencode.status"))}
+      >
         <text fg={theme().text}>
           <Switch>
             <Match when={err()}>
diff --git a/packages/tui/src/feature-plugins/sidebar/context.tsx b/packages/tui/src/feature-plugins/sidebar/context.tsx
index f1c99d9679ce..9d6943fdcd5f 100644
--- a/packages/tui/src/feature-plugins/sidebar/context.tsx
+++ b/packages/tui/src/feature-plugins/sidebar/context.tsx
@@ -2,6 +2,7 @@ import type { AssistantMessage } from "@opencode-ai/sdk/v2"
 import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui"
 import type { BuiltinTuiPlugin } from "../builtins"
 import { createMemo } from "solid-js"
+import { onClick } from "../../ui/click"
 
 const id = "internal:sidebar-context"
 
@@ -39,9 +40,11 @@ function View(props: { api: TuiPluginApi; session_id: string }) {
       <text fg={theme().text}>
         <b>Context</b>
       </text>
-      <text fg={theme().textMuted}>{state().tokens.toLocaleString()} tokens</text>
-      <text fg={theme().textMuted}>{state().percent ?? 0}% used</text>
-      <text fg={theme().textMuted}>{money.format(cost())} spent</text>
+      <box {...onClick(() => props.api.keymap.dispatchCommand("opencode.status"))}>
+        <text fg={theme().textMuted}>{state().tokens.toLocaleString()} tokens</text>
+        <text fg={theme().textMuted}>{state().percent ?? 0}% used</text>
+        <text fg={theme().textMuted}>{money.format(cost())} spent</text>
+      </box>
     </box>
   )
 }
diff --git a/packages/tui/src/feature-plugins/sidebar/files.tsx b/packages/tui/src/feature-plugins/sidebar/files.tsx
index 01f33f647d69..5bdf0872ac0c 100644
--- a/packages/tui/src/feature-plugins/sidebar/files.tsx
+++ b/packages/tui/src/feature-plugins/sidebar/files.tsx
@@ -2,6 +2,7 @@ import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui"
 import type { BuiltinTuiPlugin } from "../builtins"
 import { createMemo, For, Show, createSignal } from "solid-js"
 import { Locale } from "../../util/locale"
+import { onClick } from "../../ui/click"
 
 const id = "internal:sidebar-files"
 
@@ -30,7 +31,20 @@ function View(props: { api: TuiPluginApi; session_id: string }) {
         <Show when={list().length <= 2 || open()}>
           <For each={list()}>
             {(item) => (
-              <box flexDirection="row" gap={1} justifyContent="space-between">
+              <box
+                flexDirection="row"
+                gap={1}
+                justifyContent="space-between"
+                {...onClick(() =>
+                  // /diff, opened at this file.
+                  props.api.route.navigate("diff", {
+                    mode: "git",
+                    sessionID: props.session_id,
+                    returnRoute: props.api.route.current,
+                    file: item.file,
+                  }),
+                )}
+              >
                 <text fg={theme().textMuted} wrapMode="none">
                   {Locale.truncateLeft(item.file, Math.max(2, 36 - changeCountWidth(item)))}
                 </text>
diff --git a/packages/tui/src/feature-plugins/sidebar/footer.tsx b/packages/tui/src/feature-plugins/sidebar/footer.tsx
index c59046a01722..3b76ba1ac58a 100644
--- a/packages/tui/src/feature-plugins/sidebar/footer.tsx
+++ b/packages/tui/src/feature-plugins/sidebar/footer.tsx
@@ -3,11 +3,14 @@ import type { BuiltinTuiPlugin } from "../builtins"
 import { createMemo, Show } from "solid-js"
 import { abbreviateHome } from "../../runtime"
 import { useTuiPaths } from "../../context/runtime"
+import { copyText, onClick } from "../../ui/click"
+import { useClipboard } from "../../context/clipboard"
 
 const id = "internal:sidebar-footer"
 
 function View(props: { api: TuiPluginApi; sessionID: string }) {
   const paths = useTuiPaths()
+  const clipboard = useClipboard()
   const theme = () => props.api.theme.current
   const has = createMemo(() =>
     props.api.state.provider.some(
@@ -24,6 +27,7 @@ function View(props: { api: TuiPluginApi; sessionID: string }) {
     const text = branch ? out + ":" + branch : out
     const list = text.split("/")
     return {
+      directory: dir,
       parent: list.slice(0, -1).join("/"),
       name: list.at(-1) ?? "",
     }
@@ -57,14 +61,19 @@ function View(props: { api: TuiPluginApi; sessionID: string }) {
             <text fg={theme().textMuted}>
               Connect from 75+ providers to use other models, including Claude, GPT, Gemini etc
             </text>
-            <box flexDirection="row" gap={1} justifyContent="space-between">
+            <box
+              flexDirection="row"
+              gap={1}
+              justifyContent="space-between"
+              {...onClick(() => props.api.keymap.dispatchCommand("provider.connect"))}
+            >
               <text fg={theme().text}>Connect provider</text>
               <text fg={theme().textMuted}>/connect</text>
             </box>
           </box>
         </box>
       </Show>
-      <text>
+      <text {...onClick(() => copyText(clipboard, props.api.ui.toast, path().directory))}>
         <span style={{ fg: theme().textMuted }}>{path().parent}/</span>
         <span style={{ fg: theme().text }}>{path().name}</span>
       </text>
diff --git a/packages/tui/src/feature-plugins/sidebar/mcp.tsx b/packages/tui/src/feature-plugins/sidebar/mcp.tsx
index 99d8567ea73c..e712718ba3a7 100644
--- a/packages/tui/src/feature-plugins/sidebar/mcp.tsx
+++ b/packages/tui/src/feature-plugins/sidebar/mcp.tsx
@@ -1,12 +1,18 @@
 import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui"
 import type { BuiltinTuiPlugin } from "../builtins"
-import { createMemo, For, Match, Show, Switch, createSignal } from "solid-js"
+import { createMemo, For, Match, Show, Switch, createSignal, useContext } from "solid-js"
+import { LocalContext } from "../../context/local"
+import { onClick } from "../../ui/click"
 
 const id = "internal:sidebar-mcp"
 
 function View(props: { api: TuiPluginApi }) {
   const [open, setOpen] = createSignal(true)
   const theme = () => props.api.theme.current
+  // Clicking a server toggles it. A host without the app's local state (a test
+  // harness) still renders the list, without the toggle.
+  const local = useContext(LocalContext)
+  const pending = (name: string) => local?.mcp.pending() === name
   const list = createMemo(() => props.api.state.mcp())
   const on = createMemo(() => list().filter((item) => item.status === "connected").length)
   const bad = createMemo(
@@ -46,14 +52,14 @@ function View(props: { api: TuiPluginApi }) {
         <Show when={list().length <= 2 || open()}>
           <For each={list()}>
             {(item) => (
-              <box flexDirection="row" gap={1}>
+              <box flexDirection="row" gap={1} {...onClick(() => local?.mcp.toggle(item.name))}>
                 <text
                   flexShrink={0}
                   style={{
-                    fg: dot(item.status),
+                    fg: pending(item.name) ? theme().textMuted : dot(item.status),
                   }}
                 >
-                  •
+                  {pending(item.name) ? "⋯" : "•"}
                 </text>
                 <text fg={theme().text} wrapMode="word">
                   {item.name}{" "}
diff --git a/packages/tui/src/feature-plugins/sidebar/todo.tsx b/packages/tui/src/feature-plugins/sidebar/todo.tsx
index 15a78b0ebbf8..dd1fe5fa55c8 100644
--- a/packages/tui/src/feature-plugins/sidebar/todo.tsx
+++ b/packages/tui/src/feature-plugins/sidebar/todo.tsx
@@ -1,14 +1,32 @@
 import type { TuiPlugin, TuiPluginApi } from "@opencode-ai/plugin/tui"
 import type { BuiltinTuiPlugin } from "../builtins"
-import { createMemo, For, Show, createSignal } from "solid-js"
+import { createMemo, For, Show, createSignal, useContext } from "solid-js"
+import { unwrap } from "solid-js/store"
 import { TodoItem } from "../../component/todo-item"
+import { useClipboard } from "../../context/clipboard"
+import { PromptRefContext } from "../../context/prompt"
+import { copyText, onClick } from "../../ui/click"
 
 const id = "internal:sidebar-todo"
 
 function View(props: { api: TuiPluginApi; session_id: string }) {
   const [open, setOpen] = createSignal(true)
   const theme = () => props.api.theme.current
+  const clipboard = useClipboard()
+  const prompt = useContext(PromptRefContext)
   const list = createMemo(() => props.api.state.session.todo(props.session_id))
+  // A clicked todo is copied and added to the end of the prompt, so it can be
+  // quoted to the agent or pasted elsewhere.
+  const pick = (content: string) => {
+    copyText(clipboard, props.api.ui.toast, content, "the todo")
+    const ref = prompt?.current
+    if (!ref) return
+    const input = ref.current.input
+    ref.set({
+      ...unwrap(ref.current),
+      input: input && !/\s$/.test(input) ? `${input} ${content}` : `${input}${content}`,
+    })
+  }
   const show = createMemo(() => list().length > 0 && list().some((item) => item.status !== "completed"))
 
   return (
@@ -23,7 +41,13 @@ function View(props: { api: TuiPluginApi; session_id: string }) {
           </text>
         </box>
         <Show when={list().length <= 2 || open()}>
-          <For each={list()}>{(item) => <TodoItem status={item.status} content={item.content} />}</For>
+          <For each={list()}>
+            {(item) => (
+              <box {...onClick(() => pick(item.content))}>
+                <TodoItem status={item.status} content={item.content} />
+              </box>
+            )}
+          </For>
         </Show>
       </box>
     </Show>
diff --git a/packages/tui/src/feature-plugins/system/diff-viewer.tsx b/packages/tui/src/feature-plugins/system/diff-viewer.tsx
index c4c6aed646e5..70e91af3c326 100644
--- a/packages/tui/src/feature-plugins/system/diff-viewer.tsx
+++ b/packages/tui/src/feature-plugins/system/diff-viewer.tsx
@@ -99,6 +99,8 @@ function DiffViewer(props: { api: TuiPluginApi }) {
           sessionID?: string
           messageID?: string
           returnRoute?: TuiRouteCurrent
+          // A file to open at, e.g. a row clicked in the sidebar's Modified Files.
+          file?: string
         }
       | undefined
   const mode = () => params()?.mode ?? "git"
@@ -352,6 +354,18 @@ function DiffViewer(props: { api: TuiPluginApi }) {
     })
   }
 
+  // Opened at a file: select and scroll to it once the diff has loaded.
+  let openedAt = false
+  createEffect(() => {
+    const file = params()?.file
+    if (openedAt || !file || files().length === 0) return
+    openedAt = true
+    const fileIndex = files().findIndex((item) => item.file === file)
+    if (fileIndex < 0) return
+    selectPatchFile(fileIndex)
+    scrollToPatchFileIndexAfterRender(fileIndex)
+  })
+
   const scrollSinglePatchToTop = () => {
     requestAnimationFrame(() => {
       scroll?.scrollTo(0)
diff --git a/packages/tui/src/prompt/paste-options.ts b/packages/tui/src/prompt/paste-options.ts
new file mode 100644
index 000000000000..d5ffca727479
--- /dev/null
+++ b/packages/tui/src/prompt/paste-options.ts
@@ -0,0 +1,186 @@
+// What the paste dialog can do with a paste before it goes into the prompt. The dialog shows the
+// options in this order; every one is off until the user turns it on, and the last choice is kept.
+export const PasteOptionList = [
+  { key: "inline", label: "insert inline" },
+  { key: "fence", label: "wrap with ```" },
+  { key: "code", label: "wrap with `" },
+  { key: "quote", label: "quote with >" },
+  { key: "trim", label: "trim whitespace" },
+  { key: "dedent", label: "normalize indents" },
+  { key: "unindent", label: "remove indents" },
+  { key: "collapse", label: "collapse blank lines" },
+  { key: "join", label: "join into one line" },
+  { key: "ansi", label: "strip ANSI escapes" },
+] as const
+
+// Where the last choices are kept in kv.json, so the next paste starts from them.
+export const PasteOptionsKVKey = "paste_options"
+
+export type PasteOptionKey = (typeof PasteOptionList)[number]["key"]
+export type PasteOptions = Record<PasteOptionKey, boolean>
+
+export const PasteOptionsDefault: PasteOptions = {
+  inline: false,
+  fence: false,
+  code: false,
+  quote: false,
+  trim: false,
+  dedent: false,
+  unindent: false,
+  collapse: false,
+  join: false,
+  ansi: false,
+}
+
+// The options as stored, keeping only known keys, so a stale or hand-edited value cannot break them.
+export function readPasteOptions(value: unknown): PasteOptions {
+  if (!value || typeof value !== "object") return { ...PasteOptionsDefault }
+  const stored = value as Record<string, unknown>
+  return Object.fromEntries(
+    PasteOptionList.map((option) => [option.key, stored[option.key] === true]),
+  ) as PasteOptions
+}
+
+// Turning one wrap on turns the other off: a paste is either a code block or inline code.
+export function togglePasteOption(options: PasteOptions, key: PasteOptionKey): PasteOptions {
+  const next = { ...options, [key]: !options[key] }
+  if (key === "fence" && next.fence) next.code = false
+  if (key === "code" && next.code) next.fence = false
+  return next
+}
+
+// Off and greyed out in the dialog, keeping its stored value: inline code for text of more than one
+// line, and a cleanup another one already covers - remove indents leaves normalize indents no
+// indent to remove, and join into one line leaves collapse blank lines no blank line.
+export function pasteOptionDisabled(key: PasteOptionKey, body: string, options: PasteOptions) {
+  if (key === "code") return body.includes("\n")
+  if (key === "dedent") return options.unindent
+  if (key === "collapse") return options.join
+  return false
+}
+
+// The paste as it goes into the prompt: cleaned up, then wrapped.
+export function applyPasteOptions(text: string, options: PasteOptions) {
+  return wrapPaste(cleanPaste(text, options), options)
+}
+
+// The cleanups, each of which leaves its own output unchanged when applied again. The line-based
+// ones run before the join, and the wraps after the cleanups, so a wrap goes around the joined line.
+// A greyed-out cleanup still runs: what covers it leaves it nothing to change.
+export function cleanPaste(text: string, options: PasteOptions) {
+  const stripped = options.ansi ? text.replace(ANSI, "") : text
+  const trimmed = options.trim ? trimLines(stripped) : stripped
+  const dedented = options.dedent ? dedent(trimmed) : trimmed
+  const unindented = options.unindent ? dedented.replace(/^[ \t]+/gm, "") : dedented
+  const collapsed = options.collapse ? unindented.replace(/\n(?:[ \t]*\n){2,}/g, "\n\n") : unindented
+  return options.join ? joinLines(collapsed) : collapsed
+}
+
+// A fence longer than any run of backticks in the text, so the text cannot close it; the quote
+// goes outside the wrap, so a quoted code block stays a code block.
+export function wrapPaste(body: string, options: PasteOptions) {
+  const wrapped = options.fence
+    ? fence(body)
+    : options.code && !pasteOptionDisabled("code", body, options)
+      ? inlineCode(body)
+      : body
+  if (!options.quote) return wrapped
+  return wrapped
+    .split("\n")
+    .map((line) => (line ? `> ${line}` : ">"))
+    .join("\n")
+}
+
+// The text inside the wraps of edited dialog text, and the wraps it still has. A wrap the edit broke,
+// such as a deleted fence line, is dropped rather than guessed at.
+export function unwrapPaste(text: string, options: PasteOptions) {
+  const quoted = options.quote ? unquote(text) : undefined
+  const inner = quoted ?? text
+  const fenced = options.fence ? unfence(inner) : undefined
+  const coded = !options.fence && options.code ? uncode(inner) : undefined
+  return {
+    body: fenced ?? coded ?? inner,
+    options: {
+      ...options,
+      quote: options.quote && quoted !== undefined,
+      fence: options.fence && fenced !== undefined,
+      // Inline code is off for text of more than one line rather than broken by it.
+      code: options.code && (coded !== undefined || inner.includes("\n")),
+    },
+  }
+}
+
+// CSI sequences (colors, cursor moves), OSC sequences (titles, links) and two-byte escapes.
+const ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_]/g
+
+// Each line loses its trailing whitespace; leading whitespace is indentation, which normalize
+// indents handles. Blank lines at the start and the end go.
+function trimLines(text: string) {
+  return text
+    .split("\n")
+    .map((line) => line.trimEnd())
+    .join("\n")
+    .replace(/^\n+/, "")
+    .replace(/\n+$/, "")
+}
+
+// Removes the leading whitespace every non-blank line shares, character for character, so a tab
+// and spaces are never taken for one another; blank lines do not count and lose their whitespace.
+function dedent(text: string) {
+  const lines = text.split("\n")
+  const indents = lines.filter((line) => line.trim()).map((line) => line.match(/^[ \t]*/)![0])
+  if (indents.length === 0) return text
+  const common = indents.reduce((shared, indent) => {
+    let length = 0
+    while (length < shared.length && shared[length] === indent[length]) length++
+    return shared.slice(0, length)
+  })
+  if (!common) return text
+  return lines.map((line) => (line.trim() ? line.slice(common.length) : "")).join("\n")
+}
+
+// One line: blank lines go, and the rest are joined with one space, losing the whitespace at each
+// join (the trailing whitespace before it and the indent after it). Whitespace inside a line and at
+// the paste's two ends is left for the other cleanups. A CR LF or a lone CR is one break.
+function joinLines(text: string) {
+  if (!/[\r\n]/.test(text)) return text
+  const lines = text.split(/\r\n|\r|\n/).filter((line) => line.trim())
+  return lines
+    .map((line, index) => {
+      const start = index === 0 ? line : line.trimStart()
+      return index === lines.length - 1 ? start : start.trimEnd()
+    })
+    .join(" ")
+}
+
+function longestBacktickRun(text: string) {
+  return Math.max(0, ...(text.match(/`+/g) ?? []).map((run) => run.length))
+}
+
+function fence(body: string) {
+  const ticks = "`".repeat(Math.max(3, longestBacktickRun(body) + 1))
+  return `${ticks}\n${body}\n${ticks}`
+}
+
+function inlineCode(body: string) {
+  const ticks = "`".repeat(longestBacktickRun(body) + 1)
+  const pad = body.startsWith("`") || body.endsWith("`") ? " " : ""
+  return `${ticks}${pad}${body}${pad}${ticks}`
+}
+
+function unquote(text: string) {
+  const lines = text.split("\n")
+  if (!lines.every((line) => line === ">" || line.startsWith("> "))) return
+  return lines.map((line) => line.slice(2)).join("\n")
+}
+
+function unfence(text: string) {
+  const lines = text.split("\n")
+  if (lines.length < 2 || !/^`{3,}$/.test(lines[0]) || lines.at(-1) !== lines[0]) return
+  return lines.slice(1, -1).join("\n")
+}
+
+function uncode(text: string) {
+  const match = text.match(/^(`+)( ?)([^\n]*?)\2\1$/)
+  return match?.[3]
+}
diff --git a/packages/tui/src/prompt/paste.ts b/packages/tui/src/prompt/paste.ts
new file mode 100644
index 000000000000..ce6d6c56b74a
--- /dev/null
+++ b/packages/tui/src/prompt/paste.ts
@@ -0,0 +1,35 @@
+import { PasteSummaryDefaults, type PasteSummary } from "../config"
+
+// The placeholder a paste is replaced by, or undefined when it goes into the prompt as typed.
+export function pasteSummary(content: string, config: PasteSummary | undefined) {
+  const settings = { ...PasteSummaryDefaults, ...config }
+  if (lineCount(content) < settings.lines && content.length <= settings.characters) return
+  return pasteLabel(content, config)
+}
+
+// The placeholder for this text, whatever its size: what an edited paste is relabelled with.
+export function pasteLabel(content: string, config: PasteSummary | undefined) {
+  const settings = { ...PasteSummaryDefaults, ...config }
+  const lines = lineCount(content)
+  const values: Record<string, () => string> = {
+    lines: () => String(lines),
+    characters: () => String(content.length),
+    bytes: () => String(Buffer.byteLength(content)),
+    excerpt: () => excerpt(content, settings.excerpt),
+  }
+  // The placeholder is one line of the prompt: a line break in it would split the extmark.
+  return settings.format
+    .replace(/\{(lines|characters|bytes|excerpt)\}/g, (_, token: string) => values[token]())
+    .replace(/\s*\n\s*/g, " ")
+}
+
+function lineCount(content: string) {
+  return (content.match(/\n/g)?.length ?? 0) + 1
+}
+
+function excerpt(content: string, length: number) {
+  const flat = content.replace(/\s+/g, " ").trim()
+  const chars = Array.from(flat)
+  if (chars.length <= length) return flat
+  return chars.slice(0, length).join("").trimEnd() + "…"
+}
diff --git a/packages/tui/src/prompt/undo.ts b/packages/tui/src/prompt/undo.ts
new file mode 100644
index 000000000000..d91af24f6194
--- /dev/null
+++ b/packages/tui/src/prompt/undo.ts
@@ -0,0 +1,157 @@
+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,
+    // The next edit is a step of its own, however short: a paste from the paste dialog is undone alone.
+    split() {
+      breakNext = true
+    },
+    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/src/routes/session/index.tsx b/packages/tui/src/routes/session/index.tsx
index 2b54f21671b3..3824f8291953 100644
--- a/packages/tui/src/routes/session/index.tsx
+++ b/packages/tui/src/routes/session/index.tsx
@@ -24,7 +24,14 @@ import { SplitBorder } from "../../ui/border"
 import { useTuiPaths, useTuiTerminalEnvironment } from "../../context/runtime"
 import { Spinner } from "../../component/spinner"
 import { createSyntaxStyleMemo, generateSubtleSyntax, selectedForeground, useTheme } from "../../context/theme"
-import { BoxRenderable, ScrollBoxRenderable, addDefaultParsers, TextAttributes, RGBA } from "@opentui/core"
+import {
+  BoxRenderable,
+  ScrollBoxRenderable,
+  addDefaultParsers,
+  TextAttributes,
+  RGBA,
+  type MouseEvent,
+} from "@opentui/core"
 import { Prompt, type PromptRef } from "../../component/prompt"
 import type {
   AssistantMessage,
@@ -81,6 +88,9 @@ import { getRevertDiffFiles } from "../../util/revert-diff"
 import { OPENCODE_BASE_MODE, useBindings, useCommandShortcut, useOpencodeKeymap } from "../../keymap"
 import { usePathFormatter } from "../../context/path-format"
 import { LocationProvider } from "../../context/location"
+import { cellText, idUnder } from "../../ui/id-click"
+import { onClick } from "../../ui/click"
+import { DialogModel } from "../../component/dialog-model"
 
 addDefaultParsers(parsers.parsers)
 
@@ -1267,8 +1277,9 @@ export function Session() {
                       <Match when={message.role === "user"}>
                         <UserMessage
                           index={index()}
-                          onMouseUp={() => {
+                          onMouseUp={(event) => {
                             if (renderer.getSelection()?.getSelectedText()) return
+                            if (idUnder(renderer.currentRenderBuffer, event)) return
                             dialog.replace(() => (
                               <DialogMessage
                                 messageID={message.id}
@@ -1364,7 +1375,7 @@ export function Session() {
 function UserMessage(props: {
   message: UserMessage
   parts: Part[]
-  onMouseUp: () => void
+  onMouseUp: (event: MouseEvent) => void
   index: number
   pending?: number
 }) {
@@ -1469,6 +1480,8 @@ function UserMessage(props: {
 function AssistantMessage(props: { message: AssistantMessage; parts: Part[]; last: boolean }) {
   const ctx = use()
   const local = useLocal()
+  const renderer = useRenderer()
+  const dialog = useDialog()
   const { theme } = useTheme()
   const sync = useSync()
   const messages = createMemo(() => sync.data.message[props.message.sessionID] ?? [])
@@ -1486,6 +1499,21 @@ function AssistantMessage(props: { message: AssistantMessage; parts: Part[]; las
     return props.message.time.completed - user.time.created
   })
 
+  // A click on the footer's model opens the model picker on the model this
+  // turn ran on. The footer is one text, so the model's cells are found in
+  // the row as drawn.
+  const openModel = (event: MouseEvent) => {
+    const target = event.target
+    if (!target) return
+    const row = cellText(renderer.currentRenderBuffer, event.y, target.x, target.x + target.width)
+    const start = row.indexOf(model(), 1)
+    const column = event.x - target.x
+    if (start < 0 || column < start || column >= start + model().length) return
+    dialog.replace(() => (
+      <DialogModel current={{ providerID: props.message.providerID, modelID: props.message.modelID }} />
+    ))
+  }
+
   const childShortcut = useCommandShortcut("session.child.first")
   const backgroundShortcut = useCommandShortcut("session.background")
 
@@ -1548,7 +1576,7 @@ function AssistantMessage(props: { message: AssistantMessage; parts: Part[]; las
       <Switch>
         <Match when={props.last || final() || props.message.error?.name === "MessageAbortedError"}>
           <box ref={(el: BoxRenderable) => alwaysSeparate.add(el)} paddingLeft={3}>
-            <text marginTop={1}>
+            <text marginTop={1} {...onClick(openModel)}>
               <span
                 style={{
                   fg:
@@ -1897,8 +1925,9 @@ function InlineTool(props: {
       separate={props.separate}
       onMouseOver={() => clickable() && setHover(true)}
       onMouseOut={() => setHover(false)}
-      onMouseUp={() => {
+      onMouseUp={(event: MouseEvent) => {
         if (renderer.getSelection()?.getSelectedText()) return
+        if (idUnder(renderer.currentRenderBuffer, event)) return
         if (failed()) {
           setErrorExpanded((value) => !value)
           return
@@ -1928,7 +1957,7 @@ export function InlineToolRow(props: {
   children: JSX.Element
   onMouseOver?: () => void
   onMouseOut?: () => void
-  onMouseUp?: () => void
+  onMouseUp?: (event: MouseEvent) => void
 }) {
   return (
     <box
@@ -2016,8 +2045,9 @@ function BlockTool(props: {
       borderColor={theme.background}
       onMouseOver={() => props.onClick && setHover(true)}
       onMouseOut={() => setHover(false)}
-      onMouseUp={() => {
+      onMouseUp={(event: MouseEvent) => {
         if (renderer.getSelection()?.getSelectedText()) return
+        if (idUnder(renderer.currentRenderBuffer, event)) return
         props.onClick?.()
       }}
     >
diff --git a/packages/tui/src/routes/session/sidebar.tsx b/packages/tui/src/routes/session/sidebar.tsx
index 0c5d2b313967..1c8514cb42b6 100644
--- a/packages/tui/src/routes/session/sidebar.tsx
+++ b/packages/tui/src/routes/session/sidebar.tsx
@@ -8,6 +8,8 @@ import { usePluginRuntime } from "../../plugin/runtime"
 
 import { getScrollAcceleration } from "../../util/scroll"
 import { WorkspaceLabel } from "../../component/workspace-label"
+import { useOpencodeKeymap } from "../../keymap"
+import { onClick } from "../../ui/click"
 
 export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
   const pluginRuntime = usePluginRuntime()
@@ -15,6 +17,7 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
   const sync = useSync()
   const { theme } = useTheme()
   const tuiConfig = useTuiConfig()
+  const keymap = useOpencodeKeymap()
   const session = createMemo(() => sync.session.get(props.sessionID))
   const workspace = () => {
     const workspaceID = session()?.workspaceID
@@ -54,7 +57,7 @@ export function Sidebar(props: { sessionID: string; overlay?: boolean }) {
               share_url={session()!.share?.url}
             >
               <box paddingRight={1}>
-                <text fg={theme.text}>
+                <text fg={theme.text} {...onClick(() => keymap.dispatchCommand("session.rename"))}>
                   <b>{session()!.title}</b>
                 </text>
                 <Show when={InstallationChannel !== "latest"}>
diff --git a/packages/tui/src/ui/click.ts b/packages/tui/src/ui/click.ts
new file mode 100644
index 000000000000..4f41639ef78c
--- /dev/null
+++ b/packages/tui/src/ui/click.ts
@@ -0,0 +1,41 @@
+import { MouseButton } from "@opentui/core"
+
+type Pointer = {
+  x: number
+  y: number
+  button: number
+  target?: { ctx: { getSelection(): { getSelectedText(): string } | null } } | null
+}
+
+// Mouse handlers that run an action on a plain left click. A press dragged off
+// its cell, or one that ended up selecting text, is a selection rather than a
+// click, so drag-to-copy and drag-to-reorder keep working on the same element.
+// The release goes to the action, and what the action returns comes back from
+// onMouseUp, so a handler sharing an element can tell whether it ran.
+export function onClick<E extends Pointer, R>(run: (event: E) => R) {
+  let press: { x: number; y: number } | undefined
+  return {
+    onMouseDown: (event: E) => {
+      press = event.button === MouseButton.LEFT ? { x: event.x, y: event.y } : undefined
+    },
+    onMouseUp: (event: E) => {
+      const same = press?.x === event.x && press.y === event.y
+      press = undefined
+      if (!same || event.target?.ctx.getSelection()?.getSelectedText()) return
+      return run(event)
+    },
+  }
+}
+
+// Copies text the TUI drew and says so, the way a drag-copy does.
+export function copyText(
+  clipboard: { write?(text: string): Promise<void> },
+  toast: (input: { message: string; variant: "info" | "error" }) => void,
+  text: string,
+  label = text,
+) {
+  clipboard
+    .write?.(text)
+    .then(() => toast({ message: `Copied ${label}`, variant: "info" }))
+    .catch(() => toast({ message: "Failed to copy to clipboard", variant: "error" }))
+}
diff --git a/packages/tui/src/ui/id-click.ts b/packages/tui/src/ui/id-click.ts
new file mode 100644
index 000000000000..60fa35416ff1
--- /dev/null
+++ b/packages/tui/src/ui/id-click.ts
@@ -0,0 +1,63 @@
+import { TextareaRenderable } from "@opentui/core"
+
+// Session and message IDs are copied when clicked wherever they are drawn: in
+// the sidebar, and in what the AI and tools wrote. The ID is read back from
+// the cells on screen, inside the renderable that was clicked, so it
+// is found the way it reads, after markdown concealment and syntax colouring,
+// and never runs into the next column. Prompt text is left to the caret.
+
+const PATTERN = /^(ses|msg)_[0-9A-Za-z]{10,}$/
+const KINDS = { ses: "session", msg: "message" } as const
+
+type Cells = { width: number; height: number; buffers: { char: Uint32Array } }
+type Area = { x: number; y: number; width: number; height: number }
+
+// What a row shows between two columns, one character per cell. Cells that
+// are not a single code point (wide-character halves, graphemes) read as U+FFFD,
+// so a column is still its index.
+export function cellText(cells: Cells, y: number, left: number, right: number) {
+  const from = Math.max(0, left)
+  const to = Math.min(cells.width, right)
+  if (y < 0 || y >= cells.height || to <= from) return ""
+  return Array.from({ length: to - from }, (_, index) => {
+    const code = cells.buffers.char[y * cells.width + from + index]
+    return code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : "\ufffd"
+  }).join("")
+}
+
+export function idAt(cells: Cells, x: number, y: number, area?: Area) {
+  const top = Math.max(0, area?.y ?? 0)
+  const bottom = Math.min(cells.height, area ? area.y + area.height : cells.height)
+  const left = Math.max(0, area?.x ?? 0)
+  const right = Math.min(cells.width, area ? area.x + area.width : cells.width)
+  if (y < top || y >= bottom || x < left || x >= right) return
+  const at = (column: number) => cells.buffers.char[y * cells.width + column]
+  if (!word(at(x))) return
+  const start = scan(x, -1, (column) => column >= left && word(at(column))) + 1
+  const end = scan(x, 1, (column) => column < right && word(at(column)))
+  const value = String.fromCharCode(...Array.from({ length: end - start }, (_, index) => at(start + index)))
+  const match = PATTERN.exec(value)
+  if (!match) return
+  return { kind: KINDS[match[1] as keyof typeof KINDS], value }
+}
+
+// The ID under a click, if any. Element handlers that act on a click call this
+// first and stand down, so one click on an ID never also opens or toggles what
+// contains it.
+export function idUnder(cells: Cells, event: { x: number; y: number; target: Area | null }) {
+  const target = event.target
+  if (!target || target instanceof TextareaRenderable) return
+  return idAt(cells, event.x, event.y, target)
+}
+
+function scan(from: number, step: number, inside: (column: number) => boolean): number {
+  const next = from + step
+  return inside(next) ? scan(next, step, inside) : next
+}
+
+// ASCII letters, digits and underscore. Cells holding wide or combined
+// characters carry flag bits above the code point and end the word.
+function word(code: number | undefined) {
+  if (code === undefined) return false
+  return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95
+}
diff --git a/packages/tui/test/cli/tui/diff-viewer.test.tsx b/packages/tui/test/cli/tui/diff-viewer.test.tsx
index f7fc9c0a5159..289371f08f91 100644
--- a/packages/tui/test/cli/tui/diff-viewer.test.tsx
+++ b/packages/tui/test/cli/tui/diff-viewer.test.tsx
@@ -242,6 +242,33 @@ test("last-turn diff source requests session diff", async () => {
   }
 })
 
+test("a file param opens the viewer scrolled to that file", async () => {
+  const patch = (name: string) =>
+    `--- a/${name}\n+++ b/${name}\n@@ -1,6 +1,6 @@\n` +
+    Array.from({ length: 6 }, (_, line) =>
+      line === 2 ? `-const old_${name} = 1\n+const new_${name} = 1` : ` const keep${line} = 1`,
+    ).join("\n")
+  const files = ["a.ts", "b.ts", "c.ts"].map((name) => ({
+    file: `src/${name}`,
+    additions: 1,
+    deletions: 1,
+    status: "modified",
+    patch: patch(name.replace(".", "_")),
+  }))
+  const viewer = await renderDiffViewer(files, 12, {
+    name: "diff",
+    params: { mode: "git", sessionID: "session-1", returnRoute: startRoute, file: "src/c.ts" },
+  })
+  try {
+    await viewer.app.waitForFrame((frame) => frame.includes("keep"))
+    await viewer.app.waitFor(() => (findScrollBox(viewer.app.renderer.root)?.scrollTop ?? 0) > 0)
+    await viewer.app.flush()
+    expect(viewer.app.captureCharFrame()).toContain("new_c_ts")
+  } finally {
+    viewer.app.renderer.destroy()
+  }
+})
+
 async function waitForCommand(
   app: Awaited<ReturnType<typeof testRender>>,
   commands: Map<string, unknown>,
diff --git a/packages/tui/test/component/prompt-paste-dialog.test.tsx b/packages/tui/test/component/prompt-paste-dialog.test.tsx
new file mode 100644
index 000000000000..7dad8a315582
--- /dev/null
+++ b/packages/tui/test/component/prompt-paste-dialog.test.tsx
@@ -0,0 +1,331 @@
+import { expect, setDefaultTimeout, test } from "bun:test"
+import { wait, withPrompt, type PromptRig } from "../fixture/prompt-app"
+
+// The first test in the file also pays for starting the whole app.
+setDefaultTimeout(30_000)
+
+const UNDO = "\x1b[45;5u"
+const ESCAPE = "\x1b"
+const ENTER = "\r"
+const SPACE = " "
+const DOWN = "\x1b[B"
+const UP = "\x1b[A"
+const TAB = "\t"
+const RIGHT = "\x1b[C"
+const LEFT = "\x1b[D"
+const config = { prompt: { paste_mode: "dialog" as const } }
+const code = "    def f():\n        return 1\n"
+
+function find(rig: PromptRig, label: string) {
+  const lines = rig.frame().split("\n")
+  const y = lines.findIndex((line) => line.includes(label))
+  if (y === -1) throw new Error(`"${label}" is not on screen:\n${rig.frame()}`)
+  return { x: lines[y].indexOf(label) + 2, y }
+}
+
+async function paste(rig: PromptRig, text: string) {
+  await rig.press(`\x1b[200~${text}\x1b[201~`)
+  await wait(() => rig.frame().includes("enter paste"))
+}
+
+async function closed(rig: PromptRig) {
+  await wait(() => !rig.frame().includes("enter paste"))
+}
+
+// What the prompt sends, which is its text with each placeholder's text in its place.
+async function submitted(rig: PromptRig) {
+  await rig.press(ENTER)
+  await wait(() => rig.sent.length > 0)
+  return JSON.parse(rig.sent[0]).parts.find((part: { type: string }) => part.type === "text").text
+}
+
+// The option rows are, in order: insert inline, ```, `, >, trim, normalize indents, remove indents,
+// collapse, join into one line, ANSI.
+async function select(rig: PromptRig, index: number) {
+  for (let step = 0; step < index; step++) await rig.press(DOWN)
+}
+
+test("a paste opens the dialog, and its preview follows the options", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, code)
+      expect(rig.text()).toBe("")
+      expect(rig.frame()).toContain("[ ] insert inline")
+      expect(rig.frame()).toMatch(/┃\s+ {4}def f\(\):/)
+      await select(rig, 5)
+      await rig.press(SPACE)
+      expect(rig.frame()).toContain("[x] normalize indents")
+      expect(rig.frame()).toMatch(/┃\s{2}def f\(\):/)
+      await select(rig, 6) // down six more wraps round to ```
+      await rig.press(SPACE)
+      expect(rig.frame()).toContain("[x] wrap with ```")
+      expect(rig.frame()).toMatch(/┃\s{2}```/)
+      await rig.press(ENTER)
+      await closed(rig)
+      // Without trim the copied line's newline stays, as a blank line before the closing fence.
+      expect(rig.text()).toBe("[Pasted ~5 lines] ")
+      expect(await submitted(rig)).toBe("```\ndef f():\n    return 1\n\n``` ")
+    },
+    { config },
+  )
+})
+
+test("inline code is greyed out and cannot be turned on for more than one line", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "a\nb")
+      await select(rig, 2)
+      await rig.press(SPACE)
+      expect(rig.frame()).toContain("[ ] wrap with `")
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(await submitted(rig)).toBe("a\nb ")
+    },
+    { config },
+  )
+})
+
+test("insert inline puts the text in the prompt, and the choice is kept for the next paste", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "one\ntwo")
+      await rig.press(SPACE)
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.text()).toBe("one\ntwo")
+      await paste(rig, "three")
+      expect(rig.frame()).toContain("[x] insert inline")
+      await rig.press(ESCAPE)
+      await closed(rig)
+      expect(rig.text()).toBe("one\ntwo")
+    },
+    { config },
+  )
+})
+
+test("the options last chosen are read back from kv", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "x")
+      expect(rig.frame()).toContain("[x] quote with >")
+      expect(rig.frame()).toMatch(/┃\s+> x/)
+    },
+    { config, kv: { paste_options: { quote: true } } },
+  )
+})
+
+test("undo right after a paste takes it back and reopens the dialog with it", async () => {
+  await withPrompt(
+    async (rig) => {
+      for (const char of "see") await rig.press(char)
+      await paste(rig, "a\nb\nc")
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.text()).toBe("see[Pasted ~3 lines] ")
+      await rig.press(UNDO)
+      await wait(() => rig.frame().includes("enter paste"))
+      await rig.press(SPACE)
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.text()).toBe("seea\nb\nc")
+    },
+    { config },
+  )
+})
+
+test("a click on a placeholder reopens it with its options, and esc leaves it as it was", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "a\nb\nc")
+      await select(rig, 3)
+      await rig.press(SPACE)
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.parts()).toBe(1)
+      const at = find(rig, "[Pasted ~3 lines]")
+      await rig.click(at.x, at.y)
+      await wait(() => rig.frame().includes("enter paste"))
+      expect(rig.frame()).toContain("[x] quote with >")
+      await rig.press(SPACE) // the selection starts on insert inline
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.text()).toBe("> a\n> b\n> c ")
+      await rig.press(UNDO)
+      const again = find(rig, "[Pasted ~3 lines]")
+      await rig.click(again.x, again.y)
+      await wait(() => rig.frame().includes("enter paste"))
+      await rig.press(ESCAPE)
+      await closed(rig)
+      expect(await submitted(rig)).toBe("> a\n> b\n> c ")
+    },
+    { config },
+  )
+})
+
+test("tab moves to the editor, where space and letters type and enter still pastes", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "a\nb\nc")
+      await rig.press(TAB)
+      for (const char of "X Y") await rig.press(char)
+      await rig.press(TAB)
+      await rig.press(UP) // back in the options: wraps round to the last one
+      await rig.press(TAB)
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(await submitted(rig)).toBe("X Ya\nb\nc ")
+    },
+    { config },
+  )
+})
+
+// Every cleanup changes this text: blank lines at both ends and in a run, trailing spaces, a shared
+// four-space indent and terminal colors.
+const messy = "\n\n    alpha   \n\n\n\n        beta  \n    \x1b[31mgamma\x1b[0m\n\n"
+const keys = ["fence", "code", "quote", "trim", "dedent", "unindent", "collapse", "join", "ansi"] as const
+
+// Moves the selection to an option row and toggles it, tracking the row the selection is on.
+function options(rig: PromptRig) {
+  let row = 0
+  return async (key: (typeof keys)[number] | "inline") => {
+    const target = ["inline", ...keys].indexOf(key)
+    while (row < target) await rig.press(DOWN), row++
+    while (row > target) await rig.press(UP), row--
+    await rig.press(SPACE)
+  }
+}
+
+// With insert inline on the result goes in as typed, so the prompt holds exactly what the dialog had.
+async function pastesBack(rig: PromptRig, toggle: (key: "inline") => Promise<void>) {
+  await toggle("inline")
+  await rig.press(ENTER)
+  await closed(rig)
+  expect(rig.text()).toBe(messy)
+}
+
+test.each([...keys])("turning %s on and off gives back the paste as it was", async (key) => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, messy)
+      const toggle = options(rig)
+      await toggle(key)
+      await toggle(key)
+      await pastesBack(rig, toggle)
+    },
+    { config },
+  )
+})
+
+test("every option on, then off in reverse and in a shuffled order, gives back the paste", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, messy)
+      const toggle = options(rig)
+      for (const key of keys) await toggle(key)
+      expect(rig.frame()).toMatch(/┃\s+> ```/)
+      for (const key of [...keys].reverse()) await toggle(key)
+      // A fixed shuffle, so a failure can be replayed.
+      // Join makes the paste one line, so inline code can go on and replaces the code block; collapse
+      // is greyed out under join and stays off.
+      const shuffled = ["dedent", "join", "fence", "ansi", "unindent", "trim", "quote", "collapse", "code"] as const
+      for (const key of shuffled) await toggle(key)
+      expect(rig.frame()).toMatch(/┃\s+> `alpha beta gamma`/)
+      // Normalize indents is greyed out until remove indents is off, so it goes off last.
+      for (const key of ["code", "trim", "join", "ansi", "quote", "unindent", "dedent"] as const) await toggle(key)
+      await pastesBack(rig, toggle)
+    },
+    { config },
+  )
+})
+
+test("right moves to the editor and tab back; focus and caret moves there are not edits", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, messy)
+      const toggle = options(rig)
+      await toggle("trim")
+      await rig.press(RIGHT)
+      await wait(() => rig.frame().includes("tab options"))
+      for (const key of [DOWN, DOWN, RIGHT, RIGHT, LEFT, UP]) await rig.press(key)
+      await rig.press(TAB)
+      await wait(() => rig.frame().includes("→/tab edit"))
+      await toggle("trim")
+      await rig.press(TAB)
+      await rig.press(TAB)
+      await pastesBack(rig, toggle)
+    },
+    { config },
+  )
+})
+
+test("remove indents greys out normalize indents, and join greys out collapse blank lines", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "  a\n\n\n    b")
+      const toggle = options(rig)
+      await toggle("unindent")
+      await toggle("dedent") // greyed out: stays off
+      expect(rig.frame()).toContain("[x] remove indents")
+      expect(rig.frame()).toContain("[ ] normalize indents")
+      await toggle("join")
+      await toggle("collapse") // greyed out: stays off
+      expect(rig.frame()).toContain("[ ] collapse blank lines")
+      await toggle("code") // one line now, so inline code can go on
+      expect(rig.frame()).toMatch(/┃\s+`a b`/)
+      await toggle("inline")
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.text()).toBe("`a b`")
+    },
+    { config },
+  )
+})
+
+// The dialog starts a quarter of the way down, so a 16-row screen leaves the options 6 rows: the list
+// scrolls to keep the selection on screen.
+test("on a short screen the options scroll with the selection", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "a\nb")
+      expect(rig.frame()).toContain("[ ] insert inline")
+      expect(rig.frame()).not.toContain("strip ANSI escapes")
+      await select(rig, 9)
+      expect(rig.frame()).toContain("strip ANSI escapes")
+      expect(rig.frame()).not.toContain("insert inline")
+      expect(rig.frame()).toContain("enter paste")
+      await rig.press(DOWN) // wraps round to the first
+      expect(rig.frame()).toContain("insert inline")
+    },
+    { config, height: 16 },
+  )
+})
+
+test("right arrow in the editor moves the caret instead of leaving it", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "ab")
+      await rig.press(RIGHT)
+      await rig.press(RIGHT)
+      await rig.press("X")
+      await rig.press(TAB)
+      await rig.press(SPACE) // insert inline
+      await rig.press(ENTER)
+      await closed(rig)
+      expect(rig.text()).toBe("aXb")
+    },
+    { config },
+  )
+})
+
+test("esc on a new paste puts nothing in the prompt", async () => {
+  await withPrompt(
+    async (rig) => {
+      await paste(rig, "a\nb\nc")
+      await rig.press(ESCAPE)
+      await closed(rig)
+      expect(rig.text()).toBe("")
+      expect(rig.parts()).toBe(0)
+    },
+    { config },
+  )
+})
diff --git a/packages/tui/test/component/prompt-paste.test.tsx b/packages/tui/test/component/prompt-paste.test.tsx
new file mode 100644
index 000000000000..9bb22186ab17
--- /dev/null
+++ b/packages/tui/test/component/prompt-paste.test.tsx
@@ -0,0 +1,292 @@
+import { expect, setDefaultTimeout, test } from "bun:test"
+import { wait, withPrompt, type PromptRig } from "../fixture/prompt-app"
+
+// The first test in the file also pays for starting the whole app.
+setDefaultTimeout(30_000)
+
+const UNDO = "\x1b[45;5u"
+const ESCAPE = "\x1b"
+const ENTER = "\r"
+const SHIFT_ENTER = "\x1b[13;2u"
+const CTRL_J = "\n"
+const UP = "\x1b[A"
+const DOWN = "\x1b[B"
+const RIGHT = "\x1b[C"
+const TAB = "\t"
+const SHIFT_TAB = "\x1b[Z"
+
+// Where the frame shows `label`, as the cell to click inside it.
+function find(rig: PromptRig, label: string) {
+  const lines = rig.frame().split("\n")
+  const y = lines.findIndex((line) => line.includes(label))
+  if (y === -1) throw new Error(`"${label}" is not on screen:\n${rig.frame()}`)
+  return { x: lines[y].indexOf(label) + 2, y }
+}
+
+async function pasteBlock(rig: PromptRig) {
+  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] ")
+}
+
+// A lone escape byte is held briefly in case more of a sequence follows.
+async function close(rig: PromptRig) {
+  await rig.press(ESCAPE)
+  await wait(() => !rig.frame().includes("Pasted text"))
+}
+
+async function closed(rig: PromptRig) {
+  await wait(() => !rig.frame().includes("Pasted text"))
+}
+
+async function openPlaceholder(rig: PromptRig) {
+  const at = find(rig, "[Pasted ~3 lines]")
+  await rig.click(at.x, at.y)
+  find(rig, "Pasted text")
+}
+
+// What the prompt sends, which is the pasted text the placeholder stands for.
+async function submitted(rig: PromptRig) {
+  await rig.press("\r")
+  await wait(() => rig.sent.length > 0)
+  return JSON.parse(rig.sent[0]).parts.find((part: { type: string }) => part.type === "text").text
+}
+
+test("clicking a placeholder opens its text to edit, and escape keeps the edit", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    for (const char of "zero") await rig.press(char)
+    await rig.press(SHIFT_ENTER) // the prompt's newline key adds a line
+    await close(rig)
+    expect(rig.text()).toBe("see [Pasted ~4 lines] ")
+    expect(rig.sent).toEqual([])
+    expect(await submitted(rig)).toBe("see zero\none\ntwo\nthree ")
+  })
+})
+
+test("an edit that keeps the line count keeps the label and changes the text", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press("X")
+    await close(rig)
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(await submitted(rig)).toBe("see Xone\ntwo\nthree ")
+  })
+})
+
+test("Insert inline replaces the placeholder with its text, and undo puts the placeholder back", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    const button = find(rig, "Insert inline")
+    await rig.click(button.x, button.y)
+    await closed(rig)
+    expect(rig.text()).toBe("see one\ntwo\nthree ")
+    expect(rig.parts()).toBe(0)
+    await rig.press(UNDO)
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(rig.parts()).toBe(1)
+    expect(await submitted(rig)).toBe("see one\ntwo\nthree ")
+  })
+})
+
+test("enter saves and closes like escape, and ctrl+j adds a line", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press("X")
+    await rig.press(CTRL_J)
+    await rig.press(ENTER)
+    await closed(rig)
+    expect(rig.text()).toBe("see [Pasted ~4 lines] ")
+    expect(rig.sent).toEqual([])
+    expect(await submitted(rig)).toBe("see X\none\ntwo\nthree ")
+  })
+})
+
+test("tab moves from the text to Keep as block, which saves and keeps the placeholder", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press(DOWN) // the caret's row does not matter
+    await rig.press("X")
+    await rig.press(TAB)
+    await rig.press("Z") // typed on a button: goes nowhere
+    await rig.press(ENTER)
+    await closed(rig)
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(await submitted(rig)).toBe("see one\nXtwo\nthree ")
+  })
+})
+
+test("tab twice reaches Insert inline, and enter on it inlines the text", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press(TAB)
+    await rig.press(TAB)
+    await wait(() => !rig.frame().includes("esc/enter save"))
+    find(rig, "esc save")
+    await rig.press(ENTER)
+    await closed(rig)
+    expect(rig.text()).toBe("see one\ntwo\nthree ")
+    expect(rig.parts()).toBe(0)
+  })
+})
+
+test("a third tab goes back to the text, and shift+tab goes the other way", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press(TAB)
+    await rig.press(TAB)
+    await rig.press(TAB)
+    await rig.press("A") // back in the text
+    await rig.press(SHIFT_TAB) // to Insert inline
+    find(rig, "esc save")
+    await rig.press(SHIFT_TAB) // to Keep as block
+    await rig.press(SHIFT_TAB) // to the text
+    await rig.press("B")
+    await rig.press(ENTER)
+    await closed(rig)
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(await submitted(rig)).toBe("see ABone\ntwo\nthree ")
+  })
+})
+
+test("up on the first row moves to the buttons, right then enter inlines", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press(UP)
+    await rig.press(RIGHT)
+    find(rig, "esc save")
+    await rig.press(ENTER)
+    await closed(rig)
+    expect(rig.text()).toBe("see one\ntwo\nthree ")
+    expect(rig.parts()).toBe(0)
+  })
+})
+
+test("up below the first row moves the caret, and down from the buttons goes back to the text", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press(DOWN)
+    await rig.press(UP) // back to the first row, still in the text
+    await rig.press("A")
+    await rig.press(UP) // now on the first row: to Keep as block
+    await rig.press("Z") // typed on a button: goes nowhere
+    await rig.press(DOWN)
+    await rig.press("B")
+    await rig.press(ENTER)
+    await closed(rig)
+    expect(await submitted(rig)).toBe("see ABone\ntwo\nthree ")
+  })
+})
+
+test("clicking Keep as block saves the edit and keeps the placeholder", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press("X")
+    const button = find(rig, "Keep as block")
+    await rig.click(button.x, button.y)
+    await closed(rig)
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(await submitted(rig)).toBe("see Xone\ntwo\nthree ")
+  })
+})
+
+// A paste of 6 lines, two of them longer than the editor is wide, is 8 rows once wrapped:
+// the editor shows all of them without scrolling.
+test("the editor is as tall as the paste once wrapped", async () => {
+  await withPrompt(
+    async (rig) => {
+      const long = (tag: string) => `${tag} ${"word ".repeat(30)}${tag}-end`
+      const text = ["one", long("A"), "three", long("B"), "five", "six"].join("\n")
+      await rig.press(`\x1b[200~${text}\x1b[201~`)
+      await rig.click(find(rig, "[Pasted ~6 lines]").x, find(rig, "[Pasted ~6 lines]").y)
+      const frame = rig.frame()
+      for (const visible of ["one", "A-end", "three", "B-end", "five", "six"]) expect(frame).toContain(visible)
+      const rows = frame.split("\n")
+      const first = rows.findIndex((row) => /┃\s+one\s*$/.test(row))
+      const last = rows.findIndex((row) => /┃\s+six\s*$/.test(row))
+      expect(last - first).toBe(7)
+      // Below the last row of text: the box's padding row, its edge, then the hint row.
+      expect(rows[last + 1]).toMatch(/┃\s*$/)
+      expect(rows[last + 2]).toContain("╹▀")
+      expect(rows[last + 3]).toContain("esc/enter save")
+    },
+    { height: 40 },
+  )
+})
+
+// The editor sits in the prompt's box: the bar down its left, a padding row above and below the
+// text and the half-row edge, without the prompt's agent line. The buttons are above it and the
+// save hint is under its right end, where the prompt shows ctrl+p commands.
+test("the editor is drawn in the prompt's box without the agent line", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    const prompt = rig.frame().split("\n")
+    const promptText = prompt.findIndex((row) => row.includes("see [Pasted"))
+    const promptColumn = prompt[promptText].indexOf("see")
+    await openPlaceholder(rig)
+    const rows = rig.frame().split("\n")
+    const action = rows.findIndex((row) => row.includes("Keep as block"))
+    expect(rows[action]).toContain("Insert inline")
+    const one = rows.findIndex((row) => /┃\s+one\s*$/.test(row))
+    expect(one).toBe(action + 3)
+    expect(rows[action + 1].trim()).toBe("")
+    expect(rows[action + 2]).toMatch(/┃\s*$/)
+    for (const row of [rows[one], rows[one + 1], rows[one + 2]]) {
+      // The same gap from the bar to the text as in the prompt.
+      expect(row.indexOf("┃") + promptColumn - prompt[promptText].indexOf("┃")).toBe(row.search(/[a-z]/))
+    }
+    expect(rows[one + 3]).toMatch(/┃\s*$/)
+    expect(rows[one + 4]).toContain("╹▀")
+    expect(rows[one + 5]).toContain("tab switch")
+    expect(rows[one + 5].trimEnd().endsWith("esc/enter save")).toBe(true)
+    expect(rows[one + 5].trimEnd().length).toBe(rows[one + 4].trimEnd().length)
+    const dialog = rows.slice(action, one + 6).join("\n")
+    expect(dialog).not.toContain("Build")
+  })
+})
+
+test("undo takes back an edit made in the dialog", async () => {
+  await withPrompt(async (rig) => {
+    await pasteBlock(rig)
+    await openPlaceholder(rig)
+    await rig.press("X")
+    await close(rig)
+    await rig.press(UNDO)
+    expect(rig.text()).toBe("see [Pasted ~3 lines] ")
+    expect(await submitted(rig)).toBe("see one\ntwo\nthree ")
+  })
+})
+
+// The dialog starts a quarter of the way down the screen, so its editor gets only the rows below
+// that: a long paste scrolls inside it and the buttons and the hint stay on screen.
+test.each([16, 24, 60])("a 50-line paste keeps the buttons on screen at %i rows", async (height) => {
+  await withPrompt(
+    async (rig) => {
+      const text = Array.from({ length: 50 }, (_, index) => `line ${index + 1}`).join("\n")
+      await rig.press(`\x1b[200~${text}\x1b[201~`)
+      expect(rig.text()).toBe("[Pasted ~50 lines] ")
+      const at = find(rig, "[Pasted ~50 lines]")
+      await rig.click(at.x, at.y)
+      const lines = rig.frame().split("\n")
+      expect(lines.length).toBeLessThanOrEqual(height + 1)
+      expect(lines.findIndex((line) => line.includes("Pasted text 50 lines"))).toBeGreaterThanOrEqual(0)
+      expect(find(rig, "esc/enter save").y).toBeLessThan(height)
+      const button = find(rig, "Insert inline")
+      expect(button.y).toBeLessThan(height)
+      await rig.click(button.x, button.y)
+      await closed(rig)
+      expect(rig.text()).toBe(`${text} `)
+    },
+    { height },
+  )
+})
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..2840123c1dc9
--- /dev/null
+++ b/packages/tui/test/component/prompt-undo.test.tsx
@@ -0,0 +1,57 @@
+import { expect, setDefaultTimeout, test } from "bun:test"
+import { wait, withPrompt } from "../fixture/prompt-app"
+
+// The first test in the file also pays for starting the whole app.
+setDefaultTimeout(30_000)
+
+// 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"
+
+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..e1d8ede59870 100644
--- a/packages/tui/test/config.test.tsx
+++ b/packages/tui/test/config.test.tsx
@@ -48,6 +48,23 @@ test("validates config constraints", () => {
   expect(decodeInfo({ attention: { sounds: { unknown: "sound.wav" } } })).toEqual({ attention: { sounds: {} } })
 })
 
+test("prompt.paste_summary takes thresholds, a format and an excerpt length", () => {
+  const config = decodeInfo({
+    prompt: { paste_summary: { lines: 10, characters: 2000, format: "[{lines} lines: {excerpt}]", excerpt: 40 } },
+  }).prompt?.paste_summary
+  expect(config).toEqual({ lines: 10, characters: 2000, format: "[{lines} lines: {excerpt}]", excerpt: 40 })
+  expect(() => decodeInfo({ prompt: { paste_summary: { lines: 0 } } })).toThrow()
+  expect(() => decodeInfo({ prompt: { paste_summary: { characters: -1 } } })).toThrow()
+  expect(() => decodeInfo({ prompt: { paste_summary: { format: "" } } })).toThrow()
+  expect(() => decodeInfo({ prompt: { paste_summary: { excerpt: 1.5 } } })).toThrow()
+})
+
+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/fixture/prompt-app.ts b/packages/tui/test/fixture/prompt-app.ts
new file mode 100644
index 000000000000..3f8649dcfcc5
--- /dev/null
+++ b/packages/tui/test/fixture/prompt-app.ts
@@ -0,0 +1,161 @@
+import { mock } 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"
+import { createTuiResolvedConfig } from "./tui-runtime"
+import { createEventSource, createFetch, directory, json } from "./tui-sdk"
+
+const sessionID = "ses_prompt_app"
+const session = {
+  id: sessionID,
+  title: "Prompt app",
+  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" }
+
+export 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)
+  }
+}
+
+export type PromptRig = {
+  press(bytes: string): Promise<void>
+  click(x: number, y: number): Promise<void>
+  frame(): string
+  text(): string
+  parts(): number
+  paths: string[]
+  sent: string[]
+}
+
+// Runs the TUI in a session whose turn is running, and hands the test its prompt to type and click in.
+export async function withPrompt(
+  body: (rig: PromptRig) => Promise<void>,
+  options?: { height?: number; config?: Parameters<typeof createTuiResolvedConfig>[0]; kv?: Record<string, unknown> },
+) {
+  await using tmp = await tmpdir()
+  await Bun.write(`${tmp.path}/kv.json`, JSON.stringify(options?.kv ?? {}))
+  const setup = await createTestRenderer({ width: 120, height: options?.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: {}, ...options?.config }),
+        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,
+      async click(x, y) {
+        await setup.mockMouse.click(x, y)
+        await Bun.sleep(30)
+        await render()
+      },
+      frame: () => setup.captureCharFrame(),
+      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()
+  }
+}
+
diff --git a/packages/tui/test/prompt/paste-options.test.ts b/packages/tui/test/prompt/paste-options.test.ts
new file mode 100644
index 000000000000..1901e569edbf
--- /dev/null
+++ b/packages/tui/test/prompt/paste-options.test.ts
@@ -0,0 +1,166 @@
+import { describe, expect, test } from "bun:test"
+import {
+  applyPasteOptions,
+  pasteOptionDisabled,
+  PasteOptionList,
+  PasteOptionsDefault,
+  readPasteOptions,
+  togglePasteOption,
+  unwrapPaste,
+  type PasteOptions,
+} from "../../src/prompt/paste-options"
+
+const on = (...keys: (keyof PasteOptions)[]): PasteOptions => ({
+  ...PasteOptionsDefault,
+  ...Object.fromEntries(keys.map((key) => [key, true])),
+})
+
+describe("applyPasteOptions", () => {
+  test("no options leaves the text as it is", () => {
+    expect(applyPasteOptions("  a \n\n", PasteOptionsDefault)).toBe("  a \n\n")
+  })
+
+  test("trim drops trailing whitespace on each line and blank lines at both ends, keeping indentation", () => {
+    expect(applyPasteOptions("\n\n  a  \n\tb\t\n\n", on("trim"))).toBe("  a\n\tb")
+  })
+
+  test("normalize indents removes the indent every line shares", () => {
+    expect(applyPasteOptions("    if (x) {\n      y()\n    }", on("dedent"))).toBe("if (x) {\n  y()\n}")
+  })
+
+  test("normalize indents ignores blank lines and never mixes tabs with spaces", () => {
+    expect(applyPasteOptions("\t\ta\n\n\t\t\tb", on("dedent"))).toBe("a\n\n\tb")
+    expect(applyPasteOptions("\ta\n    b", on("dedent"))).toBe("\ta\n    b")
+    expect(applyPasteOptions("\t  a\n\t b", on("dedent"))).toBe(" a\nb")
+  })
+
+  test("a code block fence is longer than any backtick run inside", () => {
+    expect(applyPasteOptions("a\nb", on("fence"))).toBe("```\na\nb\n```")
+    expect(applyPasteOptions("x ```` y", on("fence"))).toBe("`````\nx ```` y\n`````")
+  })
+
+  test("inline code wraps one line, and is off for more", () => {
+    expect(applyPasteOptions("a b", on("code"))).toBe("`a b`")
+    expect(applyPasteOptions("a `b`", on("code"))).toBe("`` a `b` ``")
+    expect(applyPasteOptions("a\nb", on("code"))).toBe("a\nb")
+    expect(pasteOptionDisabled("code", "a\nb", PasteOptionsDefault)).toBe(true)
+    expect(pasteOptionDisabled("code", "a b", PasteOptionsDefault)).toBe(false)
+  })
+
+  test("quote prefixes every line, outside the code block", () => {
+    expect(applyPasteOptions("a\n\nb", on("quote"))).toBe("> a\n>\n> b")
+    expect(applyPasteOptions("a", on("quote", "fence"))).toBe("> ```\n> a\n> ```")
+  })
+
+  test("collapse blank lines leaves at most one blank line in a row", () => {
+    expect(applyPasteOptions("a\n\n\n\nb\n\nc", on("collapse"))).toBe("a\n\nb\n\nc")
+  })
+
+  test("strip ANSI escapes removes colors, cursor moves and links", () => {
+    expect(applyPasteOptions("\x1b[31mred\x1b[0m \x1b]8;;http://x\x07link\x1b]8;;\x07", on("ansi"))).toBe("red link")
+  })
+
+  test("remove indents strips every line's leading spaces and tabs, shared or not", () => {
+    expect(applyPasteOptions("    a\n\t\tb\n \t c\nd  e", on("unindent"))).toBe("a\nb\nc\nd  e")
+    expect(applyPasteOptions("  a\n   \n  b", on("unindent"))).toBe("a\n\nb")
+  })
+
+  test("join into one line drops blank lines and joins the rest with one space at each break", () => {
+    expect(applyPasteOptions("a\nb\nc", on("join"))).toBe("a b c")
+    expect(applyPasteOptions("a  \n\n\n   b\t\n\t c", on("join"))).toBe("a b c")
+    expect(applyPasteOptions("a\r\nb\rc", on("join"))).toBe("a b c")
+  })
+
+  test("join into one line keeps spaces inside a line and at the paste's two ends", () => {
+    expect(applyPasteOptions("  x   y  \n  z  ", on("join"))).toBe("  x   y z  ")
+    expect(applyPasteOptions("\n\n  x\n", on("join"))).toBe("  x")
+    expect(applyPasteOptions("  one line  ", on("join"))).toBe("  one line  ")
+    expect(applyPasteOptions("\n \n\t\n", on("join"))).toBe("")
+  })
+
+  test("the wraps go around the joined line, and inline code becomes possible", () => {
+    expect(applyPasteOptions("ls -la\n  | grep x", on("join", "code"))).toBe("`ls -la | grep x`")
+    expect(applyPasteOptions("a\nb", on("join", "fence"))).toBe("```\na b\n```")
+    expect(applyPasteOptions("a\nb", on("join", "quote"))).toBe("> a b")
+  })
+
+  test("trim and remove indents run before the join", () => {
+    expect(applyPasteOptions("    def f():  \n        pass\n", on("trim", "unindent", "join"))).toBe("def f(): pass")
+  })
+
+  test("remove indents greys out normalize indents, and join greys out collapse blank lines", () => {
+    expect(pasteOptionDisabled("dedent", "a", on("unindent"))).toBe(true)
+    expect(pasteOptionDisabled("dedent", "a", PasteOptionsDefault)).toBe(false)
+    expect(pasteOptionDisabled("collapse", "a", on("join"))).toBe(true)
+    expect(pasteOptionDisabled("collapse", "a", PasteOptionsDefault)).toBe(false)
+    // What covers them leaves them nothing to change, so their stored value makes no difference.
+    const text = "    a\n\n\n\n      b\n"
+    expect(applyPasteOptions(text, on("unindent", "dedent"))).toBe(applyPasteOptions(text, on("unindent")))
+    expect(applyPasteOptions(text, on("join", "collapse"))).toBe(applyPasteOptions(text, on("join")))
+  })
+
+  test("cleanups and wraps combine: an indented, trailing-space snippet becomes a clean code block", () => {
+    expect(applyPasteOptions("\n    def f():  \n        pass\n\n", on("trim", "dedent", "fence"))).toBe(
+      "```\ndef f():\n    pass\n```",
+    )
+  })
+})
+
+// Blank lines at both ends and in a run, CR LF breaks, trailing spaces, a shared four-space indent
+// with more under it (spaces on one line, a tab on another) and terminal colors: every option changes
+// it, inline code once it is one line.
+const messy = "\r\n\n    alpha   \n\n\n\n        beta  \r\n    \t\x1b[31mgamma\x1b[0m\n\n"
+
+describe("every option on a messy paste", () => {
+  const keys = PasteOptionList.map((option) => option.key).filter((key) => key !== "inline")
+
+  test.each(keys)("%s changes it", (key) => {
+    const base = key === "code" ? on("join") : PasteOptionsDefault
+    expect(applyPasteOptions(messy, { ...base, [key]: true })).not.toBe(applyPasteOptions(messy, base))
+  })
+
+  // The dialog's toggles, including the ones a greyed-out option ignores, in a seeded random order.
+  test.each([1, 7, 42, 1234])("a random walk of toggles back to all off gives the paste back (seed %i)", (seed) => {
+    let state = seed
+    const random = () => (state = (state * 1103515245 + 12345) % 2 ** 31) / 2 ** 31
+    let options = { ...PasteOptionsDefault }
+    const toggle = (key: (typeof keys)[number]) => {
+      if (pasteOptionDisabled(key, applyPasteOptions(messy, { ...options, fence: false, code: false, quote: false }), options)) return
+      options = togglePasteOption(options, key)
+    }
+    for (let step = 0; step < 60; step++) toggle(keys[Math.floor(random() * keys.length)])
+    // Turn off what shows ticked until nothing does, as a user would, uncovering greyed-out options.
+    for (let pass = 0; pass < keys.length && keys.some((key) => options[key]); pass++)
+      for (const key of [...keys].sort(() => random() - 0.5)) if (options[key]) toggle(key)
+    const left = keys.filter((key) => options[key])
+    // Only inline code can stay stored, greyed out for this multi-line paste and without effect.
+    expect(left.filter((key) => key !== "code")).toEqual([])
+    expect(applyPasteOptions(messy, options)).toBe(messy)
+  })
+})
+
+describe("unwrapPaste", () => {
+  test("gives back the body inside intact wraps", () => {
+    const options = on("quote", "fence")
+    expect(unwrapPaste(applyPasteOptions("a\nb", options), options)).toEqual({ body: "a\nb", options })
+    expect(unwrapPaste("`x`", on("code"))).toEqual({ body: "x", options: on("code") })
+  })
+
+  test("drops a wrap the edit broke", () => {
+    expect(unwrapPaste("```\na", on("fence"))).toEqual({ body: "```\na", options: PasteOptionsDefault })
+    expect(unwrapPaste("> a\nb", on("quote"))).toEqual({ body: "> a\nb", options: PasteOptionsDefault })
+  })
+})
+
+describe("stored options", () => {
+  test("only known keys with true values are read", () => {
+    expect(readPasteOptions({ fence: true, trim: "yes", bogus: true })).toEqual(on("fence"))
+    expect(readPasteOptions(undefined)).toEqual(PasteOptionsDefault)
+  })
+
+  test("the two wraps exclude each other", () => {
+    expect(togglePasteOption(on("fence"), "code")).toEqual(on("code"))
+    expect(togglePasteOption(on("code"), "fence")).toEqual(on("fence"))
+    expect(togglePasteOption(on("fence"), "fence")).toEqual(PasteOptionsDefault)
+  })
+})
diff --git a/packages/tui/test/prompt/paste.test.ts b/packages/tui/test/prompt/paste.test.ts
new file mode 100644
index 000000000000..eec2af45a1ef
--- /dev/null
+++ b/packages/tui/test/prompt/paste.test.ts
@@ -0,0 +1,35 @@
+import { describe, expect, test } from "bun:test"
+import { pasteSummary } from "../../src/prompt/paste"
+
+describe("pasteSummary", () => {
+  test("defaults: three lines or more than 150 characters are summarized", () => {
+    expect(pasteSummary("a\nb", undefined)).toBeUndefined()
+    expect(pasteSummary("a\nb\nc", undefined)).toBe("[Pasted ~3 lines]")
+    expect(pasteSummary("x".repeat(150), undefined)).toBeUndefined()
+    expect(pasteSummary("x".repeat(151), undefined)).toBe("[Pasted ~1 lines]")
+  })
+
+  test("thresholds come from the config", () => {
+    expect(pasteSummary("a\nb\nc", { lines: 4 })).toBeUndefined()
+    expect(pasteSummary("a\nb", { lines: 2 })).toBe("[Pasted ~2 lines]")
+    expect(pasteSummary("x".repeat(151), { characters: 1000 })).toBeUndefined()
+    expect(pasteSummary("xx", { characters: 1 })).toBe("[Pasted ~1 lines]")
+  })
+
+  test("formats line, character and byte counts", () => {
+    expect(pasteSummary("é\nb\nc", { format: "[{lines} lines, {characters} chars, {bytes} B]" })).toBe(
+      "[3 lines, 5 chars, 6 B]",
+    )
+  })
+
+  test("an excerpt flattens whitespace and cuts at the configured length", () => {
+    const content = "first line\n\n  second   line\nthird"
+    expect(pasteSummary(content, { format: "[Pasted: {excerpt}]" })).toBe("[Pasted: first line second line third]")
+    expect(pasteSummary(content, { format: "[{excerpt}]", excerpt: 12 })).toBe("[first line s…]")
+    expect(pasteSummary("😀😀😀\n\n", { format: "{excerpt}", excerpt: 2 })).toBe("😀😀…")
+  })
+
+  test("keeps the placeholder on one line", () => {
+    expect(pasteSummary("a\nb\nc", { format: "[Pasted\n{lines}]" })).toBe("[Pasted 3]")
+  })
+})
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/tui/test/ui/click.test.ts b/packages/tui/test/ui/click.test.ts
new file mode 100644
index 000000000000..5db0e1dbb804
--- /dev/null
+++ b/packages/tui/test/ui/click.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test"
+import { onClick } from "../../src/ui/click"
+
+const selecting = (text: string) => ({ ctx: { getSelection: () => ({ getSelectedText: () => text }) } })
+
+describe("ui.click", () => {
+  test("a left press and release on the same cell runs the action", () => {
+    let runs = 0
+    const click = onClick(() => runs++)
+    click.onMouseDown({ x: 4, y: 2, button: 0 })
+    click.onMouseUp({ x: 4, y: 2, button: 0 })
+    expect(runs).toBe(1)
+  })
+
+  test("a drag off the pressed cell, a right press or a release alone does not", () => {
+    let runs = 0
+    const click = onClick(() => runs++)
+    click.onMouseDown({ x: 4, y: 2, button: 0 })
+    click.onMouseUp({ x: 9, y: 2, button: 0 })
+    click.onMouseDown({ x: 4, y: 2, button: 2 })
+    click.onMouseUp({ x: 4, y: 2, button: 2 })
+    click.onMouseUp({ x: 4, y: 2, button: 0 })
+    expect(runs).toBe(0)
+  })
+
+  test("the release goes to the action and its result comes back", () => {
+    const click = onClick((event: { x: number; y: number; button: number }) => event.x * 10)
+    click.onMouseDown({ x: 4, y: 2, button: 0 })
+    expect(click.onMouseUp({ x: 4, y: 2, button: 0 })).toBe(40)
+    expect(click.onMouseUp({ x: 4, y: 2, button: 0 })).toBeUndefined()
+  })
+
+  test("a click that leaves text selected is a selection, not a click", () => {
+    let runs = 0
+    const click = onClick(() => runs++)
+    click.onMouseDown({ x: 4, y: 2, button: 0 })
+    click.onMouseUp({ x: 4, y: 2, button: 0, target: selecting("Build") })
+    click.onMouseDown({ x: 4, y: 2, button: 0 })
+    click.onMouseUp({ x: 4, y: 2, button: 0, target: selecting("") })
+    expect(runs).toBe(1)
+  })
+})
diff --git a/packages/tui/test/ui/id-click.test.ts b/packages/tui/test/ui/id-click.test.ts
new file mode 100644
index 000000000000..b5367aef85d7
--- /dev/null
+++ b/packages/tui/test/ui/id-click.test.ts
@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test"
+import { cellText, idAt, idUnder } from "../../src/ui/id-click"
+
+const SES = "ses_ee68a7aceffeiGmNH03eS7PU61"
+const MSG = "msg_119742d10001srfC3wz8krD00i"
+
+// A frame as the renderer holds it: one code point per cell, rows padded to the width.
+function frame(...rows: string[]) {
+  const width = Math.max(...rows.map((row) => row.length))
+  const char = new Uint32Array(width * rows.length)
+  rows.forEach((row, y) => [...row.padEnd(width)].forEach((ch, x) => (char[y * width + x] = ch.codePointAt(0)!)))
+  return { width, height: rows.length, buffers: { char } }
+}
+
+const area = (x: number, y: number, width: number, height: number) => ({ x, y, width, height })
+
+describe("ui.id-click", () => {
+  test("finds a session or message ID under any of its cells", () => {
+    const cells = frame(`see \`${SES}\` and ${MSG}.`)
+    const ses = 5
+    const msg = `see \`${SES}\` and `.length
+    expect(idAt(cells, ses, 0)).toEqual({ kind: "session", value: SES })
+    expect(idAt(cells, ses + SES.length - 1, 0)).toEqual({ kind: "session", value: SES })
+    expect(idAt(cells, msg + 10, 0)).toEqual({ kind: "message", value: MSG })
+    expect(idAt(cells, 1, 0)).toBeUndefined()
+    expect(idAt(cells, ses - 1, 0)).toBeUndefined()
+  })
+
+  test("ignores words that only look like IDs", () => {
+    const cells = frame("ses_short tool_ses_ee68a7aceffeiGmNH03eS7PU61 session_id")
+    expect(idAt(cells, 2, 0)).toBeUndefined()
+    expect(idAt(cells, 20, 0)).toBeUndefined()
+    expect(idAt(cells, 50, 0)).toBeUndefined()
+  })
+
+  test("reads only inside the clicked renderable, so a neighbouring column does not join the ID", () => {
+    const cells = frame(`${SES}abc`)
+    expect(idAt(cells, 3, 0)?.value).toBe(`${SES}abc`)
+    expect(idAt(cells, 3, 0, area(0, 0, SES.length, 1))).toEqual({ kind: "session", value: SES })
+    expect(idAt(cells, SES.length + 1, 0, area(0, 0, SES.length, 1))).toBeUndefined()
+  })
+
+  test("the ID under a click is read inside its target", () => {
+    const cells = frame(SES)
+    expect(idUnder(cells, { x: 2, y: 0, target: area(0, 0, SES.length, 1) })).toEqual({ kind: "session", value: SES })
+    expect(idUnder(cells, { x: 2, y: 0, target: null })).toBeUndefined()
+  })
+
+  test("a row reads one character per cell", () => {
+    const cells = frame("▣  Build · QA Model")
+    expect(cellText(cells, 0, 0, 20)).toBe("▣  Build · QA Model")
+    expect(cellText(cells, 0, 3, 8)).toBe("Build")
+    expect(cellText(cells, 1, 0, 5)).toBe("")
+  })
+})
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..45ffd472fa14 100644
--- a/packages/web/src/content/docs/tui.mdx
+++ b/packages/web/src/content/docs/tui.mdx
@@ -61,6 +61,34 @@ The output of the command is added to the conversation as a tool result.
 
 ---
 
+## Clickable elements
+
+These parts of the screen act when you click them. Where a keybind or slash command does the same, the click runs it:
+
+| Element | Where | Action |
+| --- | --- | --- |
+| A pasted-text placeholder, such as `[Pasted ~12 lines]` | In the prompt | Opens the pasted text to read and edit. See [Paste summary](#paste-summary) |
+| Agent name | Below the prompt | Opens the agent picker (`/agents`) |
+| Model and provider | Below the prompt | Opens the model picker (`/models`) |
+| Variant | Below the prompt, when one is selected | Opens the variant picker (`/variants`) |
+| `tab agents` | Below the prompt | Switches to the next agent, like `tab` |
+| `ctrl+p commands` | Below the prompt | Opens the command palette |
+| `esc interrupt` | Below the prompt, while the agent works | Like pressing `esc`: the first click asks for a second, and a second click within 5 seconds interrupts the agent |
+| Token, context and cost usage | Below the prompt, and the Context section of the session sidebar | Opens the status dialog (`/status`) |
+| Directory | Below the prompt, the session sidebar footer, the home screen footer | Copies the directory's path |
+| Model in a message footer | After `▣` and the agent below an answer | Opens the model picker with the model that turn ran on highlighted |
+| Session title | Top of the session sidebar | Renames the session (`/rename`) |
+| Session or message ID (`ses_...`, `msg_...`) | The sidebar, and text the agent or a tool wrote | Copies the ID |
+| An MCP server | MCP section of the session sidebar | Connects or disconnects that server, as `/mcps` does, without opening the dialog. The dot shows `⋯` until the server answers. |
+| A modified file | Modified Files section of the session sidebar | Opens the diff viewer (`/diff`) at that file |
+| A todo | Todo section of the session sidebar | Copies the todo and adds it to the end of the prompt |
+| MCP count and `/status` | Home screen footer | Opens the status dialog (`/status`) |
+| Connect provider | "Getting started" box in the session sidebar | Opens the provider list (`/connect`) |
+
+A click counts only when the mouse is pressed and released on the same cell. Dragging across any of these selects and copies its text instead, as it does elsewhere, and nothing happens on hover. A click on an ID inside a message or tool call copies the ID instead of opening the message or tool around it.
+
+---
+
 ## Commands
 
 When using the OpenCode TUI, you can type `/` followed by a command name to quickly execute actions. For example:
@@ -409,12 +437,91 @@ 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.paste_summary` - When a paste is replaced by a placeholder such as `[Pasted ~12 lines]`, and what the placeholder says. See [Paste summary](#paste-summary).
+- `prompt.paste_mode` - What pasting text does: `"direct"` (default) puts it in the prompt; `"dialog"` opens the paste dialog first. See [Paste dialog](#paste-dialog).
+- `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.
 
+### Paste summary
+
+A paste of three lines or more, or of more than 150 characters, goes into the prompt as a placeholder such as `[Pasted ~12 lines]`; the pasted text is sent in its place. `prompt.paste_summary` changes when that happens and what the placeholder says:
+
+```json title="tui.json"
+{
+  "prompt": {
+    "paste_summary": {
+      "lines": 10,
+      "characters": 2000,
+      "format": "[Pasted {lines} lines, {bytes} B: {excerpt}]",
+      "excerpt": 40
+    }
+  }
+}
+```
+
+- `lines` - A paste of at least this many lines is summarized. Defaults to `3`.
+- `characters` - A paste longer than this many characters is summarized. Defaults to `150`.
+- `format` - The placeholder. Defaults to `"[Pasted ~{lines} lines]"`. `{lines}` is the paste's line count, `{characters}` its length, `{bytes}` its size in UTF-8 bytes, and `{excerpt}` its start, with line breaks and repeated spaces collapsed.
+- `excerpt` - How many characters `{excerpt}` shows before it is cut with `…`. Defaults to `30`.
+
+With the example above, a 12-line stack trace that starts with `TypeError: Cannot read properties of undefined` shows as `[Pasted 12 lines, 1834 B: TypeError: Cannot read properties of und…]`. **Disable paste summary** in the command palette turns summarizing off for every paste, and **Enable paste summary** turns it back on.
+
+Click a placeholder to see the text behind it. With `prompt.paste_mode` set to `"dialog"`, it opens the [paste dialog](#paste-dialog) instead. Otherwise it opens in the same editor as the prompt, with the same keys, mouse caret placement and undo. <kbd>enter</kbd> or <kbd>esc</kbd> saves and closes, and the prompt's newline keys (`input_newline`, such as <kbd>shift+enter</kbd>) add a line. The placeholder keeps the edited text, and its label is redone from `format` when the text changed it, such as a new line count. Above the editor, **Keep as block** does the same as <kbd>enter</kbd>, and **Insert inline** replaces the placeholder with the text itself, as if it had been pasted without one. Click a button, or press <kbd>tab</kbd> to move from the editor to Keep as block, Insert inline and back to the editor wherever the caret is (<kbd>shift+tab</kbd> goes the other way), and <kbd>enter</kbd> to press the selected one. <kbd>up</kbd> on the editor's first line also selects the buttons, <kbd>left</kbd> and <kbd>right</kbd> move between them, and <kbd>down</kbd> goes back to the text. Saving empty text removes the placeholder. Undo in the prompt takes back either change.
+
+### Paste dialog
+
+With `prompt.paste_mode` set to `"dialog"`, pasting text opens a dialog before anything goes into the prompt. It works for any text, from <kbd>ctrl+v</kbd> (`input_paste`) or your terminal's paste; the raw paste key (`input_paste_raw`, <kbd>ctrl+x</kbd> <kbd>v</kbd>) still pastes as typed, and images and pasted file paths are attached as before.
+
+```json title="tui.json"
+{
+  "prompt": {
+    "paste_mode": "dialog"
+  }
+}
+```
+
+The options are on the left. The paste as it will go in is on the right, in the prompt's own editor, and it changes as you pick options:
+
+- **insert inline** - puts the text itself in the prompt. Off, it goes in as a placeholder such as `[Pasted ~12 lines]`, however short it is; the title shows which.
+- **wrap with \`\`\`** - a code block. Its fence is longer than any run of backticks in the text.
+- **wrap with \`** - inline code. Greyed out for text of more than one line. It and the code block exclude each other.
+- **quote with >** - a Markdown quote on every line, outside the code block.
+- **trim whitespace** - removes trailing whitespace from each line and blank lines at the start and the end. Leading whitespace is indentation and stays.
+- **normalize indents** - removes the indentation every non-blank line shares. Tabs and spaces are compared character for character, so a tab is never counted as some number of spaces.
+- **remove indents** - removes all leading spaces and tabs from every line, shared or not. While it is on, normalize indents is greyed out: there is no indentation left for it to remove.
+- **collapse blank lines** - leaves at most one blank line in a row.
+- **join into one line** - makes the paste one line. Blank lines are dropped, and the other lines are joined with a single space, without the trailing whitespace before each break or the indentation after it; spaces inside a line, and at the start and end of the paste, stay. A Windows line ending (`\r\n`) counts as one break. While it is on, collapse blank lines is greyed out, and inline code is no longer greyed out for a multi-line paste.
+- **strip ANSI escapes** - removes terminal colors and other escape sequences, as in copied command output.
+
+The cleanups run before the wraps and the quote, so a wrap goes around the cleaned-up text, and join into one line comes after the other cleanups, so a code block or inline code goes around the joined line.
+
+<kbd>up</kbd> and <kbd>down</kbd> select an option, <kbd>space</kbd> or a click toggles it, <kbd>enter</kbd> pastes and <kbd>esc</kbd> cancels. The options you pick are kept for the next paste, also after a restart. <kbd>right</kbd> or <kbd>tab</kbd> moves from the options to the editor, where you can change the text by hand: <kbd>space</kbd> and the arrow keys work as usual there, <kbd>enter</kbd> still pastes, and <kbd>tab</kbd> goes back to the options (<kbd>shift+tab</kbd> also switches either way). Until you type or delete text in the editor, every option undoes itself: turning it off gives back what it changed, and with every option off the editor holds the paste exactly as it came. Moving the caret or the focus is not an edit. After an edit, turning a cleanup off no longer restores what the edit replaced; the wraps can still be turned on and off.
+
+Undo right after a paste takes it back and opens the dialog again with the same text and options, without reading the clipboard again, which may hold something else by then. A click on a placeholder from the dialog opens it with the options it was pasted with.
+
+### 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) {