pi-copy-message 2.1.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 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.
+- Run tests with Node's built-in `node --test` and type stripping instead of `tsx`; typecheck with TypeScript 7.0.2 and `erasableSyntaxOnly`.
+- Refresh the development baseline to Pi 0.87.1, qualified against official Pi and the maintained fork.
+- Guard `package-lock.json` against private-registry URLs.
+- First npm release containing the 2.1.1 clipboard change (2.1.1 was tagged but never published to npm).
+
+## 2.1.1 - 2026-08-25
+
+- Reuse Pi's clipboard implementation instead of maintaining a duplicate command runner, enabling Pi's OSC 52 fallback on Android/Termux.
+
 ## 2.1.0 - 2026-08-17
 
 - Add an `Alt+C` picker filter and `MessageVisibility.showCustom` option for showing or hiding custom messages.

package/README.md

@@ -16,7 +16,8 @@ A [pi](https://github.com/earendil-works/pi-mono) extension that adds `/copy-mes
 - 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
-- Includes fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`
+- Keeps Pi's platform clipboard writes and OSC 52 fallback, but reports success only after local text readback
+- Includes fast paths: `/copy-message latest`, `/copy-message last`, and `/copy-message newest`, using Pi's canonical active context
 - Supports direct numbered copies like `/copy-message 3`
 - Supports metadata copies with `--with-meta`, `--with-metadata`, or `--with-role`
 
@@ -34,11 +35,7 @@ Or install it directly from GitHub with pi:
 pi install https://github.com/fitchmultz/pi-copy-message
 ```
 
-Then reload pi from inside the app:
-
-```text
-/reload
-```
+Use `/reload` after updating extension code on current official Pi and the maintained fork. Restart Pi after changing dependencies or the host runtime.
 
 If you prefer to load it directly from a local checkout during development:
 
@@ -97,7 +94,7 @@ Copy with role and timestamp metadata instead of raw text only:
 | `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 text | Filter visible messages |
+| 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 |
@@ -112,31 +109,46 @@ Copy with role and timestamp metadata instead of raw text only:
 ## Behavior notes
 
 - Entry IDs are hidden from the picker.
+- Mouse wheel navigates; clicking a message copies it and returns keyboard focus to the unchanged draft.
+- Session replacement, tree navigation, shutdown and reload cancel pending pickers without stale-context notifications.
 - 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.
+- A verified local copy notification includes the role and a short preview. Unavailable, empty or mismatched readback warns instead of claiming success; rejected writes report an error. Remote terminal delivery via OSC 52 cannot be verified, even when the remote machine's local clipboard matches.
+- Native clipboard reads are preferred where available. Bounded platform readers preserve exact text, including newlines; the extension never replaces Pi's working write fallback chain.
+- `latest` uses Pi's canonical session projection, honoring context edits, omissions and compaction. Numbered selectors, the picker and `/copy-user` retain raw active-branch history, including older pre-compaction messages.
 - `/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
 
-- Requires and is tested with Pi 0.84.0 or later
+- Requires Pi 1.0.0 or later. Development and standalone/packed qualification use the official 1.0.0 cohort; a maintained fork must be qualified at its actual supported revision, not by version-string equivalence.
+- The picker coalesces legacy in-progress assistant snapshots within their context-window boundaries so each response appears once. Current official Pi and the maintained fork no longer write those legacy boundaries.
+- 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.
-- Supported Node.js range for local repo tooling: `>=22.19.0`
-- `.nvmrc` pins Node 22.19.0 for local development
+- 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
 
 ```bash
-npm install
-npm run check
+npm ci
+npm run check # node --test + tsc --noEmit + pack dry-run
+```
+
+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 formatting, native command execution, canonical context and branch selection, both TUI modes, pointer focus and pending-picker disposal. Native addon interception and an isolated command PATH keep test clipboard writes in temporary fixture files, never the operator clipboard. Actual Android/Termux, Windows/WSL and remote terminal delivery still require platform qualification.
+
+`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:
+
+```bash
+npm install --package-lock-only --ignore-scripts --registry=https://registry.npmjs.org/
+npm ci
 ```
 
 Key files:

package/extensions/copy-message.ts

@@ -1,7 +1,8 @@
-import { spawnSync } from "node:child_process";
-import type { ExtensionAPI, ExtensionCommandContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
+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;
@@ -33,7 +34,7 @@ function textFromContent(content: unknown): string {
 			);
 		})
 		.map((part) => part.text)
-		.join("\n\n");
+		.join("");
 }
 
 function textFromMessage(message: Record<string, unknown>): string {
@@ -56,14 +57,10 @@ function textFromMessage(message: Record<string, unknown>): string {
 	return textFromContent(message.content);
 }
 
-type SegmenterCtor = new (locale?: string, options?: { granularity?: "grapheme" }) => {
-	segment(input: string): Iterable<{ segment: string }>;
-};
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
 function splitGraphemes(text: string): string[] {
-	const Segmenter = (Intl as unknown as { Segmenter?: SegmenterCtor }).Segmenter;
-	if (!Segmenter) return Array.from(text);
-	return Array.from(new Segmenter(undefined, { granularity: "grapheme" }).segment(text), (part) => part.segment);
+	return Array.from(graphemeSegmenter.segment(text), (part) => part.segment);
 }
 
 function truncateGraphemes(text: string, max: number): string {
@@ -74,8 +71,12 @@ function truncateGraphemes(text: string, max: number): string {
 	return `${graphemes.slice(0, max - 1).join("")}…`;
 }
 
+function safeDisplayText(text: string): string {
+	return text.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g, "");
+}
+
 function compactPreview(text: string, max = 96): string {
-	const preview = text.replace(/\s+/gu, " ").trim();
+	const preview = safeDisplayText(text).replace(/\s+/gu, " ").trim();
 	return truncateGraphemes(preview, max);
 }
 
@@ -96,7 +97,7 @@ function roleLabel(role: string): string {
 		case "compactionSummary":
 			return "compaction";
 		default:
-			return role || "message";
+			return safeDisplayText(role).replace(/\s+/gu, " ").trim() || "message";
 	}
 }
 
@@ -138,12 +139,49 @@ function entryToCopyableMessage(entry: unknown): CopyableMessage | undefined {
 }
 
 export function collectCopyableMessages(ctx: { sessionManager: { getBranch(): unknown[] } }): CopyableMessage[] {
-	return ctx.sessionManager.getBranch().flatMap((entry) => {
+	const entries: unknown[] = [];
+	// Pi persists assistant snapshots separately and coalesces them within each context window.
+	const responses = new Map<string, number>();
+	for (const entry of ctx.sessionManager.getBranch()) {
+		const record = entry as {
+			type?: string;
+			message?: { role?: string; responseId?: string; stopReason?: string; content?: unknown[] };
+		} | null;
+		if (record?.type === "context_window") responses.clear();
+		const responseId =
+			record?.type === "message" && record.message?.role === "assistant" && typeof record.message.responseId === "string"
+				? record.message.responseId
+				: undefined;
+		const previous = responseId ? responses.get(responseId) : undefined;
+		if (previous !== undefined) {
+			const earlier = entries[previous] as typeof record;
+			if (
+				record?.message?.stopReason !== "pending" ||
+				(earlier?.message?.stopReason === "pending" && (earlier.message.content?.length ?? 0) <= (record.message.content?.length ?? 0))
+			) entries[previous] = entry;
+			continue;
+		}
+		if (responseId) responses.set(responseId, entries.length);
+		entries.push(entry);
+	}
+
+	return entries.flatMap((entry) => {
 		const message = entryToCopyableMessage(entry);
 		return message ? [message] : [];
 	});
 }
 
+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" }
@@ -181,58 +219,6 @@ export function getMostRecentUserMessage(ctx: { sessionManager: { getBranch(): u
 	return sawUserMessage ? { kind: "no-text" } : { kind: "no-user-message" };
 }
 
-type ClipboardCommand = {
-	name: string;
-	args: string[];
-	enabled: () => boolean;
-};
-
-const clipboardCommands: ClipboardCommand[] = [
-	{ name: "pbcopy", args: [], enabled: () => process.platform === "darwin" },
-	{ name: "termux-clipboard-set", args: [], enabled: () => Boolean(process.env.TERMUX_VERSION) },
-	{ name: "wl-copy", args: [], enabled: () => true },
-	{ name: "xclip", args: ["-selection", "clipboard"], enabled: () => true },
-	{ name: "xsel", args: ["--clipboard", "--input"], enabled: () => true },
-];
-
-const CLIPBOARD_TIMEOUT_MS = 3000;
-const commandExistsCache = new Map<string, boolean>();
-
-function commandExists(command: string): boolean {
-	const cached = commandExistsCache.get(command);
-	if (cached !== undefined) return cached;
-
-	const result = spawnSync("sh", ["-c", "command -v \"$1\" >/dev/null 2>&1", "sh", command], {
-		stdio: "ignore",
-		timeout: CLIPBOARD_TIMEOUT_MS,
-		killSignal: "SIGKILL",
-	});
-	const exists = result.status === 0;
-	commandExistsCache.set(command, exists);
-	return exists;
-}
-
-function copyWith(command: string, args: string[], text: string): boolean {
-	const result = spawnSync(command, args, { input: text, encoding: "utf8", timeout: CLIPBOARD_TIMEOUT_MS, killSignal: "SIGKILL" });
-	return !result.error && result.status === 0;
-}
-
-function copyToClipboard(text: string): string | undefined {
-	const failedCommands: string[] = [];
-
-	for (const command of clipboardCommands) {
-		if (!command.enabled() || !commandExists(command.name)) continue;
-		if (copyWith(command.name, command.args, text)) return undefined;
-		failedCommands.push(command.name);
-	}
-
-	if (failedCommands.length > 0) {
-		return `Clipboard command${failedCommands.length === 1 ? "" : "s"} failed (${failedCommands.join(", ")})`;
-	}
-
-	return "No clipboard command found (tried pbcopy, termux-clipboard-set, wl-copy, xclip, xsel)";
-}
-
 function isToolMessage(message: CopyableMessage): boolean {
 	return message.role === "toolResult" || message.role === "bashExecution";
 }
@@ -353,7 +339,7 @@ function renderMessageLine(
 
 function renderPeekLines(message: CopyableMessage, width: number, theme: CopyMessageTheme, format: CopyFormat): string[] {
 	const contentWidth = Math.max(1, width - 2);
-	const text = formatMessageForCopy(message, format);
+	const text = safeDisplayText(formatMessageForCopy(message, format));
 	const wrapped = wrapTextWithAnsi(styleRoleText(theme, message.role, text, false), contentWidth);
 	const shown = wrapped.slice(0, MAX_PEEK_LINES);
 	const remaining = wrapped.length - shown.length;
@@ -440,8 +426,11 @@ export class CopyMessagePickerState {
 	format: CopyFormat;
 	peek = false;
 	private searchAnchorId: string | undefined;
+	private readonly messages: CopyableMessage[];
+	private firstVisibleIndex = 0;
 
-	constructor(private readonly messages: CopyableMessage[], initialFormat: CopyFormat = "raw") {
+	constructor(messages: CopyableMessage[], initialFormat: CopyFormat = "raw") {
+		this.messages = messages;
 		this.format = initialFormat;
 		this.visibleMessages = filteredMessages(messages, this.visibility, this.search);
 		this.selectedIndex = Math.max(0, this.visibleMessages.length - 1);
@@ -460,6 +449,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");
@@ -496,6 +486,13 @@ export class CopyMessagePickerState {
 	}
 
 	handleInput(data: string, keybindings?: PickerKeybindings): PickerInputResult {
+		// Pi delivers each paste as one input wrapped in bracketed-paste markers.
+		if (data.startsWith("\x1b[200~") && data.endsWith("\x1b[201~")) {
+			const text = data.slice(6, -6).replace(/\s+/gu, " ");
+			if (!isPrintableSearchInput(text)) return "none";
+			this.setSearch(this.search + text);
+			return "render";
+		}
 		if (keybindings?.matches(data, "tui.select.up")) {
 			this.move(-1);
 			return "render";
@@ -545,7 +542,7 @@ export class CopyMessagePickerState {
 			return "render";
 		}
 		if (matchesKey(data, "backspace") || data === "\x7f") {
-			this.setSearch(this.search.slice(0, -1));
+			this.setSearch(splitGraphemes(this.search).slice(0, -1).join(""));
 			return "render";
 		}
 		const printable = decodeKittyPrintable(data) ?? data;
@@ -602,6 +599,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);
@@ -678,28 +689,33 @@ 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);
+		const abort = () => done(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();
+				done(selected && text !== undefined ? { message: selected, text } : null);
+			} else if (result === "cancel") done(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),
 		};
 	});
 }
@@ -708,75 +724,132 @@ function copyNotificationText(selected: CopyableMessage): string {
 	return `Copied ${roleLabel(selected.role)} message: “${compactPreview(selected.text, 48)}”`;
 }
 
-function copySelectedMessage(ctx: Pick<ExtensionCommandContext, "ui">, selected: CopyableMessage, text = selected.text) {
-	const error = copyToClipboard(text);
-	if (error) {
-		ctx.ui.notify(error, "error");
-		return;
-	}
+const runClipboardReader = promisify(execFile);
 
-	ctx.ui.notify(copyNotificationText(selected), "info");
+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);
+		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) {
+		notify(error instanceof Error ? error.message : "Failed to copy to clipboard", "error");
+	}
 }
 
-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;
 	}
-
-	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) 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;
 				}
-				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;
-
-			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) => {
-			copyMostRecentUserMessage(ctx, parseCopyArgs(args).format);
+			await copyMostRecentUserMessage(ctx, notifications(ctx), parseCopyArgs(args).format);
 		},
 	});
 }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "pi-copy-message",
-  "version": "2.1.0",
+  "version": "4.0.0",
   "description": "Pi extension with a searchable TUI picker for copying raw session messages",
   "author": "Mitch Fultz (https://github.com/fitchmultz)",
   "license": "MIT",
   "type": "module",
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=24.15.0"
   },
   "keywords": [
     "pi-package",
@@ -32,10 +32,11 @@
   },
   "homepage": "https://github.com/fitchmultz/pi-copy-message#readme",
   "scripts": {
-    "test": "tsx tests/copy-message.test.ts",
+    "test": "node --test tests/*.test.ts",
     "typecheck": "tsc --noEmit",
-    "check": "npm test && npm run typecheck",
-    "prepublishOnly": "npm run check && npm pack --dry-run"
+    "check": "npm test && npm run typecheck && npm pack --dry-run",
+    "check:compat": "npm run check",
+    "prepublishOnly": "npm run check"
   },
   "files": [
     "extensions",
@@ -44,18 +45,17 @@
     "LICENSE"
   ],
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.84.0",
-    "@earendil-works/pi-tui": "0.84.0",
-    "@types/node": "^25.9.1",
-    "tsx": "^4.22.4",
-    "typescript": "^6.0.3"
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
+    "@types/node": "24.19.0",
+    "typescript": "7.0.2"
   },
   "pi": {
     "extensions": [
       "./extensions"
     ]
   },
-  "packageManager": "npm@11.16.0",
+  "packageManager": "npm@12.2.0",
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*"