agent-sh 0.12.21 → 0.12.23

package/examples/extensions/overlay-agent.ts

@@ -1,41 +1,49 @@
 /**
  * Overlay agent extension.
  *
- * Provides a hotkey (Ctrl+\) to summon the agent from anywhere — even
- * inside vim, htop, or ssh. Composites a floating response box on top
- * of the current terminal content.
+ * Press Ctrl+\ from anywhere — a shell prompt, vim, ssh, htop, a REPL — to
+ * summon the agent in a floating panel composited over the current terminal.
+ * The agent sees the live screen as `<terminal_buffer>` context (when a TUI
+ * is active) or `<shell_events>` (at a shell prompt), so screen-aware
+ * questions answer without a tool round-trip.
  *
- * Uses createRemoteSession() to route the full tui-renderer pipeline
- * (markdown, tool grouping, spinner, diffs) into the floating panel.
+ * Install (from an npm install of agent-sh):
+ *   mkdir -p ~/.agent-sh/extensions
+ *   cp "$(npm root -g)/agent-sh/examples/extensions/overlay-agent.ts" \
+ *      ~/.agent-sh/extensions/
  *
- * Install:
- *   cp examples/extensions/overlay-agent.ts ~/.agent-sh/extensions/
+ * Or load ad-hoc without copying:
+ *   agent-sh -e "$(npm root -g)/agent-sh/examples/extensions/overlay-agent.ts"
  *
- * Or load directly:
- *   agent-sh -e ./examples/extensions/overlay-agent.ts
- *
- * Requires: npm install @xterm/headless@5.5.0 @xterm/addon-serialize@0.13.0
+ * Optional companion extensions (copy the same way) — without them the
+ * overlay can read the screen but cannot interact with it:
+ *   - terminal-buffer.ts → terminal_read / terminal_keys tools
+ *   - user-shell.ts      → user_shell tool (run new shell commands)
  */
 import type { ExtensionContext, RemoteSession } from "agent-sh/types";
 import type { RenderSurface } from "agent-sh/utils/compositor";
 import { FloatingPanel } from "agent-sh/utils/floating-panel";
+import { formatScreenContext, type TerminalBuffer } from "agent-sh/utils/terminal-buffer";
 
 /** Adapt a FloatingPanel to the RenderSurface interface. */
 function createPanelSurface(panel: FloatingPanel): RenderSurface {
+  // Track the spinner row so a stop-clear ("\r\x1b[2K") removes it
+  // instead of leaving an orphan blank line in the panel.
+  let spinnerLine = false;
   return {
     write(text: string): void {
-      // Handle \r (carriage return) — overwrite the current line.
-      // The spinner uses "\r  <content>\x1b[K" to update in-place.
       if (text.startsWith("\r")) {
-        // Strip \r and any erase-line sequences
         const cleaned = text.replace(/^\r/, "").replace(/\x1b\[\d*K/g, "");
         if (cleaned.trim()) {
-          panel.updateLastLine(() => cleaned);
+          if (spinnerLine) panel.updateLastLine(() => cleaned);
+          else { panel.appendLine(cleaned); spinnerLine = true; }
+        } else if (spinnerLine) {
+          panel.popLastLine();
+          spinnerLine = false;
         }
         return;
       }
-
-      // Regular text — may contain newlines
+      if (spinnerLine) { panel.popLastLine(); spinnerLine = false; }
       panel.appendText(text);
     },
     writeLine(line: string): void {
@@ -44,12 +52,23 @@ function createPanelSurface(panel: FloatingPanel): RenderSurface {
     get columns(): number {
       return panel.computeGeometry().contentW;
     },
+    get rows(): number {
+      return panel.computeGeometry().contentH;
+    },
+    onResize(cb: (cols: number, rows: number) => void): () => void {
+      const handler = () => {
+        const g = panel.computeGeometry();
+        cb(g.contentW, g.contentH);
+      };
+      process.stdout.on("resize", handler);
+      return () => { process.stdout.off("resize", handler); };
+    },
   };
 }
 
 export default function activate(ctx: ExtensionContext): void {
   const { bus, registerInstruction, createRemoteSession } = ctx;
-  const terminalBuffer = ctx.call("terminal-buffer");
+  const terminalBuffer: TerminalBuffer | null = ctx.call("terminal-buffer");
 
   const panel = new FloatingPanel(bus, {
     trigger: "\x1c", // Ctrl+\
@@ -60,22 +79,21 @@ export default function activate(ctx: ExtensionContext): void {
   const panelSurface = createPanelSurface(panel);
   let session: RemoteSession | null = null;
 
-  // Tell the LLM it's running inside an overlay session. The matching
-  // system-prompt block (registered via registerInstruction below) describes
-  // how to behave in this mode.
   ctx.registerContextProducer("interactive-session", () =>
     session?.active ? "interactive-session: true" : null,
   );
 
+  // Inject the live screen for TUI / REPL programs. At a plain shell prompt
+  // `<shell_events>` already covers the visible scrollback — skip to dedupe.
+  ctx.registerContextProducer("terminal-screen", () => {
+    if (!session?.active || !terminalBuffer?.altScreen) return null;
+    return formatScreenContext(terminalBuffer.readScreen(), 80);
+  });
+
   registerInstruction("Interactive Overlay Sessions", [
-    "When the dynamic context includes `interactive-session: true`, the user has summoned you",
-    "via a hotkey overlay from inside their live terminal. They may be in the middle of using",
-    "a program (vim, ssh, a REPL, etc.) or at a shell prompt. In this mode:",
-    "- Start with terminal_read if you need to understand what's on screen.",
-    "- Prefer terminal_keys to interact with whatever is currently running.",
-    "- Use user_shell only for running new, standalone commands — not for interacting with",
-    "  what's already on screen.",
-    "- Keep responses concise — the user is in the middle of a workflow.",
+    "When dynamic context includes `interactive-session: true`, the user summoned you via a",
+    "hotkey overlay from their live terminal. They're mid-workflow (shell prompt, vim, ssh, a",
+    "REPL, etc.) — keep responses concise and prefer reading what's on screen over asking.",
   ].join("\n"));
 
   // ── Panel lifecycle ────────────────────────────────────────────
@@ -84,7 +102,6 @@ export default function activate(ctx: ExtensionContext): void {
     if (!session) {
       session = createRemoteSession({
         surface: panelSurface,
-        suppressQueryBox: true,
       });
     }
     panel.setActive();
@@ -92,18 +109,13 @@ export default function activate(ctx: ExtensionContext): void {
   });
 
   panel.handlers.advise("panel:show", (_next) => {
-    // Re-establish session if panel is shown while agent is still working
     if (panel.active && !session) {
-      session = createRemoteSession({
-        surface: panelSurface,
-        suppressQueryBox: true,
-      });
+      session = createRemoteSession({ surface: panelSurface });
     }
   });
 
-  // On dismiss: close session only if agent is not actively processing.
-  // If agent is still working (phase="active"), keep session alive so
-  // output buffers in the panel and agent can keep executing tools.
+  // Keep the session alive while the agent is still working, even after
+  // dismiss — so output keeps buffering and tools keep executing.
   panel.handlers.advise("panel:dismiss", (next) => {
     next();
     if (session && !panel.processing) {
@@ -113,10 +125,6 @@ export default function activate(ctx: ExtensionContext): void {
   });
 
   bus.on("agent:processing-done", () => {
-    if (!panel.active) return;
-    panel.setDone();
-    // If panel was hidden while processing (passthrough), setDone()
-    // triggers dismiss() which closes the session above.
-    // If panel is still visible, session stays for the follow-up prompt.
+    if (panel.active) panel.setDone();
   });
 }

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.23",
   "description": "A shell-first terminal where AI is one keystroke away",
   "type": "module",
   "main": "dist/core.js",