agent-sh 0.8.0 → 0.9.0

package/dist/extensions/agent-backend.js

@@ -0,0 +1,167 @@
+import { AgentLoop } from "../agent/agent-loop.js";
+import { LlmClient } from "../utils/llm-client.js";
+import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
+export default function agentBackend(ctx) {
+    const { bus } = ctx;
+    // ── Resolve providers ──────────────────────────────────────
+    const config = ctx.call("config:get-shell-config") ?? {};
+    const settings = getSettings();
+    let activeProvider = null;
+    const providerRegistry = new Map();
+    for (const name of getProviderNames()) {
+        const p = resolveProvider(name);
+        if (p)
+            providerRegistry.set(name, p);
+    }
+    const providerName = config.provider ?? settings.defaultProvider;
+    if (providerName) {
+        activeProvider = providerRegistry.get(providerName) ?? null;
+    }
+    // ── Build modes ────────────────────────────────────────────
+    const buildModes = () => {
+        const allModes = [];
+        for (const [id, p] of providerRegistry) {
+            if (!p.apiKey)
+                continue;
+            for (const model of p.models) {
+                const mc = p.modelCapabilities?.get(model);
+                allModes.push({
+                    model,
+                    provider: id,
+                    providerConfig: { apiKey: p.apiKey, baseURL: p.baseURL },
+                    contextWindow: mc?.contextWindow ?? p.contextWindow,
+                    reasoning: mc?.reasoning,
+                    supportsReasoningEffort: p.supportsReasoningEffort,
+                });
+            }
+        }
+        return allModes;
+    };
+    const effectiveApiKey = config.apiKey ?? activeProvider?.apiKey;
+    const effectiveBaseURL = config.baseURL ?? activeProvider?.baseURL;
+    const effectiveModel = config.model ?? activeProvider?.defaultModel;
+    let modes = buildModes();
+    if (modes.length === 0 && effectiveApiKey && effectiveModel) {
+        modes = [{ model: effectiveModel }];
+    }
+    const initialModeIndex = Math.max(0, modes.findIndex((m) => m.model === effectiveModel && (!activeProvider || m.provider === activeProvider.id)));
+    // ── Create LLM client ─────────────────────────────────────
+    if (!effectiveApiKey)
+        return; // No LLM provider configured — skip
+    if (!effectiveModel) {
+        bus.emit("ui:error", { message: "No model specified. Use --model or configure a provider with defaultModel in ~/.agent-sh/settings.json" });
+        return;
+    }
+    const llmClient = new LlmClient({
+        apiKey: effectiveApiKey,
+        baseURL: effectiveBaseURL,
+        model: effectiveModel,
+    });
+    // Expose LLM client for other extensions (e.g. command-suggest)
+    ctx.define("llm:get-client", () => llmClient);
+    // ── Initial modes (queryable via pipe) ─────────────────────
+    bus.onPipe("config:get-initial-modes", () => ({
+        modes,
+        initialModeIndex,
+    }));
+    // ── Create agent loop ──────────────────────────────────────
+    const agentLoop = new AgentLoop({
+        bus,
+        contextManager: ctx.contextManager,
+        llmClient,
+        handlers: { define: ctx.define, advise: ctx.advise, call: ctx.call },
+        modes,
+        initialModeIndex,
+        compositor: ctx.compositor,
+    });
+    // Register as backend
+    bus.emit("agent:register-backend", {
+        name: "ash",
+        kill: () => agentLoop.kill(),
+        start: async () => {
+            agentLoop.wire();
+            bus.emit("agent:info", {
+                name: "ash",
+                version: "0.4",
+                model: llmClient.model,
+                provider: modes[initialModeIndex]?.provider,
+                contextWindow: modes[initialModeIndex]?.contextWindow,
+            });
+        },
+    });
+    // ── Runtime provider registration ──────────────────────────
+    bus.on("provider:register", (p) => {
+        const rawModels = p.models ?? (p.defaultModel ? [p.defaultModel] : []);
+        const modelIds = [];
+        const caps = new Map();
+        for (const m of rawModels) {
+            if (typeof m === "string") {
+                modelIds.push(m);
+            }
+            else {
+                modelIds.push(m.id);
+                caps.set(m.id, { reasoning: m.reasoning, contextWindow: m.contextWindow });
+            }
+        }
+        providerRegistry.set(p.id, {
+            id: p.id,
+            apiKey: p.apiKey,
+            baseURL: p.baseURL,
+            defaultModel: p.defaultModel,
+            models: modelIds,
+            supportsReasoningEffort: p.supportsReasoningEffort,
+            modelCapabilities: caps.size > 0 ? caps : undefined,
+        });
+        const addModes = modelIds.map((m) => {
+            const mc = caps.get(m);
+            return {
+                model: m,
+                provider: p.id,
+                providerConfig: { apiKey: p.apiKey ?? "", baseURL: p.baseURL },
+                contextWindow: mc?.contextWindow,
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: p.supportsReasoningEffort,
+            };
+        });
+        bus.emit("config:add-modes", { modes: addModes });
+    });
+    // ── Runtime provider switching ─────────────────────────────
+    bus.on("config:switch-provider", ({ provider: name }) => {
+        const p = providerRegistry.get(name);
+        if (!p) {
+            bus.emit("ui:error", { message: `Unknown provider: ${name}` });
+            return;
+        }
+        const newApiKey = p.apiKey;
+        if (!newApiKey) {
+            bus.emit("ui:error", { message: `Provider "${name}" has no API key configured` });
+            return;
+        }
+        const switchModel = p.defaultModel ?? p.models[0];
+        if (!switchModel) {
+            bus.emit("ui:error", { message: `Provider "${name}" has no models configured` });
+            return;
+        }
+        llmClient.reconfigure({
+            apiKey: newApiKey,
+            baseURL: p.baseURL,
+            model: switchModel,
+        });
+        const newModes = p.models.map((m) => {
+            const mc = p.modelCapabilities?.get(m);
+            return {
+                model: m,
+                provider: name,
+                providerConfig: { apiKey: newApiKey, baseURL: p.baseURL },
+                contextWindow: mc?.contextWindow ?? p.contextWindow,
+                reasoning: mc?.reasoning,
+                supportsReasoningEffort: p.supportsReasoningEffort,
+            };
+        });
+        bus.emit("config:set-modes", { modes: newModes });
+        activeProvider = p;
+        bus.emit("agent:info", { name: "ash", version: "0.4", model: switchModel, provider: name, contextWindow: p.contextWindow });
+        bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
+        bus.emit("config:changed", {});
+    });
+}

package/dist/extensions/command-suggest.d.ts

@@ -1,10 +1,10 @@
 /**
  * Command suggestion extension (fast-path LLM feature).
  *
- * After a shell command fails (non-zero exit), uses llmClient.complete()
+ * After a shell command fails (non-zero exit), uses LlmClient.complete()
  * to suggest a fix. Shows the suggestion below the prompt.
  *
- * Only active when llmClient is available (internal agent mode).
+ * Only active when an LLM client is available (registered by agent-backend).
  */
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, llmClient }: ExtensionContext): void;
+export default function activate({ bus, call }: ExtensionContext): void;

package/dist/extensions/command-suggest.js

@@ -1,6 +1,4 @@
-export default function activate({ bus, llmClient }) {
-    if (!llmClient)
-        return;
+export default function activate({ bus, call }) {
     let suggesting = false;
     bus.on("shell:command-done", ({ command, output, exitCode, cwd }) => {
         if (exitCode === null || exitCode === 0)
@@ -9,6 +7,9 @@ export default function activate({ bus, llmClient }) {
             return;
         if (suggesting)
             return; // don't stack suggestions
+        const llmClient = call("llm:get-client");
+        if (!llmClient)
+            return;
         suggesting = true;
         // Truncate output to avoid blowing up the prompt
         const truncated = output.length > 1000

package/dist/extensions/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Built-in extension manifest.
+ *
+ * These extensions ship with agent-sh and load before user extensions.
+ * They receive unscoped contexts (not reloadable) and can be individually
+ * disabled via the `disabledBuiltins` setting in ~/.agent-sh/settings.json.
+ */
+import type { ExtensionContext } from "../types.js";
+type ActivateFn = (ctx: ExtensionContext) => void;
+export declare const BUILTIN_EXTENSIONS: Array<{
+    name: string;
+    load: () => Promise<ActivateFn>;
+}>;
+/**
+ * Load built-in extensions sequentially, skipping any in the disabled list.
+ * Returns the names of extensions that were loaded.
+ */
+export declare function loadBuiltinExtensions(ctx: ExtensionContext, disabled?: string[]): Promise<string[]>;
+export {};

package/dist/extensions/index.js

@@ -0,0 +1,25 @@
+export const BUILTIN_EXTENSIONS = [
+    { name: "agent-backend", load: () => import("./agent-backend.js").then(m => m.default) },
+    { name: "tui-renderer", load: () => import("./tui-renderer.js").then(m => m.default) },
+    { name: "slash-commands", load: () => import("./slash-commands.js").then(m => m.default) },
+    { name: "file-autocomplete", load: () => import("./file-autocomplete.js").then(m => m.default) },
+    { name: "shell-recall", load: () => import("./shell-recall.js").then(m => m.default) },
+    { name: "command-suggest", load: () => import("./command-suggest.js").then(m => m.default) },
+    { name: "terminal-buffer", load: () => import("./terminal-buffer.js").then(m => m.default) },
+];
+/**
+ * Load built-in extensions sequentially, skipping any in the disabled list.
+ * Returns the names of extensions that were loaded.
+ */
+export async function loadBuiltinExtensions(ctx, disabled = []) {
+    const disabledSet = new Set(disabled);
+    const loaded = [];
+    for (const ext of BUILTIN_EXTENSIONS) {
+        if (disabledSet.has(ext.name))
+            continue;
+        const activate = await ext.load();
+        activate(ctx);
+        loaded.push(ext.name);
+    }
+    return loaded;
+}

package/dist/extensions/slash-commands.d.ts

@@ -1,2 +1,2 @@
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, contextManager }: ExtensionContext): void;
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/slash-commands.js

@@ -12,7 +12,9 @@
  */
 import { palette as p } from "../utils/palette.js";
 import { discoverSkills, loadSkillContent } from "../agent/skills.js";
-export default function activate({ bus, contextManager }) {
+import { reloadExtensions } from "../extension-loader.js";
+export default function activate(ctx) {
+    const { bus, contextManager } = ctx;
     const commands = new Map();
     const register = (cmd) => {
         const name = cmd.name.startsWith("/") ? cmd.name : `/${cmd.name}`;
@@ -103,6 +105,19 @@ export default function activate({ bus, contextManager }) {
             bus.emit("ui:info", { message: lines.join("\n") });
         },
     });
+    register({
+        name: "/reload",
+        description: "Reload user extensions from ~/.agent-sh/extensions/",
+        handler: async () => {
+            const names = await reloadExtensions(ctx);
+            if (names.length > 0) {
+                bus.emit("ui:info", { message: `Reloaded: ${names.join(", ")}` });
+            }
+            else {
+                bus.emit("ui:info", { message: "No extensions to reload." });
+            }
+        },
+    });
     // ── Extension registration ────────────────────────────────────
     bus.on("command:register", (cmd) => {
         register(cmd);

package/dist/extensions/terminal-buffer.d.ts

@@ -11,4 +11,4 @@
  * Requires: npm install @xterm/headless@5.5.0 @xterm/addon-serialize@0.13.0
  */
 import type { ExtensionContext } from "../types.js";
-export default function activate({ bus, terminalBuffer: tb, registerTool }: ExtensionContext): void;
+export default function activate(ctx: ExtensionContext): void;

package/dist/extensions/terminal-buffer.js

@@ -19,7 +19,8 @@ function interpretEscapes(str) {
 function settle(ms = 100) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export default function activate({ bus, terminalBuffer: tb, registerTool }) {
+export default function activate(ctx) {
+    const { bus, terminalBuffer: tb, registerTool, registerInstruction } = ctx;
     if (!tb)
         return; // @xterm/headless not installed
     registerTool({
@@ -30,7 +31,14 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
             "diagnosing errors on screen, or checking state before/after sending keystrokes with terminal_keys.",
         input_schema: {
             type: "object",
-            properties: {},
+            properties: {
+                include_scrollback: {
+                    type: "boolean",
+                    description: "If true, include scrollback buffer (content that scrolled off screen) " +
+                        "in addition to the visible viewport. Useful for capturing output from " +
+                        "long-running or streaming commands. Default: false.",
+                },
+            },
         },
         showOutput: true,
         getDisplayInfo: () => ({
@@ -38,8 +46,9 @@ export default function activate({ bus, terminalBuffer: tb, registerTool }) {
             icon: "⊞",
             locations: [],
         }),
-        async execute() {
-            const { text, altScreen, cursorX, cursorY } = tb.readScreen();
+        async execute(args) {
+            const includeScrollback = args.include_scrollback ?? false;
+            const { text, altScreen, cursorX, cursorY } = tb.readScreen({ includeScrollback });
             const info = [
                 altScreen ? "mode: alternate screen" : "mode: normal",
                 `cursor: row=${cursorY} col=${cursorX}`,

package/dist/extensions/tui-renderer.js

@@ -11,14 +11,13 @@
  * can subscribe to the same events.
  */
 import { highlight } from "cli-highlight";
-import { MarkdownRenderer, wrapLine } from "../utils/markdown.js";
+import { MarkdownRenderer, wrapLine, MAX_CONTENT_WIDTH } from "../utils/markdown.js";
 import { createFencedBlockTransform } from "../utils/stream-transform.js";
 import { palette as p } from "../utils/palette.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";
-import { StdoutWriter } from "../utils/output-writer.js";
 /** Encode a PNG buffer as a terminal inline image escape sequence. */
 function encodeImageForTerminal(data) {
     const b64 = data.toString("base64");
@@ -68,12 +67,12 @@ function createRenderState() {
     };
 }
 export default function activate(ctx) {
-    const { bus, llmClient, define } = ctx;
-    const writer = new StdoutWriter();
+    const { bus, define, compositor } = ctx;
     const s = createRenderState();
-    // Suppress all TUI output while stdout is held (overlay extensions)
-    bus.on("shell:stdout-hold", () => { writer.hold(); });
-    bus.on("shell:stdout-release", () => { writer.release(); });
+    /** Shorthand — get the current agent surface. */
+    function out() { return compositor.surface("agent"); }
+    /** Capped width for borders, tool lines, and content — keeps everything aligned. */
+    function cappedW() { return Math.min(MAX_CONTENT_WIDTH + 2, out().columns); }
     // 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);
@@ -81,6 +80,9 @@ export default function activate(ctx) {
     // ── Advisable rendering handlers ───────────────────────────────
     // Extensions advise these to customize how the TUI renders content.
     // Each handler receives data and returns rendered strings.
+    define("tui:response-border", (position, width) => {
+        return `${p.dim}${p.accent}${"─".repeat(width)}${p.reset}`;
+    });
     define("tui:response-start", () => { });
     define("tui:response-end", (_hadToolCalls) => { });
     define("tui:render-info", (message) => `${p.muted}${message}${p.reset}`);
@@ -210,7 +212,7 @@ export default function activate(ctx) {
                     break;
                 case "raw":
                     flushForRaw();
-                    writer.write(block.escape);
+                    out().write(block.escape);
                     break;
             }
         }
@@ -391,6 +393,8 @@ export default function activate(ctx) {
         if (e.key === "\x14")
             toggleThinkingDisplay(); // Ctrl+T
     });
+    // Interactive tool UI — stop spinner while tool has control
+    bus.on("tool:interactive-start", () => { stopCurrentSpinner(); });
     bus.on("ui:info", (e) => {
         stopCurrentSpinner();
         showInfo(e.message);
@@ -400,23 +404,25 @@ export default function activate(ctx) {
     });
     bus.on("ui:error", (e) => showError(e.message));
     bus.on("ui:suggestion", (e) => {
-        writer.write(`${p.dim}💡 ${e.text}${p.reset}\n`);
+        compositor.surface("status").writeLine(`${p.dim}💡 ${e.text}${p.reset}`);
     });
     // ── Rendering functions ─────────────────────────────────────
     function drain() {
         if (!s.renderer)
             return;
         for (const line of s.renderer.drainLines()) {
-            writer.write(line + "\n");
+            out().write(line + "\n");
             // Track whether we just emitted a blank line (for contentGap dedup).
             // Lines from the renderer are indented ("  "), so a blank line is "  " or empty.
             lastEmittedLineBlank = line.trimEnd() === "" || line.trimEnd().replace(/\x1b\[[^m]*m/g, "").trim() === "";
         }
     }
     function startAgentResponse() {
-        s.renderer = new MarkdownRenderer(writer.columns);
+        s.renderer = new MarkdownRenderer(cappedW());
         s.hadToolCalls = false;
-        s.renderer.printTopBorder();
+        const border = ctx.call("tui:response-border", "top", cappedW());
+        if (border)
+            s.renderer.writeLine(border);
         drain();
         ctx.call("tui:response-start");
     }
@@ -434,7 +440,7 @@ export default function activate(ctx) {
                     s.renderer.flush();
                     drain();
                 }
-                writer.write(gap);
+                out().write(gap);
             }
         }
         s.lastContentKind = kind;
@@ -453,14 +459,16 @@ export default function activate(ctx) {
         if (s.renderer) {
             ctx.call("tui:response-end", s.hadToolCalls);
             s.renderer.flush();
-            s.renderer.printBottomBorder();
+            const border = ctx.call("tui:response-border", "bottom", cappedW());
+            if (border)
+                s.renderer.writeLine(border);
             drain();
-            writer.write("\n");
+            out().write("\n");
             s.renderer = null;
         }
     }
     function showUserQuery(query) {
-        const model = backendInfo?.model ?? llmClient?.model;
+        const model = backendInfo?.model;
         const backend = backendInfo?.name;
         let modelLabel;
         if (backend && model) {
@@ -472,10 +480,13 @@ export default function activate(ctx) {
         else if (backend) {
             modelLabel = `${p.bold}${backend}${p.reset}`;
         }
-        const framed = ctx.call("tui:render-user-query", query, writer.columns, modelLabel);
-        writer.write("\n");
-        for (const line of framed) {
-            writer.write(line + "\n");
+        const querySurface = compositor.surface("query");
+        const framed = ctx.call("tui:render-user-query", query, querySurface.columns, modelLabel);
+        if (framed.length > 0) {
+            querySurface.write("\n");
+            for (const line of framed) {
+                querySurface.writeLine(line);
+            }
         }
     }
     function writeAgentText(text) {
@@ -486,7 +497,7 @@ export default function activate(ctx) {
             s.isThinking = false;
             if (s.showThinkingText && s.renderer) {
                 s.renderer.flush();
-                const w = Math.min(80, writer.columns);
+                const w = Math.min(80, out().columns);
                 s.renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
                 drain();
             }
@@ -525,7 +536,7 @@ export default function activate(ctx) {
         drain();
     });
     function writeCodeBlock(language, code) {
-        ctx.call("render:code-block", language, code, writer.columns);
+        ctx.call("render:code-block", language, code, cappedW());
     }
     function flushForRaw() {
         closeToolLine();
@@ -539,7 +550,7 @@ export default function activate(ctx) {
         flushForRaw();
         const escape = encodeImageForTerminal(data);
         if (escape) {
-            writer.write("  " + escape + "\n");
+            out().write("  " + escape + "\n");
         }
     });
     function writeInlineImage(data) {
@@ -567,7 +578,7 @@ export default function activate(ctx) {
     function renderDiffBody(diff, filePath, width) {
         if (diff.isIdentical)
             return [];
-        const boxW = Math.min(120, width);
+        const boxW = Math.min(120, width - 2); // -2 for writeLine indent
         const contentW = boxW - 4;
         const diffLines = renderDiff(diff, {
             width: contentW,
@@ -663,12 +674,12 @@ export default function activate(ctx) {
             locations: extra?.locations,
             rawInput: extra?.rawInput,
             displayDetail: extra?.displayDetail,
-        }, writer.columns);
+        }, cappedW());
         if (extra?.groupContinuation && lines.length > 0) {
             // Swap the colored kind icon for a muted tree connector,
             // and strip the tool name prefix — show detail only.
             const detail = extra.displayDetail || extractDetail(extra);
-            const maxW = Math.max(1, writer.columns - 6);
+            const maxW = Math.max(1, cappedW() - 6);
             const text = detail.length > maxW ? detail.slice(0, maxW - 1) + "…" : detail;
             lines[0] = detail
                 ? `${p.muted}├${p.reset} ${p.dim}${text}${p.reset}`
@@ -687,7 +698,7 @@ export default function activate(ctx) {
                 s.toolLineOpen = false;
             }
             else {
-                writer.write(`  ${batchPrefix}${lines[lines.length - 1]}`);
+                out().write(`  ${batchPrefix}${lines[lines.length - 1]}`);
                 s.toolLineOpen = true;
             }
         }
@@ -702,7 +713,7 @@ export default function activate(ctx) {
         const elapsed = s.toolStartTime ? formatElapsed(Date.now() - s.toolStartTime) : "";
         const mark = ctx.call("tui:render-tool-complete", exitCode, elapsed, resultDisplay?.summary);
         if (s.toolLineOpen && s.commandOutputLineCount === 0) {
-            writer.write(` ${mark}\n`);
+            out().write(` ${mark}\n`);
             s.toolLineOpen = false;
         }
         else {
@@ -719,7 +730,7 @@ export default function activate(ctx) {
     function renderResultBody(body) {
         if (!s.renderer)
             return;
-        const lines = ctx.call("render:result-body", body, writer.columns) ?? [];
+        const lines = ctx.call("render:result-body", body, cappedW()) ?? [];
         for (const line of lines) {
             s.renderer.writeLine(line);
         }
@@ -748,7 +759,7 @@ export default function activate(ctx) {
                 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`);
+                out().write(`\r  ${line}\x1b[K`);
             }
         }, 80);
     }
@@ -758,13 +769,13 @@ export default function activate(ctx) {
             s.spinnerInterval = null;
         }
         if (s.spinner) {
-            writer.write("\r\x1b[2K");
+            out().write("\r\x1b[2K");
             s.spinner = null;
         }
     }
     function closeToolLine() {
         if (s.toolLineOpen) {
-            writer.write("\n");
+            out().write("\n");
             s.toolLineOpen = false;
         }
     }
@@ -847,7 +858,15 @@ export default function activate(ctx) {
             }
         }
         else if (s.commandOutputOverflow > 0 && maxLines > 0) {
-            s.renderer.writeLine(renderCommandLine(`… ${s.commandOutputOverflow} more lines`));
+            // Show last line of output so the user sees the tail (often the most useful part)
+            const tail = s.commandOverflowLines[s.commandOverflowLines.length - 1];
+            const hidden = tail ? s.commandOutputOverflow - 1 : s.commandOutputOverflow;
+            if (hidden > 0) {
+                s.renderer.writeLine(renderCommandLine(`… ${hidden} more lines`));
+            }
+            if (tail) {
+                s.renderer.writeLine(renderCommandLine(tail));
+            }
         }
         s.commandOutputOverflow = 0;
         s.commandOverflowLines = [];
@@ -864,7 +883,7 @@ export default function activate(ctx) {
         if (diff.isIdentical)
             return;
         contentGap("diff");
-        const lines = ctx.call("render:result-body", { kind: "diff", diff, filePath }, writer.columns) ?? [];
+        const lines = ctx.call("render:result-body", { kind: "diff", diff, filePath }, cappedW()) ?? [];
         if (!s.renderer)
             startAgentResponse();
         for (const line of lines) {
@@ -883,7 +902,7 @@ export default function activate(ctx) {
         }
         if (!entry.expandedLines) {
             const { filePath, diff } = entry;
-            const boxW = Math.min(120, writer.columns);
+            const boxW = Math.min(cappedW() - 2, out().columns - 2); // -2 for writeLine indent
             const contentW = boxW - 4;
             const diffLines = renderDiff(diff, {
                 width: contentW,
@@ -900,16 +919,16 @@ export default function activate(ctx) {
                 footer: [`  ${p.dim}ctrl+o to collapse${p.reset}`],
             });
         }
-        writer.write("\n");
+        out().write("\n");
         for (const line of entry.expandedLines) {
-            writer.write(line + "\n");
+            out().write(line + "\n");
         }
     }
     function showFileDiffCached(entry) {
-        const lines = ctx.call("render:result-body", { kind: "diff", diff: entry.diff, filePath: entry.filePath }, writer.columns) ?? [];
-        writer.write("\n");
+        const lines = ctx.call("render:result-body", { kind: "diff", diff: entry.diff, filePath: entry.filePath }, cappedW()) ?? [];
+        out().write("\n");
         for (const line of lines) {
-            writer.write(line + "\n");
+            out().write(line + "\n");
         }
     }
     function toggleThinkingDisplay() {
@@ -941,7 +960,7 @@ export default function activate(ctx) {
         else {
             if (s.renderer) {
                 s.renderer.flush();
-                const w = Math.min(80, writer.columns);
+                const w = Math.min(80, out().columns);
                 s.renderer.writeLine(`${p.dim}${"─".repeat(w)}${p.reset}`);
                 drain();
             }
@@ -949,9 +968,10 @@ export default function activate(ctx) {
         }
     }
     function showError(message) {
-        writer.write("\n" + ctx.call("tui:render-error", message) + "\n");
+        const s = compositor.surface("status");
+        s.write("\n" + ctx.call("tui:render-error", message) + "\n");
     }
     function showInfo(message) {
-        writer.write(ctx.call("tui:render-info", message) + "\n");
+        compositor.surface("status").writeLine(ctx.call("tui:render-info", message));
     }
 }