pi-copy-picker 0.0.0-stage → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## Unreleased
+
+## 1.0.0 - 2026-10-31
+
+### Added
+
+- Fullscreen current-branch message picker with search, source context, Markdown preview, and clipboard copy.
+- Block selection for code, quotes, and standalone inline code, plus optional tool calls and outputs.
+- `/copy-block` and `Ctrl+Shift+B` to copy the latest assistant block or message.
+- Direct TypeScript package, package contract checks, and guarded tag-based publishing.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tallshort
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,128 @@
-# Temporary Holding Version
+# Pi copy picker
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+![Copy Picker gallery preview](https://raw.githubusercontent.com/tallshort/pi-copy-picker/main/gallery-preview.png)
+
+Browse and copy messages from the current Pi branch with `/copy-picker`.
+The fullscreen picker has a paginated message list above a Markdown preview.
+It selects the newest visible message and closes after a successful copy.
+
+![Copy Picker fullscreen view with a selected code block and preview](https://raw.githubusercontent.com/tallshort/pi-copy-picker/main/copy-picker.png)
+
+Requires interactive TUI mode and `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` version 1.0.0 or newer. The host supplies these optional peer dependencies.
+Type checking and tests passed with 1.0.0 and 1.4.0. Other versions are accepted but have not been verified here.
+
+## Open the picker
+
+From a source checkout, load the TypeScript entry directly:
+
+```sh
+	pi -e ./src/index.ts
+```
+
+For directory installation, run these commands from the checkout. No build is required:
+
+```sh
+	pi install "$PWD"
+	pi -e .
+```
+
+After the first npm publication, install the published package with:
+
+```sh
+	pi install npm:pi-copy-picker
+```
+
+Run `/copy-picker` in Pi. Use `/reload` or restart an existing session after installation or source changes.
+The command does not change history or tool configuration.
+
+## Copy the last block
+
+Run `/copy-block` or press Ctrl+Shift+B in the main editor to copy the last selectable block in the latest grouped assistant reply on the current branch. If that message has no selectable block, it copies the whole message instead. It uses the same block and clipboard rules as the picker, ignores thinking and tool messages, and skips aborted empty assistant messages. It does not fall back to an older message when the latest message has no copyable text.
+
+Ctrl+Shift+B requires a terminal that distinguishes it from Ctrl+B. The terminal, operating system, or another binding may intercept it. Use `/copy-block` if the shortcut does not reach Pi. Both require TUI mode and leave the editor and conversation unchanged.
+
+## Controls
+
+| Key | Action |
+| --- | --- |
+| Up / Down | Select the whole message, then its code, inline-code, and blockquote children in source order, then the next message. Up reverses this order. No wrapping |
+| Left / Right | Change page. Select its first message only when a selection is already active |
+| Type | Edit the search, ignoring case, and clear selection and preview immediately |
+| Ctrl+A / Ctrl+E | Move the search cursor to the start or end |
+| Ctrl+U / Ctrl+K | Delete search text before or after the cursor |
+| Ctrl+T | Show or hide tool calls and results, hidden by default |
+| Enter | Copy an active selection and close on success. Do nothing when no message is selected |
+| PgUp / PgDown | Scroll the preview by one page |
+| Shift+Up / Shift+Down | Scroll the preview by one line |
+| Ctrl+Home / Ctrl+End | Jump to the start or end of the preview |
+| Esc | Close, even during a pending copy or an active search |
+
+Pi's configured selection, confirm, and cancel keys also work. Fixed keys take priority.
+A small-window message appears below 32 columns or when the list has fewer than three rows for the selected frame. Search and Escape still work; copying waits until the frame fits.
+
+## Message and clipboard behavior
+
+Each opening reads a saved `getBranch()` snapshot, including original text before compaction.
+Abandoned branches are excluded. Reopen the picker to load newer messages.
+Thinking, signatures, system messages, custom messages, and administrative entries are excluded. Assistant text records connected by tool-use steps form one reply, ending at stop, error, abort, a user message, or another history boundary. When tools are shown, unselected assistant text and tool events follow their original branch order.
+
+User cards use the chat theme's user background and text colors. Assistant cards have no background.
+The selected card has an accent border. Tool cards retain a dim border and the tool name.
+The upper list shows original Markdown source in conversation order. Headings, lists, tables, references, and blank source lines stay literal. Long context lines wrap at the list width.
+Each selected target has an accent frame with up to seven interior rows. The frame grows with its content and shrinks to fit short windows. Source lines appear in order, including code fences and punctuation. A single blank line stays blank. A run of blank lines becomes a muted `...`. If the source or its wrapped lines exceed the available rows, the last row is a muted `...`. Literal `...` remains ordinary source text. Preview and copy retain the complete selected entity. When tools are shown, a selected grouped reply frames its first segment and adds a muted `...` inside the frame if later segments contain text. Later segments remain unframed after their tool events. Preview and copy cover the whole reply. Selecting a block replaces only its original source interval. If a block spans tool events, its frame appears at the block's start and may summarize text that originally followed those events. The tool events remain in their original order, and text after the block remains visible. Changing selection centers the new frame, clamped at history ends. Reserved `...` rows indicate additional list content above and below. The bottom Pi-rendered preview shows only the selected entity.
+A local source scanner finds fenced and indented code and nonempty blockquotes. Pi's Markdown tokenizer identifies standalone inline-code lines. These are the only selectable children. A standalone inline-code line contains one nonempty span and copies its content without backticks. Inline code within a sentence does not create a separate block. Lists, headings, tables, and prose remain in the whole-message preview and copy, but do not create children.
+Search matches whole messages and tool names, so matching messages retain all their children.
+Search filters as you type. Every effective query edit clears selection and preview. Clearing the query immediately restores all messages. Down selects the first message on the visible page and Up selects the last, without needing Enter first. Repeated Enter presses do nothing until you select a message.
+While selection is inactive, the preview shows the dim, centered prompt `Use ↑/↓ to select a message`. Paging, tool visibility, preview scrolling, and resizing do not activate selection.
+Block frames leave two columns on both sides. Parent frames use the full width. Block frames have no type labels. Code excerpts show the original fence lines, language info and quote/list prefixes when they fit. Unclosed fences get no invented closing marker. Indented code keeps its source indentation without added fences. Code previews show only the highlighted body, and code copy still excludes fences and container prefixes.
+
+Source display lines and preview Markdown rendering are cached per message or block until width or theme changes. Many long messages can increase memory use until the picker closes.
+
+Whole-message copy joins original text blocks within a record with newlines and preserves surrounding whitespace. For grouped assistant records it adds enough newline characters at each seam to make a paragraph separator of at least two line breaks, preserving existing line breaks. A single record stays unchanged.
+Blockquote children copy plain text with one outer `>` prefix and at most one following space or tab removed per line. Quoted blank paragraphs stay in one target. Nested quote prefixes, internal whitespace, and line endings are preserved. Lazy continuation lines stay unchanged until an unquoted blank paragraph. Empty quotes have no child. Quote previews still render the original Markdown. Code children copy only code, without fences or Markdown quote/list prefixes. Copy removes trailing newline characters from code and quote blocks while preserving indentation, spaces, and internal line endings.
+Quote fences stop when their quote container ends. List code indentation is measured four spaces beyond the list content indentation. A dedented nonblank line ends that list context.
+The scanner covers space-indented lists and these common block forms rather than the full CommonMark grammar. Tab-expanded list indentation and lazy container continuation are not parsed as full CommonMark containers. All source remains available in the whole-message copy. Inline-code children require an unambiguous top-level paragraph token. Some valid spans in nested or otherwise ambiguous Markdown are skipped. Pi still renders and syntax-highlights the previews.
+Images are not copied. Empty messages and image-only messages show `No copyable text`.
+Tool calls copy formatted argument JSON, not the original request bytes.
+Tool results copy text blocks without their `details` field.
+Only displayed text has terminal control sequences removed. Do not paste untrusted copied text directly into a shell.
+Generated UI text is English. Original messages keep their language.
+
+Copy uses Pi's clipboard helper. Remote sessions may depend on OSC52 support in the terminal and multiplexer.
+Pi 1.4.0 limits OSC52 to 100000 Base64 characters. Large copies can fail without a local clipboard backend.
+Repeated Enter presses do not submit duplicate copies while a copy is pending. A failure leaves the picker open for retry.
+
+In fullscreen Pi, success uses the native transient `flash("Copied!")`.
+In regular Pi, success uses `ctx.ui.notify` with `Copied message to clipboard`, without a dismissal timer.
+Success means the helper returned, not that the terminal confirmed clipboard contents.
+
+## Develop in a local sandbox
+
+On Linux with a shared virtiofs checkout, keep `node_modules` outside the checkout.
+Copy the source to a sandbox-local directory. Repeat the copy when source or metadata changes.
+Run the following from the checkout, using a fresh or dedicated `/tmp/pi-copy-picker-dev` directory:
+
+```sh
+	mkdir -p /tmp/pi-copy-picker-dev
+	tar --exclude='./node_modules' --exclude='./.git' --exclude='*.tgz' -cf - . | tar -xf - -C /tmp/pi-copy-picker-dev
+	cd /tmp/pi-copy-picker-dev
+	npm ci
+	npm run check
+	npm pack
+```
+
+Stop if dependency installation fails. Run checks only after `npm ci` succeeds.
+`check` runs type checking, runtime tests, release guard tests, and a real tarball contract check.
+`prepack` runs the same checks. The package checker uses `--ignore-scripts` to avoid recursive packing.
+The package ships the three TypeScript source modules. Pi loads them with its TypeScript loader.
+The package checker extracts the tarball and uses Pi's loader to verify command registration.
+The entry is for Pi, not a promise that plain Node can execute the TypeScript source.
+
+`src/history.ts` converts history. `src/picker.ts` owns selection, search, scrolling, and copy state.
+`src/index.ts` registers the command. Tests use the real Input, Markdown renderer, and key parser with injected clipboard and dimensions.
+IME positioning and actual clipboard reception still need checks in your target terminal.
+
+For publication prerequisites and tag commands, see [Release the package](RELEASING.md).
+The [MIT license](LICENSE) and [changelog](CHANGELOG.md) ship with the package.
+
+Maintained by tallshort. Repository: [tallshort/pi-copy-picker](https://github.com/tallshort/pi-copy-picker).

package/RELEASING.md

@@ -0,0 +1,68 @@
+# Release the package
+
+## Prepare the first publication
+
+1. Create or confirm the public repository `https://github.com/tallshort/pi-copy-picker`. The package metadata already targets it.
+2. Set `origin` fetch and push URLs to that repository. If the repository changes, update `repository.url`, `homepage`, and `bugs.url` in `package.json` before publishing.
+3. Commit the package, lockfile, docs, and workflow on `main`. Push `main`. Keep the working tree clean. Do not commit `node_modules/`. The package publishes `src/` directly.
+4. Confirm that your npm account can publish the top-level package `pi-copy-picker`. The package name is not scoped; `tallshort` is the author. Use Node 24 and npm 11.5.1 or newer. Trusted publishing requires at least Node 22.14.0 and npm 11.5.1.
+5. Follow the README's isolated install and check procedure. From the checked sandbox copy, use an interactive npm login and publish the first version manually:
+
+```sh
+	npm login
+	npm publish --access public
+```
+
+The human runs these commands. No publication has been performed by this preparation task.
+A package must exist before its trusted publisher can be configured. Do not expect OIDC to bootstrap an unpublished package.
+The first manual publication does not claim GitHub Actions provenance.
+
+## Configure trusted publishing
+
+After the npm package exists, open its npm settings and add a GitHub Actions trusted publisher.
+Use GitHub owner `tallshort`, repository `pi-copy-picker`, and the exact workflow filename `release.yml`.
+Leave the environment unset unless you also add that environment to the workflow job.
+Use [npm's trusted publisher guide](https://docs.npmjs.com/trusted-publishers/) and the [npm trust reference](https://docs.npmjs.com/cli/v11/commands/npm-trust/).
+
+The workflow uses a GitHub-hosted runner, Node 24, `id-token: write`, and `npm publish --access public --provenance`.
+Provenance requires a public repository and matching `repository.url` metadata.
+Do not add `NPM_TOKEN` or other long-lived publication credentials to this workflow.
+The workflow rejects prereleases, mismatched package versions, mismatched repository identity, tags outside `main`, and incompatible npm versions.
+
+## Prepare future tags
+
+Use an ordinary local clone with dependencies installed, not the shared checkout.
+The release helper requires a real Git root, clean `main`, matching origin and repository metadata, and HEAD equal to remote `main`.
+It checks local and remote tag collisions and runs the complete check before any version or tag mutation.
+The default only performs preflight checks. It does not fetch, pull, publish, push, or change versions or refs.
+
+```sh
+	npm run release -- current
+	npm run release -- patch
+```
+
+`current` targets the existing package version. It can create the initial `v1.0.0` tag without bumping to `1.0.1`.
+After manually publishing 1.0.0, do not push its tag into the publish workflow, because npm rejects duplicate versions.
+Use a patch, minor, or major release for the next CI publication.
+Update the changelog and commit it before running the helper.
+
+To create local release refs after reviewing the preflight result:
+
+```sh
+	npm run release -- patch --execute
+```
+
+`--execute` updates the manifest and lockfile, reruns checks, commits the version change, and creates an annotated tag.
+For `current`, it only creates the tag. The helper never pushes.
+If a check or commit fails after the version change, inspect and resolve the local edits before retrying. There is no automatic rollback.
+
+Review the generated commit and tag, then atomically push `main` and the exact tag. Replace the example tag with the version you prepared:
+
+```sh
+	git push --atomic origin main refs/tags/v1.0.1
+```
+
+A tag push triggers CI. It does not prove publication succeeded.
+Check the workflow result and the registry version before announcing a release.
+If CI fails before publication, fix the cause and inspect registry state before deciding whether to retry.
+Never overwrite a published version or force-push a release tag.

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "pi-copy-picker",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Fullscreen current-branch message copy picker for Pi",
+  "type": "module",
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/tallshort/pi-copy-picker/main/gallery-preview.png"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "tsx --test tests/*.test.ts",
+    "test:release": "node --test scripts/release.test.mjs",
+    "check:package": "node scripts/check-package.mjs",
+    "check": "npm run typecheck && npm test && npm run test:release && npm run check:package",
+    "prepack": "npm run check",
+    "release": "node scripts/release.mjs"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=1.0.0",
+    "@earendil-works/pi-tui": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.4.0",
+    "@earendil-works/pi-tui": "1.4.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0"
+  },
+  "author": "tallshort",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tallshort/pi-copy-picker.git"
+  },
+  "homepage": "https://github.com/tallshort/pi-copy-picker#readme",
+  "bugs": {
+    "url": "https://github.com/tallshort/pi-copy-picker/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./src/index.ts",
+  "exports": "./src/index.ts",
+  "files": [
+    "src/",
+    "gallery-preview.png",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "RELEASING.md"
+  ]
+}

package/src/history.ts

@@ -0,0 +1,277 @@
+import { Marked } from "@earendil-works/pi-tui";
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
+type ItemKind =
+  | { readonly kind: "user" | "assistant" }
+  | { readonly kind: "tool-call" | "tool-result"; readonly toolName: string };
+
+export type PickItem = Readonly<ItemKind & {
+  id: string;
+  order?: number;
+  segments?: readonly { sourceStart: number; sourceEnd: number; entryId: string; order: number }[];
+  omittedNonText?: boolean;
+  rawText: string;
+}>;
+
+export function toPickerItems(entries: readonly SessionEntry[]): readonly PickItem[] {
+  const items: PickItem[] = [];
+  let group: { index: number; id: string; rawText: string; omitted: boolean; segments: { sourceStart: number; sourceEnd: number; entryId: string; order: number }[] } | undefined;
+  const flush = () => {
+    if (!group) return;
+    items[group.index] = Object.freeze({ id: group.id, kind: "assistant", rawText: group.rawText, omittedNonText: group.omitted, segments: group.segments, order: group.segments[0]?.order });
+    group = undefined;
+  };
+  let order = 0;
+  for (const entry of entries) {
+    if (entry.type !== "message") { flush(); continue; }
+    const message = entry.message;
+    if (message.role !== "user" && message.role !== "assistant" && message.role !== "toolResult") { flush(); continue; }
+    const content = message.content;
+    const rawText = typeof content === "string"
+      ? content
+      : content.filter(block => block.type === "text").map(block => block.text).join("\n");
+    const omitted = typeof content !== "string" && content.some(block => block.type === "image" || block.type === "toolCall" || block.type === "thinking");
+    if (message.role === "toolResult") {
+      items.push(Object.freeze({ id: `${entry.id}:result`, kind: "tool-result", toolName: message.toolName, order: order++, omittedNonText: omitted, rawText }));
+    } else if (message.role === "user") {
+      flush();
+      items.push(Object.freeze({ id: `${entry.id}:message`, kind: "user", order: order++, omittedNonText: omitted, rawText }));
+    } else {
+      const hasText = message.content.some(block => block.type === "text");
+      const empty = message.content.length === 0 && message.stopReason !== "aborted";
+      const include = (hasText || empty) && !(message.stopReason === "aborted" && !rawText.length);
+      let segment: { sourceStart: number; sourceEnd: number; entryId: string; order: number } | undefined;
+      let seenText = false;
+      const append = (text: string) => {
+        if (!group) {
+          group = { index: items.length, id: `${entry.id}:message`, rawText: "", omitted, segments: [] };
+          items.push(Object.freeze({ id: group.id, kind: "assistant", rawText: "", omittedNonText: omitted }));
+        }
+        if (!segment) {
+          segment = { sourceStart: group.rawText.length, sourceEnd: 0, entryId: entry.id, order: order++ };
+          group.segments.push(segment);
+        }
+        if (!seenText && group.rawText && rawText) {
+          const trailing = (group.rawText.match(/(?:\r\n|\r|\n)+$/)?.[0].match(/\r\n|\r|\n/g) ?? []).length;
+          const leading = (rawText.match(/^(?:\r\n|\r|\n)+/)?.[0].match(/\r\n|\r|\n/g) ?? []).length;
+          const seam = trailing + leading - (group.rawText.endsWith("\r") && rawText.startsWith("\n") ? 1 : 0);
+          group.rawText += "\n".repeat(Math.max(0, 2 - seam));
+        }
+        group.rawText += (seenText ? "\n" : "") + text;
+        segment.sourceEnd = group.rawText.length;
+        group.omitted ||= omitted;
+        seenText = true;
+      };
+      if (include && empty) append("");
+      message.content.forEach((block, index) => {
+        if (block.type === "text" && include) append(block.text);
+        else if (block.type === "toolCall") {
+          segment = undefined;
+          items.push(Object.freeze({ id: `${entry.id}:call:${index}`, kind: "tool-call", toolName: block.name, order: order++,
+            rawText: JSON.stringify(block.arguments, null, 2) }));
+        }
+      });
+      if (message.stopReason !== "toolUse") flush();
+    }
+  }
+  flush();
+  return Object.freeze(items);
+}
+
+export type PickTarget = Readonly<{
+  id: string;
+  messageId: string;
+  message: PickItem;
+  rawText: string;
+} & ({ kind: "message" } | { kind: "block"; blockKind: "quote" | "code" | "inline-code"; language?: string; sourceText: string; sourceStart: number; sourceEnd: number; fence?: { opening: string; closing?: string } })>;
+
+// Source lines keep clipboard payloads independent of rendering.
+export function toPickTargets(message: PickItem): readonly PickTarget[] {
+  const parent: PickTarget = { kind: "message", id: message.id, messageId: message.id, message, rawText: message.rawText };
+  if (message.kind !== "user" && message.kind !== "assistant") return [parent];
+  if (message.segments && message.segments.length > 1) {
+    const sourceLines = message.rawText.match(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g) ?? [];
+    const spans: { sourceStart: number; sourceEnd: number; entryId: string }[] = [];
+    for (const segment of message.segments) {
+      const last = spans.at(-1);
+      if (last?.entryId === segment.entryId) last.sourceEnd = segment.sourceEnd;
+      else spans.push({ ...segment });
+    }
+    const blocks = spans.flatMap(segment => {
+      const start = segment.sourceStart + (message.rawText[segment.sourceStart - 1] === "\r" && message.rawText[segment.sourceStart] === "\n" ? 1 : 0);
+      const offset = (message.rawText.slice(0, start).match(/\r\n|\r|\n/g) ?? []).length;
+      return toPickTargets({ ...message, segments: undefined, rawText: message.rawText.slice(start, segment.sourceEnd) })
+        .filter((target): target is Extract<PickTarget, { kind: "block" }> => target.kind === "block")
+        .map(target => ({ ...target, message, sourceStart: target.sourceStart + offset, sourceEnd: target.sourceEnd + offset,
+          id: `${message.id}:block:${target.sourceStart + offset}`,
+          sourceText: sourceLines.slice(target.sourceStart + offset, target.sourceEnd + offset).join("") }));
+    });
+    return [parent, ...blocks];
+  }
+  const lines = message.rawText.match(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g) ?? [];
+  const blocks: PickTarget[] = [];
+  let rich = false;
+  const content = (line: string) => line.replace(/(?:\r\n|\r|\n)$/, "");
+  const unquote = (line: string) => line.replace(/^(?: {0,3}>[ \t]?)+/, "");
+  const listIndents: number[] = [];
+  const listContext = (line: string) => {
+    const text = unquote(content(line));
+    if (!text.trim()) return;
+    const indent = /^ */.exec(text)![0].length;
+    while (listIndents.length && indent < listIndents.at(-1)!) listIndents.pop();
+    const marker = /^( *)(?:[-+*]|\d+[.)])([ \t]+)/.exec(text);
+    if (marker && indent <= (listIndents.at(-1) ?? 0) + 3) {
+      const contentIndent = marker[0].length;
+      if (listIndents.at(-1) !== contentIndent) listIndents.push(contentIndent);
+    }
+  };
+  const codeIndent = () => (listIndents.at(-1) ?? 0) + 4;
+  const fence = (line: string) => {
+    const match = /^( *)(?:([-+*]|\d+[.)])[ \t]+)?(`{3,}|~{3,})([^\r\n]*)$/.exec(unquote(content(line)));
+    return match && (match[1]!.length <= (listIndents.at(-1) ?? 0) + 3) ? match : null;
+  };
+  const inlineCode = (line: string): string | undefined => {
+    const text = content(line);
+    const opener = /^ {0,3}(`+)(?!`)/.exec(text);
+    if (!opener) return undefined;
+    const runs = /`+/g;
+    runs.lastIndex = opener[0].length;
+    for (let match = runs.exec(text); match; match = runs.exec(text)) {
+      if (match[0].length !== opener[1]!.length) continue;
+      const payload = text.slice(opener[0].length, match.index);
+      return /^[ \t]*$/.test(text.slice(match.index + match[0].length)) && payload.trim() ? payload : undefined;
+    }
+    return undefined;
+  };
+  const structure = (line: string) => /^(?: {0,3}(?:#{1,6}(?:\s|$)|>|[-+*]\s|\d+[.)]\s)| {4}|\t)|^ {0,3}(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/.test(content(line));
+  const inlineCandidates = new Map<number, { line: number; raw: string; payload: string }>();
+  let sourceOffset = 0;
+  for (let line = 0; line < lines.length; line++) {
+    const text = content(lines[line]!);
+    const payload = inlineCode(lines[line]!);
+    if (payload !== undefined) {
+      const indent = /^ */.exec(text)![0].length;
+      inlineCandidates.set(sourceOffset + indent, { line, raw: text.slice(indent).trimEnd(), payload });
+    }
+    sourceOffset += lines[line]!.replace(/\r\n|\r/g, "\n").length;
+  }
+  const inlineTargets = new Map<number, string>();
+  const normalized = message.rawText.replace(/\r\n|\r/g, "\n");
+  const protectedLines = new Set<number>();
+  {
+    let offset = 0;
+    let line = 0;
+    for (const token of new Marked().lexer(normalized)) {
+      if (!normalized.startsWith(token.raw, offset)) break;
+      const count = (token.raw.match(/\n/g) ?? []).length;
+      if (token.type === "paragraph" || token.type === "html") {
+        for (let n = 1; n <= count; n++) {
+          if (n < count || !token.raw.endsWith("\n")) protectedLines.add(line + n);
+        }
+      }
+      line += count;
+      if (token.type === "paragraph") {
+        let innerOffset = offset;
+        for (const inline of token.tokens ?? []) {
+          if (!normalized.startsWith(inline.raw, innerOffset)) break;
+          const candidate = inlineCandidates.get(innerOffset);
+          if (inline.type === "codespan" && candidate?.raw === inline.raw) {
+            inlineTargets.set(candidate.line, candidate.payload);
+          }
+          innerOffset += inline.raw.length;
+        }
+      }
+      offset += token.raw.length;
+    }
+  }
+  const inlineAt = (index: number) => inlineTargets.get(index);
+  const add = (start: number, end: number, blockKind: "quote" | "code" | "inline-code", rawText = lines.slice(start, end).join(""), language?: string, fence?: { opening: string; closing?: string }) => {
+    const sourceText = lines.slice(start, end).join("");
+    if (blockKind === "quote") {
+      rawText = lines.slice(start, end).map(line => line.replace(/^ {0,3}>[ \t]?/, "")).join("");
+      if (!rawText.trim()) return;
+    }
+    blocks.push({ kind: "block", sourceStart: start, sourceEnd: end, id: `${message.id}:block:${start}`, messageId: message.id, message, blockKind, rawText, language, sourceText, fence });
+  };
+  let i = 0;
+  while (i < lines.length) {
+    if (!content(lines[i]!).trim()) { i++; continue; }
+    listContext(lines[i]!);
+    const start = i;
+    const opening = fence(lines[i]!);
+    if (opening && !(opening[3]![0] === "`" && opening[4]!.includes("`"))) {
+      rich = true;
+      const marker = opening[3]!;
+      const indent = opening[1]!.length + (opening[2] ? opening[2].length + 1 : 0);
+      const quotePrefix = /^(?: {0,3}>[ \t]?)+/.exec(lines[i]!)?.[0] ?? "";
+      const quoteDepth = (quotePrefix.match(/>/g) ?? []).length;
+      const removeContainer = (line: string) => {
+        for (let depth = 0; depth < quoteDepth; depth++) line = line.replace(/^ {0,3}>[ \t]?/, "");
+        return line;
+      };
+      const containerIndent = listIndents.at(-1) ?? 0;
+      const payload: string[] = [];
+      let closingFence: string | undefined;
+      let externalBlankStart: number | undefined;
+      i++;
+      for (; i < lines.length; i++) {
+        const prefix = /^(?: {0,3}>[ \t]?)+/.exec(lines[i]!)?.[0] ?? "";
+        if ((prefix.match(/>/g) ?? []).length < quoteDepth) break;
+        const line = removeContainer(lines[i]!);
+        const blank = !content(line).trim();
+        const lineIndent = /^ */.exec(line)![0].length;
+        if (!blank && lineIndent < containerIndent) break;
+        const closing = new RegExp(`^ {${containerIndent},${containerIndent + 3}}(\x60+|~+)[ \t]*$`).exec(content(line));
+        if (closing && closing[1]![0] === marker[0] && closing[1]!.length >= marker.length) { closingFence = content(lines[i]!); externalBlankStart = undefined; i++; break; }
+        if (!blank) externalBlankStart = undefined;
+        else if (lineIndent < containerIndent) externalBlankStart ??= payload.length;
+        payload.push(line.replace(new RegExp(`^ {0,${indent}}`), ""));
+      }
+      if (externalBlankStart !== undefined) payload.length = externalBlankStart;
+      add(start, i, "code", payload.join(""), opening[4]!.trim().split(/\s+/)[0] || undefined, { opening: content(lines[start]!), closing: closingFence });
+      continue;
+    }
+    const indentation = codeIndent();
+    const indented = (line: string) => new RegExp(`^(?: {${indentation}}|\\t)`).test(line);
+    if (indented(lines[i]!)) {
+      rich = true;
+      i++;
+      while (i < lines.length && (indented(lines[i]!) || !content(lines[i]!).trim())) i++;
+      while (i > start && !content(lines[i - 1]!).trim()) i--;
+      add(start, i, "code", lines.slice(start, i).map(line => line.replace(new RegExp(`^(?: {${indentation}}|\\t)`), "")).join(""));
+      continue;
+    }
+    const inline = inlineAt(i);
+    if (inline !== undefined) {
+      rich = true;
+      i++;
+      add(start, i, "inline-code", inline);
+      continue;
+    }
+    const first = content(lines[i]!);
+    const heading = /^ {0,3}#{1,6}(?:\s|$)/.test(first);
+    const rule = /^ {0,3}(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/.test(first);
+    const list = /^ {0,3}(?:[-+*]|\d+[.)])\s/.test(first);
+    const quote = /^ {0,3}>/.test(first);
+    rich ||= structure(lines[i]!);
+    i++;
+    if (!heading && !rule) {
+      while (i < lines.length && content(lines[i]!).trim()) {
+        listContext(lines[i]!);
+        const continuation = protectedLines.has(i) || ((list || quote) && /^(?: {4}|\t)/.test(lines[i]!));
+        if ((!list && inlineAt(i) !== undefined) || (quote && /^ {0,3}>[ \t]*$/.test(content(lines[i - 1]!)) && !/^ {0,3}>/.test(content(lines[i]!))) || fence(lines[i]!) || (!continuation && new RegExp(`^ {${codeIndent()}}`).test(lines[i]!))) break;
+        if (/^ {0,3}(?:=+|-+)[ \t]*$/.test(content(lines[i]!)) && !list && !quote) { rich = true; i++; break; }
+        if (/^\s*\|?\s*:?-{3,}/.test(content(lines[i]!)) && first.includes("|")) rich = true;
+        else if (structure(lines[i]!) && !continuation && !(list && /^(?: {0,3}(?:[-+*]|\d+[.)])\s|\s{1,})/.test(lines[i]!)) && !(quote && /^ {0,3}>/.test(lines[i]!))) break;
+        i++;
+      }
+    }
+    if (quote) add(start, i, "quote");
+  }
+  return rich ? [parent, ...blocks] : [parent];
+}
+
+export function copyText(target: PickTarget): string {
+  return target.kind === "block" && (target.blockKind === "code" || target.blockKind === "quote")
+    ? target.rawText.replace(/(?:\r\n|\n|\r)+$/, "") : target.rawText;
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+import { copyToClipboard, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { TuiAltScreen } from "@earendil-works/pi-tui";
+import { copyText, toPickerItems, toPickTargets } from "./history.js";
+import { PickerScreen } from "./picker.js";
+
+export default function copyPicker(pi: ExtensionAPI): void {
+  let generation = 0;
+  pi.on("session_start", () => { generation++; });
+  pi.on("session_shutdown", () => { generation++; });
+  let copying = false;
+  const copyBlock = async (ctx: ExtensionContext): Promise<void> => {
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify("/copy-block requires interactive TUI mode", "error");
+      return;
+    }
+    if (copying) return;
+    const branch = ctx.sessionManager.getBranch();
+    const item = [...toPickerItems(branch)].reverse().find(item => item.kind === "assistant");
+    const targets = item ? toPickTargets(item) : [];
+    const target = targets.filter(target => target.kind === "block" && copyText(target).length > 0).at(-1)
+      ?? (item?.rawText.length ? targets[0] : undefined);
+    if (!target) {
+      ctx.ui.notify("No copyable text in the latest assistant message", "warning");
+      return;
+    }
+    copying = true;
+    const current = generation;
+    try {
+      await copyToClipboard(copyText(target));
+      if (current === generation) ctx.ui.notify("Copied message to clipboard", "info");
+    } catch (error) {
+      if (current === generation) ctx.ui.notify(`Copy failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+    } finally {
+      copying = false;
+    }
+  };
+  pi.registerShortcut("ctrl+shift+b", { description: "Copy last assistant block", handler: copyBlock });
+  pi.registerCommand("copy-block", {
+    description: "Copy the last block or message from the latest assistant reply (Ctrl+Shift+B)",
+    handler: (_args, ctx) => copyBlock(ctx),
+  });
+  pi.registerCommand("copy-picker", {
+    description: "Browse and copy current-branch messages in fullscreen",
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/copy-picker requires interactive TUI mode", "error");
+        return;
+      }
+      const current = ++generation;
+      const items = toPickerItems(ctx.sessionManager.getBranch());
+      let flash: (() => void) | undefined;
+      const result = await ctx.ui.custom<"copied" | undefined>((tui, theme, kb, done) => {
+        if (tui instanceof TuiAltScreen) flash = () => tui.flash("Copied!");
+        return new PickerScreen(items, tui, theme, kb, done);
+      }, {
+          overlay: true,
+          overlayOptions: { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0 },
+        });
+      if (result !== "copied" || current !== generation) return;
+      if (flash) flash();
+      else ctx.ui.notify("Copied message to clipboard", "info");
+    },
+  });
+}

package/src/picker.ts

@@ -0,0 +1,577 @@
+import { copyToClipboard, getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import {
+  Input, Key, Markdown, matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi,
+  type Component, type Focusable, type KeybindingsManager, type TUI,
+} from "@earendil-works/pi-tui";
+import { copyText, toPickTargets, type PickItem, type PickTarget } from "./history.js";
+
+type CopyState = { kind: "idle" | "pending" } | { kind: "error"; message: string };
+type Interaction = { kind: "active"; selectedId: string | undefined }
+  | { kind: "unfocused" };
+type LineStream = { lines: string[]; content: boolean[]; userBackground: boolean[]; ranges: { item: PickTarget; start: number; end: number; contentStart: number; contentEnd: number; userPadding?: { top: number; bottom: number } }[] };
+
+function safeDisplay(text: string): string {
+  return stripTerminalSequences(text.replace(/\r\n?/g, "\n")).replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "");
+}
+
+function fit(text: string, width: number): string {
+  const line = truncateToWidth(text, width, "");
+  return line + " ".repeat(Math.max(0, width - visibleWidth(line)));
+}
+
+const sourceSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+function wrapSource(line: string, width: number): string[] {
+  if (visibleWidth(line) <= width) return [line];
+  const rows: string[] = [];
+  let row = "";
+  let columns = 0;
+  let style = "";
+  for (const token of line.match(/\x1b\[[0-9;]*m|[^\x1b]+/g) ?? []) {
+    if (token.startsWith("\x1b")) {
+      row += token;
+      style = token === "\x1b[0m" ? "" : style + token;
+      continue;
+    }
+    for (const { segment } of sourceSegmenter.segment(token)) {
+      const size = visibleWidth(segment);
+      if (columns + size > width) {
+        rows.push(row + (style ? "\x1b[0m" : ""));
+        row = style;
+        columns = 0;
+      }
+      row += segment;
+      columns += size;
+    }
+  }
+  rows.push(row + (style ? "\x1b[0m" : ""));
+  return rows;
+}
+
+export class PickerScreen implements Component, Focusable {
+  private readonly queryInput = new Input({ prompt: "type to search > " });
+  private interaction: Interaction = { kind: "active", selectedId: undefined };
+  private viewportStart = Infinity;
+  private readonly sources = new Map<string, { width: number; rows: string[][] }>();
+  private readonly lineStarts = new Map<string, number[]>();
+  private revealSelection = true;
+  private pageIndex: number | undefined;
+
+  private get selectedId(): string | undefined {
+    return this.interaction.kind === "active" ? this.interaction.selectedId : undefined;
+  }
+  private showTools = false;
+  private scrollTop = 0;
+  private copyState: CopyState = { kind: "idle" };
+  private disposed = false;
+  private width = 80;
+  private renderedRows: number | undefined;
+  private cachedWidth: number | undefined;
+  private readonly previews = new Map<string, { rawText: string; lines: string[]; codeLines: string[] }>();
+  private readonly targets = new Map<string, readonly PickTarget[]>();
+  private filtered: { query: string; tools: boolean; items: readonly PickItem[] } | undefined;
+
+  constructor(
+    private readonly items: readonly PickItem[],
+    private readonly tui: TUI,
+    private readonly theme: Theme,
+    private readonly kb: KeybindingsManager,
+    private readonly close: (result?: "copied") => void,
+    private readonly copy: (text: string) => Promise<void> = copyToClipboard,
+  ) {
+    this.select(this.visibleItems().at(-1)?.id);
+  }
+
+  get focused(): boolean { return this.queryInput.focused; }
+  set focused(value: boolean) { this.queryInput.focused = value; }
+
+  private visibleItems(): readonly PickItem[] {
+    const query = this.queryInput.getValue().toLowerCase();
+    if (this.filtered?.query === query && this.filtered.tools === this.showTools) return this.filtered.items;
+    const items = this.items.filter(item =>
+      (this.showTools || item.kind === "user" || item.kind === "assistant") &&
+      `${"toolName" in item ? item.toolName : ""}\n${item.rawText}`.toLowerCase().includes(query));
+    this.filtered = { query, tools: this.showTools, items };
+    return items;
+  }
+
+  private lineCountAt(message: PickItem, offset: number): number {
+    let starts = this.lineStarts.get(message.id);
+    if (!starts) {
+      starts = Array.from(message.rawText.matchAll(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g), match => match.index);
+      this.lineStarts.set(message.id, starts);
+    }
+    let low = 0, high = starts.length;
+    while (low < high) {
+      const mid = (low + high) >>> 1;
+      if (starts[mid]! < offset) low = mid + 1;
+      else high = mid;
+    }
+    return low;
+  }
+
+  private visibleTargets(items = this.visibleItems(), showTools = this.showTools): readonly PickTarget[] {
+    const events = items.flatMap((item, index) => {
+      let targets = this.targets.get(item.id);
+      if (!targets) { targets = toPickTargets(item); this.targets.set(item.id, targets); }
+      if (!showTools || !item.segments?.length) return [{ order: item.order ?? index * 1000, targets }];
+      return item.segments.map((segment, segmentIndex) => {
+        const start = this.lineCountAt(item, segment.sourceStart);
+        const end = segment.sourceEnd === item.rawText.length ? Infinity : this.lineCountAt(item, segment.sourceEnd);
+        return { order: segment.order, targets: targets!.filter(target => target.kind === "message"
+          ? segmentIndex === 0 : target.sourceStart >= start && target.sourceStart < end) };
+      });
+    });
+    return events.sort((a, b) => a.order - b.order).flatMap(event => event.targets);
+  }
+
+  private select(id: string | undefined): void {
+    if (id !== this.selectedId) {
+      this.interaction = { kind: "active", selectedId: id };
+      this.scrollTop = 0;
+      this.pageIndex = undefined;
+      this.revealSelection = true;
+    }
+  }
+
+  private reconcile(): void {
+    if (this.interaction.kind !== "active") return;
+    const visible = this.visibleTargets();
+    if (visible.some(item => item.id === this.selectedId)) return;
+    const all = this.visibleTargets(this.items, true);
+    const previousIndex = all.findIndex(item => item.id === this.selectedId);
+    const visibleIds = new Set(visible.map(item => item.id));
+    const previous = all.slice(0, Math.max(0, previousIndex)).reverse()
+      .find(item => visibleIds.has(item.id));
+    this.select(previous?.id ?? visible[0]?.id);
+  }
+
+  private listRows(): number { return Math.floor(Math.max(0, this.tui.terminal.rows - 6) * 0.6); }
+
+  private windowTooSmall(): boolean {
+    const selected = this.visibleTargets().find(target => target.id === this.selectedId);
+    const minListRows = selected?.kind === "message" && selected.message.kind === "user" ? 5 : 3;
+    return this.width < 32 || this.listRows() < minListRows || this.previewRows() < 2;
+  }
+
+  private previewRows(): number { return Math.max(0, this.tui.terminal.rows - 6 - this.listRows()); }
+
+  private sourceLines(message: PickItem): string[] {
+    const lines = (message.rawText.match(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g) ?? [])
+      .map(line => safeDisplay(line.replace(/(?:\r\n|\r|\n)$/, "")).replace(/\t/g, "    "));
+    const targets = this.targets.get(message.id) ?? toPickTargets(message);
+    for (const block of targets) {
+      if (block.kind !== "block" || block.blockKind !== "code") continue;
+      const payload = safeDisplay(block.rawText).replace(/\t/g, "    ").split("\n");
+      const highlighted = getMarkdownTheme().highlightCode?.(payload.join("\n"), block.language);
+      const start = block.sourceStart + (block.fence ? 1 : 0);
+      for (let i = 0; i < payload.length && start + i < block.sourceEnd; i++) {
+        const original = lines[start + i]!;
+        const colored = highlighted?.[i];
+        if (payload[i] && original.endsWith(payload[i]!) && colored !== undefined && stripTerminalSequences(colored) === payload[i]) {
+          lines[start + i] = original.slice(0, original.length - payload[i]!.length) + colored;
+        }
+      }
+    }
+    return lines;
+  }
+
+  private sourceRows(message: PickItem, width: number): string[][] {
+    const cached = this.sources.get(message.id);
+    if (cached?.width === width) return cached.rows;
+    const rows = this.sourceLines(message).map(line => wrapSource(line, Math.max(1, width - 4))
+      .map(text => this.body(message, text, width - 2)));
+    this.sources.set(message.id, { width, rows });
+    return rows;
+  }
+
+  private stream(width = this.width): LineStream {
+    const lines: string[] = [];
+    const content: boolean[] = [];
+    const userBackground: boolean[] = [];
+    const add = (isContent: boolean, ...rows: string[]) => { lines.push(...rows); content.push(...rows.map(() => isContent)); userBackground.push(...rows.map(() => false)); };
+    const addUser = (isContent: boolean, ...rows: string[]) => { add(isContent, ...rows); userBackground.fill(true, userBackground.length - rows.length); };
+    const ranges: LineStream["ranges"] = [];
+    this.visibleTargets();
+    const events = this.visibleItems().flatMap((message, index) => {
+      if (this.showTools && message.segments?.length) return message.segments.map(segment => ({ message,
+        start: this.lineCountAt(message, segment.sourceStart),
+        end: segment.sourceEnd === message.rawText.length ? this.sourceRows(message, width).length : this.lineCountAt(message, segment.sourceEnd), order: segment.order }));
+      return [{ message, start: 0, end: this.sourceRows(message, width).length, order: message.order ?? index * 1000 }];
+    }).sort((a, b) => a.order - b.order);
+    let previousTool = false;
+    const summarized = new Set<string>();
+    for (const { message, start: sourceStart, end: sourceEnd } of events) {
+      const group = this.targets.get(message.id)!;
+      const parent = group[0]!;
+      const selected = group.find(target => target.id === this.selectedId);
+      const firstSegment = !summarized.has(message.id);
+      const tool = message.kind === "tool-call" || message.kind === "tool-result";
+      if (selected?.kind === "message" && firstSegment) {
+        summarized.add(message.id);
+        if (lines.length && (tool || previousTool)) add(false, "");
+        if (tool) add(true, this.theme.fg("dim", ` Tool ${message.kind === "tool-call" ? "call" : "output"}: ${safeDisplay(message.toolName)}`));
+        const shared = lines.length > 0 && !tool && !previousTool;
+        if (shared) { lines.pop(); content.pop(); userBackground.pop(); }
+        const start = lines.length;
+        const card = this.card(selected, width, this.showTools && message.segments?.length ? message.rawText.split(/\r\n|\r|\n/).slice(sourceStart, sourceEnd).join("\n") : undefined,
+          this.showTools && !!message.segments?.slice(1).some(segment => message.rawText.slice(segment.sourceStart, segment.sourceEnd).trim()));
+        const padding = message.kind === "user" ? 1 : 0;
+        add(false, card[0]!);
+        if (padding) addUser(false, card[1]!);
+        (padding ? addUser : add)(true, ...card.slice(1 + padding, card.length - 1 - padding));
+        if (padding) addUser(false, card[card.length - 2]!);
+        add(false, card[card.length - 1]!);
+        ranges.push({ item: selected, start, end: start + card.length, contentStart: start + 1 + padding, contentEnd: start + card.length - 1 - padding });
+        previousTool = tool;
+        continue;
+      }
+      const border = (top: boolean) => this.theme.fg("dim", (top ? "╭" : "╰") + "─".repeat(width - 2) + (top ? "╮" : "╯"));
+      if (lines.length && (tool || previousTool)) add(false, "");
+      const shared = lines.length > 0 && !tool && !previousTool;
+      const start = lines.length - (shared ? 1 : 0);
+      if (!shared) add(false, tool ? border(true) : "");
+      previousTool = tool;
+      const top = lines.length;
+      const decorate = (line: string) => tool ? this.theme.fg("dim", "│") + line + this.theme.fg("dim", "│") : " " + line + " ";
+      if (message.kind === "user") addUser(false, decorate(this.body(message, "", width - 2)));
+      if (tool) add(true, decorate(this.body(message, `Tool ${message.kind === "tool-call" ? "call" : "output"}: ${safeDisplay(message.toolName)}`, width - 2)));
+      const rows = this.sourceRows(message, width);
+      let focusStart = -1;
+      let focusEnd = -1;
+      for (let source = sourceStart; source < sourceEnd; source++) {
+        if (selected?.kind === "block" && source === selected.sourceStart) {
+          focusStart = lines.length;
+          const card = this.card(selected, width);
+          add(true, card[0]!);
+          (message.kind === "user" ? addUser : add)(true, ...card.slice(1, -1));
+          add(true, card[card.length - 1]!);
+          focusEnd = lines.length;
+          source = selected.sourceEnd - 1;
+        } else if (selected?.kind !== "block" || source < selected.sourceStart || source >= selected.sourceEnd) {
+          (message.kind === "user" ? addUser : add)(true, ...rows[source]!.map(decorate));
+        }
+      }
+      const bottom = lines.length;
+      if (message.kind === "user") addUser(false, decorate(this.body(message, "", width - 2)));
+      add(false, tool ? border(false) : "");
+      ranges.push({ item: focusStart >= 0 ? selected! : parent, start: focusStart >= 0 ? focusStart : start,
+        end: focusStart >= 0 ? focusEnd : lines.length, contentStart: top, contentEnd: bottom,
+        userPadding: message.kind === "user" ? { top, bottom } : undefined });
+    }
+    return { lines, content, userBackground, ranges };
+  }
+
+  private clampViewport(stream: LineStream): void {
+    const rows = Math.max(1, this.listRows());
+    const max = Math.max(0, stream.lines.length - rows);
+    this.viewportStart = Math.max(0, Math.min(max, this.viewportStart));
+    if (this.revealSelection && this.interaction.kind === "active") {
+      const target = this.visibleTargets().find(item => item.id === this.selectedId);
+      const range = stream.ranges.find(entry => entry.item.id === target?.id) ?? stream.ranges.find(entry => entry.item.messageId === target?.messageId);
+      if (range) {
+        if (range.end - range.start > rows) this.viewportStart = range.start;
+        else this.viewportStart = range.start - Math.floor((rows - (range.end - range.start)) / 2);
+        this.viewportStart = Math.max(0, Math.min(max, this.viewportStart));
+      }
+    }
+    this.revealSelection = false;
+  }
+
+  private pageMove(delta: number): void {
+    const stream = this.stream();
+    this.clampViewport(stream);
+    const rows = Math.max(1, this.listRows());
+    const max = Math.max(0, stream.lines.length - rows);
+    const currentPage = this.pageIndex ?? (this.viewportStart === max ? Math.ceil(stream.lines.length / rows) - 1 : Math.ceil(this.viewportStart / rows));
+    const nextPage = Math.max(0, Math.min(Math.ceil(stream.lines.length / rows) - 1, currentPage + delta));
+    const start = Math.max(0, Math.min(max, this.viewportStart + delta * rows));
+    if (start === this.viewportStart) return;
+    this.viewportStart = start;
+    if (this.interaction.kind !== "active") { this.pageIndex = nextPage; return; }
+    const visible = stream.ranges.filter(range => range.contentStart < start + rows && range.contentEnd > start);
+    const choice = start === 0 ? visible[0] : start === max ? visible.at(-1)
+      : visible.find(range => range.item.id === this.selectedId && range.start >= start && range.end <= start + rows) ?? visible[0];
+    if (!choice) return;
+    this.select(choice.item.id);
+    const updated = this.stream();
+    const selected = updated.ranges.find(range => range.item.id === this.selectedId);
+    const updatedMax = Math.max(0, updated.lines.length - rows);
+    if (selected) {
+      // Keep the same source anchor when replacing the selected card changes row counts.
+      const anchored = start === max ? updatedMax : start === 0 ? 0 : start + selected.start - choice.start;
+      this.viewportStart = Math.max(0, Math.min(updatedMax,
+        Math.min(selected.start, Math.max(anchored, selected.end - rows))));
+    }
+    this.revealSelection = false;
+    this.pageIndex = nextPage;
+  }
+
+  private previewLines(item: PickTarget | undefined, width: number): string[] {
+    if (!item) return ["No matching messages"];
+    if (!item.rawText.length) return ["No copyable text"];
+    if (this.cachedWidth !== width) {
+      this.previews.clear();
+      this.cachedWidth = width;
+    }
+    let cached = this.previews.get(item.id);
+    if (!cached || cached.rawText !== item.rawText) {
+      const markdownTheme = getMarkdownTheme();
+      const codeLines: string[] = [];
+      const code = item.kind === "block" && item.blockKind === "code";
+      const source = safeDisplay(item.kind === "block" && (item.blockKind === "quote" || item.blockKind === "inline-code") ? item.sourceText : item.rawText).replace(/\t/g, "    ");
+      if (code) codeLines.push(...(markdownTheme.highlightCode?.(source, item.language)
+        ?? source.split("\n").map(line => markdownTheme.codeBlock(line))));
+      const lines = code
+        ? codeLines.flatMap(line => wrapTextWithAnsi(line, width))
+        : new Markdown(source, 0, 0, {
+        ...markdownTheme,
+        highlightCode: (code, lang) => {
+          const highlighted = markdownTheme.highlightCode?.(code, lang)
+            ?? code.split("\n").map(line => markdownTheme.codeBlock(line));
+          codeLines.push("", ...highlighted, "");
+          return highlighted;
+        },
+      }).render(width);
+      cached = { rawText: item.rawText, lines, codeLines };
+      this.previews.set(item.id, cached);
+    }
+    return cached.lines;
+  }
+
+  private scroll(delta: number): void {
+    if (this.interaction.kind !== "active") return;
+    const item = this.visibleTargets().find(item => item.id === this.selectedId);
+    const lines = this.previewLines(item, Math.max(1, this.width - 2));
+    const max = Math.max(0, lines.length - this.previewRows());
+    this.scrollTop = Math.max(0, Math.min(max, this.scrollTop + delta));
+  }
+
+  private move(delta: number): void {
+    if (this.interaction.kind === "unfocused") {
+      const stream = this.stream();
+      this.clampViewport(stream);
+      const visible = stream.ranges.filter(range => range.contentStart < this.viewportStart + this.listRows() && range.contentEnd > this.viewportStart);
+      const item = delta < 0 ? visible.at(-1)?.item : visible[0]?.item;
+      if (item) this.select(item.id);
+      return;
+    }
+    const visible = this.visibleTargets();
+    const index = visible.findIndex(item => item.id === this.selectedId);
+    this.select(visible[Math.max(0, Math.min(visible.length - 1, index + delta))]?.id);
+  }
+
+  handleInput(data: string): void {
+    if (this.disposed) return;
+    if (matchesKey(data, Key.escape) || this.kb.matches(data, "tui.select.cancel")) {
+      this.dispose();
+      this.close();
+      return;
+    }
+    const baseTooSmall = this.windowTooSmall();
+    if (baseTooSmall && (
+      [Key.enter, Key.ctrl("t"), Key.pageUp, Key.pageDown, Key.shift("up"), Key.shift("down"),
+        Key.ctrl("home"), Key.ctrl("end"), Key.up, Key.down, Key.left, Key.right].some(key => matchesKey(data, key))
+      || this.kb.matches(data, "tui.select.confirm") || this.kb.matches(data, "tui.input.submit")
+      || this.kb.matches(data, "tui.select.up") || this.kb.matches(data, "tui.select.down")
+      || [this.kb.getResolvedBindings()["ui.editor.submit"]].flat().some(key => key !== undefined && matchesKey(data, key))
+    )) return;
+    if (matchesKey(data, Key.enter)) {
+      void this.copySelected();
+      return;
+    }
+    if (matchesKey(data, Key.ctrl("t"))) {
+      this.showTools = !this.showTools;
+      this.pageIndex = undefined;
+      this.reconcile();
+      this.revealSelection = true;
+    } else if (matchesKey(data, Key.pageUp)) this.scroll(-(this.previewRows() - 1));
+    else if (matchesKey(data, Key.pageDown)) this.scroll(this.previewRows() - 1);
+    else if (matchesKey(data, Key.shift("up"))) this.scroll(-1);
+    else if (matchesKey(data, Key.shift("down"))) this.scroll(1);
+    else if (matchesKey(data, Key.ctrl("home"))) this.scroll(-Infinity);
+    else if (matchesKey(data, Key.ctrl("end"))) this.scroll(Infinity);
+    else if (matchesKey(data, Key.up)) this.move(-1);
+    else if (matchesKey(data, Key.down)) this.move(1);
+    else if (matchesKey(data, Key.left)) this.pageMove(-1);
+    else if (matchesKey(data, Key.right)) this.pageMove(1);
+    else if (this.kb.matches(data, "tui.select.confirm") || this.kb.matches(data, "tui.input.submit")
+      || [this.kb.getResolvedBindings()["ui.editor.submit"]].flat().some(key => key !== undefined && matchesKey(data, key))) {
+      void this.copySelected();
+      return;
+    } else if (this.kb.matches(data, "tui.select.up")) this.move(-1);
+    else if (this.kb.matches(data, "tui.select.down")) this.move(1);
+    else {
+      const before = this.queryInput.getValue();
+      this.queryInput.handleInput(data);
+      const query = this.queryInput.getValue();
+      const safe = safeDisplay(query).replace(/[\n\t]/g, " ");
+      if (safe !== query) this.queryInput.setValue(safe);
+      if (safe !== before) {
+        this.interaction = { kind: "unfocused" };
+        this.viewportStart = safe ? 0 : Infinity;
+        this.pageIndex = undefined;
+        this.revealSelection = false;
+        this.scrollTop = 0;
+        if (this.copyState.kind === "error") this.copyState = { kind: "idle" };
+      }
+    }
+    this.tui.requestRender();
+  }
+
+  private async copySelected(): Promise<void> {
+    if (this.copyState.kind === "pending") return;
+    if (this.interaction.kind !== "active") return;
+    const item = this.visibleTargets().find(item => item.id === this.selectedId);
+    if (!item?.rawText.length) return;
+    const rawText = copyText(item);
+    if (!rawText.length) return;
+    this.copyState = { kind: "pending" };
+    this.tui.requestRender();
+    try {
+      await this.copy(rawText);
+      if (this.disposed) return;
+      this.dispose();
+      this.close("copied");
+      return;
+    } catch (error) {
+      if (this.disposed) return;
+      this.copyState = { kind: "error", message: error instanceof Error ? error.message : String(error) };
+    }
+    this.tui.requestRender();
+  }
+
+  private status(): string {
+    if (this.copyState.kind === "pending") return "Copying...";
+    if (this.copyState.kind === "error") return `Copy failed: ${safeDisplay(this.copyState.message).replace(/\s+/g, " ")} · Enter to retry`;
+    return "";
+  }
+
+  private body(item: PickItem, line: string, width: number): string {
+    const text = fit(" " + line, width);
+    return item.kind === "user"
+      ? this.theme.bg("userMessageBg", this.theme.fg("userMessageText", text)) : text;
+  }
+
+  private card(target: PickTarget, width: number, segmentSource?: string, hasLaterSource = false): string[] {
+    const block = target.kind === "block" ? target : undefined;
+    const inset = block ? "  " : "";
+    width -= inset.length * 2;
+    const source = block && block.blockKind !== "inline-code"
+      ? this.sourceLines(target.message).slice(block.sourceStart, block.sourceEnd)
+      : !block && segmentSource === undefined ? this.sourceLines(target.message)
+      : ((segmentSource ?? block?.sourceText ?? target.rawText).match(/[^\r\n]*(?:\r\n|\r|\n)|[^\r\n]+$/g) ?? [])
+        .map(line => safeDisplay(line.replace(/(?:\r\n|\r|\n)$/, "")).replace(/\t/g, "    "));
+    const rows: { text: string; synthetic: boolean }[] = [];
+    for (let i = 0; i < source.length;) {
+      if (!stripTerminalSequences(source[i]!).trim()) {
+        let end = i + 1;
+        while (end < source.length && !stripTerminalSequences(source[end]!).trim()) end++;
+        if (end - i > 1) rows.push({ text: "...", synthetic: true });
+        else for (const text of wrapSource(source[i]!, Math.max(1, width - 4))) rows.push({ text, synthetic: false });
+        i = end;
+      } else {
+        for (const text of wrapSource(source[i]!, Math.max(1, width - 4))) rows.push({ text, synthetic: false });
+        i++;
+      }
+    }
+    if (!rows.length) rows.push({ text: "No copyable text", synthetic: false });
+    const userPadding = !block && target.message.kind === "user";
+    const cap = Math.max(1, Math.min(7, this.listRows() - 2) - (userPadding ? 2 : 0));
+    if (rows.length > cap) {
+      rows.length = cap - 1;
+      rows.push({ text: "...", synthetic: true });
+    }
+    if (hasLaterSource && !rows.at(-1)?.synthetic) {
+      if (rows.length >= cap) rows.length = cap - 1;
+      rows.push({ text: "...", synthetic: true });
+    }
+    const markdown = getMarkdownTheme();
+    const excerpt = rows.map(row => row.synthetic ? this.theme.fg("muted", row.text)
+      : block?.blockKind === "inline-code" ? markdown.code(row.text) : row.text);
+    if (userPadding) { excerpt.unshift(""); excerpt.push(""); }
+    const border = (top: boolean) => this.theme.fg("accent", (top ? "╭" : "╰") + "─".repeat(width - 2) + (top ? "╮" : "╯"));
+    return [border(true), ...excerpt.map(line => this.theme.fg("accent", "│") + this.body(target.message, line, width - 2) + this.theme.fg("accent", "│")), border(false)].map(line => inset + line + inset);
+  }
+
+  render(width: number): string[] {
+    const oldWidth = this.width;
+    this.width = Math.max(0, width);
+    const rows = Math.max(0, this.tui.terminal.rows);
+    const tooSmall = () => Array.from({ length: rows }, (_, i) => fit(i === 0 ? "Window too small. Esc to close." : "", this.width));
+    if (this.windowTooSmall()) return tooSmall();
+    this.reconcile();
+    const stream = this.stream(width);
+    if (this.renderedRows !== rows || oldWidth !== this.width) this.pageIndex = undefined;
+    this.revealSelection ||= this.renderedRows !== rows || oldWidth !== this.width;
+    this.renderedRows = rows;
+    this.clampViewport(stream);
+    const item = this.visibleTargets().find(target => target.id === this.selectedId);
+    const pageCount = Math.max(1, Math.ceil(stream.lines.length / this.listRows()));
+    const maxStart = Math.max(0, stream.lines.length - this.listRows());
+    const pageIndex = this.viewportStart === 0 ? 0 : this.viewportStart === maxStart ? pageCount - 1
+      : Math.min(pageCount - 1, this.pageIndex ?? Math.ceil(this.viewportStart / this.listRows()));
+    const help = "Enter copy · ←/→ prev/next page · Ctrl+T tools · PgUp/PgDn scroll preview · Esc close";
+    const status = this.status();
+    const prefix = `Page ${pageIndex + 1}/${pageCount} ${this.theme.fg("dim", `(tool messages ${this.showTools ? "included" : "excluded"})`)}, `;
+    const inputWidth = Math.min(width, visibleWidth("type to search > ") + visibleWidth(this.queryInput.getValue()) + 1);
+    const shownPrefix = truncateToWidth(prefix, Math.max(0, width - inputWidth), "");
+    const arrow = (show: boolean, shaded: boolean) => {
+      if (!show) return "";
+      const text = " " + this.theme.fg("muted", "...");
+      return shaded ? " " + this.theme.bg("userMessageBg", fit(text, width - 2)) + " " : " " + text;
+    };
+    let visibleStart = this.viewportStart;
+    let visibleEnd = Math.min(stream.lines.length, visibleStart + this.listRows());
+    const padding = new Set(stream.ranges.flatMap(range => range.userPadding
+      ? [ ...(range.contentStart + 1 >= visibleEnd ? [range.userPadding.top] : []),
+          ...(range.contentEnd <= visibleStart ? [range.userPadding.bottom] : []) ] : []));
+    while (padding.has(visibleStart) && visibleStart < stream.lines.length) { visibleStart++; visibleEnd = Math.min(stream.lines.length, visibleStart + this.listRows()); }
+    while (padding.has(visibleEnd - 1) && visibleEnd > visibleStart) visibleEnd--;
+    const lines = [this.theme.fg("dim", help),
+      status ? this.theme.fg(this.copyState.kind === "error" ? "error" : "muted", status)
+        : shownPrefix + this.queryInput.render(Math.max(1, width - visibleWidth(shownPrefix)))[0],
+      arrow(stream.content.slice(0, visibleStart).some(Boolean), !!stream.userBackground[visibleStart - 1] && !!stream.userBackground[visibleStart])];
+    const cardRows = stream.lines.slice(visibleStart, visibleEnd);
+    if (!stream.lines.length) cardRows.push(" No matching messages");
+    while (cardRows.length < this.listRows()) cardRows.push("");
+    lines.push(...cardRows, arrow(stream.content.slice(visibleEnd).some(Boolean), !!stream.userBackground[visibleEnd] && !!stream.userBackground[visibleEnd - 1]));
+    const label = " preview ";
+    const left = Math.floor((width - label.length) / 2);
+    lines.push(this.theme.fg("dim", "─".repeat(left) + label + "─".repeat(width - label.length - left)));
+    lines.push("");
+    if (this.interaction.kind !== "active") {
+      const prompt = "Use ↑/↓ to select a message";
+      const usable = rows - lines.length;
+      const middle = Math.floor((usable - 1) / 2);
+      for (let row = 0; row < usable; row++) {
+        lines.push(row === middle
+          ? " ".repeat(Math.max(0, Math.floor((width - visibleWidth(prompt)) / 2))) + this.theme.fg("dim", prompt)
+          : "");
+      }
+      return lines.map(line => fit(line, width));
+    }
+    const preview = this.previewLines(item, Math.max(1, width - 2));
+    const count = this.previewRows();
+    this.scrollTop = Math.max(0, Math.min(this.scrollTop, preview.length - count));
+    const viewport = preview.slice(this.scrollTop, this.scrollTop + count);
+    if (this.scrollTop + count < preview.length) viewport[count - 1] = this.theme.fg("muted", "...");
+    lines.push(...viewport.map(line => " " + line));
+    while (lines.length < rows) lines.push("");
+    return lines.map(line => fit(line, width));
+  }
+
+  invalidate(): void {
+    this.previews.clear();
+    this.sources.clear();
+    this.cachedWidth = undefined;
+    this.queryInput.invalidate();
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    this.previews.clear();
+    this.sources.clear();
+    this.lineStarts.clear();
+  }
+}