pi-copy-picker 0.0.0-stage → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## Unreleased
+
+## 1.1.0 - 2026-11-10
+
+### Added
+
+- Show the number of matching items while searching.
+
+### Changed
+
+- Refactored message target parsing without changing selection or copy behavior.
+
+## 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,63 @@
-# 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.
+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.
+Tests have passed with versions 1.0.0 and 1.4.0.
+
+## Open the picker
+
+Install the package in Pi:
+
+```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
+
+The picker reads the current branch when it opens. Reopen it to see newer messages. It excludes abandoned branches, thinking, and images.
+
+Select a whole message, a code block, a standalone inline-code line, or a blockquote. The list shows Markdown source; the preview renders the selected content. Long selections are shortened in the list, but preview and copy include the complete selection.
+
+Code copies without fences or Markdown container prefixes. Standalone inline code copies without backticks. Blockquotes copy without the outer quote marker. Images are not copied. Tool calls copy formatted arguments, and tool results copy text.
+
+Search matches messages and tool names and shows the number of matching items. Changing the query clears the selection; use Up or Down to select a result before copying.
+
+Copy uses Pi's clipboard helper. Remote sessions may require OSC 52 support in the terminal and multiplexer. Large copies may fail when no local clipboard is available. If copying fails, the picker stays open for retry.
+
+Only displayed text has terminal control sequences removed. Do not paste untrusted copied text directly into a shell.
+
+## Development
+
+See [Development](https://github.com/tallshort/pi-copy-picker/blob/main/DEVELOPMENT.md) for local setup and implementation details. See [Release the package](RELEASING.md) for publication instructions.

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 [development setup](https://github.com/tallshort/pi-copy-picker/blob/main/DEVELOPMENT.md) and checks. From the checked copy, use an interactive npm login and publish the first version manually:
+
+```sh
+	npm login
+	npm publish --access public
+```
+
+The human runs these commands.
+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.1.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,285 @@
+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 } })>;
+
+function segmentBlocks(message: PickItem, segments: NonNullable<PickItem["segments"]>): PickTarget[] {
+  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 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 blocks;
+}
+
+function analyzeMarkdownLines(rawText: string, lines: string[]) {
+  const content = (line: string) => line.replace(/(?:\r\n|\r|\n)$/, "");
+  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 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 = 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;
+    }
+  }
+  return { inlineTargets, protectedLines };
+}
+
+// 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) return [parent, ...segmentBlocks(message, message.segments)];
+  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 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 { inlineTargets, protectedLines } = analyzeMarkdownLines(message.rawText, lines);
+  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,580 @@
+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 matches = this.visibleItems().length;
+    const countText = this.queryInput.getValue() ? `${matches} ${matches === 1 ? "match" : "matches"}` : "";
+    const matchCount = countText && width >= visibleWidth("type to search > ") + visibleWidth(this.queryInput.getValue()) + visibleWidth(countText) + 2 ? " " + this.theme.fg("dim", countText) : "";
+    const prefix = `Page ${pageIndex + 1}/${pageCount} ${this.theme.fg("dim", `(tool messages ${this.showTools ? "included" : "excluded"})`)}, `;
+    const inputWidth = Math.min(width - visibleWidth(matchCount), visibleWidth("type to search > ") + visibleWidth(this.queryInput.getValue()) + 1);
+    const shownPrefix = truncateToWidth(prefix, Math.max(0, width - visibleWidth(matchCount) - 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) - visibleWidth(matchCount)))[0] + matchCount,
+      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();
+  }
+}