agent-sh 0.12.21 → 0.12.22

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,

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;
@@ -307,7 +310,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 +450,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/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 +

package/examples/extensions/pi-bridge/README.md

@@ -1,14 +1,11 @@
 # pi-bridge
 
-Runs [pi](https://github.com/nickarora/pi)'s full coding agent as an agent-sh backend. Uses pi's own configuration, models, tools, and extensions — agent-sh just provides the terminal.
+Runs [pi](https://github.com/badlogic/pi-mono) (`@mariozechner/pi-coding-agent`) as an agent-sh backend. Pi brings its own configuration, models, tools, and extensions — agent-sh just provides the terminal.
 
 ## Install
 
 ```bash
-# Copy or symlink into your extensions directory
 cp -r examples/extensions/pi-bridge ~/.agent-sh/extensions/pi-bridge
-
-# Install dependencies
 cd ~/.agent-sh/extensions/pi-bridge
 npm install
 ```
@@ -26,26 +23,22 @@ Set as default backend in `~/.agent-sh/settings.json`:
 Or switch at runtime:
 
 ```
-? /backend pi
+> /backend pi
 ```
 
-## Requirements
-
-- pi must be configured separately (`~/.pi/settings.json`) with API keys and model preferences
-- agent-sh does not override pi's configuration — it uses whatever pi is set up with
+Pi reads its own settings from `~/.pi/agent/settings.json`. Configure API keys and model preferences there (or run `pi` directly to set up auth) — agent-sh does not override pi's configuration.
 
-## What this bridge is
+## What works under pi
 
-A pure protocol translator between pi's event stream and agent-sh's bus events. Pi's built-in tools (command execution, file ops, etc.) are used exactly as pi ships them. The bridge adds no tools of its own.
+These slash commands are routed to pi's SDK when pi is the active backend:
 
-## What this bridge intentionally does NOT bundle
+- `/model` — lists/switches pi's available models (`session.setModel`)
+- `/thinking` — sets pi's thinking level (`off/minimal/low/medium/high/xhigh`)
+- `/compact` — runs `session.compact()` on pi's session
+- `/context` — reports pi's token usage (`session.getContextUsage()`)
 
-Three PTY-access tools are left out on purpose:
+agent-sh's per-query context producers (e.g. `<shell_events>` from `shell-context`) are inlined into pi's prompt before each query, so pi sees the user's recent shell activity even though it doesn't subscribe to agent-sh's shell bus directly.
 
-- `terminal_read` — observe the user's live terminal screen
-- `terminal_keys` — send keystrokes to the user's PTY
-- `user_shell` — run commands in the user's live shell with lasting `cd`/`export`/`source` effects
-
-These are opt-in capabilities that belong in their own extensions. If you want any of them with pi, write a small companion extension that registers the tool as a pi `ToolDefinition` (TypeBox schema, wired to the relevant bus event: `shell:pty-write`, `shell:exec-request`, or `ctx.terminalBuffer.readScreen()`) and load it alongside pi-bridge.
+## What this bridge is
 
-Keeping this split means the bridge stays narrow — only translating events — and the capability surface is composable per-backend.
+A pure protocol translator between pi's event stream and agent-sh's bus events. Pi's built-in tools (command execution, file ops, etc.) are used exactly as pi ships them. The bridge adds no tools of its own.

package/examples/extensions/pi-bridge/index.ts

@@ -1,16 +1,6 @@
 /**
  * Pi bridge — runs pi's full coding agent in-process as agent-sh's backend.
- *
- * Uses pi's own AgentSession with its full configuration: model registry,
- * provider settings, extensions, session management, and tool system.
- * Agent-sh provides the shell frontend and TUI rendering.
- *
- * The bridge is a pure protocol translator between pi's event stream and
- * agent-sh's bus events. Pi brings its own tools for command execution,
- * file ops, etc. PTY-access tools (`terminal_read`, `terminal_keys`,
- * `user_shell`) are intentionally NOT bundled here — if you want pi to
- * observe or mutate the user's live terminal, load a companion extension
- * that registers those tools in pi's ToolDefinition format.
+ * Pure protocol translator between pi's event stream and agent-sh's bus.
  *
  * Setup:
  *   npm install @mariozechner/pi-agent-core @mariozechner/pi-ai @mariozechner/pi-coding-agent
@@ -26,25 +16,127 @@ import {
   SessionManager,
 } from "@mariozechner/pi-coding-agent";
 import type { ExtensionContext } from "agent-sh/types";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve as resolvePath } from "node:path";
+import { diffLines } from "diff";
+
+const TOOL_KINDS: Record<string, string> = {
+  bash: "execute",
+  read: "read",
+  ls: "read",
+  find: "read",
+  grep: "search",
+  edit: "execute",
+  write: "execute",
+};
+const kindForTool = (name: string): string => TOOL_KINDS[name] ?? "execute";
+
+type DiffLineRecord = { type: "context" | "added" | "removed"; oldNo: number | null; newNo: number | null; text: string };
+type DiffHunkRecord = { lines: DiffLineRecord[] };
+type DiffResultRecord = { hunks: DiffHunkRecord[]; added: number; removed: number; isIdentical: boolean; isNewFile: boolean };
+
+function buildDiffFromTexts(oldText: string, newText: string, isNewFile: boolean): DiffResultRecord | null {
+  if (oldText === newText) return null;
+  const changes = diffLines(oldText, newText);
+  const allLines: DiffLineRecord[] = [];
+  let oldNo = 0;
+  let newNo = 0;
+  let added = 0;
+  let removed = 0;
+  for (const change of changes) {
+    const lines = change.value.replace(/\n$/, "").split("\n");
+    for (const text of lines) {
+      if (change.added) {
+        newNo++;
+        allLines.push({ type: "added", oldNo: null, newNo, text });
+        added++;
+      } else if (change.removed) {
+        oldNo++;
+        allLines.push({ type: "removed", oldNo, newNo: null, text });
+        removed++;
+      } else {
+        oldNo++;
+        newNo++;
+        allLines.push({ type: "context", oldNo, newNo, text });
+      }
+    }
+  }
+  if (allLines.length === 0) return null;
+  return {
+    hunks: [{ lines: allLines }],
+    added,
+    removed,
+    isIdentical: false,
+    isNewFile,
+  };
+}
+
+// Pi's edit returns a custom diff string: prefix(+/-/space) + lineNum + " " + text, "..." between hunks.
+function parsePiDiff(raw: unknown): DiffResultRecord | null {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  const hunks: DiffHunkRecord[] = [];
+  let current: DiffLineRecord[] = [];
+  let added = 0;
+  let removed = 0;
+  let hasOriginal = false;
+  let delta = 0;
+
+  const flush = () => {
+    if (current.length > 0) hunks.push({ lines: current });
+    current = [];
+  };
+
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    const prefix = line[0];
+    const rest = line.slice(1);
+    if (prefix === " " && rest.trim() === "...") { flush(); continue; }
+    const m = rest.match(/^\s*(\d+)\s(.*)$/);
+    if (!m) continue;
+    const num = parseInt(m[1]!, 10);
+    const text = m[2]!;
+    if (prefix === "+") {
+      current.push({ type: "added", oldNo: null, newNo: num, text });
+      added++;
+      delta++;
+    } else if (prefix === "-") {
+      current.push({ type: "removed", oldNo: num, newNo: null, text });
+      removed++;
+      delta--;
+      hasOriginal = true;
+    } else if (prefix === " ") {
+      current.push({ type: "context", oldNo: num, newNo: num + delta, text });
+      hasOriginal = true;
+    }
+  }
+  flush();
+
+  if (hunks.length === 0) return null;
+  return { hunks, added, removed, isIdentical: added + removed === 0, isNewFile: !hasOriginal };
+}
 
-// ── Extension entry point ─────────────────────────────────────────
 export default function activate(ctx: ExtensionContext): void {
-  const { bus } = ctx;
+  const { bus, call } = ctx;
   const cwd = process.cwd();
 
-  // ── Boot pi session (async — register backend synchronously first) ──
   let session: any = null;
   let runtime: any = null;
+  let modelRegistry: any = null;
   let booting = true;
 
+  const PI_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+
+  // Pi's tool_execution_end omits `args` — cache from start so the end handler can use the path.
+  const pendingArgs = new Map<string, any>();
+  // Snapshot disk content before pi writes; diffed against args.content at end.
+  const pendingWriteSnapshot = new Map<string, { oldContent: string; isNewFile: boolean }>();
+
   const boot = async () => {
     try {
-      // Pi loads its own config: ~/.pi/agent/settings.json, models, extensions
       const services = await createAgentSessionServices({ cwd });
+      modelRegistry = services.modelRegistry;
       const sessionManager = SessionManager.inMemory(cwd);
 
-      // createRuntime factory — returns { session, services, ... } as expected
-      // by createAgentSessionRuntime
       const createRuntime = async (opts: any) => {
         const result = await createAgentSessionFromServices({
           services,
@@ -59,7 +151,6 @@ export default function activate(ctx: ExtensionContext): void {
       });
       session = runtime.session;
 
-      // Subscribe to pi events → agent-sh bus
       let fullResponseText = "";
 
       session.subscribe((event: AgentEvent) => {
@@ -81,13 +172,46 @@ export default function activate(ctx: ExtensionContext): void {
             break;
           }
 
-          case "tool_execution_start":
+          case "message_end": {
+            // Synthesize agent:tool-batch so tui-renderer groups parallel tool calls under one header.
+            const msg = (event as any).message;
+            if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+              const groupMap = new Map<string, Array<{ name: string }>>();
+              for (const block of msg.content) {
+                if (block?.type === "toolCall" && typeof block.name === "string") {
+                  const kind = kindForTool(block.name);
+                  if (!groupMap.has(kind)) groupMap.set(kind, []);
+                  groupMap.get(kind)!.push({ name: block.name });
+                }
+              }
+              if (groupMap.size > 0) {
+                const groups = Array.from(groupMap.entries()).map(([kind, tools]) => ({ kind, tools }));
+                bus.emit("agent:tool-batch", { groups });
+              }
+            }
+            break;
+          }
+
+          case "tool_execution_start": {
+            const ev = event as any;
+            if (ev.toolCallId) pendingArgs.set(ev.toolCallId, ev.args);
+            if (ev.toolName === "write" && ev.toolCallId && typeof ev.args?.path === "string") {
+              const abs = resolvePath(cwd, ev.args.path);
+              let oldContent = "";
+              let isNewFile = true;
+              if (existsSync(abs)) {
+                try { oldContent = readFileSync(abs, "utf8"); isNewFile = false; } catch {}
+              }
+              pendingWriteSnapshot.set(ev.toolCallId, { oldContent, isNewFile });
+            }
             bus.emit("agent:tool-started", {
-              title: (event as any).toolName,
-              toolCallId: (event as any).toolCallId,
-              kind: (event as any).toolName === "bash" ? "execute" : "read",
+              title: ev.toolName,
+              toolCallId: ev.toolCallId,
+              kind: kindForTool(ev.toolName),
+              rawInput: ev.args,
             });
             break;
+          }
 
           case "tool_execution_update": {
             const pr = (event as any).partialResult as
@@ -103,13 +227,41 @@ export default function activate(ctx: ExtensionContext): void {
             break;
           }
 
-          case "tool_execution_end":
+          case "tool_execution_end": {
+            const ev = event as any;
+            const args = ev.toolCallId ? pendingArgs.get(ev.toolCallId) : undefined;
+            if (ev.toolCallId) pendingArgs.delete(ev.toolCallId);
+            let resultDisplay: { body?: { kind: "diff"; diff: unknown; filePath: string } } | undefined;
+            if (ev.toolName === "edit" && typeof args?.path === "string") {
+              const rawDiff = ev.result?.details?.diff;
+              const parsed = parsePiDiff(rawDiff);
+              if (parsed) {
+                resultDisplay = {
+                  body: { kind: "diff", diff: parsed, filePath: args.path },
+                };
+              }
+            } else if (ev.toolName === "write" && typeof args?.path === "string" && !ev.isError) {
+              const snap = ev.toolCallId ? pendingWriteSnapshot.get(ev.toolCallId) : undefined;
+              if (ev.toolCallId) pendingWriteSnapshot.delete(ev.toolCallId);
+              if (snap) {
+                const newContent = typeof args.content === "string" ? args.content : "";
+                const built = buildDiffFromTexts(snap.oldContent, newContent, snap.isNewFile);
+                if (built) {
+                  resultDisplay = {
+                    body: { kind: "diff", diff: built, filePath: args.path },
+                  };
+                }
+              }
+            }
             bus.emit("agent:tool-completed", {
-              toolCallId: (event as any).toolCallId,
-              exitCode: (event as any).isError ? 1 : 0,
-              kind: (event as any).toolName === "bash" ? "execute" : "read",
+              toolCallId: ev.toolCallId,
+              exitCode: ev.isError ? 1 : 0,
+              kind: kindForTool(ev.toolName),
+              rawOutput: ev.result,
+              resultDisplay,
             });
             break;
+          }
 
           case "agent_end":
             bus.emitTransform("agent:response-done", {
@@ -120,7 +272,6 @@ export default function activate(ctx: ExtensionContext): void {
         }
       });
 
-      // Report model info
       const model = session.model;
       bus.emit("agent:info", {
         name: "pi",
@@ -137,8 +288,10 @@ export default function activate(ctx: ExtensionContext): void {
     }
   };
 
-  // ── Bus listeners (wired on start, unwired on kill) ────────────
-  const listeners: Array<{ event: string; fn: Function }> = [];
+  type ListenerEntry =
+    | { kind: "on"; event: string; fn: Function }
+    | { kind: "pipe"; event: string; fn: Function };
+  const listeners: ListenerEntry[] = [];
 
   const wireListeners = () => {
     const onSubmit = async ({ query }: any) => {
@@ -153,8 +306,12 @@ export default function activate(ctx: ExtensionContext): void {
       bus.emit("agent:query", { query });
       bus.emit("agent:processing-start", {});
 
+      // Inline producers raw — outputs already self-tag (<shell_events>...).
+      const ctxText = String(call("query-context:build") ?? "").trim();
+      const final = ctxText ? `${ctxText}\n\n${query}` : query;
+
       try {
-        await session.prompt(query);
+        await session.prompt(final);
       } catch (err) {
         bus.emit("agent:error", {
           message: err instanceof Error ? err.message : String(err),
@@ -169,33 +326,148 @@ export default function activate(ctx: ExtensionContext): void {
       session = runtime?.session;
     };
 
+    const onListModels = () => {
+      if (!session || !modelRegistry) return { models: [], active: null };
+      const all = modelRegistry.getAvailable() as Array<{ id: string; provider: string }>;
+      const cur = session.model;
+      return {
+        models: all.map((m) => ({ model: m.id, provider: m.provider })),
+        active: cur ? { model: cur.id, provider: cur.provider } : null,
+      };
+    };
+
+    // Slash command emits `model@provider` for disambiguation; pi looks up by (provider, id).
+    const onSwitchModel = async ({ model: target }: { model: string }) => {
+      if (!session || !modelRegistry) return;
+      const atIdx = target.lastIndexOf("@");
+      const modelId = atIdx > 0 ? target.slice(0, atIdx) : target;
+      const providerHint = atIdx > 0 ? target.slice(atIdx + 1) : undefined;
+
+      const candidates = (modelRegistry.getAvailable() as Array<{ id: string; provider: string }>)
+        .filter((m) => m.id === modelId && (!providerHint || m.provider === providerHint));
+
+      if (candidates.length === 0) {
+        bus.emit("ui:error", { message: `Unknown model: ${target}` });
+        return;
+      }
+      if (candidates.length > 1) {
+        const opts = candidates.map((m) => `${m.id}@${m.provider}`).join(", ");
+        bus.emit("ui:error", { message: `Ambiguous model "${modelId}". Use one of: ${opts}` });
+        return;
+      }
+      const picked = candidates[0]!;
+      const full = modelRegistry.find(picked.provider, picked.id);
+      if (!full) {
+        bus.emit("ui:error", { message: `Model not found: ${target}` });
+        return;
+      }
+      try {
+        await session.setModel(full);
+        bus.emit("agent:info", {
+          name: "pi",
+          version: "0.66",
+          model: `${picked.provider}/${picked.id}`,
+        });
+        bus.emit("ui:info", { message: `Model: ${picked.provider}: ${picked.id}` });
+        bus.emit("config:changed", {});
+      } catch (err) {
+        bus.emit("ui:error", {
+          message: `Failed to switch model: ${err instanceof Error ? err.message : String(err)}`,
+        });
+      }
+    };
+
+    const onGetThinking = () => {
+      const level = session?.thinkingLevel ?? "off";
+      return { level, levels: [...PI_THINKING_LEVELS], supported: true };
+    };
+
+    const onSetThinking = ({ level }: { level: string }) => {
+      if (!session) return;
+      if (!PI_THINKING_LEVELS.includes(level as any)) {
+        bus.emit("ui:error", {
+          message: `Unknown thinking level: ${level}. Use: ${PI_THINKING_LEVELS.join(", ")}`,
+        });
+        return;
+      }
+      session.setThinkingLevel(level);
+      bus.emit("ui:info", { message: `Thinking: ${level}` });
+      bus.emit("config:changed", {});
+    };
+
     bus.on("agent:submit", onSubmit);
     bus.on("agent:cancel-request", onCancel);
     bus.on("agent:reset-session", onReset);
+    bus.on("config:switch-model", onSwitchModel as any);
+    bus.on("config:set-thinking", onSetThinking as any);
+    bus.onPipe("config:get-models", onListModels as any);
+    bus.onPipe("config:get-thinking", onGetThinking as any);
     listeners.push(
-      { event: "agent:submit", fn: onSubmit },
-      { event: "agent:cancel-request", fn: onCancel },
-      { event: "agent:reset-session", fn: onReset },
+      { kind: "on", event: "agent:submit", fn: onSubmit },
+      { kind: "on", event: "agent:cancel-request", fn: onCancel },
+      { kind: "on", event: "agent:reset-session", fn: onReset },
+      { kind: "on", event: "config:switch-model", fn: onSwitchModel },
+      { kind: "on", event: "config:set-thinking", fn: onSetThinking },
+      { kind: "pipe", event: "config:get-models", fn: onListModels },
+      { kind: "pipe", event: "config:get-thinking", fn: onGetThinking },
     );
   };
 
   const unwireListeners = () => {
-    for (const { event, fn } of listeners) bus.off(event as any, fn as any);
+    for (const { kind, event, fn } of listeners) {
+      if (kind === "pipe") bus.offPipe(event as any, fn as any);
+      else bus.off(event as any, fn as any);
+    }
     listeners.length = 0;
   };
 
-  // ── Register as backend ───────────────────────────────────────
   bus.emit("agent:register-backend", {
     name: "pi",
     start: async () => {
       await boot();
       wireListeners();
+      bus.emit("command:register", {
+        name: "/compact",
+        description: "Compact pi's session context",
+        handler: async () => {
+          if (!session) return;
+          try {
+            await session.compact();
+            bus.emit("ui:info", { message: "(compacted)" });
+          } catch (err) {
+            bus.emit("ui:info", {
+              message: `(${err instanceof Error ? err.message : String(err)})`,
+            });
+          }
+        },
+      });
+      bus.emit("command:register", {
+        name: "/context",
+        description: "Show pi's context budget usage",
+        handler: () => {
+          if (!session) return;
+          const usage = session.getContextUsage() as { tokens: number; contextWindow: number } | undefined;
+          if (!usage) {
+            bus.emit("ui:info", { message: "Context: not available yet" });
+            return;
+          }
+          const pct = usage.contextWindow > 0
+            ? Math.round((usage.tokens / usage.contextWindow) * 100)
+            : 0;
+          bus.emit("ui:info", {
+            message: `Active context: ~${usage.tokens.toLocaleString()} tokens / ${usage.contextWindow.toLocaleString()} budget (${pct}%)`,
+          });
+        },
+      });
     },
     kill: () => {
+      bus.emit("command:unregister", { name: "/compact" });
+      bus.emit("command:unregister", { name: "/context" });
       unwireListeners();
       runtime?.dispose();
       session = null;
       runtime = null;
+      modelRegistry = null;
       booting = true;
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-sh",
-  "version": "0.12.21",
+  "version": "0.12.22",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",