agent-sh 0.7.0 → 0.8.0

package/dist/extensions/overlay-agent.js

@@ -1,43 +1,147 @@
-const BOLD = "\x1b[1m";
-const CYAN = "\x1b[36m";
-const RESET = "\x1b[0m";
-export default function activate({ bus, createFloatingPanel }) {
+import { MarkdownRenderer } from "../utils/markdown.js";
+import { palette as p } from "../utils/palette.js";
+import { renderToolCall, formatElapsed, } from "../utils/tool-display.js";
+export default function activate(ctx) {
+    const { bus, advise, call, createFloatingPanel } = ctx;
     const panel = createFloatingPanel({
         trigger: "\x1c", // Ctrl+\
         dimBackground: true,
-        autoDismissMs: 2000,
     });
+    // Suppress TUI renderer when overlay owns agent output
+    advise("tui:should-render-agent", (next) => {
+        return panel.active ? false : next();
+    });
+    // Signal interactive overlay mode in dynamic context
+    advise("dynamic-context:build", (next) => {
+        const base = next();
+        if (!panel.active)
+            return base;
+        return base + "\ninteractive-session: true\n";
+    });
+    // ── Conversation state (persists across hide/show) ─────────
+    const messages = [];
+    let renderer = null;
+    let currentAssistantMsg = null;
+    // ── Tool state ─────────────────────────────────────────────
+    let toolStartTime = 0;
+    function getContentWidth() {
+        return panel.computeGeometry().contentW;
+    }
+    /** Rebuild panel content from full message history. */
+    function rebuildContent() {
+        panel.clearContent();
+        for (const msg of messages) {
+            for (const line of msg.lines) {
+                panel.appendLine(line);
+            }
+            panel.appendLine("");
+        }
+    }
+    /** Append a line to current assistant message and panel (if visible). */
+    function appendLine(line) {
+        currentAssistantMsg?.lines.push(line);
+        if (panel.visible)
+            panel.appendLine(line);
+    }
+    function drainRenderer() {
+        if (!renderer)
+            return;
+        for (const line of renderer.drainLines()) {
+            appendLine(line);
+        }
+    }
+    function flushRenderer() {
+        if (!renderer)
+            return;
+        renderer.flush();
+        drainRenderer();
+    }
+    function startAssistantMessage() {
+        flushRenderer();
+        currentAssistantMsg = { role: "assistant", lines: [] };
+        messages.push(currentAssistantMsg);
+        renderer = new MarkdownRenderer(getContentWidth());
+    }
+    function finalizeAssistantMessage() {
+        flushRenderer();
+        renderer = null;
+        currentAssistantMsg = null;
+    }
     // ── Panel lifecycle ────────────────────────────────────────
     panel.handlers.advise("panel:submit", (_next, query) => {
+        messages.push({
+            role: "user",
+            lines: [`${p.accent}${p.bold}❯${p.reset} ${query}`],
+        });
         panel.setActive();
-        panel.appendLine(`${CYAN}${BOLD}❯${RESET} ${query}`);
-        panel.appendLine("");
+        rebuildContent();
+        startAssistantMessage();
         bus.emit("agent:submit", { query });
     });
+    panel.handlers.advise("panel:show", (_next) => {
+        rebuildContent();
+        if (renderer)
+            drainRenderer();
+    });
     // ── Stream agent response into panel ───────────────────────
     bus.on("agent:response-chunk", (e) => {
         if (!panel.active)
             return;
+        if (!currentAssistantMsg)
+            startAssistantMessage();
         for (const block of e.blocks) {
             if (block.type === "text" && block.text) {
-                panel.appendText(block.text);
+                renderer.push(block.text);
+                drainRenderer();
+            }
+            else if (block.type === "code-block") {
+                flushRenderer();
+                // Reuse the shared code-block handler
+                call("render:code-block", block.language, block.code, getContentWidth());
             }
         }
     });
+    // Capture lines emitted by render:code-block into the overlay
+    advise("render:code-block", (next, language, code, width) => {
+        if (!panel.active)
+            return next(language, code, width);
+        // Render code block as indented dim lines for the overlay
+        const label = language ? `${p.dim}${language}${p.reset}` : "";
+        if (label)
+            appendLine(label);
+        for (const codeLine of code.split("\n")) {
+            appendLine(`  ${p.dim}${codeLine}${p.reset}`);
+        }
+    });
     bus.on("agent:tool-started", (e) => {
         if (!panel.active)
             return;
-        panel.appendLine(`▶ ${e.title}${e.displayDetail ? " " + e.displayDetail : ""}`);
+        if (!currentAssistantMsg)
+            startAssistantMessage();
+        flushRenderer();
+        toolStartTime = Date.now();
+        const lines = renderToolCall({
+            title: e.title,
+            kind: e.kind,
+            icon: e.icon,
+            locations: e.locations,
+            rawInput: e.rawInput,
+            displayDetail: e.displayDetail,
+        }, getContentWidth());
+        for (const line of lines)
+            appendLine(line);
     });
     bus.on("agent:tool-completed", (e) => {
         if (!panel.active)
             return;
-        const mark = e.exitCode === 0 ? " ✓" : ` ✗ exit ${e.exitCode}`;
-        panel.updateLastLine((line) => line + mark);
+        const elapsed = toolStartTime ? formatElapsed(Date.now() - toolStartTime) : "";
+        const mark = call("tui:render-tool-complete", e.exitCode, elapsed, undefined);
+        appendLine(`  ${mark}`);
     });
     bus.on("agent:processing-done", () => {
         if (!panel.active)
             return;
+        finalizeAssistantMessage();
         panel.setDone();
     });
 }

package/dist/extensions/slash-commands.js

@@ -75,6 +75,34 @@ export default function activate({ bus, contextManager }) {
             }
         },
     });
+    register({
+        name: "/compact",
+        description: "Compact conversation (move full content to nuclear summaries)",
+        handler: () => {
+            bus.emit("agent:compact-request", {});
+        },
+    });
+    register({
+        name: "/context",
+        description: "Show context budget usage",
+        handler: () => {
+            const stats = bus.emitPipe("context:get-stats", {
+                activeTokens: 0,
+                nuclearEntries: 0,
+                recallArchiveSize: 0,
+                budgetTokens: 0,
+            });
+            const pct = stats.budgetTokens > 0
+                ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
+                : 0;
+            const lines = [
+                `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+                `Nuclear entries: ${stats.nuclearEntries} in-context`,
+                `Recall archive: ${stats.recallArchiveSize} entries`,
+            ];
+            bus.emit("ui:info", { message: lines.join("\n") });
+        },
+    });
     // ── Extension registration ────────────────────────────────────
     bus.on("command:register", (cmd) => {
         register(cmd);

package/dist/extensions/terminal-buffer.js

@@ -24,9 +24,10 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
         return; // @xterm/headless not installed
     registerTool({
         name: "terminal_read",
-        description: "Read the current terminal screen contents. Returns clean text (ANSI stripped) " +
+        description: "Read what is currently visible on the user's terminal screen. Returns clean text (ANSI stripped) " +
             "with cursor position and whether an alternate-screen program (vim, htop, less) is active. " +
-            "Use this to see what the user sees before sending keystrokes with terminal_keys.",
+            "Use this to observe what the user sees — helpful for answering questions about terminal output, " +
+            "diagnosing errors on screen, or checking state before/after sending keystrokes with terminal_keys.",
         input_schema: {
             type: "object",
             properties: {},
@@ -52,8 +53,11 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
     });
     registerTool({
         name: "terminal_keys",
-        description: "Send keystrokes to the user's live terminal. The keys are written directly to the PTY " +
-            "as if the user typed them. Use escape sequences for special keys:\n" +
+        description: "Send keystrokes directly into the user's live terminal PTY, as if the user typed them. " +
+            "Use this to interact with programs already running in the terminal (vim, htop, less, ssh, REPLs, etc.) " +
+            "or to type commands at the shell prompt. Do NOT use user_shell for this — user_shell runs a new " +
+            "command in a subshell, while terminal_keys types into whatever is currently on screen.\n\n" +
+            "Escape sequences for special keys:\n" +
             "  - Escape: \\x1b\n" +
             "  - Enter/Return: \\r\n" +
             "  - Tab: \\t\n" +
@@ -105,6 +109,7 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
             process.stdout.write("\n");
             bus.emit("shell:pty-write", { data: keys });
             await settle(settleMs);
+            bus.emit("shell:stdout-hide", {});
             const { text, altScreen, cursorX, cursorY } = tb.readScreen();
             const info = [
                 altScreen ? "mode: alternate screen" : "mode: normal",

package/dist/extensions/tui-renderer.js

@@ -14,7 +14,7 @@ import { highlight } from "cli-highlight";
 import { MarkdownRenderer, wrapLine } from "../utils/markdown.js";
 import { createFencedBlockTransform } from "../utils/stream-transform.js";
 import { palette as p } from "../utils/palette.js";
-import { renderToolCall, createSpinner, renderSpinnerLine, formatElapsed, } from "../utils/tool-display.js";
+import { renderToolCall, createSpinner, formatElapsed, SPINNER_FRAMES, } from "../utils/tool-display.js";
 import { renderDiff } from "../utils/diff-renderer.js";
 import { renderBoxFrame } from "../utils/box-frame.js";
 import { getSettings } from "../settings.js";
@@ -74,6 +74,69 @@ export default function activate(ctx) {
     // Suppress all TUI output while stdout is held (overlay extensions)
     bus.on("shell:stdout-hold", () => { writer.hold(); });
     bus.on("shell:stdout-release", () => { writer.release(); });
+    // Gate: other extensions (e.g. overlay) can advise this to suppress
+    // TUI rendering of agent output while they own the display.
+    define("tui:should-render-agent", () => true);
+    function shouldRender() { return ctx.call("tui:should-render-agent"); }
+    // ── Advisable rendering handlers ───────────────────────────────
+    // Extensions advise these to customize how the TUI renders content.
+    // Each handler receives data and returns rendered strings.
+    define("tui:response-start", () => { });
+    define("tui:response-end", (_hadToolCalls) => { });
+    define("tui:render-info", (message) => `${p.muted}${message}${p.reset}`);
+    define("tui:render-error", (message) => `${p.error}Error: ${message}${p.reset}`);
+    define("tui:render-usage", (promptTokens, completionTokens, maxTokens) => {
+        const ctxK = (promptTokens / 1000).toFixed(1);
+        const maxK = (maxTokens / 1000).toFixed(0);
+        const pct = Math.min(100, (promptTokens / maxTokens) * 100).toFixed(0);
+        return `${p.dim}⬆ ${promptTokens}  ⬇ ${completionTokens}  ctx: ${ctxK}k/${maxK}k (${pct}%)${p.reset}`;
+    });
+    define("tui:render-content-gap", (fromKind, toKind) => fromKind !== toKind ? "\n" : null);
+    define("tui:render-tool-complete", (exitCode, elapsed, summary) => {
+        const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
+        const summaryStr = summary ? ` ${p.dim}${summary}${p.reset}` : "";
+        if (exitCode === null)
+            return `${p.muted}(timed out)${p.reset}`;
+        if (exitCode === 0)
+            return `${p.success}✓${p.reset}${summaryStr}${timer}`;
+        return `${p.error}✗ exit ${exitCode}${p.reset}${summaryStr}${timer}`;
+    });
+    define("tui:render-tool-group-summary", (count, rendered, allOk, summaries) => {
+        const mark = allOk ? `${p.success}✓${p.reset}` : `${p.error}✗${p.reset}`;
+        const summaryStr = summaries.length > 0 ? ` ${p.dim}${summaries.join(", ")}${p.reset}` : "";
+        const collapsed = count - rendered;
+        if (collapsed > 0) {
+            return `  ${p.muted}└${p.reset} ${p.dim}+${collapsed} more${p.reset} ${mark}${summaryStr}`;
+        }
+        return `  ${p.muted}└${p.reset} ${mark}${summaryStr}`;
+    });
+    define("tui:render-command-output", (line, _kind) => `${p.dim}  ${line}${p.reset}`);
+    define("tui:render-spinner", (label, frame, elapsed, hint) => {
+        const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
+        const hintStr = hint ? ` ${p.dim}${hint}${p.reset}` : "";
+        return `${p.accent}${frame} ${label}...${p.reset}${timer}${hintStr}`;
+    });
+    define("tui:render-user-query", (query, width, modelLabel) => {
+        const contentW = width - 4;
+        let lines = [];
+        for (const raw of query.split("\n")) {
+            for (const wrapped of wrapLine(`${p.accent}${raw}${p.reset}`, contentW)) {
+                lines.push(wrapped);
+            }
+        }
+        const MAX_QUERY_LINES = 20;
+        if (lines.length > MAX_QUERY_LINES) {
+            const overflow = lines.length - MAX_QUERY_LINES;
+            lines = [...lines.slice(0, MAX_QUERY_LINES), `${p.dim}… ${overflow} more lines${p.reset}`];
+        }
+        return renderBoxFrame(lines, {
+            width,
+            style: "rounded",
+            borderColor: p.accent,
+            title: `${p.accent}${p.bold}❯${p.reset}`,
+            titleRight: modelLabel,
+        });
+    });
     // Track backend/model info for display on response border
     let backendInfo = null;
     bus.on("agent:info", (info) => { backendInfo = info; });
@@ -88,12 +151,16 @@ export default function activate(ctx) {
     });
     // ── Event subscriptions ─────────────────────────────────────
     bus.on("agent:query", (e) => {
+        if (!shouldRender())
+            return;
         s.spinnerStartTime = 0;
         showUserQuery(e.query);
         startAgentResponse();
         startThinkingSpinner();
     });
     bus.on("agent:thinking-chunk", (e) => {
+        if (!shouldRender())
+            return;
         s.thinkingPending = true;
         if (!s.isThinking) {
             s.isThinking = true;
@@ -118,6 +185,8 @@ export default function activate(ctx) {
         }
     });
     bus.on("agent:response-chunk", (e) => {
+        if (!shouldRender())
+            return;
         const { blocks } = e;
         // Inject spacing: append \n to text blocks that precede non-text blocks
         for (let i = 0; i < blocks.length; i++) {
@@ -150,17 +219,14 @@ export default function activate(ctx) {
     let pendingUsage = null;
     bus.on("agent:usage", (e) => { pendingUsage = e; });
     bus.on("agent:response-done", () => {
+        if (!shouldRender())
+            return;
         s.isThinking = false;
         if (pendingUsage && s.renderer) {
             const { prompt_tokens, completion_tokens } = pendingUsage;
             const maxTokens = backendInfo?.contextWindow ?? 128_000;
-            // prompt_tokens of the latest call = current context usage
-            // (it includes the full conversation history)
-            const ctxK = (prompt_tokens / 1000).toFixed(1);
-            const maxK = (maxTokens / 1000).toFixed(0);
-            const pct = Math.min(100, (prompt_tokens / maxTokens) * 100).toFixed(0);
             s.renderer.writeLine("");
-            s.renderer.writeLine(`${p.dim}⬆ ${prompt_tokens}  ⬇ ${completion_tokens}  ctx: ${ctxK}k/${maxK}k (${pct}%)${p.reset}`);
+            s.renderer.writeLine(ctx.call("tui:render-usage", prompt_tokens, completion_tokens, maxTokens));
             drain();
             pendingUsage = null;
         }
@@ -173,6 +239,8 @@ export default function activate(ctx) {
     // Batch groups: kind → { total, rendered, headerShown }
     let batchGroups = new Map();
     bus.on("agent:tool-batch", (e) => {
+        if (!shouldRender())
+            return;
         fencedTransform.flush();
         finalizeToolGroup();
         batchGroups = new Map();
@@ -185,6 +253,8 @@ export default function activate(ctx) {
         }
     });
     bus.on("agent:tool-started", (e) => {
+        if (!shouldRender())
+            return;
         fencedTransform.flush();
         stopCurrentSpinner();
         s.currentToolKind = e.kind;
@@ -248,6 +318,8 @@ export default function activate(ctx) {
         }
     });
     bus.on("agent:tool-completed", (e) => {
+        if (!shouldRender())
+            return;
         s.toolExitCode = e.exitCode;
         if (e.exitCode !== 0)
             s.toolGroupAllOk = false;
@@ -265,20 +337,28 @@ export default function activate(ctx) {
             startThinkingSpinner();
         }
     });
-    bus.on("agent:tool-output-chunk", (e) => writeCommandOutput(e.chunk));
-    bus.on("agent:tool-output", () => flushCommandOutput());
+    bus.on("agent:tool-output-chunk", (e) => { if (shouldRender())
+        writeCommandOutput(e.chunk); });
+    bus.on("agent:tool-output", () => { if (shouldRender())
+        flushCommandOutput(); });
     bus.on("agent:cancelled", () => {
+        if (!shouldRender())
+            return;
         s.isThinking = false;
         stopCurrentSpinner();
         showInfo("(cancelled)");
         endAgentResponse();
     });
     bus.on("agent:processing-done", () => {
+        if (!shouldRender())
+            return;
         s.isThinking = false;
         stopCurrentSpinner();
         endAgentResponse();
     });
     bus.on("agent:error", (e) => {
+        if (!shouldRender())
+            return;
         stopCurrentSpinner();
         showCollapsedThinking();
         if (!s.renderer)
@@ -289,6 +369,8 @@ export default function activate(ctx) {
         drain();
     });
     bus.on("permission:request", (e) => {
+        if (!shouldRender())
+            return;
         stopCurrentSpinner();
         flushCommandOutput();
         if (s.renderer) {
@@ -334,9 +416,9 @@ export default function activate(ctx) {
     function startAgentResponse() {
         s.renderer = new MarkdownRenderer(writer.columns);
         s.hadToolCalls = false;
-        // Preserve lastContentKind across responses so text→tool gaps work
         s.renderer.printTopBorder();
         drain();
+        ctx.call("tui:response-start");
     }
     /**
      * Insert an empty line when transitioning between different content kinds
@@ -345,12 +427,15 @@ export default function activate(ctx) {
      */
     let lastEmittedLineBlank = false;
     function contentGap(kind) {
-        if (s.lastContentKind && s.lastContentKind !== kind) {
-            if (s.renderer) {
-                s.renderer.flush();
-                drain();
+        if (s.lastContentKind) {
+            const gap = ctx.call("tui:render-content-gap", s.lastContentKind, kind);
+            if (gap) {
+                if (s.renderer) {
+                    s.renderer.flush();
+                    drain();
+                }
+                writer.write(gap);
             }
-            writer.write("\n");
         }
         s.lastContentKind = kind;
     }
@@ -366,6 +451,7 @@ export default function activate(ctx) {
         closeToolLine();
         stopCurrentSpinner();
         if (s.renderer) {
+            ctx.call("tui:response-end", s.hadToolCalls);
             s.renderer.flush();
             s.renderer.printBottomBorder();
             drain();
@@ -374,39 +460,6 @@ export default function activate(ctx) {
         }
     }
     function showUserQuery(query) {
-        const boxW = writer.columns;
-        const contentW = boxW - 4;
-        let lines = [];
-        for (const raw of query.split("\n")) {
-            if (raw.length <= contentW) {
-                lines.push(`${p.accent}${raw}${p.reset}`);
-            }
-            else {
-                let remaining = raw;
-                while (remaining.length > contentW) {
-                    let breakAt = remaining.lastIndexOf(" ", contentW);
-                    if (breakAt <= 0)
-                        breakAt = contentW;
-                    lines.push(`${p.accent}${remaining.slice(0, breakAt)}${p.reset}`);
-                    remaining = remaining.slice(breakAt).trimStart();
-                }
-                if (remaining)
-                    lines.push(`${p.accent}${remaining}${p.reset}`);
-            }
-        }
-        // Truncate very long queries to keep the response visible
-        const MAX_QUERY_LINES = 20;
-        if (lines.length > MAX_QUERY_LINES) {
-            const overflow = lines.length - MAX_QUERY_LINES;
-            lines = [
-                ...lines.slice(0, MAX_QUERY_LINES),
-                `${p.dim}… ${overflow} more lines${p.reset}`,
-            ];
-        }
-        // Mode-specific border color and title
-        const borderColor = p.accent;
-        const title = `${p.accent}${p.bold}❯${p.reset}`;
-        // Backend/model label on the right (backend/model, highlighted)
         const model = backendInfo?.model ?? llmClient?.model;
         const backend = backendInfo?.name;
         let modelLabel;
@@ -419,13 +472,7 @@ export default function activate(ctx) {
         else if (backend) {
             modelLabel = `${p.bold}${backend}${p.reset}`;
         }
-        const framed = renderBoxFrame(lines, {
-            width: boxW,
-            style: "rounded",
-            borderColor,
-            title,
-            titleRight: modelLabel,
-        });
+        const framed = ctx.call("tui:render-user-query", query, writer.columns, modelLabel);
         writer.write("\n");
         for (const line of framed) {
             writer.write(line + "\n");
@@ -653,13 +700,7 @@ export default function activate(ctx) {
             return;
         stopCurrentSpinner();
         const elapsed = s.toolStartTime ? formatElapsed(Date.now() - s.toolStartTime) : "";
-        const timer = elapsed ? ` ${p.dim}${elapsed}${p.reset}` : "";
-        const summary = resultDisplay?.summary ? ` ${p.dim}${resultDisplay.summary}${p.reset}` : "";
-        const mark = exitCode === null
-            ? `${p.muted}(timed out)${p.reset}`
-            : exitCode === 0
-                ? `${p.success}✓${p.reset}${summary}${timer}`
-                : `${p.error}✗ exit ${exitCode}${p.reset}${summary}${timer}`;
+        const mark = ctx.call("tui:render-tool-complete", exitCode, elapsed, resultDisplay?.summary);
         if (s.toolLineOpen && s.commandOutputLineCount === 0) {
             writer.write(` ${mark}\n`);
             s.toolLineOpen = false;
@@ -703,7 +744,10 @@ export default function activate(ctx) {
         s.spinner = createSpinner({ startTime: s.spinnerStartTime });
         s.spinnerInterval = setInterval(() => {
             if (s.spinner) {
-                const line = renderSpinnerLine(s.spinner, s.spinnerLabel, s.spinnerOpts);
+                const frame = SPINNER_FRAMES[s.spinner.frame % SPINNER_FRAMES.length];
+                s.spinner.frame++;
+                const elapsed = formatElapsed(Date.now() - s.spinner.startTime);
+                const line = ctx.call("tui:render-spinner", s.spinnerLabel, frame, elapsed, s.spinnerOpts.hint);
                 writer.write(`\r  ${line}\x1b[K`);
             }
         }, 80);
@@ -737,20 +781,8 @@ export default function activate(ctx) {
         closeToolLine();
         if (!s.renderer)
             startAgentResponse();
-        const mark = s.toolGroupAllOk
-            ? `${p.success}✓${p.reset}`
-            : `${p.error}✗${p.reset}`;
-        const summary = s.toolGroupSummaries.length > 0
-            ? ` ${p.dim}${s.toolGroupSummaries.join(", ")}${p.reset}`
-            : "";
-        const collapsed = s.toolGroupCount - s.toolGroupRendered;
-        if (collapsed > 0) {
-            s.renderer.writeLine(`  ${p.muted}└${p.reset} ${p.dim}+${collapsed} more${p.reset} ${mark}${summary}`);
-        }
-        else {
-            // All items visible — close the tree with └ mark + summary
-            s.renderer.writeLine(`  ${p.muted}└${p.reset} ${mark}${summary}`);
-        }
+        const groupLine = ctx.call("tui:render-tool-group-summary", s.toolGroupCount, s.toolGroupRendered, s.toolGroupAllOk, s.toolGroupSummaries);
+        s.renderer.writeLine(groupLine);
         drain();
         s.toolGroupKind = undefined;
         s.toolGroupCount = 0;
@@ -758,6 +790,9 @@ export default function activate(ctx) {
         s.toolGroupRendered = 0;
         s.toolGroupSummaries = [];
     }
+    function renderCommandLine(line) {
+        return ctx.call("tui:render-command-output", line, s.currentToolKind);
+    }
     function writeCommandOutput(chunk) {
         if (!s.renderer)
             return;
@@ -770,7 +805,7 @@ export default function activate(ctx) {
         s.commandOutputBuffer = lines.pop();
         for (const line of lines) {
             if (s.commandOutputLineCount < maxLines) {
-                s.renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
+                s.renderer.writeLine(renderCommandLine(line));
                 s.commandOutputLineCount++;
             }
             else {
@@ -790,7 +825,7 @@ export default function activate(ctx) {
             : getSettings().maxCommandOutputLines;
         if (s.commandOutputBuffer) {
             if (s.commandOutputLineCount < maxLines) {
-                s.renderer.writeLine(`${p.dim}  ${s.commandOutputBuffer}${p.reset}`);
+                s.renderer.writeLine(renderCommandLine(s.commandOutputBuffer));
                 s.commandOutputLineCount++;
             }
             else {
@@ -805,14 +840,14 @@ export default function activate(ctx) {
             const tail = s.commandOverflowLines.slice(-FAIL_OVERFLOW_MAX);
             const skipped = s.commandOverflowLines.length - tail.length;
             if (skipped > 0) {
-                s.renderer.writeLine(`${p.dim}  … ${skipped} lines hidden${p.reset}`);
+                s.renderer.writeLine(renderCommandLine(`… ${skipped} lines hidden`));
             }
             for (const line of tail) {
-                s.renderer.writeLine(`${p.dim}  ${line}${p.reset}`);
+                s.renderer.writeLine(renderCommandLine(line));
             }
         }
         else if (s.commandOutputOverflow > 0 && maxLines > 0) {
-            s.renderer.writeLine(`${p.dim}  … ${s.commandOutputOverflow} more lines${p.reset}`);
+            s.renderer.writeLine(renderCommandLine(`… ${s.commandOutputOverflow} more lines`));
         }
         s.commandOutputOverflow = 0;
         s.commandOverflowLines = [];
@@ -914,9 +949,9 @@ export default function activate(ctx) {
         }
     }
     function showError(message) {
-        writer.write(`\n${p.error}Error: ${message}${p.reset}\n`);
+        writer.write("\n" + ctx.call("tui:render-error", message) + "\n");
     }
     function showInfo(message) {
-        writer.write(`${p.muted}${message}${p.reset}\n`);
+        writer.write(ctx.call("tui:render-info", message) + "\n");
     }
 }

package/dist/settings.d.ts

@@ -1,4 +1,13 @@
 export declare const CONFIG_DIR: string;
+/** Per-model capability overrides. */
+export interface ModelCapabilityConfig {
+    /** Model identifier. */
+    id: string;
+    /** Whether the model supports reasoning/thinking tokens. */
+    reasoning?: boolean;
+    /** Context window size in tokens for this specific model. */
+    contextWindow?: number;
+}
 /** Provider profile — a named LLM configuration. */
 export interface ProviderConfig {
     /** API key (supports $ENV_VAR syntax for runtime expansion). */
@@ -7,8 +16,8 @@ export interface ProviderConfig {
     baseURL?: string;
     /** Default model to use. Falls back to first entry in models list. */
     defaultModel?: string;
-    /** Models available for cycling. */
-    models?: string[];
+    /** Models available for cycling. Plain strings or objects with capabilities. */
+    models?: (string | ModelCapabilityConfig)[];
     /** Context window size in tokens (e.g. 128000). Used for usage display. */
     contextWindow?: number;
 }
@@ -35,6 +44,14 @@ export interface Settings {
     shellTailLines?: number;
     /** Max lines for recall expand before requiring line ranges. */
     recallExpandMaxLines?: number;
+    /** Fraction of content budget allocated to shell context (0-1, default 0.35). */
+    shellContextRatio?: number;
+    /** Max history file size in bytes (default: 102400 = 100KB). */
+    historyMaxBytes?: number;
+    /** Number of prior history entries to load on startup (default: 50). */
+    historyStartupEntries?: number;
+    /** Max nuclear entries kept in-context before flushing to history file (default: 200). */
+    nuclearMaxEntries?: number;
     /** Max command output lines shown inline in TUI. */
     maxCommandOutputLines?: number;
     /** Max read tool output lines shown inline in TUI (0 = hide). */