agent-sh 0.12.24 → 0.12.26

package/dist/shell/tui-input-view.js

@@ -11,130 +11,171 @@ export class TuiInputView {
     cursorTermCol = 1;
     autocompleteLines = 0;
     surface;
+    frameBuf = null;
     constructor(surface) {
         this.surface = surface ?? new StdoutSurface();
     }
+    // Frame buffering: coalesces all emit() calls until endFrame() into one
+    // surface.write, bracketed by cursor hide/show so intermediate redraw
+    // states never flicker through.
+    beginFrame() {
+        if (this.frameBuf === null)
+            this.frameBuf = "\x1b[?25l";
+    }
+    endFrame() {
+        if (this.frameBuf === null)
+            return;
+        const out = this.frameBuf + "\x1b[?25h";
+        this.frameBuf = null;
+        this.surface.write(out);
+    }
+    emit(s) {
+        if (this.frameBuf !== null)
+            this.frameBuf += s;
+        else
+            this.surface.write(s);
+    }
+    autoFrame(fn) {
+        const owned = this.frameBuf === null;
+        if (owned)
+            this.beginFrame();
+        try {
+            return fn();
+        }
+        finally {
+            if (owned)
+                this.endFrame();
+        }
+    }
     resetCursor() {
         this.cursorRowsBelow = 0;
         this.cursorTermCol = 1;
     }
     enableModeKeys() {
         // Kitty progressive enhancement + bracket paste (Shift+Enter → \x1b[13;2u).
-        this.surface.write("\x1b[>1u\x1b[?2004h");
+        this.emit("\x1b[>1u\x1b[?2004h");
     }
     disableModeKeys() {
-        this.surface.write("\x1b[<u\x1b[?2004l");
+        this.emit("\x1b[<u\x1b[?2004l");
     }
     clearPromptArea() {
-        if (this.cursorRowsBelow > 0) {
-            this.surface.write(`\x1b[${this.cursorRowsBelow}A`);
-        }
-        this.surface.write("\r\x1b[J");
-        this.cursorRowsBelow = 0;
+        this.autoFrame(() => {
+            if (this.cursorRowsBelow > 0) {
+                this.emit(`\x1b[${this.cursorRowsBelow}A`);
+            }
+            this.emit("\r\x1b[J");
+            this.cursorRowsBelow = 0;
+        });
     }
     drawPrompt(vm) {
-        const termW = this.surface.columns;
-        if (this.cursorRowsBelow > 0) {
-            this.surface.write(`\x1b[${this.cursorRowsBelow}A`);
-        }
-        this.surface.write("\r\x1b[J");
-        const infoPrefix = vm.agentInfo.info
-            ? `${vm.agentInfo.info} ${p.success}${vm.indicator}${p.reset} `
-            : `${p.success}${vm.indicator}${p.reset} `;
-        const promptPrefix = infoPrefix + p.warning + p.bold + vm.promptIcon + " " + p.reset;
-        const promptVisLen = visibleLen(infoPrefix) + visibleLen(vm.promptIcon) + 1;
-        const display = vm.showBuffer ? vm.displayText : "";
-        const dCursor = vm.showBuffer ? vm.displayCursor : 0;
-        if (!vm.showBuffer) {
-            this.surface.write(promptPrefix);
-            const N = promptVisLen;
-            this.cursorRowsBelow = N > 0 ? Math.ceil(N / termW) - 1 : 0;
-            this.cursorTermCol = N === 0 ? 1 : (N % termW === 0 ? termW : (N % termW) + 1);
-        }
-        else if (!display.includes("\n")) {
-            // DECSC/DECRC bracket the after-cursor text so the cursor lands mid-line.
-            const before = display.slice(0, dCursor);
-            const after = display.slice(dCursor);
-            this.surface.write(promptPrefix + p.accent + before + p.reset +
-                "\x1b7" +
-                p.accent + after + p.reset +
-                "\x1b8");
-            const cursorVisCol = promptVisLen + visibleLen(before);
-            this.cursorRowsBelow = cursorVisCol > 0 ? Math.ceil(cursorVisCol / termW) - 1 : 0;
-            this.cursorTermCol = cursorVisCol === 0 ? 1 : (cursorVisCol % termW === 0 ? termW : (cursorVisCol % termW) + 1);
-        }
-        else {
-            const lines = display.split("\n");
-            const indent = " ".repeat(promptVisLen);
-            let charsRemaining = dCursor;
-            let cursorLine = 0;
-            for (let li = 0; li < lines.length; li++) {
-                if (charsRemaining <= lines[li].length) {
-                    cursorLine = li;
-                    break;
-                }
-                charsRemaining -= lines[li].length + 1;
-                cursorLine = li + 1;
+        this.autoFrame(() => {
+            const termW = this.surface.columns;
+            if (this.cursorRowsBelow > 0) {
+                this.emit(`\x1b[${this.cursorRowsBelow}A`);
             }
-            let output = "";
-            let cursorRowFromTop = 0;
-            let rowsSoFar = 0;
-            for (let li = 0; li < lines.length; li++) {
-                const prefix = li === 0 ? promptPrefix : indent;
-                const lineText = lines[li];
-                const lineVisLen = promptVisLen + visibleLen(lineText);
-                const lineTermRows = lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
-                if (li === cursorLine) {
-                    const before = lineText.slice(0, charsRemaining);
-                    const after = lineText.slice(charsRemaining);
-                    output += prefix + p.accent + before + p.reset;
-                    output += "\x1b7";
-                    output += p.accent + after + p.reset;
-                    const beforeVisCol = promptVisLen + visibleLen(before);
-                    cursorRowFromTop = rowsSoFar + (beforeVisCol > 0 ? Math.ceil(beforeVisCol / termW) - 1 : 0);
-                    this.cursorTermCol = beforeVisCol === 0 ? 1 : (beforeVisCol % termW === 0 ? termW : (beforeVisCol % termW) + 1);
+            this.emit("\r\x1b[J");
+            const infoPrefix = vm.agentInfo.info
+                ? `${vm.agentInfo.info} ${p.success}${vm.indicator}${p.reset} `
+                : `${p.success}${vm.indicator}${p.reset} `;
+            const promptPrefix = infoPrefix + p.warning + p.bold + vm.promptIcon + " " + p.reset;
+            const promptVisLen = visibleLen(infoPrefix) + visibleLen(vm.promptIcon) + 1;
+            const display = vm.showBuffer ? vm.displayText : "";
+            const dCursor = vm.showBuffer ? vm.displayCursor : 0;
+            if (!vm.showBuffer) {
+                this.emit(promptPrefix);
+                const N = promptVisLen;
+                this.cursorRowsBelow = N > 0 ? Math.ceil(N / termW) - 1 : 0;
+                this.cursorTermCol = N === 0 ? 1 : (N % termW === 0 ? termW : (N % termW) + 1);
+            }
+            else if (!display.includes("\n")) {
+                // DECSC/DECRC bracket the after-cursor text so the cursor lands mid-line.
+                const before = display.slice(0, dCursor);
+                const after = display.slice(dCursor);
+                this.emit(promptPrefix + p.accent + before + p.reset +
+                    "\x1b7" +
+                    p.accent + after + p.reset +
+                    "\x1b8");
+                const cursorVisCol = promptVisLen + visibleLen(before);
+                this.cursorRowsBelow = cursorVisCol > 0 ? Math.ceil(cursorVisCol / termW) - 1 : 0;
+                this.cursorTermCol = cursorVisCol === 0 ? 1 : (cursorVisCol % termW === 0 ? termW : (cursorVisCol % termW) + 1);
+            }
+            else {
+                const lines = display.split("\n");
+                const indent = " ".repeat(promptVisLen);
+                let charsRemaining = dCursor;
+                let cursorLine = 0;
+                for (let li = 0; li < lines.length; li++) {
+                    if (charsRemaining <= lines[li].length) {
+                        cursorLine = li;
+                        break;
+                    }
+                    charsRemaining -= lines[li].length + 1;
+                    cursorLine = li + 1;
                 }
-                else {
-                    output += prefix + p.accent + lineText + p.reset;
+                let output = "";
+                let cursorRowFromTop = 0;
+                let rowsSoFar = 0;
+                for (let li = 0; li < lines.length; li++) {
+                    const prefix = li === 0 ? promptPrefix : indent;
+                    const lineText = lines[li];
+                    const lineVisLen = promptVisLen + visibleLen(lineText);
+                    const lineTermRows = lineVisLen > 0 ? Math.ceil(lineVisLen / termW) : 1;
+                    if (li === cursorLine) {
+                        const before = lineText.slice(0, charsRemaining);
+                        const after = lineText.slice(charsRemaining);
+                        output += prefix + p.accent + before + p.reset;
+                        output += "\x1b7";
+                        output += p.accent + after + p.reset;
+                        const beforeVisCol = promptVisLen + visibleLen(before);
+                        cursorRowFromTop = rowsSoFar + (beforeVisCol > 0 ? Math.ceil(beforeVisCol / termW) - 1 : 0);
+                        this.cursorTermCol = beforeVisCol === 0 ? 1 : (beforeVisCol % termW === 0 ? termW : (beforeVisCol % termW) + 1);
+                    }
+                    else {
+                        output += prefix + p.accent + lineText + p.reset;
+                    }
+                    if (li < lines.length - 1)
+                        output += "\n";
+                    rowsSoFar += lineTermRows;
                 }
-                if (li < lines.length - 1)
-                    output += "\n";
-                rowsSoFar += lineTermRows;
+                this.emit(output + "\x1b8");
+                this.cursorRowsBelow = cursorRowFromTop;
             }
-            this.surface.write(output + "\x1b8");
-            this.cursorRowsBelow = cursorRowFromTop;
-        }
+        });
     }
     drawAutocomplete(vm) {
         if (vm.items.length === 0)
             return;
-        const lines = [];
-        for (let i = 0; i < vm.items.length; i++) {
-            const item = vm.items[i];
-            const selected = i === vm.selected;
-            if (selected) {
-                lines.push(`  \x1b[7m ${p.accent}${item.name.padEnd(12)}${p.reset}\x1b[7m ${item.description} ${p.reset}`);
+        this.autoFrame(() => {
+            const lines = [];
+            for (let i = 0; i < vm.items.length; i++) {
+                const item = vm.items[i];
+                const selected = i === vm.selected;
+                if (selected) {
+                    lines.push(`  \x1b[7m ${p.accent}${item.name.padEnd(12)}${p.reset}\x1b[7m ${item.description} ${p.reset}`);
+                }
+                else {
+                    lines.push(`   ${p.muted}${item.name.padEnd(12)} ${item.description}${p.reset}`);
+                }
             }
-            else {
-                lines.push(`   ${p.muted}${item.name.padEnd(12)} ${item.description}${p.reset}`);
+            this.emit("\n" + lines.join("\n"));
+            this.autocompleteLines = lines.length;
+            if (this.autocompleteLines > 0) {
+                this.emit(`\x1b[${this.autocompleteLines}A`);
             }
-        }
-        this.surface.write("\n" + lines.join("\n"));
-        this.autocompleteLines = lines.length;
-        if (this.autocompleteLines > 0) {
-            this.surface.write(`\x1b[${this.autocompleteLines}A`);
-        }
-        // Absolute column set — preceding \n may have scrolled, invalidating DECSC.
-        this.surface.write(`\x1b[${this.cursorTermCol}G`);
+            // Absolute column set — preceding \n may have scrolled, invalidating DECSC.
+            this.emit(`\x1b[${this.cursorTermCol}G`);
+        });
     }
     clearAutocomplete() {
         if (this.autocompleteLines <= 0)
             return;
-        // CSI B (cursor down, bounded) so we don't scroll on the last row.
-        for (let i = 0; i < this.autocompleteLines; i++) {
-            this.surface.write("\x1b[B\x1b[2K");
-        }
-        this.surface.write(`\x1b[${this.autocompleteLines}A\x1b[${this.cursorTermCol}G`);
-        this.autocompleteLines = 0;
+        this.autoFrame(() => {
+            // CSI B (cursor down, bounded) so we don't scroll on the last row.
+            for (let i = 0; i < this.autocompleteLines; i++) {
+                this.emit("\x1b[B\x1b[2K");
+            }
+            this.emit(`\x1b[${this.autocompleteLines}A\x1b[${this.cursorTermCol}G`);
+            this.autocompleteLines = 0;
+        });
     }
 }

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

@@ -1,6 +1,4 @@
 import type { EventBus } from "../event-bus.js";
-/** Check if @xterm/headless is installed without loading it. */
-export declare function isXtermAvailable(): boolean;
 export interface TerminalBufferConfig {
     /** Terminal width in columns. Default: process.stdout.columns || 80. */
     cols?: number;
@@ -31,15 +29,14 @@ export declare class TerminalBuffer {
     /** Flush pending drip-feed data (set by createWired). */
     _flushPending: (() => void) | null;
     private constructor();
+    static create(config?: TerminalBufferConfig): TerminalBuffer;
     /**
-     * Create a new TerminalBuffer. Returns null if xterm is not installed.
+     * Create a TerminalBuffer wired to a bus's `shell:pty-data` event.
+     * Drip-feeds writes asynchronously: synchronous `term.write()` in the
+     * pty-data handler changes PTY read coalescing enough to introduce
+     * visual artifacts.
      */
-    static create(config?: TerminalBufferConfig): TerminalBuffer | null;
-    /**
-     * Create a TerminalBuffer and wire it to a bus's shell:pty-data event.
-     * Returns null if xterm is not installed.
-     */
-    static createWired(bus: EventBus, config?: TerminalBufferConfig): TerminalBuffer | null;
+    static createWired(bus: EventBus, config?: TerminalBufferConfig): TerminalBuffer;
     /** Flush any pending drip-feed data into the virtual terminal. */
     flush(): void;
     /** Write raw data into the virtual terminal. */

package/dist/utils/terminal-buffer.js

@@ -9,38 +9,19 @@
  *   - floating-panel.ts: composited overlay rendering + screen restore
  *   - terminal-buffer extension: agent tools (terminal_read, terminal_keys)
  *   - Any extension needing a virtual terminal snapshot
- *
- * The xterm dependency is loaded lazily on first use. If @xterm/headless
- * is not installed, create() returns null.
- *
- * Install (optional):
- *   npm install @xterm/headless@5.5.0 @xterm/addon-serialize@0.13.0
  */
+// xterm is loaded lazily on first TerminalBuffer.create(). Subcommands
+// (init/install/list) and non-shell frontends (web bridges) import this
+// file transitively but never instantiate a buffer; they shouldn't pay
+// the xterm parse cost at startup.
 import { createRequire } from "module";
-// ── Lazy xterm loader ───────────────────────────────────────────
 const require = createRequire(import.meta.url);
-let loadAttempted = false;
-let available = false;
-let TerminalCtor;
-let SerializeAddonCtor;
-function ensureXterm() {
-    if (loadAttempted)
-        return available;
-    loadAttempted = true;
-    try {
-        TerminalCtor = require("@xterm/headless").Terminal;
-        SerializeAddonCtor = require("@xterm/addon-serialize").SerializeAddon;
-        available = true;
-    }
-    catch {
-        available = false;
-    }
-    return available;
-}
-/** Check if @xterm/headless is installed without loading it. */
-export function isXtermAvailable() {
-    return ensureXterm();
-}
+// Node's require cache memoizes the first hit; subsequent calls are
+// just a hashmap lookup, so this stays lazy without our own caching.
+const loadXterm = () => ({
+    Terminal: require("@xterm/headless").Terminal,
+    SerializeAddon: require("@xterm/addon-serialize").SerializeAddon,
+});
 /**
  * Format a screen snapshot as an XML context block for agent injection.
  * Trims, caps to `maxLines` (from the bottom), and wraps in `<terminal_buffer>`.
@@ -71,47 +52,35 @@ export class TerminalBuffer {
         this.term = term;
         this.serializeAddon = serialize;
     }
-    /**
-     * Create a new TerminalBuffer. Returns null if xterm is not installed.
-     */
     static create(config) {
-        if (!ensureXterm())
-            return null;
+        const { Terminal, SerializeAddon } = loadXterm();
         const cols = config?.cols ?? (process.stdout.columns || 80);
         const rows = config?.rows ?? (process.stdout.rows || 24);
         const scrollback = config?.scrollback ?? 200;
-        const term = new TerminalCtor({ cols, rows, allowProposedApi: true, scrollback });
-        const serialize = new SerializeAddonCtor();
+        const term = new Terminal({ cols, rows, allowProposedApi: true, scrollback });
+        const serialize = new SerializeAddon();
         term.loadAddon(serialize);
         return new TerminalBuffer(term, serialize);
     }
     /**
-     * Create a TerminalBuffer and wire it to a bus's shell:pty-data event.
-     * Returns null if xterm is not installed.
+     * Create a TerminalBuffer wired to a bus's `shell:pty-data` event.
+     * Drip-feeds writes asynchronously: synchronous `term.write()` in the
+     * pty-data handler changes PTY read coalescing enough to introduce
+     * visual artifacts.
      */
     static createWired(bus, config) {
         const tb = TerminalBuffer.create(config);
-        if (!tb)
-            return null;
-        // Buffer PTY data and drip-feed to xterm in the background.
-        // Synchronous term.write() in the pty-data handler introduces enough
-        // latency to change PTY read coalescing, causing visual artifacts.
         let pending = "";
-        bus.on("shell:pty-data", ({ raw }) => { pending += raw; });
-        setInterval(() => {
-            if (pending) {
-                const d = pending;
-                pending = "";
-                tb.write(d);
-            }
-        }, 50);
-        tb._flushPending = () => {
+        const drain = () => {
             if (pending) {
                 const d = pending;
                 pending = "";
                 tb.write(d);
             }
         };
+        bus.on("shell:pty-data", ({ raw }) => { pending += raw; });
+        setInterval(drain, 50);
+        tb._flushPending = drain;
         process.stdout.on("resize", () => {
             tb.resize(process.stdout.columns || 80, process.stdout.rows || 24);
         });
@@ -171,7 +140,6 @@ export class TerminalBuffer {
             const line = buf.getLine(y);
             lines.push(line ? line.translateToString(true) : "");
         }
-        // Trim trailing empty lines
         while (lines.length > 0 && lines[lines.length - 1] === "") {
             lines.pop();
         }

package/examples/extensions/claude-code-bridge/README.md

@@ -5,12 +5,16 @@ Runs Claude Code as an agent-sh backend using the official [@anthropic-ai/claude
 ## Install
 
 ```bash
-# Copy or symlink into your extensions directory
-cp -r examples/extensions/claude-code-bridge ~/.agent-sh/extensions/claude-code-bridge
+agent-sh install claude-code-bridge
+```
+
+This copies the bundled extension into `~/.agent-sh/extensions/claude-code-bridge` and runs `npm install` for you. To overwrite an existing install, pass `--force`. To uninstall, run `agent-sh uninstall claude-code-bridge`.
 
-# Install dependencies
-cd ~/.agent-sh/extensions/claude-code-bridge
-npm install
+Manual alternative (e.g. for a development checkout you want to symlink):
+
+```bash
+cp -r examples/extensions/claude-code-bridge ~/.agent-sh/extensions/claude-code-bridge
+cd ~/.agent-sh/extensions/claude-code-bridge && npm install
 ```
 
 ## Configure
@@ -34,16 +38,12 @@ Or switch at runtime:
 - `ANTHROPIC_API_KEY` must be set in your environment
 - Claude Code manages its own model selection — no model configuration needed in agent-sh
 
-## What this bridge is
-
-A pure protocol translator between the Claude Agent SDK's event stream and agent-sh's bus events. Claude Code uses its own built-in tools exactly as the SDK ships them (`Read`, `Edit`, `Write`, `Bash`, `Glob`, `Grep`). The bridge adds no tools of its own.
+## What works under claude-code
 
-## What this bridge intentionally does NOT bundle
+agent-sh's per-query context producers (e.g. `<shell_events>` from `shell-context`) are inlined into the prompt before each query, so claude-code sees the user's recent shell activity even though the SDK doesn't subscribe to agent-sh's shell bus directly.
 
-Three PTY-access tools are left out on purpose:
+The SDK's working directory follows agent-sh's PTY-tracked cwd, so when the user `cd`s in the terminal, claude-code's tools (Bash, Read, etc.) operate in the new directory.
 
-- `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
+## What this bridge is
 
-These are opt-in capabilities that belong in their own extensions. If you want any of them with Claude Code, write a companion extension that uses the SDK's `tool()` + `createSdkMcpServer()` to expose them as MCP tools, and extend the bridge (or fork it) to attach that MCP server to the SDK's `query()` options.
+A pure protocol translator between the Claude Agent SDK's event stream and agent-sh's bus events. Claude Code uses its own built-in tools exactly as the SDK ships them (`Read`, `Edit`, `Write`, `Bash`, `Glob`, `Grep`). The bridge adds no tools of its own.

package/examples/extensions/claude-code-bridge/index.ts

@@ -1,25 +1,8 @@
 /**
  * Claude Code bridge — runs Claude Code Agent SDK in-process as agent-sh's backend.
  *
- * Uses the official @anthropic-ai/claude-agent-sdk to spawn a Claude Code
- * session. Claude Code handles its own model selection, tool execution, and
- * permissions — the bridge is a pure protocol translator between the SDK's
- * event stream and agent-sh's bus events.
- *
- * PTY-access tools (`terminal_read`, `terminal_keys`, `user_shell`) are
- * intentionally NOT bundled here. If you want Claude Code to observe or
- * drive the user's live terminal, load a companion extension that
- * registers those tools as MCP tools the SDK can consume.
- *
- * Setup (from repo root):
- *   npm run build && npm link                    # register local agent-sh globally
- *   cd examples/extensions/claude-code-bridge
- *   npm install && npm link agent-sh             # link local dev copy
- *
- * Usage:
- *   agent-sh -e examples/extensions/claude-code-bridge
- *
- * Requires: Claude Code CLI installed and authenticated (claude login).
+ * Pure protocol translator between the SDK's event stream and agent-sh's bus.
+ * Requires Claude Code CLI installed and authenticated (claude login).
  */
 import { query, type Query } from "@anthropic-ai/claude-agent-sdk";
 import { readFile } from "node:fs/promises";
@@ -29,7 +12,13 @@ import { computeDiff, type DiffResult } from "agent-sh/utils/diff";
 
 // ── Extension entry point ─────────────────────────────────────────
 export default function activate(ctx: ExtensionContext): void {
-  const { bus } = ctx;
+  const { bus, call } = ctx;
+
+  // PTY-tracked cwd from shell-context; falls back when no PTY frontend.
+  const cwd = (): string => {
+    const v = call("cwd");
+    return typeof v === "string" && v ? v : process.cwd();
+  };
 
   let activeQuery: Query | null = null;
   const listeners: Array<{ event: string; fn: Function }> = [];
@@ -88,11 +77,16 @@ export default function activate(ctx: ExtensionContext): void {
       /** Pre-edit file snapshots for diff display (Edit/Write tools). */
       const fileSnapshots = new Map<string, string | null>();
 
+      // Splice per-query context (e.g. <shell_events>) into the prompt — the
+      // SDK has no other channel for it. Mirrors pi-bridge.
+      const ctxText = String(call("query-context:build") ?? "").trim();
+      const finalPrompt = ctxText ? `${ctxText}\n\n${userQuery}` : userQuery;
+
       try {
         activeQuery = query({
-          prompt: userQuery,
+          prompt: finalPrompt,
           options: {
-            cwd: process.cwd(),
+            cwd: cwd(),
             systemPrompt: {
               type: "preset",
               preset: "claude_code",
@@ -155,7 +149,7 @@ export default function activate(ctx: ExtensionContext): void {
 
                   // Snapshot file content before Edit/Write modifies it
                   if ((meta.name === "Edit" || meta.name === "Write") && typeof (input as any).file_path === "string") {
-                    const absPath = resolve(process.cwd(), (input as any).file_path);
+                    const absPath = resolve(cwd(), (input as any).file_path);
                     readFile(absPath, "utf-8")
                       .then(content => fileSnapshots.set(meta.id, content))
                       .catch(() => fileSnapshots.set(meta.id, null)); // file doesn't exist yet
@@ -191,7 +185,7 @@ export default function activate(ctx: ExtensionContext): void {
 
                   // Snapshot file content before Edit/Write modifies it
                   if ((b.name === "Edit" || b.name === "Write") && typeof (input as any).file_path === "string") {
-                    const absPath = resolve(process.cwd(), (input as any).file_path);
+                    const absPath = resolve(cwd(), (input as any).file_path);
                     readFile(absPath, "utf-8")
                       .then(content => fileSnapshots.set(b.id, content))
                       .catch(() => fileSnapshots.set(b.id, null));
@@ -226,7 +220,7 @@ export default function activate(ctx: ExtensionContext): void {
                       fileSnapshots.delete(toolUseId);
                       const filePath = (pending.input as any)?.file_path as string | undefined;
                       if (filePath) {
-                        const absPath = resolve(process.cwd(), filePath);
+                        const absPath = resolve(cwd(), filePath);
                         try {
                           const newContent = await readFile(absPath, "utf-8");
                           const diff = computeDiff(oldContent, newContent);

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

@@ -0,0 +1,59 @@
+# opencode-bridge
+
+Runs [opencode](https://opencode.ai/) as an agent-sh backend using the official [@opencode-ai/sdk](https://www.npmjs.com/package/@opencode-ai/sdk). opencode brings its own configuration, models, tools, and authentication — agent-sh just provides the terminal.
+
+## Install
+
+```bash
+agent-sh install opencode-bridge
+```
+
+This copies the bundled extension into `~/.agent-sh/extensions/opencode-bridge` and runs `npm install` for you. To overwrite an existing install, pass `--force`. To uninstall, run `agent-sh uninstall opencode-bridge`.
+
+Manual alternative (e.g. for a development checkout you want to symlink):
+
+```bash
+cp -r examples/extensions/opencode-bridge ~/.agent-sh/extensions/opencode-bridge
+cd ~/.agent-sh/extensions/opencode-bridge && npm install
+```
+
+## Configure
+
+Set as default backend in `~/.agent-sh/settings.json`:
+
+```json
+{
+  "defaultBackend": "opencode"
+}
+```
+
+Or switch at runtime:
+
+```
+> /backend opencode
+```
+
+opencode reads its own config from `~/.local/share/opencode/` (auth credentials) and `opencode.json` / `opencode.jsonc` in your project. Configure providers and authentication by running `opencode auth login` directly — agent-sh does not override opencode's configuration.
+
+## Requirements
+
+- opencode authenticated locally — run `opencode auth login` once before using this bridge.
+- Provider env vars (e.g. `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`) as required by opencode for the model you've selected.
+
+## What works under opencode
+
+agent-sh's per-query context producers (e.g. `<shell_events>` from `shell-context`) are inlined into opencode's prompt before each query, so opencode sees the user's recent shell activity even though the SDK doesn't subscribe to agent-sh's shell bus directly. The current cwd is part of that context, so opencode knows where the user is even when its tools are anchored elsewhere.
+
+## cwd handling
+
+opencode treats the `directory` query param as a project ID and routes its event stream per-project — switching project mid-session silences the SSE channel we already subscribed to (no tool events, no streaming text). Because of that, the bridge **pins the session to the directory agent-sh launched from** and does not propagate later in-shell `cd`s to opencode. opencode's tools (`Bash`, `Read`, `Edit`, etc.) operate from that pinned directory; the agent learns the user's real cwd from `<shell_events>` and can still reach other locations through absolute paths or `cd && cmd` in `Bash`.
+
+To re-anchor the agent to your current cwd, run `/reset` — it tears down the conversation and creates a fresh session in your present directory.
+
+## Permission prompts
+
+opencode supports a `permission.edit = "ask"` config in `opencode.json` that gates write/edit tools behind an approval. The bridge has no UI primitive for showing that prompt, so it **auto-approves each request once** — without this, write/edit tool calls hang forever waiting for a reply that never comes. This matches claude-code-bridge's `permissionMode: "acceptEdits"` behavior. If you want to actually gate edits, set `permission.edit` to `"allow"` (skip the prompt entirely) or run opencode standalone for the interactive flow.
+
+## What this bridge is
+
+A pure protocol translator between opencode's SSE event stream and agent-sh's bus events. opencode runs as an in-process HTTP server (booted by `createOpencode()`); the bridge consumes its global event stream, filters by the active session's ID, and translates `message.part.updated` events (text/reasoning deltas, `ToolPart.state` transitions) into agent-sh tool/response events. opencode's built-in tools (bash, edit, read, write, grep, glob, etc.) are used exactly as opencode ships them. The bridge adds no tools of its own.