atom-lite 0.4.1 → 0.6.2

package/dist/cli/app.js

@@ -1,9 +1,12 @@
 import { loadConfig } from "../config/load.js";
+import { DEFAULT_SYSTEM_PROMPT } from "../agent/system-prompt.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 { execSync, spawn } from "node:child_process";
+import { defaultShell, terminateProcessTree } from "../security/process.js";
 import { openSearchablePicker } from "./picker.js";
 import { openCommandPalette } from "./palette.js";
 import { bareCommandName, createCommandRegistry } from "./commands.js";
@@ -12,7 +15,6 @@ 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";
@@ -20,15 +22,18 @@ 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 { readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool, grepTool, globTool } 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";
+import { ProcessTerminal, isKeyRelease, isKeyRepeat, Key, matchesKey, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
 export async function run(args) {
     let providerOverride;
     let modelOverride;
@@ -41,9 +46,15 @@ export async function run(args) {
     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];
@@ -68,7 +79,7 @@ export async function run(args) {
         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");
+            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("--")) {
@@ -114,7 +125,7 @@ export async function run(args) {
         modelByProvider.set(provider.id, modelOverride);
     const useTools = !positional.includes("__notools__");
     const builtInTools = useTools
-        ? [readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool]
+        ? [readTool, writeTool, editTool, bashTool, webfetchTool, websearchTool, grepTool, globTool]
         : [];
     const interactive = process.stdin.isTTY === true && !jsonMode;
     // one-shot task from positional or stdin
@@ -145,27 +156,108 @@ export async function run(args) {
             }
         },
     });
+    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({
-        userDir: join(process.env.HOME ?? "", ".config", "atom-lite", "extensions"),
+        cliPaths: extensionPaths,
+        cwd: process.cwd(),
+        agentDir: defaultAgentDir(),
+        userDir: join(userConfigDir(), "extensions"),
         projectDir: process.cwd(),
-        trustedProjects: config.extensions?.trustedProjects,
     });
-    void extensionLoader.loadAll().catch(() => {
+    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.",
+        systemPrompt: DEFAULT_SYSTEM_PROMPT,
         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;
     const approvals = {
-        mode: config.runtime.approvalMode ?? "ask",
+        mode: "ask",
         // Installed below once the interactive UI helpers exist.
         handler: undefined,
         isTrusted: () => sessionTrusted,
@@ -178,13 +270,17 @@ export async function run(args) {
         provider,
         model: modelOverride,
         workspace: process.cwd(),
-        tools: builtInTools,
+        tools: allTools,
         approvals,
+        mode: config.runtime.mode,
+        maxTokensPerSession: config.runtime.maxTokensPerSession,
+        maxTokensPerTurn: config.runtime.maxTokensPerTurn,
         contextManager,
+        extensionDispatch,
         bashConcurrency: config.runtime.bashConcurrency,
     });
     mcpManager.onToolsChanged = () => {
-        runtime.setTools([...builtInTools, ...createMcpTools(mcpManager)]);
+        runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
     };
     if (oneShot || !interactive) {
         // non-interactive / one-shot path
@@ -194,7 +290,7 @@ export async function run(args) {
         try {
             if (useTools) {
                 await mcpManager.syncTools();
-                runtime.setTools([...builtInTools, ...createMcpTools(mcpManager)]);
+                runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
             }
             const result = await runtime.runAgentTurn(oneShot || " ", session, controller.signal);
             if (jsonMode) {
@@ -218,14 +314,14 @@ export async function run(args) {
         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 { 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 TuiAltScreen(terminal, false, undefined, { mouse: mouseEnabled });
     const mouseCapture = createMouseCapture((data) => terminal.write(data));
     let effortLevel = "medium";
     runtime.setEffort(effortLevel);
@@ -267,10 +363,12 @@ export async function run(args) {
     const header = new Text(theme.tokens.dim(headerLabel()), 1, 0);
     const statusBar = new StatusLine(theme);
     const activity = new Activity({ theme, onChange: () => updateStatus() });
+    let currentMode = config.runtime.mode;
     statusBar.setParts({
         left: `${provider.id}/${provider.model ?? "default"}`,
         tokens: "tokens: ?",
         effort: "effort: medium",
+        mode: currentMode,
         activity: activity.text(),
     });
     const selectListTheme = {
@@ -305,17 +403,60 @@ export async function run(args) {
             return;
         commandRegistry = createCommandRegistry({ skills: cachedSkillRegistry().list() });
         registrySkillSignature = sig;
-        input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd()));
+        input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd(), fdPath));
     }
-    input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd()));
-    tui.addChild(output);
-    tui.addChild(new Spacer());
-    tui.addChild(input);
-    tui.addChild(statusBar);
+    const fdPath = (() => {
+        for (const bin of ["fd", "fdfind"]) {
+            try {
+                const found = execSync(`command -v ${bin}`, {
+                    encoding: "utf8",
+                    stdio: ["ignore", "pipe", "ignore"],
+                }).trim();
+                if (found)
+                    return found;
+            }
+            catch {
+                // ignore
+            }
+        }
+        return null;
+    })();
+    input.setAutocompleteProvider(new CombinedAutocompleteProvider(commandRegistry.autocomplete(), process.cwd(), fdPath));
+    // Skills should autocomplete (fill the input) rather than execute immediately
+    // when selected from the autocomplete list; Enter on a typed command still
+    // runs them. Convert a confirming Enter into a Tab completion for skills.
+    const originalHandleInput = input.handleInput.bind(input);
+    input.handleInput = (data) => {
+        try {
+            if ((data === "\r" || data === "\n") &&
+                input.autocompleteState &&
+                input.autocompleteList) {
+                const selected = input.autocompleteList.getSelectedItem?.();
+                const name = selected?.value ?? selected?.name ?? selected?.label;
+                const cmd = name ? commandRegistry.get(String(name).replace(/^\//, "")) : undefined;
+                if (cmd?.bareInvokable) {
+                    originalHandleInput("\t");
+                    return;
+                }
+            }
+        }
+        catch {
+            // Fall through to default handling on any introspection failure.
+        }
+        originalHandleInput(data);
+    };
+    const root = new VStack([]);
+    // Keep fixed chrome (spacer, input, status, header, dropdown) from being
+    // collapsed when the transcript grows; only the output region may shrink.
+    root.addChild(output, { grow: 1, shrink: 1, minSize: 0 });
+    root.addChild(new Spacer(1), { grow: 0, shrink: 0, minSize: 1 });
+    root.addChild(input, { grow: 0, shrink: 0 });
+    root.addChild(statusBar, { grow: 0, shrink: 0 });
     // folder:branch info below the status line, dimmed
-    tui.addChild(header);
+    root.addChild(header, { grow: 0, shrink: 0 });
     const dropdownContainer = new Container();
-    tui.addChild(dropdownContainer);
+    root.addChild(dropdownContainer, { grow: 0, shrink: 0 });
+    tui.setLayoutRoot(root);
     tui.setFocus(input);
     if (!noColor) {
         try {
@@ -331,6 +472,27 @@ export async function run(args) {
             // 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 = config.ui.showThinking;
@@ -348,29 +510,83 @@ export async function run(args) {
         closeActiveOverlay = undefined;
         close?.();
     }
-    function appendLine(text) {
+    function appendLine(text, style = theme.tokens.text) {
         if (thinkingText) {
             thinkingText = null;
             thinkingBuffer = "";
         }
         streamText.finalize();
-        transcript.addLine(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}`))
+            .map((line) => theme.tokens.dim(`│ ${line}`))
             .join("\n");
     }
     function finalizeText() {
         streamText.finalize();
     }
     let activeTurnController = null;
+    let shellMode = false;
+    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");
@@ -379,9 +595,13 @@ export async function run(args) {
         try {
             if (useTools) {
                 await mcpManager.syncTools();
-                runtime.setTools([...builtInTools, ...createMcpTools(mcpManager)]);
+                runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
+            }
+            const turnResult = await runtime.runAgentTurn(prompt, session, controller.signal);
+            if (turnResult === "TOKEN_BUDGET_REACHED") {
+                appendLine("token budget reached; stopping", theme.tokens.warning);
+                tui.requestRender();
             }
-            await runtime.runAgentTurn(prompt, session, controller.signal);
         }
         catch (err) {
             if (err instanceof Error && err.message === "USER_CANCELLED") {
@@ -394,6 +614,92 @@ export async function run(args) {
         finally {
             activeTurnController = null;
             activity.stop();
+            if (messageQueue.length > 0) {
+                const next = messageQueue.shift();
+                appendLine(`> ${next}`, theme.tokens.user);
+                void runTurn(next);
+            }
+        }
+    }
+    /** Run a shell command directly (shell mode / `!` prefix). */
+    async function runShellCommand(command) {
+        const shell = defaultShell();
+        const flag = process.platform === "win32" ? "/c" : "-c";
+        const start = Date.now();
+        const cap = 30000;
+        let stdout = "";
+        let stderr = "";
+        let truncated = false;
+        const append = (target, chunk) => {
+            const s = chunk.toString("utf8");
+            let accepted = s;
+            if (target === "out") {
+                if (stdout.length + s.length > cap) {
+                    truncated = true;
+                    accepted = s.slice(0, Math.max(0, cap - stdout.length));
+                    stdout += accepted;
+                }
+                else {
+                    stdout += s;
+                }
+            }
+            else {
+                if (stderr.length + s.length > cap) {
+                    truncated = true;
+                    accepted = s.slice(0, Math.max(0, cap - stderr.length));
+                    stderr += accepted;
+                }
+                else {
+                    stderr += s;
+                }
+            }
+            if (accepted) {
+                tui.requestRender();
+            }
+        };
+        try {
+            const child = spawn(shell, [flag, command], {
+                cwd: process.cwd(),
+                env: process.env,
+                detached: process.platform !== "win32",
+            });
+            child.stdout?.on("data", (c) => append("out", c));
+            child.stderr?.on("data", (c) => append("err", c));
+            const exit = await new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    terminateProcessTree(child, "SIGTERM");
+                    setTimeout(() => terminateProcessTree(child, "SIGKILL"), 1000).unref();
+                    resolve({ code: null, signal: "SIGTERM" });
+                }, 120000);
+                timer.unref();
+                child.on("exit", (code, signal) => {
+                    clearTimeout(timer);
+                    resolve({ code, signal });
+                });
+                child.on("error", (err) => {
+                    clearTimeout(timer);
+                    resolve({ code: null, signal: null });
+                    stderr = `COMMAND_FAILED: ${err instanceof Error ? err.message : String(err)}`;
+                });
+            });
+            const parts = [];
+            parts.push(`exit_code: ${exit.code ?? "null"}`);
+            if (exit.signal)
+                parts.push(`signal: ${exit.signal}`);
+            if (truncated)
+                parts.push("OUTPUT_TRUNCATED");
+            parts.push(`duration_ms: ${Date.now() - start}`);
+            if (stdout)
+                parts.push(`stdout:\n${stdout}`);
+            if (stderr)
+                parts.push(`stderr:\n${stderr}`);
+            const content = parts.join("\n");
+            appendLine(content, exit.code === 0 && !exit.signal && !stderr
+                ? theme.tokens.success
+                : theme.tokens.error);
+        }
+        catch (err) {
+            appendLine(`shell error: ${err instanceof Error ? err.message : String(err)}`, theme.tokens.error);
         }
     }
     function updateStatus() {
@@ -402,6 +708,7 @@ export async function run(args) {
             left: `${provider.id}/${currentModelLabel()}`,
             tokens: `tokens: ${formatContextUsage(usage.used, usage.window)}`,
             effort: `effort: ${effortLevel}`,
+            mode: currentMode,
             activity: activity.text(),
         });
         tui.requestRender();
@@ -467,6 +774,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];
     }
@@ -901,13 +1219,15 @@ export async function run(args) {
             appendLine(`skill not found: ${name}`);
             return false;
         }
+        if (extra) {
+            appendLine(`> ${extra}`, theme.tokens.user);
+        }
         session.appendMessage({ role: "system", content });
         if (typeof session.appendEvent === "function") {
             session.appendEvent({ type: "skill_loaded", name });
         }
-        appendLine(`Loaded skill: ${name}`);
+        appendLine(`Loaded skill: ${name}`, theme.tokens.dim);
         if (extra) {
-            appendLine(`> ${extra}`);
             await runTurn(extra);
         }
         return true;
@@ -927,6 +1247,7 @@ export async function run(args) {
         updateStatus,
         runDoctor,
         runMcp,
+        runCompact,
         runExport,
         openModelPicker,
         openProviderPicker,
@@ -935,10 +1256,22 @@ export async function run(args) {
         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.",
+        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,
@@ -1162,8 +1495,111 @@ export async function run(args) {
         for (const box of toolBoxes) {
             box.setExpanded(expandTools);
         }
+        transcript.invalidate();
+        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)}`);
+                    }
+                }
+            }
+        }
+        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);
@@ -1183,12 +1619,16 @@ export async function run(args) {
         if (!(child instanceof ToolBox))
             return false;
         child.toggleExpanded();
+        transcript.invalidate();
         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, {
@@ -1214,11 +1654,28 @@ export async function run(args) {
             toggleTools();
             return { consume: true };
         }
-        // Escape cancels the active turn.
-        if (matchesKey(data, Key.escape) && !uiModalOpen && activeTurnController) {
-            activeTurnController.abort();
+        // Tab toggles plan/yolo mode.
+        if (matchesKey(data, Key.tab) && !uiModalOpen) {
+            currentMode = currentMode === "plan" ? "yolo" : "plan";
+            runtime.setMode(currentMode);
+            updateStatus();
+            appendLine(`mode: ${currentMode}`, theme.tokens.dim);
+            tui.requestRender();
             return { consume: true };
         }
+        // Escape cancels the active turn, or exits shell mode.
+        if (matchesKey(data, Key.escape) && !uiModalOpen) {
+            if (activeTurnController) {
+                activeTurnController.abort();
+                return { consume: true };
+            }
+            if (shellMode) {
+                shellMode = false;
+                appendLine("shell mode: off", theme.tokens.dim);
+                tui.requestRender();
+                return { consume: true };
+            }
+        }
         return undefined;
     });
     runtime["onEvent"] = (e) => {
@@ -1227,18 +1684,19 @@ export async function run(args) {
             if (!showThinking)
                 return;
             if (!thinkingText) {
-                thinkingText = new Text(theme.tokens.dim("Thinking..."));
+                thinkingText = new ThinkingBlock();
                 transcript.add(thinkingText);
                 thinkingBuffer = "";
             }
             thinkingBuffer += e.text;
-            thinkingText.setText(`${theme.tokens.dim("Thinking...")}\n${thinkingBody()}`);
+            thinkingText.buffer = thinkingBuffer;
+            transcript.invalidate();
             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")}`);
+                transcript.invalidate();
                 thinkingText = null;
                 thinkingBuffer = "";
             }
@@ -1247,7 +1705,7 @@ export async function run(args) {
         else if (e.type === "assistant_text") {
             activity.setPhase("working");
             if (thinkingText) {
-                thinkingText.setText(`${theme.tokens.dim("Thinking...")}\n${thinkingBody()}\n${theme.tokens.dim("| end")}`);
+                transcript.invalidate();
                 thinkingText = null;
                 thinkingBuffer = "";
             }
@@ -1257,6 +1715,10 @@ export async function run(args) {
         else if (e.type === "context_usage") {
             updateStatus();
         }
+        else if (e.type === "budget_warning") {
+            appendLine(`budget warning (${e.scope}): ${e.used}/${e.limit} tokens`, theme.tokens.warning);
+            tui.requestRender();
+        }
         else if (e.type === "model_switched") {
             appendLine(`switched model to ${e.provider}/${e.model}`);
             if (typeof session.appendEvent === "function") {
@@ -1278,6 +1740,7 @@ export async function run(args) {
             if (box) {
                 activity.setPhase("working", e.name);
                 box.appendLive(e.text);
+                transcript.invalidate();
                 tui.requestRender();
             }
         }
@@ -1330,7 +1793,7 @@ export async function run(args) {
             }
             if (useTools) {
                 await mcpManager.syncTools();
-                runtime.setTools([...builtInTools, ...createMcpTools(mcpManager)]);
+                runtime.setTools([...builtInTools, ...extensionTools, ...createMcpTools(mcpManager)]);
             }
             appendLine(formatMcpStatus(mcpManager.status()));
             return;
@@ -1483,6 +1946,19 @@ export async function run(args) {
         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;
+        }
+        const summary = await runtime.compactSession(session, focus || undefined);
+        if (!summary) {
+            appendLine("nothing to compact");
+            return;
+        }
+        appendLine(`compacted: ${summary.slice(0, 200)}`);
+    }
     input.onSubmit = async (value) => {
         const trimmed = value.trim();
         input.setText("");
@@ -1490,7 +1966,46 @@ export async function run(args) {
             tui.requestRender();
             return;
         }
+        // Shell mode: every line is a shell command. `!` alone (or as first char)
+        // enters shell mode; Escape exits it.
+        if (shellMode) {
+            const cmd = trimmed.startsWith("!") ? trimmed.slice(1).trim() : trimmed;
+            appendLine(`$ ${cmd}`, theme.tokens.user);
+            await runShellCommand(cmd);
+            tui.requestRender();
+            return;
+        }
+        // `!` as first character enters shell mode.
+        if (trimmed === "!" || trimmed.startsWith("! ")) {
+            shellMode = true;
+            const rest = trimmed.slice(1).trim();
+            appendLine("shell mode: on (Escape to exit)", theme.tokens.dim);
+            if (rest) {
+                appendLine(`$ ${rest}`, theme.tokens.user);
+                await runShellCommand(rest);
+            }
+            tui.requestRender();
+            return;
+        }
         refreshCommandRegistry();
+        if (trimmed === "/steer" || trimmed.startsWith("/steer ")) {
+            const text = trimmed.slice("/steer".length).trim();
+            if (!text) {
+                appendLine("usage: /steer <message>");
+                tui.requestRender();
+                return;
+            }
+            if (activeTurnController) {
+                steeringQueue.push(text);
+                appendLine(`steering: ${text}`, theme.tokens.dim);
+            }
+            else {
+                appendLine(`> ${text}`, theme.tokens.user);
+                await runTurn(text);
+            }
+            tui.requestRender();
+            return;
+        }
         if (trimmed.startsWith("/")) {
             const result = await commandRegistry.dispatch(trimmed, commandContext);
             if (result.exit)
@@ -1506,30 +2021,17 @@ export async function run(args) {
             await commandRegistry.dispatch(`/${bare} ${trimmed.slice(bare.length)}`, commandContext);
             return;
         }
-        appendLine(`> ${trimmed}`);
+        if (activeTurnController) {
+            messageQueue.push(trimmed);
+            appendLine(`queued: ${trimmed}`, theme.tokens.dim);
+            tui.requestRender();
+            return;
+        }
+        appendLine(`> ${trimmed}`, theme.tokens.user);
         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;
+    // Approval prompts are superseded by plan/yolo modes.
+    approvals.handler = undefined;
     process.on("SIGTERM", () => {
         void mcpManager.close().finally(() => {
             tui.stop();
@@ -1537,8 +2039,8 @@ export async function run(args) {
         });
     });
     tui.start();
+    maybeReviewProjectTrust();
     if (mouseEnabled) {
-        mouseCapture.enable();
         process.once("exit", () => mouseCapture.disable());
         if (process.platform !== "win32") {
             process.on("SIGTSTP", () => {