@herbertgao/pi-extensions 2026.8.14 → 2026.9.0

package/node_modules/@narumitw/pi-btw/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-btw",
-	"version": "0.55.4",
+	"version": "0.57.0",
 	"description": "Pi extension that adds a /btw side-question command.",
 	"type": "module",
 	"license": "MIT",
@@ -23,9 +23,6 @@
 			"./dist/index.ts"
 		]
 	},
-	"piExtension": {
-		"lifecycle": "stable"
-	},
 	"scripts": {
 		"build": "node scripts/build-runtime.mjs",
 		"check": "npm run build && biome check . && npm run typecheck",
@@ -34,10 +31,10 @@
 		"prepack": "npm run build"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.10",
-		"@earendil-works/pi-ai": "0.84.3",
-		"@earendil-works/pi-coding-agent": "0.84.3",
-		"@earendil-works/pi-tui": "0.84.3",
+		"@biomejs/biome": "2.5.11",
+		"@earendil-works/pi-ai": "0.85.0",
+		"@earendil-works/pi-coding-agent": "0.85.0",
+		"@earendil-works/pi-tui": "0.85.0",
 		"esbuild": "0.28.2",
 		"typescript": "7.0.2"
 	},

package/node_modules/@narumitw/pi-btw/src/btw.ts

@@ -33,6 +33,7 @@ import {
 } from "./menu.js";
 import {
 	type BtwSettings,
+	effectiveFullscreenCopyOnSelect,
 	effectiveRememberThinkingLevelChanges,
 	parseBtwModelReference,
 	readBtwSettings,
@@ -193,7 +194,7 @@ export async function loadBtwThinkingLevel(
 
 	options.warn?.(
 		sanitizeSingleLine(
-			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", and boolean rememberThinkingLevelChanges. Using current Pi thinking level.`,
+			`pi-btw settings ignored: ${settings.reason}; expected optional model "provider/model-id", omitted thinkingLevel for Same as main thread or thinkingLevel "${BTW_THINKING_LEVELS.join('" | "')}", boolean rememberThinkingLevelChanges, and boolean fullscreenCopyOnSelect. Using current Pi thinking level.`,
 		),
 	);
 	return currentThinkingLevel;
@@ -314,31 +315,35 @@ export default function btw(pi: ExtensionAPI, dependencies: BtwExtensionDependen
 			const startingTurnCount = state?.thread.turns.length ?? 0;
 
 			try {
-				await runFullscreen(ctx, (fullscreenCtx) => {
-					if (!state) {
-						const createdAt = Date.now();
-						state = {
-							id: `btw-${nextThreadNumber}`,
-							thread: createSideThread(
-								selectedConversationContext ??
-									buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
-							),
-							thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
-							createdAt,
-							updatedAt: createdAt,
-						};
-						nextThreadNumber += 1;
-					}
-					return runThread({
-						initialQuestion: question || undefined,
-						selected: resolution.selected,
-						thinkingLevel: state.thinkingLevel,
-						rememberThinkingLevelChanges:
-							!sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
-						state,
-						ctx: fullscreenCtx,
-					});
-				});
+				await runFullscreen(
+					ctx,
+					(fullscreenCtx) => {
+						if (!state) {
+							const createdAt = Date.now();
+							state = {
+								id: `btw-${nextThreadNumber}`,
+								thread: createSideThread(
+									selectedConversationContext ??
+										buildConversationContext(fullscreenCtx.sessionManager.getBranch()),
+								),
+								thinkingLevel: settings.thinkingLevel ?? pi.getThinkingLevel(),
+								createdAt,
+								updatedAt: createdAt,
+							};
+							nextThreadNumber += 1;
+						}
+						return runThread({
+							initialQuestion: question || undefined,
+							selected: resolution.selected,
+							thinkingLevel: state.thinkingLevel,
+							rememberThinkingLevelChanges:
+								!sameAsMainThinkingLevel && effectiveRememberThinkingLevelChanges(settings),
+							state,
+							ctx: fullscreenCtx,
+						});
+					},
+					{ copyOnSelect: effectiveFullscreenCopyOnSelect(settings) },
+				);
 			} finally {
 				if (state?.title && state.thread.turns.length > 0) {
 					if (state.thread.turns.length > startingTurnCount) {

package/node_modules/@narumitw/pi-btw/src/fullscreen-ui.ts

@@ -8,16 +8,18 @@ import {
 import {
 	type Component,
 	isKeyRelease,
+	isKittyProtocolActive,
 	Key,
 	matchesKey,
 	type OverlayHandle,
+	parseKey,
 	type TUI,
 	TuiAltScreen,
 	type TuiInputListener,
 	type TuiInputListenerResult,
 	truncateToWidth,
 } from "@earendil-works/pi-tui";
-import { sanitizeSingleLine } from "./text.js";
+import { formatKeyLabel, sanitizeSingleLine } from "./text.js";
 
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 type BtwCustomFactory<T> = (
@@ -30,6 +32,7 @@ type BtwCustomFactory<T> = (
 type BtwFullscreenTui = TUI & {
 	flash?: (message: string, durationMs?: number) => void;
 	setLayoutRoot(component: Component | undefined): void;
+	addInputListenerBeforeAll?(listener: TuiInputListener): () => void;
 	addInputListenerBeforeViewport?(listener: TuiInputListener): () => void;
 };
 
@@ -37,17 +40,28 @@ export interface BtwFullscreenLayoutComponent extends Component {
 	getFullscreenLayout(): Component;
 }
 
-export type BtwFullscreenTuiFactory = (parent: TUI, theme: Theme) => BtwFullscreenTui;
+export interface BtwFullscreenOptions {
+	copyOnSelect?: boolean;
+}
+
+export type BtwFullscreenTuiFactory = (
+	parent: TUI,
+	theme: Theme,
+	keybindings: KeybindingsManager,
+	options: BtwFullscreenOptions,
+) => BtwFullscreenTui;
 
 export interface BtwFullscreenDependencies {
 	createTui?: BtwFullscreenTuiFactory;
 	openUrl?: (url: string) => void;
 	copyToClipboard?: (text: string) => Promise<void>;
+	manualSelectionCopySupported?: boolean;
 }
 
 export type RunBtwFullscreen = <T>(
 	ctx: ExtensionCommandContext,
 	run: (ctx: ExtensionCommandContext) => Promise<T>,
+	options?: BtwFullscreenOptions,
 ) => Promise<T>;
 
 type FullscreenOutcome<T> = { kind: "completed"; value: T } | { kind: "failed"; error: unknown };
@@ -62,14 +76,23 @@ class FullscreenUiDisposedError extends Error {
 export async function runBtwFullscreen<T>(
 	ctx: ExtensionCommandContext,
 	run: (ctx: ExtensionCommandContext) => Promise<T>,
+	options: BtwFullscreenOptions = {},
 	dependencies: BtwFullscreenDependencies = {},
 ): Promise<T> {
 	const createTui =
 		dependencies.createTui ??
-		((parent: TUI, theme: Theme) =>
+		((
+			parent: TUI,
+			theme: Theme,
+			keybindings: KeybindingsManager,
+			fullscreenOptions: BtwFullscreenOptions,
+		) =>
 			createBtwFullscreenTui(
 				parent,
 				theme,
+				keybindings,
+				fullscreenOptions.copyOnSelect ?? true,
+				dependencies.manualSelectionCopySupported ?? hasManualSelectionCopyApi(),
 				dependencies.openUrl ?? openUrlInBrowser,
 				dependencies.copyToClipboard ?? copyToHostClipboard,
 			));
@@ -94,6 +117,7 @@ export async function runBtwFullscreen<T>(
 					done(value);
 				},
 				createTui,
+				options,
 			);
 			return host;
 		},
@@ -114,6 +138,7 @@ export async function runBtwFullscreen<T>(
 }
 
 type BtwInputListeners = {
+	beforeAll: Set<TuiInputListener>;
 	beforeViewport: Set<TuiInputListener>;
 	regular: Set<TuiInputListener>;
 };
@@ -122,7 +147,7 @@ const btwInputListeners = new WeakMap<BtwTuiAltScreen, BtwInputListeners>();
 
 function dispatchBtwInput(listeners: BtwInputListeners, data: string): TuiInputListenerResult {
 	let current = data;
-	for (const group of [listeners.beforeViewport, listeners.regular]) {
+	for (const group of [listeners.beforeAll, listeners.beforeViewport, listeners.regular]) {
 		for (const listener of group) {
 			const result = listener(current);
 			if (result?.consume) return result;
@@ -133,10 +158,15 @@ function dispatchBtwInput(listeners: BtwInputListeners, data: string): TuiInputL
 }
 
 class BtwTuiAltScreen extends TuiAltScreen {
+	hasFocusedOverlay(): boolean {
+		return this.isOverlayFocused();
+	}
+
 	override addInputListener(listener: TuiInputListener): () => void {
 		let listeners = btwInputListeners.get(this);
 		if (!listeners) {
 			const registeredListeners: BtwInputListeners = {
+				beforeAll: new Set(),
 				beforeViewport: new Set(),
 				regular: new Set(),
 			};
@@ -148,6 +178,13 @@ class BtwTuiAltScreen extends TuiAltScreen {
 		return () => listeners.regular.delete(listener);
 	}
 
+	addInputListenerBeforeAll(listener: TuiInputListener): () => void {
+		const listeners = btwInputListeners.get(this);
+		if (!listeners) return super.addInputListener(listener);
+		listeners.beforeAll.add(listener);
+		return () => listeners.beforeAll.delete(listener);
+	}
+
 	addInputListenerBeforeViewport(listener: TuiInputListener): () => void {
 		const listeners = btwInputListeners.get(this);
 		if (!listeners) return super.addInputListener(listener);
@@ -161,33 +198,208 @@ class BtwTuiAltScreen extends TuiAltScreen {
 			super.removeInputListener(listener);
 			return;
 		}
+		listeners.beforeAll.delete(listener);
 		listeners.beforeViewport.delete(listener);
 		listeners.regular.delete(listener);
 	}
 }
 
+const BRACKETED_PASTE_START = "\u001b[200~";
+const BRACKETED_PASTE_END = "\u001b[201~";
+
+// TuiAltScreen evaluates these actions before bottom, so shared keys cannot jump to latest.
+const ALT_SCREEN_ACTIONS_BEFORE_BOTTOM = [
+	"tui.altScreen.search",
+	"tui.altScreen.searchNext",
+	"tui.altScreen.searchPrevious",
+	"tui.altScreen.searchClose",
+	"tui.altScreen.pageUp",
+	"tui.altScreen.pageDown",
+	"tui.altScreen.halfPageUp",
+	"tui.altScreen.halfPageDown",
+	"tui.altScreen.lineUp",
+	"tui.altScreen.lineDown",
+	"tui.altScreen.previousPrompt",
+	"tui.altScreen.nextPrompt",
+	"tui.altScreen.top",
+] as const;
+const KEY_MODIFIER_ORDER = ["shift", "ctrl", "alt", "super"] as const;
+const MATCHABLE_SPECIAL_KEYS = new Set([
+	"space",
+	"tab",
+	"enter",
+	"backspace",
+	"delete",
+	"insert",
+	"home",
+	"end",
+	"pageup",
+	"pagedown",
+	"up",
+	"down",
+	"left",
+	"right",
+]);
+const MATCHABLE_SYMBOL_KEYS = new Set("`-=[]\\;',./!@#$%^&*()_+|~{}:<>?");
+
+function normalizedKeyId(key: string): string {
+	const parts = key.toLowerCase().split("+");
+	const base = parts.at(-1);
+	if (!base) return "";
+	const normalizedBase = base === "esc" ? "escape" : base === "return" ? "enter" : base;
+	const modifiers = KEY_MODIFIER_ORDER.filter((modifier) => parts.includes(modifier));
+	return [...modifiers, normalizedBase].join("+");
+}
+
+function formatEffectiveKeyLabel(key: string): string {
+	const parts = key.split("+");
+	const base = parts.at(-1);
+	if (base === "pageup") parts[parts.length - 1] = "pageUp";
+	if (base === "pagedown") parts[parts.length - 1] = "pageDown";
+	return formatKeyLabel(parts.join("+"));
+}
+
+function canMatchKeyInput(key: string): boolean {
+	const parts = key.split("+");
+	const base = parts.at(-1) ?? "";
+	const modifiers = parts.slice(0, -1);
+	if (base === "escape") return modifiers.length === 0;
+	if (base === "clear") {
+		return (
+			modifiers.length === 0 ||
+			(modifiers.length === 1 && (modifiers[0] === "shift" || modifiers[0] === "ctrl"))
+		);
+	}
+	if (/^f(?:[1-9]|1[0-2])$/u.test(base)) return modifiers.length === 0;
+	return (
+		MATCHABLE_SPECIAL_KEYS.has(base) ||
+		(base.length === 1 && (/^[a-z0-9]$/u.test(base) || MATCHABLE_SYMBOL_KEYS.has(base)))
+	);
+}
+
+function rawCtrlInput(base: string): string | undefined {
+	if (base.length !== 1) return undefined;
+	const rawBase = base === "-" ? "_" : base;
+	if (!"abcdefghijklmnopqrstuvwxyz[\\]_".includes(rawBase)) return undefined;
+	return String.fromCharCode(rawBase.charCodeAt(0) & 0x1f);
+}
+
+function legacyRawInput(key: string): string | undefined {
+	const parts = key.split("+");
+	const base = parts.at(-1) ?? "";
+	if (parts.length === 2 && parts[0] === "ctrl") return rawCtrlInput(base);
+	if (isKittyProtocolActive()) return undefined;
+	if (parts.length === 2 && parts[0] === "alt" && base.length === 1) return `\u001b${base}`;
+	if (parts.length === 3 && parts[0] === "ctrl" && parts[1] === "alt") {
+		const input = rawCtrlInput(base);
+		return input ? `\u001b${input}` : undefined;
+	}
+	return undefined;
+}
+
+// Mirror matchesKey(), using parseKey() to canonicalize IDs that share legacy raw input.
+function keyInputIdentity(key: string): string {
+	const identity = normalizedKeyId(key);
+	const input = legacyRawInput(identity);
+	return input ? normalizedKeyId(parseKey(input) ?? identity) : identity;
+}
+
+function hasManualSelectionCopyApi(): boolean {
+	return (
+		typeof TuiAltScreen.prototype.hasActiveSelection === "function" &&
+		typeof TuiAltScreen.prototype.copyActiveSelectionToClipboard === "function"
+	);
+}
+
 function createBtwFullscreenTui(
 	parent: TUI,
 	theme: Theme,
+	keybindings: KeybindingsManager,
+	copyOnSelect: boolean,
+	manualSelectionCopySupported: boolean,
 	openUrl: (url: string) => void,
 	copyToClipboard: (text: string) => Promise<void>,
 ): BtwFullscreenTui {
+	if (!copyOnSelect && !manualSelectionCopySupported) {
+		throw new Error(
+			"Manual fullscreen selection copying is unavailable in this Pi version; update Pi or enable automatic selection copying.",
+		);
+	}
 	const styleSearchMatch = (text: string) =>
 		theme.bg("searchMatchBg", theme.fg("searchMatchText", text));
-	return new BtwTuiAltScreen(parent.terminal, parent.getShowHardwareCursor(), undefined, {
-		mouse: true,
-		searchMatchStyle: (text) => theme.underline(styleSearchMatch(text)),
-		searchCurrentMatchStyle: (text) => theme.bold(theme.inverse(styleSearchMatch(text))),
-		openUrl,
-		copySelection: async (text) => {
-			try {
-				await copyToClipboard(text);
-				return true;
-			} catch {
-				return false;
-			}
+	const fullscreen = new BtwTuiAltScreen(
+		parent.terminal,
+		parent.getShowHardwareCursor(),
+		undefined,
+		{
+			mouse: true,
+			copyOnSelect,
+			searchMatchStyle: (text) => theme.underline(styleSearchMatch(text)),
+			scrollToEndIndicator: () => {
+				const unavailableKeyIdentities = new Set<string>([keyInputIdentity(Key.ctrl("c"))]);
+				for (const action of ALT_SCREEN_ACTIONS_BEFORE_BOTTOM) {
+					for (const actionKey of keybindings.getKeys(action)) {
+						unavailableKeyIdentities.add(keyInputIdentity(String(actionKey)));
+					}
+				}
+				if (!copyOnSelect) {
+					for (const copyKey of keybindings.getKeys("app.message.copy")) {
+						unavailableKeyIdentities.add(keyInputIdentity(String(copyKey)));
+					}
+				}
+				const key = keybindings
+					.getKeys("tui.altScreen.bottom")
+					.map((candidate) => keyInputIdentity(String(candidate)))
+					.find(
+						(identity) =>
+							identity &&
+							canMatchKeyInput(identity) &&
+							!unavailableKeyIdentities.has(identity) &&
+							formatEffectiveKeyLabel(identity),
+					);
+				const label = theme.fg("text", " ↓ Jump to latest message");
+				const shortcut = key ? theme.fg("muted", ` · ${formatEffectiveKeyLabel(key)}`) : "";
+				return theme.bg("selectedBg", `${label}${shortcut} `);
+			},
+			searchCurrentMatchStyle: (text) => theme.bold(theme.inverse(styleSearchMatch(text))),
+			openUrl,
+			copySelection: async (text) => {
+				try {
+					await copyToClipboard(text);
+					return true;
+				} catch {
+					return false;
+				}
+			},
 		},
-	});
+	);
+	if (!copyOnSelect) {
+		let isInBracketedPaste = false;
+		fullscreen.addInputListenerBeforeViewport((data) => {
+			const wasInBracketedPaste = isInBracketedPaste;
+			const startsBracketedPaste = data.includes(BRACKETED_PASTE_START);
+			if (startsBracketedPaste) isInBracketedPaste = true;
+			if (isInBracketedPaste && data.includes(BRACKETED_PASTE_END)) {
+				isInBracketedPaste = false;
+			}
+			if (
+				wasInBracketedPaste ||
+				startsBracketedPaste ||
+				fullscreen.hasFocusedOverlay() ||
+				isKeyRelease(data) ||
+				!keybindings.matches(data, "app.message.copy")
+			) {
+				return undefined;
+			}
+			if (!fullscreen.hasActiveSelection()) {
+				fullscreen.flash("No selection to copy");
+				return { consume: true };
+			}
+			void fullscreen.copyActiveSelectionToClipboard().catch(() => fullscreen.flash("Copy failed"));
+			return { consume: true };
+		});
+	}
+	return fullscreen;
 }
 
 // Pi does not export its browser opener, so mirror its shell-free launcher for this isolated TUI.
@@ -213,9 +425,11 @@ class BtwFullscreenHost<T> implements Component {
 	private disposed = false;
 	private finished = false;
 	private parentStopped = false;
-	private parentRestarted = false;
+	private parentRestoreAttempted = false;
 	private fullscreenCreated = false;
 	private fullscreenStopped = false;
+	private parentRestoreQueued = false;
+	private parentRestorePromise: Promise<void> | undefined;
 	private cleanupError: unknown;
 
 	constructor(
@@ -226,6 +440,7 @@ class BtwFullscreenHost<T> implements Component {
 		private readonly run: (ctx: ExtensionCommandContext) => Promise<T>,
 		private readonly done: (outcome: FullscreenOutcome<T>) => void,
 		private readonly createTui: BtwFullscreenTuiFactory,
+		private readonly options: BtwFullscreenOptions,
 	) {
 		queueMicrotask(() => void this.start());
 	}
@@ -255,11 +470,12 @@ class BtwFullscreenHost<T> implements Component {
 			this.parent.stop({ preserveScreen: true });
 			this.parentStopped = true;
 			if (this.disposed) throw new FullscreenUiDisposedError();
-			this.fullscreen = this.createTui(this.parent, this.theme);
+			this.fullscreen = this.createTui(this.parent, this.theme, this.keybindings, this.options);
 			this.fullscreenCreated = true;
 			this.fullscreen.start();
 			// Waiting for the custom promise would leave follow-up keys bound to the side TUI.
 			const addHardCancelListener =
+				this.fullscreen.addInputListenerBeforeAll?.bind(this.fullscreen) ??
 				this.fullscreen.addInputListenerBeforeViewport?.bind(this.fullscreen) ??
 				this.fullscreen.addInputListener.bind(this.fullscreen);
 			this.removeHardCancelListener = addHardCancelListener((data) => {
@@ -267,7 +483,11 @@ class BtwFullscreenHost<T> implements Component {
 				try {
 					this.hardCancelActiveCustom?.();
 				} finally {
-					this.restoreParent();
+					// ProcessTerminal.stop() destroys its active input buffer. Keep cancellation
+					// synchronous, then drain input before the physical Windows terminal handoff.
+					// Pi has no public input injection, so do not replay bytes already coalesced
+					// behind the hard-cancel key.
+					this.queueParentRestore();
 				}
 				return { consume: true };
 			});
@@ -281,15 +501,35 @@ class BtwFullscreenHost<T> implements Component {
 		} catch (error) {
 			this.cleanupError ??= error;
 		}
-		this.restoreParent();
+		if (this.parentRestorePromise) await this.parentRestorePromise;
+		else this.restoreParent();
 		if (this.cleanupError !== undefined) outcome = { kind: "failed", error: this.cleanupError };
 		this.finished = true;
 		this.done(outcome);
 	}
 
+	private queueParentRestore(): void {
+		if (this.parentRestoreQueued || this.parentRestoreAttempted) return;
+		this.parentRestoreQueued = true;
+		this.parentRestorePromise = Promise.resolve().then(async () => {
+			try {
+				await this.fullscreen?.terminal.drainInput?.();
+			} catch (error) {
+				this.cleanupError ??= error;
+			}
+			this.parentRestoreQueued = false;
+			this.restoreParent();
+		});
+	}
+
 	private restoreParent(): void {
-		this.removeHardCancelListener?.();
+		const removeHardCancelListener = this.removeHardCancelListener;
 		this.removeHardCancelListener = undefined;
+		try {
+			removeHardCancelListener?.();
+		} catch (error) {
+			this.cleanupError ??= error;
+		}
 		if (this.fullscreenCreated && !this.fullscreenStopped) {
 			this.fullscreenStopped = true;
 			try {
@@ -298,7 +538,7 @@ class BtwFullscreenHost<T> implements Component {
 				this.cleanupError ??= error;
 			}
 		}
-		if (!this.parentStopped || this.parentRestarted) return;
+		if (!this.parentStopped || this.parentRestoreAttempted) return;
 		const parentOverlay = this.parentOverlay;
 		this.parentOverlay = undefined;
 		try {
@@ -307,8 +547,8 @@ class BtwFullscreenHost<T> implements Component {
 			this.cleanupError ??= error;
 		}
 		try {
+			this.parentRestoreAttempted = true;
 			this.parent.start();
-			this.parentRestarted = true;
 			this.parent.renderNow(false);
 		} catch (error) {
 			this.cleanupError ??= error;

package/node_modules/@narumitw/pi-btw/src/menu.ts

@@ -9,6 +9,7 @@ import {
 	type BtwSettings,
 	type BtwSettingsPatch,
 	btwSettingsPath,
+	effectiveFullscreenCopyOnSelect,
 	effectiveRememberThinkingLevelChanges,
 	readBtwSettings,
 	type UpdateBtwSettingsOptions,
@@ -48,7 +49,13 @@ export type BtwCommandMenuResult =
 	| { kind: "resume"; threadId: string };
 
 type BtwMenuScreen = "main" | "resume" | "settings" | "invalid";
-type BtwMenuAction = "start" | "start-tree" | "resume" | "set-thinking" | "set-remember";
+type BtwMenuAction =
+	| "start"
+	| "start-tree"
+	| "resume"
+	| "set-thinking"
+	| "set-remember"
+	| "set-fullscreen-copy";
 const SAME_AS_MAIN_THREAD = "Same as main thread";
 type BtwCustomOptions = Parameters<ExtensionCommandContext["ui"]["custom"]>[1];
 
@@ -111,6 +118,7 @@ export async function showBtwCommandMenu(
 				title: "Pi BTW",
 				lines: [
 					`Thinking: ${displayThinkingSummary(state.settings)} · Remember changes: ${displayRememberSummary(state.settings)}`,
+					`Copy on select: ${effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off"}`,
 				],
 				items: [
 					{
@@ -138,7 +146,7 @@ export async function showBtwCommandMenu(
 					{
 						id: "settings",
 						label: "Settings",
-						description: "Choose pi-btw thinking level and fixed-level shortcut memory",
+						description: "Choose thinking, shortcut memory, and selection copying",
 						to: state.kind === "invalid" ? "invalid" : "settings",
 					},
 				],
@@ -178,6 +186,15 @@ export async function showBtwCommandMenu(
 						values: ["On", "Off"],
 						action: "set-remember",
 					},
+					{
+						id: "fullscreenCopyOnSelect",
+						label: "Copy selection automatically",
+						description:
+							"Copy mouse selections immediately instead of with the configured copy key.",
+						currentValue: effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off",
+						values: ["On", "Off"],
+						action: "set-fullscreen-copy",
+					},
 				],
 			}),
 			invalid: ({ state }) => ({
@@ -240,6 +257,21 @@ export async function showBtwCommandMenu(
 					return { kind: "rejected" };
 				}
 			},
+			"set-fullscreen-copy": async ({ value, signal }) => {
+				if (value !== "On" && value !== "Off") return { kind: "rejected" };
+				try {
+					await updateSettings(
+						{ fullscreenCopyOnSelect: value === "On" },
+						{ settingsPath, signal },
+					);
+					if (signal.aborted) return { kind: "rejected" };
+					notifySafely(ctx, `Copy selection automatically: ${value}.`, "info");
+					return { kind: "stay" };
+				} catch (error) {
+					if (!signal.aborted) notifySaveFailure(ctx, error);
+					return { kind: "rejected" };
+				}
+			},
 		},
 	});