@xopcai/xopc 0.0.103 → 0.0.104

package/dist/src/tui/tui.js

@@ -1,23 +1,39 @@
 import { version } from "../../package.js";
+import { resolveStateDir, resolveXopcDatabasePath } from "../config/paths-state.js";
+import { init_paths } from "../config/paths.js";
 import { loadConfig } from "../config/loader.js";
 import { parseAgentSessionKey } from "../routing/session-key-utils.js";
 import { init_agent_session_key } from "../routing/agent-session-key.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
+import { getAllModels, getAllProviders, getApiKey, init_providers, isProviderConfiguredSync } from "../providers/index.js";
 import "../config/index.js";
+import { MAX_WEBCHAT_ATTACHMENT_FILE_BYTES } from "../gateway/chat-limits.js";
+import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../project-trust/trust-store.js";
 import { resolveTuiSessionKey, resolveTuiStartupSessionKey } from "../routing/resolve-tui-session-key.js";
-import { saveClipboardImageToTempFile } from "./clipboard-image.js";
-import { createXopcTuiKeybindingsManager } from "./tui-keybindings-file.js";
-import { StreamAssembler } from "./stream-assembler.js";
-import { applyThemeById, getBashExcludeBorderColor, getBashModeBorderColor, getThinkingBorderColor, initTuiTheme } from "./theme-manager.js";
+import { applyThemeById, getBashExcludeBorderColor, getBashModeBorderColor, getCustomThemesDir, getThemeExports, getThinkingBorderColor, initTuiTheme, listAvailableThemeIds, resolveThemePalette } from "./theme-manager.js";
 import { editorTheme, theme } from "./theme.js";
-import { clearPendingToolCallIds, dispatchAgentSSE } from "./tui-agent-events.js";
+import { extensionForImageMimeType, readClipboardImage } from "./clipboard-image.js";
+import { copyTextToClipboard } from "./clipboard-text.js";
+import { createXopcTuiKeybindingsManager } from "./tui-keybindings-file.js";
+import { formatKeyIds } from "./format-tui-hotkeys.js";
+import { isActiveRunStreamStale, markActiveRunStalled, markRunRecovering, markRunRecoveryComplete, markRunSending } from "./tui-run-state.js";
+import { clearSeenStreamEvents, clearSeenStreamEventsForRun, dispatchAgentEvent } from "./tui-agent-events.js";
+import { transcriptTreeEntryIdToRowNumber } from "./tui-transcript-tree.js";
+import { formatTuiCompactionResult, formatTuiShareResult } from "./tui-command-formatters.js";
+import { formatTuiStartupText } from "./tui-startup-text.js";
 import { createTuiCommandHandler, getSlashCommands } from "./tui-commands.js";
+import { extensionCustomMessageContentToText, extensionCustomMessageToTurnText, extensionUserMessageContentToText } from "./tui-extension-user-message.js";
 import { resolveFdPath } from "./tui-fd-path.js";
+import { drainFollowUpQueue, restoreQueuedMessages } from "./tui-follow-up-queue.js";
 import { createBackspaceDeduper, drainAndStopTuiSafely, isIgnorableTuiStopError, resolveCtrlCAction, stopTuiSafely } from "./tui-lifecycle.js";
 import { createLocalShellRunner } from "./tui-local-shell.js";
-import { createOverlayHandlers } from "./tui-overlays.js";
 import { filterModelsForCycle, loadScopedModelRefs, saveScopedModelRefs } from "./tui-scoped-models.js";
-import { openModelPickerOverlay, openScopedModelsOverlay, openSessionPickerOverlay, openSettingsOverlay } from "./tui-picker-overlay.js";
+import { openModelPickerOverlay } from "./tui-model-picker.js";
+import { runTuiOAuthLogin } from "./tui-oauth-login.js";
+import { openAgentPickerOverlay, openProjectTrustOverlay, openScopedModelsOverlay, openSessionPickerOverlay, openSessionTreeOverlay, openSettingsOverlay, openThinkingSelectorOverlay, openTranscriptTreeOverlay, openUserMessageForkOverlay } from "./tui-picker-overlay.js";
+import { formatBusyResponseHint, formatSteerUnavailableHint, formatSuspendUnsupportedHint } from "./tui-runtime-hints.js";
 import { createSessionActions } from "./tui-session-actions.js";
+import { TuiSessionSnapshot } from "./tui-session-snapshot.js";
 import { loadTuiSettings, saveTuiSettings } from "./tui-settings.js";
 import { installTuiStdioFilter } from "./tui-stdio-filter.js";
 import { createEditorSubmitHandler, createSubmitBurstCoalescer, shouldEnableWindowsGitBashPasteFallback } from "./tui-submit.js";
@@ -31,13 +47,17 @@ import { TuiBottomBar } from "./components/tui-bottom-bar.js";
 import { TuiHeader } from "./components/tui-header.js";
 import { loadExtensionsForTuiLocalMode } from "./extension-host/load-extensions.js";
 import { createTuiExtensionRuntime } from "./extension-host/runtime.js";
-import { mkdtempSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { Container, Loader, ProcessTerminal, TUI, setKeybindings } from "@earendil-works/pi-tui";
+import { Buffer } from "node:buffer";
 //#region src/tui/tui.ts
+init_paths();
 init_agent_session_key();
+init_providers();
 const THINK_LEVEL_CYCLE = [
 	"off",
 	"minimal",
@@ -54,12 +74,102 @@ function nextThinkLevel(current) {
 	return THINK_LEVEL_CYCLE[((idx >= 0 ? idx : mediumIdx >= 0 ? mediumIdx : 0) + 1) % THINK_LEVEL_CYCLE.length];
 }
 const DOUBLE_ESCAPE_WINDOW_MS = 500;
+function escapeHtml(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function exportExtension(format) {
+	if (format === "json") return "json";
+	if (format === "markdown") return "md";
+	return "html";
+}
+function wrapMarkdownExportAsHtml(markdown) {
+	return [
+		"<!doctype html>",
+		"<html>",
+		"<head>",
+		"<meta charset=\"utf-8\">",
+		"<title>xopc session export</title>",
+		"<style>body{font:14px/1.5 system-ui,sans-serif;margin:32px;max-width:960px}pre{white-space:pre-wrap}</style>",
+		"</head>",
+		"<body>",
+		"<pre>",
+		escapeHtml(markdown),
+		"</pre>",
+		"</body>",
+		"</html>",
+		""
+	].join("\n");
+}
+function defaultExportPath(sessionKey, format) {
+	const safeKey = sessionKey.replace(/[^a-z0-9_.-]+/gi, "_").replace(/^_+|_+$/g, "") || "session";
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	return resolve(process.cwd(), `xopc-session-${safeKey}-${stamp}.${exportExtension(format)}`);
+}
+function userDisplayContentForAttachments(text, attachments) {
+	if (!attachments?.length) return text;
+	const blocks = [];
+	if (text.trim()) blocks.push({
+		type: "text",
+		text
+	});
+	for (const att of attachments) {
+		if (att.mimeType?.startsWith("image/") || att.type === "image" || att.type === "photo") {
+			blocks.push({
+				type: "image",
+				name: att.name
+			});
+			continue;
+		}
+		blocks.push({
+			type: "file",
+			name: att.name
+		});
+	}
+	return blocks;
+}
+function shellQuote(value) {
+	if (/^[A-Za-z0-9_/:@%+=,.-]+$/.test(value)) return value;
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function formatTuiResumeCommand(opts, sessionKey) {
+	const parts = ["xopc", "tui"];
+	if (opts.local === true) parts.push("--local");
+	if (opts.url) parts.push("--url", shellQuote(opts.url));
+	parts.push("--session", shellQuote(sessionKey));
+	return parts.join(" ");
+}
+function isLoopbackGatewayUrl(rawUrl) {
+	try {
+		const hostname = new URL(rawUrl).hostname.toLowerCase();
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+function resolveStartupWorkingDirectory(opts, isLocalMode) {
+	const explicit = opts.workdir?.trim();
+	if (explicit) return resolve(explicit);
+	if (opts.useStartupCwd === false || opts.session?.trim()) return;
+	const gatewayUrl = opts.url ?? "http://localhost:3120";
+	if (isLocalMode || isLoopbackGatewayUrl(gatewayUrl)) return process.cwd();
+}
+function assistantMessagePlainText(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((block) => {
+		if (!block || typeof block !== "object") return "";
+		const rec = block;
+		return rec.type === "text" && typeof rec.text === "string" ? rec.text : "";
+	}).join("");
+}
 async function runTui(opts) {
 	const stdioFilter = installTuiStdioFilter();
 	const restoreStdio = () => stdioFilter.restore();
 	const isLocalMode = opts.local === true;
+	const config = loadConfig();
 	const startup = resolveTuiStartupSessionKey({
-		cfg: loadConfig(),
+		cfg: config,
 		sessionOption: opts.session,
 		cwd: process.cwd()
 	});
@@ -75,16 +185,41 @@ async function runTui(opts) {
 	let tuiSettings = loadTuiSettings();
 	initTuiTheme({ themeId: opts.theme ?? tuiSettings.theme });
 	const state = createInitialState(startup.sessionKey);
+	const projectTrustStore = new ProjectTrustStore();
+	let projectTrustSessionDecision = null;
+	const isCurrentProjectTrusted = () => {
+		if (projectTrustSessionDecision !== null) return projectTrustSessionDecision;
+		if (!hasTrustRequiringProjectResources(process.cwd())) return true;
+		return projectTrustStore.get(process.cwd()) === true;
+	};
+	let projectTrustPromptShown = false;
+	const sessionStateDir = resolveStateDir();
+	const sessionDatabasePath = resolveXopcDatabasePath();
+	const sessionSnapshot = new TuiSessionSnapshot(() => state.currentSessionKey, () => process.cwd(), () => state.sessionInfo.displayName, () => `${sessionDatabasePath}#session=${encodeURIComponent(state.currentSessionKey)}`, () => sessionStateDir);
 	state.scopedModelRefs = loadScopedModelRefs();
 	state.showThinking = tuiSettings.showThinking;
 	state.toolsExpanded = tuiSettings.toolsExpanded;
-	const assembler = new StreamAssembler();
+	let pendingImageAttachments = [];
+	const pendingNextTurnCustomMessages = [];
+	let lastRetryMessageText = null;
+	let setExtensionLabel = (_entryId, _label) => {};
+	let sendExtensionUserMessage = (_content, _options) => {};
+	let appendExtensionEntry = (_customType, _data) => {};
+	let sendExtensionMessage = (_message, _options) => {};
 	let extensionRegistry;
-	if (isLocalMode) extensionRegistry = await loadExtensionsForTuiLocalMode();
+	if (isLocalMode) extensionRegistry = await loadExtensionsForTuiLocalMode({
+		setLabel: (entryId, label) => setExtensionLabel(entryId, label),
+		sendUserMessage: (content, options) => sendExtensionUserMessage(content, options),
+		appendEntry: (customType, data) => appendExtensionEntry(customType, data),
+		sendMessage: (message, options) => sendExtensionMessage(message, options)
+	});
 	const client = isLocalMode ? new EmbeddedBackend({ extensionRegistry }) : new GatewaySseBackend({
 		url: opts.url ?? "http://localhost:3120",
 		token: opts.token
 	});
+	const startupWorkingDirectory = resolveStartupWorkingDirectory(opts, isLocalMode);
+	if (startupWorkingDirectory) state.sessionInfo.effectiveWorkspacePath = startupWorkingDirectory;
+	let startupWorkingDirectoryApplied = false;
 	const keybindings = createXopcTuiKeybindingsManager();
 	setKeybindings(keybindings);
 	let modelChoices = [];
@@ -94,6 +229,8 @@ async function runTui(opts) {
 		tui.requestRender();
 	};
 	const tui = new TUI(new ProcessTerminal());
+	tui.setShowHardwareCursor(tuiSettings.showHardwareCursor);
+	tui.setClearOnShrink(tuiSettings.clearOnShrink);
 	const dedupeBackspace = createBackspaceDeduper();
 	tui.addInputListener((data) => {
 		const next = dedupeBackspace(data);
@@ -105,17 +242,108 @@ async function runTui(opts) {
 		connectionLabel: client.connectionLabel,
 		sessionKey: state.currentSessionKey,
 		showHints: tuiSettings.showStartupHints
-	}));
+	}), keybindings);
 	const statusContainer = new Container();
-	const bottomBar = new TuiBottomBar(() => state, () => opts.thinking);
-	const chatLog = new ChatLog();
+	const bottomBar = new TuiBottomBar(() => state, () => opts.thinking, () => formatKeyIds(keybindings, "app.message.dequeue", { capitalize: true }));
+	const chatLog = new ChatLog(keybindings);
+	let startupResources;
+	let startupCardShown = false;
+	chatLog.setShowThinking(state.showThinking);
 	chatLog.setToolsExpanded(state.toolsExpanded);
-	const editor = new CustomEditor(tui, editorTheme, keybindings);
+	chatLog.setToolImageOptions({
+		showImages: tuiSettings.showImages,
+		imageWidthCells: tuiSettings.imageWidthCells,
+		cwd: process.cwd()
+	});
+	setExtensionLabel = (entryId, label) => {
+		sessionSnapshot.setLabel(entryId, label);
+		client.setTranscriptLabel(state.currentSessionKey, entryId, label).catch((err) => {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Label update failed: ${errorMessage}`);
+		}).finally(() => {
+			updateFooter();
+			tui.requestRender();
+		});
+	};
+	appendExtensionEntry = (customType, data) => {
+		const normalized = customType.trim();
+		if (!normalized) throw new Error("appendEntry requires customType.");
+		sessionSnapshot.appendCustomEntry(normalized, data);
+		client.appendCustomEntry(state.currentSessionKey, normalized, data).catch((err) => {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Custom entry append failed: ${errorMessage}`);
+		}).finally(() => {
+			updateFooter();
+			tui.requestRender();
+		});
+	};
+	sendExtensionMessage = (message, options) => {
+		const customType = message.customType.trim();
+		if (!customType) throw new Error("sendMessage requires customType.");
+		const display = message.display ?? true;
+		const nextMessage = {
+			customType,
+			content: message.content,
+			display,
+			details: message.details
+		};
+		sessionSnapshot.appendCustomMessage(nextMessage);
+		if (display) {
+			chatLog.addCustomMessage({
+				customType,
+				content: extensionCustomMessageContentToText(message.content),
+				rawContent: message.content,
+				details: message.details,
+				display
+			});
+			tui.requestRender();
+		}
+		const persist = client.appendCustomMessage(state.currentSessionKey, nextMessage).catch((err) => {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Custom message append failed: ${errorMessage}`);
+			throw err;
+		}).finally(() => {
+			updateFooter();
+			tui.requestRender();
+		});
+		const turnText = extensionCustomMessageToTurnText(nextMessage).trim();
+		if (!turnText) return;
+		persist.then(() => {
+			const controlText = `Continue with the extension message "${customType}" above.`;
+			if (options?.deliverAs === "nextTurn") {
+				pendingNextTurnCustomMessages.push(controlText);
+				chatLog.addSystem(theme.dim(`Queued extension message for next turn (${pendingNextTurnCustomMessages.length}).`));
+				bottomBar.invalidate();
+				tui.requestRender();
+				return;
+			}
+			if (state.activeRunId) {
+				if (options?.deliverAs === "followUp") {
+					state.messageFollowUpQueue.push(controlText);
+					chatLog.addSystem(theme.dim(`Queued extension follow-up (${state.messageFollowUpQueue.length} in queue). ${tuiSettings.followUpMode === "all" ? "All queued messages send together when this reply finishes." : "Next sends when this reply finishes."}`));
+					bottomBar.invalidate();
+					tui.requestRender();
+					return;
+				}
+				steerMessage(turnText);
+				return;
+			}
+			if (options?.triggerTurn) sendMessage(controlText);
+		}).catch(() => {});
+	};
+	const defaultEditor = new CustomEditor(tui, editorTheme, keybindings, {
+		paddingX: tuiSettings.editorPaddingX,
+		autocompleteMaxVisible: tuiSettings.autocompleteMaxVisible
+	});
+	let editor = defaultEditor;
+	let editorComponentFactory;
+	const editorContainer = new Container();
+	editorContainer.addChild(editor);
 	const root = new Container();
 	root.addChild(header);
 	root.addChild(chatLog);
 	root.addChild(statusContainer);
-	root.addChild(editor);
+	root.addChild(editorContainer);
 	root.addChild(bottomBar);
 	tui.addChild(root);
 	tui.setFocus(editor);
@@ -123,7 +351,10 @@ async function runTui(opts) {
 	let isBashExcludeContext = false;
 	const updateEditorBorderColor = () => {
 		if (isBashMode) editor.borderColor = isBashExcludeContext ? getBashExcludeBorderColor() : getBashModeBorderColor();
-		else editor.borderColor = getThinkingBorderColor(state.sessionInfo.thinkingLevel ?? opts.thinking ?? "off");
+		else {
+			const level = state.sessionInfo.thinkingLevel ?? opts.thinking ?? "off";
+			editor.borderColor = getThinkingBorderColor(level);
+		}
 		tui.requestRender();
 	};
 	editor.onChange = (text) => {
@@ -136,8 +367,330 @@ async function runTui(opts) {
 			updateEditorBorderColor();
 		}
 	};
-	const { openOverlay, closeOverlay } = createOverlayHandlers(tui, editor);
-	const slashCommands = getSlashCommands(isLocalMode);
+	const copyDefaultEditorAppHandlers = (target) => {
+		const customEditor = target;
+		if (!(customEditor.actionHandlers instanceof Map)) return;
+		customEditor.onEscape ??= () => defaultEditor.onEscape?.();
+		customEditor.onCtrlD ??= () => defaultEditor.onCtrlD?.();
+		customEditor.onPasteImage ??= () => defaultEditor.onPasteImage?.();
+		customEditor.onExtensionShortcut ??= (data) => defaultEditor.onExtensionShortcut?.(data) ?? false;
+		for (const [action, handler] of defaultEditor.actionHandlers) customEditor.actionHandlers.set(action, handler);
+	};
+	const setEditorExtensionShortcut = () => {
+		const customEditor = editor;
+		customEditor.onExtensionShortcut = (data) => extensionRuntime.handleShortcut(data);
+	};
+	const setEditorComponent = (factory) => {
+		editorComponentFactory = factory;
+		const currentText = editor.getText();
+		editorContainer.clear();
+		if (factory) {
+			const nextEditor = factory(tui, editorTheme, keybindings);
+			nextEditor.onSubmit = defaultEditor.onSubmit;
+			nextEditor.onChange = defaultEditor.onChange;
+			nextEditor.setText(currentText);
+			if (nextEditor.borderColor !== void 0) nextEditor.borderColor = defaultEditor.borderColor;
+			nextEditor.setPaddingX?.(tuiSettings.editorPaddingX);
+			nextEditor.setAutocompleteMaxVisible?.(tuiSettings.autocompleteMaxVisible);
+			nextEditor.setAutocompleteProvider?.(extensionRuntime.autocompleteProvider);
+			copyDefaultEditorAppHandlers(nextEditor);
+			editor = nextEditor;
+		} else {
+			defaultEditor.setText(currentText);
+			editor = defaultEditor;
+		}
+		editorContainer.addChild(editor);
+		setEditorExtensionShortcut();
+		tui.setFocus(editor);
+		updateEditorBorderColor();
+		tui.requestRender();
+	};
+	let activeEditorSelectorClose = null;
+	const closeEditorSelector = () => {
+		activeEditorSelectorClose?.();
+	};
+	const openEditorSelector = (component, focus = component) => {
+		closeEditorSelector();
+		editorContainer.clear();
+		editorContainer.addChild(component);
+		tui.setFocus(focus);
+		tui.requestRender();
+		const close = () => {
+			if (activeEditorSelectorClose !== close) return;
+			activeEditorSelectorClose = null;
+			editorContainer.clear();
+			editorContainer.addChild(editor);
+			tui.setFocus(editor);
+			tui.requestRender();
+		};
+		activeEditorSelectorClose = close;
+		return close;
+	};
+	const openCommandOverlay = (component, _options) => {
+		let hidden = false;
+		let closeCurrent = openEditorSelector(component, component);
+		return {
+			hide: () => closeCurrent(),
+			setHidden: (nextHidden) => {
+				hidden = nextHidden;
+				if (nextHidden) closeCurrent();
+				else closeCurrent = openEditorSelector(component, component);
+			},
+			isHidden: () => hidden,
+			focus: () => tui.setFocus(component),
+			unfocus: () => tui.setFocus(editor),
+			isFocused: () => false
+		};
+	};
+	const closeCommandOverlay = () => {
+		closeEditorSelector();
+	};
+	const slashCommands = getSlashCommands(isLocalMode, keybindings);
+	let extensionWorkingMessage;
+	let extensionWorkingVisible = true;
+	let extensionWorkingIndicator;
+	const getAllExtensionThemes = () => {
+		const customDir = getCustomThemesDir();
+		return listAvailableThemeIds().map((name) => ({
+			name,
+			path: name === "auto" || name === "dark" || name === "light" ? void 0 : join(customDir, `${name}.json`)
+		}));
+	};
+	const getExtensionTheme = (name) => {
+		const normalized = name.trim().toLowerCase() || "auto";
+		if (!listAvailableThemeIds().includes(normalized)) return void 0;
+		const currentTheme = tuiSettings.theme;
+		applyThemeById(normalized);
+		const resolved = getThemeExports().theme;
+		applyThemeById(currentTheme);
+		return resolved;
+	};
+	const setExtensionTheme = (nextTheme) => {
+		const normalized = nextTheme.trim().toLowerCase() || "auto";
+		if (!listAvailableThemeIds().includes(normalized)) return {
+			success: false,
+			error: `Unknown theme: ${nextTheme}`
+		};
+		try {
+			resolveThemePalette(normalized);
+			tuiSettings = {
+				...tuiSettings,
+				theme: normalized
+			};
+			saveTuiSettings(tuiSettings);
+			applyThemeById(normalized);
+			updateEditorBorderColor();
+			chatLog.invalidate();
+			header.invalidate();
+			bottomBar.invalidate();
+			tui.requestRender();
+			return { success: true };
+		} catch (err) {
+			return {
+				success: false,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	};
+	const getAvailableProviderCount = () => getAllProviders().filter((provider) => isProviderConfiguredSync(provider)).length;
+	const getExtensionSystemPrompt = () => resolveEffectiveAgentProfileForSession(config, state.currentSessionKey).systemPromptOverride ?? "";
+	const waitForTuiIdle = async () => {
+		while (state.activeRunId != null || state.isCompacting || state.activityStatus === "sending" || state.activityStatus === "waiting" || state.activityStatus === "streaming" || state.activityStatus === "running" || state.activityStatus === "compacting") await new Promise((resolveDelay) => setTimeout(resolveDelay, 50));
+	};
+	const createReplacementContext = () => {
+		const model = state.sessionInfo.model ? {
+			...state.sessionInfo.modelProvider ? { provider: state.sessionInfo.modelProvider } : {},
+			id: state.sessionInfo.model,
+			ref: state.sessionInfo.modelProvider ? `${state.sessionInfo.modelProvider}/${state.sessionInfo.model}` : state.sessionInfo.model,
+			contextWindow: state.sessionInfo.contextWindow ?? null
+		} : void 0;
+		return {
+			mode: "tui",
+			hasUI: true,
+			signal: client.getActiveSignal?.(),
+			ui: {
+				select: async () => void 0,
+				confirm: async () => false,
+				input: async () => void 0,
+				notify: (message, level) => {
+					const prefix = level === "error" ? "Error: " : level === "warn" || level === "warning" ? "Warning: " : "";
+					chatLog.addSystem(`${prefix}${message}`);
+					tui.requestRender();
+				},
+				onTerminalInput: (handler) => tui.addInputListener(handler),
+				setStatus: () => {},
+				setWorkingMessage: (message) => {
+					extensionWorkingMessage = message?.trim() || void 0;
+					renderStatus();
+				},
+				setWorkingVisible: (visible) => {
+					extensionWorkingVisible = visible;
+					renderStatus();
+				},
+				setWorkingIndicator: (indicator) => {
+					extensionWorkingIndicator = indicator ?? void 0;
+					statusLoader?.setIndicator(indicator ?? void 0);
+					renderStatus();
+				},
+				setHiddenThinkingLabel: (label) => {
+					chatLog.setHiddenThinkingLabel(label ?? void 0);
+					tui.requestRender();
+				},
+				setWidget: () => {},
+				setFooter: () => {},
+				setHeader: () => {},
+				custom: async () => void 0,
+				setTitle: (title) => tui.terminal.setTitle(title),
+				pasteToEditor: (text) => editor.handleInput(`\x1b[200~${text}\x1b[201~`),
+				setEditorText: (text) => editor.setText(text),
+				getEditorText: () => editor.getExpandedText?.() ?? editor.getText(),
+				editor: async () => void 0,
+				addAutocompleteProvider: () => () => {},
+				setEditorComponent,
+				getEditorComponent: () => editorComponentFactory,
+				theme,
+				getAllThemes: getAllExtensionThemes,
+				getTheme: getExtensionTheme,
+				setTheme: setExtensionTheme,
+				getToolsExpanded: () => state.toolsExpanded,
+				setToolsExpanded: (expanded) => {
+					state.toolsExpanded = expanded;
+					tuiSettings = {
+						...tuiSettings,
+						toolsExpanded: expanded
+					};
+					saveTuiSettings(tuiSettings);
+					chatLog.setToolsExpanded(expanded);
+					updateFooter();
+					tui.requestRender();
+				}
+			},
+			sessionManager: sessionSnapshot.manager(),
+			modelRegistry: {
+				find(provider, modelId) {
+					return getAllModels().find((candidate) => candidate.provider === provider && candidate.id === modelId);
+				},
+				async getApiKeyAndHeaders(nextModel) {
+					const provider = typeof nextModel.provider === "string" ? nextModel.provider : void 0;
+					if (!provider) return {
+						ok: false,
+						error: "Model provider is missing."
+					};
+					try {
+						return {
+							ok: true,
+							apiKey: await getApiKey(provider),
+							headers: {}
+						};
+					} catch (error) {
+						return {
+							ok: false,
+							error: error instanceof Error ? error.message : String(error)
+						};
+					}
+				}
+			},
+			model,
+			cwd: process.cwd(),
+			sessionKey: state.currentSessionKey,
+			isProjectTrusted: isCurrentProjectTrusted,
+			isIdle: () => !state.activeRunId && !state.isCompacting,
+			hasPendingMessages: () => state.messageFollowUpQueue.length > 0 || state.steeringQueue.length > 0 || state.compactionQueue.length > 0,
+			abort: () => abortActive(),
+			shutdown: () => requestExit(),
+			compact: (options) => runCompaction(options?.customInstructions, {
+				onComplete: options?.onComplete,
+				onError: options?.onError
+			}),
+			getSystemPrompt: getExtensionSystemPrompt,
+			getSystemPromptOptions: () => ({
+				cwd: process.cwd(),
+				sessionKey: state.currentSessionKey,
+				...model ? { model } : {}
+			}),
+			waitForIdle: waitForTuiIdle,
+			newSession: (options) => runExtensionNewSession(options),
+			fork: (entryId, options) => runExtensionFork(entryId, options),
+			navigateTree: (targetId, options) => runExtensionNavigateTree(targetId, options),
+			switchSession: (sessionPath, options) => runExtensionSwitchSession(sessionPath, options),
+			reload: async () => {
+				await loadSessionHistory({ merge: true });
+				await refreshSessionInfoWithBorder();
+			},
+			getModel: () => model,
+			setModel: (modelRef) => switchCurrentModel(modelRef),
+			getThinkingLevel: () => state.sessionInfo.thinkingLevel,
+			setThinkingLevel,
+			getReasoningLevel: () => state.sessionInfo.reasoningLevel,
+			setReasoningLevel,
+			getVerboseLevel: () => state.sessionInfo.verboseLevel,
+			setVerboseLevel,
+			getCommands: () => slashCommands.map((command) => ({
+				name: command.name,
+				description: command.description,
+				source: "builtin"
+			})),
+			getContextUsage: () => {
+				const tokens = state.sessionInfo.totalTokens ?? state.sessionInfo.contextTokens ?? null;
+				const contextWindow = state.sessionInfo.contextWindow ?? null;
+				const percent = state.sessionInfo.contextUsagePercent ?? null;
+				if (tokens == null && contextWindow == null) return void 0;
+				return {
+					estimatedTokens: tokens,
+					tokens,
+					contextWindow,
+					usagePercent: percent,
+					percent
+				};
+			},
+			notify: (message, level) => {
+				const prefix = level === "error" ? "Error: " : level === "warn" || level === "warning" ? "Warning: " : "";
+				chatLog.addSystem(`${prefix}${message}`);
+				tui.requestRender();
+			},
+			sendMessage: async (message, options) => sendExtensionMessage(message, options),
+			sendUserMessage: async (content, options) => sendExtensionUserMessage(content, options)
+		};
+	};
+	const runWithReplacementContext = async (callback) => {
+		if (callback) await callback(createReplacementContext());
+	};
+	const runExtensionNewSession = async (options) => {
+		await abortActive({ clearUi: false });
+		await setSession(resolveSessionKey(`session-${randomUUID()}`));
+		await options?.setup?.(sessionSnapshot.manager());
+		await runWithReplacementContext(options?.withSession);
+		return { cancelled: false };
+	};
+	const runExtensionFork = async (entryId, options) => {
+		const rowNumber = transcriptTreeEntryIdToRowNumber(entryId);
+		if (rowNumber == null) throw new Error(`Invalid entry ID for forking: ${entryId}`);
+		const throughRow = options?.position === "before" ? rowNumber - 1 : rowNumber;
+		if (throughRow <= 0) throw new Error(`Invalid entry ID for forking: ${entryId}`);
+		const sourceSessionKey = state.currentSessionKey;
+		const targetKey = resolveSessionKey(`fork-${randomUUID()}`);
+		await abortActive({ clearUi: false });
+		const result = await client.forkSessionAt(sourceSessionKey, targetKey, `row-${throughRow}`);
+		await setSession(result.sessionKey);
+		chatLog.addBranchSummary({
+			sourceSessionKey,
+			targetSessionKey: result.sessionKey,
+			rowCount: result.rowCount,
+			entryId
+		});
+		await runWithReplacementContext(options?.withSession);
+		return { cancelled: false };
+	};
+	const runExtensionNavigateTree = async (targetId, options) => {
+		if (options?.label) setExtensionLabel(targetId, options.label);
+		return runExtensionFork(targetId, { position: "at" });
+	};
+	const runExtensionSwitchSession = async (sessionPath, options) => {
+		await abortActive({ clearUi: false });
+		await setSession(sessionPath);
+		await runWithReplacementContext(options?.withSession);
+		return { cancelled: false };
+	};
 	const extensionRuntime = createTuiExtensionRuntime({
 		registry: extensionRegistry,
 		tui,
@@ -146,17 +699,91 @@ async function runTui(opts) {
 		bottomBar,
 		getState: () => state,
 		baseSlashCommands: slashCommands,
+		keybindings,
+		addInputListener: (handler) => tui.addInputListener(handler),
+		setTitle: (title) => tui.terminal.setTitle(title),
+		pasteToEditor: (text) => editor.handleInput(`\x1b[200~${text}\x1b[201~`),
+		setEditorText: (text) => editor.setText(text),
+		getEditorText: () => editor.getExpandedText?.() ?? editor.getText(),
+		setEditorComponent,
+		getEditorComponent: () => editorComponentFactory,
+		getThemeObject: () => theme,
+		getAllThemes: getAllExtensionThemes,
+		getTheme: getExtensionTheme,
+		setTheme: setExtensionTheme,
+		getToolsExpanded: () => state.toolsExpanded,
+		setToolsExpanded: (expanded) => {
+			state.toolsExpanded = expanded;
+			tuiSettings = {
+				...tuiSettings,
+				toolsExpanded: expanded
+			};
+			saveTuiSettings(tuiSettings);
+			chatLog.setToolsExpanded(expanded);
+			updateFooter();
+			tui.requestRender();
+		},
+		getAvailableProviderCount,
+		getActiveSignal: () => client.getActiveSignal?.(),
+		isProjectTrusted: isCurrentProjectTrusted,
+		getSessionManager: () => sessionSnapshot.manager(),
+		getSystemPrompt: getExtensionSystemPrompt,
+		getSystemPromptOptions: () => ({
+			cwd: process.cwd(),
+			sessionKey: state.currentSessionKey,
+			...state.sessionInfo.model ? { model: {
+				...state.sessionInfo.modelProvider ? { provider: state.sessionInfo.modelProvider } : {},
+				id: state.sessionInfo.model,
+				ref: state.sessionInfo.modelProvider ? `${state.sessionInfo.modelProvider}/${state.sessionInfo.model}` : state.sessionInfo.model,
+				contextWindow: state.sessionInfo.contextWindow ?? null
+			} } : {}
+		}),
+		waitForIdle: waitForTuiIdle,
+		newSession: runExtensionNewSession,
+		forkSession: runExtensionFork,
+		navigateTree: runExtensionNavigateTree,
+		switchSession: runExtensionSwitchSession,
+		reload: async () => {
+			await loadSessionHistory();
+			await refreshSessionInfoWithBorder();
+		},
+		sendUserMessage: async (content, options) => sendExtensionUserMessage(content, options),
+		sendMessage: async (message, options) => sendExtensionMessage(message, options),
 		cwd: process.cwd(),
 		fdPath: resolveFdPath(),
-		openOverlay,
-		closeOverlay,
+		openOverlay: openCommandOverlay,
+		closeOverlay: closeCommandOverlay,
 		onInvalidate: () => {
 			updateHeader();
 			updateFooter();
 			tui.requestRender();
+		},
+		abortActive: () => abortActive(),
+		requestExit: () => requestExit(),
+		compactSession: (options) => runCompaction(options?.customInstructions, {
+			onComplete: options?.onComplete,
+			onError: options?.onError
+		}),
+		setModel: (modelRef) => switchCurrentModel(modelRef),
+		setThinkingLevel: (level) => setThinkingLevel(level),
+		setReasoningLevel: (level) => setReasoningLevel(level),
+		setVerboseLevel: (level) => setVerboseLevel(level),
+		setWorkingMessage: (message) => {
+			extensionWorkingMessage = message?.trim() || void 0;
+			renderStatus();
+		},
+		setWorkingVisible: (visible) => {
+			extensionWorkingVisible = visible;
+			renderStatus();
+		},
+		setWorkingIndicator: (indicator) => {
+			extensionWorkingIndicator = indicator;
+			statusLoader?.setIndicator(indicator);
+			renderStatus();
 		}
 	});
-	editor.setAutocompleteProvider(extensionRuntime.autocompleteProvider);
+	editor.setAutocompleteProvider?.(extensionRuntime.autocompleteProvider);
+	setEditorExtensionShortcut();
 	let statusLoader = null;
 	let statusStartedAt = null;
 	let lastActivityStatus = "";
@@ -166,7 +793,8 @@ async function runTui(opts) {
 		"waiting",
 		"streaming",
 		"running",
-		"compacting"
+		"compacting",
+		"recovering"
 	]);
 	const syncTerminalProgress = () => {
 		if (!tuiSettings.showTerminalProgress) {
@@ -179,6 +807,11 @@ async function runTui(opts) {
 	let streamWatchdogId = null;
 	const touchStreamingActivity = () => {
 		lastStreamActivityAt = Date.now();
+		if (state.activeRunId && state.runStatus.lastActivityAt == null) state.runStatus = {
+			...state.runStatus,
+			runId: state.activeRunId,
+			lastActivityAt: lastStreamActivityAt
+		};
 	};
 	const formatElapsed = (startMs) => {
 		const totalSeconds = Math.max(0, Math.floor((Date.now() - startMs) / 1e3));
@@ -186,24 +819,29 @@ async function runTui(opts) {
 		return `${Math.floor(totalSeconds / 60)}m ${totalSeconds % 60}s`;
 	};
 	const renderStatus = () => {
-		if (busyStates.has(state.activityStatus)) {
+		const isBusy = busyStates.has(state.activityStatus);
+		if (isBusy && extensionWorkingVisible) {
 			if (!statusStartedAt || lastActivityStatus !== state.activityStatus) statusStartedAt = Date.now();
 			if (!statusLoader) {
 				statusContainer.clear();
-				statusLoader = new Loader(tui, (spinner) => theme.accent(spinner), (text) => theme.bold(theme.accentSoft(text)), "");
+				statusLoader = new Loader(tui, (spinner) => theme.accent(spinner), (text) => theme.bold(theme.accentSoft(text)), "", extensionWorkingIndicator);
 				statusContainer.addChild(statusLoader);
 			}
 			const elapsed = formatElapsed(statusStartedAt);
-			statusLoader.setMessage(`${state.progressMessage ?? state.activityStatus} • ${elapsed} | ${state.connectionStatus}`);
+			const loaderMessage = state.progressMessage ?? extensionWorkingMessage ?? state.activityStatus;
+			statusLoader.setMessage(`${loaderMessage} • ${elapsed} | ${state.connectionStatus}`);
 			if (!elapsedTimerId) elapsedTimerId = setInterval(() => {
 				if (statusStartedAt && statusLoader) {
 					const el = formatElapsed(statusStartedAt);
-					statusLoader.setMessage(`${state.progressMessage ?? state.activityStatus} • ${el} | ${state.connectionStatus}`);
+					const message = state.progressMessage ?? extensionWorkingMessage ?? state.activityStatus;
+					statusLoader.setMessage(`${message} • ${el} | ${state.connectionStatus}`);
 				}
 			}, 1e3);
 		} else {
-			state.progressMessage = null;
-			statusStartedAt = null;
+			if (!isBusy) {
+				state.progressMessage = null;
+				statusStartedAt = null;
+			}
 			if (elapsedTimerId) {
 				clearInterval(elapsedTimerId);
 				elapsedTimerId = null;
@@ -262,6 +900,7 @@ async function runTui(opts) {
 		tui.terminal.setProgress(false);
 		drainAndStopTuiSafely(tui).then(() => {
 			restoreStdio();
+			process.stdout.write(`\nTo resume this session: ${formatTuiResumeCommand(opts, state.currentSessionKey)}\n`);
 			finishTui?.();
 			process.exit(0);
 		});
@@ -271,11 +910,11 @@ async function runTui(opts) {
 		chatLog,
 		tui,
 		state,
-		assembler,
 		resolveSessionKey,
 		updateHeader,
 		updateFooter,
 		setActivityStatus,
+		sessionSnapshot,
 		onAgentIdChange: (agentId) => {
 			currentAgentId = agentId;
 		}
@@ -284,6 +923,166 @@ async function runTui(opts) {
 		await refreshSessionInfo();
 		updateEditorBorderColor();
 	};
+	const refreshStartupResources = async () => {
+		if (!client.getStartupResources) return;
+		try {
+			startupResources = await client.getStartupResources(state.currentSessionKey);
+		} catch {
+			startupResources = void 0;
+		}
+	};
+	const showStartupCardOnce = () => {
+		if (startupCardShown) return;
+		startupCardShown = true;
+		chatLog.addSystem(formatTuiStartupText({
+			state,
+			isLocal: isLocalMode,
+			keybindings,
+			resources: startupResources,
+			expanded: false
+		}));
+	};
+	const applyStartupWorkingDirectory = async () => {
+		if (startupWorkingDirectoryApplied || !startupWorkingDirectory) return;
+		startupWorkingDirectoryApplied = true;
+		await client.patchSession(state.currentSessionKey, { workingDirectory: startupWorkingDirectory });
+		state.sessionInfo.effectiveWorkspacePath = startupWorkingDirectory;
+		state.sessionInfo.workingDirectoryLocked = true;
+	};
+	let streamRecoveryPromise = null;
+	const recoverActiveRunFromHistory = (reason) => {
+		if (!state.activeRunId) return Promise.resolve();
+		if (streamRecoveryPromise) return streamRecoveryPromise;
+		const runId = state.activeRunId;
+		markRunRecovering(state, Date.now());
+		state.progressMessage = "recovering stream history";
+		setActivityStatus("recovering");
+		streamRecoveryPromise = (async () => {
+			try {
+				await loadSessionHistory();
+				await refreshSessionInfoWithBorder();
+				if (state.activeRunId === runId) {
+					clearSeenStreamEventsForRun(runId);
+					if (client.resumeChat) {
+						const resumed = await client.resumeChat({
+							sessionKey: state.currentSessionKey,
+							runId
+						});
+						if (resumed.ok) {
+							state.progressMessage = "resuming stream";
+							setActivityStatus("recovering");
+							chatLog.addSystem(theme.dim(`Reattached to active run after ${reason}.`));
+						} else {
+							markRunRecoveryComplete(state, Date.now());
+							state.progressMessage = "stream stalled; resume unavailable";
+							setActivityStatus("stalled");
+							chatLog.addSystem(theme.dim(`Recovered persisted history after ${reason}, but could not resume stream: ${resumed.reason ?? "run relay unavailable"}. Press Escape or /abort to stop it.`));
+						}
+					} else {
+						markRunRecoveryComplete(state, Date.now());
+						state.progressMessage = "stream stalled; waiting for new events or abort";
+						setActivityStatus("stalled");
+						chatLog.addSystem(theme.dim(`Recovered persisted history after ${reason}. Active run is still marked stalled; press Escape or /abort to stop it.`));
+					}
+				}
+			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
+				chatLog.addSystem(theme.dim(`Stream recovery failed after ${reason}: ${errorMessage}`));
+				if (state.activeRunId === runId) {
+					markRunRecoveryComplete(state, Date.now());
+					setActivityStatus("stalled");
+				}
+			} finally {
+				streamRecoveryPromise = null;
+				updateFooter();
+				tui.requestRender();
+			}
+		})();
+		return streamRecoveryPromise;
+	};
+	const setThinkingLevel = async (level) => {
+		try {
+			await client.patchSession(state.currentSessionKey, { thinkingLevel: level });
+			state.sessionInfo.thinkingLevel = level;
+			await refreshSessionInfoWithBorder();
+			updateFooter();
+			chatLog.addStatus(theme.dim(`Thinking level: ${level}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Thinking level change failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const setReasoningLevel = async (level) => {
+		try {
+			await client.patchSession(state.currentSessionKey, { reasoningLevel: level });
+			state.sessionInfo.reasoningLevel = level;
+			await refreshSessionInfoWithBorder();
+			updateFooter();
+			chatLog.addStatus(theme.dim(`Reasoning visibility: ${level}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Reasoning visibility change failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const setVerboseLevel = async (level) => {
+		try {
+			await client.patchSession(state.currentSessionKey, { verboseLevel: level });
+			state.sessionInfo.verboseLevel = level;
+			await refreshSessionInfoWithBorder();
+			updateFooter();
+			chatLog.addStatus(theme.dim(`Verbose mode: ${level}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Verbose mode change failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const copyLastAssistant = async () => {
+		const text = chatLog.getLastAssistantText().trim();
+		if (!text) {
+			chatLog.addSystem("No assistant messages to copy yet.");
+			tui.requestRender();
+			return;
+		}
+		try {
+			await copyTextToClipboard(text);
+			chatLog.addStatus(theme.dim("Copied last assistant message to clipboard"));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Copy failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const renameCurrentSession = async (name) => {
+		const nextName = name.trim();
+		if (!nextName) {
+			chatLog.addSystem("Usage: /name <name>");
+			tui.requestRender();
+			return;
+		}
+		try {
+			if (!(await client.renameSession(state.currentSessionKey, nextName)).ok) {
+				chatLog.addSystem("Session rename failed.");
+				tui.requestRender();
+				return;
+			}
+			state.sessionInfo.displayName = nextName;
+			updateFooter();
+			updateHeader();
+			chatLog.addStatus(theme.dim(`Session name set: ${nextName}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Session rename failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
 	const resolveModelChoiceIndex = () => {
 		const choices = cycleModelChoices();
 		if (choices.length === 0) return -1;
@@ -315,11 +1114,140 @@ async function runTui(opts) {
 		}
 		const idx = resolveModelChoiceIndex();
 		const next = choices[((idx >= 0 ? idx : 0) + (dir === "forward" ? 1 : -1) + choices.length) % choices.length];
-		sendMessage(`/switch ${next.provider}/${next.id}`);
+		switchCurrentModel(`${next.provider}/${next.id}`);
+	};
+	const listCurrentModels = async () => {
+		if (modelChoices.length === 0) await refreshModelChoices();
+		return modelChoices;
+	};
+	const switchCurrentModel = async (modelRef) => {
+		const trimmed = modelRef.trim();
+		if (!trimmed.includes("/")) {
+			chatLog.addSystem("Usage: /switch <provider/model>");
+			tui.requestRender();
+			return;
+		}
+		if (modelChoices.length === 0) await refreshModelChoices();
+		const [provider, id] = trimmed.split("/", 2);
+		const selected = modelChoices.find((choice) => choice.provider === provider && choice.id === id);
+		if (!selected) {
+			chatLog.addSystem(`Model not found: ${trimmed}`);
+			tui.requestRender();
+			return;
+		}
+		try {
+			await client.patchSession(state.currentSessionKey, { model: trimmed });
+			state.sessionInfo.modelProvider = selected.provider;
+			state.sessionInfo.model = selected.id;
+			if (selected.contextWindow != null) state.sessionInfo.contextWindow = selected.contextWindow;
+			await refreshSessionInfoWithBorder();
+			updateFooter();
+			updateHeader();
+			chatLog.addStatus(theme.dim(`Model: ${trimmed}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Model switch failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const exportCurrentSession = async (request) => {
+		const outputPath = request.outputPath ? isAbsolute(request.outputPath) ? request.outputPath : resolve(process.cwd(), request.outputPath) : defaultExportPath(state.currentSessionKey, request.format);
+		try {
+			const backendFormat = request.format === "json" ? "json" : "markdown";
+			const raw = await client.exportSession(state.currentSessionKey, backendFormat);
+			const content = request.format === "html" ? wrapMarkdownExportAsHtml(raw) : raw;
+			mkdirSync(dirname(outputPath), { recursive: true });
+			writeFileSync(outputPath, content, "utf8");
+			chatLog.addStatus(theme.dim(`Exported ${request.format} session to: ${outputPath}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Export failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const importSessionExport = async (request) => {
+		const rawPath = request.inputPath?.trim();
+		if (!rawPath) {
+			chatLog.addSystem("Usage: /import <path.json> [target-session]");
+			tui.requestRender();
+			return;
+		}
+		const inputPath = isAbsolute(rawPath) ? rawPath : resolve(process.cwd(), rawPath);
+		const targetKey = resolveSessionKey(request.targetKey?.trim() || `import-${randomUUID()}`);
+		try {
+			const content = readFileSync(inputPath, "utf8");
+			const result = await client.importSession(targetKey, content);
+			await setSession(result.sessionKey);
+			chatLog.addStatus(theme.dim(`Imported ${result.rowCount} transcript rows from: ${inputPath}`));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Import failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const createShareLink = async (request) => {
+		try {
+			chatLog.addStatus(theme.dim(`Creating share for: ${request.path}`));
+			tui.requestRender();
+			const result = await client.createShare(state.currentSessionKey, request, { agentId: currentAgentId });
+			chatLog.addSystem(formatTuiShareResult(result));
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Share failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
+	};
+	const runBtwQuery = async (question) => {
+		const previousStatus = state.activityStatus;
+		try {
+			setActivityStatus("waiting");
+			state.progressMessage = "btw";
+			const result = await client.btwQuery(state.currentSessionKey, question);
+			if (result.error) {
+				chatLog.addSystem(`BTW failed: ${result.error}`);
+				return;
+			}
+			chatLog.addSystem(`BTW\n\n${result.text}`);
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`BTW failed: ${errorMessage}`);
+		} finally {
+			state.activityStatus = previousStatus;
+			renderStatus();
+			tui.requestRender();
+		}
+	};
+	const forkCurrentSession = async (rawKey) => {
+		const targetKey = resolveSessionKey(rawKey?.trim() || `fork-${randomUUID()}`);
+		if (targetKey === state.currentSessionKey) {
+			chatLog.addSystem("Fork target must be different from the current session.");
+			tui.requestRender();
+			return;
+		}
+		const sourceSessionKey = state.currentSessionKey;
+		try {
+			await abortActive({ clearUi: false });
+			const result = await client.forkSession(sourceSessionKey, targetKey);
+			await setSession(result.sessionKey);
+			chatLog.addBranchSummary({
+				sourceSessionKey,
+				targetSessionKey: result.sessionKey,
+				rowCount: result.rowCount
+			});
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Fork failed: ${errorMessage}`);
+		} finally {
+			tui.requestRender();
+		}
 	};
 	const handleCtrlZ = () => {
 		if (process.platform === "win32") {
-			chatLog.addSystem("Suspend (Ctrl+Z) is not supported on Windows.");
+			chatLog.addSystem(formatSuspendUnsupportedHint(keybindings));
 			tui.requestRender();
 			return;
 		}
@@ -361,7 +1289,8 @@ async function runTui(opts) {
 		})();
 	};
 	const isAgentBusy = () => state.activeRunId != null || state.isCompacting || busyStates.has(state.activityStatus);
-	const steerMessage = (text) => {
+	let steeringInFlightForRunId = null;
+	const sendSteeringToActiveRun = (text) => {
 		chatLog.addUser(text);
 		touchStreamingActivity();
 		tui.requestRender();
@@ -369,7 +1298,7 @@ async function runTui(opts) {
 			sessionKey: state.currentSessionKey,
 			message: text
 		}).then(({ ok }) => {
-			if (!ok) chatLog.addSystem(theme.dim("Could not steer — no active run or steer failed. Press Escape to abort, or Alt+Enter to queue a follow-up."));
+			if (!ok) chatLog.addSystem(theme.dim(formatSteerUnavailableHint(keybindings)));
 			else chatLog.addSystem(theme.dim("Steered — message injects at the next tool boundary (pi-style)."));
 			tui.requestRender();
 		}).catch((error) => {
@@ -378,52 +1307,117 @@ async function runTui(opts) {
 			tui.requestRender();
 		});
 	};
+	const flushSteeringQueue = () => {
+		if (state.exitRequested) return;
+		if (state.activeRunId) return;
+		const next = drainFollowUpQueue(state.steeringQueue, tuiSettings.steeringMode);
+		if (next === void 0) return;
+		sendMessage(next);
+	};
+	const steerMessage = (text) => {
+		if (!state.activeRunId) {
+			sendMessage(text);
+			return;
+		}
+		if (steeringInFlightForRunId === state.activeRunId) {
+			state.steeringQueue.push(text);
+			chatLog.addSystem(theme.dim(`Queued steering (${state.steeringQueue.length} in queue). ${tuiSettings.steeringMode === "all" ? "All queued steering sends together after this reply." : "Next sends after this reply."}`));
+			bottomBar.invalidate();
+			tui.requestRender();
+			return;
+		}
+		steeringInFlightForRunId = state.activeRunId;
+		sendSteeringToActiveRun(text);
+	};
 	const sendMessage = (text) => {
+		if (state.activeRunId && pendingImageAttachments.length > 0) {
+			chatLog.addSystem(theme.dim("Image attachments cannot be steered into an active run. Wait for this reply to finish, then send."));
+			tui.requestRender();
+			return;
+		}
+		const pendingCustomText = pendingNextTurnCustomMessages.splice(0).join("\n\n").trim();
+		const messageText = [text, pendingCustomText].filter(Boolean).join("\n\n");
+		const attachments = pendingImageAttachments;
+		pendingImageAttachments = [];
 		if (state.isCompacting) {
-			state.compactionQueue.push(text);
+			state.compactionQueue.push(messageText);
+			if (attachments.length > 0) pendingImageAttachments.unshift(...attachments);
 			chatLog.addSystem(theme.dim(`Queued during compaction (${state.compactionQueue.length}). Sends when compact finishes.`));
 			bottomBar.invalidate();
 			tui.requestRender();
 			return;
 		}
 		if (state.activeRunId) {
-			chatLog.addSystem("A response is still in progress. Press Enter to steer, Alt+Enter to queue, or Escape to abort.");
+			chatLog.addSystem(formatBusyResponseHint(keybindings));
+			if (pendingCustomText) pendingNextTurnCustomMessages.unshift(pendingCustomText);
+			if (attachments.length > 0) pendingImageAttachments.unshift(...attachments);
 			tui.requestRender();
 			return;
 		}
-		chatLog.addUser(text);
+		chatLog.addUser(userDisplayContentForAttachments(text, attachments));
+		sessionSnapshot.appendMessage("user", messageText);
+		lastRetryMessageText = messageText;
+		markRunSending(state);
 		setActivityStatus("sending");
 		touchStreamingActivity();
 		tui.requestRender();
 		client.sendChat({
 			sessionKey: state.currentSessionKey,
-			message: text,
+			message: messageText,
+			attachments: attachments.length > 0 ? attachments : void 0,
 			thinking: opts.thinking
 		}).catch((error) => {
 			const errorMessage = error instanceof Error ? error.message : String(error);
+			if (attachments.length > 0) pendingImageAttachments.unshift(...attachments);
 			chatLog.addSystem(`❌ Failed to send: ${errorMessage}`);
 			setActivityStatus("idle");
 			tui.requestRender();
 		});
 	};
-	const runCompaction = async () => {
-		if (state.isCompacting) return;
+	sendExtensionUserMessage = (content, options) => {
+		const text = extensionUserMessageContentToText(content).trim();
+		if (!text) throw new Error("sendUserMessage requires text content.");
+		if (!state.activeRunId) {
+			sendMessage(text);
+			return;
+		}
+		if (options?.deliverAs === "steer") {
+			steerMessage(text);
+			return;
+		}
+		if (options?.deliverAs === "followUp") {
+			state.messageFollowUpQueue.push(text);
+			chatLog.addSystem(theme.dim(`Queued follow-up (${state.messageFollowUpQueue.length} in queue). ${tuiSettings.followUpMode === "all" ? "All queued messages send together when this reply finishes." : "Next sends when this reply finishes."}`));
+			bottomBar.invalidate();
+			tui.requestRender();
+			return;
+		}
+		throw new Error("Agent is busy. Use deliverAs: \"steer\" or \"followUp\".");
+	};
+	const runCompaction = async (instructions, callbacks) => {
+		if (state.isCompacting) return void 0;
 		state.isCompacting = true;
 		setActivityStatus("compacting");
-		chatLog.addSystem(theme.dim("Compacting session…"));
+		chatLog.addSystem(theme.dim(instructions ? `Compacting session with instructions: ${instructions}` : "Compacting session…"));
 		tui.requestRender();
 		try {
-			const result = await client.compactSession(state.currentSessionKey, { force: true });
-			chatLog.addSystem(result.summary ?? (result.compacted ? "Session compacted" : "Nothing to compact"));
+			const result = await client.compactSession(state.currentSessionKey, {
+				force: true,
+				instructions
+			});
 			if (result.compacted) {
-				assembler.clear();
-				clearPendingToolCallIds();
+				clearSeenStreamEvents();
 				state.historyLoaded = false;
 				await loadSessionHistory();
-			}
+				chatLog.addCompactionSummary(result);
+			} else chatLog.addSystem(formatTuiCompactionResult(result));
+			callbacks?.onComplete?.(result);
+			return result;
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error);
 			chatLog.addSystem(`❌ Compaction failed: ${errorMessage}`);
+			callbacks?.onError?.(error instanceof Error ? error : new Error(errorMessage));
+			return;
 		} finally {
 			state.isCompacting = false;
 			setActivityStatus("idle");
@@ -439,7 +1433,21 @@ async function runTui(opts) {
 		saveTuiSettings(tuiSettings);
 		state.showThinking = tuiSettings.showThinking;
 		state.toolsExpanded = tuiSettings.toolsExpanded;
+		chatLog.setShowThinking(tuiSettings.showThinking);
 		chatLog.setToolsExpanded(tuiSettings.toolsExpanded);
+		chatLog.setToolImageOptions({
+			showImages: tuiSettings.showImages,
+			imageWidthCells: tuiSettings.imageWidthCells,
+			cwd: process.cwd()
+		});
+		tui.setShowHardwareCursor(tuiSettings.showHardwareCursor);
+		tui.setClearOnShrink(tuiSettings.clearOnShrink);
+		defaultEditor.setPaddingX(tuiSettings.editorPaddingX);
+		defaultEditor.setAutocompleteMaxVisible(tuiSettings.autocompleteMaxVisible);
+		if (editor !== defaultEditor) {
+			editor.setPaddingX?.(tuiSettings.editorPaddingX);
+			editor.setAutocompleteMaxVisible?.(tuiSettings.autocompleteMaxVisible);
+		}
 		applyThemeById(tuiSettings.theme);
 		header.invalidate();
 		updateEditorBorderColor();
@@ -452,74 +1460,189 @@ async function runTui(opts) {
 		updateEditorBorderColor();
 		tui.requestRender();
 	};
-	const reloadKeybindings = () => {
+	const reloadTuiRuntime = async () => {
+		if (state.activeRunId) throw new Error("Wait for the current response to finish before reloading.");
+		if (state.isCompacting) throw new Error("Wait for compaction to finish before reloading.");
 		keybindings.reload();
 		setKeybindings(keybindings);
+		applyTuiSettings(loadTuiSettings());
+		extensionRuntime.dispose();
+		await extensionRuntime.activate();
+		editor.setAutocompleteProvider?.(extensionRuntime.autocompleteProvider);
+		setEditorExtensionShortcut();
+		updateHeader();
+		updateFooter();
 		tui.requestRender();
 	};
 	const uiOverlays = {
+		openModelPicker: (_initialSearch) => {},
+		openAgentPicker: () => {},
 		openSessionPicker: () => {},
+		openSessionTree: () => {},
+		openTranscriptTree: () => {},
+		openUserMessageFork: () => {},
 		openScopedModels: () => {},
+		openThinkingSelector: () => {},
 		openSettings: () => {},
-		reloadKeybindings: () => reloadKeybindings()
+		openProjectTrust: () => {},
+		reloadKeybindings: () => reloadTuiRuntime()
+	};
+	const recoverCurrentStream = async () => {
+		if (state.activeRunId) {
+			await recoverActiveRunFromHistory("manual recover");
+			return;
+		}
+		await loadSessionHistory({ merge: true });
+		await refreshSessionInfoWithBorder();
+		chatLog.addSystem(theme.dim("Reloaded persisted history; no active run to recover."));
+		tui.requestRender();
+	};
+	const retryLastMessage = async () => {
+		const message = lastRetryMessageText?.trim();
+		if (!message) {
+			chatLog.addSystem("No previous user message to retry.");
+			return;
+		}
+		if (state.activeRunId) await abortActive({ clearUi: false });
+		sendMessage(message);
+	};
+	const switchAgentSession = async (sessionKey, agentId) => {
+		const previousWorkspace = state.sessionInfo.effectiveWorkspacePath?.trim();
+		await setSession(sessionKey);
+		await refreshStartupResources();
+		if (previousWorkspace && state.sessionInfo.workingDirectoryLocked !== true) try {
+			await client.patchSession(state.currentSessionKey, { workingDirectory: previousWorkspace });
+			state.sessionInfo.effectiveWorkspacePath = previousWorkspace;
+			state.sessionInfo.workingDirectoryLocked = true;
+			await refreshSessionInfoWithBorder();
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			chatLog.addSystem(`Switched agent, but workspace was not copied: ${errorMessage}`);
+		}
+		currentAgentId = agentId;
+		updateHeader();
+		updateFooter();
 	};
 	const handleCommand = createTuiCommandHandler({
 		state,
 		chatLog,
 		tui,
-		assembler,
 		isLocalMode,
 		abortActive,
 		sendMessage,
 		requestExit,
 		updateFooter,
 		keybindings,
+		recoverStream: recoverCurrentStream,
+		retryLastMessage,
 		uiOverlays,
+		setThinkingLevel,
+		setReasoningLevel,
+		setVerboseLevel,
+		copyLastAssistant,
+		renameCurrentSession,
 		runCompaction,
+		listModels: listCurrentModels,
+		switchModel: switchCurrentModel,
+		listSessions: () => client.listSessions(),
+		listAgents: () => client.listAgents(),
+		switchAgentSession,
+		getSessionStats: () => client.getSessionStats(state.currentSessionKey),
+		getStartupResources: () => startupResources,
+		loadTranscriptTree: () => client.loadTranscriptTree(state.currentSessionKey),
+		exportSession: exportCurrentSession,
+		importSession: importSessionExport,
+		createShare: createShareLink,
+		runBtwQuery,
+		forkSession: forkCurrentSession,
 		extensionSlashCommands: extensionRuntime.slashCommands,
+		extensionShortcuts: extensionRuntime.shortcuts,
 		currentAgentId,
-		setSession,
-		resetSession: resetCurrentSession
+		setSession: async (rawKey) => {
+			await setSession(rawKey);
+			await refreshStartupResources();
+		},
+		resetSession: resetCurrentSession,
+		projectTrust: {
+			cwd: process.cwd(),
+			hasProjectResources: () => hasTrustRequiringProjectResources(process.cwd()),
+			getStorePath: () => projectTrustStore.getPath(),
+			getEntry: () => projectTrustStore.getEntry(process.cwd()),
+			getSessionDecision: () => projectTrustSessionDecision
+		},
+		runLogin: (provider) => runTuiOAuthLogin(provider, {
+			chatLog,
+			tui,
+			editor,
+			openOverlay: openCommandOverlay,
+			closeOverlay: closeCommandOverlay,
+			keybindings
+		})
 	});
 	const { runLocalShellLine } = createLocalShellRunner({
 		chatLog,
 		tui,
 		editor,
-		openOverlay,
-		closeOverlay,
+		openOverlay: openCommandOverlay,
+		closeOverlay: closeCommandOverlay,
 		pauseStdioFilter: () => stdioFilter.pause(),
 		resumeStdioFilter: () => stdioFilter.resume(),
 		runWithInheritedStdio: async (work) => {
 			await withTuiSuspended(tui, work);
+		},
+		keybindings,
+		getCwd: () => {
+			const workspace = state.sessionInfo.effectiveWorkspacePath?.trim();
+			if (!workspace) throw new Error("Workspace is not loaded yet.");
+			return workspace;
+		},
+		onComplete: async (entry) => {
+			await client.appendBashExecution(state.currentSessionKey, entry).catch((err) => {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				chatLog.addSystem(`Bash transcript append failed: ${errorMessage}`);
+			}).finally(() => {
+				updateFooter();
+				tui.requestRender();
+			});
 		}
 	});
 	const submitBurst = createSubmitBurstCoalescer({
 		submit: createEditorSubmitHandler({
-			editor,
+			editor: {
+				setText: (value) => editor.setText(value),
+				addToHistory: (value) => editor.addToHistory?.(value)
+			},
 			handleCommand,
 			sendMessage,
 			handleBangLine: runLocalShellLine,
 			isAgentBusy,
-			steerWhileBusy: steerMessage
+			steerWhileBusy: steerMessage,
+			hasPendingAttachments: () => pendingImageAttachments.length > 0,
+			defaultAttachmentMessage: "Please analyze the attached image."
 		}),
 		enabled: shouldEnableWindowsGitBashPasteFallback()
 	});
-	editor.onSubmit = submitBurst;
+	defaultEditor.onSubmit = submitBurst;
 	const flushFollowUpQueue = () => {
 		if (state.exitRequested) return;
 		if (state.activeRunId) return;
-		const next = state.messageFollowUpQueue.shift();
+		const next = drainFollowUpQueue(state.messageFollowUpQueue, tuiSettings.followUpMode);
 		if (next === void 0) return;
 		sendMessage(next);
 	};
 	const handleFollowUp = () => {
 		const text = editor.getText().trim();
-		if (!text) return;
+		if (!text && pendingImageAttachments.length === 0) return;
 		if (isAgentBusy()) {
+			if (pendingImageAttachments.length > 0) {
+				chatLog.addSystem(theme.dim("Image attachments cannot be queued while the agent is busy. Wait for this reply to finish, then send."));
+				tui.requestRender();
+				return;
+			}
 			editor.addToHistory(text);
 			state.messageFollowUpQueue.push(text);
 			editor.setText("");
-			chatLog.addSystem(theme.dim(`Queued follow-up (${state.messageFollowUpQueue.length} in queue). Next sends when this reply finishes.`));
+			chatLog.addSystem(theme.dim(`Queued follow-up (${state.messageFollowUpQueue.length} in queue). ${tuiSettings.followUpMode === "all" ? "All queued messages send together when this reply finishes." : "Next sends when this reply finishes."}`));
 			bottomBar.invalidate();
 			tui.requestRender();
 			return;
@@ -527,17 +1650,17 @@ async function runTui(opts) {
 		submitBurst(text);
 	};
 	const handleDequeue = () => {
-		if (state.messageFollowUpQueue.length === 0) {
-			chatLog.addSystem(theme.dim("No queued messages to restore."));
+		const restored = restoreQueuedMessages({
+			steeringQueue: state.steeringQueue,
+			followUpQueue: state.messageFollowUpQueue
+		}, editor.getText());
+		if (restored.restoredCount === 0) {
+			chatLog.addStatus(theme.dim("No queued messages to restore."));
 			tui.requestRender();
 			return;
 		}
-		const queued = [...state.messageFollowUpQueue];
-		state.messageFollowUpQueue.length = 0;
-		const current = editor.getText().trim();
-		const combined = [queued.join("\n\n"), current].filter(Boolean).join("\n\n");
-		editor.setText(combined);
-		chatLog.addSystem(theme.dim(`Restored ${queued.length} queued message${queued.length > 1 ? "s" : ""} to editor.`));
+		editor.setText(restored.text);
+		chatLog.addStatus(theme.dim(`Restored ${restored.restoredCount} queued message${restored.restoredCount > 1 ? "s" : ""} to editor.`));
 		bottomBar.invalidate();
 		tui.requestRender();
 	};
@@ -583,17 +1706,21 @@ async function runTui(opts) {
 	const pickerSvc = {
 		tui,
 		editor,
-		openOverlay,
-		closeOverlay,
+		openOverlay: openCommandOverlay,
+		closeOverlay: closeCommandOverlay,
 		chatLog,
 		client,
 		sendMessage,
+		switchModel: switchCurrentModel,
+		openEditorSelector,
 		refreshSessionInfo,
 		updateHeader,
 		state,
 		setSessionKey,
+		switchAgentSession,
 		clearChatForSessionSwitch,
 		loadSessionHistory,
+		setEditorText: (text) => editor.setText(text),
 		setModelChoices,
 		getScopedModelRefs: () => state.scopedModelRefs,
 		setScopedModelRefs: (refs) => {
@@ -604,24 +1731,40 @@ async function runTui(opts) {
 		getTuiSettings: () => ({ ...tuiSettings }),
 		applyTuiSettings,
 		previewTheme,
-		reloadKeybindings
+		reloadKeybindings: reloadTuiRuntime,
+		setThinkingLevel,
+		getProjectTrustStore: () => projectTrustStore,
+		getProjectTrustSessionDecision: () => projectTrustSessionDecision,
+		setProjectTrustSessionDecision: (decision) => {
+			projectTrustSessionDecision = decision;
+		},
+		keybindings
 	};
+	uiOverlays.openModelPicker = (initialSearch) => void openModelPickerOverlay(pickerSvc, initialSearch);
+	uiOverlays.openAgentPicker = () => void openAgentPickerOverlay(pickerSvc);
 	uiOverlays.openSessionPicker = () => void openSessionPickerOverlay(pickerSvc);
+	uiOverlays.openSessionTree = () => void openSessionTreeOverlay(pickerSvc);
+	uiOverlays.openTranscriptTree = () => void openTranscriptTreeOverlay(pickerSvc);
+	uiOverlays.openUserMessageFork = () => void openUserMessageForkOverlay(pickerSvc);
 	uiOverlays.openScopedModels = () => void openScopedModelsOverlay(pickerSvc);
+	uiOverlays.openThinkingSelector = () => openThinkingSelectorOverlay(pickerSvc);
 	uiOverlays.openSettings = () => openSettingsOverlay(pickerSvc);
+	uiOverlays.openProjectTrust = () => openProjectTrustOverlay(pickerSvc);
+	const showSessionTree = () => {
+		uiOverlays.openTranscriptTree();
+	};
 	const handleDoubleEscape = () => {
 		switch (tuiSettings.doubleEscapeAction) {
 			case "tree":
-				chatLog.addSystem(theme.dim("Session tree is not available in xopc TUI yet."));
+				showSessionTree();
 				break;
 			case "fork":
-				chatLog.addSystem(theme.dim("Session fork is not available in xopc TUI yet."));
+				uiOverlays.openUserMessageFork();
 				break;
 			default: break;
 		}
-		tui.requestRender();
 	};
-	editor.onEscape = () => {
+	defaultEditor.onEscape = () => {
 		if (state.activeRunId) {
 			abortActive();
 			return;
@@ -635,19 +1778,20 @@ async function runTui(opts) {
 		}
 		state.lastEscapeAt = now;
 	};
-	editor.onCtrlD = () => requestExit();
-	editor.onAction("app.clear", handleCtrlC);
-	editor.onAction("app.exit", () => requestExit());
-	editor.onAction("app.suspend", handleCtrlZ);
-	editor.onAction("app.thinking.cycle", () => {
-		sendMessage(`/think ${nextThinkLevel(state.sessionInfo.thinkingLevel ?? opts.thinking ?? "medium")}`);
-		updateEditorBorderColor();
+	defaultEditor.onCtrlD = () => requestExit();
+	defaultEditor.onAction("app.clear", handleCtrlC);
+	defaultEditor.onAction("app.exit", () => requestExit());
+	defaultEditor.onAction("app.suspend", handleCtrlZ);
+	defaultEditor.onAction("app.thinking.cycle", () => {
+		setThinkingLevel(nextThinkLevel(state.sessionInfo.thinkingLevel ?? opts.thinking ?? "medium"));
 	});
-	editor.onAction("app.model.cycleForward", () => cycleModel("forward"));
-	editor.onAction("app.model.cycleBackward", () => cycleModel("backward"));
-	editor.onAction("app.model.select", () => void openModelPickerOverlay(pickerSvc));
-	editor.onAction("app.session.resume", () => void openSessionPickerOverlay(pickerSvc));
-	editor.onAction("app.tools.expand", () => {
+	defaultEditor.onAction("app.model.cycleForward", () => cycleModel("forward"));
+	defaultEditor.onAction("app.model.cycleBackward", () => cycleModel("backward"));
+	defaultEditor.onAction("app.model.select", () => uiOverlays.openModelPicker());
+	defaultEditor.onAction("app.session.resume", () => void openSessionPickerOverlay(pickerSvc));
+	defaultEditor.onAction("app.session.tree", showSessionTree);
+	defaultEditor.onAction("app.session.fork", () => uiOverlays.openUserMessageFork());
+	defaultEditor.onAction("app.tools.expand", () => {
 		state.toolsExpanded = !state.toolsExpanded;
 		tuiSettings = {
 			...tuiSettings,
@@ -658,65 +1802,95 @@ async function runTui(opts) {
 		setActivityStatus(state.toolsExpanded ? "tools expanded" : "tools collapsed");
 		tui.requestRender();
 	});
-	editor.onAction("app.thinking.toggle", () => {
+	defaultEditor.onAction("app.thinking.toggle", () => {
 		state.showThinking = !state.showThinking;
 		tuiSettings = {
 			...tuiSettings,
 			showThinking: state.showThinking
 		};
 		saveTuiSettings(tuiSettings);
+		chatLog.setShowThinking(state.showThinking);
 		updateFooter();
 		tui.requestRender();
 	});
-	editor.onAction("app.editor.external", openExternalEditor);
-	editor.onPasteImage = () => {
+	defaultEditor.onAction("app.editor.external", openExternalEditor);
+	defaultEditor.onPasteImage = () => {
 		(async () => {
-			const filePath = await saveClipboardImageToTempFile();
-			if (!filePath) return;
-			editor.insertTextAtCursor(filePath);
-			chatLog.addSystem(theme.dim(`Pasted image path: ${filePath}`));
+			const image = await readClipboardImage();
+			if (!image) {
+				chatLog.addStatus(theme.dim("No image found on clipboard."));
+				tui.requestRender();
+				return;
+			}
+			if (pendingImageAttachments.length >= 10) {
+				chatLog.addSystem(`Attachment limit reached (10). Send or clear the current draft first.`);
+				tui.requestRender();
+				return;
+			}
+			if (image.bytes.byteLength > 33554432) {
+				chatLog.addSystem(`Clipboard image is too large (${image.bytes.byteLength} bytes; max ${MAX_WEBCHAT_ATTACHMENT_FILE_BYTES}).`);
+				tui.requestRender();
+				return;
+			}
+			const ext = extensionForImageMimeType(image.mimeType) ?? "png";
+			const name = `clipboard-${pendingImageAttachments.length + 1}.${ext}`;
+			pendingImageAttachments.push({
+				type: "image",
+				mimeType: image.mimeType,
+				data: Buffer.from(image.bytes).toString("base64"),
+				name,
+				size: image.bytes.byteLength
+			});
+			chatLog.addStatus(theme.dim(`Attached image: ${name} (${pendingImageAttachments.length} pending). Send a message to include it.`));
 			tui.requestRender();
 		})();
 	};
-	editor.onAction("app.message.followUp", handleFollowUp);
-	editor.onAction("app.message.dequeue", handleDequeue);
+	defaultEditor.onAction("app.message.followUp", handleFollowUp);
+	defaultEditor.onAction("app.message.dequeue", handleDequeue);
 	streamWatchdogId = setInterval(() => {
-		if (!state.activeRunId) return;
-		if (!busyStates.has(state.activityStatus)) return;
-		if (Date.now() - lastStreamActivityAt < 3e4) return;
-		const rid = state.activeRunId;
-		const finalText = assembler.finalize(rid, state.showThinking);
-		if (finalText) chatLog.finalizeAssistant(finalText, rid);
-		chatLog.addSystem("⚠️ No stream activity for 30s; UI reset (connection may have stalled). Retry or check gateway.");
-		state.activeRunId = null;
-		setActivityStatus("idle");
-		refreshSessionInfoWithBorder().finally(() => {
-			updateFooter();
-			tui.requestRender();
-		});
-		flushFollowUpQueue();
+		const now = Date.now();
+		if (!isActiveRunStreamStale(state, now, 3e4)) return;
+		if (!markActiveRunStalled(state, now)) return;
+		chatLog.addSystem(theme.dim("No stream activity for 30s; preserving active run and reloading persisted history."));
+		setActivityStatus("stalled");
+		recoverActiveRunFromHistory("stream watchdog");
 		tui.requestRender();
 	}, 5e3);
 	const onAgentRunEnded = () => {
 		state.progressMessage = null;
+		steeringInFlightForRunId = null;
 		refreshSessionInfoWithBorder().finally(() => {
 			updateFooter();
 			tui.requestRender();
 		});
+		flushSteeringQueue();
 		flushFollowUpQueue();
 	};
 	client.onEvent = (evt) => {
 		const data = evt.data ?? {};
-		dispatchAgentSSE(evt.event, data, state, chatLog, assembler, tui, setActivityStatus, touchStreamingActivity, onAgentRunEnded);
+		dispatchAgentEvent(evt.event, data, state, chatLog, tui, setActivityStatus, touchStreamingActivity, onAgentRunEnded, (message) => sessionSnapshot.appendMessage("assistant", assistantMessagePlainText(message)), evt.source);
 	};
 	client.onConnected = () => {
 		state.isConnected = true;
 		setConnectionStatus(isLocalMode ? "local ready" : "gateway connected");
 		touchStreamingActivity();
 		(async () => {
+			try {
+				await applyStartupWorkingDirectory();
+			} catch (err) {
+				const errorMessage = err instanceof Error ? err.message : String(err);
+				chatLog.addSystem(`Working directory not changed: ${errorMessage}`);
+			}
 			await refreshSessionInfoWithBorder();
 			await refreshModelChoices();
-			await loadSessionHistory();
+			await refreshStartupResources();
+			await loadSessionHistory({ merge: true });
+			showStartupCardOnce();
+			if (state.activeRunId) recoverActiveRunFromHistory("broadcast reconnect");
+			if (!projectTrustPromptShown && isLocalMode && projectTrustSessionDecision === null && hasTrustRequiringProjectResources(process.cwd()) && projectTrustStore.get(process.cwd()) === null) {
+				projectTrustPromptShown = true;
+				chatLog.addSystem("Project-local xopc resources detected. Use /trust to trust this folder, trust a parent folder, or keep it untrusted.");
+			}
 			updateHeader();
 			updateFooter();
 			tui.requestRender();
@@ -743,6 +1917,8 @@ async function runTui(opts) {
 	client.onGap = (info) => {
 		chatLog.addSystem(`⚠️ Event gap: expected ${info.expected}, received ${info.received}. Some updates may be missing.`);
 		setConnectionStatus(`event gap: expected ${info.expected}, got ${info.received}`);
+		if (state.activeRunId) recoverActiveRunFromHistory("broadcast event gap");
+		else loadSessionHistory({ merge: true });
 		tui.requestRender();
 	};
 	const sigintHandler = () => handleCtrlC();