oma-coding-agent 1.1.4

package/src/slash-commands/builtin-registry.ts

@@ -0,0 +1,2332 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
+import { setNextRequestDebugPath } from "@oh-my-pi/pi-ai/utils/request-debug";
+import { type AutocompleteItem, Spacer } from "@oh-my-pi/pi-tui";
+import { APP_NAME, setProjectDir } from "@oh-my-pi/pi-utils";
+import { COLLAB_GUEST_ALLOWED_COMMANDS, CollabGuestLink } from "../collab/guest";
+import { CollabHost } from "../collab/host";
+import type { SettingPath, SettingValue } from "../config/settings";
+import { settings } from "../config/settings";
+import {
+	clearPluginRootsAndCaches,
+	resolveActiveProjectRegistryPath,
+	resolveOrDefaultProjectRegistryPath,
+} from "../discovery/helpers.js";
+import { shareSession } from "../export/share";
+import { PluginManager } from "../extensibility/plugins";
+import {
+	getInstalledPluginsRegistryPath,
+	getMarketplacesCacheDir,
+	getMarketplacesRegistryPath,
+	getPluginsCacheDir,
+	MarketplaceManager,
+} from "../extensibility/plugins/marketplace";
+import { resolveMemoryBackend } from "../memory-backend";
+import { theme } from "../modes/theme/theme";
+import type { InteractiveModeContext } from "../modes/types";
+import type { AgentSession, FreshSessionResult } from "../session/agent-session";
+import { COMPACT_MODES, parseCompactArgs } from "../session/compact-modes";
+import { formatShakeSummary, type ShakeMode } from "../session/shake-types";
+import { urlHyperlinkAlways } from "../tui";
+import { getChangelogPath, parseChangelog } from "../utils/changelog";
+import { CollabQrCodeComponent } from "./helpers/collab-qrcode";
+import { buildContextReportText } from "./helpers/context-report";
+import { formatDuration } from "./helpers/format";
+import { createMarketplaceManager } from "./helpers/marketplace-manager";
+import { handleMcpAcp } from "./helpers/mcp";
+import { commandConsumed, errorMessage, parseSlashCommand, parseSubcommand, usage } from "./helpers/parse";
+import { describeRedeemOutcome, type ResetUsageAccount, toResetUsageAccounts } from "./helpers/reset-usage";
+import { handleSshAcp } from "./helpers/ssh";
+import { launchStatsDashboard, parseStatsDashboardArgs } from "./helpers/stats-dashboard";
+import { handleTodoAcp } from "./helpers/todo";
+import { buildUsageReportText } from "./helpers/usage-report";
+import { parseMarketplaceInstallArgs, parsePluginScopeArgs } from "./marketplace-install-parser";
+import type {
+	BuiltinSlashCommand,
+	ParsedSlashCommand,
+	SlashCommandResult,
+	SlashCommandRuntime,
+	SlashCommandSpec,
+	SubcommandDef,
+	TuiSlashCommandRuntime,
+} from "./types";
+
+export type { BuiltinSlashCommand, SubcommandDef } from "./types";
+
+/** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
+export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
+
+function refreshStatusLine(ctx: InteractiveModeContext): void {
+	ctx.statusLine.invalidate();
+	ctx.updateEditorTopBorder();
+	ctx.ui.requestRender();
+}
+
+/** `/fast status` label: "off", "on", or scope-qualified "on (… only)". */
+function formatFastModeStatus(session: AgentSession): string {
+	if (!session.isFastModeEnabled()) return "off";
+	switch (session.serviceTier) {
+		case "openai-only":
+			return "on (OpenAI only)";
+		case "claude-only":
+			return "on (Claude only)";
+		default:
+			return "on";
+	}
+}
+
+/** Scheme-less display form of a browser deep link: accent + underline, OSC-8 linked to the full URL. */
+function collabWebLinkClickable(webLink: string): string {
+	const display = theme.fg("accent", `\x1b[4m${webLink.replace(/^https?:\/\//, "")}\x1b[24m`);
+	return urlHyperlinkAlways(webLink, display);
+}
+
+/** Join hint printed by /collab: compact terminal link + clickable browser deep link. */
+function collabLinkHint(host: CollabHost, heading: string, view = false): string {
+	const bullet = theme.fg("accent", theme.format.bullet);
+	const link = view ? host.viewLink : host.link;
+	const webLink = view ? host.webViewLink : host.webLink;
+	return [
+		theme.fg("success", heading),
+		` ${bullet} ${theme.fg("muted", view ? "Watch from another terminal:" : "Join from another terminal:")} ${APP_NAME} join "${link}"`,
+		` ${bullet} ${theme.fg("muted", "or any web browser:")} ${collabWebLinkClickable(webLink)}`,
+		theme.fg(
+			"dim",
+			view
+				? "Anyone with this link can watch the session but cannot prompt the agent."
+				: "Anyone with the link can read the session and prompt the agent. Read-only link: /collab view",
+		),
+	].join("\n");
+}
+
+function showCollabQrCode(ctx: InteractiveModeContext, webLink: string): void {
+	try {
+		ctx.present([new Spacer(1), new CollabQrCodeComponent(webLink)]);
+	} catch (err) {
+		ctx.showError(`Failed to render collab QR code: ${errorMessage(err)}`);
+	}
+}
+
+function showCollabLink(ctx: InteractiveModeContext, host: CollabHost, heading: string, view = false): void {
+	ctx.showStatus(collabLinkHint(host, heading, view), { dim: false });
+	showCollabQrCode(ctx, view ? host.webViewLink : host.webLink);
+}
+
+function formatFreshSessionResult(result: FreshSessionResult): string {
+	const stateLabel = result.closedProviderSessions === 1 ? "provider state" : "provider states";
+	return `Fresh provider session started (${result.closedProviderSessions} ${stateLabel} pruned).`;
+}
+
+const shutdownHandlerTui = (_command: ParsedSlashCommand, runtime: TuiSlashCommandRuntime): SlashCommandResult => {
+	runtime.ctx.editor.setText("");
+	void runtime.ctx.shutdown();
+	return commandConsumed();
+};
+
+async function handleUsageResetCommand(
+	arg: string,
+	session: AgentSession,
+	output: SlashCommandRuntime["output"],
+): Promise<void> {
+	let accounts: ResetUsageAccount[];
+	try {
+		accounts = toResetUsageAccounts(await session.listResetCredits());
+	} catch (error) {
+		await output(`Could not load saved resets: ${errorMessage(error)}`);
+		return;
+	}
+	if (accounts.length === 0) {
+		await output("No Codex accounts found. Use /login to add one.");
+		return;
+	}
+	const targetArg = arg.trim();
+	if (!targetArg) {
+		const lines = ["Saved Codex rate-limit resets:"];
+		for (const account of accounts) {
+			const detail = account.error ? `unavailable (${account.error})` : `${account.availableCount} available`;
+			lines.push(`- ${account.label}: ${detail}${account.active ? " (active)" : ""}`);
+		}
+		lines.push("", "Spend one with `/usage reset <account email>` or `/usage reset active`.");
+		await output(lines.join("\n"));
+		return;
+	}
+	const wanted = targetArg.toLowerCase();
+	const target =
+		wanted === "active"
+			? accounts.find(account => account.active)
+			: accounts.find(
+					account =>
+						account.label.toLowerCase() === wanted ||
+						account.target.email?.toLowerCase() === wanted ||
+						account.target.accountId?.toLowerCase() === wanted,
+				);
+	if (!target) {
+		await output(`No Codex account matches "${targetArg}".`);
+		return;
+	}
+	if (target.availableCount <= 0) {
+		await output(`${target.label}: no saved resets to spend.`);
+		return;
+	}
+	const outcome = await session.redeemResetCredit(target.target);
+	await output(describeRedeemOutcome(outcome, target.label));
+}
+
+const DEBUG_DUMP_NEXT_REQUEST_USAGE = "Usage: /debug dump-next-request <path>";
+
+function resolveDebugRequestDumpPath(target: string, cwd: string): string {
+	const expanded =
+		target === "~"
+			? os.homedir()
+			: target.startsWith("~/") || target.startsWith("~\\")
+				? path.join(os.homedir(), target.slice(2))
+				: target;
+	return path.resolve(cwd, expanded);
+}
+
+async function handleDebugSubcommand(
+	args: string,
+	cwd: string,
+	output: (text: string) => Promise<void> | void,
+): Promise<SlashCommandResult> {
+	const { verb, rest } = parseSubcommand(args);
+	switch (verb) {
+		case "":
+			await output(DEBUG_DUMP_NEXT_REQUEST_USAGE);
+			return commandConsumed();
+		case "dump-next-request":
+		case "dump-request":
+		case "next-request": {
+			if (!rest) {
+				await output(DEBUG_DUMP_NEXT_REQUEST_USAGE);
+				return commandConsumed();
+			}
+			const requestPath = resolveDebugRequestDumpPath(rest, cwd);
+			setNextRequestDebugPath(requestPath);
+			await output(`Next AI provider request will be dumped to ${requestPath}`);
+			return commandConsumed();
+		}
+		default:
+			await output(`Unknown /debug subcommand "${verb}". ${DEBUG_DUMP_NEXT_REQUEST_USAGE}`);
+			return commandConsumed();
+	}
+}
+
+/** Parse the `/shake` subcommand into a {@link ShakeMode}; empty defaults to elide. */
+function parseShakeMode(args: string): ShakeMode | { error: string } {
+	const verb = args.trim().toLowerCase();
+	if (verb === "" || verb === "elide") return "elide";
+	if (verb === "images") return "images";
+	return { error: `Unknown /shake mode "${verb}". Use elide or images.` };
+}
+
+const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
+	{
+		name: "settings",
+		description: "Open settings menu",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showSettingsSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "setup",
+		aliases: ["providers"],
+		description: "Open provider setup",
+		allowArgs: true,
+		subcommands: [{ name: "providers", description: "Configure sign-in and web search providers" }],
+		handleTui: async (command, runtime) => {
+			const args = command.args.trim().toLowerCase();
+			const opensProviders = args === "" || args === "providers";
+			if (opensProviders) {
+				await runtime.ctx.showProviderSetup();
+			} else {
+				runtime.ctx.showWarning(`Usage: /${command.name} [providers]`);
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "plan",
+		description: "Toggle plan mode (agent plans before executing)",
+		inlineHint: "[prompt]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const hadArgs = !!command.args;
+			await runtime.ctx.handlePlanModeCommand(command.args || undefined);
+			if (hadArgs) {
+				runtime.ctx.editor.addToHistory(command.text);
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "plan-review",
+		description: "Re-open the plan review for the latest plan (plan mode only)",
+		handleTui: async (_command, runtime) => {
+			await runtime.ctx.openPlanReview();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "goal",
+		description: "Toggle goal mode (persistent autonomous objective for this session)",
+		subcommands: [
+			{ name: "set", description: "Set or replace the goal", usage: "<objective>" },
+			{ name: "show", description: "Show current goal details" },
+			{ name: "pause", description: "Pause the current goal" },
+			{ name: "resume", description: "Resume a paused goal" },
+			{ name: "drop", description: "Drop the current goal" },
+			{ name: "budget", description: "Adjust the token budget", usage: "<N|off>" },
+		],
+		inlineHint: "[objective]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const hadArgs = !!command.args;
+			await runtime.ctx.handleGoalModeCommand(command.args || undefined);
+			if (hadArgs) {
+				runtime.ctx.editor.addToHistory(command.text);
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "guided-goal",
+		description: "Interview and refine a goal before enabling goal mode",
+		inlineHint: "[rough objective]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleGuidedGoalCommand(command.args || undefined);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "loop",
+		description:
+			"Toggle loop mode. While enabled, the next prompt you send re-submits after every yield. Esc cancels the current iteration; /loop again to disable.",
+		inlineHint: "[count|duration] [prompt]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const prompt = await runtime.ctx.handleLoopCommand(command.args);
+			runtime.ctx.editor.setText("");
+			// Surface any inline prompt so the dispatcher returns it and the normal
+			// submit flow runs the first loop iteration (recording it as the loop prompt).
+			if (prompt) return { prompt };
+		},
+	},
+	{
+		name: "model",
+		aliases: ["models"],
+		description: "Switch model for this session",
+		acpDescription: "Show current model selection",
+		handle: async (command, runtime) => {
+			if (command.args) {
+				const modelId = command.args.trim();
+				const availableModels = runtime.session.getAvailableModels?.() ?? [];
+				const match = availableModels.find(
+					model => model.id === modelId || `${model.provider}/${model.id}` === modelId,
+				);
+				if (!match) {
+					return usage(
+						`Unknown model: ${modelId}. Use ACP \`session/setModel\` for picker-driven selection or list available models with /model.`,
+						runtime,
+					);
+				}
+				try {
+					await runtime.session.setModel(match);
+					await runtime.output(`Model set to ${match.provider}/${match.id}.`);
+					await runtime.notifyTitleChanged?.();
+					await runtime.notifyConfigChanged?.();
+					return commandConsumed();
+				} catch (err) {
+					return usage(`Failed to set model: ${errorMessage(err)}`, runtime);
+				}
+			}
+
+			const model = runtime.session.model;
+			await runtime.output(
+				model ? `Current model: ${model.provider}/${model.id}` : "No model is currently selected.",
+			);
+			return commandConsumed();
+		},
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showModelSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "switch",
+		description: "Switch model for this session (same as alt+p)",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showModelSelector({ temporaryOnly: true });
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "fast",
+		description: "Toggle priority service tier (OpenAI service_tier=priority, Anthropic speed=fast)",
+		acpDescription: "Toggle fast mode",
+		acpInputHint: "[on|off|status]",
+		subcommands: [
+			{ name: "on", description: "Enable fast mode" },
+			{ name: "off", description: "Disable fast mode" },
+			{ name: "status", description: "Show fast mode status" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const arg = command.args.toLowerCase();
+			if (!arg || arg === "toggle") {
+				const enabled = runtime.session.toggleFastMode();
+				await runtime.output(`Fast mode ${enabled ? "enabled" : "disabled"}.`);
+				return commandConsumed();
+			}
+			if (arg === "on") {
+				runtime.session.setFastMode(true);
+				await runtime.output("Fast mode enabled.");
+				return commandConsumed();
+			}
+			if (arg === "off") {
+				runtime.session.setFastMode(false);
+				await runtime.output("Fast mode disabled.");
+				return commandConsumed();
+			}
+			if (arg === "status") {
+				await runtime.output(`Fast mode is ${formatFastModeStatus(runtime.session)}.`);
+				return commandConsumed();
+			}
+			return usage("Usage: /fast [on|off|status]", runtime);
+		},
+		handleTui: (command, runtime) => {
+			const arg = command.args.trim().toLowerCase();
+			if (!arg || arg === "toggle") {
+				const enabled = runtime.ctx.session.toggleFastMode();
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.showStatus(`Fast mode ${enabled ? "enabled" : "disabled"}.`);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "on") {
+				runtime.ctx.session.setFastMode(true);
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.showStatus("Fast mode enabled.");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "off") {
+				runtime.ctx.session.setFastMode(false);
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.showStatus("Fast mode disabled.");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (arg === "status") {
+				runtime.ctx.showStatus(`Fast mode is ${formatFastModeStatus(runtime.ctx.session)}.`);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /fast [on|off|status]");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "advisor",
+		description: "Toggle the advisor (a second model that reviews each turn and injects notes)",
+		acpDescription: "Toggle advisor",
+		acpInputHint: "[on|off|status|dump [raw]]",
+		subcommands: [
+			{ name: "on", description: "Enable the advisor" },
+			{ name: "off", description: "Disable the advisor" },
+			{ name: "status", description: "Show advisor status" },
+			{ name: "dump", description: "Copy the advisor's transcript to clipboard", usage: "[raw]" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || verb === "toggle") {
+				const active = runtime.session.toggleAdvisorEnabled();
+				const configured = runtime.session.isAdvisorEnabled();
+				if (active) {
+					await runtime.output("Advisor enabled.");
+				} else if (configured) {
+					await runtime.output("Advisor setting enabled, but no model is assigned to the 'advisor' role.");
+				} else {
+					await runtime.output("Advisor disabled.");
+				}
+				return commandConsumed();
+			}
+			if (verb === "on") {
+				const active = runtime.session.setAdvisorEnabled(true);
+				await runtime.output(
+					active ? "Advisor enabled." : "Advisor setting enabled, but no model is assigned to the 'advisor' role.",
+				);
+				return commandConsumed();
+			}
+			if (verb === "off") {
+				runtime.session.setAdvisorEnabled(false);
+				await runtime.output("Advisor disabled.");
+				return commandConsumed();
+			}
+			if (verb === "status") {
+				await runtime.output(runtime.session.formatAdvisorStatus());
+				return commandConsumed();
+			}
+			if (verb === "dump") {
+				const isRaw = rest.toLowerCase() === "raw";
+				const text = runtime.session.formatAdvisorHistoryAsText({ compact: !isRaw });
+				await runtime.output(text ?? "Advisor is not active for this session.");
+				return commandConsumed();
+			}
+			return usage("Usage: /advisor [on|off|status|dump [raw]]", runtime);
+		},
+		handleTui: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || verb === "toggle") {
+				const active = runtime.ctx.session.toggleAdvisorEnabled();
+				const configured = runtime.ctx.session.isAdvisorEnabled();
+				if (active) {
+					runtime.ctx.showStatus("Advisor enabled.");
+				} else if (configured) {
+					runtime.ctx.showStatus("Advisor setting enabled, but no model is assigned to the 'advisor' role.");
+				} else {
+					runtime.ctx.showStatus("Advisor disabled.");
+				}
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "on") {
+				const active = runtime.ctx.session.setAdvisorEnabled(true);
+				runtime.ctx.showStatus(
+					active ? "Advisor enabled." : "Advisor setting enabled, but no model is assigned to the 'advisor' role.",
+				);
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "off") {
+				runtime.ctx.session.setAdvisorEnabled(false);
+				runtime.ctx.showStatus("Advisor disabled.");
+				refreshStatusLine(runtime.ctx);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "status") {
+				await runtime.ctx.handleAdvisorStatusCommand();
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "dump") {
+				const isRaw = rest.toLowerCase() === "raw";
+				runtime.ctx.handleAdvisorDumpCommand(isRaw);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /advisor [on|off|status|dump [raw]]");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "export",
+		description: "Export session to HTML file",
+		inlineHint: "[path]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const arg = command.args.trim();
+			// Match the interactive `/export` behavior: clipboard aliases are not a
+			// valid export target. Without this, the literal value (`copy`,
+			// `--copy`, `clipboard`) is passed to `exportToHtml` and becomes the
+			// output filename.
+			if (arg === "--copy" || arg === "clipboard" || arg === "copy") {
+				return usage("Use /dump to copy the session to clipboard.", runtime);
+			}
+			try {
+				const filePath = await runtime.session.exportToHtml(arg || undefined);
+				await runtime.output(`Session exported to: ${filePath}`);
+				return commandConsumed();
+			} catch (err) {
+				return usage(`Failed to export session: ${errorMessage(err)}`, runtime);
+			}
+		},
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleExportCommand(command.text);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "dump",
+		description: "Copy session transcript to clipboard",
+		acpDescription: "Return full transcript as plain text",
+		allowArgs: true,
+		handle: async (_command, runtime) => {
+			const text = runtime.session.formatSessionAsText();
+			await runtime.output(text || "No messages to dump yet.");
+			return commandConsumed();
+		},
+		handleTui: (_command, runtime) => {
+			runtime.ctx.handleDumpCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "share",
+		description: "Share session via an encrypted link (secret gist or share server)",
+		handle: async (_command, runtime) => {
+			try {
+				const result = await shareSession(runtime.sessionManager, {
+					serverUrl: runtime.settings.get("share.serverUrl"),
+					state: runtime.session.state,
+					obfuscator: runtime.settings.get("share.redactSecrets") ? runtime.session.obfuscator : undefined,
+				});
+				const lines = [`Share URL: ${result.url}`];
+				if (result.gistUrl) lines.push(`Gist: ${result.gistUrl}`);
+				if (result.truncated) lines.push("Note: large content was trimmed to fit the share size limit.");
+				await runtime.output(lines.join("\n"));
+				return commandConsumed();
+			} catch (err) {
+				return usage(`Failed to share session: ${errorMessage(err)}`, runtime);
+			}
+		},
+		handleTui: async (_command, runtime) => {
+			await runtime.ctx.handleShareCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "collab",
+		description: "Share this session live via a relay",
+		inlineHint: "[start|view|stop|status] [relayUrl]",
+		subcommands: [
+			{ name: "view", description: "Share a read-only link (guests can watch, not prompt)" },
+			{ name: "status", description: "Show link + participants" },
+			{ name: "stop", description: "Stop sharing" },
+		],
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const ctx = runtime.ctx;
+			ctx.editor.setText("");
+			const args = command.args.trim();
+			const { verb, rest } = parseSubcommand(args);
+			if (verb === "stop") {
+				if (!ctx.collabHost) {
+					ctx.showStatus("Not hosting a collab session");
+					return;
+				}
+				await ctx.collabHost.stop("host stopped");
+				ctx.showStatus("Collab stopped");
+				return;
+			}
+			if (verb === "status") {
+				if (ctx.collabHost) {
+					const names = ctx.collabHost.participants.map(p =>
+						p.role === "host" ? `${p.name} (host)` : p.readOnly ? `${p.name} (view-only)` : p.name,
+					);
+					ctx.showStatus(`Collab: ${names.join(", ")} — ${collabWebLinkClickable(ctx.collabHost.webLink)}`);
+				} else if (ctx.collabGuest) {
+					ctx.showStatus(
+						ctx.collabGuest.readOnly
+							? "In a collab session as a read-only guest (/leave to exit)"
+							: "In a collab session as a guest (/leave to exit)",
+					);
+				} else {
+					ctx.showStatus("Not in a collab session");
+				}
+				return;
+			}
+			if (ctx.collabGuest) {
+				ctx.showError("Already in a collab session as a guest (/leave first)");
+				return;
+			}
+			const knownStartVerb = verb === "start" || verb === "view";
+			const view = verb === "view";
+			if (ctx.collabHost) {
+				showCollabLink(
+					ctx,
+					ctx.collabHost,
+					view ? "Read-only collab session active" : "Collab session active",
+					view,
+				);
+				return;
+			}
+			const explicitUrl = knownStartVerb ? rest : args;
+			const relayInput = explicitUrl || ctx.settings.get("collab.relayUrl") || "";
+			if (!relayInput) {
+				ctx.showError(
+					"No relay configured. Set collab.relayUrl in /settings or pass one: /collab relay.example.com",
+				);
+				return;
+			}
+			// Scheme-less relay args default to wss (ws:// must be spelled out for localhost).
+			const relayUrl = relayInput.includes("://") ? relayInput : `wss://${relayInput}`;
+			const webUrl = ctx.settings.get("collab.webUrl") || "";
+			const host = new CollabHost(ctx);
+			try {
+				await host.start(relayUrl, webUrl);
+			} catch (err) {
+				ctx.showError(`Failed to start collab session: ${errorMessage(err)}`);
+				return;
+			}
+			ctx.collabHost = host;
+			showCollabLink(ctx, host, "Collab session started!", view);
+		},
+	},
+	{
+		name: "join",
+		description: "Join a shared collab session",
+		inlineHint: "<link>",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const ctx = runtime.ctx;
+			ctx.editor.setText("");
+			const link = command.args.trim();
+			if (!link) {
+				ctx.showError("Usage: /join <link>");
+				return;
+			}
+			if (ctx.collabHost) {
+				ctx.showError("Stop hosting first (/collab stop)");
+				return;
+			}
+			if (ctx.collabGuest) {
+				ctx.showError("Already in a collab session (/leave first)");
+				return;
+			}
+			try {
+				await new CollabGuestLink(ctx).join(link);
+			} catch (err) {
+				ctx.showError(`Failed to join collab session: ${errorMessage(err)}`);
+			}
+		},
+	},
+	{
+		name: "leave",
+		description: "Leave the collab session",
+		handleTui: async (_command, runtime) => {
+			const ctx = runtime.ctx;
+			ctx.editor.setText("");
+			if (ctx.collabGuest) {
+				await ctx.collabGuest.leave("left");
+				return;
+			}
+			if (ctx.collabHost) {
+				await ctx.collabHost.stop("host stopped");
+				ctx.showStatus("Collab stopped");
+				return;
+			}
+			ctx.showStatus("Not in a collab session");
+		},
+	},
+	{
+		name: "browser",
+		description: "Toggle browser headless vs visible mode",
+		acpInputHint: "[headless|visible]",
+		subcommands: [
+			{ name: "headless", description: "Switch to headless mode" },
+			{ name: "visible", description: "Switch to visible mode" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const arg = command.args.toLowerCase();
+			const enabled = runtime.settings.get("browser.enabled" as SettingPath) as boolean;
+			if (!enabled) return usage("Browser tool is disabled (enable in settings).", runtime);
+			const current = runtime.settings.get("browser.headless" as SettingPath) as boolean;
+			let next = current;
+			if (!arg) next = !current;
+			else if (arg === "headless" || arg === "hidden") next = true;
+			else if (arg === "visible" || arg === "show" || arg === "headful") next = false;
+			else return usage("Usage: /browser [headless|visible]", runtime);
+			runtime.settings.set("browser.headless" as SettingPath, next as SettingValue<SettingPath>);
+			const tool = runtime.session.getToolByName("browser");
+			if (tool && "restartForModeChange" in tool) {
+				try {
+					await (tool as { restartForModeChange: () => Promise<void> }).restartForModeChange();
+				} catch (err) {
+					// Setting was already mutated; surface the restart failure so the
+					// user knows the browser is in an inconsistent state.
+					await runtime.output(
+						`Browser mode set to ${next ? "headless" : "visible"}, but restart failed: ${errorMessage(err)}`,
+					);
+					return commandConsumed();
+				}
+			}
+			await runtime.output(`Browser mode: ${next ? "headless" : "visible"}`);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			const arg = command.args.toLowerCase();
+			const current = settings.get("browser.headless" as SettingPath) as boolean;
+			let next = current;
+			if (!(settings.get("browser.enabled" as SettingPath) as boolean)) {
+				runtime.ctx.showWarning("Browser tool is disabled (enable in settings)");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (!arg) {
+				next = !current;
+			} else if (arg === "headless" || arg === "hidden") {
+				next = true;
+			} else if (arg === "visible" || arg === "show" || arg === "headful") {
+				next = false;
+			} else {
+				runtime.ctx.showStatus("Usage: /browser [headless|visible]");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			settings.set("browser.headless" as SettingPath, next as SettingValue<SettingPath>);
+			const tool = runtime.ctx.session.getToolByName("browser");
+			if (tool && "restartForModeChange" in tool) {
+				try {
+					await (tool as { restartForModeChange: () => Promise<void> }).restartForModeChange();
+				} catch (error) {
+					runtime.ctx.showWarning(`Failed to restart browser: ${errorMessage(error)}`);
+					runtime.ctx.editor.setText("");
+					return;
+				}
+			}
+			runtime.ctx.showStatus(`Browser mode: ${next ? "headless" : "visible"}`);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "copy",
+		description: "Pick text or code from the conversation to copy",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showCopySelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "todo",
+		description: "View or modify the agent's todo list",
+		acpDescription: "Manage todos",
+		acpInputHint: "<subcommand>",
+		subcommands: [
+			{ name: "edit", description: "Open todos in $EDITOR (Markdown round-trip)" },
+			{ name: "copy", description: "Copy todos as Markdown to clipboard" },
+			{ name: "export", description: "Write todos as Markdown to a file (default: TODO.md)", usage: "[<path>]" },
+			{ name: "import", description: "Replace todos from a Markdown file (default: TODO.md)", usage: "[<path>]" },
+			{
+				name: "append",
+				description: "Append a task; phase fuzzy-matched or auto-created",
+				usage: "[<phase>] <task...>",
+			},
+			{ name: "start", description: "Mark task in_progress (fuzzy-matched)", usage: "<task>" },
+			{ name: "done", description: "Mark task/phase/all completed (fuzzy-matched)", usage: "[<task|phase>]" },
+			{ name: "drop", description: "Mark task/phase/all abandoned (fuzzy-matched)", usage: "[<task|phase>]" },
+			{ name: "rm", description: "Remove task/phase/all (fuzzy-matched)", usage: "[<task|phase>]" },
+		],
+		allowArgs: true,
+		handle: handleTodoAcp,
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleTodoCommand(command.args);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "session",
+		description: "Session management commands",
+		acpDescription: "Show session information",
+		acpInputHint: "info|delete",
+		subcommands: [
+			{ name: "info", description: "Show session info and stats" },
+			{ name: "delete", description: "Delete current session and return to selector" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			if (!command.args || command.args === "info") {
+				await runtime.output(
+					[
+						`Session: ${runtime.session.sessionId}`,
+						`Title: ${runtime.session.sessionName}`,
+						`CWD: ${runtime.cwd}`,
+					].join("\n"),
+				);
+				return commandConsumed();
+			}
+			if (command.args === "delete") {
+				if (runtime.session.isStreaming) return usage("Cannot delete the session while streaming.", runtime);
+				const sessionFile = runtime.sessionManager.getSessionFile();
+				if (!sessionFile) return usage("No session file to delete (in-memory session).", runtime);
+				// Route through the active SessionManager so the persist writer is
+				// closed before the file is deleted. Constructing a fresh
+				// FileSessionStorage and calling deleteSessionWithArtifacts leaves
+				// the active writer attached to the now-deleted path, so the next
+				// prompt would silently resurrect or corrupt the "deleted" file.
+				try {
+					await runtime.sessionManager.dropSession(sessionFile);
+				} catch (err) {
+					return usage(`Failed to delete session: ${errorMessage(err)}`, runtime);
+				}
+				await runtime.output(
+					`Session deleted: ${sessionFile}. Use ACP \`session/load\` to switch to another session.`,
+				);
+				return commandConsumed();
+			}
+			return usage("Usage: /session [info|delete]", runtime);
+		},
+		handleTui: async (command, runtime) => {
+			const sub = command.args.trim().toLowerCase() || "info";
+			if (sub === "delete") {
+				runtime.ctx.editor.setText("");
+				await runtime.ctx.handleSessionDeleteCommand();
+				return;
+			}
+			// Default: show session info
+			await runtime.ctx.handleSessionCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "jobs",
+		description: "Show async background jobs status",
+		acpDescription: "Show background jobs",
+		handle: async (_command, runtime) => {
+			const snapshot = runtime.session.getAsyncJobSnapshot({ recentLimit: 5 });
+			if (!snapshot || (snapshot.running.length === 0 && snapshot.recent.length === 0)) {
+				await runtime.output(
+					"No background jobs running. (Background jobs run async tools — e.g. long-running bash, debug, or task subagents that would otherwise tie up a turn. They appear here while alive and for ~5 minutes after.)",
+				);
+				return commandConsumed();
+			}
+			const now = Date.now();
+			const lines: string[] = ["Background Jobs", `Running: ${snapshot.running.length}`];
+			if (snapshot.running.length > 0) {
+				lines.push("", "Running Jobs");
+				for (const job of snapshot.running) {
+					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(now - job.startTime)}`);
+					lines.push(`    ${job.label}`);
+				}
+			}
+			if (snapshot.recent.length > 0) {
+				lines.push("", "Recent Jobs");
+				for (const job of snapshot.recent) {
+					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(now - job.startTime)}`);
+					lines.push(`    ${job.label}`);
+				}
+			}
+			await runtime.output(lines.join("\n"));
+			return commandConsumed();
+		},
+		handleTui: async (_command, runtime) => {
+			await runtime.ctx.handleJobsCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "usage",
+		description: "Show provider usage and limits",
+		acpDescription: "Show token usage",
+		acpInputHint: "[show|reset [account|active]]",
+		subcommands: [
+			{ name: "show", description: "Show provider usage and limits" },
+			{ name: "reset", description: "Spend a saved Codex rate-limit reset", usage: "[account|active]" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || (verb === "show" && !rest)) {
+				await runtime.output(await buildUsageReportText(runtime));
+				return commandConsumed();
+			}
+			if (verb === "reset") {
+				await handleUsageResetCommand(rest, runtime.session, runtime.output);
+				return commandConsumed();
+			}
+			return usage("Usage: /usage [show|reset [account|active]]", runtime);
+		},
+		handleTui: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb || (verb === "show" && !rest)) {
+				await runtime.ctx.handleUsageCommand();
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			if (verb === "reset") {
+				if (rest) {
+					await handleUsageResetCommand(rest, runtime.ctx.session, text => runtime.ctx.showStatus(text));
+				} else {
+					await runtime.ctx.showResetUsageSelector();
+				}
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.showStatus("Usage: /usage [show|reset [account|active]]");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "stats",
+		description: "Launch the local stats dashboard",
+		inlineHint: "[--port <port>]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const parsed = parseStatsDashboardArgs(command.args);
+			if ("error" in parsed) return usage(parsed.error, runtime);
+
+			await runtime.output("Syncing session files...");
+			try {
+				const result = await launchStatsDashboard(parsed);
+				await runtime.output(result.message);
+			} catch (error) {
+				await runtime.output(`Stats dashboard failed: ${errorMessage(error)}`);
+			}
+			return commandConsumed();
+		},
+	},
+	{
+		name: "changelog",
+		description: "Show changelog entries",
+		acpDescription: "Show changelog",
+		acpInputHint: "[full]",
+		subcommands: [{ name: "full", description: "Show complete changelog" }],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const changelogPath = getChangelogPath();
+			const allEntries = await parseChangelog(changelogPath);
+			const showFull = command.args.trim().toLowerCase() === "full";
+			const entriesToShow = showFull ? allEntries : allEntries.slice(0, 3);
+			if (entriesToShow.length === 0) {
+				await runtime.output("No changelog entries found.");
+				return commandConsumed();
+			}
+			await runtime.output(
+				[...entriesToShow]
+					.reverse()
+					.map(entry => entry.content)
+					.join("\n\n"),
+			);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			const showFull = command.args.split(/\s+/).filter(Boolean).includes("full");
+			await runtime.ctx.handleChangelogCommand(showFull);
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "hotkeys",
+		description: "Show all keyboard shortcuts",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.handleHotkeysCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "tools",
+		description: "Show tools currently visible to the agent",
+		acpDescription: "Show available tools",
+		handle: async (_command, runtime) => {
+			const active = runtime.session.getActiveToolNames();
+			const all = runtime.session.getAllToolNames();
+			if (all.length === 0) {
+				await runtime.output("No tools are available.");
+				return commandConsumed();
+			}
+			await runtime.output(all.map(name => `${active.includes(name) ? "*" : "-"} ${name}`).join("\n"));
+			return commandConsumed();
+		},
+		handleTui: (_command, runtime) => {
+			runtime.ctx.handleToolsCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "context",
+		description: "Show estimated context usage breakdown",
+		acpDescription: "Show context usage",
+		handle: async (_command, runtime) => {
+			await runtime.output(buildContextReportText(runtime));
+			return commandConsumed();
+		},
+		handleTui: (_command, runtime) => {
+			runtime.ctx.handleContextCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "extensions",
+		aliases: ["status"],
+		description: "Open Extension Control Center dashboard",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showExtensionsDashboard();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "agents",
+		description: "Open Agent Control Center dashboard",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showAgentsDashboard();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "branch",
+		description: "Create a new branch from a previous message",
+		handleTui: (_command, runtime) => {
+			if (settings.get("doubleEscapeAction") === "tree") {
+				runtime.ctx.showTreeSelector();
+			} else {
+				runtime.ctx.showUserMessageSelector();
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "fork",
+		description: "Create a new fork from a previous message",
+		handleTui: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleForkCommand();
+		},
+	},
+	{
+		name: "tree",
+		description: "Navigate session tree (switch branches)",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showTreeSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "login",
+		description: "Login with OAuth provider",
+		inlineHint: "[provider|redirect URL]",
+		allowArgs: true,
+		handleTui: (command, runtime) => {
+			const manualInput = runtime.ctx.oauthManualInput;
+			const args = command.args.trim();
+			if (args.length > 0) {
+				const matchedProvider = getOAuthProviders().find(provider => provider.id === args);
+				if (matchedProvider) {
+					if (manualInput.hasPending()) {
+						const pendingProvider = manualInput.pendingProviderId;
+						const message = pendingProvider
+							? `OAuth login already in progress for ${pendingProvider}. Paste the redirect URL with /login <url>.`
+							: "OAuth login already in progress. Paste the redirect URL with /login <url>.";
+						runtime.ctx.showWarning(message);
+						runtime.ctx.editor.setText("");
+						return;
+					}
+					void runtime.ctx.showOAuthSelector("login", matchedProvider.id);
+					runtime.ctx.editor.setText("");
+					return;
+				}
+				const submitted = manualInput.submit(args);
+				if (submitted) {
+					runtime.ctx.showStatus("OAuth callback received; completing login…");
+				} else {
+					runtime.ctx.showWarning("No OAuth login is waiting for a manual callback.");
+				}
+				runtime.ctx.editor.setText("");
+				return;
+			}
+
+			if (manualInput.hasPending()) {
+				const provider = manualInput.pendingProviderId;
+				const message = provider
+					? `OAuth login already in progress for ${provider}. Paste the redirect URL with /login <url>.`
+					: "OAuth login already in progress. Paste the redirect URL with /login <url>.";
+				runtime.ctx.showWarning(message);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+
+			void runtime.ctx.showOAuthSelector("login");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "logout",
+		description: "Logout from OAuth provider",
+		inlineHint: "[provider]",
+		allowArgs: true,
+		handleTui: (command, runtime) => {
+			const providerId = command.args.trim();
+			if (providerId) {
+				const matchedProvider = getOAuthProviders().find(provider => provider.id === providerId);
+				if (!matchedProvider) {
+					runtime.ctx.showWarning(`Unknown OAuth provider: ${providerId}`);
+					runtime.ctx.editor.setText("");
+					return;
+				}
+				void runtime.ctx.showOAuthSelector("logout", matchedProvider.id);
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			void runtime.ctx.showOAuthSelector("logout");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "mcp",
+		description: "Manage MCP servers (add, list, remove, test)",
+		acpDescription: "Manage MCP servers",
+		inlineHint: "<subcommand>",
+		subcommands: [
+			{
+				name: "add",
+				description: "Add a new MCP server",
+				usage: "<name> [--scope project|user] [--url <url>] [-- <command...>]",
+			},
+			{ name: "list", description: "List all configured MCP servers" },
+			{ name: "remove", description: "Remove an MCP server", usage: "<name> [--scope project|user]" },
+			{ name: "test", description: "Test connection to a server", usage: "<name>" },
+			{ name: "reauth", description: "Reauthorize OAuth for a server", usage: "<name>" },
+			{ name: "unauth", description: "Remove OAuth auth from a server", usage: "<name>" },
+			{ name: "enable", description: "Enable an MCP server", usage: "<name>" },
+			{ name: "disable", description: "Disable an MCP server", usage: "<name>" },
+			{
+				name: "smithery-search",
+				description: "Search Smithery registry and deploy an MCP server",
+				usage: "<keyword> [--scope project|user] [--limit <1-100>] [--semantic]",
+			},
+			{ name: "smithery-login", description: "Login to Smithery and cache API key" },
+			{ name: "smithery-logout", description: "Remove cached Smithery API key" },
+			{ name: "reconnect", description: "Reconnect to a specific MCP server", usage: "<name>" },
+			{ name: "reload", description: "Force reload MCP runtime tools" },
+			{ name: "resources", description: "List available resources from connected servers" },
+			{ name: "prompts", description: "List available prompts from connected servers" },
+			{ name: "notifications", description: "Show notification capabilities and subscriptions" },
+			{ name: "help", description: "Show help message" },
+		],
+		allowArgs: true,
+		handle: handleMcpAcp,
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.addToHistory(command.text);
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleMCPCommand(command.text);
+		},
+	},
+	{
+		name: "ssh",
+		description: "Manage SSH hosts (add, list, remove)",
+		acpDescription: "Manage SSH connections",
+		inlineHint: "<subcommand>",
+		subcommands: [
+			{
+				name: "add",
+				description: "Add an SSH host",
+				usage: "<name> --host <host> [--user <user>] [--port <port>] [--key <keyPath>]",
+			},
+			{ name: "list", description: "List all configured SSH hosts" },
+			{ name: "remove", description: "Remove an SSH host", usage: "<name> [--scope project|user]" },
+			{ name: "help", description: "Show help message" },
+		],
+		allowArgs: true,
+		handle: handleSshAcp,
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.addToHistory(command.text);
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleSSHCommand(command.text);
+		},
+	},
+	{
+		name: "new",
+		description: "Start a new session",
+		handleTui: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleClearCommand();
+		},
+	},
+	{
+		name: "fresh",
+		description: "Reset provider stream state without changing the local transcript",
+		handle: async (_command, runtime) => {
+			const result = runtime.session.freshSession();
+			if (!result) {
+				await runtime.output(
+					"Wait for the current response to finish or abort it before refreshing provider state.",
+				);
+				return commandConsumed();
+			}
+			await runtime.output(formatFreshSessionResult(result));
+			return commandConsumed();
+		},
+		handleTui: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleFreshCommand();
+		},
+	},
+	{
+		name: "drop",
+		description: "Delete the current session and start a new one",
+		handleTui: async (_command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleDropCommand();
+		},
+	},
+	{
+		name: "compact",
+		description: "Manually compact the session context",
+		acpDescription: "Compact the conversation",
+		subcommands: COMPACT_MODES.map(mode => ({
+			name: mode.name,
+			description: mode.description,
+			usage: mode.rejectsFocus ? undefined : "[focus]",
+		})),
+		acpInputHint: `[${COMPACT_MODES.map(mode => mode.name).join("|")}] [focus]`,
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const parsed = parseCompactArgs(command.args);
+			if ("error" in parsed) return usage(parsed.error, runtime);
+			const before = runtime.session.getContextUsage?.();
+			const beforeTokens = before?.tokens;
+			try {
+				await runtime.session.compact(parsed.instructions, parsed.mode ? { mode: parsed.mode } : undefined);
+			} catch (err) {
+				// Compaction precondition failures (no model, already compacted, too
+				// small) and provider errors propagate as plain Errors; surface them
+				// via runtime.output so they don't fail the ACP prompt turn.
+				return usage(`Compaction failed: ${errorMessage(err)}`, runtime);
+			}
+			const after = runtime.session.getContextUsage?.();
+			const afterTokens = after?.tokens;
+			if (beforeTokens != null && afterTokens != null) {
+				const saved = beforeTokens - afterTokens;
+				await runtime.output(`Compaction complete. Tokens: ${beforeTokens} -> ${afterTokens} (saved ${saved}).`);
+			} else {
+				await runtime.output("Compaction complete.");
+			}
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			const parsed = parseCompactArgs(command.args);
+			runtime.ctx.editor.setText("");
+			if ("error" in parsed) {
+				runtime.ctx.showWarning(parsed.error);
+				return;
+			}
+			await runtime.ctx.handleCompactCommand(parsed.instructions, parsed.mode);
+		},
+	},
+	{
+		name: "shake",
+		description: "Drop heavy content from context (tool results, large blocks)",
+		acpDescription: "Shake heavy content out of the conversation context",
+		subcommands: [
+			{ name: "elide", description: "Strip tool results + large blocks (default)" },
+			{ name: "images", description: "Strip image blocks" },
+		],
+		acpInputHint: "[elide|images]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const mode = parseShakeMode(command.args);
+			if (typeof mode !== "string") return usage(mode.error, runtime);
+			const result = await runtime.session.shake(mode);
+			await runtime.output(formatShakeSummary(result));
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			const mode = parseShakeMode(command.args);
+			if (typeof mode !== "string") {
+				runtime.ctx.showWarning(mode.error);
+				return;
+			}
+			await runtime.ctx.handleShakeCommand(mode);
+		},
+	},
+	{
+		name: "handoff",
+		description: "Hand off session context to a new session",
+		inlineHint: "[focus instructions]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const customInstructions = command.args || undefined;
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleHandoffCommand(customInstructions);
+		},
+	},
+	{
+		name: "resume",
+		description: "Resume a different session",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showSessionSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "btw",
+		description: "Ask an ephemeral side question using the current session context",
+		inlineHint: "<question>",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const question = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleBtwCommand(question);
+		},
+	},
+	{
+		name: "tan",
+		description: "Run a full background agent on tangential work",
+		inlineHint: "<work>",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const work = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleTanCommand(work);
+		},
+	},
+	{
+		name: "omfg",
+		description: "Forge a TTSR rule from a complaint to stop a recurring behavior",
+		inlineHint: "<complaint>",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			const complaint = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleOmfgCommand(complaint);
+		},
+	},
+	{
+		name: "retry",
+		description: "Retry the last failed agent turn",
+		handleTui: async (_command, runtime) => {
+			const didRetry = await runtime.ctx.session.retry();
+			if (!didRetry) {
+				runtime.ctx.showStatus("Nothing to retry");
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "debug",
+		description: "Open debug tools selector",
+		allowArgs: true,
+		subcommands: [
+			{
+				name: "dump-next-request",
+				description: "Dump the next AI provider HTTP request as JSON",
+				usage: "<path>",
+			},
+		],
+		handle: async (command, runtime) =>
+			handleDebugSubcommand(command.args, runtime.cwd, text => runtime.output(text)),
+		handleTui: async (command, runtime) => {
+			const args = command.args.trim();
+			if (args.length === 0) {
+				runtime.ctx.showDebugSelector();
+			} else {
+				await handleDebugSubcommand(args, runtime.ctx.sessionManager.getCwd(), text =>
+					runtime.ctx.showStatus(text),
+				);
+			}
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "memory",
+		description: "Inspect and operate memory maintenance",
+		acpDescription: "Manage memory",
+		acpInputHint: "<subcommand>",
+		subcommands: [
+			{ name: "view", description: "Show current memory injection payload" },
+			{ name: "stats", description: "Show memory backend statistics" },
+			{ name: "diagnose", description: "Run memory backend diagnostics" },
+			{ name: "clear", description: "Clear persisted memory data and artifacts" },
+			{ name: "reset", description: "Alias for clear" },
+			{ name: "enqueue", description: "Enqueue memory consolidation maintenance" },
+			{ name: "rebuild", description: "Alias for enqueue" },
+			{ name: "mm list", description: "List mental models on the active bank" },
+			{ name: "mm show", description: "Show one mental model (id required)" },
+			{
+				name: "mm refresh",
+				description: "Refresh auto-refresh models bank-wide, or one model by id",
+			},
+			{ name: "mm history", description: "Diff the change history of a mental model" },
+			{ name: "mm seed", description: "Create any built-in mental models that are missing" },
+			{ name: "mm delete", description: "Delete a mental model from the bank (id required)" },
+			{ name: "mm reload", description: "Re-pull the cached <mental_models> block" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const verb = (command.args.trim().split(/\s+/)[0] ?? "").toLowerCase() || "view";
+			const backend = await resolveMemoryBackend(runtime.settings);
+			switch (verb) {
+				case "view": {
+					const payload = await backend.buildDeveloperInstructions(
+						runtime.settings.getAgentDir(),
+						runtime.settings,
+						runtime.session,
+					);
+					await runtime.output(payload || "Memory payload is empty.");
+					return commandConsumed();
+				}
+				case "clear":
+				case "reset": {
+					await backend.clear(runtime.settings.getAgentDir(), runtime.cwd, runtime.session);
+					await runtime.session.refreshBaseSystemPrompt();
+					await runtime.output("Memory cleared.");
+					return commandConsumed();
+				}
+				case "enqueue":
+				case "rebuild": {
+					await backend.enqueue(runtime.settings.getAgentDir(), runtime.cwd, runtime.session);
+					await runtime.output("Memory consolidation enqueued.");
+					return commandConsumed();
+				}
+				case "stats":
+				case "diagnose": {
+					const hook = verb === "stats" ? backend.stats : backend.diagnose;
+					const payload = await hook?.(runtime.settings.getAgentDir(), runtime.cwd, runtime.session);
+					await runtime.output(payload ?? `Memory ${verb} is not available for the ${backend.id} backend.`);
+					return commandConsumed();
+				}
+				case "mm":
+					return usage(
+						"Mental-model maintenance via /memory mm is unsupported in ACP mode; use the hindsight HTTP API directly.",
+						runtime,
+					);
+				default:
+					return usage("Usage: /memory <view|stats|diagnose|clear|reset|enqueue|rebuild>", runtime);
+			}
+		},
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleMemoryCommand(command.text);
+		},
+	},
+	{
+		name: "rename",
+		description: "Rename the current session",
+		inlineHint: "<title>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			if (!command.args) return usage("Usage: /rename <title>", runtime);
+			const ok = await runtime.sessionManager.setSessionName(command.args, "user");
+			if (!ok) {
+				await runtime.output("Session name not changed (a user-set name takes precedence).");
+				return commandConsumed();
+			}
+			await runtime.notifyTitleChanged?.();
+			await runtime.output(`Session renamed to ${command.args}.`);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			const title = command.args.trim();
+			if (!title) {
+				runtime.ctx.showError("Usage: /rename <title>");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleRenameCommand(title);
+		},
+	},
+	{
+		name: "move",
+		description: "Move session to a different working directory",
+		acpDescription: "Move the current session file",
+		inlineHint: "<path>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			if (runtime.session.isStreaming) return usage("Cannot move while streaming.", runtime);
+			if (!command.args) return usage("Usage: /move <path>", runtime);
+			const resolvedPath = path.resolve(runtime.cwd, command.args);
+			let isDirectory: boolean;
+			try {
+				isDirectory = (await fs.stat(resolvedPath)).isDirectory();
+			} catch {
+				return usage(`Directory does not exist or is not a directory: ${resolvedPath}`, runtime);
+			}
+			if (!isDirectory) return usage(`Directory does not exist or is not a directory: ${resolvedPath}`, runtime);
+			try {
+				await runtime.sessionManager.flush();
+				await runtime.sessionManager.moveTo(resolvedPath);
+			} catch (err) {
+				return usage(`Move failed: ${errorMessage(err)}`, runtime);
+			}
+			setProjectDir(resolvedPath);
+			// Reload plugin/capability caches so the next prompt sees commands and
+			// capabilities scoped to the new cwd.
+			await runtime.reloadPlugins();
+			await runtime.notifyTitleChanged?.();
+			await runtime.output(`Session moved to ${runtime.sessionManager.getCwd()}.`);
+			return commandConsumed();
+		},
+		handleTui: async (command, runtime) => {
+			const targetPath = command.args;
+			if (!targetPath) {
+				runtime.ctx.showError("Usage: /move <path>");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleMoveCommand(targetPath);
+		},
+	},
+	{
+		name: "exit",
+		description: "Exit the application",
+		handleTui: shutdownHandlerTui,
+	},
+	{
+		name: "marketplace",
+		description: "Manage marketplace plugin sources and installed plugins",
+		acpDescription: "Manage plugins from marketplaces",
+		acpInputHint: "<subcommand>",
+		subcommands: [
+			{ name: "add", description: "Add a marketplace source", usage: "<source>" },
+			{ name: "remove", description: "Remove a marketplace source", usage: "<name>" },
+			{ name: "update", description: "Update marketplace catalog(s)", usage: "[name]" },
+			{ name: "list", description: "List configured marketplaces" },
+			{ name: "discover", description: "Browse available plugins", usage: "[marketplace]" },
+			{
+				name: "install",
+				description: "Install a plugin (interactive browser if no args)",
+				usage: "[--force] [name@marketplace]",
+			},
+			{ name: "uninstall", description: "Uninstall a plugin (selector if no args)", usage: "[name@marketplace]" },
+			{ name: "installed", description: "List installed marketplace plugins" },
+			{ name: "upgrade", description: "Upgrade outdated plugins", usage: "[name@marketplace]" },
+			{ name: "help", description: "Show usage guide" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			if (!verb) {
+				try {
+					const manager = await createMarketplaceManager(runtime);
+					const marketplaces = await manager.listMarketplaces();
+					if (marketplaces.length === 0) {
+						await runtime.output(
+							"No marketplaces configured.\n\nGet started:\n  /marketplace add anthropics/claude-plugins-official\n\nThen browse with /marketplace discover",
+						);
+					} else {
+						const lines = marketplaces.map(m => `  ${m.name}  ${m.sourceUri}`);
+						await runtime.output(
+							`Marketplaces:\n${lines.join("\n")}\n\nUse /marketplace discover to browse plugins, or /marketplace help for all commands`,
+						);
+					}
+					return commandConsumed();
+				} catch (err) {
+					return usage(`Marketplace error: ${errorMessage(err)}`, runtime);
+				}
+			}
+			if (verb === "help") {
+				await runtime.output(
+					[
+						"Marketplace commands:",
+						"  /marketplace                              List configured marketplaces",
+						"  /marketplace add <source>                  Add a marketplace (e.g. owner/repo)",
+						"  /marketplace remove <name>                 Remove a marketplace",
+						"  /marketplace update [name]                 Re-fetch catalog(s)",
+						"  /marketplace list                          List configured marketplaces",
+						"  /marketplace discover [marketplace]        Browse available plugins",
+						"  /marketplace install <name@marketplace>    Install a plugin",
+						"  /marketplace uninstall <name@marketplace>  Uninstall a plugin",
+						"  /marketplace installed                     List installed plugins",
+						"  /marketplace upgrade [name@marketplace]    Upgrade plugin(s)",
+						"",
+						"Quick start:",
+						"  /marketplace add anthropics/claude-plugins-official",
+					].join("\n"),
+				);
+				return commandConsumed();
+			}
+			if ((verb === "install" || verb === "uninstall") && !rest) {
+				return usage(
+					"Interactive plugin pickers are TUI-only. Pass an explicit name@marketplace argument.",
+					runtime,
+				);
+			}
+			try {
+				const manager = await createMarketplaceManager(runtime);
+				switch (verb) {
+					case "add": {
+						if (!rest) return usage("Usage: /marketplace add <source>", runtime);
+						const entry = await manager.addMarketplace(rest);
+						await runtime.output(`Added marketplace: ${entry.name}`);
+						return commandConsumed();
+					}
+					case "remove":
+					case "rm": {
+						if (!rest) return usage("Usage: /marketplace remove <name>", runtime);
+						await manager.removeMarketplace(rest);
+						await runtime.output(`Removed marketplace: ${rest}`);
+						return commandConsumed();
+					}
+					case "update": {
+						if (rest) {
+							await manager.updateMarketplace(rest);
+							await runtime.output(`Updated marketplace: ${rest}`);
+						} else {
+							const results = await manager.updateAllMarketplaces();
+							await runtime.output(`Updated ${results.length} marketplace(s)`);
+						}
+						return commandConsumed();
+					}
+					case "list": {
+						const marketplaces = await manager.listMarketplaces();
+						if (marketplaces.length === 0) {
+							await runtime.output("No marketplaces configured.");
+						} else {
+							const lines = marketplaces.map(m => `  ${m.name}  ${m.sourceUri}`);
+							await runtime.output(`Marketplaces:\n${lines.join("\n")}`);
+						}
+						return commandConsumed();
+					}
+					case "discover": {
+						const plugins = await manager.listAvailablePlugins(rest || undefined);
+						if (plugins.length === 0) {
+							const marketplaces = await manager.listMarketplaces();
+							await runtime.output(
+								marketplaces.length === 0
+									? "No marketplaces configured. Try:\n  /marketplace add anthropics/claude-plugins-official"
+									: "No plugins available in configured marketplaces",
+							);
+							return commandConsumed();
+						}
+						const lines = ["Available plugins:"];
+						for (const plugin of plugins) {
+							lines.push(`  - ${plugin.name}${plugin.version ? `@${plugin.version}` : ""}`);
+							if (plugin.description) lines.push(`      ${plugin.description}`);
+						}
+						await runtime.output(lines.join("\n"));
+						return commandConsumed();
+					}
+					case "install": {
+						const parsed = parseMarketplaceInstallArgs(rest);
+						if ("error" in parsed) return usage(parsed.error, runtime);
+						const atIndex = parsed.installSpec.lastIndexOf("@");
+						const pluginName = parsed.installSpec.slice(0, atIndex);
+						const marketplace = parsed.installSpec.slice(atIndex + 1);
+						await manager.installPlugin(pluginName, marketplace, { force: parsed.force, scope: parsed.scope });
+						await runtime.reloadPlugins();
+						await runtime.output(`Installed ${pluginName} from ${marketplace}`);
+						return commandConsumed();
+					}
+					case "uninstall": {
+						const parsed = parsePluginScopeArgs(
+							rest,
+							"Usage: /marketplace uninstall [--scope user|project] <name@marketplace>",
+						);
+						if ("error" in parsed) return usage(parsed.error, runtime);
+						await manager.uninstallPlugin(parsed.pluginId, parsed.scope);
+						await runtime.reloadPlugins();
+						await runtime.output(`Uninstalled ${parsed.pluginId}`);
+						return commandConsumed();
+					}
+					case "installed": {
+						const installed = await manager.listInstalledPlugins();
+						if (installed.length === 0) {
+							await runtime.output("No marketplace plugins installed");
+						} else {
+							const lines = installed.map(
+								p => `  ${p.id} [${p.scope}]${p.shadowedBy ? " [shadowed]" : ""} (${p.entries.length} entry)`,
+							);
+							await runtime.output(`Installed plugins:\n${lines.join("\n")}`);
+						}
+						return commandConsumed();
+					}
+					case "upgrade": {
+						if (rest) {
+							const parsed = parsePluginScopeArgs(
+								rest,
+								"Usage: /marketplace upgrade [--scope user|project] <name@marketplace>",
+							);
+							if ("error" in parsed) return usage(parsed.error, runtime);
+							const result = await manager.upgradePlugin(parsed.pluginId, parsed.scope);
+							await runtime.reloadPlugins();
+							await runtime.output(`Upgraded ${parsed.pluginId} to ${result.version}`);
+							return commandConsumed();
+						}
+						const results = await manager.upgradeAllPlugins();
+						if (results.length === 0) {
+							await runtime.output("All marketplace plugins are up to date");
+						} else {
+							await runtime.reloadPlugins();
+							const lines = results.map(r => `  ${r.pluginId}: ${r.from} -> ${r.to}`);
+							await runtime.output(`Upgraded ${results.length} plugin(s):\n${lines.join("\n")}`);
+						}
+						return commandConsumed();
+					}
+					default:
+						return usage(
+							`Unknown /marketplace subcommand: ${verb}. Use /marketplace help for available commands.`,
+							runtime,
+						);
+				}
+			} catch (err) {
+				return usage(`Marketplace error: ${errorMessage(err)}`, runtime);
+			}
+		},
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			const args = command.args.trim().split(/\s+/);
+			const sub = args[0] || "install";
+			const rest = args.slice(1).join(" ").trim();
+
+			// /marketplace (no args) or /marketplace install (no args) → interactive browser
+			if ((sub === "install" && !rest) || (!args[0] && !command.args.trim())) {
+				try {
+					runtime.ctx.showPluginSelector("install");
+				} catch (err) {
+					runtime.ctx.showStatus(`Marketplace error: ${err}`);
+				}
+				return;
+			}
+
+			const mgr = new MarketplaceManager({
+				marketplacesRegistryPath: getMarketplacesRegistryPath(),
+				installedRegistryPath: getInstalledPluginsRegistryPath(),
+				projectInstalledRegistryPath: await resolveOrDefaultProjectRegistryPath(
+					runtime.ctx.sessionManager.getCwd(),
+				),
+				marketplacesCacheDir: getMarketplacesCacheDir(),
+				pluginsCacheDir: getPluginsCacheDir(),
+				clearPluginRootsCache: clearPluginRootsAndCaches,
+			});
+
+			try {
+				switch (sub) {
+					case "add": {
+						if (!rest) {
+							runtime.ctx.showStatus("Usage: /marketplace add <source>");
+							return;
+						}
+						const entry = await mgr.addMarketplace(rest);
+						runtime.ctx.showStatus(`Added marketplace: ${entry.name}`);
+						break;
+					}
+					case "remove":
+					case "rm": {
+						if (!rest) {
+							runtime.ctx.showStatus("Usage: /marketplace remove <name>");
+							return;
+						}
+						await mgr.removeMarketplace(rest);
+						runtime.ctx.showStatus(`Removed marketplace: ${rest}`);
+						break;
+					}
+					case "update": {
+						if (rest) {
+							await mgr.updateMarketplace(rest);
+							runtime.ctx.showStatus(`Updated marketplace: ${rest}`);
+						} else {
+							const results = await mgr.updateAllMarketplaces();
+							runtime.ctx.showStatus(`Updated ${results.length} marketplace(s)`);
+						}
+						break;
+					}
+					case "discover": {
+						const plugins = await mgr.listAvailablePlugins(rest || undefined);
+						if (plugins.length === 0) {
+							const marketplaces = await mgr.listMarketplaces();
+							if (marketplaces.length === 0) {
+								runtime.ctx.showStatus(
+									"No marketplaces configured. Try:\n  /marketplace add anthropics/claude-plugins-official",
+								);
+							} else {
+								runtime.ctx.showStatus("No plugins available in configured marketplaces");
+							}
+						} else {
+							const lines = plugins.map(
+								p =>
+									`  ${p.name}${p.version ? `@${p.version}` : ""}${p.description ? ` - ${p.description}` : ""}`,
+							);
+							runtime.ctx.showStatus(`Available plugins:\n${lines.join("\n")}`);
+						}
+						break;
+					}
+					case "install": {
+						// Parse: /marketplace install [--force] [--scope user|project] name@marketplace
+						const parsed = parseMarketplaceInstallArgs(rest);
+						if ("error" in parsed) {
+							runtime.ctx.showStatus(parsed.error);
+							return;
+						}
+						const atIdx = parsed.installSpec.lastIndexOf("@");
+						const name = parsed.installSpec.slice(0, atIdx);
+						const marketplace = parsed.installSpec.slice(atIdx + 1);
+						await mgr.installPlugin(name, marketplace, { force: parsed.force, scope: parsed.scope });
+						runtime.ctx.showStatus(`Installed ${name} from ${marketplace}`);
+						break;
+					}
+					case "uninstall": {
+						if (!rest) {
+							// No args → open interactive uninstall selector
+							runtime.ctx.showPluginSelector("uninstall");
+							return;
+						}
+						const uninstArgs = parsePluginScopeArgs(
+							rest,
+							"Usage: /marketplace uninstall [--scope user|project] <name@marketplace>",
+						);
+						if ("error" in uninstArgs) {
+							runtime.ctx.showStatus(uninstArgs.error);
+							return;
+						}
+						await mgr.uninstallPlugin(uninstArgs.pluginId, uninstArgs.scope);
+						runtime.ctx.showStatus(`Uninstalled ${uninstArgs.pluginId}`);
+						break;
+					}
+					case "installed": {
+						const installed = await mgr.listInstalledPlugins();
+						if (installed.length === 0) {
+							runtime.ctx.showStatus("No marketplace plugins installed");
+						} else {
+							const lines = installed.map(
+								p => `  ${p.id} [${p.scope}]${p.shadowedBy ? " [shadowed]" : ""} (${p.entries.length} entry)`,
+							);
+							runtime.ctx.showStatus(`Installed plugins:\n${lines.join("\n")}`);
+						}
+						break;
+					}
+					case "upgrade": {
+						if (rest) {
+							const upArgs = parsePluginScopeArgs(
+								rest,
+								"Usage: /marketplace upgrade [--scope user|project] <name@marketplace>",
+							);
+							if ("error" in upArgs) {
+								runtime.ctx.showStatus(upArgs.error);
+								return;
+							}
+							const result = await mgr.upgradePlugin(upArgs.pluginId, upArgs.scope);
+							runtime.ctx.showStatus(`Upgraded ${upArgs.pluginId} to ${result.version}`);
+						} else {
+							const results = await mgr.upgradeAllPlugins();
+							if (results.length === 0) {
+								runtime.ctx.showStatus("All marketplace plugins are up to date");
+							} else {
+								const lines = results.map(r => `  ${r.pluginId}: ${r.from} -> ${r.to}`);
+								runtime.ctx.showStatus(`Upgraded ${results.length} plugin(s):\n${lines.join("\n")}`);
+							}
+						}
+						break;
+					}
+					case "help": {
+						runtime.ctx.showStatus(
+							[
+								"Marketplace commands:",
+								"  /marketplace                              Browse and install plugins",
+								"  /marketplace add <source>                  Add a marketplace (e.g. owner/repo)",
+								"  /marketplace remove <name>                 Remove a marketplace",
+								"  /marketplace update [name]                 Re-fetch catalog(s)",
+								"  /marketplace list                          List configured marketplaces",
+								"  /marketplace discover [marketplace]        Browse available plugins",
+								"  /marketplace install <name@marketplace>    Install a plugin",
+								"  /marketplace uninstall <name@marketplace>  Uninstall a plugin",
+								"  /marketplace installed                     List installed plugins",
+								"  /marketplace upgrade [name@marketplace]    Upgrade plugin(s)",
+								"",
+								"Quick start:",
+								"  /marketplace add anthropics/claude-plugins-official",
+								"  /marketplace                               (opens interactive browser)",
+							].join("\n"),
+						);
+						break;
+					}
+					default: {
+						const marketplaces = await mgr.listMarketplaces();
+						if (marketplaces.length === 0) {
+							runtime.ctx.showStatus(
+								"No marketplaces configured.\n\nGet started:\n  /marketplace add anthropics/claude-plugins-official\n\nThen browse plugins with /marketplace or /marketplace discover",
+							);
+						} else {
+							const lines = marketplaces.map(m => `  ${m.name}  ${m.sourceUri}`);
+							runtime.ctx.showStatus(
+								`Marketplaces:\n${lines.join("\n")}\n\nUse /marketplace discover to browse plugins, or /marketplace help for all commands`,
+							);
+						}
+						break;
+					}
+				}
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				runtime.ctx.showStatus(`Marketplace error: ${msg}`);
+			}
+		},
+	},
+	{
+		name: "plugins",
+		description: "View and manage installed plugins",
+		acpDescription: "Manage plugins",
+		acpInputHint: "[list|enable|disable]",
+		subcommands: [
+			{ name: "list", description: "List all installed plugins (npm + marketplace)" },
+			{ name: "enable", description: "Enable a marketplace plugin", usage: "<name@marketplace>" },
+			{ name: "disable", description: "Disable a marketplace plugin", usage: "<name@marketplace>" },
+		],
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const { verb, rest } = parseSubcommand(command.args);
+			try {
+				if (verb === "enable" || verb === "disable") {
+					const parsed = parsePluginScopeArgs(
+						rest,
+						`Usage: /plugins ${verb} [--scope user|project] <name@marketplace>`,
+					);
+					if ("error" in parsed) return usage(parsed.error, runtime);
+					const manager = await createMarketplaceManager(runtime);
+					const isEnable = verb === "enable";
+					await manager.setPluginEnabled(parsed.pluginId, isEnable, parsed.scope);
+					await runtime.reloadPlugins();
+					await runtime.output(`${isEnable ? "Enabled" : "Disabled"} ${parsed.pluginId}`);
+					return commandConsumed();
+				}
+				// Default: list
+				const lines: string[] = [];
+				const npmManager = new PluginManager();
+				const npmPlugins = await npmManager.list();
+				if (npmPlugins.length > 0) {
+					lines.push("npm plugins:");
+					for (const plugin of npmPlugins) {
+						const status = plugin.enabled === false ? " (disabled)" : "";
+						lines.push(`  ${plugin.name}@${plugin.version}${status}`);
+					}
+				}
+
+				const marketplaceManager = await createMarketplaceManager(runtime);
+				const marketplacePlugins = await marketplaceManager.listInstalledPlugins();
+				if (marketplacePlugins.length > 0) {
+					if (lines.length > 0) lines.push("");
+					lines.push("marketplace plugins:");
+					for (const plugin of marketplacePlugins) {
+						const entry = plugin.entries[0];
+						const status = entry?.enabled === false ? " (disabled)" : "";
+						const shadowed = plugin.shadowedBy ? " [shadowed]" : "";
+						lines.push(`  ${plugin.id} v${entry?.version ?? "?"}${status} [${plugin.scope}]${shadowed}`);
+					}
+				}
+
+				await runtime.output(lines.length === 0 ? "No plugins installed" : lines.join("\n"));
+				return commandConsumed();
+			} catch (err) {
+				return usage(`Plugin error: ${errorMessage(err)}`, runtime);
+			}
+		},
+		handleTui: async (command, runtime) => {
+			runtime.ctx.editor.setText("");
+			const args = command.args.trim().split(/\s+/);
+			const sub = args[0] || "list";
+			const rest = args.slice(1).join(" ").trim();
+
+			try {
+				const mgr = new MarketplaceManager({
+					marketplacesRegistryPath: getMarketplacesRegistryPath(),
+					installedRegistryPath: getInstalledPluginsRegistryPath(),
+					projectInstalledRegistryPath: await resolveOrDefaultProjectRegistryPath(
+						runtime.ctx.sessionManager.getCwd(),
+					),
+					marketplacesCacheDir: getMarketplacesCacheDir(),
+					pluginsCacheDir: getPluginsCacheDir(),
+					clearPluginRootsCache: clearPluginRootsAndCaches,
+				});
+
+				switch (sub) {
+					case "enable":
+					case "disable": {
+						const parsed = parsePluginScopeArgs(
+							rest ?? "",
+							`Usage: /plugins ${sub} [--scope user|project] <name@marketplace>`,
+						);
+						if ("error" in parsed) {
+							runtime.ctx.showStatus(parsed.error);
+							return;
+						}
+						const isEnable = sub === "enable";
+						await mgr.setPluginEnabled(parsed.pluginId, isEnable, parsed.scope);
+						runtime.ctx.showStatus(`${isEnable ? "Enabled" : "Disabled"} ${parsed.pluginId}`);
+						break;
+					}
+					default: {
+						const lines: string[] = [];
+
+						const npm = new PluginManager();
+						const npmPlugins = await npm.list();
+						if (npmPlugins.length > 0) {
+							lines.push("npm plugins:");
+							for (const p of npmPlugins) {
+								const status = p.enabled === false ? " (disabled)" : "";
+								lines.push(`  ${p.name}@${p.version}${status}`);
+							}
+						}
+
+						const mktPlugins = await mgr.listInstalledPlugins();
+						if (mktPlugins.length > 0) {
+							if (lines.length > 0) lines.push("");
+							lines.push("marketplace plugins:");
+							for (const p of mktPlugins) {
+								const entry = p.entries[0];
+								const status = entry?.enabled === false ? " (disabled)" : "";
+								const shadowed = p.shadowedBy ? " [shadowed]" : "";
+								lines.push(`  ${p.id} v${entry?.version ?? "?"}${status} [${p.scope}]${shadowed}`);
+							}
+						}
+
+						if (lines.length === 0) {
+							runtime.ctx.showStatus("No plugins installed");
+						} else {
+							runtime.ctx.showStatus(lines.join("\n"));
+						}
+						break;
+					}
+				}
+			} catch (err) {
+				runtime.ctx.showStatus(`Plugin error: ${err}`);
+			}
+		},
+	},
+	{
+		name: "reload-plugins",
+		description: "Reload all plugins (skills, commands, hooks, tools, agents, MCP)",
+		acpDescription: "Reload all plugins",
+		handle: async (_command, runtime) => {
+			await runtime.reloadPlugins();
+			await runtime.output("Plugins reloaded.");
+			return commandConsumed();
+		},
+		handleTui: async (_command, runtime) => {
+			// Invalidate registry fs caches and the plugin roots cache so
+			// listClaudePluginRoots re-reads from disk on next access.
+			const projectPath = await resolveActiveProjectRegistryPath(runtime.ctx.sessionManager.getCwd());
+			clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
+			await runtime.ctx.refreshSlashCommandState();
+			await runtime.ctx.session.refreshSshTool({ activateIfAvailable: true });
+			runtime.ctx.showStatus("Plugins reloaded.");
+			runtime.ctx.editor.setText("");
+		},
+	},
+	{
+		name: "force",
+		description: "Force next turn to use a specific tool",
+		aliases: ["force:"],
+		inlineHint: "<tool-name> [prompt]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const spaceIdx = command.args.indexOf(" ");
+			const toolName = spaceIdx === -1 ? command.args : command.args.slice(0, spaceIdx);
+			const prompt = spaceIdx === -1 ? "" : command.args.slice(spaceIdx + 1).trim();
+			if (!toolName) return usage("Usage: /force:<tool-name> [prompt]", runtime);
+			try {
+				runtime.session.setForcedToolChoice(toolName);
+			} catch (err) {
+				return usage(errorMessage(err), runtime);
+			}
+			await runtime.output(`Next turn forced to use ${toolName}.`);
+			return prompt ? { prompt } : commandConsumed();
+		},
+		handleTui: (command, runtime) => {
+			const spaceIdx = command.args.indexOf(" ");
+			const toolName = spaceIdx === -1 ? command.args : command.args.slice(0, spaceIdx);
+			const prompt = spaceIdx === -1 ? "" : command.args.slice(spaceIdx + 1).trim();
+
+			if (!toolName) {
+				runtime.ctx.showError("Usage: /force:<tool-name> [prompt]");
+				runtime.ctx.editor.setText("");
+				return;
+			}
+
+			try {
+				runtime.ctx.session.setForcedToolChoice(toolName);
+				runtime.ctx.showStatus(`Next turn forced to use ${toolName}.`);
+			} catch (error) {
+				runtime.ctx.showError(errorMessage(error));
+				runtime.ctx.editor.setText("");
+				return;
+			}
+
+			runtime.ctx.editor.setText("");
+
+			// If a prompt was provided, pass it through as input
+			if (prompt) return { prompt };
+		},
+	},
+	{
+		name: "quit",
+		description: "Quit the application",
+		handleTui: shutdownHandlerTui,
+	},
+];
+
+const BUILTIN_SLASH_COMMAND_LOOKUP = new Map<string, SlashCommandSpec>();
+for (const command of BUILTIN_SLASH_COMMAND_REGISTRY) {
+	BUILTIN_SLASH_COMMAND_LOOKUP.set(command.name, command);
+	for (const alias of command.aliases ?? []) {
+		BUILTIN_SLASH_COMMAND_LOOKUP.set(alias, command);
+	}
+}
+
+export const BUILTIN_SLASH_COMMAND_RESERVED_NAMES: ReadonlySet<string> = new Set(BUILTIN_SLASH_COMMAND_LOOKUP.keys());
+
+/**
+ * Build getArgumentCompletions from declarative subcommand definitions.
+ * Returns subcommand names filtered by prefix in the dropdown.
+ */
+function buildArgumentCompletions(subcommands: SubcommandDef[]): (prefix: string) => AutocompleteItem[] | null {
+	return (argumentPrefix: string) => {
+		if (argumentPrefix.includes(" ")) return null; // past the subcommand
+		const lower = argumentPrefix.toLowerCase();
+		const matches = subcommands
+			.filter(s => s.name.startsWith(lower))
+			.map(s => ({
+				value: `${s.name} `,
+				label: s.name,
+				description: s.description,
+				hint: s.usage,
+			}));
+		return matches.length > 0 ? matches : null;
+	};
+}
+
+/**
+ * Build getInlineHint from declarative subcommand definitions.
+ * Shows remaining completion + usage as dim ghost text after cursor.
+ */
+function buildSubcommandInlineHint(subcommands: SubcommandDef[]): (argumentText: string) => string | null {
+	return (argumentText: string) => {
+		const trimmed = argumentText.trimStart();
+		const spaceIndex = trimmed.indexOf(" ");
+
+		if (spaceIndex === -1) {
+			// Still typing subcommand name — show remaining chars + usage
+			const prefix = trimmed.toLowerCase();
+			if (prefix.length === 0) return null;
+			const match = subcommands.find(s => s.name.startsWith(prefix));
+			if (!match) return null;
+			const remaining = match.name.slice(prefix.length);
+			return remaining + (match.usage ? ` ${match.usage}` : "");
+		}
+
+		// Subcommand typed — show remaining usage params
+		const subName = trimmed.slice(0, spaceIndex).toLowerCase();
+		const afterSub = trimmed.slice(spaceIndex + 1);
+		const sub = subcommands.find(s => s.name === subName);
+		if (!sub?.usage) return null;
+
+		if (afterSub.length > 0) {
+			const usageParts = sub.usage.split(" ");
+			const inputParts = afterSub.trim().split(/\s+/);
+			const remaining = usageParts.slice(inputParts.length);
+			return remaining.length > 0 ? remaining.join(" ") : null;
+		}
+
+		return sub.usage;
+	};
+}
+
+/**
+ * Build getInlineHint for commands with a simple static hint string.
+ * Shows the hint only when no arguments have been typed yet.
+ */
+function buildStaticInlineHint(hint: string): (argumentText: string) => string | null {
+	return (argumentText: string) => (argumentText.trim().length === 0 ? hint : null);
+}
+
+/** Builtin command metadata used for slash-command autocomplete and help text. */
+export const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand> = BUILTIN_SLASH_COMMAND_REGISTRY.map(
+	command => ({
+		name: command.name,
+		aliases: command.aliases,
+		description: command.description,
+		subcommands: command.subcommands,
+		inlineHint: command.inlineHint,
+	}),
+);
+
+/**
+ * Materialized builtin slash commands with completion functions derived from
+ * declarative subcommand/hint definitions.
+ */
+export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<
+	BuiltinSlashCommand & {
+		getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null;
+		getInlineHint?: (argumentText: string) => string | null;
+	}
+> = BUILTIN_SLASH_COMMAND_DEFS.map(cmd => {
+	if (cmd.subcommands) {
+		return {
+			...cmd,
+			getArgumentCompletions: buildArgumentCompletions(cmd.subcommands),
+			getInlineHint: buildSubcommandInlineHint(cmd.subcommands),
+		};
+	}
+	if (cmd.inlineHint) {
+		return {
+			...cmd,
+			getInlineHint: buildStaticInlineHint(cmd.inlineHint),
+		};
+	}
+	return cmd;
+});
+
+/**
+ * Unified registry exposed for cross-mode tooling. Each spec carries at least
+ * one of `handle` / `handleTui`. The TUI dispatcher prefers `handleTui`; the
+ * ACP dispatcher requires `handle` and skips TUI-only entries.
+ */
+export const BUILTIN_SLASH_COMMANDS_INTERNAL: ReadonlyArray<SlashCommandSpec> = BUILTIN_SLASH_COMMAND_REGISTRY;
+
+/**
+ * Execute a builtin slash command in the interactive TUI.
+ *
+ * Returns `false` when no builtin matched. Returns `true` when a command
+ * consumed the input entirely. Returns a `string` when the command was handled
+ * but remaining text should be sent as a prompt.
+ */
+export async function executeBuiltinSlashCommand(
+	text: string,
+	runtime: BuiltinSlashCommandRuntime,
+): Promise<string | boolean> {
+	const parsed = parseSlashCommand(text);
+	if (!parsed) return false;
+
+	const command = BUILTIN_SLASH_COMMAND_LOOKUP.get(parsed.name);
+	if (!command) return false;
+	if (parsed.args.length > 0 && !command.allowArgs) {
+		return false;
+	}
+	// Collab guests run a read-mostly replica: session-mutating builtins are
+	// host-only; the allowlist covers purely local/read-only commands.
+	if (runtime.ctx.collabGuest && !COLLAB_GUEST_ALLOWED_COMMANDS[command.name]) {
+		runtime.ctx.showStatus(`/${command.name} is host-only during a collab session`);
+		runtime.ctx.editor.setText("");
+		return true;
+	}
+	if (command.handleTui) {
+		const result = await command.handleTui(parsed, runtime);
+		if (result && typeof result === "object" && "prompt" in result) return result.prompt;
+		return true;
+	}
+	if (command.handle) {
+		// No TUI-specific override → adapt the ACP/text-mode `handle` to the
+		// TUI by routing `runtime.output` through `ctx.showStatus`, clearing
+		// the editor after the call, and reusing the active session's plugin
+		// reload pipeline. Spec authors get a single body usable from either
+		// dispatcher without forcing every TUI test to construct the full
+		// `SlashCommandRuntime` shape.
+		const ctx = runtime.ctx;
+		const adapted: SlashCommandRuntime = {
+			session: ctx.session,
+			sessionManager: ctx.sessionManager,
+			settings: ctx.settings,
+			cwd: ctx.sessionManager.getCwd(),
+			output: (text: string) => {
+				ctx.showStatus(text);
+			},
+			refreshCommands: () => ctx.refreshSlashCommandState(),
+			reloadPlugins: async () => {
+				const projectPath = await resolveActiveProjectRegistryPath(ctx.sessionManager.getCwd());
+				clearPluginRootsAndCaches(projectPath ? [projectPath] : undefined);
+				await ctx.refreshSlashCommandState();
+				await ctx.session.refreshSshTool({ activateIfAvailable: true });
+			},
+		};
+		const result = await command.handle(parsed, adapted);
+		ctx.editor.setText("");
+		if (result && typeof result === "object" && "prompt" in result) return result.prompt;
+		return true;
+	}
+	return false;
+}
+
+/** Look up a unified spec by name or alias. Used by the ACP dispatcher. */
+export function lookupBuiltinSlashCommand(name: string): SlashCommandSpec | undefined {
+	return BUILTIN_SLASH_COMMAND_LOOKUP.get(name);
+}
+
+export type { ParsedSlashCommand, SlashCommandResult, SlashCommandRuntime, SlashCommandSpec, TuiSlashCommandRuntime };