atom-lite 0.0.0-stage → 0.4.1

package/dist/cli/app.js

@@ -0,0 +1,1576 @@
+import { loadConfig } from "../config/load.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 { 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, isKeyRepeat, Key, matchesKey, } from "@earendil-works/pi-tui";
+export async function run(args) {
+    let providerOverride;
+    let modelOverride;
+    let jsonMode = false;
+    let debug = false;
+    let showVersion = false;
+    let sessionOverride;
+    let themeOverride;
+    let noColor = false;
+    let listSessions = false;
+    let searchSessionsQuery;
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--provider")
+            providerOverride = args[++i];
+        else if (a === "--model")
+            modelOverride = args[++i];
+        else if (a === "--json")
+            jsonMode = true;
+        else if (a === "--debug")
+            debug = true;
+        else if (a === "--version")
+            showVersion = true;
+        else if (a === "--continue")
+            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] [--list-sessions] [--search-sessions QUERY] [--no-tools] [--json] [--debug] [--theme NAME] [--no-color] [--version] [--help]\n");
+            return;
+        }
+        else if (a.startsWith("--")) {
+            // ignore
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    if (showVersion) {
+        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();
+    const initialProfile = providerOverride ?? config.defaultProvider;
+    if (!config.providers[initialProfile]) {
+        const preset = getPreset(initialProfile);
+        if (preset) {
+            config.providers[initialProfile] =
+                materializeProviderConfig(preset);
+        }
+    }
+    let provider = createProvider(config, providerOverride, modelOverride);
+    const modelByProvider = new Map();
+    if (modelOverride)
+        modelByProvider.set(provider.id, modelOverride);
+    const useTools = !positional.includes("__notools__");
+    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 = "";
+    if (!process.stdin.isTTY && positional.filter((p) => !p.startsWith("__")).length === 0) {
+        const chunks = [];
+        for await (const chunk of process.stdin)
+            chunks.push(chunk);
+        stdinTask = Buffer.concat(chunks).toString("utf8").trim();
+    }
+    const taskArgs = positional.filter((p) => !p.startsWith("__"));
+    const oneShot = (taskArgs.join(" ").trim() || stdinTask).trim();
+    const store = new JsonlSessionStore();
+    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 extensionLoader = new ExtensionLoader({
+        userDir: join(process.env.HOME ?? "", ".config", "atom-lite", "extensions"),
+        projectDir: process.cwd(),
+        trustedProjects: config.extensions?.trustedProjects,
+    });
+    void extensionLoader.loadAll().catch(() => {
+        // Extension failures are reported per extension.
+    });
+    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,
+        provider,
+        model: modelOverride ?? "default",
+        userInstructionsPath: undefined,
+    });
+    let sessionTrusted = false;
+    const approvals = {
+        mode: config.runtime.approvalMode ?? "ask",
+        // Installed below once the interactive UI helpers exist.
+        handler: undefined,
+        isTrusted: () => sessionTrusted,
+        trustSession: () => {
+            sessionTrusted = true;
+        },
+        nonInteractive: !interactive,
+    };
+    const runtime = new AgentRuntime({
+        provider,
+        model: modelOverride,
+        workspace: process.cwd(),
+        tools: builtInTools,
+        approvals,
+        contextManager,
+        bashConcurrency: config.runtime.bashConcurrency,
+    });
+    mcpManager.onToolsChanged = () => {
+        runtime.setTools([...builtInTools, ...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, ...createMcpTools(mcpManager)]);
+            }
+            const result = await runtime.runAgentTurn(oneShot || " ", session, controller.signal);
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify({ result, sessionId: session.id }) + "\n");
+            }
+            else {
+                process.stdout.write(result + "\n");
+            }
+        }
+        catch (err) {
+            if (jsonMode)
+                process.stderr.write(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }) + "\n");
+            else
+                process.stderr.write(`atom-lite: ${err instanceof Error ? err.message : String(err)}\n`);
+            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 terminal = new ProcessTerminal();
+    const tui = new TuiMainScreen(terminal);
+    const mouseEnabled = shouldEnableMouse({
+        interactive,
+        configured: config.ui.mouse,
+        stdoutIsTTY: process.stdout.isTTY === true,
+    });
+    const mouseCapture = createMouseCapture((data) => terminal.write(data));
+    let effortLevel = "medium";
+    runtime.setEffort(effortLevel);
+    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, 200, 200, markdownThemeFor(theme));
+    function headerLabel() {
+        const cwd = process.cwd();
+        const home = process.env.HOME ?? "";
+        let displayPath = cwd;
+        if (home && cwd.startsWith(home))
+            displayPath = "~" + cwd.slice(home.length);
+        let branch = "";
+        try {
+            branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+            if (branch === "HEAD") {
+                branch = execSync("git rev-parse --short HEAD", { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+            }
+        }
+        catch {
+            branch = "";
+        }
+        return branch ? `${displayPath}:${branch}` : displayPath;
+    }
+    // paddingY = 0 keeps the workspace path directly under the status line.
+    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: `${provider.id}/${provider.model ?? "default"}`,
+        tokens: "tokens: ?",
+        effort: "effort: medium",
+        activity: activity.text(),
+    });
+    const selectListTheme = {
+        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 input = new Editor(tui, editorTheme, {});
+    const { CombinedAutocompleteProvider } = await import("@earendil-works/pi-tui");
+    const { DefaultSkillRegistry, skillCacheSignature } = await import("../skills/registry.js");
+    let skillSignature = skillCacheSignature(process.cwd());
+    let skillReg = new DefaultSkillRegistry(process.cwd());
+    function cachedSkillRegistry() {
+        const sig = skillCacheSignature(process.cwd());
+        if (sig !== skillSignature) {
+            skillReg = new DefaultSkillRegistry(process.cwd());
+            skillSignature = sig;
+        }
+        return skillReg;
+    }
+    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()));
+    tui.addChild(output);
+    tui.addChild(new Spacer());
+    tui.addChild(input);
+    tui.addChild(statusBar);
+    // folder:branch info below the status line, dimmed
+    tui.addChild(header);
+    const dropdownContainer = new Container();
+    tui.addChild(dropdownContainer);
+    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.
+        }
+    }
+    let thinkingText = null;
+    let thinkingBuffer = "";
+    let showThinking = config.ui.showThinking;
+    let expandTools = false;
+    let uiModalOpen = false;
+    let closeActiveOverlay;
+    const toolBoxes = [];
+    /**
+     * 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) {
+        if (thinkingText) {
+            thinkingText = null;
+            thinkingBuffer = "";
+        }
+        streamText.finalize();
+        transcript.addLine(text);
+        tui.requestRender();
+    }
+    function appendDelta(delta) {
+        streamText.append(delta);
+        tui.requestRender();
+    }
+    function thinkingBody() {
+        return thinkingBuffer
+            .split("\n")
+            .map((line) => theme.tokens.dim(`| ${line}`))
+            .join("\n");
+    }
+    function finalizeText() {
+        streamText.finalize();
+    }
+    let activeTurnController = null;
+    /** 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, ...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();
+        }
+    }
+    function updateStatus() {
+        const usage = runtime.getContextUsage();
+        statusBar.setParts({
+            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.
+     */
+    function refreshContextWindow() {
+        const profile = provider.id;
+        const model = currentModelLabel();
+        const configured = profileConfig(profile)?.contextWindow;
+        const window = typeof configured === "number" && configured > 0
+            ? configured
+            : knownContextWindow(model);
+        runtime.setContextWindow(window);
+        updateStatus();
+        const getModelInfo = provider.getModelInfo;
+        if (typeof getModelInfo !== "function")
+            return;
+        void Promise.resolve()
+            .then(() => getModelInfo.call(provider))
+            .then((info) => {
+            if (provider.id !== profile || currentModelLabel() !== model)
+                return;
+            const resolved = info?.contextWindow;
+            if (typeof resolved === "number" && resolved > 0) {
+                runtime.setContextWindow(resolved);
+                updateStatus();
+            }
+        })
+            .catch(() => {
+            // Keep the static/config fallback.
+        });
+    }
+    // Resolve the initial model's window before the first response.
+    refreshContextWindow();
+    const MODEL_CACHE_TTL_MS = 5 * 60 * 1000;
+    const modelCache = new Map();
+    function profileConfig(profile) {
+        return config.providers[profile];
+    }
+    /** Ensure a preset profile exists in the in-memory config. */
+    function ensureProfile(profile) {
+        let pcfg = profileConfig(profile);
+        if (pcfg)
+            return pcfg;
+        const preset = getPreset(profile);
+        if (!preset)
+            return undefined;
+        pcfg = materializeProviderConfig(preset);
+        config.providers[profile] = pcfg;
+        saveProviderSelection(profile, pcfg);
+        return pcfg;
+    }
+    function modelsFor(profile) {
+        const cached = modelCache.get(profile);
+        if (cached && Date.now() - cached.at < MODEL_CACHE_TTL_MS) {
+            return cached.models;
+        }
+        const pcfg = profileConfig(profile);
+        const preset = getPreset(profile);
+        const fallback = [
+            ...(preset?.fallbackModels ?? []),
+            ...(pcfg?.model ? [String(pcfg.model)] : []),
+        ];
+        return [...new Set(fallback.filter(Boolean))];
+    }
+    function buildModelItems() {
+        const names = availableProviderNames(config);
+        if (!names.includes(provider.id) && profileConfig(provider.id)) {
+            names.unshift(provider.id);
+        }
+        else {
+            const idx = names.indexOf(provider.id);
+            if (idx > 0) {
+                names.splice(idx, 1);
+                names.unshift(provider.id);
+            }
+        }
+        const items = [];
+        const seen = new Set();
+        for (const name of names) {
+            let pcfg = profileConfig(name);
+            if (!pcfg) {
+                const preset = getPreset(name);
+                if (!preset)
+                    continue;
+                // Materialize env/credential-only presets in memory so they appear in
+                // the picker without being written to disk until the user picks one.
+                pcfg = materializeProviderConfig(preset);
+                config.providers[name] = pcfg;
+            }
+            for (const model of modelsFor(name)) {
+                const value = `${name}\u0000${model}`;
+                if (seen.has(value))
+                    continue;
+                seen.add(value);
+                const isCurrent = name === provider.id && model === currentModelLabel();
+                items.push({
+                    value,
+                    label: `${model}${isCurrent ? "  (current)" : ""}`,
+                    description: providerLabel(name),
+                });
+            }
+        }
+        return items;
+    }
+    function refreshModelCache(names, onUpdate) {
+        if (names.length === 0)
+            return;
+        let remaining = names.length;
+        for (const name of names) {
+            void listModelsForProvider(config, name, 8000).then((models) => {
+                if (models.length) {
+                    const configured = profileConfig(name)?.model;
+                    modelCache.set(name, {
+                        models: [
+                            ...new Set([
+                                ...(configured ? [String(configured)] : []),
+                                ...models,
+                            ]),
+                        ],
+                        at: Date.now(),
+                    });
+                }
+                remaining--;
+                if (remaining === 0)
+                    onUpdate();
+            });
+        }
+    }
+    /** 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) {
+            appendLine(`unknown provider: ${profile}`);
+            return;
+        }
+        pcfg.model = model;
+        config.defaultProvider = profile;
+        try {
+            saveProviderSelection(profile, { model }, { defaultProvider: profile });
+        }
+        catch (err) {
+            appendLine(`warning: could not persist model choice: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        modelByProvider.set(profile, model);
+        modelOverride = model;
+        provider = createProvider(config, profile, model);
+        runtime.switchModel(provider, model);
+        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)) {
+            names.unshift(provider.id);
+        }
+        uiModalOpen = true;
+        const picker = openSearchablePicker({
+            tui,
+            container: dropdownContainer,
+            title: "Select model",
+            theme,
+            items: buildModelItems(),
+            maxVisible: 15,
+            onSelect: (item) => {
+                uiModalOpen = false;
+                const sep = item.value.indexOf("\u0000");
+                const profile = item.value.slice(0, sep);
+                const model = item.value.slice(sep + 1);
+                switchToModel(profile, model);
+            },
+            onCancel: () => {
+                uiModalOpen = false;
+                appendLine("cancelled");
+            },
+            restoreFocus: () => tui.setFocus(input),
+        });
+        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());
+            });
+        }
+    }
+    function providerItems() {
+        return PROVIDER_PRESETS.map((preset) => {
+            const configured = Boolean(profileConfig(preset.id));
+            const key = preset.requiresKey
+                ? resolveApiKey(preset.id, { apiKeyEnv: preset.keyEnv })
+                : null;
+            const status = !preset.requiresKey
+                ? preset.local
+                    ? "local · no key"
+                    : "no key"
+                : key
+                    ? "key saved"
+                    : preset.keyEnv
+                        ? `needs key (${preset.keyEnv})`
+                        : "needs key";
+            return {
+                value: preset.id,
+                label: `${configured ? "✓ " : "  "}${preset.label}`,
+                description: `${preset.description} · ${status}`,
+            };
+        });
+    }
+    function activateProvider(preset, models) {
+        const existing = profileConfig(preset.id);
+        const pcfg = materializeProviderConfig(preset, existing);
+        config.providers[preset.id] = pcfg;
+        config.defaultProvider = preset.id;
+        saveProviderSelection(preset.id, pcfg, { defaultProvider: preset.id });
+        if (models?.length) {
+            modelCache.set(preset.id, {
+                models: [...new Set([String(pcfg.model), ...models])],
+                at: Date.now(),
+            });
+        }
+        const chosen = modelByProvider.get(preset.id) ?? String(pcfg.model);
+        pcfg.model = chosen;
+        modelOverride = chosen;
+        provider = createProvider(config, preset.id, chosen);
+        runtime.switchModel(provider, chosen);
+        if (typeof session.appendEvent === "function") {
+            session.appendEvent({ type: "provider_selected", provider: preset.id, model: chosen });
+        }
+        refreshContextWindow();
+        appendLine(`provider: ${preset.label} (${preset.id}) · model: ${chosen}`);
+        appendLine("tip: /model searches every configured provider");
+    }
+    function closeApiKeyPrompt() {
+        closeOverlay();
+        dropdownContainer.clear();
+        uiModalOpen = false;
+        tui.setFocus(input);
+        tui.requestRender();
+    }
+    function promptForApiKey(preset, existingKey) {
+        uiModalOpen = true;
+        closeOverlay();
+        dropdownContainer.clear();
+        const wrapper = new Container();
+        wrapper.addChild(new Text(theme.tokens.accent(`${preset.label} API key`)));
+        if (preset.keyUrl)
+            wrapper.addChild(new Text(theme.tokens.dim(`create one: ${preset.keyUrl}`)));
+        if (existingKey)
+            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);
+        wrapper.addChild(status);
+        dropdownContainer.addChild(wrapper);
+        tui.setFocus(secret);
+        tui.requestRender();
+        let busy = false;
+        secret.onCancel = () => {
+            if (busy)
+                return;
+            closeApiKeyPrompt();
+            appendLine(`cancelled ${preset.label} setup`);
+        };
+        secret.onSubmit = async (value) => {
+            if (busy)
+                return;
+            const key = value.trim();
+            if (!key) {
+                if (existingKey) {
+                    closeApiKeyPrompt();
+                    try {
+                        activateProvider(preset);
+                    }
+                    catch (err) {
+                        appendLine(`could not activate ${preset.label}: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    return;
+                }
+                status.setText(theme.tokens.dim("an API key is required"));
+                tui.requestRender();
+                return;
+            }
+            busy = true;
+            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(theme.tokens.error(`✗ key rejected by ${preset.label}`));
+                secret.reset();
+                tui.requestRender();
+                return;
+            }
+            try {
+                saveApiKey(preset.id, key);
+            }
+            catch (err) {
+                busy = false;
+                status.setText(theme.tokens.error(`✗ could not save key: ${err instanceof Error ? err.message : String(err)}`));
+                tui.requestRender();
+                return;
+            }
+            closeApiKeyPrompt();
+            if (!probe.ok) {
+                appendLine(`warning: could not verify ${preset.label} key (${probe.error ?? "network error"}); saved anyway`);
+            }
+            try {
+                activateProvider(preset, probe.models);
+            }
+            catch (err) {
+                appendLine(`could not activate ${preset.label}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        };
+    }
+    function startProviderSetup(profile) {
+        const preset = getPreset(profile);
+        if (!preset) {
+            appendLine(`unknown provider: ${profile}`);
+            return;
+        }
+        if (!preset.requiresKey) {
+            try {
+                activateProvider(preset);
+            }
+            catch (err) {
+                appendLine(`could not activate ${preset.label}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return;
+        }
+        const existingKey = resolveApiKey(preset.id, { apiKeyEnv: preset.keyEnv });
+        promptForApiKey(preset, existingKey);
+    }
+    function openProviderPicker() {
+        uiModalOpen = true;
+        const picker = openSearchablePicker({
+            tui,
+            container: dropdownContainer,
+            title: "Select provider",
+            theme,
+            items: providerItems(),
+            maxVisible: 12,
+            onSelect: (item) => {
+                uiModalOpen = false;
+                startProviderSetup(item.value);
+            },
+            onCancel: () => {
+                uiModalOpen = false;
+                appendLine("cancelled");
+            },
+            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,
+        runExport,
+        openModelPicker,
+        openProviderPicker,
+        openEffortPicker,
+        openThemePicker,
+        openSessionsPicker,
+        searchSessions: searchSessionsInStore,
+        renameSession,
+        listExtensions: () => extensionLoader
+            .list()
+            .map((ext) => `${ext.id}\t${ext.source}\t${ext.status}${ext.error ? `\t${ext.error}` : ""}`)
+            .join("\n") || "No extensions loaded.",
+        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());
+            });
+        }
+    }
+    function toggleTools() {
+        expandTools = !expandTools;
+        for (const box of toolBoxes) {
+            box.setExpanded(expandTools);
+        }
+        tui.requestRender();
+    }
+    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;
+        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(theme.tokens.dim("Thinking..."));
+                transcript.add(thinkingText);
+                thinkingBuffer = "";
+            }
+            thinkingBuffer += e.text;
+            thinkingText.setText(`${theme.tokens.dim("Thinking...")}\n${thinkingBody()}`);
+            tui.requestRender();
+        }
+        else if (e.type === "assistant_delta") {
+            activity.setPhase("working");
+            if (thinkingText) {
+                thinkingText.setText(`${theme.tokens.dim("Thinking...")}\n${thinkingBody()}\n${theme.tokens.dim("| end")}`);
+                thinkingText = null;
+                thinkingBuffer = "";
+            }
+            appendDelta(e.text);
+        }
+        else if (e.type === "assistant_text") {
+            activity.setPhase("working");
+            if (thinkingText) {
+                thinkingText.setText(`${theme.tokens.dim("Thinking...")}\n${thinkingBody()}\n${theme.tokens.dim("| end")}`);
+                thinkingText = null;
+                thinkingBuffer = "";
+            }
+            appendDelta(e.text);
+            finalizeText();
+        }
+        else if (e.type === "context_usage") {
+            updateStatus();
+        }
+        else if (e.type === "model_switched") {
+            appendLine(`switched model to ${e.provider}/${e.model}`);
+            if (typeof session.appendEvent === "function") {
+                session.appendEvent({ type: "model_switched", provider: e.provider, model: e.model });
+            }
+            updateStatus();
+        }
+        else if (e.type === "tool_call") {
+            finalizeText();
+            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(box);
+            tui.requestRender();
+        }
+        else if (e.type === "tool_output") {
+            const box = toolBoxes.find((b) => b.id === e.toolCallId);
+            if (box) {
+                activity.setPhase("working", e.name);
+                box.appendLive(e.text);
+                tui.requestRender();
+            }
+        }
+        else if (e.type === "tool_result") {
+            const last = toolBoxes.find((b) => b.id === e.toolCallId) ??
+                toolBoxes[toolBoxes.length - 1];
+            if (last) {
+                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() {
+        const lines = ["Doctor:"];
+        try {
+            loadConfig();
+            lines.push("  config: ok");
+        }
+        catch (e) {
+            lines.push(`  config: FAIL ${e instanceof Error ? e.message : String(e)}`);
+        }
+        try {
+            const r = await provider.generate({ model: modelOverride ?? "default", messages: [{ role: "user", content: [{ type: "text", text: "ping" }] }], tools: [] });
+            lines.push(`  provider generate: ok (${r.finishReason})`);
+        }
+        catch (e) {
+            lines.push(`  provider generate: FAIL ${e instanceof Error ? e.message : String(e)}`);
+        }
+        lines.push(...formatMcpDoctor(mcpManager.status()));
+        return lines.join("\n");
+    }
+    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;
+            }
+            if (useTools) {
+                await mcpManager.syncTools();
+                runtime.setTools([...builtInTools, ...createMcpTools(mcpManager)]);
+            }
+            appendLine(formatMcpStatus(mcpManager.status()));
+            return;
+        }
+        if (trimmed) {
+            appendLine("usage: /mcp [reconnect [server]]");
+            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);
+            }
+        }
+        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 (!redact) {
+            appendLine("warning: redaction disabled; secrets may be written to disk");
+        }
+        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;
+        }
+        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)"}`);
+            }
+        }
+        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("");
+            }
+            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("");
+            }
+            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("");
+            }
+        }
+        writeFileSync(outPath, lines.join("\\n"), "utf8");
+        appendLine(`exported session to ${outPath}`);
+    }
+    input.onSubmit = async (value) => {
+        const trimmed = value.trim();
+        input.setText("");
+        if (!trimmed) {
+            tui.requestRender();
+            return;
+        }
+        refreshCommandRegistry();
+        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)`);
+            }
+            return;
+        }
+        // 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;
+        }
+        appendLine(`> ${trimmed}`);
+        await runTurn(trimmed);
+    };
+    approvals.handler = interactive
+        ? (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();
+    if (mouseEnabled) {
+        mouseCapture.enable();
+        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