pi-copy-message 3.0.0 → 4.0.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## Unreleased
+
+## 4.0.1 - 2026-10-31
+
+- Stop enumerating graphemes once a message preview is known to need truncation; preserve preview and copied text.
+
+- Wrap only enough of a long message to fill the `Tab` peek instead of the whole message; very long messages note that more lines remain instead of counting them. Copied text is unchanged.
+
+- Cancel pending copy pickers when the host disposes their UI, including during reload, without interrupting sibling dialog teardown.
+
+## 4.0.0 - 2026-10-01
+
+- Require Pi 1.0.0 and pin the official 1.0.0 development cohort.
+- Use the native canonical projection for latest-message copies, honoring context edits and compaction while retaining raw historical numbered/picker/user copies and legacy response snapshots.
+- Verify clipboard text before reporting success; keep Pi's complete native/platform/OSC 52 write fallback chain and warn when delivery is unverified, empty, mismatched or remote.
+- Cancel pending pickers on session/tree/shutdown lifecycle changes; suppress stale completion notifications.
+- Add native mouse navigation/copy with restored editor focus and safe isolated clipboard/SDK lifecycle regression coverage.
+
 ## 3.0.0 - 2026-09-26
 
 - Require Node.js 24.15 or newer for repository tooling; `.nvmrc` pins 24.21.0 and `packageManager` is npm 12.1.0.

package/README.md

@@ -1,153 +1,74 @@
-# pi copy-message extension
+# pi-copy-message
 
-A [pi](https://github.com/earendil-works/pi-mono) extension that adds `/copy-message`: a keyboard-first picker for copying raw session message text without terminal wrapping, padding, or rendered TUI artifacts. It also adds `/copy-user` as a direct shortcut for the most recent user message.
+Copy message text from a [Pi](https://github.com/earendil-works/pi-mono) session with a searchable picker. The copied text keeps the original code, spaces, and line breaks.
 
-`pi-copy-message` supersedes [`pi-copy-user-message`](https://github.com/fitchmultz/pi-copy-user-message), which only copied the most recent user message.
+![Flow from the /copy-message command through message search and selection to the clipboard.](.github/readme/copy-flow.png)
 
-## What it does
+## Install and start
 
-- Adds `/copy-message`
-- Adds `/copy-user` for copying the most recent user message directly
-- Copies raw stored session message text, not rendered terminal lines
-- Shows messages in chat order: oldest at top, newest at bottom
-- Selects the newest visible message by default
-- Supports role filters for user, assistant, tool/bash, and custom messages
-- Hides tool/bash messages by default
-- Supports type-to-filter search across role and message text, with `time:<term>` for timestamp search
-- Supports Home/End jumps for oldest/newest visible messages
-- Uses Pi's configured selection bindings for navigation, copy, and cancel
-- Uses Pi's clipboard implementation, including its OSC 52 terminal fallback
-- Includes fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`
-- Supports direct numbered copies like `/copy-message 3`
-- Supports metadata copies with `--with-meta`, `--with-metadata`, or `--with-role`
+This extension requires Pi and Node.js. See the [development guide](https://github.com/fitchmultz/pi-copy-message/blob/main/docs/development.md) for version requirements.
 
-## Install
-
-Install it from npm with pi:
+Run this command:
 
 ```bash
 pi install npm:pi-copy-message
 ```
 
-Or install it directly from GitHub with pi:
-
-```bash
-pi install https://github.com/fitchmultz/pi-copy-message
-```
-
-Restart Pi after installing or updating extension code or dependencies. The maintained fork's `/reload` refreshes resources and reinitializes cached code; it does not apply code updates.
-
-If you prefer to load it directly from a local checkout during development:
-
-```bash
-pi -e ./extensions/copy-message.ts
-```
-
-## Usage
+Start Pi. Run `/reload` if Pi is already open.
 
-Open the picker:
+Enter this command in Pi:
 
 ```text
 /copy-message
 ```
 
-Copy the most recent user message directly:
+Type words to search roles and message text. Use ↑ or ↓ to select a message. Press Enter to copy the message.
 
-```text
-/copy-user
-```
+## Use the picker
 
-Copy the latest visible default message directly:
+Messages appear from oldest to newest. The picker selects the newest visible message first.
 
-```text
-/copy-message latest
-```
+User, assistant, and visible custom messages appear by default. Tool and bash messages stay hidden.
 
-Aliases:
+| Key | Action |
+|---|---|
+| Ctrl+T | Show or hide tool and bash messages |
+| Ctrl+U / Ctrl+A / Alt+C | Show or hide user, assistant, or custom messages |
+| Tab | Preview the selected message |
+| Alt+M | Switch between raw text and text with role/time metadata |
+| Esc / Ctrl+C | Cancel |
 
-```text
-/copy-message last
-/copy-message newest
-```
+The picker uses your Pi selection bindings. Its key hints show those bindings.
 
-Copy the 3rd default-visible message directly, matching the picker's 1-based oldest-to-newest numbering:
+## Direct copies
 
-```text
-/copy-message 3
-```
+| Command | What it copies |
+|---|---|
+| `/copy-user` | Your most recent message with text |
+| `/copy-message latest` | The latest default-visible message in Pi's active context |
+| `/copy-message 3` | The third default-visible message, counted oldest to newest |
+| `/copy-message latest --with-meta` | The latest message with its role and local time, when available |
 
-Copy with role and timestamp metadata instead of raw text only:
+`latest` follows Pi's active context, including context edits, omissions, and compaction. The picker, numbered copies, and `/copy-user` use stored messages on the current branch, including history before compaction.
 
-```text
-/copy-message latest --with-meta
-/copy-message 3 --with-role
-/copy-user --with-meta
-```
+## Limits and clipboard
 
-## Keyboard controls
+The picker requires interactive TUI mode. Direct commands also work outside TUI mode, where Pi may hide notifications.
 
-| Key | Action |
-|---|---|
-| Configured `tui.select.up` (default: `↑`) | Move to older visible message |
-| Configured `tui.select.down` (default: `↓`) | Move to newer visible message |
-| Configured `tui.select.pageUp` / `tui.select.pageDown` (default: `PageUp` / `PageDown`) | Move by one visible page in regular mode |
-| `Ctrl+PageUp` / `Ctrl+PageDown` | Move by one visible page in fullscreen mode |
-| `Home` / `End` | Jump to oldest/newest visible message in regular mode |
-| `Ctrl+Home` / `Ctrl+End` | Jump to oldest/newest visible message in fullscreen mode |
-| Type or paste text | Filter visible messages; pasted line breaks and tabs become spaces |
-| `time:<term>` | Search timestamps |
-| `Backspace` | Delete one search character |
-| `Ctrl+U` | Toggle user messages |
-| `Ctrl+A` | Toggle assistant messages |
-| `Ctrl+T` | Toggle tool/bash messages |
-| `Alt+C` | Toggle custom messages |
-| `Tab` | Toggle a wrapped preview of the selected message |
-| `Alt+M` | Toggle raw vs metadata copy format |
-| Configured `tui.select.confirm` (default: `Enter`) | Copy selected message text |
-| Configured `tui.select.cancel` (default: `Esc`/`Ctrl+C`) | Cancel |
-
-## Behavior notes
-
-- Entry IDs are hidden from the picker.
-- The picker caps visible rows and scrolls instead of filling the screen.
-- Search preserves your original selected message and restores it when the search is cleared.
-- General search does not match timestamps; use `time:<term>` when you want to search by displayed time.
-- Picker previews and copy notifications remove terminal control characters; the copied text stays raw.
-- Filter labels honor the active pi theme.
-- Selection key hints show the active Pi bindings. Configured selection actions take precedence if they collide with the picker's filter, preview, or format shortcuts.
-- Only custom messages with `display: true` can appear or be copied from current `custom_message` entries or legacy message-wrapped entries; visible ones can be toggled with `Alt+C`.
-- Copy notifications include the role and a short preview so you can verify what was copied.
-- `/copy-message latest` and numbered selectors include user, assistant, and visible custom messages by default while hiding tool/bash messages. `Alt+C` only affects the picker. If only hidden messages exist, `latest` falls back to the newest message so the command still does something useful.
-- `/copy-message` with no direct selector requires interactive TUI mode because the picker is a custom TUI component.
-- Direct commands such as `/copy-user`, `/copy-message latest`, and `/copy-message 3` do not require TUI mode, though non-UI modes may not display notifications.
-
-## Compatibility
-
-- Declared Pi floor: 0.84.0. Qualified on official Pi 0.87.1 and the maintained fork's `main` (not a claim that every later release has been tested).
-- The maintained fork persists in-progress assistant snapshots and context-window boundaries; the picker coalesces those so each response appears once. Official Pi writes neither, and the same code handles both.
-- Android/Termux clipboard writes use Pi's normal fallback chain, including OSC 52 when native clipboard commands are unavailable.
-- Pi includes `Ctrl+X` for copying the latest assistant response; this extension remains useful for searchable history, other roles, metadata, and direct selectors.
-- Node.js `>=24.15.0`. `.nvmrc` pins Node 24.21.0 for local development.
-
-This package keeps pi core packages as wildcard peers (`*`) per pi package guidance. Pi aliases these imports to its own bundled copies when loading the extension, so the package never bundles or shadows pi core. Local development uses `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` as dev dependencies for typechecking and tests.
-
-## Development
+The extension uses Pi's clipboard support and OSC 52 fallback. It reports “Copied” only after local clipboard readback matches the copied text.
 
-```bash
-npm ci
-npm run check # node --test + tsc --noEmit + pack dry-run
-```
+Unverified delivery produces a warning. A failed write produces an error.
 
-No production build or `prepare` is required. Tests run TypeScript directly with Node's type stripping, so source must stay erasable (`erasableSyntaxOnly`). Qualification uses the selected host installed in this checkout's dependency graph. The tests cover picker behavior and formatting without clipboard writes; native clipboard delivery, including Android/Termux and OSC 52, requires separate platform qualification.
+The extension cannot verify remote terminal delivery. Paste into a local editor to check delivery.
 
-`package-lock.json` must only reference `registry.npmjs.org`; a test fails on private-registry URLs. Behind a registry proxy that rewrites tarball URLs, refresh the lock from public metadata and install through the proxy:
+Restart Pi after you change dependencies or the Pi runtime.
 
-```bash
-npm install --package-lock-only --ignore-scripts --registry=https://registry.npmjs.org/
-npm ci
-```
+## Docs and support
+
+The [reference](https://github.com/fitchmultz/pi-copy-message/blob/main/docs/reference.md) lists all controls, command aliases, and clipboard details. The [development guide](https://github.com/fitchmultz/pi-copy-message/blob/main/docs/development.md) covers tests and releases.
+
+[Changelog](CHANGELOG.md) · [Report an issue](https://github.com/fitchmultz/pi-copy-message/issues)
 
-Key files:
+## License
 
-- `extensions/copy-message.ts` — publishable extension implementation
-- `tests/copy-message.test.ts` — regression tests for command wiring, filtering, search, navigation, and copy formatting
+[MIT](LICENSE) · Mitch Fultz

package/extensions/copy-message.ts

@@ -1,9 +1,12 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { copyToClipboard, type ExtensionAPI, type ExtensionCommandContext, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem, TuiMode } from "@earendil-works/pi-tui";
-import { decodeKittyPrintable, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { decodeKittyPrintable, getNativeClipboard, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
 
 const MAX_VISIBLE_MESSAGES = 8;
 const MAX_PEEK_LINES = 16;
+const PEEK_WRAP_CHARS = 65_536;
 
 export type CopyFormat = "raw" | "metadata";
 
@@ -63,10 +66,14 @@ function splitGraphemes(text: string): string[] {
 
 function truncateGraphemes(text: string, max: number): string {
 	if (max <= 0) return "";
-	const graphemes = splitGraphemes(text);
-	if (graphemes.length <= max) return text;
-	if (max === 1) return "…";
-	return `${graphemes.slice(0, max - 1).join("")}…`;
+	let count = 0;
+	let prefixEnd = 0;
+	for (const { index } of graphemeSegmenter.segment(text)) {
+		if (count === max) return `${text.slice(0, prefixEnd)}…`;
+		if (count === max - 1) prefixEnd = index;
+		count++;
+	}
+	return text;
 }
 
 function safeDisplayText(text: string): string {
@@ -169,6 +176,17 @@ export function collectCopyableMessages(ctx: { sessionManager: { getBranch(): un
 	});
 }
 
+function collectProjectedMessages(ctx: ExtensionCommandContext): CopyableMessage[] {
+	const entries = ctx.sessionManager.buildSessionProjection().entries.flatMap(({ sourceEntry, messages }): unknown[] => {
+		// Retain saved fork boundaries for legacy response-snapshot coalescing.
+		if ((sourceEntry.type as string) === "context_window") return [sourceEntry];
+		return messages
+			.filter((message) => !(sourceEntry.type === "compaction" && message.role === "system"))
+			.map((message) => ({ ...sourceEntry, type: "message", message }));
+	});
+	return collectCopyableMessages({ sessionManager: { getBranch: () => entries } });
+}
+
 export type MostRecentUserMessageResult =
 	| { kind: "message"; message: CopyableMessage }
 	| { kind: "no-user-message" }
@@ -244,7 +262,7 @@ function messageMatchesSearch(message: CopyableMessage, search: string): boolean
 	});
 }
 
-export function filteredMessages(messages: CopyableMessage[], visibility: MessageVisibility, search = ""): CopyableMessage[] {
+function filteredMessages(messages: CopyableMessage[], visibility: MessageVisibility, search = ""): CopyableMessage[] {
 	return messages.filter((message) => isVisibleMessage(message, visibility) && messageMatchesSearch(message, search));
 }
 
@@ -261,7 +279,7 @@ export function messageByDefaultNumber(messages: CopyableMessage[], number: numb
 	return defaultVisibleMessages(messages)[number - 1];
 }
 
-export function formatMessageForCopy(message: CopyableMessage, format: CopyFormat): string {
+function formatMessageForCopy(message: CopyableMessage, format: CopyFormat): string {
 	if (format === "raw") return message.text;
 	const time = formatTime(message.timestamp);
 	const label = roleLabel(message.role);
@@ -326,13 +344,25 @@ function renderMessageLine(
 
 function renderPeekLines(message: CopyableMessage, width: number, theme: CopyMessageTheme, format: CopyFormat): string[] {
 	const contentWidth = Math.max(1, width - 2);
-	const text = safeDisplayText(formatMessageForCopy(message, format));
-	const wrapped = wrapTextWithAnsi(styleRoleText(theme, message.role, text, false), contentWidth);
+	let wrapped: string[];
+	let complete: boolean;
+	// Wrap a growing prefix instead of the whole message. A cut prefix ends on visible text: styling
+	// codes attached to a trailing whitespace run would make the wrapper break it into blank lines that
+	// a full wrap drops. Greedy wrapping then changes only the prefix's last two wrapped lines, so stop
+	// once those lines fall outside the visible window.
+	for (let chars = PEEK_WRAP_CHARS; ; chars *= 2) {
+		complete = chars >= message.text.length;
+		const prefix = complete ? message : { ...message, text: message.text.slice(0, chars) };
+		const text = safeDisplayText(formatMessageForCopy(prefix, format));
+		wrapped = wrapTextWithAnsi(styleRoleText(theme, message.role, complete ? text : text.trimEnd(), false), contentWidth);
+		if (complete || wrapped.length >= MAX_PEEK_LINES + 2) break;
+	}
 	const shown = wrapped.slice(0, MAX_PEEK_LINES);
 	const remaining = wrapped.length - shown.length;
 	const title = theme.fg("dim", `Peek ${format === "metadata" ? "metadata" : "raw"} ${roleLabel(message.role)} message`);
 	const lines = [title, ...shown.map((line) => `  ${line}`)];
-	if (remaining > 0) lines.push(theme.fg("dim", `  … ${remaining} more wrapped line${remaining === 1 ? "" : "s"}`));
+	if (!complete) lines.push(theme.fg("dim", "  … more wrapped lines"));
+	else if (remaining > 0) lines.push(theme.fg("dim", `  … ${remaining} more wrapped line${remaining === 1 ? "" : "s"}`));
 	return lines;
 }
 
@@ -414,6 +444,7 @@ export class CopyMessagePickerState {
 	peek = false;
 	private searchAnchorId: string | undefined;
 	private readonly messages: CopyableMessage[];
+	private firstVisibleIndex = 0;
 
 	constructor(messages: CopyableMessage[], initialFormat: CopyFormat = "raw") {
 		this.messages = messages;
@@ -435,6 +466,7 @@ export class CopyMessagePickerState {
 		const maxVisible = Math.min(this.visibleMessages.length, MAX_VISIBLE_MESSAGES);
 		const start = maxVisible === 0 ? 0 : Math.max(0, Math.min(this.selectedIndex - maxVisible + 1, this.visibleMessages.length - maxVisible));
 		const end = Math.min(this.visibleMessages.length, start + maxVisible);
+		this.firstVisibleIndex = start;
 		const hasCustomMessages = this.messages.some((message) => message.role === "custom");
 		const userState = filterLabel(theme, "user", this.visibility.showUser, "warning");
 		const assistantState = filterLabel(theme, "assistant", this.visibility.showAssistant, "accent");
@@ -584,6 +616,20 @@ export class CopyMessagePickerState {
 		return "none";
 	}
 
+	handleMouse(event: TuiMouseEvent): PickerInputResult {
+		if (event.type === "wheel" && event.wheelDelta) {
+			this.move(event.wheelDelta < 0 ? -1 : 1);
+			return "render";
+		}
+		if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) return "none";
+		const row = event.y - 2; // The message list follows the title and spacer.
+		if (row < 0 || row >= MAX_VISIBLE_MESSAGES) return "none";
+		const index = this.firstVisibleIndex + row;
+		if (!this.visibleMessages[index]) return "none";
+		this.selectedIndex = index;
+		return event.type === "click" ? "copy" : "render";
+	}
+
 	private refreshMessages(preferredId?: string) {
 		const selectedId = preferredId ?? this.visibleMessages[this.selectedIndex]?.id;
 		this.visibleMessages = filteredMessages(this.messages, this.visibility, this.search);
@@ -650,7 +696,7 @@ function parseCopyArgs(args: string | undefined): ParsedCopyMessageArgs {
 	return result;
 }
 
-export function copyArgumentCompletions(prefix: string, includeSelectors: boolean): AutocompleteItem[] | null {
+function copyArgumentCompletions(prefix: string, includeSelectors: boolean): AutocompleteItem[] | null {
 	if (/^\d+$/.test(prefix)) return null;
 	const candidates = includeSelectors ? [...COPY_LATEST_SELECTORS, ...COPY_METADATA_FLAGS] : COPY_METADATA_FLAGS;
 	const normalized = prefix.toLowerCase();
@@ -660,27 +706,44 @@ export function copyArgumentCompletions(prefix: string, includeSelectors: boolea
 	return items.length > 0 ? items : null;
 }
 
-async function pickMessage(ctx: ExtensionCommandContext, messages: CopyableMessage[], initialFormat: CopyFormat) {
+async function pickMessage(ctx: ExtensionCommandContext, messages: CopyableMessage[], initialFormat: CopyFormat, signal: AbortSignal) {
+	if (signal.aborted) return null;
 	return ctx.ui.custom<{ message: CopyableMessage; text: string } | null>((tui, theme, keybindings, done) => {
 		const state = new CopyMessagePickerState(messages, initialFormat);
+		let settled = false;
+		const finish = (result: Parameters<typeof done>[0], defer = false) => {
+			if (settled) return;
+			settled = true;
+			if (defer) queueMicrotask(() => done(result));
+			else done(result);
+		};
+		const abort = () => finish(null);
+		if (signal.aborted) abort();
+		else signal.addEventListener("abort", abort, { once: true });
+		const act = (result: PickerInputResult) => {
+			if (result === "copy") {
+				const selected = state.selectedMessage();
+				const text = state.selectedCopyText();
+				finish(selected && text !== undefined ? { message: selected, text } : null);
+			} else if (result === "cancel") finish(null);
+			else if (result === "render") tui.requestRender();
+		};
 		return {
 			render(width: number) {
 				return state.render(width, theme, keybindings, tui.mode);
 			},
 			invalidate() {},
-			handleInput(data: string) {
-				const result = state.handleInput(data, keybindings);
-				if (result === "copy") {
-					const selected = state.selectedMessage();
-					const text = state.selectedCopyText();
-					done(selected && text !== undefined ? { message: selected, text } : null);
-					return;
-				}
-				if (result === "cancel") {
-					done(null);
-					return;
-				}
-				if (result === "render") tui.requestRender();
+			handleInput(data: string) { act(state.handleInput(data, keybindings)); },
+			handleMouse(event) {
+				const result = state.handleMouse(event);
+				act(result);
+				if (result !== "none") return { handled: true, focus: result === "render" };
+			},
+			dispose() {
+				signal.removeEventListener("abort", abort);
+				// Settle even if disposal precedes session_shutdown. Defer the host callback:
+				// it can remove this component from a live dialog-disposal iteration.
+				finish(null, true);
 			},
 		};
 	});
@@ -690,74 +753,132 @@ function copyNotificationText(selected: CopyableMessage): string {
 	return `Copied ${roleLabel(selected.role)} message: “${compactPreview(selected.text, 48)}”`;
 }
 
-async function copySelectedMessage(ctx: Pick<ExtensionCommandContext, "ui">, selected: CopyableMessage, text = selected.text) {
+const runClipboardReader = promisify(execFile);
+
+async function readCopiedText(expected: string): Promise<string | null | undefined> {
+	if (process.platform !== "linux") {
+		try {
+			const text = await getNativeClipboard()?.getText();
+			if (text !== undefined) return text;
+		} catch {
+			// The platform command fallback can still work if the native helper fails.
+		}
+	}
+	const commands: [string, string[]][] = [];
+	const windowsRead = ["-NoProfile", "-Command", "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false); [Console]::Write((Get-Clipboard -Raw))"];
+	if (process.platform === "darwin") commands.push(["pbpaste", []]);
+	else if (process.platform === "win32") commands.push(["powershell", windowsRead]);
+	else {
+		if (process.env.TERMUX_VERSION) commands.push(["termux-clipboard-get", []]);
+		if (process.env.WAYLAND_DISPLAY) commands.push(["wl-paste", ["--no-newline", "--type", "text"]]);
+		if (process.env.DISPLAY) commands.push(["xclip", ["-selection", "clipboard", "-out"]], ["xsel", ["--clipboard", "--output"]]);
+		if (!commands.length && (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)) commands.push(["powershell.exe", windowsRead]);
+	}
+	for (const [command, args] of commands) {
+		try {
+			const { stdout } = await runClipboardReader(command, args, {
+				encoding: "utf8", timeout: 3000, maxBuffer: Math.max(1024 * 1024, Buffer.byteLength(expected) + 4096),
+			});
+			return stdout || null;
+		} catch {
+			// Try the next platform reader; never expose clipboard contents on failure.
+		}
+	}
+	return undefined;
+}
+
+type Notify = ExtensionCommandContext["ui"]["notify"];
+
+async function copySelectedMessage(notify: Notify, selected: CopyableMessage, text = selected.text) {
 	try {
 		await copyToClipboard(text);
-		ctx.ui.notify(copyNotificationText(selected), "info");
+		const actual = await readCopiedText(text);
+		const remote = Boolean(process.env.SSH_CONNECTION || process.env.SSH_CLIENT || process.env.MOSH_CONNECTION);
+		if (actual === text && !remote) notify(copyNotificationText(selected), "info");
+		else notify(
+			actual === text ? "Local clipboard verified; remote terminal clipboard delivery is unverified."
+				: "Clipboard command completed, but delivery could not be verified.",
+			"warning",
+		);
 	} catch (error) {
-		ctx.ui.notify(error instanceof Error ? error.message : "Failed to copy to clipboard", "error");
+		notify(error instanceof Error ? error.message : "Failed to copy to clipboard", "error");
 	}
 }
 
-async function copyMostRecentUserMessage(ctx: Pick<ExtensionCommandContext, "sessionManager" | "ui">, format: CopyFormat) {
+async function copyMostRecentUserMessage(ctx: Pick<ExtensionCommandContext, "sessionManager">, notify: Notify, format: CopyFormat) {
 	const result = getMostRecentUserMessage(ctx);
 	if (result.kind === "no-user-message") {
-		ctx.ui.notify("No user messages found", "warning");
+		notify("No user messages found", "warning");
 		return;
 	}
 	if (result.kind === "no-text") {
-		ctx.ui.notify("No user message text found", "warning");
+		notify("No user message text found", "warning");
 		return;
 	}
-
-	await copySelectedMessage(ctx, result.message, formatMessageForCopy(result.message, format));
+	await copySelectedMessage(notify, result.message, formatMessageForCopy(result.message, format));
 }
 
-export default function copyMessageExtension(pi: Pick<ExtensionAPI, "registerCommand">) {
+export default function copyMessageExtension(pi: Pick<ExtensionAPI, "registerCommand" | "on">) {
+	let generation = 0;
+	let pickerAbort: AbortController | undefined;
+	const reset = () => {
+		generation++;
+		pickerAbort?.abort();
+		pickerAbort = undefined;
+	};
+	pi.on("session_start", reset);
+	pi.on("session_shutdown", reset);
+	pi.on("session_tree", reset);
+	const notifications = (ctx: ExtensionCommandContext): Notify => {
+		const current = generation;
+		return (message, type) => { if (current === generation) ctx.ui.notify(message, type); };
+	};
 	pi.registerCommand("copy-message", {
 		description: "Select a session message and copy its text to the clipboard",
 		getArgumentCompletions: (argumentPrefix) => copyArgumentCompletions(argumentPrefix, true),
 		handler: async (args, ctx) => {
+			const notify = notifications(ctx);
 			const parsedArgs = parseCopyArgs(args);
-			const messages = collectCopyableMessages(ctx);
+			const messages = parsedArgs.selector === "latest" ? collectProjectedMessages(ctx) : collectCopyableMessages(ctx);
 			if (messages.length === 0) {
-				ctx.ui.notify("No copyable messages found in the current branch", "error");
+				notify("No copyable messages found in the current branch", "error");
 				return;
 			}
-
 			if (parsedArgs.selector === "latest") {
 				const latestVisible = latestDefaultMessage(messages);
-				if (latestVisible) await copySelectedMessage(ctx, latestVisible, formatMessageForCopy(latestVisible, parsedArgs.format));
+				if (latestVisible) await copySelectedMessage(notify, latestVisible, formatMessageForCopy(latestVisible, parsedArgs.format));
 				return;
 			}
-
 			if (typeof parsedArgs.selector === "object") {
 				const selected = messageByDefaultNumber(messages, parsedArgs.selector.number);
 				if (!selected) {
-					ctx.ui.notify(`No default visible message #${parsedArgs.selector.number} (found ${defaultVisibleMessages(messages).length})`, "warning");
+					notify(`No default visible message #${parsedArgs.selector.number} (found ${defaultVisibleMessages(messages).length})`, "warning");
 					return;
 				}
-				await copySelectedMessage(ctx, selected, formatMessageForCopy(selected, parsedArgs.format));
+				await copySelectedMessage(notify, selected, formatMessageForCopy(selected, parsedArgs.format));
 				return;
 			}
-
 			if (ctx.mode !== "tui") {
-				ctx.ui.notify("/copy-message requires interactive TUI mode unless you pass latest/last/newest or a message number", "error");
+				notify("/copy-message requires interactive TUI mode unless you pass latest/last/newest or a message number", "error");
 				return;
 			}
-
-			const selected = await pickMessage(ctx, messages, parsedArgs.format);
-			if (!selected) return;
-
-			await copySelectedMessage(ctx, selected.message, selected.text);
+			pickerAbort?.abort();
+			const controller = new AbortController();
+			pickerAbort = controller;
+			try {
+				const selected = await pickMessage(ctx, messages, parsedArgs.format, controller.signal);
+				if (!selected || controller.signal.aborted) return;
+				await copySelectedMessage(notify, selected.message, selected.text);
+			} finally {
+				if (pickerAbort === controller) pickerAbort = undefined;
+			}
 		},
 	});
-
 	pi.registerCommand("copy-user", {
 		description: "Copy the most recent user message to the clipboard",
 		getArgumentCompletions: (argumentPrefix) => copyArgumentCompletions(argumentPrefix, false),
 		handler: async (args, ctx) => {
-			await copyMostRecentUserMessage(ctx, parseCopyArgs(args).format);
+			await copyMostRecentUserMessage(ctx, notifications(ctx), parseCopyArgs(args).format);
 		},
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-copy-message",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "Pi extension with a searchable TUI picker for copying raw session messages",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
   "license": "MIT",
@@ -45,9 +45,9 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@earendil-works/pi-tui": "0.87.1",
-    "@types/node": "24.19.0",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
+    "@types/node": "24.19.1",
     "typescript": "7.0.2"
   },
   "pi": {
@@ -55,7 +55,7 @@
       "./extensions"
     ]
   },
-  "packageManager": "npm@12.1.0",
+  "packageManager": "npm@12.2.0",
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"