atom-lite 0.1.0 → 0.5.1

package/dist/cli/app.js

@@ -1,21 +1,38 @@
 import { loadConfig } from "../config/load.js";
-import { saveProviderSelection } from "../config/write.js";
+import { defaultAgentDir, userConfigDir } from "../config/paths.js";
+import { saveProviderSelection, saveTheme, } from "../config/write.js";
 import { resolveApiKey, saveApiKey } from "../config/credentials.js";
+import { join } from "node:path";
+import { writeFileSync, existsSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { openSearchablePicker } from "./picker.js";
+import { openCommandPalette } from "./palette.js";
+import { bareCommandName, createCommandRegistry } from "./commands.js";
+import { resolveTheme, themeLabel, themeNames, markdownThemeFor, } from "./theme.js";
 import { SecretInput } from "./secret-input.js";
 import { StatusLine } from "./status-line.js";
+import { Activity } from "./activity.js";
+import { ToolBox } from "./tool-box.js";
+import { ApprovalPrompt } from "./approval-prompt.js";
 import { Banner } from "./banner.js";
 import { formatContextUsage, knownContextWindow, } from "../providers/context-window.js";
 import { StreamText } from "./stream-text.js";
 import { Transcript } from "./transcript.js";
 import { AgentRuntime } from "../agent/loop.js";
 import { JsonlSessionStore } from "../sessions/store.js";
+import { ExtensionLoader } from "../extensions/loader.js";
+import { collectExtensionTools } from "../extensions/tool-adapter.js";
+import { denyProject, trustProject } from "../extensions/trust.js";
+import { ProjectTrustPrompt } from "./trust-prompt.js";
+import { formatSessionList, formatSessionSearch, searchSessions, sessionTitleFromEvents, } from "../sessions/search.js";
+import { providerSwitchNotice, sessionHistoryLines, sessionSelectionFromEvents, } from "../sessions/history.js";
+import { blockAtLine, createMouseCapture, handleMouseEvent, parseSgrMouse, shouldEnableMouse, } from "./mouse.js";
 import { readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool } from "../tools/index.js";
+import { McpManager, formatMcpStatus, formatMcpDoctor, createMcpTools } from "../mcp/index.js";
 import { createProvider } from "../providers/factory.js";
 import { availableProviderNames, getPreset, listModelsForProvider, materializeProviderConfig, probeApiKey, providerLabel, PROVIDER_PRESETS, } from "../providers/catalog.js";
 import { ContextManager } from "../context/manager.js";
-import { ProcessTerminal, isKeyRelease, Key, matchesKey, } from "@earendil-works/pi-tui";
+import { ProcessTerminal, isKeyRelease, isKeyRepeat, Key, matchesKey, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 export async function run(args) {
     let providerOverride;
     let modelOverride;
@@ -23,10 +40,20 @@ export async function run(args) {
     let debug = false;
     let showVersion = false;
     let sessionOverride;
+    let themeOverride;
+    let noColor = false;
+    let listSessions = false;
+    let searchSessionsQuery;
     const positional = [];
+    const extensionPaths = [];
     for (let i = 0; i < args.length; i++) {
         const a = args[i];
-        if (a === "--provider")
+        if (a === "-e" || a === "--extension") {
+            const path = args[++i];
+            if (path)
+                extensionPaths.push(path);
+        }
+        else if (a === "--provider")
             providerOverride = args[++i];
         else if (a === "--model")
             modelOverride = args[++i];
@@ -40,10 +67,18 @@ export async function run(args) {
             positional.push("__continue__");
         else if (a === "--session")
             sessionOverride = args[++i];
+        else if (a === "--list-sessions")
+            listSessions = true;
+        else if (a === "--search-sessions")
+            searchSessionsQuery = args[++i] ?? "";
+        else if (a === "--theme")
+            themeOverride = args[++i];
+        else if (a === "--no-color")
+            noColor = true;
         else if (a === "--no-tools")
             positional.push("__notools__");
         else if (a === "--help") {
-            process.stdout.write("atom-lite [task] [--provider NAME] [--model MODEL] [--continue] [--session ID] [--no-tools] [--json] [--debug] [--version] [--help]\n");
+            process.stdout.write("atom-lite [task] [--provider NAME] [--model MODEL] [--continue] [--session ID] [--list-sessions] [--search-sessions QUERY] [--no-tools] [--json] [--debug] [--theme NAME] [--no-color] [-e PATH] [--version] [--help]\n");
             return;
         }
         else if (a.startsWith("--")) {
@@ -54,7 +89,24 @@ export async function run(args) {
         }
     }
     if (showVersion) {
-        process.stdout.write("0.1.0\n");
+        process.stdout.write("0.3.1\n");
+        return;
+    }
+    if (listSessions || searchSessionsQuery !== undefined) {
+        const store = new JsonlSessionStore();
+        if (listSessions) {
+            process.stdout.write(`${formatSessionList(store.list())}\n`);
+        }
+        if (searchSessionsQuery !== undefined) {
+            const query = searchSessionsQuery.trim();
+            if (!query) {
+                process.stderr.write("atom-lite: --search-sessions requires a query\n");
+                process.exitCode = 1;
+                return;
+            }
+            const matches = searchSessions(store.list(), query);
+            process.stdout.write(`${formatSessionSearch(matches)}\n`);
+        }
         return;
     }
     let config = loadConfig();
@@ -71,7 +123,9 @@ export async function run(args) {
     if (modelOverride)
         modelByProvider.set(provider.id, modelOverride);
     const useTools = !positional.includes("__notools__");
-    const tools = useTools ? [readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool] : [];
+    const builtInTools = useTools
+        ? [readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool]
+        : [];
     const interactive = process.stdin.isTTY === true && !jsonMode;
     // one-shot task from positional or stdin
     let stdinTask = "";
@@ -84,39 +138,127 @@ export async function run(args) {
     const taskArgs = positional.filter((p) => !p.startsWith("__"));
     const oneShot = (taskArgs.join(" ").trim() || stdinTask).trim();
     const store = new JsonlSessionStore();
-    const session = sessionOverride
+    let session = sessionOverride
         ? store.resume(sessionOverride) ?? store.create(process.cwd(), provider.id)
         : positional.includes("__continue__")
             ? store.resumeLatest(process.cwd()) ?? store.create(process.cwd(), provider.id)
             : store.create(process.cwd(), provider.id);
+    const mcpServers = (config.mcpServers ?? {});
+    const mcpManager = new McpManager({
+        servers: mcpServers,
+        onEvent: (event) => {
+            try {
+                session?.appendEvent?.(event);
+            }
+            catch {
+                // Observability must not break the session.
+            }
+        },
+    });
+    const extensionUICallbacks = {};
+    const extensionProviderNames = new Set();
+    function resolveExtensionApiKey(value) {
+        if (typeof value !== "string" || !value)
+            return undefined;
+        if (value.startsWith("!")) {
+            try {
+                const { execFileSync } = require("node:child_process");
+                const parts = value.slice(1).trim().split(/\s+/);
+                return execFileSync(parts[0], parts.slice(1), { encoding: "utf8" }).trim();
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (value.startsWith("$"))
+            return process.env[value.slice(1)] ?? value;
+        if (value.startsWith("${") && value.endsWith("}"))
+            return process.env[value.slice(2, -1)] ?? value;
+        return value;
+    }
+    const extensionLoader = new ExtensionLoader({
+        cliPaths: extensionPaths,
+        cwd: process.cwd(),
+        agentDir: defaultAgentDir(),
+        userDir: join(userConfigDir(), "extensions"),
+        projectDir: process.cwd(),
+    });
+    const pendingTrust = extensionLoader
+        .discover()
+        .filter((entry) => entry.source === "project" &&
+        !entry.trusted &&
+        entry.skipReason === "project is not trusted");
+    if (!interactive && pendingTrust.length > 0) {
+        process.stderr.write(`atom-lite: skipping ${pendingTrust.length} untrusted project extension(s); run interactively to review\n`);
+    }
+    await extensionLoader.loadAll().catch(() => {
+        // Extension failures are reported per extension.
+    });
+    // Remove any previously bridged extension providers before re-bridging.
+    for (const name of extensionProviderNames) {
+        delete config.providers[name];
+    }
+    extensionProviderNames.clear();
+    // Bridge Pi-style extension providers into Atom-lite's config so they
+    // appear in /provider, /model, and the command palette.
+    for (const loaded of extensionLoader.list()) {
+        for (const [name, provider] of (loaded.registries?.providers ?? new Map())) {
+            const cfg = provider?.config ?? {};
+            const firstModel = Array.isArray(cfg.models) && cfg.models.length > 0
+                ? (cfg.models[0].id ?? cfg.models[0].name ?? "default")
+                : "default";
+            const apiKey = resolveExtensionApiKey(cfg.apiKey);
+            const headers = { ...(cfg.headers ?? {}) };
+            if (cfg.authHeader && apiKey)
+                headers.Authorization = `Bearer ${apiKey}`;
+            config.providers[name] = {
+                type: "openai-compatible",
+                baseUrl: cfg.baseUrl,
+                model: firstModel,
+                apiKey: apiKey ?? null,
+                apiKeyEnv: null,
+                headers,
+                contextWindow: cfg.models?.[0]?.contextWindow,
+            };
+            extensionProviderNames.add(name);
+        }
+    }
+    const extensionTools = collectExtensionTools(extensionLoader);
+    const allTools = [...builtInTools, ...extensionTools];
+    const extensionDispatch = async (event, payload) => {
+        const results = [];
+        for (const loaded of extensionLoader.list()) {
+            const handlers = loaded.registries.handlers.get(event);
+            if (!handlers)
+                continue;
+            for (const handler of handlers) {
+                try {
+                    results.push(await handler(payload, loaded.context ?? {}));
+                }
+                catch (error) {
+                    // eslint-disable-next-line no-console
+                    console.error(`[extension:${loaded.id}] handler error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        return results;
+    };
     const contextManager = new ContextManager({
         systemPrompt: "You are a coding assistant.",
         maxInputTokens: config.context.maxInputTokens ?? null,
         reserveOutputTokens: config.context.reserveOutputTokens,
         compactAtPercent: config.context.compactAtPercent,
         maxProjectInstructionBytes: config.context.maxProjectInstructionBytes,
+        compactEveryNTurns: config.context.compactEveryNTurns ?? 0,
         provider,
         model: modelOverride ?? "default",
         userInstructionsPath: undefined,
     });
     let sessionTrusted = false;
-    let appendLineFn = () => { };
-    let pendingApproval = null;
     const approvals = {
         mode: config.runtime.approvalMode ?? "ask",
-        handler: interactive
-            ? async (req) => {
-                appendLineFn(`[approval] ${req.command}`);
-                appendLineFn(`  cwd: ${req.cwd}  timeout: ${req.timeoutMs}ms  sandboxed: ${req.sandboxed}`);
-                appendLineFn("  type y (approve) / n (deny) / t (trust session)");
-                return new Promise((resolve) => {
-                    pendingApproval = (d) => {
-                        pendingApproval = null;
-                        resolve(d);
-                    };
-                });
-            }
-            : undefined,
+        // Installed below once the interactive UI helpers exist.
+        handler: undefined,
         isTrusted: () => sessionTrusted,
         trustSession: () => {
             sessionTrusted = true;
@@ -127,17 +269,25 @@ export async function run(args) {
         provider,
         model: modelOverride,
         workspace: process.cwd(),
-        tools,
+        tools: allTools,
         approvals,
         contextManager,
+        extensionDispatch,
         bashConcurrency: config.runtime.bashConcurrency,
     });
+    mcpManager.onToolsChanged = () => {
+        runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
+    };
     if (oneShot || !interactive) {
         // non-interactive / one-shot path
         const controller = new AbortController();
         const onSigint = () => controller.abort();
         process.on("SIGINT", onSigint);
         try {
+            if (useTools) {
+                await mcpManager.syncTools();
+                runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
+            }
             const result = await runtime.runAgentTurn(oneShot || " ", session, controller.signal);
             if (jsonMode) {
                 process.stdout.write(JSON.stringify({ result, sessionId: session.id }) + "\n");
@@ -154,22 +304,39 @@ export async function run(args) {
             process.exit(1);
         }
         finally {
+            await mcpManager.close().catch(() => { });
             process.off("SIGINT", onSigint);
         }
         return;
     }
     // ---- Interactive TUI (first-class) ----
-    const { TuiMainScreen, Text, Input, Editor, Container, Spacer, ScrollView, Loader, Markdown, Box } = await import("@earendil-works/pi-tui");
+    const { TuiAltScreen, Text, Input, Editor, Container, Spacer, ScrollView, VStack, Loader, Markdown, Box } = await import("@earendil-works/pi-tui");
+    const mouseEnabled = shouldEnableMouse({
+        interactive,
+        configured: config.ui.mouse,
+        stdoutIsTTY: process.stdout.isTTY === true,
+    });
     const terminal = new ProcessTerminal();
-    const tui = new TuiMainScreen(terminal);
+    const tui = new TuiAltScreen(terminal, false, undefined, { mouse: mouseEnabled });
+    const mouseCapture = createMouseCapture((data) => terminal.write(data));
     let effortLevel = "medium";
     runtime.setEffort(effortLevel);
-    const transcript = new Transcript();
-    transcript.add(new Banner());
+    let themeName = themeOverride ?? config.ui.theme;
+    if (noColor)
+        themeName = "ansi";
+    let terminalScheme;
+    let theme = resolveTheme(themeName, {
+        noColor,
+        env: process.env,
+        scheme: terminalScheme,
+    });
+    const transcript = new Transcript(theme);
+    const banner = new Banner(theme);
+    transcript.add(banner);
     transcript.add(new Spacer(1));
     const content = transcript.container;
     const output = new ScrollView(content, { follow: "end" });
-    const streamText = new StreamText(transcript);
+    const streamText = new StreamText(transcript, 200, 200, markdownThemeFor(theme));
     function headerLabel() {
         const cwd = process.cwd();
         const home = process.env.HOME ?? "";
@@ -188,23 +355,27 @@ export async function run(args) {
         }
         return branch ? `${displayPath}:${branch}` : displayPath;
     }
-    const dim = (s) => `\x1b[2m${s}\x1b[0m`;
     // paddingY = 0 keeps the workspace path directly under the status line.
-    const header = new Text(dim(headerLabel()), 1, 0);
-    const statusBar = new StatusLine();
+    const header = new Text(theme.tokens.dim(headerLabel()), 1, 0);
+    const statusBar = new StatusLine(theme);
+    const activity = new Activity({ theme, onChange: () => updateStatus() });
     statusBar.setParts({
-        left: dim(`${provider.id}/${provider.model ?? "default"}`),
-        tokens: dim("tokens: ?"),
-        effort: dim("effort: medium"),
+        left: `${provider.id}/${provider.model ?? "default"}`,
+        tokens: "tokens: ?",
+        effort: "effort: medium",
+        activity: activity.text(),
     });
     const selectListTheme = {
-        selectedPrefix: (s) => s,
-        selectedText: (s) => `\x1b[7m${s}\x1b[0m`,
-        description: (s) => s,
-        scrollInfo: (s) => s,
-        noMatch: (s) => s,
+        selectedPrefix: (s) => theme.tokens.accent(s),
+        selectedText: (s) => theme.tokens.selection(s),
+        description: (s) => theme.tokens.dim(s),
+        scrollInfo: (s) => theme.tokens.dim(s),
+        noMatch: (s) => theme.tokens.dim(s),
+    };
+    const editorTheme = {
+        borderColor: (s) => theme.tokens.border(s),
+        selectList: selectListTheme,
     };
-    const editorTheme = { borderColor: (s) => s, selectList: selectListTheme };
     const input = new Editor(tui, editorTheme, {});
     const { CombinedAutocompleteProvider } = await import("@earendil-works/pi-tui");
     const { DefaultSkillRegistry, skillCacheSignature } = await import("../skills/registry.js");
@@ -218,80 +389,222 @@ export async function run(args) {
         }
         return skillReg;
     }
-    const slashCommands = [
-        { name: "help", description: "show commands" },
-        { name: "model", description: "search/switch model" },
-        { name: "provider", description: "add/select provider" },
-        { name: "session", description: "session info" },
-        { name: "compact", description: "compact history" },
-        { name: "clear", description: "clear session" },
-        { name: "approval", description: "approval mode" },
-        { name: "doctor", description: "diagnostics" },
-        { name: "effort", description: "set effort level" },
-        { name: "skills", description: "list/select skills" },
-        { name: "exit", description: "exit" },
-    ];
-    for (const s of skillReg.list()) {
-        slashCommands.push({ name: s.name, description: s.description });
-    }
-    input.setAutocompleteProvider(new CombinedAutocompleteProvider(slashCommands, process.cwd()));
-    tui.addChild(output);
-    tui.addChild(new Spacer());
-    tui.addChild(input);
-    tui.addChild(statusBar);
+    let commandRegistry = createCommandRegistry({ skills: skillReg.list() });
+    let registrySkillSignature = skillSignature;
+    function refreshCommandRegistry() {
+        const sig = skillCacheSignature(process.cwd());
+        if (sig === registrySkillSignature)
+            return;
+        commandRegistry = createCommandRegistry({ skills: cachedSkillRegistry().list() });
+        registrySkillSignature = sig;
+        input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd()));
+    }
+    input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd()));
+    const root = new VStack([]);
+    root.addChild(output, { grow: 1 });
+    root.addChild(new Spacer(1));
+    root.addChild(input);
+    root.addChild(statusBar);
     // folder:branch info below the status line, dimmed
-    tui.addChild(header);
+    root.addChild(header);
     const dropdownContainer = new Container();
-    tui.addChild(dropdownContainer);
+    root.addChild(dropdownContainer);
+    tui.setLayoutRoot(root);
     tui.setFocus(input);
+    if (!noColor) {
+        try {
+            tui.setTerminalColorSchemeNotifications(true);
+            tui.onTerminalColorSchemeChange((scheme) => {
+                terminalScheme = scheme;
+                if (themeName === "auto")
+                    applyTheme("auto", false);
+            });
+        }
+        catch {
+            // Terminals that do not support colour-scheme reports keep the
+            // COLORFGBG/dark fallback.
+        }
+    }
+    class ThinkingBlock {
+        buffer = "";
+        render(width) {
+            const lines = [theme.tokens.dim("💭 thinking")];
+            const sep = theme.tokens.dim("│ ");
+            const contentWidth = Math.max(1, width - 2);
+            const logicalLines = this.buffer.length > 0 ? this.buffer.split("\\n") : [""];
+            for (const logical of logicalLines) {
+                const wrapped = wrapTextWithAnsi(logical, contentWidth);
+                if (wrapped.length === 0) {
+                    lines.push(sep);
+                }
+                else {
+                    for (const part of wrapped)
+                        lines.push(sep + theme.tokens.dim(part));
+                }
+            }
+            return lines;
+        }
+        invalidate() { }
+    }
     let thinkingText = null;
     let thinkingBuffer = "";
-    let showThinking = true;
-    let loader = null;
+    let showThinking = config.ui.showThinking;
     let expandTools = false;
     let uiModalOpen = false;
+    let closeActiveOverlay;
     const toolBoxes = [];
-    approvals.handler = interactive
-        ? async (req) => {
-            appendLine("box: approval");
-            appendLine(req.command);
-            appendLine("type y / n / t");
-            return new Promise((resolve) => {
-                pendingApproval = (d) => {
-                    pendingApproval = null;
-                    resolve(d);
-                };
-            });
-        }
-        : undefined;
-    function appendLine(text) {
+    /**
+     * Close whichever modal overlay owns the keyboard. Callers that clear the
+     * dropdown container directly must use this first, or the overlay's input
+     * listener would keep consuming keys after it disappears from the screen.
+     */
+    function closeOverlay() {
+        const close = closeActiveOverlay;
+        closeActiveOverlay = undefined;
+        close?.();
+    }
+    function appendLine(text, style = theme.tokens.text) {
         if (thinkingText) {
             thinkingText = null;
             thinkingBuffer = "";
         }
         streamText.finalize();
-        transcript.add(new Text(text));
+        transcript.add(new Text(style(text)));
         tui.requestRender();
     }
     function appendDelta(delta) {
         streamText.append(delta);
         tui.requestRender();
     }
+    /** Review project-local extensions once per project decision. */
+    function maybeReviewProjectTrust() {
+        if (uiModalOpen)
+            return;
+        const pending = extensionLoader
+            .discover()
+            .filter((entry) => entry.source === "project" &&
+            !entry.trusted &&
+            entry.skipReason === "project is not trusted");
+        if (pending.length === 0)
+            return;
+        uiModalOpen = true;
+        closeOverlay();
+        dropdownContainer.clear();
+        const prompt = new ProjectTrustPrompt(pending.map((entry) => ({
+            id: entry.id,
+            entryPath: entry.entryPath,
+            version: entry.manifest?.version,
+            capabilities: entry.manifest?.capabilities ?? [],
+        })), process.cwd(), (decision) => {
+            uiModalOpen = false;
+            dropdownContainer.clear();
+            tui.setFocus(input);
+            if (decision === "approve") {
+                trustProject(process.cwd());
+                appendLine("approved project extensions");
+            }
+            else {
+                denyProject(process.cwd());
+                appendLine("denied project extensions");
+            }
+            void extensionLoader
+                .loadAll()
+                .then(() => {
+                runtime.setTools([
+                    ...builtInTools,
+                    ...collectExtensionTools(extensionLoader),
+                    ...createMcpTools(mcpManager),
+                ]);
+                appendLine(`extensions: ${extensionLoader.list().length} processed (see /extensions)`);
+                tui.requestRender();
+            })
+                .catch((error) => {
+                appendLine(`extensions: reload failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        });
+        dropdownContainer.addChild(prompt);
+        tui.setFocus(prompt);
+        tui.requestRender();
+    }
+    function thinkingBody() {
+        return thinkingBuffer
+            .split("\n")
+            .map((line) => theme.tokens.dim(`│ ${line}`))
+            .join("\n");
+    }
     function finalizeText() {
         streamText.finalize();
     }
+    let activeTurnController = null;
+    const messageQueue = [];
+    const steeringQueue = [];
+    runtime.setSteeringQueue(steeringQueue);
+    /** Run one interactive turn while keeping the status bar's activity fresh. */
+    async function runTurn(prompt) {
+        activity.start("formulating");
+        const controller = new AbortController();
+        activeTurnController = controller;
+        try {
+            if (useTools) {
+                await mcpManager.syncTools();
+                runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
+            }
+            await runtime.runAgentTurn(prompt, session, controller.signal);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message === "USER_CANCELLED") {
+                appendLine("cancelled");
+            }
+            else {
+                appendLine(`atom-lite: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        finally {
+            activeTurnController = null;
+            activity.stop();
+            if (messageQueue.length > 0) {
+                const next = messageQueue.shift();
+                appendLine(`> ${next}`, theme.tokens.user);
+                void runTurn(next);
+            }
+        }
+    }
     function updateStatus() {
         const usage = runtime.getContextUsage();
         statusBar.setParts({
-            left: dim(`${provider.id}/${currentModelLabel()}`),
-            tokens: dim(`tokens: ${formatContextUsage(usage.used, usage.window)}`),
-            effort: dim(`effort: ${effortLevel}`),
+            left: `${provider.id}/${currentModelLabel()}`,
+            tokens: `tokens: ${formatContextUsage(usage.used, usage.window)}`,
+            effort: `effort: ${effortLevel}`,
+            activity: activity.text(),
         });
         tui.requestRender();
     }
     function currentModelLabel() {
         return modelOverride ?? provider.model ?? "default";
     }
+    function applyTheme(name, persist) {
+        themeName = name;
+        theme = resolveTheme(name, {
+            noColor,
+            env: process.env,
+            scheme: terminalScheme,
+        });
+        banner.setTheme(theme);
+        transcript.setTheme(theme);
+        statusBar.setTheme(theme);
+        activity.setTheme(theme);
+        header.setText(theme.tokens.dim(headerLabel()));
+        if (persist) {
+            try {
+                saveTheme(name);
+            }
+            catch (err) {
+                appendLine(`warning: could not persist theme: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        updateStatus();
+        tui.requestRender();
+    }
     /**
      * Show the best-known window immediately, then refine it from live provider
      * metadata without blocking the TUI.
@@ -327,6 +640,17 @@ export async function run(args) {
     refreshContextWindow();
     const MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
     const modelCache = new Map();
+    for (const loaded of extensionLoader.list()) {
+        for (const [name, provider] of (loaded.registries?.providers ?? new Map())) {
+            const cfg = provider?.config ?? {};
+            const models = Array.isArray(cfg.models)
+                ? cfg.models.map((m) => m.id ?? m.name).filter(Boolean)
+                : [];
+            if (models.length > 0) {
+                modelCache.set(name, { models, at: Date.now() });
+            }
+        }
+    }
     function profileConfig(profile) {
         return config.providers[profile];
     }
@@ -420,6 +744,13 @@ export async function run(args) {
             });
         }
     }
+    /** Providers whose model list is missing or older than the cache TTL. */
+    function providersNeedingRefresh(names) {
+        return names.filter((name) => {
+            const cached = modelCache.get(name);
+            return !cached || Date.now() - cached.at >= MODEL_CACHE_TTL_MS;
+        });
+    }
     function switchToModel(profile, model) {
         const pcfg = ensureProfile(profile);
         if (!pcfg) {
@@ -441,6 +772,35 @@ export async function run(args) {
         refreshContextWindow();
         appendLine(`switched to ${profile}/${model}`);
     }
+    /** Interpret `/model` arguments: bare model, provider/model, or provider. */
+    function switchModelTarget(target) {
+        const rest = target.trim();
+        if (!rest) {
+            openModelPicker();
+            return;
+        }
+        const knownModels = modelsFor(provider.id);
+        if (knownModels.includes(rest)) {
+            switchToModel(provider.id, rest);
+            return;
+        }
+        const slash = rest.indexOf("/");
+        if (slash > 0) {
+            const profile = rest.slice(0, slash);
+            const model = rest.slice(slash + 1);
+            if (profileConfig(profile) || getPreset(profile)) {
+                switchToModel(profile, model);
+                return;
+            }
+        }
+        if (profileConfig(rest) || getPreset(rest)) {
+            ensureProfile(rest);
+            const pcfg = profileConfig(rest);
+            switchToModel(rest, String(pcfg?.model ?? modelOverride ?? "default"));
+            return;
+        }
+        switchToModel(provider.id, rest);
+    }
     function openModelPicker() {
         const names = availableProviderNames(config);
         if (!names.includes(provider.id) && profileConfig(provider.id)) {
@@ -451,6 +811,7 @@ export async function run(args) {
             tui,
             container: dropdownContainer,
             title: "Select model",
+            theme,
             items: buildModelItems(),
             maxVisible: 15,
             onSelect: (item) => {
@@ -466,9 +827,11 @@ export async function run(args) {
             },
             restoreFocus: () => tui.setFocus(input),
         });
-        if (names.length) {
-            picker.setStatus(`loading live models from ${names.length} provider${names.length === 1 ? "" : "s"}…`);
-            refreshModelCache(names, () => {
+        closeActiveOverlay = picker.close;
+        const stale = providersNeedingRefresh(names);
+        if (stale.length) {
+            picker.setStatus(`loading live models from ${stale.length} provider${stale.length === 1 ? "" : "s"}…`);
+            refreshModelCache(stale, () => {
                 picker.setStatus("");
                 picker.updateItems(buildModelItems());
             });
@@ -521,6 +884,7 @@ export async function run(args) {
         appendLine("tip: /model searches every configured provider");
     }
     function closeApiKeyPrompt() {
+        closeOverlay();
         dropdownContainer.clear();
         uiModalOpen = false;
         tui.setFocus(input);
@@ -528,13 +892,14 @@ export async function run(args) {
     }
     function promptForApiKey(preset, existingKey) {
         uiModalOpen = true;
+        closeOverlay();
         dropdownContainer.clear();
         const wrapper = new Container();
-        wrapper.addChild(new Text(`\x1b[36m${preset.label} API key\x1b[0m`));
+        wrapper.addChild(new Text(theme.tokens.accent(`${preset.label} API key`)));
         if (preset.keyUrl)
-            wrapper.addChild(new Text(dim(`create one: ${preset.keyUrl}`)));
+            wrapper.addChild(new Text(theme.tokens.dim(`create one: ${preset.keyUrl}`)));
         if (existingKey)
-            wrapper.addChild(new Text(dim("a key is already saved — press Enter to keep it")));
+            wrapper.addChild(new Text(theme.tokens.dim("a key is already saved — press Enter to keep it")));
         const secret = new SecretInput("API key", existingKey ? "hidden (Enter keeps saved key)" : "paste key (hidden)");
         const status = new Text("");
         wrapper.addChild(secret);
@@ -564,18 +929,18 @@ export async function run(args) {
                     }
                     return;
                 }
-                status.setText(dim("an API key is required"));
+                status.setText(theme.tokens.dim("an API key is required"));
                 tui.requestRender();
                 return;
             }
             busy = true;
-            status.setText(dim("validating key…"));
+            status.setText(theme.tokens.dim("validating key…"));
             tui.requestRender();
             await new Promise((r) => setImmediate(r));
             const probe = await probeApiKey(preset, key);
             if (probe.invalid) {
                 busy = false;
-                status.setText(`\x1b[31m✗ key rejected by ${preset.label}\x1b[0m`);
+                status.setText(theme.tokens.error(`✗ key rejected by ${preset.label}`));
                 secret.reset();
                 tui.requestRender();
                 return;
@@ -585,7 +950,7 @@ export async function run(args) {
             }
             catch (err) {
                 busy = false;
-                status.setText(`\x1b[31m✗ could not save key: ${err instanceof Error ? err.message : String(err)}\x1b[0m`);
+                status.setText(theme.tokens.error(`✗ could not save key: ${err instanceof Error ? err.message : String(err)}`));
                 tui.requestRender();
                 return;
             }
@@ -621,10 +986,11 @@ export async function run(args) {
     }
     function openProviderPicker() {
         uiModalOpen = true;
-        openSearchablePicker({
+        const picker = openSearchablePicker({
             tui,
             container: dropdownContainer,
             title: "Select provider",
+            theme,
             items: providerItems(),
             maxVisible: 12,
             onSelect: (item) => {
@@ -637,69 +1003,554 @@ export async function run(args) {
             },
             restoreFocus: () => tui.setFocus(input),
         });
+        closeActiveOverlay = picker.close;
+    }
+    function openEffortPicker() {
+        uiModalOpen = true;
+        const items = [
+            { value: "low", label: "low", description: "minimal reasoning" },
+            { value: "medium", label: "medium", description: "balanced" },
+            { value: "high", label: "high", description: "deep reasoning" },
+        ];
+        const picker = openSearchablePicker({
+            tui,
+            container: dropdownContainer,
+            title: "Select effort",
+            theme,
+            items,
+            maxVisible: 3,
+            onSelect: (item) => {
+                uiModalOpen = false;
+                setEffortTarget(item.value);
+            },
+            onCancel: () => {
+                uiModalOpen = false;
+                appendLine("cancelled");
+            },
+            restoreFocus: () => tui.setFocus(input),
+        });
+        closeActiveOverlay = picker.close;
+        picker.setStatus("applies to the next turn");
+    }
+    function setEffortTarget(level) {
+        effortLevel = level;
+        runtime.setEffort(level);
+        updateStatus();
+        appendLine(`effort set to ${effortLevel}`);
+    }
+    function themePickerItems() {
+        return themeNames().map((name) => ({
+            value: name,
+            label: name,
+            description: themeLabel(name),
+        }));
+    }
+    function setThemeTarget(name) {
+        if (!themeNames().includes(name)) {
+            appendLine(`unknown theme: ${name} (available: ${themeNames().join(", ")})`);
+            return;
+        }
+        applyTheme(name, true);
+        appendLine(`theme: ${themeLabel(name)}`);
+    }
+    function openThemePicker() {
+        uiModalOpen = true;
+        const original = themeName;
+        const picker = openSearchablePicker({
+            tui,
+            container: dropdownContainer,
+            title: "Select theme",
+            theme,
+            items: themePickerItems(),
+            maxVisible: 4,
+            initialValue: themeName,
+            onPreview: (item) => applyTheme(item.value, false),
+            onSelect: (item) => {
+                uiModalOpen = false;
+                setThemeTarget(item.value);
+            },
+            onCancel: () => {
+                uiModalOpen = false;
+                applyTheme(original, false);
+                appendLine("cancelled");
+            },
+            restoreFocus: () => tui.setFocus(input),
+        });
+        closeActiveOverlay = picker.close;
+    }
+    async function loadSkill(name, extra) {
+        const registry = cachedSkillRegistry();
+        const content = registry.load(name);
+        if (!content) {
+            appendLine(`skill not found: ${name}`);
+            return false;
+        }
+        session.appendMessage({ role: "system", content });
+        if (typeof session.appendEvent === "function") {
+            session.appendEvent({ type: "skill_loaded", name });
+        }
+        appendLine(`Loaded skill: ${name}`);
+        if (extra) {
+            appendLine(`> ${extra}`);
+            await runTurn(extra);
+        }
+        return true;
+    }
+    const commandContext = {
+        get session() {
+            return session;
+        },
+        runtime,
+        approvals,
+        appendLine,
+        clearContent: () => {
+            session.messages.length = 0;
+            content.clear();
+            tui.requestRender();
+        },
+        updateStatus,
+        runDoctor,
+        runMcp,
+        runCompact,
+        runExport,
+        openModelPicker,
+        openProviderPicker,
+        openEffortPicker,
+        openThemePicker,
+        openSessionsPicker,
+        searchSessions: searchSessionsInStore,
+        renameSession,
+        listExtensions: () => {
+            const report = extensionLoader.report();
+            if (report.length === 0)
+                return "No extensions discovered.";
+            return report
+                .map((ext) => {
+                const origin = ext.origin ? `${ext.source}:${ext.origin}` : ext.source;
+                const version = ext.version ? `v${ext.version}` : "-";
+                const counts = `${ext.toolCount} tools / ${ext.commandCount} commands`;
+                const error = ext.error ? `\t${ext.error}` : "";
+                return `${ext.id}\t${origin}\t${version}\t${ext.status}\t${counts}\t${ext.entryPath}${error}`;
+            })
+                .join("\n");
+        },
+        extensionDoctor: () => extensionLoader.doctor(),
+        reloadExtensions,
+        switchModel: switchModelTarget,
+        startProviderSetup,
+        setEffort: setEffortTarget,
+        toggleThinking: () => {
+            showThinking = !showThinking;
+            return showThinking;
+        },
+        setTheme: setThemeTarget,
+        listSkills: () => cachedSkillRegistry().list().map((skill) => ({
+            name: skill.name,
+            description: skill.description,
+        })),
+        loadSkill,
+        runTurn,
+        requestExit: () => {
+            void mcpManager.close().finally(() => {
+                tui.stop();
+                process.exit(0);
+            });
+        },
+    };
+    function restoreTranscript(next) {
+        streamText.finalize();
+        transcript.reset();
+        banner.setTheme(theme);
+        transcript.add(banner);
+        transcript.add(new Spacer(1));
+        for (const line of sessionHistoryLines(next.messages)) {
+            transcript.addLine(line);
+        }
+        tui.requestRender();
+    }
+    function resumeSession(id) {
+        const next = store.resume(id);
+        if (!next) {
+            appendLine(`could not resume session: ${id}`);
+            return;
+        }
+        const previous = session.id;
+        session = next;
+        session.appendEvent({ type: "session_resumed", from: previous });
+        restoreTranscript(next);
+        const title = sessionTitleFromEvents(next.events);
+        appendLine(`resumed session ${session.id}: ${title} (${session.messages.length} messages)`);
+        const notice = providerSwitchNotice({ provider: provider.id, model: currentModelLabel() }, sessionSelectionFromEvents(next.events));
+        if (notice)
+            appendLine(notice);
+        updateStatus();
+        tui.requestRender();
+    }
+    function renameSession(title) {
+        const trimmed = title.trim();
+        if (!trimmed) {
+            appendLine("usage: /session rename <title>");
+            return;
+        }
+        session.appendEvent({ type: "session_renamed", title: trimmed });
+        appendLine(`session renamed: ${trimmed}`);
+        tui.requestRender();
+    }
+    function searchSessionsInStore(query) {
+        const matches = searchSessions(store.list(), query);
+        if (matches.length === 0) {
+            appendLine(`no sessions match “${query}”`);
+            return;
+        }
+        appendLine(formatSessionSearch(matches));
+    }
+    function openSessionsPicker(initialScope) {
+        uiModalOpen = true;
+        let scope = initialScope;
+        const buildItems = () => {
+            const summaries = scope === "all" ? store.list() : store.list(process.cwd());
+            const toggle = {
+                value: "__scope__",
+                label: scope === "all"
+                    ? "Show this workspace only"
+                    : "Show all workspaces",
+                description: `scope: ${scope === "all" ? "all workspaces" : process.cwd()}`,
+            };
+            return [
+                toggle,
+                ...summaries.map((summary) => ({
+                    value: `session:${summary.id}`,
+                    label: summary.title ?? summary.id,
+                    description: `${summary.updatedAt ?? "unknown"} · ${summary.provider} · ${summary.messageCount ?? 0} messages · ${summary.workspace}`,
+                })),
+            ];
+        };
+        let picker;
+        picker = openSearchablePicker({
+            tui,
+            container: dropdownContainer,
+            title: "Resume session",
+            theme,
+            items: buildItems(),
+            closeOnSelect: false,
+            onSelect: (item) => {
+                if (item.value === "__scope__") {
+                    scope = scope === "all" ? "workspace" : "all";
+                    picker.updateItems(buildItems());
+                    picker.setStatus(scope === "all" ? "showing all workspaces" : "showing this workspace");
+                    return;
+                }
+                picker.close();
+                uiModalOpen = false;
+                resumeSession(item.value.slice("session:".length));
+            },
+            onCancel: () => {
+                uiModalOpen = false;
+                appendLine("cancelled");
+            },
+            restoreFocus: () => tui.setFocus(input),
+        });
+        closeActiveOverlay = picker.close;
+        picker.setStatus(scope === "all" ? "showing all workspaces" : "showing this workspace");
+    }
+    function buildPaletteItems() {
+        const items = [];
+        for (const command of commandRegistry.list()) {
+            const hint = command.argumentHint ? ` ${command.argumentHint}` : "";
+            items.push({
+                id: `command:${command.name}`,
+                label: `/${command.name}${hint}`,
+                description: command.description,
+                category: command.category,
+                keywords: command.aliases,
+                action: async () => {
+                    await commandRegistry.dispatch(`/${command.name}`, commandContext);
+                },
+            });
+        }
+        const profiles = new Set([
+            ...availableProviderNames(config),
+            ...Object.keys(config.providers),
+        ]);
+        for (const profile of profiles) {
+            const preset = getPreset(profile);
+            items.push({
+                id: `provider:${profile}`,
+                label: providerLabel(profile),
+                description: preset?.description ?? "configured provider",
+                category: "Providers",
+                action: () => {
+                    if (preset)
+                        startProviderSetup(profile);
+                    else
+                        switchModelTarget(`${profile}/${String(profileConfig(profile)?.model ?? "default")}`);
+                },
+            });
+        }
+        for (const item of buildModelItems()) {
+            const separator = item.value.indexOf("\u0000");
+            const profile = item.value.slice(0, separator);
+            const model = item.value.slice(separator + 1);
+            items.push({
+                id: `model:${item.value}`,
+                label: item.label.replace("  (current)", ""),
+                description: `${providerLabel(profile)}${item.label.includes("(current)") ? " · current" : ""}`,
+                category: "Models",
+                action: () => switchToModel(profile, model),
+            });
+        }
+        for (const name of themeNames()) {
+            items.push({
+                id: `theme:${name}`,
+                label: name,
+                description: themeLabel(name),
+                category: "Themes",
+                action: () => setThemeTarget(name),
+            });
+        }
+        for (const summary of store.list(process.cwd()).slice(0, 8)) {
+            items.push({
+                id: `session:${summary.id}`,
+                label: summary.title ?? summary.id,
+                description: `${summary.updatedAt ?? "unknown"} · ${summary.provider} · ${summary.messageCount ?? 0} messages`,
+                category: "Sessions",
+                keywords: [summary.provider, summary.workspace],
+                action: () => resumeSession(summary.id),
+            });
+        }
+        return items;
+    }
+    function openPalette() {
+        if (uiModalOpen)
+            return;
+        refreshCommandRegistry();
+        uiModalOpen = true;
+        const palette = openCommandPalette({
+            tui,
+            container: dropdownContainer,
+            items: buildPaletteItems(),
+            theme,
+            title: "Command palette",
+            onSelect: () => {
+                uiModalOpen = false;
+            },
+            onCancel: () => {
+                uiModalOpen = false;
+                appendLine("cancelled");
+            },
+            onError: (err) => {
+                uiModalOpen = false;
+                appendLine(`palette: ${err instanceof Error ? err.message : String(err)}`);
+            },
+            restoreFocus: () => tui.setFocus(input),
+        });
+        closeActiveOverlay = palette.close;
+        // The palette lists models too; refresh stale caches in the background and
+        // update the open list when live discovery finishes.
+        const stale = providersNeedingRefresh(availableProviderNames(config));
+        if (stale.length) {
+            refreshModelCache(stale, () => {
+                palette.updateItems(buildPaletteItems());
+            });
+        }
     }
-    appendLineFn = appendLine;
     function toggleTools() {
         expandTools = !expandTools;
         for (const box of toolBoxes) {
-            if (box.live)
-                continue; // a running command keeps its live view
-            box.output.clear();
-            if (expandTools) {
-                if (box.lines.length > 0) {
-                    box.output.addChild(new Text(box.lines.join("\n")));
+            box.setExpanded(expandTools);
+        }
+        tui.requestRender();
+    }
+    async function reloadExtensions() {
+        const previous = extensionLoader.list();
+        // Emit session_shutdown and extension_unload before unloading.
+        for (const loaded of previous) {
+            const handlers = loaded.registries?.handlers?.get?.("session_shutdown");
+            if (handlers) {
+                for (const handler of handlers) {
+                    try {
+                        await handler({ type: "session_shutdown", reason: "reload" }, (loaded.context ?? {}));
+                    }
+                    catch (error) {
+                        appendLine(`extension shutdown error: ${error instanceof Error ? error.message : String(error)}`);
+                    }
                 }
             }
-            else {
-                box.output.addChild(new Text(`  (${box.lines.length} lines, ctrl+o to expand)`));
+        }
+        await extensionLoader.unloadAll();
+        try {
+            await extensionLoader.loadAll();
+        }
+        catch (error) {
+            appendLine(`extensions: reload failed: ${error instanceof Error ? error.message : String(error)}`);
+            tui.requestRender();
+            return;
+        }
+        // Remove previously bridged providers, then re-bridge.
+        for (const name of extensionProviderNames) {
+            delete config.providers[name];
+            modelCache.delete(name);
+        }
+        extensionProviderNames.clear();
+        for (const loaded of extensionLoader.list()) {
+            for (const [name, provider] of (loaded.registries?.providers ?? new Map())) {
+                const cfg = provider?.config ?? {};
+                const firstModel = Array.isArray(cfg.models) && cfg.models.length > 0
+                    ? (cfg.models[0].id ?? cfg.models[0].name ?? "default")
+                    : "default";
+                const apiKey = resolveExtensionApiKey(cfg.apiKey);
+                const headers = { ...(cfg.headers ?? {}) };
+                if (cfg.authHeader && apiKey)
+                    headers.Authorization = `Bearer ${apiKey}`;
+                config.providers[name] = {
+                    type: "openai-compatible",
+                    baseUrl: cfg.baseUrl,
+                    model: firstModel,
+                    apiKey: apiKey ?? null,
+                    apiKeyEnv: null,
+                    headers,
+                    contextWindow: cfg.models?.[0]?.contextWindow,
+                };
+                extensionProviderNames.add(name);
+                const models = Array.isArray(cfg.models)
+                    ? cfg.models.map((m) => m.id ?? m.name).filter(Boolean)
+                    : [];
+                if (models.length > 0)
+                    modelCache.set(name, { models, at: Date.now() });
+            }
+        }
+        // Re-apply extension tools.
+        try {
+            await mcpManager.syncTools();
+        }
+        catch {
+            // ignore
+        }
+        runtime.setTools([
+            ...builtInTools,
+            ...collectExtensionTools(extensionLoader),
+            ...createMcpTools(mcpManager),
+        ]);
+        // Emit session_start with reason reload.
+        for (const loaded of extensionLoader.list()) {
+            const handlers = loaded.registries?.handlers?.get?.("session_start");
+            if (handlers) {
+                for (const handler of handlers) {
+                    try {
+                        await handler({ type: "session_start", reason: "reload" }, (loaded.context ?? {}));
+                    }
+                    catch (error) {
+                        appendLine(`extension start error: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
             }
         }
+        appendLine(`extensions: ${extensionLoader.list().length} reloaded (see /extensions)`);
         tui.requestRender();
     }
+    // Wire interactive extension UI callbacks now that the TUI exists.
+    extensionUICallbacks.notify = (message, type) => {
+        const style = type === "error"
+            ? theme.tokens.error
+            : type === "warning"
+                ? theme.tokens.warning
+                : theme.tokens.accent;
+        appendLine(`${style(`[ext]`)} ${message}`);
+    };
+    extensionUICallbacks.requestRender = () => tui.requestRender();
+    extensionUICallbacks.getToolsExpanded = () => expandTools;
+    extensionUICallbacks.setToolsExpanded = (expanded) => {
+        if (expandTools !== expanded)
+            toggleTools();
+    };
+    function toggleToolBoxAtScreenRow(screenY) {
+        const width = terminal.columns;
+        const outputHeight = Math.max(1, output.viewportHeight || output.render(width).length);
+        if (screenY < 0 || screenY >= outputHeight)
+            return false;
+        const children = content.children;
+        const contentBlocks = children.map((child, index) => ({
+            id: `content:${index}`,
+            height: child.render(width).length,
+        }));
+        const total = contentBlocks.reduce((sum, block) => sum + block.height, 0);
+        const viewportTop = Math.max(0, total - outputHeight);
+        const inner = blockAtLine(contentBlocks, viewportTop + screenY);
+        if (!inner)
+            return false;
+        const child = children[Number(inner.id.slice("content:".length))];
+        if (!(child instanceof ToolBox))
+            return false;
+        child.toggleExpanded();
+        return true;
+    }
+    tui.addInputListener((data) => {
+        const event = parseSgrMouse(data);
+        if (!event)
+            return undefined;
+        // Let the alt-screen TUI own wheel scrolling; only intercept clicks.
+        if (event.type === "wheel")
+            return undefined;
+        if (!mouseEnabled)
+            return { consume: true };
+        handleMouseEvent(event, {
+            isModalOpen: () => uiModalOpen,
+            scrollBy: (lines) => output.scrollBy(lines),
+            focusInput: () => tui.setFocus(input),
+            toggleToolBox: (screenY) => toggleToolBoxAtScreenRow(screenY),
+            requestRender: () => tui.requestRender(),
+        });
+        return { consume: true };
+    });
     tui.addInputListener((data) => {
+        // Releases and repeats must not toggle modal shortcuts twice.
+        if (isKeyRelease(data) || isKeyRepeat(data))
+            return undefined;
+        // Ctrl+P opens the command palette unless a modal owns the keyboard.
+        if (matchesKey(data, Key.ctrl("p")) && !uiModalOpen) {
+            openPalette();
+            return { consume: true };
+        }
         // Ctrl+O toggles tool expansion (unless a modal is capturing input).
         if (matchesKey(data, Key.ctrl("o")) && !uiModalOpen) {
             toggleTools();
             return { consume: true };
         }
+        // Escape cancels the active turn.
+        if (matchesKey(data, Key.escape) && !uiModalOpen && activeTurnController) {
+            activeTurnController.abort();
+            return { consume: true };
+        }
         return undefined;
     });
     runtime["onEvent"] = (e) => {
         if (e.type === "thinking_delta") {
+            activity.setPhase("thinking");
             if (!showThinking)
                 return;
             if (!thinkingText) {
-                thinkingText = new Text("\x1b[2mThinking...\x1b[0m");
+                thinkingText = new ThinkingBlock();
                 transcript.add(thinkingText);
                 thinkingBuffer = "";
             }
             thinkingBuffer += e.text;
-            const prefixed = thinkingBuffer
-                .split("\n")
-                .map((l) => `\x1b[2m| ${l}\x1b[0m`)
-                .join("\n");
-            thinkingText.setText(`\x1b[2mThinking...\x1b[0m\n${prefixed}`);
+            thinkingText.buffer = thinkingBuffer;
+            transcript.invalidate();
             tui.requestRender();
         }
         else if (e.type === "assistant_delta") {
+            activity.setPhase("working");
             if (thinkingText) {
-                const prefixed = thinkingBuffer
-                    .split("\n")
-                    .map((l) => `\x1b[2m| ${l}\x1b[0m`)
-                    .join("\n");
-                thinkingText.setText(`\x1b[2mThinking...\x1b[0m\n${prefixed}\n\x1b[2m| end\x1b[0m`);
+                transcript.invalidate();
                 thinkingText = null;
                 thinkingBuffer = "";
             }
             appendDelta(e.text);
         }
         else if (e.type === "assistant_text") {
+            activity.setPhase("working");
             if (thinkingText) {
-                const prefixed = thinkingBuffer
-                    .split("\n")
-                    .map((l) => `\x1b[2m| ${l}\x1b[0m`)
-                    .join("\n");
-                thinkingText.setText(`\x1b[2mThinking...\x1b[0m\n${prefixed}\n\x1b[2m| end\x1b[0m`);
+                transcript.invalidate();
                 thinkingText = null;
                 thinkingBuffer = "";
             }
@@ -718,37 +1569,18 @@ export async function run(args) {
         }
         else if (e.type === "tool_call") {
             finalizeText();
-            const box = new Container();
-            const header = new Text(`▸ ${e.name} ${JSON.stringify(e.args)}`);
-            box.addChild(header);
-            const output = new Container();
-            box.addChild(output);
+            activity.setPhase("working", e.name);
+            const box = new ToolBox({ id: e.id, name: e.name, args: e.args });
+            box.setExpanded(expandTools);
             transcript.add(box);
-            toolBoxes.push({
-                id: e.id,
-                header,
-                output,
-                container: box,
-                lines: [],
-                toolName: e.name,
-                args: e.args,
-            });
+            toolBoxes.push(box);
             tui.requestRender();
         }
         else if (e.type === "tool_output") {
             const box = toolBoxes.find((b) => b.id === e.toolCallId);
             if (box) {
-                if (!box.live) {
-                    box.live = new Text("");
-                    box.output.addChild(box.live);
-                }
-                box.liveBuffer = (box.liveBuffer ?? "") + e.text;
-                // Keep the live view bounded; the completed result carries the full
-                // capped output, and the JSONL transcript keeps everything.
-                if (box.liveBuffer.length > 60_000) {
-                    box.liveBuffer = box.liveBuffer.slice(-60_000);
-                }
-                box.live.setText(box.liveBuffer);
+                activity.setPhase("working", e.name);
+                box.appendLive(e.text);
                 tui.requestRender();
             }
         }
@@ -756,44 +1588,14 @@ export async function run(args) {
             const last = toolBoxes.find((b) => b.id === e.toolCallId) ??
                 toolBoxes[toolBoxes.length - 1];
             if (last) {
-                last.live = null;
-                last.liveBuffer = "";
-                last.output.clear();
-                if (e.diff) {
-                    const diffLines = e.diff;
-                    last.lines = diffLines;
-                    if (expandTools) {
-                        const colored = diffLines
-                            .map((l) => l.startsWith("+")
-                            ? `\x1b[32m${l}\x1b[0m`
-                            : l.startsWith("-")
-                                ? `\x1b[31m${l}\x1b[0m`
-                                : l)
-                            .join("\n");
-                        if (colored)
-                            last.output.addChild(new Text(colored));
-                    }
-                    else {
-                        const added = diffLines.filter((l) => l.startsWith("+")).length;
-                        const removed = diffLines.filter((l) => l.startsWith("-")).length;
-                        last.output.addChild(new Text(`  +${added} -${removed} (ctrl+o to expand)`));
-                    }
-                }
-                else {
-                    const lines = e.content.split("\n");
-                    last.lines = lines;
-                    if (expandTools) {
-                        last.output.addChild(new Text(lines.join("\n")));
-                    }
-                    else {
-                        last.output.addChild(new Text(`  (${lines.length} lines, ctrl+o to expand)`));
-                    }
-                }
+                last.setResult(e.content, { isError: e.isError, diff: e.diff });
+                activity.setPhase("working");
                 tui.requestRender();
             }
         }
         else if (e.type === "final") {
             finalizeText();
+            activity.stop();
         }
     };
     async function runDoctor() {
@@ -812,249 +1614,303 @@ export async function run(args) {
         catch (e) {
             lines.push(`  provider generate: FAIL ${e instanceof Error ? e.message : String(e)}`);
         }
+        lines.push(...formatMcpDoctor(mcpManager.status()));
         return lines.join("\n");
     }
-    input.onSubmit = async (value) => {
-        const trimmed = value.trim();
-        input.setText("");
-        if (pendingApproval) {
-            const a = trimmed.toLowerCase();
-            if (a === "y" || a === "yes")
-                pendingApproval("approve");
-            else if (a === "t" || a === "trust")
-                pendingApproval("trust-session");
-            else
-                pendingApproval("deny");
-            return;
-        }
-        if (!trimmed) {
-            tui.requestRender();
-            return;
-        }
-        const firstToken = trimmed.split(/\s+/)[0].replace(/^\//, "");
-        const _skillReg = cachedSkillRegistry();
-        const isSkill = _skillReg.list().some((s) => s.name === firstToken) || trimmed.startsWith("/skill ");
-        if (isSkill) {
-            const skillName = trimmed.startsWith("/skill ") ? trimmed.split(/\s+/)[1] : firstToken;
-            const content = _skillReg.load(skillName);
-            if (!content) {
-                appendLine(`skill not found: ${skillName}`);
+    async function runMcp(args) {
+        const trimmed = (args ?? "").trim();
+        if (trimmed === "reconnect" || trimmed.startsWith("reconnect ")) {
+            const server = trimmed.slice("reconnect".length).trim();
+            try {
+                if (server)
+                    await mcpManager.reconnect(server);
+                else
+                    await mcpManager.reconnect();
+            }
+            catch (e) {
+                appendLine(`mcp reconnect failed: ${e instanceof Error ? e.message : String(e)}`);
                 return;
             }
-            session.appendMessage({ role: "system", content });
-            if (typeof session.appendEvent === "function") {
-                session.appendEvent({ type: "skill_loaded", name: skillName });
+            if (useTools) {
+                await mcpManager.syncTools();
+                runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
             }
-            appendLine(`Loaded skill: ${skillName}`);
-            const extra = trimmed.startsWith("/skill ")
-                ? trimmed.split(/\s+/).slice(2).join(" ").trim()
-                : trimmed.slice(firstToken.length + 1).trim();
-            if (extra) {
-                appendLine(`> ${extra}`);
-                const controller = new AbortController();
-                try {
-                    await runtime.runAgentTurn(extra, session, controller.signal);
-                }
-                catch (err) {
-                    appendLine(`atom-lite: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            return;
-        }
-        if (trimmed === "/exit") {
-            tui.stop();
-            process.exit(0);
+            appendLine(formatMcpStatus(mcpManager.status()));
             return;
         }
-        if (trimmed === "/help") {
-            appendLine(["/help", "/model", "/provider", "/session", "/compact", "/clear", "/approval", "/doctor", "/effort", "/thinking", "/exit"].join("\n"));
+        if (trimmed) {
+            appendLine("usage: /mcp [reconnect [server]]");
             return;
         }
-        if (trimmed === "/session") {
-            appendLine(`session: ${session.id}\nworkspace: ${session.workspace}\nprovider: ${session.provider}\nmessages: ${session.messages.length}`);
-            return;
-        }
-        if (trimmed === "/approval") {
-            appendLine(`approval mode: ${approvals.mode}\ntrusted this session: ${approvals.isTrusted()}`);
-            return;
+        appendLine(formatMcpStatus(mcpManager.status()));
+    }
+    async function runExport(args) {
+        const tokens = (args ?? "").trim().split(/\s+/).filter(Boolean);
+        let format = "md";
+        let force = false;
+        let redact = true;
+        const positional = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t === "--format") {
+                format = tokens[++i] ?? format;
+            }
+            else if (t.startsWith("--format=")) {
+                format = t.slice("--format=".length);
+            }
+            else if (t === "--force") {
+                force = true;
+            }
+            else if (t === "--no-redact") {
+                redact = false;
+            }
+            else {
+                positional.push(t);
+            }
         }
-        if (trimmed === "/doctor") {
-            const out = await runDoctor();
-            appendLine(out);
+        const isJson = format === "json";
+        const ext = isJson ? "json" : "md";
+        const outPath = positional[0] || `${session.id}.${ext}`;
+        if (existsSync(outPath) && !force) {
+            appendLine(`export refused: ${outPath} already exists (use --force)`);
             return;
         }
-        if (trimmed === "/clear") {
-            session.messages.length = 0;
-            content.clear();
-            tui.requestRender();
-            appendLine("started new session");
-            return;
+        if (!redact) {
+            appendLine("warning: redaction disabled; secrets may be written to disk");
         }
-        if (trimmed === "/compact") {
-            appendLine("compaction is automatic");
+        const secretPatterns = [
+            /sk-[A-Za-z0-9_-]{8,}/g,
+            /ghp_[A-Za-z0-9]{20,}/g,
+            /gho_[A-Za-z0-9]{20,}/g,
+            /github_pat_[A-Za-z0-9_]{20,}/g,
+            /AKIA[0-9A-Z]{16}/g,
+            /xox[baprs]-[A-Za-z0-9-]{10,}/g,
+            /Bearer\s+[A-Za-z0-9._-]+/g,
+        ];
+        const redactText = (value) => {
+            if (!redact)
+                return value;
+            let out = value;
+            for (const pattern of secretPatterns) {
+                out = out.replace(pattern, "[REDACTED]");
+            }
+            return out;
+        };
+        const messageText = (message) => {
+            const content = message?.content;
+            if (Array.isArray(content)) {
+                return content
+                    .map((p) => (p?.type === "text" ? p.text : ""))
+                    .join("");
+            }
+            return typeof content === "string" ? content : "";
+        };
+        if (isJson) {
+            const events = typeof session.events !== "undefined"
+                ? session.events
+                : [];
+            const payload = {
+                version: 1,
+                session: {
+                    id: session.id,
+                    workspace: session.workspace,
+                    provider: session.provider,
+                    messageCount: session.messages.length,
+                },
+                messages: session.messages,
+                events,
+            };
+            let json = JSON.stringify(payload, null, 2);
+            if (redact)
+                json = redactText(json);
+            writeFileSync(outPath, json + "\n", "utf8");
+            appendLine(`exported session to ${outPath}`);
             return;
         }
-        if (trimmed === "/model" || trimmed.startsWith("/model ")) {
-            const rest = trimmed.slice("/model".length).trim();
-            if (!rest) {
-                openModelPicker();
-                return;
+        const lines = [];
+        lines.push(`# Session ${session.id}`);
+        lines.push("");
+        lines.push(`- Workspace: ${session.workspace}`);
+        lines.push(`- Provider: ${session.provider}`);
+        lines.push(`- Messages: ${session.messages.length}`);
+        lines.push(`- Exported: ${new Date().toISOString()}`);
+        lines.push("");
+        lines.push("## Table of contents");
+        lines.push("");
+        let turn = 0;
+        for (const message of session.messages) {
+            if (message.role === "user") {
+                turn++;
+                const snippet = redactText(messageText(message)).split("\\n")[0].slice(0, 80);
+                lines.push(`${turn}. ${snippet || "(empty)"}`);
             }
-            const knownModels = modelsFor(provider.id);
-            if (knownModels.includes(rest)) {
-                switchToModel(provider.id, rest);
-                return;
+        }
+        lines.push("");
+        lines.push("## Transcript");
+        lines.push("");
+        for (const message of session.messages) {
+            if (message.role === "user") {
+                lines.push("### User");
+                lines.push("");
+                lines.push(redactText(messageText(message)));
+                lines.push("");
             }
-            const slash = rest.indexOf("/");
-            if (slash > 0) {
-                const profile = rest.slice(0, slash);
-                const model = rest.slice(slash + 1);
-                if (profileConfig(profile) || getPreset(profile)) {
-                    switchToModel(profile, model);
-                    return;
+            else if (message.role === "assistant") {
+                lines.push("### Assistant");
+                lines.push("");
+                const text = redactText(messageText(message));
+                if (text.trim())
+                    lines.push(text);
+                if (Array.isArray(message.toolCalls) && message.toolCalls.length) {
+                    lines.push("");
+                    lines.push("Tool calls:");
+                    for (const call of message.toolCalls) {
+                        lines.push(`- \`${call.name}\` ${JSON.stringify(call.arguments ?? {})}`);
+                    }
                 }
+                lines.push("");
             }
-            if (profileConfig(rest) || getPreset(rest)) {
-                ensureProfile(rest);
-                const pcfg = profileConfig(rest);
-                switchToModel(rest, String(pcfg?.model ?? modelOverride ?? "default"));
-                return;
+            else if (message.role === "tool") {
+                lines.push(`### Tool result: ${message.name}`);
+                lines.push("");
+                const content = redactText(String(message.content ?? ""));
+                const truncated = content.length > 4000
+                    ? content.slice(0, 4000) + "\\n… (truncated)"
+                    : content;
+                lines.push("```");
+                lines.push(truncated);
+                lines.push("```");
+                lines.push("");
             }
-            switchToModel(provider.id, rest);
+        }
+        writeFileSync(outPath, lines.join("\\n"), "utf8");
+        appendLine(`exported session to ${outPath}`);
+    }
+    async function runCompact(args) {
+        const focus = (args ?? "").trim();
+        if (session.messages.length <= 6) {
+            appendLine("nothing to compact");
             return;
         }
-        if (trimmed === "/provider" || trimmed.startsWith("/provider ")) {
-            const rest = trimmed.slice("/provider".length).trim();
-            if (rest)
-                startProviderSetup(rest);
-            else
-                openProviderPicker();
+        const summary = await runtime.compactSession(session, focus || undefined);
+        if (!summary) {
+            appendLine("nothing to compact");
             return;
         }
-        if (trimmed === "/skills") {
-            const reg = new (await import("../skills/registry.js")).DefaultSkillRegistry(process.cwd());
-            const skills = reg.list();
-            if (skills.length === 0) {
-                appendLine("no skills available");
-                return;
-            }
-            appendLine(skills.map((sk) => `${sk.name} - ${sk.description}`).join("\n"));
+        appendLine(`compacted: ${summary.slice(0, 200)}`);
+    }
+    input.onSubmit = async (value) => {
+        const trimmed = value.trim();
+        input.setText("");
+        if (!trimmed) {
+            tui.requestRender();
             return;
         }
-        if (trimmed.startsWith("/skill ")) {
-            const name = trimmed.split(/\s+/)[1];
-            const reg = new (await import("../skills/registry.js")).DefaultSkillRegistry(process.cwd());
-            const content = reg.load(name);
-            if (!content) {
-                appendLine(`skill not found: ${name}`);
+        refreshCommandRegistry();
+        if (trimmed === "/steer" || trimmed.startsWith("/steer ")) {
+            const text = trimmed.slice("/steer".length).trim();
+            if (!text) {
+                appendLine("usage: /steer <message>");
+                tui.requestRender();
                 return;
             }
-            session.appendMessage({ role: "system", content });
-            if (typeof session.appendEvent === "function") {
-                session.appendEvent({ type: "skill_loaded", name });
+            if (activeTurnController) {
+                steeringQueue.push(text);
+                appendLine(`steering: ${text}`, theme.tokens.dim);
             }
-            appendLine(`Loaded skill: ${name}`);
-            const extra = trimmed.split(/\s+/).slice(2).join(" ").trim();
-            if (extra) {
-                appendLine(`> ${extra}`);
-                const controller = new AbortController();
-                try {
-                    await runtime.runAgentTurn(extra, session, controller.signal);
-                }
-                catch (err) {
-                    appendLine(`atom-lite: ${err instanceof Error ? err.message : String(err)}`);
-                }
+            else {
+                appendLine(`> ${text}`, theme.tokens.user);
+                await runTurn(text);
             }
+            tui.requestRender();
             return;
         }
-        if (trimmed === "/thinking") {
-            showThinking = !showThinking;
-            appendLine(`thinking display: ${showThinking ? "shown" : "hidden"}`);
-            return;
-        }
-        if (trimmed.startsWith("/effort")) {
-            const parts = trimmed.split(/\s+/);
-            if (parts.length >= 2) {
-                const lvl = parts[1];
-                if (lvl === "low" || lvl === "medium" || lvl === "high") {
-                    effortLevel = lvl;
-                    runtime.setEffort(lvl);
-                    updateStatus();
-                    appendLine(`effort set to ${effortLevel}`);
-                }
-                else {
-                    appendLine("usage: /effort low|medium|high");
-                }
+        if (trimmed.startsWith("/")) {
+            const result = await commandRegistry.dispatch(trimmed, commandContext);
+            if (result.exit)
                 return;
+            if (!result.handled) {
+                appendLine(`unknown command: ${trimmed.split(/\s+/)[0]} (type /help for a list of commands)`);
             }
-            // Interactive dropdown
-            const items = [
-                { value: "low", label: "low", description: "minimal reasoning" },
-                { value: "medium", label: "medium", description: "balanced" },
-                { value: "high", label: "high", description: "deep reasoning" },
-            ];
-            const { SelectList } = await import("@earendil-works/pi-tui");
-            const selectListTheme = {
-                selectedPrefix: (s) => s,
-                selectedText: (s) => `\x1b[7m${s}\x1b[0m`,
-                description: (s) => s,
-                scrollInfo: (s) => s,
-                noMatch: (s) => s,
-            };
-            const selectList = new SelectList(items, 3, selectListTheme);
-            dropdownContainer.addChild(selectList);
-            tui.requestRender();
-            const removeListener = tui.addInputListener((data) => {
-                // Skip kitty-protocol key-release events to avoid double moves.
-                if (isKeyRelease(data))
-                    return { consume: true };
-                selectList.handleInput(data);
-                tui.requestRender();
-                return { consume: true };
-            });
-            selectList.onSelect = (item) => {
-                removeListener();
-                const lvl = item.value;
-                effortLevel = lvl;
-                runtime.setEffort(lvl);
-                dropdownContainer.clear();
-                tui.setFocus(input);
-                updateStatus();
-                appendLine(`effort set to ${effortLevel}`);
-            };
-            selectList.onCancel = () => {
-                removeListener();
-                dropdownContainer.clear();
-                tui.setFocus(input);
-                appendLine("cancelled");
-            };
             return;
         }
-        appendLine(`> ${trimmed}`);
-        const controller = new AbortController();
-        try {
-            await runtime.runAgentTurn(trimmed, session, controller.signal);
+        // Skills remain invokable by bare name, but still run through the registry.
+        const bare = bareCommandName(commandRegistry, trimmed);
+        if (bare) {
+            await commandRegistry.dispatch(`/${bare} ${trimmed.slice(bare.length)}`, commandContext);
+            return;
         }
-        catch (err) {
-            appendLine(`atom-lite: ${err instanceof Error ? err.message : String(err)}`);
+        if (activeTurnController) {
+            messageQueue.push(trimmed);
+            appendLine(`queued: ${trimmed}`, theme.tokens.dim);
+            tui.requestRender();
+            return;
         }
+        appendLine(`> ${trimmed}`, theme.tokens.user);
+        await runTurn(trimmed);
     };
-    // fix approvals handler to use appendLine (defined above via closure var)
     approvals.handler = interactive
-        ? async (req) => {
-            appendLine("┌─ approval ─────────────────────────────");
-            appendLine(`│ ${req.command}`);
-            appendLine(`│ cwd: ${req.cwd}  timeout: ${req.timeoutMs}ms  sandboxed: ${req.sandboxed}`);
-            appendLine("│ [y]es / [n]o / [t]rust session");
-            appendLine("└────────────────────────────────────────");
-            return new Promise((resolve) => {
-                pendingApproval = (d) => {
-                    pendingApproval = null;
-                    resolve(d);
-                };
+        ? (req) => new Promise((resolve) => {
+            uiModalOpen = true;
+            closeOverlay();
+            dropdownContainer.clear();
+            activity.setPhase("waiting");
+            const prompt = new ApprovalPrompt(req, (decision) => {
+                uiModalOpen = false;
+                dropdownContainer.clear();
+                tui.setFocus(input);
+                activity.setPhase("working");
+                if (decision === "trust-session") {
+                    appendLine("trusted this session: shell commands will run without approval");
+                }
+                resolve(decision);
             });
-        }
+            dropdownContainer.addChild(prompt);
+            tui.setFocus(prompt);
+            tui.requestRender();
+        })
         : undefined;
+    process.on("SIGTERM", () => {
+        void mcpManager.close().finally(() => {
+            tui.stop();
+            process.exit(0);
+        });
+    });
     tui.start();
+    maybeReviewProjectTrust();
+    if (mouseEnabled) {
+        process.once("exit", () => mouseCapture.disable());
+        if (process.platform !== "win32") {
+            process.on("SIGTSTP", () => {
+                mouseCapture.disable();
+                process.kill(process.pid, "SIGSTOP");
+            });
+            process.on("SIGCONT", () => {
+                mouseCapture.enable();
+                tui.requestRender();
+            });
+        }
+    }
+    // Some terminals answer OSC 11 but not the colour-scheme report. Query the
+    // background once and derive light/dark from its luminance.
+    if (!noColor && typeof tui.queryTerminalColors === "function") {
+        void tui
+            .queryTerminalColors({ timeoutMs: 250 })
+            .then((colors) => {
+            const background = colors.background;
+            if (!background)
+                return;
+            const luminance = (0.2126 * background.r +
+                0.7152 * background.g +
+                0.0722 * background.b) /
+                255;
+            terminalScheme = luminance > 0.5 ? "light" : "dark";
+            if (themeName === "auto")
+                applyTheme("auto", false);
+        })
+            .catch(() => {
+            // Keep the static fallback.
+        });
+    }
 }
 //# sourceMappingURL=app.js.map