@oh-my-pi/pi-coding-agent 11.2.3 → 11.3.0

package/src/modes/components/tree-selector.ts

@@ -55,6 +55,7 @@ class TreeList implements Component {
 	private toolCallMap: Map<string, ToolCallInfo> = new Map();
 	private multipleRoots = false;
 	private activePathIds: Set<string> = new Set();
+	private lastSelectedId: string | null = null;
 
 	public onSelect?: (entryId: string) => void;
 	public onCancel?: () => void;
@@ -64,19 +65,17 @@ class TreeList implements Component {
 		tree: SessionTreeNode[],
 		private readonly currentLeafId: string | null,
 		private readonly maxVisibleLines: number,
+		initialSelectedId?: string,
 	) {
 		this.multipleRoots = tree.length > 1;
 		this.flatNodes = this.flattenTree(tree);
 		this.buildActivePath();
 		this.applyFilter();
 
-		// Start with current leaf selected
-		const leafIndex = this.filteredNodes.findIndex(n => n.node.entry.id === currentLeafId);
-		if (leafIndex !== -1) {
-			this.selectedIndex = leafIndex;
-		} else {
-			this.selectedIndex = Math.max(0, this.filteredNodes.length - 1);
-		}
+		// Start with initialSelectedId if provided, otherwise current leaf
+		const targetId = initialSelectedId ?? currentLeafId;
+		this.selectedIndex = this.findNearestVisibleIndex(targetId);
+		this.lastSelectedId = this.filteredNodes[this.selectedIndex]?.node.entry.id ?? null;
 	}
 
 	/** Build the set of entry IDs on the path from root to current leaf */
@@ -100,6 +99,36 @@ class TreeList implements Component {
 		}
 	}
 
+	/**
+	 * Find the index of the nearest visible entry, walking up the parent chain if needed.
+	 * Returns the index in filteredNodes, or the last index as fallback.
+	 */
+	private findNearestVisibleIndex(entryId: string | null): number {
+		if (this.filteredNodes.length === 0) return 0;
+
+		// Build a map for parent lookup
+		const entryMap = new Map<string, FlatNode>();
+		for (const flatNode of this.flatNodes) {
+			entryMap.set(flatNode.node.entry.id, flatNode);
+		}
+
+		// Build a map of visible entry IDs to their indices in filteredNodes
+		const visibleIdToIndex = new Map<string, number>(this.filteredNodes.map((node, i) => [node.node.entry.id, i]));
+
+		// Walk from entryId up to root, looking for a visible entry
+		let currentId = entryId;
+		while (currentId !== null) {
+			const index = visibleIdToIndex.get(currentId);
+			if (index !== undefined) return index;
+			const node = entryMap.get(currentId);
+			if (!node) break;
+			currentId = node.node.entry.parentId ?? null;
+		}
+
+		// Fallback: last visible entry
+		return this.filteredNodes.length - 1;
+	}
+
 	private flattenTree(roots: SessionTreeNode[]): FlatNode[] {
 		const result: FlatNode[] = [];
 		this.toolCallMap.clear();
@@ -231,8 +260,11 @@ class TreeList implements Component {
 	}
 
 	private applyFilter(): void {
-		// Remember currently selected node to preserve cursor position
-		const previouslySelectedId = this.filteredNodes[this.selectedIndex]?.node.entry.id;
+		// Update lastSelectedId only when we have a valid selection (non-empty list)
+		// This preserves the selection when switching through empty filter results
+		if (this.filteredNodes.length > 0) {
+			this.lastSelectedId = this.filteredNodes[this.selectedIndex]?.node.entry.id ?? this.lastSelectedId;
+		}
 
 		const searchTokens = this.searchQuery.toLowerCase().split(/\s+/).filter(Boolean);
 
@@ -295,18 +327,17 @@ class TreeList implements Component {
 			return true;
 		});
 
-		// Try to preserve cursor on the same node after filtering
-		if (previouslySelectedId) {
-			const newIndex = this.filteredNodes.findIndex(n => n.node.entry.id === previouslySelectedId);
-			if (newIndex !== -1) {
-				this.selectedIndex = newIndex;
-				return;
-			}
+		// Try to preserve cursor on the same node, or find nearest visible ancestor
+		if (this.lastSelectedId) {
+			this.selectedIndex = this.findNearestVisibleIndex(this.lastSelectedId);
+		} else if (this.selectedIndex >= this.filteredNodes.length) {
+			// Clamp index if out of bounds
+			this.selectedIndex = Math.max(0, this.filteredNodes.length - 1);
 		}
 
-		// Fall back: clamp index if out of bounds
-		if (this.selectedIndex >= this.filteredNodes.length) {
-			this.selectedIndex = Math.max(0, this.filteredNodes.length - 1);
+		// Update lastSelectedId to the actual selection (may have changed due to parent walk)
+		if (this.filteredNodes.length > 0) {
+			this.lastSelectedId = this.filteredNodes[this.selectedIndex]?.node.entry.id ?? this.lastSelectedId;
 		}
 	}
 

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

@@ -97,6 +97,7 @@ export class EventController {
 					this.ctx.ui.requestRender();
 				} else if (event.message.role === "assistant") {
 					this.lastThinkingCount = 0;
+					this.resetReadGroup();
 					this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock);
 					this.ctx.streamingMessage = event.message;
 					this.ctx.chatContainer.addChild(this.ctx.streamingComponent);

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

@@ -64,6 +64,8 @@ export class ExtensionUiController {
 			setFooter: () => {},
 			setHeader: () => {},
 			setEditorComponent: () => {},
+			getToolsExpanded: () => this.ctx.toolOutputExpanded,
+			setToolsExpanded: expanded => this.ctx.setToolsExpanded(expanded),
 		};
 		this.ctx.setToolUIContext(uiContext, true);
 
@@ -114,6 +116,7 @@ export class ExtensionUiController {
 			},
 			getThinkingLevel: () => this.ctx.session.thinkingLevel,
 			setThinkingLevel: level => this.ctx.session.setThinkingLevel(level),
+			getCommands: () => [],
 		};
 		const contextActions: ExtensionContextActions = {
 			getModel: () => this.ctx.session.model,
@@ -130,6 +133,7 @@ export class ExtensionUiController {
 					instructionsOrOptions && typeof instructionsOrOptions === "object" ? instructionsOrOptions : undefined;
 				await this.ctx.session.compact(instructions, options);
 			},
+			getSystemPrompt: () => this.ctx.session.systemPrompt,
 		};
 		const commandActions: ExtensionCommandContextActions = {
 			getContextUsage: () => this.ctx.session.getContextUsage(),
@@ -195,7 +199,7 @@ export class ExtensionUiController {
 				this.ctx.chatContainer.clear();
 				this.ctx.renderInitialMessages();
 				await this.ctx.reloadTodos();
-				if (result.editorText) {
+				if (result.editorText && !this.ctx.editor.getText().trim()) {
 					this.ctx.editor.setText(result.editorText);
 				}
 				this.ctx.showStatus("Navigated to selected point");
@@ -212,6 +216,16 @@ export class ExtensionUiController {
 				}
 				await this.ctx.executeCompaction(instructionsOrOptions, false);
 			},
+			switchSession: async sessionPath => {
+				const result = await this.ctx.session.switchSession(sessionPath);
+				if (!result) {
+					return { cancelled: true };
+				}
+				this.ctx.chatContainer.clear();
+				this.ctx.renderInitialMessages();
+				await this.ctx.reloadTodos();
+				return { cancelled: false };
+			},
 		};
 
 		extensionRunner.initialize(actions, contextActions, commandActions, uiContext);
@@ -283,6 +297,7 @@ export class ExtensionUiController {
 			},
 			getThinkingLevel: () => this.ctx.session.thinkingLevel,
 			setThinkingLevel: (level, persist) => this.ctx.session.setThinkingLevel(level, persist),
+			getCommands: () => [],
 		};
 		const contextActions: ExtensionContextActions = {
 			getModel: () => this.ctx.session.model,
@@ -299,6 +314,7 @@ export class ExtensionUiController {
 					instructionsOrOptions && typeof instructionsOrOptions === "object" ? instructionsOrOptions : undefined;
 				await this.ctx.session.compact(instructions, options);
 			},
+			getSystemPrompt: () => this.ctx.session.systemPrompt,
 		};
 		const commandActions: ExtensionCommandContextActions = {
 			getContextUsage: () => this.ctx.session.getContextUsage(),
@@ -373,7 +389,7 @@ export class ExtensionUiController {
 				this.ctx.chatContainer.clear();
 				this.ctx.renderInitialMessages();
 				await this.ctx.reloadTodos();
-				if (result.editorText) {
+				if (result.editorText && !this.ctx.editor.getText().trim()) {
 					this.ctx.editor.setText(result.editorText);
 				}
 				this.ctx.showStatus("Navigated to selected point");
@@ -390,6 +406,19 @@ export class ExtensionUiController {
 				}
 				await this.ctx.executeCompaction(instructionsOrOptions, false);
 			},
+			switchSession: async sessionPath => {
+				if (this.ctx.isBackgrounded) {
+					return { cancelled: true };
+				}
+				const result = await this.ctx.session.switchSession(sessionPath);
+				if (!result) {
+					return { cancelled: true };
+				}
+				this.ctx.chatContainer.clear();
+				this.ctx.renderInitialMessages();
+				await this.ctx.reloadTodos();
+				return { cancelled: false };
+			},
 		};
 
 		extensionRunner.initialize(actions, contextActions, commandActions, uiContext);
@@ -418,6 +447,8 @@ export class ExtensionUiController {
 			setFooter: () => {},
 			setHeader: () => {},
 			setEditorComponent: () => {},
+			getToolsExpanded: () => false,
+			setToolsExpanded: () => {},
 		};
 	}
 
@@ -461,6 +492,7 @@ export class ExtensionUiController {
 						shutdown: () => {
 							// Signal shutdown request
 						},
+						getSystemPrompt: () => this.ctx.session.systemPrompt,
 					});
 				} catch (err) {
 					this.showToolError(registeredTool.definition.name, err instanceof Error ? err.message : String(err));

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

@@ -97,6 +97,22 @@ export class InputController {
 			this.ctx.editor.setCustomKeyHandler(key, () => void this.ctx.handlePlanModeCommand());
 		}
 
+		for (const key of this.ctx.keybindings.getKeys("newSession")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.handleClearCommand());
+		}
+		for (const key of this.ctx.keybindings.getKeys("tree")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showTreeSelector());
+		}
+		for (const key of this.ctx.keybindings.getKeys("fork")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showUserMessageSelector());
+		}
+		for (const key of this.ctx.keybindings.getKeys("resume")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => this.ctx.showSessionSelector());
+		}
+		for (const key of this.ctx.keybindings.getKeys("followUp")) {
+			this.ctx.editor.setCustomKeyHandler(key, () => void this.handleFollowUp());
+		}
+
 		this.ctx.editor.onChange = (text: string) => {
 			const wasBashMode = this.ctx.isBashMode;
 			const wasPythonMode = this.ctx.isPythonMode;
@@ -107,37 +123,6 @@ export class InputController {
 				this.ctx.updateEditorBorderColor();
 			}
 		};
-
-		this.ctx.editor.onAltEnter = async (text: string) => {
-			const trimmedText = text.trim();
-
-			// Queue follow-up messages while compaction is running
-			if (this.ctx.session.isCompacting) {
-				if (!trimmedText) {
-					this.ctx.editor.handleInput("\n");
-					return;
-				}
-				this.ctx.queueCompactionMessage(trimmedText, "followUp");
-				return;
-			}
-
-			// Alt+Enter queues a follow-up message while streaming
-			if (this.ctx.session.isStreaming) {
-				if (!trimmedText) {
-					this.ctx.editor.handleInput("\n");
-					return;
-				}
-				this.ctx.editor.addToHistory(trimmedText);
-				this.ctx.editor.setText("");
-				await this.ctx.session.prompt(trimmedText, { streamingBehavior: "followUp" });
-				this.ctx.updatePendingMessagesDisplay();
-				this.ctx.ui.requestRender();
-				return;
-			}
-
-			// Default behavior: insert a new line
-			this.ctx.editor.handleInput("\n");
-		};
 	}
 
 	setupEditorSubmitHandler(): void {
@@ -519,6 +504,31 @@ export class InputController {
 		}
 	}
 
+	/** Send editor text as a follow-up message (queued behind current stream). */
+	async handleFollowUp(): Promise<void> {
+		const text = this.ctx.editor.getText().trim();
+		if (!text) return;
+
+		if (this.ctx.session.isCompacting) {
+			this.ctx.queueCompactionMessage(text, "followUp");
+			return;
+		}
+
+		if (this.ctx.session.isStreaming) {
+			this.ctx.editor.addToHistory(text);
+			this.ctx.editor.setText("");
+			await this.ctx.session.prompt(text, { streamingBehavior: "followUp" });
+			this.ctx.updatePendingMessagesDisplay();
+			this.ctx.ui.requestRender();
+			return;
+		}
+
+		// Not streaming — just submit normally
+		this.ctx.editor.addToHistory(text);
+		this.ctx.editor.setText("");
+		await this.ctx.session.prompt(text);
+	}
+
 	restoreQueuedMessagesToEditor(options?: { abort?: boolean; currentText?: string }): number {
 		const { steering, followUp } = this.ctx.session.clearQueue();
 		const allQueued = [...steering, ...followUp];
@@ -681,10 +691,14 @@ export class InputController {
 	}
 
 	toggleToolOutputExpansion(): void {
-		this.ctx.toolOutputExpanded = !this.ctx.toolOutputExpanded;
+		this.setToolsExpanded(!this.ctx.toolOutputExpanded);
+	}
+
+	setToolsExpanded(expanded: boolean): void {
+		this.ctx.toolOutputExpanded = expanded;
 		for (const child of this.ctx.chatContainer.children) {
 			if (isExpandable(child)) {
-				child.setExpanded(this.ctx.toolOutputExpanded);
+				child.setExpanded(expanded);
 			}
 		}
 		this.ctx.ui.requestRender();

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

@@ -84,7 +84,7 @@ export class SelectorController {
 						},
 						getStatusLinePreview: () => {
 							// Return the rendered status line for inline preview
-							const width = this.ctx.ui.getWidth();
+							const width = this.ctx.ui.terminal.columns;
 							return this.ctx.statusLine.getTopBorder(width).content;
 						},
 						onPluginsChanged: () => {
@@ -185,6 +185,10 @@ export class SelectorController {
 				this.ctx.updateEditorBorderColor();
 				break;
 
+			case "clearOnShrink":
+				this.ctx.ui.setClearOnShrink(value as boolean);
+				break;
+
 			// Settings with UI side effects
 			case "showImages":
 				for (const child of this.ctx.chatContainer.children) {
@@ -354,15 +358,6 @@ export class SelectorController {
 		const tree = this.ctx.sessionManager.getTree();
 		const realLeafId = this.ctx.sessionManager.getLeafId();
 
-		// Find the visible leaf for display (skip metadata entries like labels)
-		let visibleLeafId = realLeafId;
-		while (visibleLeafId) {
-			const entry = this.ctx.sessionManager.getEntry(visibleLeafId);
-			if (!entry) break;
-			if (entry.type !== "label" && entry.type !== "custom") break;
-			visibleLeafId = entry.parentId ?? null;
-		}
-
 		if (tree.length === 0) {
 			this.ctx.showStatus("No entries in session");
 			return;
@@ -371,11 +366,11 @@ export class SelectorController {
 		this.showSelector(done => {
 			const selector = new TreeSelectorComponent(
 				tree,
-				visibleLeafId,
+				realLeafId,
 				this.ctx.ui.terminal.rows,
 				async entryId => {
-					// Selecting the visible leaf is a no-op (already there)
-					if (entryId === visibleLeafId) {
+					// Selecting the current leaf is a no-op (already there)
+					if (entryId === realLeafId) {
 						done();
 						this.ctx.showStatus("Already at this point");
 						return;
@@ -458,7 +453,7 @@ export class SelectorController {
 						this.ctx.chatContainer.clear();
 						this.ctx.renderInitialMessages();
 						await this.ctx.reloadTodos();
-						if (result.editorText) {
+						if (result.editorText && !this.ctx.editor.getText().trim()) {
 							this.ctx.editor.setText(result.editorText);
 						}
 						this.ctx.showStatus("Navigated to selected point");
@@ -552,7 +547,7 @@ export class SelectorController {
 					done();
 
 					if (mode === "login") {
-						this.ctx.showStatus(`Logging in to ${providerId}...`);
+						this.ctx.showStatus(`Logging in to ${providerId}…`);
 
 						try {
 							await this.ctx.session.modelRegistry.authStorage.login(providerId as OAuthProvider, {

package/src/modes/interactive-mode.ts

@@ -17,12 +17,13 @@ import {
 } from "@oh-my-pi/pi-tui";
 import { $env, isEnoent, logger, postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { APP_NAME } from "../config";
 import { KeybindingsManager } from "../config/keybindings";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import { type Settings, settings } from "../config/settings";
 import type { ExtensionUIContext, ExtensionUIDialogOptions } from "../extensibility/extensions";
 import type { CompactOptions } from "../extensibility/extensions/types";
-import { loadSlashCommands } from "../extensibility/slash-commands";
+import { BUILTIN_SLASH_COMMANDS, loadSlashCommands } from "../extensibility/slash-commands";
 import { resolvePlanUrlToPath } from "../internal-urls";
 import planModeApprovedPrompt from "../prompts/system/plan-mode-approved.md" with { type: "text" };
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
@@ -173,6 +174,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.mcpManager = mcpManager;
 
 		this.ui = new TUI(new ProcessTerminal(), settings.get("showHardwareCursor"));
+		this.ui.setClearOnShrink(settings.get("clearOnShrink"));
 		setMermaidRenderCallback(() => this.ui.requestRender());
 		this.chatContainer = new Container();
 		this.pendingMessagesContainer = new Container();
@@ -199,39 +201,10 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		this.hideThinkingBlock = settings.get("hideThinkingBlock");
 
-		// Define slash commands for autocomplete
-		const slashCommands: SlashCommand[] = [
-			{ name: "settings", description: "Open settings menu" },
-			{ name: "plan", description: "Toggle plan mode (agent plans before executing)" },
-			{ name: "model", description: "Select model (opens selector UI)" },
-			{ name: "export", description: "Export session to HTML file" },
-			{ name: "dump", description: "Copy session transcript to clipboard" },
-			{ name: "share", description: "Share session as a secret GitHub gist" },
-			{ name: "browser", description: "Toggle browser headless vs visible mode" },
-			{ name: "copy", description: "Copy last agent message to clipboard" },
-			{ name: "session", description: "Show session info and stats" },
-			{ name: "usage", description: "Show provider usage and limits" },
-			{ name: "extensions", description: "Open Extension Control Center dashboard" },
-			{ name: "status", description: "Alias for /extensions" },
-			{ name: "changelog", description: "Show changelog entries" },
-			{ name: "hotkeys", description: "Show all keyboard shortcuts" },
-			{ name: "branch", description: "Create a new branch from a previous message" },
-			{ name: "tree", description: "Navigate session tree (switch branches)" },
-			{ name: "login", description: "Login with OAuth provider" },
-			{ name: "logout", description: "Logout from OAuth provider" },
-			{ name: "new", description: "Start a new session" },
-			{ name: "fork", description: "Duplicate current session into a new session" },
-			{ name: "compact", description: "Manually compact the session context" },
-			{ name: "handoff", description: "Hand off the session context to a new session" },
-			{ name: "background", description: "Detach UI and continue running in background" },
-			{ name: "bg", description: "Alias for /background" },
-			{ name: "resume", description: "Resume a different session" },
-			{ name: "debug", description: "Write debug log (TUI state and messages)" },
-			{ name: "exit", description: "Exit the application" },
-		];
-
-		// Convert hook commands to SlashCommand format
-		const hookCommands: SlashCommand[] = (this.session.extensionRunner?.getRegisteredCommands() ?? []).map(cmd => ({
+		const builtinCommandNames = new Set(BUILTIN_SLASH_COMMANDS.map(c => c.name));
+		const hookCommands: SlashCommand[] = (
+			this.session.extensionRunner?.getRegisteredCommands(builtinCommandNames) ?? []
+		).map(cmd => ({
 			name: cmd.name,
 			description: cmd.description ?? "(hook command)",
 			getArgumentCompletions: cmd.getArgumentCompletions,
@@ -254,7 +227,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 
 		// Store pending commands for init() where file commands are loaded async
-		this.pendingSlashCommands = [...slashCommands, ...hookCommands, ...customCommands, ...skillCommandList];
+		this.pendingSlashCommands = [...BUILTIN_SLASH_COMMANDS, ...hookCommands, ...customCommands, ...skillCommandList];
 
 		this.uiHelpers = new UiHelpers(this);
 		this.extensionUiController = new ExtensionUiController(this);
@@ -373,6 +346,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		// Initialize hooks with TUI-based UI context
 		await this.initHooksAndCustomTools();
 
+		// Restore mode from session (e.g. plan mode on resume)
+		await this.restoreModeFromSession();
+
 		// Subscribe to agent events
 		this.subscribeToAgent();
 
@@ -416,7 +392,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	updateEditorTopBorder(): void {
-		const width = this.ui.getWidth();
+		const width = this.ui.terminal.columns;
 		const topBorder = this.statusLine.getTopBorder(width);
 		this.editor.setTopBorder(topBorder);
 	}
@@ -561,6 +537,19 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 	}
 
+	/** Restore mode state from session entries on resume (e.g. plan mode). */
+	private async restoreModeFromSession(): Promise<void> {
+		const sessionContext = this.sessionManager.buildSessionContext();
+		if (sessionContext.mode === "plan") {
+			const planFilePath = sessionContext.modeData?.planFilePath as string | undefined;
+			await this.enterPlanMode({ planFilePath });
+		} else if (sessionContext.mode === "plan_paused") {
+			this.planModePaused = true;
+			this.planModeHasEntered = true;
+			this.updatePlanModeStatus();
+		}
+	}
+
 	private async enterPlanMode(options?: {
 		planFilePath?: string;
 		workflow?: "parallel" | "iterative";
@@ -594,6 +583,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.planModeHasEntered = true;
 		await this.applyPlanModeModel();
 		this.updatePlanModeStatus();
+		this.sessionManager.appendModeChange("plan", { planFilePath });
 		this.showStatus(`Plan mode enabled. Plan file: ${planFilePath}`);
 	}
 
@@ -621,8 +611,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.planModePreviousTools = undefined;
 		this.planModePreviousModel = undefined;
 		this.updatePlanModeStatus();
+		const paused = options?.paused ?? false;
+		this.sessionManager.appendModeChange(paused ? "plan_paused" : "none");
 		if (!options?.silent) {
-			this.showStatus(this.planModePaused ? "Plan mode paused." : "Plan mode disabled.");
+			this.showStatus(paused ? "Plan mode paused." : "Plan mode disabled.");
 		}
 	}
 
@@ -735,10 +727,26 @@ export class InteractiveMode implements InteractiveModeContext {
 		await this.session.emitCustomToolSessionEvent("shutdown");
 
 		if (this.isInitialized) {
-			await this.ui.waitForRender();
+			this.ui.requestRender(true);
 		}
 
+		// Wait for any pending renders to complete
+		// requestRender() uses process.nextTick(), so we wait one tick
+		await new Promise(resolve => process.nextTick(resolve));
+
+		// Drain any in-flight Kitty key release events before stopping.
+		// This prevents escape sequences from leaking to the parent shell over slow SSH.
+		await this.ui.terminal.drainInput(1000);
+
 		this.stop();
+
+		// Print resumption hint if this is a persisted session
+		const sessionId = this.sessionManager.getSessionId();
+		const sessionFile = this.sessionManager.getSessionFile();
+		if (sessionId && sessionFile) {
+			process.stderr.write(`\n${chalk.dim(`Resume this session with ${APP_NAME} --resume ${sessionId}`)}\n`);
+		}
+
 		await postmortem.quit(0);
 	}
 
@@ -1011,6 +1019,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.inputController.toggleToolOutputExpansion();
 	}
 
+	setToolsExpanded(expanded: boolean): void {
+		this.inputController.setToolsExpanded(expanded);
+	}
+
 	toggleThinkingBlockVisibility(): void {
 		this.inputController.toggleThinkingBlockVisibility();
 	}

package/src/modes/print-mode.ts

@@ -63,6 +63,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				getActiveTools: () => session.getActiveToolNames(),
 				getAllTools: () => session.getAllToolNames(),
 				setActiveTools: (toolNames: string[]) => session.setActiveToolsByName(toolNames),
+				getCommands: () => [],
 				setModel: async model => {
 					const key = await session.modelRegistry.getApiKey(model);
 					if (!key) return false;
@@ -80,6 +81,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 				hasPendingMessages: () => session.queuedMessageCount > 0,
 				shutdown: () => {},
 				getContextUsage: () => session.getContextUsage(),
+				getSystemPrompt: () => session.systemPrompt,
 				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =
@@ -108,6 +110,10 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 					const result = await session.navigateTree(targetId, { summarize: options?.summarize });
 					return { cancelled: result.cancelled };
 				},
+				switchSession: async sessionPath => {
+					const success = await session.switchSession(sessionPath);
+					return { cancelled: !success };
+				},
 				compact: async instructionsOrOptions => {
 					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
 					const options =

package/src/modes/rpc/rpc-client.ts

@@ -189,15 +189,15 @@ export class RpcClient {
 	/**
 	 * Queue a steering message to interrupt the agent mid-run.
 	 */
-	async steer(message: string): Promise<void> {
-		await this.send({ type: "steer", message });
+	async steer(message: string, images?: ImageContent[]): Promise<void> {
+		await this.send({ type: "steer", message, images });
 	}
 
 	/**
 	 * Queue a follow-up message to be processed after the agent finishes.
 	 */
-	async followUp(message: string): Promise<void> {
-		await this.send({ type: "follow_up", message });
+	async followUp(message: string, images?: ImageContent[]): Promise<void> {
+		await this.send({ type: "follow_up", message, images });
 	}
 
 	/**