agent-sh 0.12.27 → 0.13.0

package/examples/extensions/ashi/src/theme.ts

@@ -0,0 +1,151 @@
+import chalk from "chalk";
+import { highlight, supportsLanguage } from "cli-highlight";
+import type { EditorTheme, MarkdownTheme, SelectListTheme } from "@earendil-works/pi-tui";
+
+/** Bundled dark palette, lifted from pi-coding-agent's dark.json. */
+const VARS: Record<string, string> = {
+  cyan: "#00d7ff",
+  blue: "#5f87ff",
+  green: "#b5bd68",
+  red: "#cc6666",
+  yellow: "#ffff00",
+  gray: "#808080",
+  dimGray: "#666666",
+  darkGray: "#505050",
+  accent: "#8abeb7",
+  selectedBg: "#3a3a4a",
+  userMsgBg: "#343541",
+  toolPendingBg: "#282832",
+  toolSuccessBg: "#283228",
+  toolErrorBg: "#3c2828",
+};
+
+const RAW = {
+  accent: "accent",
+  border: "blue",
+  borderAccent: "cyan",
+  borderMuted: "darkGray",
+  success: "green",
+  error: "red",
+  warning: "yellow",
+  muted: "gray",
+  dim: "dimGray",
+  text: "",
+  thinkingText: "gray",
+  selectedBg: "selectedBg",
+  userMessageBg: "userMsgBg",
+  userMessageText: "",
+  toolPendingBg: "toolPendingBg",
+  toolSuccessBg: "toolSuccessBg",
+  toolErrorBg: "toolErrorBg",
+  toolTitle: "",
+  toolOutput: "gray",
+  mdHeading: "#f0c674",
+  mdLink: "#81a2be",
+  mdLinkUrl: "dimGray",
+  mdCode: "accent",
+  mdCodeBlock: "green",
+  mdCodeBlockBorder: "gray",
+  mdQuote: "gray",
+  mdQuoteBorder: "gray",
+  mdHr: "gray",
+  mdListBullet: "accent",
+  toolDiffAdded: "green",
+  toolDiffRemoved: "red",
+  toolDiffContext: "gray",
+  bashMode: "green",
+} as const;
+
+export type ThemeColor = keyof typeof RAW;
+
+function resolve(v: string): string {
+  if (v === "") return "";
+  if (v.startsWith("#")) return v;
+  const hex = VARS[v];
+  if (!hex) throw new Error(`Unknown theme var: ${v}`);
+  return hex;
+}
+
+function hexToRgb(hex: string): [number, number, number] {
+  const c = hex.replace("#", "");
+  return [parseInt(c.slice(0, 2), 16), parseInt(c.slice(2, 4), 16), parseInt(c.slice(4, 6), 16)];
+}
+
+function fgAnsi(hex: string): string {
+  if (hex === "") return "\x1b[39m";
+  const [r, g, b] = hexToRgb(hex);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function bgAnsi(hex: string): string {
+  if (hex === "") return "\x1b[49m";
+  const [r, g, b] = hexToRgb(hex);
+  return `\x1b[48;2;${r};${g};${b}m`;
+}
+
+class Theme {
+  private fgCodes = new Map<ThemeColor, string>();
+  private bgCodes = new Map<ThemeColor, string>();
+  constructor() {
+    for (const k of Object.keys(RAW) as ThemeColor[]) {
+      const hex = resolve(RAW[k]);
+      this.fgCodes.set(k, fgAnsi(hex));
+      this.bgCodes.set(k, bgAnsi(hex));
+    }
+  }
+  fg(color: ThemeColor, text: string): string { return `${this.fgCodes.get(color)}${text}\x1b[39m`; }
+  bg(color: ThemeColor, text: string): string { return `${this.bgCodes.get(color)}${text}\x1b[49m`; }
+  bgCode(color: ThemeColor): string { return this.bgCodes.get(color) ?? ""; }
+  bold(text: string): string { return chalk.bold(text); }
+  italic(text: string): string { return chalk.italic(text); }
+  underline(text: string): string { return chalk.underline(text); }
+  strikethrough(text: string): string { return chalk.strikethrough(text); }
+}
+
+export const theme = new Theme();
+
+export function markdownTheme(): MarkdownTheme {
+  return {
+    heading: (t) => theme.fg("mdHeading", t),
+    link: (t) => theme.fg("mdLink", t),
+    linkUrl: (t) => theme.fg("mdLinkUrl", t),
+    code: (t) => theme.fg("mdCode", t),
+    codeBlock: (t) => theme.fg("mdCodeBlock", t),
+    codeBlockBorder: (t) => theme.fg("mdCodeBlockBorder", t),
+    quote: (t) => theme.fg("mdQuote", t),
+    quoteBorder: (t) => theme.fg("mdQuoteBorder", t),
+    hr: (t) => theme.fg("mdHr", t),
+    listBullet: (t) => theme.fg("mdListBullet", t),
+    bold: (t) => theme.bold(t),
+    italic: (t) => theme.italic(t),
+    underline: (t) => theme.underline(t),
+    strikethrough: (t) => theme.strikethrough(t),
+    highlightCode: (src: string, lang?: string): string[] => {
+      const validLang = lang && supportsLanguage(lang) ? lang : undefined;
+      if (!validLang) return src.split("\n").map((l) => theme.fg("mdCodeBlock", l));
+      try {
+        return highlight(src, { language: validLang, ignoreIllegals: true }).split("\n");
+      } catch {
+        return src.split("\n").map((l) => theme.fg("mdCodeBlock", l));
+      }
+    },
+  };
+}
+
+export function selectListTheme(): SelectListTheme {
+  return {
+    selectedPrefix: (t) => theme.fg("accent", t),
+    selectedText: (t) => theme.fg("accent", t),
+    description: (t) => theme.fg("muted", t),
+    scrollInfo: (t) => theme.fg("muted", t),
+    noMatch: (t) => theme.fg("muted", t),
+  };
+}
+
+export function editorTheme(): EditorTheme {
+  return {
+    borderColor: (t) => theme.fg("borderMuted", t),
+    selectList: selectListTheme(),
+  };
+}
+

package/examples/extensions/ashi/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

package/examples/extensions/emacs-buffer.ts

@@ -187,7 +187,7 @@ function renderSnapshot(snap: EmacsSnapshot): string {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { registerTool } = ctx;
+  const { registerTool } = ctx.agent;
   if (!emacsclientAvailable()) return;
 
   registerTool({

package/examples/extensions/interactive-prompts.ts

@@ -1,10 +1,9 @@
 /**
  * Interactive permission prompts extension.
  *
- * Adds permission gates for tool calls and file writes.
- * Without this extension, agent-sh runs in yolo mode (auto-approve).
- *
- * Uses the interactive UI primitive for compositor-aware, themed rendering.
+ * Gates the four built-in side-effect tools (bash, pwsh, write_file,
+ * edit_file) via tool advisors. Without this extension, agent-sh runs in
+ * yolo mode — tools execute without confirmation.
  *
  * Usage:
  *   agent-sh -e ./examples/extensions/interactive-prompts.ts
@@ -12,19 +11,22 @@
  *   # Or copy to ~/.agent-sh/extensions/ for permanent use:
  *   cp examples/extensions/interactive-prompts.ts ~/.agent-sh/extensions/
  */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { renderDiff } from "agent-sh/utils/diff-renderer.js";
 import { renderBoxFrame } from "agent-sh/utils/box-frame.js";
 import { palette as p } from "agent-sh/utils/palette.js";
-import type { ExtensionContext } from "agent-sh/types";
+import { computeDiff, computeEditDiff, computeInputDiff, type DiffResult } from "agent-sh/utils/diff.js";
+import type { AgentContext } from "agent-sh/types";
 import type { ToolUI } from "agent-sh/agent/types.js";
 
-export default function activate(ctx: ExtensionContext) {
+const GATED_TOOLS = ["bash", "pwsh", "write_file", "edit_file"] as const;
+
+export default function activate(ctx: AgentContext) {
   let autoApproveWrites = false;
 
-  // Advise the TUI diff renderer to add permission prompt framing.
-  // This replaces the default plain diff box with one that has a warning
-  // border and key hints, so only one diff box is shown (not two).
-  ctx.advise("tui:render-diff", (next, filePath: string, diff: any, width: number) => {
+  // Frame pre-execute diff previews as a permission prompt.
+  ctx.advise("tui:render-diff", (_next, filePath: string, diff: DiffResult, width: number) => {
     const boxW = Math.min(84, width);
     const contentW = boxW - 4;
     const MAX_DISPLAY = 25;
@@ -54,94 +56,137 @@ export default function activate(ctx: ExtensionContext) {
     });
   });
 
-  const { bus } = ctx;
+  for (const name of GATED_TOOLS) {
+    ctx.agent.adviseTool(name, async (next, args, onChunk, toolCtx) => {
+      const ui = toolCtx?.ui;
+      if (!ui) return next(args, onChunk, toolCtx);
 
-  bus.onPipeAsync("permission:request", async (payload) => {
-    const ui = payload.ui as ToolUI | undefined;
-    if (!ui) return payload;
+      const isFileWrite = name === "write_file" || name === "edit_file";
+      let diffPreRendered = false;
 
-    switch (payload.kind) {
-      case "tool-call":
-        return handleToolCall(payload, ui);
-      case "file-write": {
-        if (autoApproveWrites) {
-          return { ...payload, decision: { outcome: "approved" } };
-        }
-        const result = await handleFileWrite(payload, ui);
-        if ((result.decision as any).autoApprove) {
-          autoApproveWrites = true;
+      ctx.bus.emit("shell:stdout-show", {});
+      try {
+        if (isFileWrite) {
+          if (autoApproveWrites) {
+            // Skip prompt; tool's own post-execute diff renders as usual.
+            return next(args, onChunk, toolCtx);
+          }
+          await renderPreviewDiff(ctx, name, args);
+          diffPreRendered = true;
+
+          const answer = await promptWrite(ui);
+          if (answer === "reject") {
+            return { content: "Permission denied by user.", exitCode: 1, isError: true };
+          }
+          if (answer === "approve_all") autoApproveWrites = true;
+        } else {
+          const answer = await promptCommand(ui, name, args);
+          if (answer === "deny") {
+            return { content: "Permission denied by user.", exitCode: 1, isError: true };
+          }
         }
-        return result;
+      } finally {
+        ctx.bus.emit("shell:stdout-hide", {});
       }
-      default:
-        return payload;
-    }
-  });
+
+      const result = await next(args, onChunk, toolCtx);
+      if (diffPreRendered && result.display?.body?.kind === "diff") {
+        // Strip the redundant post-execute diff body since we already showed it.
+        return { ...result, display: { ...result.display, body: undefined } };
+      }
+      return result;
+    });
+  }
 }
 
-async function handleToolCall(payload: any, ui: ToolUI) {
-  const options = payload.metadata.options;
+async function renderPreviewDiff(
+  ctx: AgentContext,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<void> {
+  const rawPath = args.path;
+  if (typeof rawPath !== "string") return;
+  const absPath = path.resolve(process.cwd(), rawPath);
 
-  const answer = await ui.custom<"approve" | "approve_all" | "deny">({
+  let diff: DiffResult | undefined;
+  if (toolName === "edit_file" && typeof args.old_text === "string" && typeof args.new_text === "string") {
+    const normalizedOld = (args.old_text as string).replace(/\r\n/g, "\n");
+    const normalizedNew = (args.new_text as string).replace(/\r\n/g, "\n");
+    try {
+      const oldFileContent = await fs.readFile(absPath, "utf-8");
+      diff = computeEditDiff(
+        oldFileContent, normalizedOld, normalizedNew,
+        args.replace_all === true,
+      );
+    } catch {
+      diff = computeInputDiff(normalizedOld, normalizedNew);
+    }
+  } else if (toolName === "write_file" && typeof args.content === "string") {
+    let oldContent: string | null = null;
+    try { oldContent = await fs.readFile(absPath, "utf-8"); } catch { /* new file */ }
+    diff = computeDiff(oldContent, args.content as string);
+  }
+  if (!diff || diff.isIdentical) return;
+
+  const cwd = process.cwd();
+  const home = process.env.HOME ?? "";
+  let displayPath = absPath;
+  if (absPath.startsWith(cwd + "/")) displayPath = absPath.slice(cwd.length + 1);
+  else if (home && absPath.startsWith(home + "/")) displayPath = "~/" + absPath.slice(home.length + 1);
+
+  ctx.call("tui:show-diff", displayPath, diff);
+}
+
+async function promptWrite(ui: ToolUI): Promise<"approve" | "approve_all" | "reject"> {
+  return ui.custom<"approve" | "approve_all" | "reject">({
     render(width) {
       const boxW = Math.min(84, width);
-      return renderBoxFrame(
-        [`${p.bold}⚠ ${payload.title}${p.reset}`],
-        {
-          width: boxW,
-          style: "rounded",
-          borderColor: p.warning,
-          title: "Permission required",
-          footer: [`  ${p.dim}[y]es / [n]o / [a]llow all${p.reset}`],
-        },
-      );
+      return renderBoxFrame([], {
+        width: boxW,
+        style: "rounded",
+        borderColor: p.warning,
+        footer: [`  ${p.bold}[y] Apply  [n] Skip  [a] Don't ask again${p.reset}`],
+      });
     },
     handleInput(data, done) {
       const ch = data.toLowerCase();
       if (ch === "y") done("approve");
       else if (ch === "a") done("approve_all");
-      else if (ch === "n" || ch === "\x1b") done("deny");
+      else if (ch === "n" || ch === "\x1b") done("reject");
     },
   });
-
-  if (answer === "approve" || answer === "approve_all") {
-    const kind = answer === "approve_all" ? "allow_always" : "allow_once";
-    const option = options?.find((o: any) => o.kind === kind)
-      ?? options?.find((o: any) => o.kind === "allow_once" || o.kind === "allow_always");
-    if (option) {
-      return { ...payload, decision: { outcome: "selected", optionId: option.optionId } };
-    }
-    return { ...payload, decision: { outcome: "approved" } };
-  }
-  return { ...payload, decision: { outcome: "cancelled" } };
 }
 
-async function handleFileWrite(payload: any, ui: ToolUI) {
-  const answer = await ui.custom<"approve" | "approve_all" | "reject">({
+async function promptCommand(
+  ui: ToolUI,
+  toolName: string,
+  args: Record<string, unknown>,
+): Promise<"approve" | "deny"> {
+  const command = typeof args.command === "string" ? args.command : "";
+  const description = typeof args.description === "string" ? args.description : "";
+  const title = description ? `${toolName}: ${description}` : toolName;
+  const body = command
+    ? `${p.bold}${title}${p.reset}\n${p.dim}${truncate(command, 200)}${p.reset}`
+    : `${p.bold}${title}${p.reset}`;
+  return ui.custom<"approve" | "deny">({
     render(width) {
       const boxW = Math.min(84, width);
-      // Just show the prompt actions — the diff itself was already rendered
-      // by our advise on "tui:render-diff".
-      return renderBoxFrame([], {
+      return renderBoxFrame(body.split("\n"), {
         width: boxW,
         style: "rounded",
         borderColor: p.warning,
-        footer: [`  ${p.bold}[y] Apply  [n] Skip  [a] Don't ask again${p.reset}`],
+        title: "Permission required",
+        footer: [`  ${p.dim}[y]es / [n]o${p.reset}`],
       });
     },
     handleInput(data, done) {
       const ch = data.toLowerCase();
       if (ch === "y") done("approve");
-      else if (ch === "a") done("approve_all");
-      else if (ch === "n" || ch === "\x1b") done("reject");
+      else if (ch === "n" || ch === "\x1b") done("deny");
     },
   });
+}
 
-  if (answer === "approve") {
-    return { ...payload, decision: { outcome: "approved" } };
-  }
-  if (answer === "approve_all") {
-    return { ...payload, decision: { outcome: "approved", autoApprove: true } };
-  }
-  return { ...payload, decision: { outcome: "cancelled" } };
+function truncate(s: string, max: number): string {
+  return s.length <= max ? s : s.slice(0, max - 1) + "…";
 }

package/examples/extensions/latex-images.ts

@@ -19,7 +19,7 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { ExtensionContext } from "agent-sh/types";
+import type { ShellContext } from "agent-sh/types";
 
 // Settings loaded in activate() via ctx.getExtensionSettings
 let config = { dpi: 300, fgColor: "d4d4d4" };
@@ -98,7 +98,7 @@ function renderEquation(equation: string): Buffer | null {
 
 // ── Extension entry point ────────────────────────────────────────
 
-export default function activate(ctx: ExtensionContext) {
+export default function activate(ctx: ShellContext) {
   const { bus } = ctx;
 
   // Load settings: ~/.agent-sh/settings.json → "latex-images": { dpi, fgColor }
@@ -116,7 +116,7 @@ export default function activate(ctx: ExtensionContext) {
   }
 
   // Handle inline $$...$$ display math
-  ctx.createBlockTransform({
+  ctx.shell.createBlockTransform({
     open: "$$",
     close: "$$",
     transform(latex) {

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

@@ -60,7 +60,7 @@ function parseUnifiedDiff(patch: string): DiffResult | null {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, call, compositor } = ctx;
+  const { bus, call } = ctx; const { compositor } = ctx.shell;
 
   const cwd = (): string => {
     const v = call("cwd");

package/examples/extensions/overlay-agent.ts

@@ -20,7 +20,7 @@
  *   - 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 { AgentContext, ShellContext, 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";
@@ -66,8 +66,10 @@ function createPanelSurface(panel: FloatingPanel): RenderSurface {
   };
 }
 
-export default function activate(ctx: ExtensionContext): void {
-  const { bus, registerInstruction, createRemoteSession } = ctx;
+export default function activate(ctx: AgentContext & ShellContext): void {
+  const { bus } = ctx;
+  const { registerInstruction } = ctx.agent;
+  const { createRemoteSession } = ctx.shell;
   const terminalBuffer: TerminalBuffer | null = ctx.call("terminal-buffer");
 
   const panel = new FloatingPanel(bus, {
@@ -79,13 +81,13 @@ export default function activate(ctx: ExtensionContext): void {
   const panelSurface = createPanelSurface(panel);
   let session: RemoteSession | null = null;
 
-  ctx.registerContextProducer("interactive-session", () =>
+  ctx.agent.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", () => {
+  ctx.agent.registerContextProducer("terminal-screen", () => {
     if (!session?.active || !terminalBuffer?.altScreen) return null;
     return formatScreenContext(terminalBuffer.readScreen(), 80);
   });

package/examples/extensions/peer-mesh.ts

@@ -190,7 +190,7 @@ class PeerServer {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, registerCommand, registerTool, registerInstruction, define } = ctx;
+  const { bus, registerCommand, define } = ctx; const { registerTool, registerInstruction } = ctx.agent;
   const getCwd = () => ctx.call("cwd") as string;
   const startTime = Date.now();
 

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

@@ -391,7 +391,6 @@ export default function activate(ctx: ExtensionContext): void {
         return;
       }
       session.setThinkingLevel(level);
-      bus.emit("ui:info", { message: `Thinking: ${level}` });
       bus.emit("config:changed", {});
     };
 

package/examples/extensions/questionnaire.ts

@@ -55,7 +55,8 @@ interface QuestionnaireResult {
 
 // ── Extension ────────────────────────────────────────────────────
 
-export default function activate({ registerTool, registerInstruction }: ExtensionContext) {
+export default function activate(ctx: ExtensionContext) {
+  const { registerTool, registerInstruction } = ctx.agent;
   registerInstruction("questionnaire", [
     "# When to use the questionnaire tool",
     "ALWAYS use the `questionnaire` tool instead of asking the user a question in plain text when:",

package/examples/extensions/rtk-proxy.ts

@@ -20,7 +20,7 @@
  *   cp examples/extensions/rtk-proxy.ts ~/.agent-sh/extensions/
  */
 import { execSync } from "node:child_process";
-import type { ExtensionContext } from "agent-sh/types";
+import type { AgentContext } from "agent-sh/types";
 
 const DEFAULT_PREFIXES = new Set([
   "git", "gh",
@@ -73,7 +73,7 @@ function rewriteForRtk(cmd: string, prefixes: Set<string>, flag: string): string
   return `RTK_TELEMETRY_DISABLED=1 rtk ${flag}${cmd}`;
 }
 
-export default function activate(ctx: ExtensionContext) {
+export default function activate(ctx: AgentContext) {
   const config = ctx.getExtensionSettings("rtk-proxy", {
     enabled: true,
     ultraCompact: false,
@@ -95,7 +95,7 @@ export default function activate(ctx: ExtensionContext) {
   for (const p of config.excludePrefixes) prefixes.delete(p);
   const flag = config.ultraCompact ? "--ultra-compact " : "";
 
-  ctx.registerInstruction("rtk-proxy",
+  ctx.agent.registerInstruction("rtk-proxy",
     "The rtk-proxy extension transparently rewrites bash commands like " +
     "`git status`, `cargo test`, `pytest` to their rtk-compressed equivalents " +
     "before execution. Output will be condensed (errors/failures first, " +

package/examples/extensions/solarized-theme.ts

@@ -9,10 +9,10 @@
  *   # Or copy to ~/.agent-sh/extensions/ for permanent use:
  *   cp examples/extensions/solarized-theme.ts ~/.agent-sh/extensions/
  */
-import type { ExtensionContext } from "agent-sh/types";
+import type { ShellContext } from "agent-sh/types";
 
-export default function activate({ setPalette }: ExtensionContext) {
-  setPalette({
+export default function activate(ctx: ShellContext) {
+  ctx.shell.setPalette({
     accent:  "\x1b[38;2;38;139;210m",   // blue (#268bd2)
     success: "\x1b[38;2;133;153;0m",    // green (#859900)
     warning: "\x1b[38;2;181;137;0m",    // yellow (#b58900)

package/examples/extensions/subagents.ts

@@ -8,22 +8,22 @@
  * Usage:
  *   agent-sh -e ./examples/extensions/subagents.ts
  */
-import type { ExtensionContext } from "agent-sh/types";
+import type { AgentContext } from "agent-sh/types";
 import { runSubagent } from "agent-sh/agent/subagent";
 
-export default function activate(ctx: ExtensionContext): void {
+export default function activate(ctx: AgentContext): void {
   const { bus, llmClient } = ctx;
   if (!llmClient) return;
 
-  const allToolNames = () => ctx.getTools().map(t => t.name);
+  const allToolNames = () => ctx.agent.getTools().map(t => t.name);
 
-  ctx.registerInstruction("subagent-guide", [
+  ctx.agent.registerInstruction("subagent-guide", [
     "You have a spawn_agent tool for delegating work to a subagent with its own context.",
     "The subagent inherits your session history, so write a short directive (what to do), not a briefing (what happened).",
     "Use it for tasks that need multiple tool calls you don't need to see — research, exploration, independent implementation.",
   ].join("\n"));
 
-  ctx.registerTool({
+  ctx.agent.registerTool({
     name: "spawn_agent",
     description:
       "Spawn a subagent with its own fresh context to handle a focused task. " +
@@ -63,7 +63,7 @@ export default function activate(ctx: ExtensionContext): void {
       const task = args.task as string;
       const toolNames = args.tools as string[] | undefined;
 
-      const allTools = ctx.getTools();
+      const allTools = ctx.agent.getTools();
       // Filter to requested tools, or give all tools (minus spawn_agent to prevent recursion)
       const tools = toolNames
         ? allTools.filter(t => toolNames.includes(t.name))

package/examples/extensions/terminal-buffer.ts

@@ -138,7 +138,7 @@ function diffScreens(before: string, after: string): string {
 }
 
 export default function activate(ctx: ExtensionContext): void {
-  const { bus, registerTool } = ctx;
+  const { bus } = ctx; const { registerTool } = ctx.agent;
   const tb = ctx.call("terminal-buffer");
   if (!tb) return; // @xterm/headless not installed, or shell frontend not loaded
 

package/examples/extensions/tmux-pane.ts

@@ -22,7 +22,7 @@ import * as net from "node:net";
 import * as os from "node:os";
 import * as path from "node:path";
 import { execSync, spawn } from "node:child_process";
-import type { ExtensionContext, RenderSurface, RemoteSession } from "agent-sh/types";
+import type { AgentContext, ShellContext, RenderSurface, RemoteSession } from "agent-sh/types";
 
 // ── Helpers ─────────────────────────────────────────────────────
 
@@ -142,15 +142,17 @@ interface PaneState {
 
 // ── Extension ───────────────────────────────────────────────────
 
-export default function activate(ctx: ExtensionContext): void {
-  const { bus, registerCommand, registerInstruction, createRemoteSession } = ctx;
+export default function activate(ctx: AgentContext & ShellContext): void {
+  const { bus, registerCommand } = ctx;
+  const { registerInstruction } = ctx.agent;
+  const { createRemoteSession } = ctx.shell;
 
   if (!inTmux()) return;
 
   let state: PaneState | null = null;
 
   // Tell the LLM it's running inside an interactive pane session.
-  ctx.registerContextProducer("interactive-session", () =>
+  ctx.agent.registerContextProducer("interactive-session", () =>
     state?.mode === "rsplit" ? "interactive-session: true" : null,
   );