agent-sh 0.12.21 → 0.12.23

package/README.md

@@ -19,7 +19,7 @@ So I built agent-sh. Under the hood it's a normal shell on top of node-pty — y
 ~ $ > draft a commit message     # agent reads your diff and shell history
 ```
 
-I still use Claude Code and pi for serious coding work — this doesn't replace them. But for the quick stuff in the terminal, I reach for agent-sh almost every day now. The built-in agent is lightweight and good enough for most of what I throw at it, and when it isn't, bridge extensions let you plug [Claude Code](examples/extensions/claude-code-bridge/) or [pi](examples/extensions/pi-bridge/) in as the backend.
+I still use a proper coding harness for serious work — this doesn't replace that. But for the quick stuff in the terminal, I reach for agent-sh almost every day now. The built-in agent is lightweight and good enough for most of what I throw at it, and when it isn't, you can swap in [pi](examples/extensions/pi-bridge/) as the backend via a bridge extension.
 
 ## Quick Start
 
@@ -95,7 +95,7 @@ Requires Node.js 18+. Currently supports **bash** and **zsh**; other shells (fis
 
 **Context that just works.** Every query includes your cwd, recent commands, and their output. Run a failing test, type `> fix this`, and agent-sh knows exactly what happened. Context management works like shell history — continuous, persistent across restarts, no sessions to manage. See [Context Management](docs/context-management.md).
 
-**Any LLM, any backend.** agent-sh works with any OpenAI-compatible API out of the box. Define multiple providers in settings and switch models at runtime with `/model <name>`. Or swap in a completely different agent — [Claude Code](examples/extensions/claude-code-bridge/) and [pi](examples/extensions/pi-bridge/) run as drop-in backend extensions.
+**Any LLM, any backend.** agent-sh works with any OpenAI-compatible API out of the box. Define multiple providers in settings and switch models at runtime with `/model <name>`. Or swap in a completely different agent — [pi](examples/extensions/pi-bridge/) runs as a drop-in backend extension.
 
 **Extensible by design.** The entire system is built on a typed event bus. Extensions can add custom input modes, content transforms (render LaTeX as images, Mermaid as diagrams), themes, slash commands, or replace the agent backend entirely. The built-in TUI renderer is itself just an extension.
 

package/dist/agent/agent-loop.d.ts

@@ -38,6 +38,7 @@ export declare class AgentLoop implements AgentBackend {
     private modes;
     private currentModeIndex;
     private boundListeners;
+    private boundPipeListeners;
     private ctorListeners;
     private ctorPipeListeners;
     private lastProjectSkillNames;

package/dist/agent/agent-loop.js

@@ -59,6 +59,7 @@ export class AgentLoop {
     modes;
     currentModeIndex = 0;
     boundListeners = [];
+    boundPipeListeners = [];
     ctorListeners = [];
     ctorPipeListeners = [];
     lastProjectSkillNames = new Set();
@@ -216,12 +217,24 @@ export class AgentLoop {
             this.bus.on(event, fn);
             this.boundListeners.push({ event, fn });
         };
+        const onPipe = (event, fn) => {
+            this.bus.onPipe(event, fn);
+            this.boundPipeListeners.push({ event, fn, async: false });
+        };
+        const onPipeAsync = (event, fn) => {
+            this.bus.onPipeAsync(event, fn);
+            this.boundPipeListeners.push({ event, fn, async: true });
+        };
         on("agent:submit", ({ query }) => {
             this.handleQuery(query).catch(() => { });
         });
         on("agent:cancel-request", (e) => {
             this.abortController?.abort(e.silent ? "silent" : undefined);
         });
+        on("agent:append-user-message", ({ text }) => {
+            this.conversation.appendUserMessage(text);
+            this.bus.emit("conversation:message-appended", { role: "user", content: text });
+        });
         on("config:switch-model", ({ model: target }) => {
             const atIdx = target.lastIndexOf("@");
             const modelId = atIdx > 0 ? target.slice(0, atIdx) : target;
@@ -257,7 +270,7 @@ export class AgentLoop {
             }
             this.bus.emit("config:changed", {});
         });
-        this.bus.onPipe("config:get-models", (payload) => {
+        onPipe("config:get-models", () => {
             const models = this.modes.map((m) => ({ model: m.model, provider: m.provider ?? "" }));
             const cur = this.modes[this.currentModeIndex];
             const active = cur ? { model: cur.model, provider: cur.provider ?? "" } : null;
@@ -281,7 +294,7 @@ export class AgentLoop {
             this.bus.emit("ui:info", { message: `Thinking: ${level}` });
             this.bus.emit("config:changed", {});
         });
-        this.bus.onPipe("config:get-thinking", () => {
+        onPipe("config:get-thinking", () => {
             const mode = this.currentMode;
             const supported = mode.reasoning !== false && mode.supportsReasoningEffort !== false;
             return { level: this.thinkingLevel, levels: AgentLoop.THINKING_LEVELS, supported };
@@ -303,20 +316,20 @@ export class AgentLoop {
                 this.bus.emit("ui:info", { message: "(nothing to compact)" });
             }
         });
-        this.bus.onPipe("context:get-stats", () => ({
+        onPipe("context:get-stats", () => ({
             activeTokens: this.conversation.estimateTokens(),
             totalTokens: this.conversation.estimatePromptTokens(),
             nuclearEntries: this.conversation.getNuclearEntryCount(),
             recallArchiveSize: this.conversation.getRecallArchiveSize(),
             budgetTokens: this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
         }));
-        this.bus.onPipe("context:snapshot", (payload) => {
+        onPipe("context:snapshot", (payload) => {
             payload.messages = this.conversation.getMessages();
             payload.contextWindow = this.currentMode.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
             payload.activeTokens = this.conversation.estimateTokens();
             return payload;
         });
-        this.bus.onPipeAsync("context:compact", async (payload) => {
+        onPipeAsync("context:compact", async (payload) => {
             const stats = await this.compactWithHooks(0, undefined, false, payload.strategy);
             if (stats)
                 payload.stats = { before: stats.before, after: stats.after, evictedCount: stats.evictedCount };
@@ -366,6 +379,13 @@ export class AgentLoop {
             this.bus.off(event, fn);
         }
         this.boundListeners = [];
+        for (const { event, fn, async } of this.boundPipeListeners) {
+            if (async)
+                this.bus.offPipeAsync(event, fn);
+            else
+                this.bus.offPipe(event, fn);
+        }
+        this.boundPipeListeners = [];
     }
     /** Register a tool (used by extensions via ctx.registerTool). */
     registerTool(tool) {

package/dist/agent/conversation-state.d.ts

@@ -38,7 +38,7 @@ export declare class ConversationState {
     private nextSeq;
     private lastApiTokenCount;
     private lastApiMessageCount;
-    private pendingNotes;
+    private pendingMessages;
     constructor(handlers?: HandlerFunctions, instanceId?: string);
     /** Get JSON.stringify of messages, cached until next mutation. */
     private getMessagesJson;
@@ -56,8 +56,9 @@ export declare class ConversationState {
     addToolResultInline(content: string): void;
     /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
     addSystemNote(text: string): void;
+    appendUserMessage(text: string): void;
     private hasOpenToolCalls;
-    private flushPendingNotes;
+    private flushPendingMessages;
     getMessages(): ChatCompletionMessageParam[];
     /** Drop tool messages with no matching preceding tool_call — strict
      *  providers (DeepSeek) 400, and compaction can leave such orphans. */

package/dist/agent/conversation-state.js

@@ -56,10 +56,10 @@ export class ConversationState {
     nextSeq = 1;
     lastApiTokenCount = null;
     lastApiMessageCount = 0;
-    // Notes queued when addSystemNote fires mid-tool-pair; flushed once
-    // the trailing tool_result lands. Splicing into the gap breaks
-    // reasoning_content pairing and is rejected by strict providers.
-    pendingNotes = [];
+    // Buffered when addSystemNote/appendUserMessage fires mid-tool-pair;
+    // flushed once the trailing tool_result lands. Splicing into the gap
+    // breaks reasoning_content pairing and is rejected by strict providers.
+    pendingMessages = [];
     constructor(handlers, instanceId = "0000") {
         this.handlers = handlers ?? null;
         this.instanceId = instanceId;
@@ -114,23 +114,30 @@ export class ConversationState {
         if (isError)
             this.toolErrors.add(toolCallId);
         this.invalidateMessagesCache();
-        this.flushPendingNotes();
+        this.flushPendingMessages();
     }
     /** Add tool results as a user message (for inline tool protocol). */
     addToolResultInline(content) {
         this.messages.push({ role: "user", content });
         this.invalidateMessagesCache();
-        this.flushPendingNotes();
+        this.flushPendingMessages();
     }
     /** Safe from any context: queues if mid-tool-pair, appends otherwise. */
     addSystemNote(text) {
         if (this.hasOpenToolCalls()) {
-            this.pendingNotes.push(text);
+            this.pendingMessages.push({ kind: "system", text });
             return;
         }
         this.messages.push({ role: "user", content: text });
         this.invalidateMessagesCache();
     }
+    appendUserMessage(text) {
+        if (this.hasOpenToolCalls()) {
+            this.pendingMessages.push({ kind: "user", text });
+            return;
+        }
+        this.addUserMessage(text);
+    }
     hasOpenToolCalls() {
         for (let i = this.messages.length - 1; i >= 0; i--) {
             const msg = this.messages[i];
@@ -151,15 +158,21 @@ export class ConversationState {
         }
         return false;
     }
-    flushPendingNotes() {
-        if (this.pendingNotes.length === 0)
+    flushPendingMessages() {
+        if (this.pendingMessages.length === 0)
             return;
         if (this.hasOpenToolCalls())
             return;
-        for (const text of this.pendingNotes) {
-            this.messages.push({ role: "user", content: text });
+        const pending = this.pendingMessages;
+        this.pendingMessages = [];
+        for (const m of pending) {
+            if (m.kind === "user") {
+                this.addUserMessage(m.text);
+            }
+            else {
+                this.messages.push({ role: "user", content: m.text });
+            }
         }
-        this.pendingNotes = [];
         this.invalidateMessagesCache();
     }
     getMessages() {
@@ -244,7 +257,7 @@ export class ConversationState {
         this.invalidateMessagesCache();
         this.lastApiTokenCount = null;
         this.lastApiMessageCount = 0;
-        this.flushPendingNotes();
+        this.flushPendingMessages();
     }
     pruneToolErrors() {
         if (this.toolErrors.size === 0)
@@ -544,7 +557,7 @@ export class ConversationState {
         this.nuclearEntries = [];
         this.nuclearBySeq.clear();
         this.recallArchive.clear();
-        this.pendingNotes = [];
+        this.pendingMessages = [];
         this.invalidateMessagesCache();
         this.lastApiTokenCount = null;
         this.lastApiMessageCount = 0;

package/dist/core.d.ts

@@ -37,11 +37,13 @@ export interface AgentShellCore {
     /** Unique id for this agent process; used for shell-marker tagging and lineage tracking. */
     instanceId: string;
     /** Activate the agent backend (call after extensions load). */
-    activateBackend(): void;
+    activateBackend(): Promise<void>;
     /** Convenience: emit agent:submit and await the response. */
     query(text: string): Promise<string>;
     /** Convenience: emit agent:cancel-request. */
     cancel(): void;
+    /** Convenience: emit agent:append-user-message. */
+    appendUserMessage(text: string): void;
     /** Build an ExtensionContext for loading extensions against this core. */
     extensionContext(opts: {
         quit: () => void;

package/dist/core.js

@@ -56,33 +56,30 @@ export function createCore(config) {
     handlers.define("query-context:build", () => "");
     const backends = new Map();
     let activeBackendName = null;
-    const activateByName = async (name, silent = false) => {
+    const activateByName = async (name) => {
         const backend = backends.get(name);
         if (!backend) {
             bus.emit("ui:error", { message: `Unknown backend: ${name}` });
-            return;
+            return false;
         }
-        // Deactivate current backend
         if (activeBackendName) {
             backends.get(activeBackendName)?.kill();
         }
-        // Activate new backend
         await backend.start?.();
         activeBackendName = name;
-        if (!silent) {
-            bus.emit("ui:info", { message: `Backend: ${name}` });
-        }
-        bus.emit("config:changed", {});
+        return true;
     };
     bus.on("agent:register-backend", (backend) => {
         backends.set(backend.name, backend);
     });
     bus.on("config:switch-backend", ({ name }) => {
-        activateByName(name).then(() => {
-            if (activeBackendName === name) {
-                settingsMod.updateSettings({ defaultBackend: name });
-                bus.emit("ui:info", { message: `Saved '${name}' as default backend.` });
-            }
+        activateByName(name).then((ok) => {
+            if (!ok)
+                return;
+            settingsMod.updateSettings({ defaultBackend: name });
+            // Single ui:info; config:changed (which triggers prompt redraw) follows it.
+            bus.emit("ui:info", { message: `Backend: ${name} (saved as default)` });
+            bus.emit("config:changed", {});
         });
     });
     bus.on("config:list-backends", () => {
@@ -105,18 +102,12 @@ export function createCore(config) {
         bus,
         handlers,
         instanceId,
-        activateBackend() {
-            // Silent — backend info is shown in the startup banner.
-            // Runtime switches (config:switch-backend) still emit ui:info.
+        async activateBackend() {
             if (backends.size === 0)
                 return;
             const preferred = settings.defaultBackend;
-            if (preferred && backends.has(preferred)) {
-                activateByName(preferred, true);
-            }
-            else {
-                activateByName(backends.keys().next().value, true);
-            }
+            const name = preferred && backends.has(preferred) ? preferred : backends.keys().next().value;
+            await activateByName(name);
         },
         async query(text) {
             return new Promise((resolve, reject) => {
@@ -155,6 +146,9 @@ export function createCore(config) {
         cancel() {
             bus.emit("agent:cancel-request", {});
         },
+        appendUserMessage(text) {
+            bus.emit("agent:append-user-message", { text });
+        },
         extensionContext(opts) {
             const ctx = {
                 bus,
@@ -210,9 +204,11 @@ export function createCore(config) {
                     cleanups.push(compositor.redirect("agent", surface));
                     cleanups.push(compositor.redirect("query", surface));
                     cleanups.push(compositor.redirect("status", surface));
-                    // Keep shell interactive
+                    // Suppress the host shell's mute lifecycle and post-turn
+                    // redraw nudge. on-processing-done is intentionally not advised
+                    // — its scope cleanup must always run.
                     cleanups.push(handlers.advise("shell:on-processing-start", (next) => active ? undefined : next()));
-                    cleanups.push(handlers.advise("shell:on-processing-done", (next) => active ? undefined : next()));
+                    cleanups.push(handlers.advise("shell:on-processing-redraw", (next) => active ? undefined : next()));
                     // Suppress chrome
                     if (opts.suppressBorders !== false) {
                         cleanups.push(handlers.advise("tui:response-border", (next, ...a) => active ? null : next(...a)));

package/dist/event-bus.d.ts

@@ -47,6 +47,9 @@ export interface ShellEvents {
     "agent:cancel-request": {
         silent?: boolean;
     };
+    "agent:append-user-message": {
+        text: string;
+    };
     "input-mode:register": import("./types.js").InputModeConfig;
     "agent:query": {
         query: string;
@@ -211,6 +214,7 @@ export interface ShellEvents {
     };
     "shell:redraw-prompt": {
         cwd: string;
+        kind: "fresh" | "redraw";
         handled: boolean;
     };
     "shell:exec-request": {
@@ -307,7 +311,9 @@ export interface ShellEvents {
     "config:add-modes": {
         modes: AgentMode[];
     };
-    "core:extensions-loaded": Record<string, never>;
+    "core:extensions-loaded": {
+        names: string[];
+    };
     "provider:register": {
         id: string;
         apiKey?: string;
@@ -445,6 +451,8 @@ export declare class EventBus {
      * If no listeners are registered, returns the original payload unchanged.
      */
     emitPipe<K extends keyof ShellEvents>(event: K, payload: ShellEvents[K]): ShellEvents[K];
+    /** Remove an async transform listener from a pipeline event. */
+    offPipeAsync<K extends keyof ShellEvents>(event: K, fn: AsyncPipeListener<ShellEvents[K]>): void;
     /** Register an async transform listener for a pipeline event. */
     onPipeAsync<K extends keyof ShellEvents>(event: K, fn: AsyncPipeListener<ShellEvents[K]>): void;
     /**

package/dist/event-bus.js

@@ -131,6 +131,15 @@ export class EventBus {
         }
         return result;
     }
+    /** Remove an async transform listener from a pipeline event. */
+    offPipeAsync(event, fn) {
+        const listeners = this.asyncPipeListeners.get(event);
+        if (!listeners)
+            return;
+        const idx = listeners.indexOf(fn);
+        if (idx !== -1)
+            listeners.splice(idx, 1);
+    }
     /** Register an async transform listener for a pipeline event. */
     onPipeAsync(event, fn) {
         let listeners = this.asyncPipeListeners.get(event);

package/dist/executor.js

@@ -1,5 +1,13 @@
 import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { stripAnsi } from "./utils/ansi.js";
+// Node reports a missing cwd as `spawn <binary> ENOENT` — disambiguate.
+function explainSpawnError(err, cwd) {
+    if (err.code === "ENOENT" && !existsSync(cwd)) {
+        return `cwd no longer exists: ${cwd} (${err.message})`;
+    }
+    return err.message;
+}
 let cachedBashPath;
 /** Resolve a usable bash binary, or null if none is on PATH.
  *  Unix: `/bin/bash` (canonical, present on every Linux/macOS install).
@@ -60,7 +68,10 @@ export function executeCommand(opts) {
     catch (err) {
         session.exitCode = -1;
         session.spawnFailed = true;
-        session.output = `Failed to spawn: ${err instanceof Error ? err.message : String(err)}`;
+        const msg = err instanceof Error
+            ? explainSpawnError(err, opts.cwd)
+            : String(err);
+        session.output = `Failed to spawn: ${msg}`;
         session.done = true;
         session.resolve?.();
         return { session, done };
@@ -103,7 +114,7 @@ export function executeCommand(opts) {
             const code = err.code;
             if (code === "ENOENT" || code === "EACCES")
                 session.spawnFailed = true;
-            session.output += `\nProcess error: ${err.message}`;
+            session.output += `\nProcess error: ${explainSpawnError(err, opts.cwd)}`;
             session.done = true;
             session.process = null;
             session.resolve?.();
@@ -149,7 +160,10 @@ export function executeArgv(opts) {
     catch (err) {
         session.exitCode = -1;
         session.spawnFailed = true;
-        session.output = `Failed to spawn ${opts.file}: ${err instanceof Error ? err.message : String(err)}`;
+        const msg = err instanceof Error
+            ? explainSpawnError(err, opts.cwd)
+            : String(err);
+        session.output = `Failed to spawn ${opts.file}: ${msg}`;
         session.done = true;
         session.resolve?.();
         return { session, done };
@@ -197,7 +211,7 @@ export function executeArgv(opts) {
             const code = err.code;
             if (code === "ENOENT" || code === "EACCES")
                 session.spawnFailed = true;
-            session.output += `\nProcess error: ${err.message}`;
+            session.output += `\nProcess error: ${explainSpawnError(err, opts.cwd)}`;
             session.done = true;
             session.process = null;
             session.resolve?.();

package/dist/extensions/agent-backend.js

@@ -2,6 +2,7 @@ import { AgentLoop } from "../agent/agent-loop.js";
 import { LlmClient } from "../utils/llm-client.js";
 import { resolveProvider, getProviderNames, getSettings } from "../settings.js";
 import { PACKAGE_VERSION } from "../utils/package-version.js";
+import { discoverSkills } from "../agent/skills.js";
 /** Read the user's persisted defaultModel for a provider, if any. */
 function persistedModelFor(providerName) {
     if (!providerName)
@@ -88,6 +89,8 @@ export default function agentBackend(ctx) {
     let modes = [];
     let initialModeIndex = 0;
     let resolved = false;
+    // Gates late-registration reconcile so its config:switch-model emit doesn't misroute under a non-ash backend.
+    let ashActive = false;
     bus.onPipe("config:get-initial-modes", () => ({ modes, initialModeIndex }));
     // AgentLoop must be constructed *before* user extensions activate,
     // because its ctor defines handlers (history:append, etc.) that
@@ -104,7 +107,9 @@ export default function agentBackend(ctx) {
         instanceId: ctx.instanceId,
         history: config.history,
     });
-    bus.on("core:extensions-loaded", () => {
+    let loadedExtensionNames = [];
+    bus.on("core:extensions-loaded", ({ names }) => {
+        loadedExtensionNames = names;
         const settings = getSettings();
         // If the user didn't pick a default, fall back to the first registered
         // provider (built-in load order biases to openrouter → openai).
@@ -149,9 +154,37 @@ export default function agentBackend(ctx) {
         resolved = true;
         bus.emit("agent:register-backend", {
             name: "ash",
-            kill: () => agentLoop.kill(),
+            kill: () => {
+                ashActive = false;
+                bus.emit("command:unregister", { name: "/compact" });
+                bus.emit("command:unregister", { name: "/context" });
+                agentLoop.kill();
+            },
             start: async () => {
                 agentLoop.wire();
+                ashActive = true;
+                bus.emit("command:register", {
+                    name: "/compact",
+                    description: "Compact conversation via the active compaction strategy",
+                    handler: () => bus.emit("agent:compact-request", {}),
+                });
+                bus.emit("command:register", {
+                    name: "/context",
+                    description: "Show context budget usage",
+                    handler: () => {
+                        const stats = bus.emitPipe("context:get-stats", {
+                            activeTokens: 0,
+                            totalTokens: 0,
+                            budgetTokens: 0,
+                        });
+                        const pct = stats.budgetTokens > 0
+                            ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
+                            : 0;
+                        bus.emit("ui:info", {
+                            message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
+                        });
+                    },
+                });
                 bus.emit("agent:info", {
                     name: "ash",
                     version: PACKAGE_VERSION,
@@ -215,7 +248,7 @@ export default function agentBackend(ctx) {
         // Late-registration reconcile: if this completes the user's persisted
         // default (openrouter's async fetch delivers the full catalog after
         // we've already fallen back to mode 0), quietly switch to it.
-        if (!resolved)
+        if (!resolved || !ashActive)
             return;
         const pendingProvider = getSettings().defaultProvider;
         if (pendingProvider !== p.id)
@@ -259,4 +292,17 @@ export default function agentBackend(ctx) {
         bus.emit("ui:info", { message: `Switched to ${name} (${switchModel})` });
         bus.emit("config:changed", {});
     });
+    bus.onPipe("banner:collect", (e) => {
+        const settings = getSettings();
+        if (settings.defaultBackend && settings.defaultBackend !== "ash")
+            return e;
+        if (loadedExtensionNames.length > 0) {
+            e.sections.push({ label: "Extensions", items: [...loadedExtensionNames] });
+        }
+        const skills = discoverSkills(ctx.call("cwd") ?? process.cwd());
+        if (skills.length > 0) {
+            e.sections.push({ label: "Skills", items: skills.map((s) => s.name) });
+        }
+        return e;
+    });
 }

package/dist/extensions/slash-commands.js

@@ -76,30 +76,6 @@ export default function activate(ctx) {
             }
         },
     });
-    register({
-        name: "/compact",
-        description: "Compact conversation via the active compaction strategy",
-        handler: () => {
-            bus.emit("agent:compact-request", {});
-        },
-    });
-    register({
-        name: "/context",
-        description: "Show context budget usage",
-        handler: () => {
-            const stats = bus.emitPipe("context:get-stats", {
-                activeTokens: 0,
-                totalTokens: 0,
-                budgetTokens: 0,
-            });
-            const pct = stats.budgetTokens > 0
-                ? Math.round((stats.activeTokens / stats.budgetTokens) * 100)
-                : 0;
-            bus.emit("ui:info", {
-                message: `Active context: ~${stats.activeTokens.toLocaleString()} tokens / ${stats.budgetTokens.toLocaleString()} budget (${pct}%)`,
-            });
-        },
-    });
     register({
         name: "/reload",
         description: "Reload user extensions from ~/.agent-sh/extensions/",

package/dist/index.js

@@ -7,7 +7,6 @@ import { palette as p } from "./utils/palette.js";
 import { loadBuiltinExtensions } from "./extensions/index.js";
 import { loadExtensions } from "./extension-loader.js";
 import { getSettings } from "./settings.js";
-import { discoverSkills } from "./agent/skills.js";
 import { runInit } from "./init.js";
 import { PACKAGE_VERSION } from "./utils/package-version.js";
 /**
@@ -270,11 +269,8 @@ 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());
+    // Names ride along so backend extensions can build banner sections.
+    core.bus.emit("core:extensions-loaded", { names: loadedExtensions });
     // ── Activate agent backend ────────────────────────────────────
     // Extensions had their chance to register via agent:register-backend.
     // If none did, the built-in AgentLoop gets wired to bus events.
@@ -288,6 +284,7 @@ async function main() {
             "  Alternatively, install a bridge extension (claude-code-bridge, pi-bridge).\n");
         process.exit(1);
     }
+    // No await: banner must out-race the shell's PS1 arriving via PTY.
     core.activateBackend();
     // ── Startup banner ───────────────────────────────────────────
     const settings = getSettings();
@@ -295,31 +292,11 @@ async function main() {
         const termW = process.stdout.columns || 80;
         const bannerW = Math.min(termW, 60);
         const productName = `${p.accent}${p.bold}agent-sh${p.reset}`;
-        const info = agentInfo;
-        const backendReady = !!info?.model;
-        const backendName = info?.name ?? "ash";
-        const model = info?.model;
-        const provider = info?.provider;
-        const modelValue = model
-            ? provider ? `${model} [${provider}]` : model
-            : null;
+        const backendName = settings.defaultBackend && backendNames.includes(settings.defaultBackend)
+            ? settings.defaultBackend
+            : backendNames[0];
         let sections = "";
-        sections += `\n\n  ${p.muted}Backend:${p.reset} ${p.dim}${backendName}${backendReady ? "" : " (not configured)"}${p.reset}`;
-        if (modelValue) {
-            sections += `\n  ${p.muted}Model:${p.reset} ${p.dim}${modelValue}${p.reset}`;
-        }
-        if (loadedExtensions.length > 0) {
-            sections += `\n\n  ${p.muted}Extensions:${p.reset}`;
-            for (const name of loadedExtensions) {
-                sections += `\n    ${p.dim}${name}${p.reset}`;
-            }
-        }
-        if (skills.length > 0) {
-            sections += `\n\n  ${p.muted}Skills:${p.reset}`;
-            for (const s of skills) {
-                sections += `\n    ${p.dim}${s.name}${p.reset}`;
-            }
-        }
+        sections += `\n\n  ${p.muted}Backend:${p.reset} ${p.dim}${backendName}${p.reset}`;
         const extSections = bus.emitPipe("banner:collect", { sections: [] }).sections;
         for (const sec of extSections) {
             sections += `\n\n  ${p.muted}${sec.label}:${p.reset}`;
@@ -327,9 +304,7 @@ async function main() {
                 sections += `\n    ${p.dim}${item}${p.reset}`;
             }
         }
-        const hint = backendReady
-            ? `${p.muted}Type ${p.warning}>${p.muted} to ask AI · ${p.warning}>/help${p.muted} for commands${p.reset}`
-            : `${p.muted}Set ${p.warning}OPENROUTER_API_KEY${p.muted} or ${p.warning}OPENAI_API_KEY${p.muted} and restart to enable AI${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" +
             "  " + productName +