agent-sh 0.8.0 → 0.10.0

package/dist/extensions/tui-renderer.js

@@ -11,14 +11,14 @@
  * 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 { DEFAULT_CONTEXT_WINDOW } from "../agent/token-budget.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");
@@ -64,16 +64,18 @@ function createRenderState() {
         isThinking: false,
         showThinkingText: false,
         thinkingPending: false,
-        lastTruncatedDiff: null,
     };
 }
 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(); });
+    /** Track the shell's cwd so path shortening is relative to where the user actually is. */
+    let shellCwd = process.cwd();
+    bus.on("shell:cwd-change", (e) => { shellCwd = e.cwd; });
+    /** 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 +83,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 +215,7 @@ export default function activate(ctx) {
                     break;
                 case "raw":
                     flushForRaw();
-                    writer.write(block.escape);
+                    out().write(block.escape);
                     break;
             }
         }
@@ -224,7 +229,7 @@ export default function activate(ctx) {
         s.isThinking = false;
         if (pendingUsage && s.renderer) {
             const { prompt_tokens, completion_tokens } = pendingUsage;
-            const maxTokens = backendInfo?.contextWindow ?? 128_000;
+            const maxTokens = backendInfo?.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
             s.renderer.writeLine("");
             s.renderer.writeLine(ctx.call("tui:render-usage", prompt_tokens, completion_tokens, maxTokens));
             drain();
@@ -377,20 +382,42 @@ export default function activate(ctx) {
             s.renderer.flush();
             drain();
         }
+        // Diff rendering is handled in the async pipe below so it can yield
+        // to the event loop between hunks (keeping the spinner responsive).
+    });
+    // Async pipe: render diffs via the tui:render-diff handler (extensions can
+    // advise to customize).  Runs after the sync `on` handler above (which
+    // flushes state) and before shell.ts's pipe (which pauses stdout).
+    bus.onPipeAsync("permission:request", async (e) => {
+        if (!shouldRender())
+            return e;
         if (e.kind === "file-write" && e.metadata?.diff) {
             showCollapsedThinking();
-            showFileDiff(e.title, e.metadata.diff);
+            const lines = ctx.call("tui:render-diff", e.title, e.metadata.diff, cappedW());
+            if (lines.length > 0) {
+                if (!s.renderer)
+                    startAgentResponse();
+                contentGap("diff");
+                for (const line of lines)
+                    s.renderer.writeLine(line);
+                drain();
+            }
+            // The diff box IS the visual representation of the upcoming tool call.
+            // Mark lastContentKind as "tool" so the tool call line that follows
+            // doesn't inject an extra gap between the diff box and the checkmark.
+            s.lastContentKind = "tool";
         }
         // Don't endAgentResponse() here — permission requests that aren't
         // file-write diffs are handled inline (auto-approved or by extensions).
         // Closing the response prematurely causes double separator borders.
+        return e;
     });
     bus.on("input:keypress", (e) => {
-        if (e.key === "\x0f")
-            expandLastDiff(); // Ctrl+O
         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 +427,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 +463,7 @@ export default function activate(ctx) {
                     s.renderer.flush();
                     drain();
                 }
-                writer.write(gap);
+                out().write(gap);
             }
         }
         s.lastContentKind = kind;
@@ -453,14 +482,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 +503,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 +520,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();
             }
@@ -507,9 +541,23 @@ export default function activate(ctx) {
         }
         let highlighted;
         try {
-            highlighted = language
-                ? highlight(code, { language })
-                : highlight(code); // auto-detect
+            // highlight.js warns to console.error for unsupported languages (elisp, org, etc).
+            // Suppress so it doesn't leak into the terminal.
+            const origError = console.error;
+            console.error = (...args) => {
+                const msg = args.join(" ");
+                if (msg.includes("Could not find the language"))
+                    return;
+                origError.apply(console, args);
+            };
+            try {
+                highlighted = language
+                    ? highlight(code, { language })
+                    : highlight(code); // auto-detect
+            }
+            finally {
+                console.error = origError;
+            }
         }
         catch {
             highlighted = code;
@@ -525,7 +573,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 +587,7 @@ export default function activate(ctx) {
         flushForRaw();
         const escape = encodeImageForTerminal(data);
         if (escape) {
-            writer.write("  " + escape + "\n");
+            out().write("  " + escape + "\n");
         }
     });
     function writeInlineImage(data) {
@@ -563,11 +611,22 @@ export default function activate(ctx) {
         }
         return [];
     });
+    /**
+     * Default renderer for standalone diffs (e.g. permission prompts).
+     * Extensions can advise this to customize diff rendering:
+     *
+     *   ctx.advise("tui:render-diff", (next, filePath, diff, width) => {
+     *     return myCustomDiffBox(filePath, diff, width);
+     *   });
+     */
+    define("tui:render-diff", (filePath, diff, width) => {
+        return renderDiffBody(diff, filePath, width);
+    });
     /** Render a diff as framed box lines (pure — no TUI state side effects). */
     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,
@@ -575,18 +634,8 @@ export default function activate(ctx) {
             maxLines: getSettings().diffMaxLines,
             trueColor: true,
         });
-        const lastLine = diffLines[diffLines.length - 1] ?? "";
-        const isTruncated = lastLine.includes("… ");
-        if (isTruncated) {
-            s.lastTruncatedDiff = { filePath, diff, expanded: false };
-        }
-        else {
-            s.lastTruncatedDiff = null;
-        }
         const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-        const footer = isTruncated
-            ? [`  ${p.dim}ctrl+o to expand${p.reset}`]
-            : undefined;
+        const footer = undefined;
         return renderBoxFrame(body, {
             width: boxW,
             style: "rounded",
@@ -614,11 +663,10 @@ export default function activate(ctx) {
     function extractDetail(extra) {
         if (extra.locations && extra.locations.length > 0) {
             const loc = extra.locations[0];
-            const cwd = process.cwd();
             const home = process.env.HOME;
             let fp = loc.path;
-            if (fp.startsWith(cwd + "/"))
-                fp = fp.slice(cwd.length + 1);
+            if (fp.startsWith(shellCwd + "/"))
+                fp = fp.slice(shellCwd.length + 1);
             else if (home && fp.startsWith(home + "/"))
                 fp = "~/" + fp.slice(home.length + 1);
             return loc.line ? `${fp}:${loc.line}` : fp;
@@ -631,11 +679,10 @@ export default function activate(ctx) {
         if (typeof raw.pattern === "string")
             return raw.pattern;
         if (typeof raw.path === "string") {
-            const cwd = process.cwd();
             const home = process.env.HOME;
             let fp = raw.path;
-            if (fp.startsWith(cwd + "/"))
-                fp = fp.slice(cwd.length + 1);
+            if (fp.startsWith(shellCwd + "/"))
+                fp = fp.slice(shellCwd.length + 1);
             else if (home && fp.startsWith(home + "/"))
                 fp = "~/" + fp.slice(home.length + 1);
             return fp;
@@ -663,12 +710,12 @@ export default function activate(ctx) {
             locations: extra?.locations,
             rawInput: extra?.rawInput,
             displayDetail: extra?.displayDetail,
-        }, writer.columns);
+        }, cappedW(), shellCwd);
         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 +734,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 +749,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 +766,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 +795,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 +805,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 +894,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 = [];
@@ -860,58 +915,6 @@ export default function activate(ctx) {
             : `${p.success}+${diff.added}${p.reset} ${p.error}-${diff.removed}${p.reset}`;
         return `${p.dim}${filePath}${p.reset}  ${stats}`;
     }
-    function showFileDiff(filePath, diff) {
-        if (diff.isIdentical)
-            return;
-        contentGap("diff");
-        const lines = ctx.call("render:result-body", { kind: "diff", diff, filePath }, writer.columns) ?? [];
-        if (!s.renderer)
-            startAgentResponse();
-        for (const line of lines) {
-            s.renderer.writeLine(line);
-        }
-        drain();
-    }
-    function expandLastDiff() {
-        if (!s.lastTruncatedDiff)
-            return;
-        const entry = s.lastTruncatedDiff;
-        entry.expanded = !entry.expanded;
-        if (!entry.expanded) {
-            showFileDiffCached(entry);
-            return;
-        }
-        if (!entry.expandedLines) {
-            const { filePath, diff } = entry;
-            const boxW = Math.min(120, writer.columns);
-            const contentW = boxW - 4;
-            const diffLines = renderDiff(diff, {
-                width: contentW,
-                filePath,
-                maxLines: 500,
-                trueColor: true,
-            });
-            const body = diffLines.length > 1 ? ["", ...diffLines.slice(1), ""] : diffLines;
-            entry.expandedLines = renderBoxFrame(body, {
-                width: boxW,
-                style: "rounded",
-                borderColor: p.dim,
-                title: diffTitle(filePath, diff),
-                footer: [`  ${p.dim}ctrl+o to collapse${p.reset}`],
-            });
-        }
-        writer.write("\n");
-        for (const line of entry.expandedLines) {
-            writer.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");
-        for (const line of lines) {
-            writer.write(line + "\n");
-        }
-    }
     function toggleThinkingDisplay() {
         s.showThinkingText = !s.showThinkingText;
         if (s.spinner) {
@@ -941,7 +944,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 +952,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));
     }
 }

package/dist/index.js

@@ -1,16 +1,10 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import * as path from "node:path";
-import { Shell } from "./shell.js";
+import { Shell } from "./shell/shell.js";
 import { createCore } from "./core.js";
 import { palette as p } from "./utils/palette.js";
-import tuiRenderer from "./extensions/tui-renderer.js";
-import slashCommands from "./extensions/slash-commands.js";
-import fileAutocomplete from "./extensions/file-autocomplete.js";
-import shellRecall from "./extensions/shell-recall.js";
-import commandSuggest from "./extensions/command-suggest.js";
-import terminalBuffer from "./extensions/terminal-buffer.js";
-import overlayAgent from "./extensions/overlay-agent.js";
+import { loadBuiltinExtensions } from "./extensions/index.js";
 import { loadExtensions } from "./extension-loader.js";
 import { getSettings } from "./settings.js";
 import { discoverSkills } from "./agent/skills.js";
@@ -21,6 +15,13 @@ import { discoverSkills } from "./agent/skills.js";
  */
 async function captureShellEnvAsync(shell) {
     return new Promise((resolve) => {
+        let settled = false;
+        const done = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
         try {
             const shellName = path.basename(shell);
             const isZsh = shellName.includes("zsh");
@@ -36,8 +37,9 @@ async function captureShellEnvAsync(shell) {
                 output += data.toString("utf-8");
             });
             child.on("close", (code) => {
+                clearTimeout(timer);
                 if (code !== 0 || !output) {
-                    resolve({});
+                    done({});
                     return;
                 }
                 const env = {};
@@ -46,18 +48,19 @@ async function captureShellEnvAsync(shell) {
                     if (eq > 0)
                         env[entry.slice(0, eq)] = entry.slice(eq + 1);
                 }
-                resolve(env);
+                done(env);
             });
             child.on("error", () => {
-                resolve({});
+                clearTimeout(timer);
+                done({});
             });
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 child.kill("SIGTERM");
-                resolve({});
+                done({});
             }, 5000);
         }
         catch {
-            resolve({});
+            done({});
         }
     });
 }
@@ -160,6 +163,13 @@ async function main() {
         const shellEnv = await captureShellEnvAsync(shellPath);
         if (Object.keys(shellEnv).length > 0) {
             Object.assign(baseEnv, mergeShellEnv(baseEnv, shellEnv));
+            // Expose captured env vars to process.env so extensions can read them.
+            // Only add vars not already present to avoid clobbering runtime state.
+            for (const [k, v] of Object.entries(baseEnv)) {
+                if (process.env[k] === undefined) {
+                    process.env[k] = v;
+                }
+            }
             if (process.env.DEBUG) {
                 console.error('[agent-sh] Shell environment captured');
             }
@@ -195,6 +205,7 @@ async function main() {
     await new Promise(resolve => setTimeout(resolve, 100));
     const shell = new Shell({
         bus,
+        handlers: core.handlers,
         cols,
         rows,
         shell: config.shell || process.env.SHELL || "/bin/bash",
@@ -203,9 +214,6 @@ async function main() {
             if (agentInfo) {
                 return { info: `${p.dim}${agentInfo.name}${agentInfo.model ? ` (${agentInfo.model})` : ""}${p.reset}` };
             }
-            if (core.llmClient) {
-                return { info: `${p.dim}agent-sh (${core.llmClient.model})${p.reset}` };
-            }
             return { info: "" };
         },
     });
@@ -229,13 +237,8 @@ async function main() {
         console.error('[agent-sh] Setting up extensions...');
     }
     const extCtx = core.extensionContext({ quit: cleanup });
-    tuiRenderer(extCtx);
-    slashCommands(extCtx);
-    fileAutocomplete(extCtx);
-    shellRecall(extCtx);
-    commandSuggest(extCtx);
-    terminalBuffer(extCtx);
-    overlayAgent(extCtx);
+    // Load built-in extensions (individually disableable via settings.disabledBuiltins)
+    await loadBuiltinExtensions(extCtx, getSettings().disabledBuiltins);
     // Load user extensions (may register alternative agent backends)
     if (process.env.DEBUG) {
         console.error('[agent-sh] Loading extensions...');
@@ -251,6 +254,9 @@ async function main() {
     if (process.env.DEBUG) {
         console.error('[agent-sh] Extensions loaded');
     }
+    // Tell deferred-init listeners (agent-backend) that the provider
+    // registry is now complete.
+    core.bus.emit("core:extensions-loaded", {});
     // ── Discover skills ───────────────────────────────────────────
     const skills = discoverSkills(process.cwd());
     // ── Activate agent backend ────────────────────────────────────
@@ -264,8 +270,8 @@ async function main() {
         const bannerW = Math.min(termW, 60);
         const productName = `${p.accent}${p.bold}agent-sh${p.reset}`;
         const info = agentInfo;
-        const backendName = info?.name ?? "agent-sh";
-        const model = info?.model ?? core.llmClient?.model;
+        const backendName = info?.name ?? "ash";
+        const model = info?.model;
         const provider = info?.provider;
         const modelValue = model
             ? provider ? `${model} [${provider}]` : model
@@ -287,6 +293,13 @@ async function main() {
                 sections += `\n    ${p.dim}${s.name}${p.reset}`;
             }
         }
+        const extSections = bus.emitPipe("banner:collect", { sections: [] }).sections;
+        for (const sec of extSections) {
+            sections += `\n\n  ${p.muted}${sec.label}:${p.reset}`;
+            for (const item of sec.items) {
+                sections += `\n    ${p.dim}${item}${p.reset}`;
+            }
+        }
         const hint = `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`;
         const borderLine = `${p.muted}${"─".repeat(bannerW)}${p.reset}`;
         process.stdout.write("\n" + borderLine + "\n" +