@oh-my-pi/pi-coding-agent 13.13.0 → 13.14.0

package/src/mcp/transports/stdio.ts

@@ -7,7 +7,16 @@
 
 import { getProjectDir, readJsonl, Snowflake } from "@oh-my-pi/pi-utils";
 import { type Subprocess, spawn } from "bun";
-import type { JsonRpcResponse, MCPRequestOptions, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
+import type {
+	JsonRpcError,
+	JsonRpcMessage,
+	JsonRpcRequest,
+	JsonRpcResponse,
+	MCPRequestOptions,
+	MCPStdioServerConfig,
+	MCPTransport,
+} from "../../mcp/types";
+import { toJsonRpcError } from "../../mcp/types";
 
 /**
  * Stdio transport for MCP servers.
@@ -28,6 +37,7 @@ export class StdioTransport implements MCPTransport {
 	onClose?: () => void;
 	onError?: (error: Error) => void;
 	onNotification?: (method: string, params: unknown) => void;
+	onRequest?: (method: string, params: unknown) => Promise<unknown>;
 
 	constructor(private config: MCPStdioServerConfig) {}
 
@@ -71,7 +81,7 @@ export class StdioTransport implements MCPTransport {
 			for await (const line of readJsonl(this.#process.stdout)) {
 				if (!this.#connected) break;
 				try {
-					this.#handleMessage(line as JsonRpcResponse);
+					this.#handleMessage(line as JsonRpcMessage);
 				} catch {
 					// Skip malformed lines
 				}
@@ -109,25 +119,65 @@ export class StdioTransport implements MCPTransport {
 		}
 	}
 
-	#handleMessage(message: JsonRpcResponse): void {
-		// Check if it's a response (has id)
-		if ("id" in message && message.id !== null) {
-			const pending = this.#pendingRequests.get(message.id);
+	#handleMessage(message: JsonRpcMessage | JsonRpcMessage[]): void {
+		if (Array.isArray(message)) {
+			for (const m of message) this.#handleMessage(m);
+			return;
+		}
+		// Server-to-client request: has both method and id
+		if ("method" in message && "id" in message && message.id != null) {
+			void this.#handleServerRequest(message as JsonRpcRequest);
+			return;
+		}
+
+		// Response to our request: has id
+		if ("id" in message && message.id != null) {
+			const response = message as JsonRpcResponse;
+			const pending = this.#pendingRequests.get(response.id);
 			if (pending) {
-				this.#pendingRequests.delete(message.id);
-				if (message.error) {
-					pending.reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
+				this.#pendingRequests.delete(response.id);
+				if (response.error) {
+					pending.reject(new Error(`MCP error ${response.error.code}: ${response.error.message}`));
 				} else {
-					pending.resolve(message.result);
+					pending.resolve(response.result);
 				}
 			}
-		} else if ("method" in message) {
-			// It's a notification from server
+			return;
+		}
+
+		// Notification: has method but no id
+		if ("method" in message) {
 			const notification = message as { method: string; params?: unknown };
 			this.onNotification?.(notification.method, notification.params);
 		}
 	}
 
+	async #handleServerRequest(request: JsonRpcRequest): Promise<void> {
+		try {
+			if (!this.onRequest) {
+				this.#sendResponse(request.id, undefined, { code: -32601, message: "Method not found" });
+				return;
+			}
+			const result = await this.onRequest(request.method, request.params);
+			this.#sendResponse(request.id, result);
+		} catch (error) {
+			try {
+				this.#sendResponse(request.id, undefined, toJsonRpcError(error));
+			} catch {
+				// Best-effort — process may have exited
+			}
+		}
+	}
+
+	#sendResponse(id: string | number, result?: unknown, error?: JsonRpcError): void {
+		if (!this.#connected || !this.#process?.stdin) return;
+		const response = error
+			? { jsonrpc: "2.0" as const, id, error }
+			: { jsonrpc: "2.0" as const, id, result: result ?? {} };
+		this.#process.stdin.write(`${JSON.stringify(response)}\n`);
+		this.#process.stdin.flush();
+	}
+
 	#handleClose(): void {
 		if (!this.#connected) return;
 		this.#connected = false;

package/src/mcp/types.ts

@@ -100,8 +100,12 @@ export interface MCPSseServerConfig extends MCPServerConfigBase {
 
 export type MCPServerConfig = MCPStdioServerConfig | MCPHttpServerConfig | MCPSseServerConfig;
 
-/** Root .mcp.json file structure */
+export const MCP_CONFIG_SCHEMA_URL =
+	"https://raw.githubusercontent.com/can1357/oh-my-pi/main/packages/coding-agent/src/config/mcp-schema.json";
+
+/** Root mcp.json/.mcp.json file structure */
 export interface MCPConfigFile {
+	$schema?: string;
 	mcpServers?: Record<string, MCPServerConfig>;
 	disabledServers?: string[];
 }
@@ -228,6 +232,8 @@ export interface MCPTransport {
 	onClose?: () => void;
 	onError?: (error: Error) => void;
 	onNotification?: (method: string, params: unknown) => void;
+	/** Handler for server-to-client requests (e.g. roots/list). Returns result or throws a JsonRpcError. */
+	onRequest?: (method: string, params: unknown) => Promise<unknown>;
 }
 
 /** Transport factory function */
@@ -400,3 +406,18 @@ export const MCPNotificationMethods = {
 	RESOURCES_UPDATED: "notifications/resources/updated",
 	PROMPTS_LIST_CHANGED: "notifications/prompts/list_changed",
 } as const;
+
+/** Extract a JsonRpcError from a thrown value. Preserves `.code` and `.message` from Error instances or plain objects. */
+export function toJsonRpcError(error: unknown): JsonRpcError {
+	if (error instanceof Error) {
+		const code = "code" in error && typeof error.code === "number" ? error.code : -32603;
+		return { code, message: error.message };
+	}
+	if (typeof error === "object" && error !== null) {
+		const obj = error as Record<string, unknown>;
+		if (typeof obj.code === "number" && typeof obj.message === "string") {
+			return { code: obj.code, message: obj.message };
+		}
+	}
+	return { code: -32603, message: "Internal error" };
+}

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

@@ -1,34 +1,89 @@
 import { Editor, type KeyId, matchesKey, parseKittySequence } from "@oh-my-pi/pi-tui";
+import type { AppAction } from "../../config/keybindings";
+
+type ConfigurableEditorAction = Extract<
+	AppAction,
+	| "interrupt"
+	| "clear"
+	| "exit"
+	| "suspend"
+	| "cycleThinkingLevel"
+	| "cycleModelForward"
+	| "cycleModelBackward"
+	| "selectModel"
+	| "expandTools"
+	| "toggleThinking"
+	| "externalEditor"
+	| "historySearch"
+	| "dequeue"
+	| "pasteImage"
+	| "copyPrompt"
+>;
+
+const DEFAULT_ACTION_KEYS: Record<ConfigurableEditorAction, KeyId[]> = {
+	interrupt: ["escape"],
+	clear: ["ctrl+c"],
+	exit: ["ctrl+d"],
+	suspend: ["ctrl+z"],
+	cycleThinkingLevel: ["shift+tab"],
+	cycleModelForward: ["ctrl+p"],
+	cycleModelBackward: ["shift+ctrl+p"],
+	selectModel: ["ctrl+l"],
+	expandTools: ["ctrl+o"],
+	toggleThinking: ["ctrl+t"],
+	externalEditor: ["ctrl+g"],
+	historySearch: ["ctrl+r"],
+	dequeue: ["alt+up"],
+	pasteImage: ["ctrl+v"],
+	copyPrompt: ["alt+shift+c"],
+};
 
 /**
- * Custom editor that handles Escape and Ctrl+C keys for coding-agent
+ * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
 export class CustomEditor extends Editor {
 	onEscape?: () => void;
 	shouldBypassAutocompleteOnEscape?: () => boolean;
-	onCtrlC?: () => void;
-	onCtrlD?: () => void;
-	onShiftTab?: () => void;
-	onCtrlP?: () => void;
-	onShiftCtrlP?: () => void;
-	onCtrlL?: () => void;
-	onCtrlR?: () => void;
-	onCtrlO?: () => void;
-	onCtrlT?: () => void;
-	onCtrlG?: () => void;
-	onCtrlZ?: () => void;
-	onQuestionMark?: () => void;
-	onCapsLock?: () => void;
-	onAltP?: () => void;
-	/** Called when Alt+Shift+C is pressed to copy prompt to clipboard. */
+	onClear?: () => void;
+	onExit?: () => void;
+	onCycleThinkingLevel?: () => void;
+	onCycleModelForward?: () => void;
+	onCycleModelBackward?: () => void;
+	onSelectModel?: () => void;
+	onExpandTools?: () => void;
+	onToggleThinking?: () => void;
+	onExternalEditor?: () => void;
+	onHistorySearch?: () => void;
+	onSuspend?: () => void;
+	onShowHotkeys?: () => void;
+	onQuickSelectModel?: () => void;
+	/** Called when the configured copy-prompt shortcut is pressed. */
 	onCopyPrompt?: () => void;
-	/** Called when Ctrl+V is pressed. Returns true if handled (image found), false to fall through to text paste. */
-	onCtrlV?: () => Promise<boolean>;
-	/** Called when Alt+Up is pressed (dequeue keybinding). */
-	onAltUp?: () => void;
+	/** Called when the configured image-paste shortcut is pressed. */
+	onPasteImage?: () => Promise<boolean>;
+	/** Called when the configured dequeue shortcut is pressed. */
+	onDequeue?: () => void;
+	/** Called when Caps Lock is pressed. */
+	onCapsLock?: () => void;
 
-	/** Custom key handlers from extensions */
+	/** Custom key handlers from extensions and non-built-in app actions. */
 	#customKeyHandlers = new Map<KeyId, () => void>();
+	#actionKeys = new Map<ConfigurableEditorAction, KeyId[]>(
+		Object.entries(DEFAULT_ACTION_KEYS).map(([action, keys]) => [action as ConfigurableEditorAction, [...keys]]),
+	);
+
+	setActionKeys(action: ConfigurableEditorAction, keys: KeyId[]): void {
+		this.#actionKeys.set(action, [...keys]);
+	}
+
+	#matchesAction(data: string, action: ConfigurableEditorAction): boolean {
+		const keys = this.#actionKeys.get(action);
+		if (!keys) return false;
+		for (const key of keys) {
+			if (matchesKey(data, key)) return true;
+		}
+		return false;
+	}
 
 	/**
 	 * Register a custom key handler. Extensions use this for shortcuts.
@@ -59,111 +114,111 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
-		// Intercept Ctrl+V for image paste (async - fires and handles result)
-		if (matchesKey(data, "ctrl+v") && this.onCtrlV) {
-			void this.onCtrlV();
+		// Intercept configured image paste (async - fires and handles result)
+		if (this.#matchesAction(data, "pasteImage") && this.onPasteImage) {
+			void this.onPasteImage();
 			return;
 		}
 
-		// Intercept Ctrl+G for external editor
-		if (matchesKey(data, "ctrl+g") && this.onCtrlG) {
-			this.onCtrlG();
+		// Intercept configured external editor shortcut
+		if (this.#matchesAction(data, "externalEditor") && this.onExternalEditor) {
+			this.onExternalEditor();
 			return;
 		}
 
 		// Intercept Alt+P for quick model switching
-		if (matchesKey(data, "alt+p") && this.onAltP) {
-			this.onAltP();
+		if (matchesKey(data, "alt+p") && this.onQuickSelectModel) {
+			this.onQuickSelectModel();
 			return;
 		}
 
-		// Intercept Ctrl+Z for suspend
-		if (matchesKey(data, "ctrl+z") && this.onCtrlZ) {
-			this.onCtrlZ();
+		// Intercept configured suspend shortcut
+		if (this.#matchesAction(data, "suspend") && this.onSuspend) {
+			this.onSuspend();
 			return;
 		}
 
-		// Intercept Ctrl+T for thinking block visibility toggle
-		if (matchesKey(data, "ctrl+t") && this.onCtrlT) {
-			this.onCtrlT();
+		// Intercept configured thinking block visibility toggle
+		if (this.#matchesAction(data, "toggleThinking") && this.onToggleThinking) {
+			this.onToggleThinking();
 			return;
 		}
 
-		// Intercept Ctrl+L for model selector
-		if (matchesKey(data, "ctrl+l") && this.onCtrlL) {
-			this.onCtrlL();
+		// Intercept configured model selector shortcut
+		if (this.#matchesAction(data, "selectModel") && this.onSelectModel) {
+			this.onSelectModel();
 			return;
 		}
 
-		// Intercept Ctrl+R for history search
-		if (matchesKey(data, "ctrl+r") && this.onCtrlR) {
-			this.onCtrlR();
+		// Intercept configured history search shortcut
+		if (this.#matchesAction(data, "historySearch") && this.onHistorySearch) {
+			this.onHistorySearch();
 			return;
 		}
 
-		// Intercept Ctrl+O for tool output expansion
-		if (matchesKey(data, "ctrl+o") && this.onCtrlO) {
-			this.onCtrlO();
+		// Intercept configured tool output expansion shortcut
+		if (this.#matchesAction(data, "expandTools") && this.onExpandTools) {
+			this.onExpandTools();
 			return;
 		}
 
-		// Intercept Shift+Ctrl+P for backward model cycling (check before Ctrl+P)
-		if ((matchesKey(data, "shift+ctrl+p") || matchesKey(data, "ctrl+shift+p")) && this.onShiftCtrlP) {
-			this.onShiftCtrlP();
+		// Intercept configured backward model cycling (check before forward cycling)
+		if (this.#matchesAction(data, "cycleModelBackward") && this.onCycleModelBackward) {
+			this.onCycleModelBackward();
 			return;
 		}
 
-		// Intercept Ctrl+P for model cycling
-		if (matchesKey(data, "ctrl+p") && this.onCtrlP) {
-			this.onCtrlP();
+		// Intercept configured forward model cycling
+		if (this.#matchesAction(data, "cycleModelForward") && this.onCycleModelForward) {
+			this.onCycleModelForward();
 			return;
 		}
 
-		// Intercept Shift+Tab for thinking level cycling
-		if (matchesKey(data, "shift+tab") && this.onShiftTab) {
-			this.onShiftTab();
+		// Intercept configured thinking level cycling
+		if (this.#matchesAction(data, "cycleThinkingLevel") && this.onCycleThinkingLevel) {
+			this.onCycleThinkingLevel();
 			return;
 		}
 
-		// Intercept Escape key.
-		// Default behavior keeps autocomplete dismissal, but parent can prioritize global escape handling.
-		if ((matchesKey(data, "escape") || matchesKey(data, "esc")) && this.onEscape) {
+		// Intercept configured interrupt shortcut.
+		// Default behavior keeps autocomplete dismissal, but parent can prioritize global interrupt handling.
+		if (this.#matchesAction(data, "interrupt") && this.onEscape) {
 			if (!this.isShowingAutocomplete() || this.shouldBypassAutocompleteOnEscape?.()) {
 				this.onEscape();
 				return;
 			}
 		}
 
-		// Intercept Ctrl+C
-		if (matchesKey(data, "ctrl+c") && this.onCtrlC) {
-			this.onCtrlC();
+		// Intercept configured clear shortcut
+		if (this.#matchesAction(data, "clear") && this.onClear) {
+			this.onClear();
 			return;
 		}
 
-		// Intercept Ctrl+D (only when editor is empty)
-		if (matchesKey(data, "ctrl+d")) {
-			if (this.getText().length === 0 && this.onCtrlD) {
-				this.onCtrlD();
+		// Intercept configured exit shortcut (only when editor is empty)
+		if (this.#matchesAction(data, "exit")) {
+			if (this.getText().length === 0 && this.onExit) {
+				this.onExit();
 			}
-			// Always consume Ctrl+D (don't pass to parent)
+			// Always consume exit shortcut (don't pass to parent)
 			return;
 		}
 
-		// Intercept Alt+Up for dequeue (restore queued message to editor)
-		if (matchesKey(data, "alt+up") && this.onAltUp) {
-			this.onAltUp();
+		// Intercept configured dequeue shortcut (restore queued message to editor)
+		if (this.#matchesAction(data, "dequeue") && this.onDequeue) {
+			this.onDequeue();
 			return;
 		}
 
-		// Intercept Alt+Shift+C to copy prompt to clipboard
-		if (matchesKey(data, "alt+shift+c") && this.onCopyPrompt) {
+		// Intercept configured copy-prompt shortcut
+		if (this.#matchesAction(data, "copyPrompt") && this.onCopyPrompt) {
 			this.onCopyPrompt();
 			return;
 		}
 
 		// Intercept ? when editor is empty to show hotkeys
-		if (data === "?" && this.getText().length === 0 && this.onQuestionMark) {
-			this.onQuestionMark();
+		if (data === "?" && this.getText().length === 0 && this.onShowHotkeys) {
+			this.onShowHotkeys();
 			return;
 		}
 

package/src/modes/controllers/command-controller.ts

@@ -32,6 +32,7 @@ import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog";
 import { openPath } from "../../utils/open";
+import { setSessionTerminalTitle } from "../../utils/title-generator";
 
 export class CommandController {
 	constructor(private readonly ctx: InteractiveModeContext) {}
@@ -505,18 +506,7 @@ export class CommandController {
 	}
 
 	handleHotkeysCommand(): void {
-		const expandToolsKey = this.ctx.keybindings.getDisplayString("expandTools") || "Ctrl+O";
-		const planModeKey = this.ctx.keybindings.getDisplayString("togglePlanMode") || "Alt+Shift+P";
-		const sttKey = this.ctx.keybindings.getDisplayString("toggleSTT") || "Alt+H";
-		const copyLineKey = this.ctx.keybindings.getDisplayString("copyLine") || "Alt+Shift+L";
-		const copyPromptKey = this.ctx.keybindings.getDisplayString("copyPrompt") || "Alt+Shift+C";
-		const hotkeys = buildHotkeysMarkdown({
-			expandToolsKey,
-			planModeKey,
-			sttKey,
-			copyLineKey,
-			copyPromptKey,
-		});
+		const hotkeys = buildHotkeysMarkdown({ keybindings: this.ctx.keybindings });
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new DynamicBorder());
 		this.ctx.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", "Keyboard Shortcuts")), 1, 0));
@@ -585,6 +575,7 @@ export class CommandController {
 			}
 		}
 		await this.ctx.session.newSession();
+		setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
 		this.ctx.statusLine.invalidate();
 		this.ctx.statusLine.setSessionStartTime(Date.now());

package/src/modes/controllers/extension-ui-controller.ts

@@ -16,7 +16,7 @@ import { HookInputComponent } from "../../modes/components/hook-input";
 import { HookSelectorComponent } from "../../modes/components/hook-selector";
 import { getAvailableThemesWithPaths, getThemeByName, setTheme, type Theme, theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
-import { setTerminalTitle } from "../../utils/title-generator";
+import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
 
 export class ExtensionUiController {
 	#extensionTerminalInputUnsubscribers = new Set<() => void>();
@@ -154,6 +154,7 @@ export class ExtensionUiController {
 				if (!success) {
 					return { cancelled: true };
 				}
+				setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 
 				// Call setup callback if provided
 				if (options?.setup) {
@@ -230,6 +231,7 @@ export class ExtensionUiController {
 				if (!result) {
 					return { cancelled: true };
 				}
+				setSessionTerminalTitle(this.ctx.sessionManager.getSessionName(), this.ctx.sessionManager.getCwd());
 				this.ctx.chatContainer.clear();
 				this.ctx.renderInitialMessages();
 				await this.ctx.reloadTodos();

package/src/modes/controllers/input-controller.ts

@@ -12,7 +12,7 @@ import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../sessio
 import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registry";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
 import { resizeImage } from "../../utils/image-resize";
-import { generateSessionTitle, setTerminalTitle } from "../../utils/title-generator";
+import { generateSessionTitle, setSessionTerminalTitle } from "../../utils/title-generator";
 
 interface Expandable {
 	setExpanded(expanded: boolean): void;
@@ -26,6 +26,7 @@ export class InputController {
 	constructor(private ctx: InteractiveModeContext) {}
 
 	setupKeyHandlers(): void {
+		this.ctx.editor.setActionKeys("interrupt", this.ctx.keybindings.getKeys("interrupt"));
 		this.ctx.editor.shouldBypassAutocompleteOnEscape = () =>
 			Boolean(
 				this.ctx.loadingAnimation ||
@@ -64,7 +65,7 @@ export class InputController {
 			} else if (this.ctx.session.isStreaming) {
 				void this.ctx.session.abort();
 			} else if (!this.ctx.editor.getText().trim()) {
-				// Double-escape with empty editor triggers /tree, /branch, or nothing based on setting
+				// Double-interrupt with empty editor triggers /tree, /branch, or nothing based on setting
 				const action = settings.get("doubleEscapeAction");
 				if (action !== "none") {
 					const now = Date.now();
@@ -82,42 +83,44 @@ export class InputController {
 			}
 		};
 
-		this.ctx.editor.onCtrlC = () => this.handleCtrlC();
-		this.ctx.editor.onCtrlD = () => this.handleCtrlD();
-		this.ctx.editor.onCtrlZ = () => this.handleCtrlZ();
-		this.ctx.editor.onShiftTab = () => this.cycleThinkingLevel();
-		this.ctx.editor.onCtrlP = () => this.cycleRoleModel();
-		this.ctx.editor.onShiftCtrlP = () => this.cycleRoleModel({ temporary: true });
-		this.ctx.editor.onAltP = () => this.ctx.showModelSelector({ temporaryOnly: true });
+		this.ctx.editor.setActionKeys("clear", this.ctx.keybindings.getKeys("clear"));
+		this.ctx.editor.onClear = () => this.handleCtrlC();
+		this.ctx.editor.setActionKeys("exit", this.ctx.keybindings.getKeys("exit"));
+		this.ctx.editor.onExit = () => this.handleCtrlD();
+		this.ctx.editor.setActionKeys("suspend", this.ctx.keybindings.getKeys("suspend"));
+		this.ctx.editor.onSuspend = () => this.handleCtrlZ();
+		this.ctx.editor.setActionKeys("cycleThinkingLevel", this.ctx.keybindings.getKeys("cycleThinkingLevel"));
+		this.ctx.editor.onCycleThinkingLevel = () => this.cycleThinkingLevel();
+		this.ctx.editor.setActionKeys("cycleModelForward", this.ctx.keybindings.getKeys("cycleModelForward"));
+		this.ctx.editor.onCycleModelForward = () => this.cycleRoleModel();
+		this.ctx.editor.setActionKeys("cycleModelBackward", this.ctx.keybindings.getKeys("cycleModelBackward"));
+		this.ctx.editor.onCycleModelBackward = () => this.cycleRoleModel({ temporary: true });
+		this.ctx.editor.onQuickSelectModel = () => this.ctx.showModelSelector({ temporaryOnly: true });
 
 		// Global debug handler on TUI (works regardless of focus)
 		this.ctx.ui.onDebug = () => this.ctx.showDebugSelector();
-		this.ctx.editor.onCtrlL = () => this.ctx.showModelSelector();
-		this.ctx.editor.onCtrlR = () => this.ctx.showHistorySearch();
-		this.ctx.editor.onCtrlT = () => this.ctx.toggleTodoExpansion();
-		this.ctx.editor.onCtrlG = () => void this.openExternalEditor();
-		this.ctx.editor.onQuestionMark = () => this.ctx.handleHotkeysCommand();
-		this.ctx.editor.onCtrlV = () => this.handleImagePaste();
-		const copyPromptKeys = this.ctx.keybindings.getKeys("copyPrompt");
-		this.ctx.editor.onCopyPrompt = copyPromptKeys.includes("alt+shift+c") ? () => this.handleCopyPrompt() : undefined;
-
+		this.ctx.editor.setActionKeys("selectModel", this.ctx.keybindings.getKeys("selectModel"));
+		this.ctx.editor.onSelectModel = () => this.ctx.showModelSelector();
+		this.ctx.editor.setActionKeys("historySearch", this.ctx.keybindings.getKeys("historySearch"));
+		this.ctx.editor.onHistorySearch = () => this.ctx.showHistorySearch();
+		this.ctx.editor.setActionKeys("toggleThinking", this.ctx.keybindings.getKeys("toggleThinking"));
+		this.ctx.editor.onToggleThinking = () => this.ctx.toggleThinkingBlockVisibility();
+		this.ctx.editor.setActionKeys("externalEditor", this.ctx.keybindings.getKeys("externalEditor"));
+		this.ctx.editor.onExternalEditor = () => void this.openExternalEditor();
+		this.ctx.editor.onShowHotkeys = () => this.ctx.handleHotkeysCommand();
+		this.ctx.editor.setActionKeys("pasteImage", this.ctx.keybindings.getKeys("pasteImage"));
+		this.ctx.editor.onPasteImage = () => this.handleImagePaste();
+		this.ctx.editor.setActionKeys("copyPrompt", this.ctx.keybindings.getKeys("copyPrompt"));
+		this.ctx.editor.onCopyPrompt = () => this.handleCopyPrompt();
+		this.ctx.editor.setActionKeys("expandTools", this.ctx.keybindings.getKeys("expandTools"));
+		this.ctx.editor.onExpandTools = () => this.toggleToolOutputExpansion();
+		this.ctx.editor.setActionKeys("dequeue", this.ctx.keybindings.getKeys("dequeue"));
+		this.ctx.editor.onDequeue = () => this.handleDequeue();
+
+		this.ctx.editor.clearCustomKeyHandlers();
 		// Wire up extension shortcuts
 		this.registerExtensionShortcuts();
 
-		const expandToolsKeys = this.ctx.keybindings.getKeys("expandTools");
-		this.ctx.editor.onCtrlO = expandToolsKeys.includes("ctrl+o") ? () => this.toggleToolOutputExpansion() : undefined;
-		for (const key of expandToolsKeys) {
-			if (key === "ctrl+o") continue;
-			this.ctx.editor.setCustomKeyHandler(key, () => this.toggleToolOutputExpansion());
-		}
-
-		const dequeueKeys = this.ctx.keybindings.getKeys("dequeue");
-		this.ctx.editor.onAltUp = dequeueKeys.includes("alt+up") ? () => this.handleDequeue() : undefined;
-		for (const key of dequeueKeys) {
-			if (key === "alt+up") continue;
-			this.ctx.editor.setCustomKeyHandler(key, () => this.handleDequeue());
-		}
-
 		const planModeKeys = this.ctx.keybindings.getKeys("togglePlanMode");
 		for (const key of planModeKeys) {
 			this.ctx.editor.setCustomKeyHandler(key, () => void this.ctx.handlePlanModeCommand());
@@ -144,10 +147,6 @@ export class InputController {
 		for (const key of this.ctx.keybindings.getKeys("copyLine")) {
 			this.ctx.editor.setCustomKeyHandler(key, () => this.handleCopyCurrentLine());
 		}
-		for (const key of copyPromptKeys) {
-			if (key === "alt+shift+c") continue;
-			this.ctx.editor.setCustomKeyHandler(key, () => this.handleCopyPrompt());
-		}
 
 		this.ctx.editor.onChange = (text: string) => {
 			const wasBashMode = this.ctx.isBashMode;
@@ -326,7 +325,7 @@ export class InputController {
 					.then(async title => {
 						if (title) {
 							await this.ctx.sessionManager.setSessionName(title);
-							setTerminalTitle(`π: ${title}`);
+							setSessionTerminalTitle(title, this.ctx.sessionManager.getCwd());
 						}
 					})
 					.catch(() => {});