@oh-my-pi/pi-coding-agent 15.7.5 → 15.8.0

package/src/lsp/diagnostics-ledger.ts

@@ -0,0 +1,51 @@
+import type { FileDiagnosticsResult } from "./index";
+import { summarizeDiagnosticMessages } from "./utils";
+
+const DIAGNOSTIC_LOCATION_PREFIX_RE = /^.*?:\d+:\d+\s+/;
+
+export function diagnosticIdentity(message: string): string {
+	return message.replace(DIAGNOSTIC_LOCATION_PREFIX_RE, "");
+}
+
+export class DiagnosticsLedger {
+	readonly #seen = new Map<string, Set<string>>();
+
+	reduce(absPath: string, result: FileDiagnosticsResult): FileDiagnosticsResult {
+		const previous = this.#seen.get(absPath);
+		const currentIdentities = new Set<string>();
+		const fresh: string[] = [];
+
+		for (const message of result.messages) {
+			const identity = diagnosticIdentity(message);
+			currentIdentities.add(identity);
+			if (!previous?.has(identity)) {
+				fresh.push(message);
+			}
+		}
+
+		if (currentIdentities.size === 0) {
+			this.#seen.delete(absPath);
+		} else {
+			this.#seen.set(absPath, currentIdentities);
+		}
+
+		if (fresh.length === result.messages.length) {
+			return result;
+		}
+
+		return {
+			...result,
+			messages: fresh,
+			...summarizeDiagnosticMessages(fresh),
+		};
+	}
+}
+
+export interface DiagnosticsLedgerOwner {
+	diagnosticsLedger?: DiagnosticsLedger;
+}
+
+export function getDiagnosticsLedger(owner: DiagnosticsLedgerOwner): DiagnosticsLedger {
+	owner.diagnosticsLedger ??= new DiagnosticsLedger();
+	return owner.diagnosticsLedger;
+}

package/src/lsp/index.ts

@@ -79,6 +79,7 @@ import {
 	resolveDiagnosticTargets,
 	resolveSymbolColumn,
 	sortDiagnostics,
+	summarizeDiagnosticMessages,
 	symbolKindToIcon,
 	uriToFile,
 } from "./utils";
@@ -816,12 +817,15 @@ export interface WritethroughOptions {
 	onDeferredDiagnostics?: (diagnostics: FileDiagnosticsResult) => void;
 	/** Signal to cancel a pending deferred diagnostics fetch. */
 	deferredSignal?: AbortSignal;
+	/** Transform diagnostics before surfacing them after a successful fetch. */
+	transformDiagnostics?: (absPath: string, result: FileDiagnosticsResult) => FileDiagnosticsResult;
 }
 
 /** Internal resolved form of {@link WritethroughOptions} that the writethrough machinery operates on. */
 type ResolvedWritethroughOptions = {
 	enableFormat: boolean;
 	enableDiagnostics: boolean;
+	transformDiagnostics?: (absPath: string, result: FileDiagnosticsResult) => FileDiagnosticsResult;
 };
 
 /** Per-file deferred LSP diagnostics wiring for {@link WritethroughCallback}. */
@@ -881,6 +885,7 @@ function getOrCreateWritethroughBatch(id: string, options: ResolvedWritethroughO
 	if (existing) {
 		existing.options.enableFormat ||= options.enableFormat;
 		existing.options.enableDiagnostics ||= options.enableDiagnostics;
+		existing.options.transformDiagnostics ??= options.transformDiagnostics;
 		return existing;
 	}
 	const batch: LspWritethroughBatchState = {
@@ -904,27 +909,6 @@ export async function flushLspWritethroughBatch(
 	return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal);
 }
 
-function summarizeDiagnosticMessages(messages: string[]): { summary: string; errored: boolean } {
-	const counts = { error: 0, warning: 0, info: 0, hint: 0 };
-	for (const message of messages) {
-		const match = message.match(/\[(error|warning|info|hint)\]/i);
-		if (!match) continue;
-		const key = match[1].toLowerCase() as keyof typeof counts;
-		counts[key] += 1;
-	}
-
-	const parts: string[] = [];
-	if (counts.error > 0) parts.push(`${counts.error} error(s)`);
-	if (counts.warning > 0) parts.push(`${counts.warning} warning(s)`);
-	if (counts.info > 0) parts.push(`${counts.info} info(s)`);
-	if (counts.hint > 0) parts.push(`${counts.hint} hint(s)`);
-
-	return {
-		summary: parts.length > 0 ? parts.join(", ") : "no issues",
-		errored: counts.error > 0,
-	};
-}
-
 function mergeDiagnostics(
 	results: Array<FileDiagnosticsResult | undefined>,
 	options: ResolvedWritethroughOptions,
@@ -1083,12 +1067,14 @@ async function runLspWritethrough(
 
 			// 6. Get diagnostics from all servers (wait for fresh results)
 			if (enableDiagnostics) {
-				diagnostics = await getDiagnosticsForFile(dst, cwd, servers, {
+				const fetched = await getDiagnosticsForFile(dst, cwd, servers, {
 					signal: operationSignal,
 					minVersions,
 					expectedDocumentVersions,
 					allowUnversionedLspDiagnostics: false,
 				});
+				diagnostics =
+					fetched && options.transformDiagnostics ? options.transformDiagnostics(dst, fetched) : fetched;
 			}
 		});
 	} catch {
@@ -1155,6 +1141,7 @@ export function createLspWritethrough(cwd: string, options?: WritethroughOptions
 	const resolvedOptions: ResolvedWritethroughOptions = {
 		enableFormat: options?.enableFormat ?? false,
 		enableDiagnostics: options?.enableDiagnostics ?? false,
+		transformDiagnostics: options?.transformDiagnostics,
 	};
 	if (!resolvedOptions.enableFormat && !resolvedOptions.enableDiagnostics) {
 		return writethroughNoop;

package/src/lsp/utils.ts

@@ -221,6 +221,27 @@ export function formatDiagnosticsSummary(diagnostics: Diagnostic[]): string {
 	return parts.length > 0 ? parts.join(", ") : "no issues";
 }
 
+export function summarizeDiagnosticMessages(messages: string[]): { summary: string; errored: boolean } {
+	const counts = { error: 0, warning: 0, info: 0, hint: 0 };
+	for (const message of messages) {
+		const match = message.match(/\[(error|warning|info|hint)\]/i);
+		if (!match) continue;
+		const key = match[1].toLowerCase() as keyof typeof counts;
+		counts[key] += 1;
+	}
+
+	const parts: string[] = [];
+	if (counts.error > 0) parts.push(`${counts.error} error(s)`);
+	if (counts.warning > 0) parts.push(`${counts.warning} warning(s)`);
+	if (counts.info > 0) parts.push(`${counts.info} info(s)`);
+	if (counts.hint > 0) parts.push(`${counts.hint} hint(s)`);
+
+	return {
+		summary: parts.length > 0 ? parts.join(", ") : "no issues",
+		errored: counts.error > 0,
+	};
+}
+
 // =============================================================================
 // Location Formatting
 // =============================================================================

package/src/main.ts

@@ -21,6 +21,7 @@ import {
 	VERSION,
 } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { reset as resetCapabilities } from "./capability";
 import type { Args } from "./cli/args";
 import { applyExtensionFlags, type ExtensionFlagSink } from "./cli/extension-flags";
 import { processFileArguments } from "./cli/file-processor";
@@ -91,15 +92,11 @@ async function checkForNewVersion(currentVersion: string): Promise<string | unde
 	}
 }
 
-const RPC_DEFAULTED_SETTING_PATHS: SettingPath[] = [
+const HOST_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"todo.enabled",
 	"todo.reminders",
 	"todo.reminders.max",
 	"todo.eager",
-	"async.enabled",
-	"async.maxJobs",
-	"bash.autoBackground.enabled",
-	"bash.autoBackground.thresholdMs",
 	"task.isolation.mode",
 	"task.isolation.merge",
 	"task.isolation.commits",
@@ -109,18 +106,34 @@ const RPC_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"task.maxRecursionDepth",
 	"task.disabledAgents",
 	"task.agentModelOverrides",
-	// Memory subsystems are off-by-default for RPC hosts; embedders that want
+	// Memory subsystems are off-by-default for RPC/ACP hosts; embedders that want
 	// memory should opt in explicitly through their own settings layer.
 	"memory.backend",
 	"memories.enabled",
 ];
 
-function applyRpcDefaultSettingOverrides(targetSettings: Settings = settings): void {
-	for (const settingPath of RPC_DEFAULTED_SETTING_PATHS) {
+const RPC_BACKGROUND_DEFAULTED_SETTING_PATHS: SettingPath[] = [
+	"async.enabled",
+	"async.maxJobs",
+	"bash.autoBackground.enabled",
+	"bash.autoBackground.thresholdMs",
+];
+
+function applyDefaultSettingOverrides(settingPaths: SettingPath[], targetSettings: Settings): void {
+	for (const settingPath of settingPaths) {
 		targetSettings.override(settingPath, getDefault(settingPath));
 	}
 }
 
+function applyRpcDefaultSettingOverrides(targetSettings: Settings = settings): void {
+	applyDefaultSettingOverrides(HOST_DEFAULTED_SETTING_PATHS, targetSettings);
+	applyDefaultSettingOverrides(RPC_BACKGROUND_DEFAULTED_SETTING_PATHS, targetSettings);
+}
+
+function applyAcpDefaultSettingOverrides(targetSettings: Settings = settings): void {
+	applyDefaultSettingOverrides(HOST_DEFAULTED_SETTING_PATHS, targetSettings);
+}
+
 async function readPipedInput(): Promise<string | undefined> {
 	if (process.stdin.isTTY !== false) return undefined;
 	try {
@@ -312,15 +325,19 @@ async function runInteractiveMode(
 	}
 }
 
-async function promptForkSession(session: SessionInfo): Promise<boolean> {
+type ForkSessionPromptResult = "accepted" | "declined" | "unavailable";
+
+type ForkSessionPrompt = (session: SessionInfo) => Promise<ForkSessionPromptResult>;
+
+async function promptForkSession(session: SessionInfo): Promise<ForkSessionPromptResult> {
 	if (!process.stdin.isTTY) {
-		return false;
+		return "unavailable";
 	}
 	const message = `Session found in different project: ${session.cwd}. Fork into current directory? [y/N] `;
 	const rl = createInterface({ input: process.stdin, output: process.stdout });
 	try {
 		const answer = (await rl.question(message)).trim().toLowerCase();
-		return answer === "y" || answer === "yes";
+		return answer === "y" || answer === "yes" ? "accepted" : "declined";
 	} finally {
 		rl.close();
 	}
@@ -366,10 +383,12 @@ async function flushChangelogVersion(): Promise<void> {
 	}
 }
 
-async function createSessionManager(
+/** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
+export async function createSessionManager(
 	parsed: Args,
 	cwd: string,
 	activeSettings: Settings = settings,
+	askToForkSession: ForkSessionPrompt = promptForkSession,
 ): Promise<SessionManager | undefined> {
 	if (parsed.fork) {
 		if (parsed.noSession) {
@@ -402,9 +421,17 @@ async function createSessionManager(
 			const normalizedCwd = normalizePathForComparison(cwd);
 			const normalizedMatchCwd = normalizePathForComparison(match.session.cwd || cwd);
 			if (normalizedCwd !== normalizedMatchCwd) {
-				const shouldFork = await promptForkSession(match.session);
-				if (!shouldFork) {
-					throw new Error(`Session "${sessionArg}" is in another project (${match.session.cwd}).`);
+				const forkPromptResult = await askToForkSession(match.session);
+				if (forkPromptResult === "unavailable") {
+					throw new Error(
+						`Session "${sessionArg}" is in another project (${match.session.cwd}); run interactively to fork it into the current project.`,
+					);
+				}
+				if (forkPromptResult === "declined") {
+					// User declined the cross-project fork prompt. Caller distinguishes
+					// this cancellation from the "default new session" undefined return
+					// by checking `typeof parsed.resume === "string"`.
+					return undefined;
 				}
 				return await SessionManager.forkFrom(match.session.path, cwd, parsed.sessionDir);
 			}
@@ -776,15 +803,17 @@ export async function runRootCommand(
 		}
 	}
 
-	const cwd = getProjectDir();
+	let cwd = getProjectDir();
 	const settingsInstance = deps.settings ?? (await logger.time("settings:init", Settings.init, { cwd }));
 	if (parsedArgs.approvalMode) {
 		// Runtime override (not persisted): every settings.get("tools.approvalMode") downstream
 		// sees this value. The wrapper still honours --auto-approve / --yolo on top of it.
 		settingsInstance.override("tools.approvalMode", parsedArgs.approvalMode);
 	}
-	if (parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui" || parsedArgs.mode === "acp") {
+	if (parsedArgs.mode === "rpc" || parsedArgs.mode === "rpc-ui") {
 		applyRpcDefaultSettingOverrides(settingsInstance);
+	} else if (parsedArgs.mode === "acp") {
+		applyAcpDefaultSettingOverrides(settingsInstance);
 	}
 	if (parsedArgs.noPty || parsedArgs.mode === "rpc-ui") {
 		Bun.env.PI_NO_PTY = "1";
@@ -812,6 +841,11 @@ export async function runRootCommand(
 		});
 	}
 
+	// Apply --hide-thinking CLI flag (ephemeral, not persisted)
+	if (parsedArgs.hideThinking) {
+		settingsInstance.override("hideThinkingBlock", true);
+	}
+
 	await logger.time(
 		"initTheme:final",
 		initTheme,
@@ -846,19 +880,53 @@ export async function runRootCommand(
 		settingsInstance,
 	);
 
+	// User declined the cross-project fork prompt — exit cleanly with a friendly
+	// message rather than letting the decline bubble up as an uncaught exception
+	// (see issue #1668).
+	if (typeof parsedArgs.resume === "string" && !sessionManager) {
+		process.stdout.write(`${chalk.dim("Resume cancelled: session is in another project.")}\n`);
+		return;
+	}
+
 	// Handle --resume (no value): show session picker
 	if (parsedArgs.resume === true && !parsedArgs.fork) {
-		const sessions = await logger.time("SessionManager.list", SessionManager.list, cwd, parsedArgs.sessionDir);
-		if (sessions.length === 0) {
-			process.stdout.write(`${chalk.dim("No sessions found")}\n`);
-			return;
+		const folderSessions = await logger.time("SessionManager.list", SessionManager.list, cwd, parsedArgs.sessionDir);
+		let preloadedAllSessions: SessionInfo[] | undefined;
+		let startInAllScope = false;
+		if (folderSessions.length === 0) {
+			// Nothing in the current folder — fall back to a global scan so the
+			// picker can still open in all-projects scope instead of dead-ending.
+			preloadedAllSessions = await logger.time("SessionManager.listAll", SessionManager.listAll);
+			if (preloadedAllSessions.length === 0) {
+				process.stdout.write(`${chalk.dim("No sessions found")}\n`);
+				return;
+			}
+			startInAllScope = true;
 		}
-		const selectedPath = await logger.time("selectSession", selectSession, sessions);
-		if (!selectedPath) {
+		const selected = await logger.time("selectSession", selectSession, folderSessions, {
+			allSessions: preloadedAllSessions,
+			startInAllScope,
+		});
+		if (!selected) {
 			process.stdout.write(`${chalk.dim("No session selected")}\n`);
 			return;
 		}
-		sessionManager = await SessionManager.open(selectedPath);
+		// Resuming a session from another project: switch the process into that
+		// project's directory and refresh cwd-derived caches before the session is
+		// built, so settings discovery, plugins, and capabilities all scope to it.
+		if (selected.cwd && normalizePathForComparison(selected.cwd) !== normalizePathForComparison(getProjectDir())) {
+			// Let the original (launch-cwd) plugin-root preload settle first so its
+			// late resolution can't clobber the re-warm we trigger below.
+			await pluginPreloadPromise.catch(() => {});
+			setProjectDir(selected.cwd);
+			clearPluginRootsAndCaches();
+			resetCapabilities();
+			cwd = getProjectDir();
+			// Re-scope project settings (.claude/settings.yml etc.) to the resumed
+			// project in place so the session is built with its configuration.
+			await settingsInstance.reloadForCwd(cwd);
+		}
+		sessionManager = await SessionManager.open(selected.path);
 	}
 
 	await pluginPreloadPromise;

package/src/modes/acp/acp-agent.ts

@@ -47,7 +47,11 @@ import { logger, VERSION } from "@oh-my-pi/pi-utils";
 import { disableProvider, enableProvider, reset as resetCapabilities } from "../../capability";
 import { Settings } from "../../config/settings";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
-import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../../extensibility/extensions";
+import {
+	type ExtensionUIContext,
+	type ExtensionUIDialogOptions,
+	getExtensionUISelectOptionLabel,
+} from "../../extensibility/extensions";
 import { runExtensionCompact } from "../../extensibility/extensions/compact-handler";
 import { getSessionSlashCommands } from "../../extensibility/extensions/get-commands-handler";
 import { buildSkillPromptMessage, getSkillSlashCommandName } from "../../extensibility/skills";
@@ -302,7 +306,7 @@ export function createAcpExtensionUiContext(
 				getSessionId(),
 				"select",
 				title,
-				{ type: "string", enum: options },
+				{ type: "string", enum: options.map(getExtensionUISelectOptionLabel) },
 				dialogOptions,
 			);
 			return typeof value === "string" ? value : undefined;
@@ -1981,7 +1985,7 @@ export class AcpAgent implements Agent {
 		}
 		if (servers.length === 0) {
 			record.mcpManager = undefined;
-			await record.session.refreshMCPTools([]);
+			await record.session.refreshMCPTools([], { activateAll: true });
 			return;
 		}
 
@@ -2008,7 +2012,7 @@ export class AcpAgent implements Agent {
 		}
 
 		record.mcpManager = manager;
-		await record.session.refreshMCPTools(result.tools);
+		await record.session.refreshMCPTools(result.tools, { activateAll: true });
 	}
 
 	#toMcpConfig(server: McpServer): MCPServerConfig {

package/src/modes/acp/acp-event-mapper.ts

@@ -69,6 +69,16 @@ interface CommandContainer {
 	command?: unknown;
 }
 
+interface EvalCellContainer {
+	cells?: unknown;
+}
+
+interface EvalCellLike {
+	language?: unknown;
+	title?: unknown;
+	code?: unknown;
+}
+
 interface PatternContainer {
 	pattern?: unknown;
 }
@@ -435,11 +445,43 @@ function getToolExecutionEndArgs(
 }
 
 function buildToolStartContent(toolName: string, args: unknown): ToolCallContent[] {
-	if (!isCommandToolName(toolName)) {
-		return [];
+	const text = buildToolStartText(toolName, args);
+	return text ? [textToolCallContent(text)] : [];
+}
+
+function buildToolStartText(toolName: string, args: unknown): string | undefined {
+	if (isCommandToolName(toolName)) {
+		const command = extractStringProperty<CommandContainer>(args, "command");
+		return command ? limitText(`$ ${command}`) : undefined;
+	}
+	if (toolName === "eval") {
+		return buildEvalStartText(args);
+	}
+	return undefined;
+}
+
+function buildEvalStartText(args: unknown): string | undefined {
+	if (typeof args !== "object" || args === null || Array.isArray(args)) {
+		return undefined;
+	}
+	const cells = (args as EvalCellContainer).cells;
+	if (!Array.isArray(cells) || cells.length === 0) {
+		return undefined;
 	}
-	const command = extractStringProperty<CommandContainer>(args, "command");
-	return command ? [textToolCallContent(`$ ${command}`)] : [];
+	const lines: string[] = [];
+	for (const cell of cells) {
+		if (typeof cell !== "object" || cell === null || Array.isArray(cell)) {
+			continue;
+		}
+		const language = extractStringProperty<EvalCellLike>(cell, "language") ?? "?";
+		const title = extractStringProperty<EvalCellLike>(cell, "title");
+		const code = extractStringProperty<EvalCellLike>(cell, "code");
+		if (!code) {
+			continue;
+		}
+		lines.push(title ? `[${language}] ${title}` : `[${language}]`, code);
+	}
+	return lines.length > 0 ? limitText(lines.join("\n")) : undefined;
 }
 
 function mergeToolUpdateContent(startContent: ToolCallContent[], resultContent: ToolCallContent[]): ToolCallContent[] {
@@ -465,6 +507,14 @@ function isCommandToolName(toolName: string): boolean {
 }
 
 function buildToolTitle(toolName: string, args: unknown, intent: string | undefined): string {
+	if (isCommandToolName(toolName)) {
+		const commandText = buildToolStartText(toolName, args);
+		if (commandText) return commandText;
+	}
+	if (toolName === "eval") {
+		const evalText = buildEvalStartText(args);
+		if (evalText) return evalText;
+	}
 	const trimmedIntent = intent?.trim();
 	if (trimmedIntent) {
 		return trimmedIntent;

package/src/modes/components/assistant-message.ts

@@ -2,6 +2,7 @@ import type { AssistantMessage, ImageContent, Usage } from "@oh-my-pi/pi-ai";
 import { Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
+import type { AssistantThinkingRenderer } from "../../extensibility/extensions/types";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import { isSilentAbort } from "../../session/messages";
 import { resolveImageOptions } from "../../tools/render-utils";
@@ -21,6 +22,7 @@ export class AssistantMessageComponent extends Container {
 		message?: AssistantMessage,
 		private hideThinkingBlock = false,
 		private readonly onImageUpdate?: () => void,
+		private readonly thinkingRenderers: readonly AssistantThinkingRenderer[] = [],
 	) {
 		super();
 
@@ -131,6 +133,27 @@ export class AssistantMessageComponent extends Container {
 		}
 	}
 
+	#appendThinkingExtensions(contentIndex: number, thinkingIndex: number, text: string): void {
+		for (const renderer of this.thinkingRenderers) {
+			try {
+				const component = renderer(
+					{
+						contentIndex,
+						thinkingIndex,
+						text,
+						requestRender: () => this.onImageUpdate?.(),
+					},
+					theme,
+				);
+				if (component) {
+					this.#contentContainer.addChild(component);
+				}
+			} catch {
+				// Ignore extension renderer failures and keep the original thinking block visible.
+			}
+		}
+	}
+
 	updateContent(message: AssistantMessage): void {
 		this.#lastMessage = message;
 
@@ -146,6 +169,7 @@ export class AssistantMessageComponent extends Container {
 		}
 
 		// Render content in order
+		let thinkingIndex = 0;
 		for (let i = 0; i < message.content.length; i++) {
 			const content = message.content[i];
 			if (content.type === "text" && content.text.trim()) {
@@ -166,13 +190,16 @@ export class AssistantMessageComponent extends Container {
 						this.#contentContainer.addChild(new Spacer(1));
 					}
 				} else {
+					const thinkingText = content.thinking.trim();
 					// Thinking traces in thinkingText color, italic
 					this.#contentContainer.addChild(
-						new Markdown(content.thinking.trim(), 1, 0, getMarkdownTheme(), {
+						new Markdown(thinkingText, 1, 0, getMarkdownTheme(), {
 							color: (text: string) => theme.fg("thinkingText", text),
 							italic: true,
 						}),
 					);
+					this.#appendThinkingExtensions(i, thinkingIndex, thinkingText);
+					thinkingIndex += 1;
 					if (hasVisibleContentAfter) {
 						this.#contentContainer.addChild(new Spacer(1));
 					}

package/src/modes/components/custom-editor.ts

@@ -19,6 +19,7 @@ type ConfigurableEditorAction = Extract<
 	| "app.history.search"
 	| "app.message.dequeue"
 	| "app.clipboard.pasteImage"
+	| "app.clipboard.pasteTextRaw"
 	| "app.clipboard.copyPrompt"
 >;
 
@@ -38,6 +39,7 @@ const DEFAULT_ACTION_KEYS: Record<ConfigurableEditorAction, KeyId[]> = {
 	"app.history.search": ["ctrl+r"],
 	"app.message.dequeue": ["alt+up"],
 	"app.clipboard.pasteImage": ["ctrl+v"],
+	"app.clipboard.pasteTextRaw": ["ctrl+shift+v", "alt+shift+v"],
 	"app.clipboard.copyPrompt": ["alt+shift+c"],
 };
 
@@ -49,7 +51,6 @@ export class CustomEditor extends Editor {
 	 *  them, skipping any occurrence inside code spans, fenced blocks, or XML sections. */
 	decorateText = (text: string): string => highlightMagicKeywords(text);
 	onEscape?: () => void;
-	shouldBypassAutocompleteOnEscape?: () => boolean;
 	onClear?: () => void;
 	onExit?: () => void;
 	onCycleThinkingLevel?: () => void;
@@ -66,6 +67,8 @@ export class CustomEditor extends Editor {
 	onCopyPrompt?: () => void;
 	/** Called when the configured image-paste shortcut is pressed. */
 	onPasteImage?: () => Promise<boolean>;
+	/** Called when the configured raw text-paste shortcut is pressed. */
+	onPasteTextRaw?: () => void;
 	/** Called when the configured dequeue shortcut is pressed. */
 	onDequeue?: () => void;
 	/** Called when Caps Lock is pressed. */
@@ -125,6 +128,12 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		// Intercept configured raw text paste (fires and handles result)
+		if (this.#matchesAction(data, "app.clipboard.pasteTextRaw") && this.onPasteTextRaw) {
+			this.onPasteTextRaw();
+			return;
+		}
+
 		// Intercept configured external editor shortcut
 		if (this.#matchesAction(data, "app.editor.external") && this.onExternalEditor) {
 			this.onExternalEditor();
@@ -186,12 +195,15 @@ export class CustomEditor extends Editor {
 		}
 
 		// Intercept configured interrupt shortcut.
-		// Default behavior keeps autocomplete dismissal, but parent can prioritize global interrupt handling.
-		if (this.#matchesAction(data, "app.interrupt") && this.onEscape) {
-			if (!this.isShowingAutocomplete() || this.shouldBypassAutocompleteOnEscape?.()) {
-				this.onEscape();
-				return;
-			}
+		// When the autocomplete popup is visible, ESC's first job is to dismiss
+		// the popup — let super.handleInput() route it to #cancelAutocomplete().
+		// The user can press ESC again afterward to fire the global interrupt
+		// handler. This matches the standard TUI/IDE pattern and prevents a
+		// single ESC from both closing an @ completion and aborting an active
+		// agent run (#1655).
+		if (this.#matchesAction(data, "app.interrupt") && this.onEscape && !this.isShowingAutocomplete()) {
+			this.onEscape();
+			return;
 		}
 
 		// Intercept configured clear shortcut