@oh-my-pi/pi-tui 18.4.2 → 18.4.4

package/src/overlays/copy-selector.ts

@@ -15,13 +15,16 @@
  * mouse selection nor cmd-click.
  */
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { TspPickerColumn, TspPickerItem, TspPickerProps, TspText } from "@oh-my-pi/pi-wire";
 import { type Component, matchesKey, routeSgrMouseInput, type TUI, truncateToWidth, visibleWidth } from "../index";
 import type { MessageRenderer } from "../chat/extension-types";
 import {
 	recentTranscriptEntries,
 	type SessionMessageEntryLike as SessionMessageEntry,
 	type TranscriptEntryLike as TranscriptEntry,
+	textContent,
 	transcriptEntryMessage,
+	userMessageLabel,
 	userTurnDraft,
 } from "../chat/transcript-entry";
 import { expandKeyHint, replaceTabs } from "../render/render-utils";
@@ -39,6 +42,228 @@ import {
 	type OutlineTarget,
 	outlineRows,
 } from "../chat/transcript-outline";
+import { code, compact, md, node, row, span, text } from "../native/describe";
+import type { DescribeContext, NativeChild, NativeNode, NativeUiEvent } from "../native/node";
+import { actionHint, hintsRow, type NativeHint, overlayCard } from "../native/overlay";
+import { CLOSE_ACTION, type PickerEvent, picker, pickerAction, pickerEvent } from "../native/picker";
+
+/** Key of the leading list item that replays the history older than the startup tail. */
+export const EARLIER_TURNS_KEY = "earlier";
+
+/** Leading item of a truncated transcript list; selecting it loads the older turns. */
+export const earlierTurnsItem: NativeNode = node(
+	"item",
+	{ label: [span("Earlier turns…", "muted")], hint: ["a"] },
+	undefined,
+	EARLIER_TURNS_KEY,
+);
+
+/** First non-blank line of `source`, whitespace collapsed. */
+function firstLine(source: string): string {
+	const line = source.split("\n").find(part => part.trim().length > 0) ?? "";
+	return line.replace(/\s+/g, " ").trim();
+}
+
+/** Plain one-line label and styling role for the turn a target opens. */
+function turnSummary(entry: TranscriptEntry): { label: string; role: string } {
+	const message = transcriptEntryMessage(entry);
+	switch (message?.role) {
+		case "user":
+			return { label: userMessageLabel(message.content), role: "omp.user" };
+		case "assistant": {
+			let prose = "";
+			const tools: string[] = [];
+			for (const content of message.content) {
+				if (content.type === "text") prose += content.text;
+				else if (content.type === "toolCall") tools.push(content.name);
+			}
+			const label = firstLine(prose) || tools.join(", ") || "thinking";
+			return { label, role: "omp.assistant" };
+		}
+		case "toolResult":
+			return { label: `${message.toolName} result`, role: `omp.tool.${message.toolName}` };
+		case "bashExecution":
+			return { label: `$ ${firstLine(message.command)}`, role: "omp.tool.bash" };
+		case "pythonExecution":
+			return { label: firstLine(message.code), role: "omp.tool.eval" };
+		case "compactionSummary":
+			return { label: "Compaction summary", role: "omp.summary" };
+		case "branchSummary":
+			return { label: "Branch summary", role: "omp.summary" };
+		case "custom":
+		case "hookMessage": {
+			const draft = userTurnDraft(entry);
+			if (draft !== undefined) return { label: firstLine(draft), role: "omp.user" };
+			return { label: firstLine(textContent(message.content, " ")) || message.customType, role: "omp.custom" };
+		}
+		default:
+			return { label: entry.id, role: "omp.message" };
+	}
+}
+
+/** Local `HH:MM` of an entry's persisted timestamp; empty when unparsable. */
+function entryTime(entry: TranscriptEntry): string {
+	const date = new Date(entry.timestamp);
+	if (Number.isNaN(date.getTime())) return "";
+	return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+
+/**
+ * One list item per outline target, keyed by the turn's opening entry id:
+ * the plain turn summary as label, `detail` (or the entry time) on the right.
+ */
+export function turnItem(target: OutlineTarget, detail?: TspText): NativeNode {
+	const entry = target.entries[0]!;
+	const { label, role } = turnSummary(entry);
+	const time = entryTime(entry);
+	return node(
+		"item",
+		{
+			label: label || "(empty)",
+			detail: detail ?? (time || undefined),
+			value: detail !== undefined && time ? [span(time, "dim")] : undefined,
+			role,
+			tone: target.isUserTurn ? "user" : undefined,
+		},
+		undefined,
+		target.turnId,
+	);
+}
+
+/** Preview of a turn's text: prose as markdown, command/tool output as a plain code block. */
+export function turnPreview(target: OutlineTarget, content: string): NativeNode {
+	if (!content.trim()) return text([span("(no text)", "muted")]);
+	const message = transcriptEntryMessage(target.entries[0]!);
+	switch (message?.role) {
+		case "assistant":
+			// A pure tool turn previews its joined commands/results, not prose.
+			return message.content.some(part => part.type === "text" && part.text.trim())
+				? md(content)
+				: code(content, { wrap: true });
+		case "user":
+		case "custom":
+		case "hookMessage":
+		case "compactionSummary":
+		case "branchSummary":
+			return md(content);
+		default:
+			return code(content, { wrap: true });
+	}
+}
+
+/** Argument keys naming what a tool call works on, in preference order. */
+const TOOL_TARGET_KEYS = ["command", "pattern", "path", "file_path", "query", "url", "code"] as const;
+
+/** One-line label of a tool call: its name and main argument (`grep ack`, `bash ls -la`). */
+function toolCallLabel(name: string, args: Record<string, unknown> | undefined): string {
+	for (const key of TOOL_TARGET_KEYS) {
+		const value = args?.[key];
+		if (typeof value === "string" && value.trim()) return `${name} ${firstLine(value)}`;
+	}
+	return name;
+}
+
+/** The timeline pickers' one fact column: a user turn's clock time. */
+export const TIMELINE_COLUMNS: readonly TspPickerColumn[] = [{ id: "at", format: "dim", priority: 1 }];
+
+/**
+ * The `timeline` picker item of one outline target (rewind, copy), keyed by
+ * the turn's opening entry id: user turns carry their `HH:MM`, pure tool turns
+ * the tool's role and a `name target` label.
+ */
+export function timelineItem(target: OutlineTarget): TspPickerItem {
+	const entry = target.entries[0]!;
+	const id = target.turnId;
+	const summary = turnSummary(entry);
+	const label = summary.label || "(empty)";
+	if (target.isUserTurn) {
+		const at = entryTime(entry);
+		return { id, label, node: "user", ...(at ? { facts: { at } } : {}) };
+	}
+	const message = transcriptEntryMessage(entry);
+	switch (message?.role) {
+		case "assistant": {
+			const prose = message.content.some(part => part.type === "text" && part.text.trim());
+			const calls = message.content.filter(part => part.type === "toolCall");
+			if (prose || calls.length === 0) return { id, label, node: "assistant" };
+			return {
+				id,
+				label: calls.map(call => toolCallLabel(call.name, call.arguments)).join(" · "),
+				node: "tool",
+				role: `omp.tool.${calls[0]!.name}`,
+			};
+		}
+		case "toolResult":
+		case "bashExecution":
+		case "pythonExecution":
+			return { id, label, node: "tool", role: summary.role };
+		default:
+			return { id, label, node: "marker" };
+	}
+}
+
+/** Timeline picker items for `targets`, reused while `targets` is the same array. */
+export class TimelineItems {
+	#memo: { targets: readonly OutlineTarget[]; items: TspPickerItem[] } | undefined;
+
+	of(targets: readonly OutlineTarget[]): TspPickerItem[] {
+		if (this.#memo?.targets !== targets) this.#memo = { targets, items: targets.map(timelineItem) };
+		return this.#memo.items;
+	}
+}
+
+/** Lines of a copy block shown in the native preview; longer blocks copy through omp. */
+const PREVIEW_BLOCK_LINES = 400;
+
+/** A block's preview caption: `rust · 12 lines`, `quote`, `link · docs`. */
+function blockCaption(block: CopyBlock): string {
+	if (block.href || block.kind === "quote") return block.label;
+	const lines = block.content.split("\n").length;
+	const kind = block.kind === "code" ? (block.language ?? "code") : block.label;
+	return `${kind}${theme.sep.dot}${lines} line${lines === 1 ? "" : "s"}`;
+}
+
+/** A block's preview content: the link, the quote as markdown, else highlighted code. */
+function blockBody(block: CopyBlock): NativeNode {
+	if (block.href) return text([span(block.href, "link")], { wrap: "char", href: block.href });
+	if (block.kind === "quote") return md(block.content);
+	const lines = block.content.split("\n");
+	if (lines.length <= PREVIEW_BLOCK_LINES) return code(block.content, { lang: block.language, wrap: true });
+	const shown = lines.slice(0, PREVIEW_BLOCK_LINES).join("\n");
+	return node("col", { gap: "xs" }, [
+		code(shown, { lang: block.language, wrap: true }),
+		text([span(`… +${lines.length - PREVIEW_BLOCK_LINES} more lines`, "dim")]),
+	]);
+}
+
+/**
+ * One borderless preview section of the copy picker. A click copies it in the
+ * terminal (`copy`) when the preview holds the whole text, else asks omp to
+ * (`pick`); link sections also offer `open`. The focused block's section takes
+ * the `omp.picker.block.focused` role and the accent tone.
+ */
+function previewSection(
+	key: string,
+	caption: string,
+	body: NativeNode,
+	content: string,
+	focused: boolean,
+	href?: string,
+): NativeNode {
+	const whole = content.split("\n").length <= PREVIEW_BLOCK_LINES;
+	return node(
+		"section",
+		{
+			head: caption,
+			role: focused ? "omp.picker.block.focused" : "omp.picker.block",
+			...(focused ? { tone: "accent" as const } : {}),
+			...(href ? { href } : {}),
+			actions: { click: whole ? "copy" : "pick", ...(href ? { menu: ["copy", "open"] } : {}) },
+		},
+		[body],
+		key,
+	);
+}
 
 export interface CopySelectorDeps {
 	ui: TUI;
@@ -120,6 +345,15 @@ export class CopySelectorComponent implements Component {
 	/** True while older history is still unreplayed. */
 	#truncated = false;
 
+	/** Last described root and the state it was built from. */
+	#native: { memo: string; targets: OutlineTarget[]; blocks: CopyBlock[] | undefined; node: NativeNode } | undefined;
+	/** Transcript list items, rebuilt only when the replayed targets change. */
+	#nativeItems: { targets: OutlineTarget[]; truncated: boolean; items: NativeNode[] } | undefined;
+	/** Timeline picker items of the replayed targets. */
+	#pickerItems = new TimelineItems();
+	/** Last described picker and the state it was built from. */
+	#picker: { memo: string; targets: OutlineTarget[]; blocks: CopyBlock[] | undefined; node: NativeNode } | undefined;
+
 	constructor(
 		entries: TranscriptEntry[],
 		private readonly deps: CopySelectorDeps,
@@ -213,8 +447,7 @@ export class CopySelectorComponent implements Component {
 			return;
 		}
 		if (matchesSelectCancel(data) || matchesKey(data, "escape")) {
-			if (this.#blocks) this.#ascend();
-			else this.deps.onCancel();
+			this.#escape();
 			return;
 		}
 		if (matchesAppToolsExpand(data)) {
@@ -232,14 +465,7 @@ export class CopySelectorComponent implements Component {
 			return;
 		}
 		if (matchesKey(data, "right")) {
-			if (this.#blocks) return;
-			const target = this.#targets[this.#selected];
-			if (!target) return;
-			const blocks = this.#blocksFor(target);
-			if (blocks.length === 0) return;
-			this.#blocks = blocks;
-			this.#blockSelected = 0;
-			this.deps.requestRender();
+			this.#descend();
 			return;
 		}
 		if (matchesKey(data, "left")) {
@@ -251,20 +477,11 @@ export class CopySelectorComponent implements Component {
 			return;
 		}
 		if (data === "o" || data === "O") {
-			const block = this.#blocks?.[this.#blockSelected];
-			if (block?.href && this.deps.onOpen) this.deps.onOpen(block.href, block.label);
+			this.#openSelectedBlock();
 			return;
 		}
 		if (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n") {
-			if (this.#blocks) {
-				const block = this.#blocks[this.#blockSelected];
-				if (block) this.deps.onPick(block.content, block.label, { entry: block.entry, block });
-				return;
-			}
-			const target = this.#targets[this.#selected];
-			if (!target) return;
-			const item = targetCopy(target, this.#blocksFor(target));
-			this.deps.onPick(item.content, item.label, { entry: target.entries[0]! });
+			this.#pickOutlined();
 			return;
 		}
 		// Page/home/end/shift+arrow scrolling without moving the selection.
@@ -273,6 +490,42 @@ export class CopySelectorComponent implements Component {
 		}
 	}
 
+	/** Esc: leave the block view, else close. */
+	#escape(): void {
+		if (this.#blocks) this.#ascend();
+		else this.deps.onCancel();
+	}
+
+	/** Right: replace the outlined turn with its inner blocks. */
+	#descend(): void {
+		if (this.#blocks) return;
+		const target = this.#targets[this.#selected];
+		if (!target) return;
+		const blocks = this.#blocksFor(target);
+		if (blocks.length === 0) return;
+		this.#blocks = blocks;
+		this.#blockSelected = 0;
+		this.deps.requestRender();
+	}
+
+	/** Enter: pick the outlined block, or the outlined turn's text. */
+	#pickOutlined(): void {
+		if (this.#blocks) {
+			const block = this.#blocks[this.#blockSelected];
+			if (block) this.deps.onPick(block.content, block.label, { entry: block.entry, block });
+			return;
+		}
+		const target = this.#targets[this.#selected];
+		if (!target) return;
+		const item = targetCopy(target, this.#blocksFor(target));
+		this.deps.onPick(item.content, item.label, { entry: target.entries[0]! });
+	}
+
+	#openSelectedBlock(): void {
+		const block = this.#blocks?.[this.#blockSelected];
+		if (block?.href && this.deps.onOpen) this.deps.onOpen(block.href, block.label);
+	}
+
 	#ascend(): void {
 		this.#blocks = undefined;
 		this.#blockSelected = 0;
@@ -324,6 +577,275 @@ export class CopySelectorComponent implements Component {
 		}
 	}
 
+	// ========================================================================
+	// Native
+	// ========================================================================
+
+	/** A `picker` is its own sheet: the backend mounts it in `layer` without a wrapper. */
+	nativeSheet(cx: DescribeContext): boolean {
+		return cx.supports("picker");
+	}
+
+	handleNativeEvent(event: NativeUiEvent): void {
+		const picked = pickerEvent(event);
+		if (picked) {
+			this.#handlePickerEvent(picked);
+			return;
+		}
+		if (event.type === "action" && event.act === "pick") {
+			// A preview section too long to copy in the terminal: omp copies the full text.
+			this.#pickSection(event.key);
+			return;
+		}
+		if (event.type === "action") {
+			if (event.act === "blocks") this.#descend();
+			else if (event.act === "back") this.#ascend();
+			else if (event.act === "open") this.#openSelectedBlock();
+			else if (event.act === "copy") this.#pickOutlined();
+			return;
+		}
+		if (event.type !== "select" && event.type !== "activate") return;
+		// A click on an item outlines it and picks it, as Enter would.
+		if (event.key === "list" && !this.#blocks) {
+			if (event.item === EARLIER_TURNS_KEY) {
+				this.#loadFullHistory();
+				return;
+			}
+			const index = this.#targets.findIndex(target => target.turnId === event.item);
+			if (index < 0) return;
+			this.#selected = index;
+		} else if (event.key === "blocks" && this.#blocks) {
+			const index = Number(event.item);
+			if (!Number.isInteger(index) || !this.#blocks[index]) return;
+			this.#blockSelected = index;
+		} else {
+			return;
+		}
+		this.deps.requestRender();
+		this.#pickOutlined();
+	}
+
+	/** Row click selects a turn (leaving the block view), a second click copies it; the action bar runs its key. */
+	#handlePickerEvent(event: PickerEvent): void {
+		if (event.kind === "action") {
+			switch (event.act) {
+				case "pick":
+					this.#pickOutlined();
+					return;
+				case "blocks":
+					this.#descend();
+					return;
+				case "open-link":
+					this.#openSelectedBlock();
+					return;
+				case "earlier":
+					this.#loadFullHistory();
+					return;
+				case "close":
+					this.#escape();
+					return;
+				default:
+					return;
+			}
+		}
+		const index = this.#targets.findIndex(target => target.turnId === event.item);
+		if (index < 0) return;
+		if (index !== this.#selected || this.#blocks) {
+			this.#selected = index;
+			this.#blocks = undefined;
+			this.#blockSelected = 0;
+			this.deps.requestRender();
+		}
+		if (event.kind === "activate") this.#pickOutlined();
+	}
+
+	/** Pick the preview section keyed `key` (`whole` or `b<index>`) of the selected turn. */
+	#pickSection(key: string): void {
+		const target = this.#targets[this.#selected];
+		if (!target) return;
+		const blocks = this.#blocksFor(target);
+		if (key === "whole") {
+			const item = targetCopy(target, blocks);
+			this.deps.onPick(item.content, item.label, { entry: target.entries[0]! });
+			return;
+		}
+		const block = key.startsWith("b") ? blocks[Number(key.slice(1))] : undefined;
+		if (block) this.deps.onPick(block.content, block.label, { entry: block.entry, block });
+	}
+
+	describe(cx: DescribeContext): NativeNode {
+		return cx.supports("picker") ? this.#describePicker() : this.#describeCard();
+	}
+
+	/**
+	 * The `timeline` picker: the turns as rows, the selected turn's blocks as
+	 * preview sections (the whole message first), each copied by a click. In
+	 * the block view the focused block's section takes the
+	 * `omp.picker.block.focused` role and the preview owns the focus.
+	 */
+	#describePicker(): NativeNode {
+		const memo = `${this.#selected}|${this.#blockSelected}|${this.#truncated}`;
+		const cached = this.#picker;
+		if (cached?.memo === memo && cached.targets === this.#targets && cached.blocks === this.#blocks) {
+			return cached.node;
+		}
+		const target = this.#targets[this.#selected];
+		const blocks = target ? this.#blocksFor(target) : [];
+		const descended = this.#blocks !== undefined;
+		const focused = this.#blocks?.[this.#blockSelected];
+		const action = this.deps.actionLabel ?? "copy";
+		const props: TspPickerProps = {
+			title: this.deps.title ?? "Copy",
+			...(this.deps.title ? {} : { subtitle: "Pick what to put on the clipboard" }),
+			icon: "clipboard",
+			noun: "turns",
+			size: "lg",
+			layout: "timeline",
+			preview: "side",
+			query: null,
+			columns: TIMELINE_COLUMNS,
+			items: this.#pickerItems.of(this.#targets),
+			selected: target?.turnId ?? null,
+			total: this.#targets.length,
+			empty: "Nothing to copy",
+			focus: descended ? "preview" : "list",
+			actions: compact([
+				pickerAction("pick", `${action[0]!.toUpperCase()}${action.slice(1)}`, "enter", { primary: true }),
+				!descended && blocks.length > 0 ? pickerAction("blocks", "Blocks", "right") : undefined,
+				focused?.href && this.deps.onOpen ? pickerAction("open-link", "Open link", "o") : undefined,
+				!descended && this.#truncated ? pickerAction("earlier", "Earlier turns", "a") : undefined,
+				descended ? { ...CLOSE_ACTION, label: "Back" } : CLOSE_ACTION,
+			]),
+		};
+		const preview: NativeNode[] = [];
+		if (target) {
+			const whole = targetCopy(target, blocks);
+			if (whole.content.trim()) {
+				preview.push(
+					previewSection("whole", "Whole message", turnPreview(target, whole.content), whole.content, false),
+				);
+			}
+			blocks.forEach((block, index) => {
+				preview.push(
+					previewSection(
+						`b${index}`,
+						blockCaption(block),
+						blockBody(block),
+						block.content,
+						descended && index === this.#blockSelected,
+						block.href,
+					),
+				);
+			});
+		}
+		const root = picker(props, preview);
+		this.#picker = { memo, targets: this.#targets, blocks: this.#blocks, node: root };
+		return root;
+	}
+
+	#describeCard(): NativeNode {
+		const memo = `${this.#selected}|${this.#blockSelected}|${this.#truncated}`;
+		const cached = this.#native;
+		if (cached?.memo === memo && cached.targets === this.#targets && cached.blocks === this.#blocks) {
+			return cached.node;
+		}
+		const target = this.#targets[this.#selected];
+		const action = this.deps.actionLabel ?? "copy";
+		const upDown = actionHint(["tui.select.up", "tui.select.down"], this.#blocks ? "block" : "step");
+		const cancel = actionHint("tui.select.cancel", this.#blocks ? "back" : "close");
+		const children: NativeChild[] = [];
+		let hints: (NativeHint | undefined)[];
+		if (this.#blocks && target) {
+			const block = this.#blocks[this.#blockSelected];
+			children.push(
+				row([text([span("‹ back", "accent")], { actions: { click: "back" } })], { gap: "md" }),
+				node(
+					"list",
+					{ selected: String(this.#blockSelected), empty: "No blocks" },
+					this.#blocks.map((item, index) => {
+						const lines = item.content.split("\n").length;
+						return node(
+							"item",
+							{ label: item.label, detail: `${lines} line${lines === 1 ? "" : "s"}` },
+							undefined,
+							String(index),
+						);
+					}),
+					"blocks",
+				),
+			);
+			if (block) children.push(this.#blockPreview(block, action));
+			hints = [
+				upDown,
+				{ keys: ["left", ...(cancel?.keys ?? [])], label: "back" },
+				{ keys: ["enter"], label: action },
+				block?.href && this.deps.onOpen ? { keys: ["o"], label: "open" } : undefined,
+			];
+		} else {
+			const blocks = target ? this.#blocksFor(target) : [];
+			children.push(
+				node(
+					"list",
+					{ selected: target?.turnId ?? null, virtual: true, max: 0.5, empty: "Nothing to copy" },
+					this.#transcriptItems(),
+					"list",
+				),
+			);
+			if (target) {
+				const item = targetCopy(target, blocks);
+				const body: NativeChild[] = [turnPreview(target, item.content)];
+				if (blocks.length > 0) {
+					body.push(
+						text([span(`${blocks.length} block${blocks.length === 1 ? "" : "s"} ›`, "accent")], {
+							actions: { click: "blocks" },
+						}),
+					);
+				}
+				children.push(node("section", { head: [span(item.label, "strong")] }, body, "preview"));
+			}
+			hints = [
+				upDown,
+				blocks.length > 0 ? { keys: ["right"], label: "blocks" } : undefined,
+				{ keys: ["enter"], label: action },
+				this.#truncated ? { keys: ["a"], label: "earlier turns" } : undefined,
+				cancel,
+			];
+		}
+		children.push(hintsRow(hints));
+		const head: TspText = this.deps.title ?? [
+			span(`${theme.cmd.copy} `),
+			span("Copy", "strong"),
+			span(`${theme.sep.dot}pick what to put on the clipboard`, "dim"),
+		];
+		const root = overlayCard("omp.overlay.copy", head, children);
+		this.#native = { memo, targets: this.#targets, blocks: this.#blocks, node: root };
+		return root;
+	}
+
+	#transcriptItems(): NativeNode[] {
+		const cached = this.#nativeItems;
+		if (cached?.targets === this.#targets && cached.truncated === this.#truncated) return cached.items;
+		const items = this.#targets.map(target => turnItem(target));
+		if (this.#truncated) items.unshift(earlierTurnsItem);
+		this.#nativeItems = { targets: this.#targets, truncated: this.#truncated, items };
+		return items;
+	}
+
+	/** The selected block in full: highlighted code, a link, a quote, or plain output. */
+	#blockPreview(block: CopyBlock, action: string): NativeNode {
+		let body: NativeNode;
+		if (block.href) body = text([span(block.href, "link")], { wrap: "char" });
+		else if (block.kind === "quote") body = md(block.content);
+		else body = code(block.content, { lang: block.language, wrap: true });
+		const controls: NativeChild[] = [
+			text([span(`${theme.cmd.copy} ${action}`, "accent")], { actions: { click: "copy" } }),
+		];
+		if (block.href && this.deps.onOpen) {
+			controls.push(text([span(`${theme.cmd.share} open`, "accent")], { actions: { click: "open" } }));
+		}
+		return node("section", { head: [span(block.label, "strong")] }, [body, row(controls, { gap: "md" })], "preview");
+	}
+
 	// ========================================================================
 	// Render
 	// ========================================================================
@@ -530,7 +1052,7 @@ function pushMarkdownBlocks(blocks: CopyBlock[], text: string, entry: Transcript
 }
 
 /** Inner blocks of one turn: markdown code/quotes, commands, and tool output. */
-function collectBlocks(entries: readonly TranscriptEntry[]): CopyBlock[] {
+export function collectBlocks(entries: readonly TranscriptEntry[]): CopyBlock[] {
 	const blocks: CopyBlock[] = [];
 	for (const entry of entries) {
 		const message = transcriptEntryMessage(entry);
@@ -577,7 +1099,7 @@ function collectBlocks(entries: readonly TranscriptEntry[]): CopyBlock[] {
 }
 
 /** Clipboard payload for a whole turn, falling back to its blocks when the turn has no prose. */
-function targetCopy(target: OutlineTarget, blocks: readonly CopyBlock[]): { content: string; label: string } {
+export function targetCopy(target: OutlineTarget, blocks: readonly CopyBlock[]): { content: string; label: string } {
 	const entry = target.entries[0]!;
 	const message = transcriptEntryMessage(entry);
 	switch (message?.role) {