@xopcai/xopc 0.0.102 → 0.0.104

package/dist/src/tui/tui-commands.js

@@ -1,9 +1,31 @@
+import { resolveConfigPath } from "../config/paths.js";
+import { loadConfig } from "../config/loader.js";
+import { parseAgentSessionKey } from "../routing/session-key-utils.js";
+import { init_agent_session_key, isValidAgentId, normalizeAgentId } from "../routing/agent-session-key.js";
+import { init_providers, providerSupportsOAuth } from "../providers/index.js";
+import { createWorkflowCatalog } from "../agent/workflow/catalog.js";
+import { normalizeReasoningLevel, normalizeThinkLevel, normalizeVerboseLevel } from "../agent/transcript/thinking-types.js";
+import { provenanceTracker } from "../extensions/security.js";
+import "../config/index.js";
 import { getTuiKeybindingsPath } from "./tui-keybindings-file.js";
-import { formatXopcTuiHotkeys } from "./format-tui-hotkeys.js";
+import { formatKeyIds, formatXopcTuiHotkeys } from "./format-tui-hotkeys.js";
+import { formatTuiConfigInfo, formatTuiContextInfo, formatTuiLoginInfo, formatTuiModelsInfo, formatTuiSessionInfo, formatTuiSessionListInfo, formatTuiSessionTreeInfo, formatTuiStoredAuthProfilesInfo, formatTuiTranscriptTreeInfo, formatTuiTrustInfo, formatTuiUsageInfo, formatTuiWorkflowDetail, formatTuiWorkflowsInfo, loadTuiChangelogInfo, nextVerboseLevel, parseTuiExportRequest, parseTuiImportRequest, parseTuiShareRequest, writeTuiDebugInfo } from "./tui-command-formatters.js";
+import { getAuthStorePath, listAllProfiles, listProfilesForProvider, removeAuthProfile } from "../auth/profiles/profiles.js";
 import { rewriteUnknownSlashAsWorkflow } from "./tui-workflow-slash.js";
+import { formatTuiStartupText } from "./tui-startup-text.js";
 import { randomUUID } from "node:crypto";
 //#region src/tui/tui-commands.ts
-function getSlashCommands(_isLocal) {
+init_agent_session_key();
+init_providers();
+function keyLabel(keybindings, id, fallback) {
+	return keybindings ? formatKeyIds(keybindings, id, { capitalize: true }) : fallback;
+}
+function getSlashCommands(_isLocal, keybindings) {
+	const abortKey = keyLabel(keybindings, "app.interrupt", "Escape");
+	const toolsKey = keyLabel(keybindings, "app.tools.expand", "Ctrl+O");
+	const thinkingKey = keyLabel(keybindings, "app.thinking.toggle", "Ctrl+T");
+	const sessionKey = keyLabel(keybindings, "app.session.resume", "Ctrl+Shift+P");
+	const modelCycleKey = keyLabel(keybindings, "app.model.cycleForward", "Ctrl+P");
 	return [
 		{
 			name: "help",
@@ -11,20 +33,40 @@ function getSlashCommands(_isLocal) {
 		},
 		{
 			name: "abort",
-			description: "Abort active run (or press Escape)"
+			description: `Abort active run (or press ${abortKey})`
+		},
+		{
+			name: "recover",
+			description: "Reload history and reattach to a stalled run"
+		},
+		{
+			name: "retry",
+			description: "Abort current run if needed and resend the last user message"
 		},
 		{
 			name: "tools",
-			description: "Toggle tool output expanded/collapsed (or Ctrl+O)"
+			description: `Toggle tool output expanded/collapsed (or ${toolsKey})`
 		},
 		{
 			name: "thinking",
-			description: "Toggle thinking display (or Ctrl+T)"
+			description: `Toggle thinking display (or ${thinkingKey})`
+		},
+		{
+			name: "copy",
+			description: "Copy last assistant message to clipboard"
 		},
 		{
 			name: "exit",
 			description: "Exit the TUI"
 		},
+		{
+			name: "quit",
+			description: "Quit the TUI"
+		},
+		{
+			name: "model",
+			description: "Open model picker (optional search text)"
+		},
 		{
 			name: "models",
 			description: "List available models"
@@ -33,14 +75,50 @@ function getSlashCommands(_isLocal) {
 			name: "switch",
 			description: "Switch model — copy `provider/model` from /models"
 		},
+		{
+			name: "login",
+			description: "Login to an OAuth provider"
+		},
+		{
+			name: "logout",
+			description: "Remove stored provider auth profiles"
+		},
 		{
 			name: "usage",
 			description: "Show token usage statistics"
 		},
+		{
+			name: "session",
+			description: "Show current session info"
+		},
+		{
+			name: "agent",
+			description: "Show or switch agent for this TUI session"
+		},
+		{
+			name: "agents",
+			description: "List available agents"
+		},
 		{
 			name: "new",
 			description: "Start a new isolated TUI session (tui-{uuid})"
 		},
+		{
+			name: "fork",
+			description: "Fork current session transcript into a new session"
+		},
+		{
+			name: "clone",
+			description: "Duplicate current session transcript into a new session"
+		},
+		{
+			name: "trust",
+			description: "Manage project trust and show extension security policy"
+		},
+		{
+			name: "name",
+			description: "Show or set current session display name"
+		},
 		{
 			name: "reset",
 			description: "Reset current session transcript and reload history"
@@ -55,11 +133,15 @@ function getSlashCommands(_isLocal) {
 		},
 		{
 			name: "resume",
-			description: "Open session picker (or Ctrl+Shift+P)"
+			description: `Open session picker (or ${sessionKey})`
+		},
+		{
+			name: "tree",
+			description: "Show grouped session tree"
 		},
 		{
 			name: "scoped-models",
-			description: "Choose models for Ctrl+P cycling"
+			description: `Choose models for ${modelCycleKey} cycling`
 		},
 		{
 			name: "compact",
@@ -97,13 +179,25 @@ function getSlashCommands(_isLocal) {
 			name: "export",
 			description: "Export session (markdown/html/json)"
 		},
+		{
+			name: "import",
+			description: "Import an xopc JSON session export"
+		},
+		{
+			name: "share",
+			description: "Create a share link for a workspace file/folder/site"
+		},
 		{
 			name: "settings",
 			description: "Open TUI settings overlay"
 		},
+		{
+			name: "reload",
+			description: "Reload keybindings, TUI settings, theme, and extension UI"
+		},
 		{
 			name: "reload-keybindings",
-			description: "Reload ~/.xopc/keybindings.json"
+			description: `Reload ${getTuiKeybindingsPath()}`
 		},
 		{
 			name: "start",
@@ -113,6 +207,10 @@ function getSlashCommands(_isLocal) {
 			name: "hotkeys",
 			description: "Show resolved keyboard shortcuts (pi-style)"
 		},
+		{
+			name: "changelog",
+			description: "Show version history"
+		},
 		{
 			name: "workflows",
 			description: "List saved workflows (built-in + ~/.xopc/workflows/)"
@@ -123,44 +221,128 @@ function getSlashCommands(_isLocal) {
 		}
 	];
 }
-function formatTuiHelpText(isLocal) {
-	const commands = getSlashCommands(isLocal);
+function formatExtraSlashCommands(commands) {
+	const seen = new Set(getSlashCommands(true).map((command) => command.name));
+	const lines = [];
+	for (const command of commands) {
+		const name = command.name.replace(/^\//, "").trim().toLowerCase();
+		const originalName = command.originalName?.replace(/^\//, "").trim().toLowerCase();
+		if (!name || seen.has(name) || originalName && seen.has(originalName)) continue;
+		seen.add(name);
+		lines.push(`  /${name} — ${command.description}`);
+	}
+	return lines;
+}
+function formatTuiHelpText(isLocal, keybindings, extraSlashCommands = []) {
+	const commands = getSlashCommands(isLocal, keybindings);
+	const interrupt = keyLabel(keybindings, "app.interrupt", "Escape");
+	const thinkCycle = keyLabel(keybindings, "app.thinking.cycle", "Shift+Tab");
+	const modelNext = keyLabel(keybindings, "app.model.cycleForward", "Ctrl+P");
+	const modelPrev = keyLabel(keybindings, "app.model.cycleBackward", "Shift+Ctrl+P");
+	const modelPicker = keyLabel(keybindings, "app.model.select", "Ctrl+L");
+	const sessionPicker = keyLabel(keybindings, "app.session.resume", "Ctrl+Shift+P");
+	const sessionTree = keyLabel(keybindings, "app.session.tree", "(not bound)");
+	const sessionFork = keyLabel(keybindings, "app.session.fork", "(not bound)");
+	const toolExpand = keyLabel(keybindings, "app.tools.expand", "Ctrl+O");
+	const thinkingToggle = keyLabel(keybindings, "app.thinking.toggle", "Ctrl+T");
+	const editorExternal = keyLabel(keybindings, "app.editor.external", "Ctrl+G");
+	const suspend = keyLabel(keybindings, "app.suspend", "Ctrl+Z");
+	const followUp = keyLabel(keybindings, "app.message.followUp", "Alt+Enter");
+	const dequeue = keyLabel(keybindings, "app.message.dequeue", "Alt+Up");
+	const pasteImage = keyLabel(keybindings, "app.clipboard.pasteImage", "Ctrl+V / Alt+V");
+	const clearInput = keyLabel(keybindings, "app.clear", "Ctrl+C");
+	const exit = keyLabel(keybindings, "app.exit", "Ctrl+D");
 	const lines = ["Available commands:"];
 	for (const c of commands) lines.push(`  /${c.name} — ${c.description}`);
+	const extraCommandLines = formatExtraSlashCommands(extraSlashCommands);
+	if (extraCommandLines.length > 0) {
+		lines.push("", "Extension commands:");
+		lines.push(...extraCommandLines);
+	}
 	lines.push("", "Keyboard shortcuts (defaults align with pi coding-agent where noted):");
-	lines.push("  Escape — Abort active run");
-	lines.push("  Shift+Tab — Cycle /think level");
-	lines.push("  Ctrl+P / Shift+Ctrl+P — Next / previous model (/switch)");
-	lines.push("  Ctrl+L — Model picker");
-	lines.push("  Ctrl+Shift+P — Session picker (rename/delete)");
-	lines.push("  /scoped-models — Limit Ctrl+P model cycle set");
-	lines.push("  Ctrl+O — Toggle tool output");
-	lines.push("  Ctrl+T — Toggle thinking block display");
-	lines.push("  Ctrl+G — Edit draft in $EDITOR");
-	lines.push("  Ctrl+Z — Suspend to shell (Unix)");
-	lines.push("  Alt+Enter — Queue follow-up while busy (sends when this reply finishes)");
-	lines.push("  Alt+Up — Restore queued follow-up messages to editor");
+	lines.push(`  ${interrupt} — Abort active run`);
+	lines.push(`  ${thinkCycle} — Cycle /think level`);
+	lines.push(`  ${modelNext} / ${modelPrev} — Next / previous model (/switch)`);
+	lines.push(`  ${modelPicker} — Model picker`);
+	lines.push(`  ${sessionPicker} — Session picker (rename/delete)`);
+	lines.push(`  ${sessionTree} — Session tree`);
+	lines.push(`  ${sessionFork} — Fork current session`);
+	lines.push(`  /scoped-models — Limit ${modelNext} model cycle set`);
+	lines.push(`  ${toolExpand} — Toggle tool output`);
+	lines.push(`  ${thinkingToggle} — Toggle thinking block display`);
+	lines.push(`  ${editorExternal} — Edit draft in $EDITOR`);
+	lines.push(`  ${suspend} — Suspend to shell (Unix)`);
+	lines.push(`  ${followUp} — Queue follow-up while busy (sends when this reply finishes)`);
+	lines.push(`  ${dequeue} — Restore queued messages to editor`);
 	lines.push("  Enter (while busy) — Steer: inject at next tool boundary");
-	lines.push("  Ctrl+V (mac/Linux) / Alt+V (Win) — Paste image from clipboard");
+	lines.push(`  ${pasteImage} — Paste image from clipboard`);
 	lines.push("  /settings — Theme, thinking display, terminal progress, …");
-	lines.push("  ~/.xopc/keybindings.json — Custom shortcuts (use /reload-keybindings)");
-	lines.push("  Ctrl+C — Clear input; repeat within ~0.5s to exit when empty");
-	lines.push("  Ctrl+D — Exit when input empty");
+	lines.push(`  ${getTuiKeybindingsPath()} — Custom shortcuts (use /reload)`);
+	lines.push(`  ${clearInput} — Clear input; repeat within ~0.5s to exit when empty`);
+	lines.push(`  ${exit} — Exit when input empty`);
 	lines.push("  !cmd — Local shell (gated; runs on this machine)");
 	lines.push("", "Use /hotkeys for the resolved binding list from the active keymap.");
 	return lines.join("\n");
 }
+function formatTuiStartText(state, isLocal, keybindings, resources) {
+	return formatTuiStartupText({
+		state,
+		isLocal,
+		keybindings,
+		resources,
+		expanded: true
+	});
+}
+function defaultAuthProfiles() {
+	return {
+		listAll: () => listAllProfiles(),
+		listProvider: (provider) => listProfilesForProvider(provider),
+		remove: (profileId) => removeAuthProfile(profileId),
+		getStorePath: () => getAuthStorePath()
+	};
+}
+function formatAgentsList(agents, currentAgentId) {
+	if (agents.length === 0) return "No agents available.";
+	const current = currentAgentId?.trim().toLowerCase();
+	return [
+		"Available agents:",
+		...[...agents].sort((a, b) => {
+			if (a.id === current && b.id !== current) return -1;
+			if (b.id === current && a.id !== current) return 1;
+			if (a.id === "coder" && b.id !== "coder") return -1;
+			if (b.id === "coder" && a.id !== "coder") return 1;
+			return a.id.localeCompare(b.id);
+		}).map((agent) => {
+			const marker = agent.id === current ? "*" : " ";
+			const label = agent.displayName ? ` — ${agent.displayName}` : "";
+			return `${marker} ${agent.id} (${agent.source})${label}`;
+		}),
+		"",
+		"Switch with: /agent <id>"
+	].join("\n");
+}
+function formatCurrentAgent(state) {
+	const parsed = parseAgentSessionKey(state.currentSessionKey);
+	if (!parsed) return `Current session is not an agent session.\nSession: ${state.currentSessionKey}`;
+	const lines = [`Current agent: ${parsed.agentId}`, `Session: ${state.currentSessionKey}`];
+	const workspace = state.sessionInfo.effectiveWorkspacePath?.trim();
+	if (workspace) lines.push(`Workspace: ${workspace}`);
+	const provider = state.sessionInfo.modelProvider?.trim();
+	const model = state.sessionInfo.model?.trim();
+	if (model) lines.push(`Model: ${provider ? `${provider}/${model}` : model}`);
+	return lines.join("\n");
+}
 function createTuiCommandHandler(deps) {
-	const { state, chatLog, tui, assembler, isLocalMode, abortActive, sendMessage, requestExit, updateFooter, keybindings, uiOverlays, extensionSlashCommands = [], setSession, resetSession } = deps;
+	const { state, chatLog, tui, isLocalMode, abortActive, sendMessage, requestExit, updateFooter, keybindings, uiOverlays, extensionSlashCommands = [], extensionShortcuts = [], setSession, resetSession } = deps;
 	const runReset = async () => {
 		await abortActive();
 		if (resetSession) {
 			await resetSession();
 			chatLog.addSystem(`session ${state.currentSessionKey} reset`);
 		} else {
-			assembler.clear();
 			chatLog.clearAll();
 			state.messageFollowUpQueue.length = 0;
+			state.steeringQueue.length = 0;
 			chatLog.addSystem("Session cleared (reset not available in this mode).");
 		}
 		tui.requestRender();
@@ -169,23 +351,332 @@ function createTuiCommandHandler(deps) {
 		const [commandName, ...restParts] = input.replace(/^\//, "").trim().split(/\s+/);
 		const normalizedCommand = (commandName ?? "").toLowerCase();
 		const commandArgs = restParts.join(" ");
-		const extensionCmd = extensionSlashCommands.find((c) => c.name === normalizedCommand);
-		if (extensionCmd) {
-			Promise.resolve(extensionCmd.handler(commandArgs)).then(() => {
-				tui.requestRender();
-			});
-			return;
-		}
 		switch (normalizedCommand) {
 			case "help":
-				chatLog.addSystem(formatTuiHelpText(isLocalMode));
+				chatLog.addSystem(formatTuiHelpText(isLocalMode, keybindings, extensionSlashCommands));
+				tui.requestRender();
+				return;
+			case "start":
+				chatLog.addSystem(formatTuiStartText(state, isLocalMode, keybindings, deps.getStartupResources?.()));
 				tui.requestRender();
 				return;
 			case "hotkeys":
 			case "keys":
-				chatLog.addSystem(formatXopcTuiHotkeys(keybindings));
+				chatLog.addSystem(formatXopcTuiHotkeys(keybindings, extensionShortcuts));
+				tui.requestRender();
+				return;
+			case "changelog":
+				chatLog.addSystem(loadTuiChangelogInfo());
+				tui.requestRender();
+				return;
+			case "debug":
+				try {
+					const debugPath = writeTuiDebugInfo({
+						state,
+						tui
+					});
+					chatLog.addSystem(`Debug log written\n${debugPath}`);
+				} catch (err) {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Debug log failed: ${errorMessage}`);
+				}
 				tui.requestRender();
 				return;
+			case "session":
+			case "status":
+				Promise.resolve(deps.getSessionStats?.()).catch(() => void 0).then((stats) => {
+					chatLog.addSystem(formatTuiSessionInfo(state, stats));
+					tui.requestRender();
+				});
+				return;
+			case "agents":
+				if (uiOverlays?.openAgentPicker) {
+					uiOverlays.openAgentPicker();
+					return;
+				}
+				Promise.resolve(deps.listAgents?.() ?? []).then((agents) => {
+					const current = parseAgentSessionKey(state.currentSessionKey)?.agentId;
+					chatLog.addSystem(formatAgentsList(agents, current));
+					tui.requestRender();
+				}).catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Agents list failed: ${errorMessage}`);
+					tui.requestRender();
+				});
+				return;
+			case "agent": {
+				const targetRaw = commandArgs.trim();
+				if (!targetRaw) {
+					chatLog.addSystem(formatCurrentAgent(state));
+					tui.requestRender();
+					return;
+				}
+				(async () => {
+					const parsedCurrent = parseAgentSessionKey(state.currentSessionKey);
+					if (!parsedCurrent) {
+						chatLog.addSystem("Cannot switch agent: current session is not an agent session.");
+						tui.requestRender();
+						return;
+					}
+					if (state.activeRunId) {
+						chatLog.addSystem("Cannot switch agent while a run is active. Abort first.");
+						tui.requestRender();
+						return;
+					}
+					if (!isValidAgentId(targetRaw)) {
+						chatLog.addSystem(`Invalid agent id: ${targetRaw}`);
+						tui.requestRender();
+						return;
+					}
+					const targetAgentId = normalizeAgentId(targetRaw);
+					if (!(await Promise.resolve(deps.listAgents?.() ?? [])).some((agent) => agent.enabled !== false && agent.id === targetAgentId)) {
+						chatLog.addSystem(`Unknown agent: ${targetAgentId}`);
+						tui.requestRender();
+						return;
+					}
+					const targetSessionKey = `agent:${targetAgentId}:${parsedCurrent.rest}`;
+					if (targetSessionKey === state.currentSessionKey) {
+						chatLog.addSystem(`Already using agent: ${targetAgentId}`);
+						tui.requestRender();
+						return;
+					}
+					if (!deps.switchAgentSession) {
+						chatLog.addSystem("Agent switching is not available in this mode.");
+						tui.requestRender();
+						return;
+					}
+					await deps.switchAgentSession(targetSessionKey, targetAgentId);
+					chatLog.addSystem(`Switched to agent: ${targetAgentId}\nSession: ${targetSessionKey}`);
+					tui.requestRender();
+				})().catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Agent switch failed: ${errorMessage}`);
+					tui.requestRender();
+				});
+				return;
+			}
+			case "usage":
+				Promise.resolve(deps.getSessionStats?.()).catch(() => void 0).then((stats) => {
+					chatLog.addSystem(formatTuiUsageInfo(state, stats));
+					tui.requestRender();
+				});
+				return;
+			case "context":
+				chatLog.addSystem(formatTuiContextInfo(state));
+				tui.requestRender();
+				return;
+			case "config":
+				chatLog.addSystem(formatTuiConfigInfo(state));
+				tui.requestRender();
+				return;
+			case "trust":
+				if (uiOverlays?.openProjectTrust) {
+					uiOverlays.openProjectTrust();
+					return;
+				}
+				chatLog.addSystem(formatTuiTrustInfo(loadConfig(), {
+					configPath: resolveConfigPath(),
+					provenance: provenanceTracker.getAll(),
+					cwd: deps.projectTrust?.cwd,
+					hasProjectResources: deps.projectTrust?.hasProjectResources(),
+					projectTrustStorePath: deps.projectTrust?.getStorePath(),
+					projectTrustEntry: deps.projectTrust?.getEntry(),
+					projectTrustSessionDecision: deps.projectTrust?.getSessionDecision()
+				}));
+				tui.requestRender();
+				return;
+			case "export":
+				if (!deps.exportSession) {
+					chatLog.addSystem("Export is not available in this mode.");
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.exportSession(parseTuiExportRequest(commandArgs))).then(() => {
+					tui.requestRender();
+				});
+				return;
+			case "import":
+				if (!deps.importSession) {
+					chatLog.addSystem("Import is not available in this mode.");
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.importSession(parseTuiImportRequest(commandArgs))).then(() => {
+					tui.requestRender();
+				});
+				return;
+			case "share": {
+				if (!deps.createShare) {
+					chatLog.addSystem("Share is not available in this mode.");
+					tui.requestRender();
+					return;
+				}
+				const request = parseTuiShareRequest(commandArgs);
+				if (!request) {
+					chatLog.addSystem(["Usage: /share <workspace-path> [friend|colleague|public] [--site|--zip|--file]", "Optional: --title \"Title\" --description \"Description\""].join("\n"));
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.createShare(request)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
+			case "btw":
+			case "aside": {
+				const question = commandArgs.trim();
+				if (!question) {
+					chatLog.addSystem("Usage: /btw <question>\nAnswers use the current session as read-only background and are not saved.");
+					tui.requestRender();
+					return;
+				}
+				if (!deps.runBtwQuery) {
+					chatLog.addSystem("/btw is not available in this mode.");
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.runBtwQuery(question)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
+			case "workflows":
+				try {
+					chatLog.addSystem(formatTuiWorkflowsInfo(createWorkflowCatalog().list()));
+				} catch (err) {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Workflow list failed: ${errorMessage}`);
+				}
+				tui.requestRender();
+				return;
+			case "workflow": {
+				const [subcommandRaw, ...workflowRest] = commandArgs.trim().split(/\s+/);
+				const subcommand = (subcommandRaw || "list").toLowerCase();
+				if (subcommand === "list" || subcommand === "ls") {
+					try {
+						chatLog.addSystem(formatTuiWorkflowsInfo(createWorkflowCatalog().list()));
+					} catch (err) {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						chatLog.addSystem(`Workflow list failed: ${errorMessage}`);
+					}
+					tui.requestRender();
+					return;
+				}
+				if (subcommand === "view" || subcommand === "show") {
+					const name = workflowRest[0]?.trim();
+					if (!name) {
+						chatLog.addSystem("Usage: /workflow view <name>");
+						tui.requestRender();
+						return;
+					}
+					try {
+						chatLog.addSystem(formatTuiWorkflowDetail(name));
+					} catch (err) {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						chatLog.addSystem(`Workflow view failed: ${errorMessage}`);
+					}
+					tui.requestRender();
+					return;
+				}
+				if (subcommand === "save") {
+					chatLog.addSystem("/workflow save is available through the workflow tool after a generated workflow run.");
+					tui.requestRender();
+					return;
+				}
+				chatLog.addSystem("Usage: /workflow list | /workflow view <name> | /workflow save <name>");
+				tui.requestRender();
+				return;
+			}
+			case "models":
+				Promise.resolve(deps.listModels?.() ?? []).then((models) => {
+					chatLog.addSystem(formatTuiModelsInfo(models));
+					tui.requestRender();
+				});
+				return;
+			case "model":
+				if (uiOverlays) {
+					uiOverlays.openModelPicker(commandArgs.trim() || void 0);
+					return;
+				}
+				chatLog.addSystem("Model picker is not available in this mode. Use /models and /switch <provider/model>.");
+				tui.requestRender();
+				return;
+			case "list":
+				Promise.resolve(deps.listSessions?.() ?? []).then((sessions) => {
+					chatLog.addSystem(formatTuiSessionListInfo(sessions, { currentSessionKey: state.currentSessionKey }));
+					tui.requestRender();
+				});
+				return;
+			case "tree":
+				if (uiOverlays) {
+					uiOverlays.openTranscriptTree();
+					return;
+				}
+				if (deps.loadTranscriptTree) {
+					Promise.resolve(deps.loadTranscriptTree()).then((entries) => {
+						chatLog.addSystem(formatTuiTranscriptTreeInfo(entries));
+						tui.requestRender();
+					});
+					return;
+				}
+				uiOverlays?.openSessionTree();
+				if (uiOverlays) return;
+				Promise.resolve(deps.listSessions?.() ?? []).then((sessions) => {
+					chatLog.addSystem(formatTuiSessionTreeInfo(sessions, { currentSessionKey: state.currentSessionKey }));
+					tui.requestRender();
+				});
+				return;
+			case "switch": {
+				const modelRef = commandArgs.trim();
+				if (!modelRef) {
+					chatLog.addSystem("Usage: /switch <provider/model>");
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.switchModel?.(modelRef)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
+			case "login":
+				if (deps.runLogin && (!commandArgs.trim() || providerSupportsOAuth(commandArgs.trim()))) {
+					Promise.resolve(deps.runLogin(commandArgs.trim() || void 0)).catch((err) => {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						chatLog.addSystem(`Login failed: ${errorMessage}`);
+					}).finally(() => tui.requestRender());
+					return;
+				}
+				chatLog.addSystem(formatTuiLoginInfo(commandArgs));
+				tui.requestRender();
+				return;
+			case "logout": {
+				const provider = commandArgs.trim();
+				const authProfiles = deps.authProfiles ?? defaultAuthProfiles();
+				(async () => {
+					try {
+						if (!provider) {
+							const profiles = await authProfiles.listAll();
+							chatLog.addSystem(formatTuiStoredAuthProfilesInfo(profiles, { authStorePath: authProfiles.getStorePath() }));
+							tui.requestRender();
+							return;
+						}
+						const profiles = await authProfiles.listProvider(provider);
+						if (profiles.length === 0) {
+							chatLog.addSystem([`No stored auth profiles found for provider: ${provider}`, "Environment variables and config credentials are unchanged."].join("\n"));
+							tui.requestRender();
+							return;
+						}
+						let removed = 0;
+						for (const profile of profiles) if (await authProfiles.remove(profile.profileId)) removed += 1;
+						chatLog.addSystem([`Logged out from ${provider}: removed ${removed} stored auth profile${removed === 1 ? "" : "s"}.`, "Environment variables and config credentials are unchanged."].join("\n"));
+					} catch (err) {
+						const errorMessage = err instanceof Error ? err.message : String(err);
+						chatLog.addSystem(`Logout failed: ${errorMessage}`);
+					}
+					tui.requestRender();
+				})();
+				return;
+			}
 			case "exit":
 			case "quit":
 				requestExit();
@@ -198,6 +689,18 @@ function createTuiCommandHandler(deps) {
 					tui.requestRender();
 				});
 				return;
+			case "recover":
+				Promise.resolve(deps.recoverStream?.()).catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Recover failed: ${errorMessage}`);
+				}).finally(() => tui.requestRender());
+				return;
+			case "retry":
+				Promise.resolve(deps.retryLastMessage?.()).catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Retry failed: ${errorMessage}`);
+				}).finally(() => tui.requestRender());
+				return;
 			case "tools":
 				state.toolsExpanded = !state.toolsExpanded;
 				chatLog.setToolsExpanded(state.toolsExpanded);
@@ -206,10 +709,29 @@ function createTuiCommandHandler(deps) {
 				return;
 			case "thinking":
 				state.showThinking = !state.showThinking;
+				chatLog.setShowThinking(state.showThinking);
 				chatLog.addSystem(`Thinking display: ${state.showThinking ? "on" : "off"}`);
 				updateFooter();
 				tui.requestRender();
 				return;
+			case "copy":
+				Promise.resolve(deps.copyLastAssistant?.()).then(() => {
+					tui.requestRender();
+				});
+				return;
+			case "name": {
+				const name = commandArgs.trim();
+				if (!name) {
+					const currentName = state.sessionInfo.displayName?.trim();
+					chatLog.addSystem(currentName ? `Session name: ${currentName}` : "Usage: /name <name>");
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.renameCurrentSession?.(name)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
 			case "resume":
 			case "sessions":
 				uiOverlays?.openSessionPicker();
@@ -218,17 +740,70 @@ function createTuiCommandHandler(deps) {
 			case "scopedmodels":
 				uiOverlays?.openScopedModels();
 				return;
+			case "think": {
+				const level = normalizeThinkLevel(commandArgs);
+				if (!commandArgs.trim()) {
+					uiOverlays?.openThinkingSelector();
+					return;
+				}
+				if (!level) {
+					chatLog.addSystem(`Invalid thinking level: ${commandArgs}`);
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.setThinkingLevel?.(level)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
+			case "reasoning": {
+				const level = normalizeReasoningLevel(commandArgs);
+				if (!commandArgs.trim()) {
+					const current = state.sessionInfo.reasoningLevel?.trim();
+					chatLog.addSystem(current ? `Reasoning visibility: ${current}` : "Usage: /reasoning <off|on|stream>");
+					tui.requestRender();
+					return;
+				}
+				if (!level) {
+					chatLog.addSystem(`Invalid reasoning visibility: ${commandArgs}`);
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.setReasoningLevel?.(level)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
+			case "verbose": {
+				const raw = commandArgs.trim();
+				const level = raw ? normalizeVerboseLevel(raw) : nextVerboseLevel(state.sessionInfo.verboseLevel);
+				if (raw && !level) {
+					chatLog.addSystem(`Invalid verbose level: ${commandArgs}`);
+					tui.requestRender();
+					return;
+				}
+				Promise.resolve(deps.setVerboseLevel?.(level)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			}
 			case "settings":
 				uiOverlays?.openSettings();
 				return;
+			case "reload":
 			case "reload-keybindings":
 			case "reload-keybind":
-				uiOverlays?.reloadKeybindings();
-				chatLog.addSystem(`Keybindings reloaded from ${getTuiKeybindingsPath()}`);
-				tui.requestRender();
+				Promise.resolve(uiOverlays?.reloadKeybindings()).then(() => {
+					chatLog.addSystem("Reloaded keybindings, TUI settings, theme, and extension UI.");
+					tui.requestRender();
+				}).catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					chatLog.addSystem(`Reload failed: ${errorMessage}`);
+					tui.requestRender();
+				});
 				return;
 			case "compact":
-				deps.runCompaction?.();
+				deps.runCompaction?.(commandArgs.trim() || void 0);
 				return;
 			default: break;
 		}
@@ -242,9 +817,9 @@ function createTuiCommandHandler(deps) {
 							await setSession(uniqueKey);
 							chatLog.addSystem(`new session: ${state.currentSessionKey}`);
 						} else {
-							assembler.clear();
 							chatLog.clearAll();
 							state.messageFollowUpQueue.length = 0;
+							state.steeringQueue.length = 0;
 							chatLog.addSystem("New session requires gateway or local session support.");
 						}
 						tui.requestRender();
@@ -255,6 +830,20 @@ function createTuiCommandHandler(deps) {
 					}
 				})();
 				return;
+			case "fork":
+				if (!commandArgs.trim() && uiOverlays) {
+					uiOverlays.openUserMessageFork();
+					return;
+				}
+				Promise.resolve(deps.forkSession?.(commandArgs.trim() || void 0)).then(() => {
+					tui.requestRender();
+				});
+				return;
+			case "clone":
+				Promise.resolve(deps.forkSession?.(commandArgs.trim() || void 0)).then(() => {
+					tui.requestRender();
+				});
+				return;
 			case "reset":
 			case "restart":
 				runReset();
@@ -264,6 +853,13 @@ function createTuiCommandHandler(deps) {
 				return;
 			default: break;
 		}
+		const extensionCmd = extensionSlashCommands.find((c) => c.name === normalizedCommand);
+		if (extensionCmd) {
+			Promise.resolve(extensionCmd.handler(commandArgs, extensionCmd.getContext?.())).then(() => {
+				tui.requestRender();
+			});
+			return;
+		}
 		if (input.trimStart().startsWith("/")) {
 			const rewritten = rewriteUnknownSlashAsWorkflow(normalizedCommand, commandArgs);
 			if (rewritten) {
@@ -277,6 +873,6 @@ function createTuiCommandHandler(deps) {
 	};
 }
 //#endregion
-export { createTuiCommandHandler, formatTuiHelpText, getSlashCommands };
+export { createTuiCommandHandler, formatTuiHelpText, formatTuiStartText, getSlashCommands };
 
 //# sourceMappingURL=tui-commands.js.map