@tintinweb/pi-subagents 0.4.10 → 0.5.0

package/dist/ui/conversation-viewer.test.js

@@ -0,0 +1,254 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+// ── Mock wrapTextWithAnsi ──────────────────────────────────────────────
+// We need to control what wrapTextWithAnsi returns to simulate the
+// upstream bug (returning lines wider than requested width).
+// vi.mock is hoisted and intercepts before conversation-viewer.ts binds
+// its import.
+let wrapOverride = null;
+vi.mock("@mariozechner/pi-tui", async (importOriginal) => {
+    const original = await importOriginal();
+    return {
+        ...original,
+        wrapTextWithAnsi: (...args) => {
+            if (wrapOverride)
+                return wrapOverride(...args);
+            return original.wrapTextWithAnsi(...args);
+        },
+    };
+});
+// Must import AFTER vi.mock declaration (vitest hoists vi.mock but the
+// dynamic import of the test subject must happen after)
+const { visibleWidth } = await import("@mariozechner/pi-tui");
+const { ConversationViewer } = await import("./conversation-viewer.js");
+// ── Helpers ────────────────────────────────────────────────────────────
+function mockTui(rows = 40, columns = 80) {
+    return {
+        terminal: { rows, columns },
+        requestRender: vi.fn(),
+    };
+}
+function mockSession(messages = []) {
+    return {
+        messages,
+        subscribe: vi.fn(() => vi.fn()),
+        dispose: vi.fn(),
+        getSessionStats: () => ({ tokens: { total: 0 } }),
+    };
+}
+function mockRecord(overrides = {}) {
+    return {
+        id: "test-1",
+        type: "general-purpose",
+        description: "test agent",
+        status: "running",
+        toolUses: 0,
+        startedAt: Date.now(),
+        ...overrides,
+    };
+}
+function ansiTheme() {
+    return {
+        fg: (_color, text) => `\x1b[38;5;240m${text}\x1b[0m`,
+        bold: (text) => `\x1b[1m${text}\x1b[22m`,
+    };
+}
+function assertAllLinesFit(lines, width) {
+    for (let i = 0; i < lines.length; i++) {
+        const vw = visibleWidth(lines[i]);
+        expect(vw, `line ${i} exceeds width (${vw} > ${width}): ${JSON.stringify(lines[i])}`).toBeLessThanOrEqual(width);
+    }
+}
+// ── Tests ──────────────────────────────────────────────────────────────
+beforeEach(() => {
+    wrapOverride = null;
+});
+describe("ConversationViewer", () => {
+    describe("render width safety", () => {
+        const widths = [40, 80, 120, 216];
+        it("no line exceeds width with empty messages", () => {
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession([]), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with plain text messages", () => {
+            const messages = [
+                { role: "user", content: "Hello, how are you?" },
+                { role: "assistant", content: [{ type: "text", text: "I am fine, thank you for asking." }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width when text is longer than viewport", () => {
+            const longLine = "A".repeat(500);
+            const messages = [
+                { role: "user", content: longLine },
+                { role: "assistant", content: [{ type: "text", text: longLine }] },
+                { role: "toolResult", toolUseId: "t1", content: [{ type: "text", text: longLine }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with embedded ANSI escape codes in content", () => {
+            const ansiText = `\x1b[1mBold heading\x1b[22m and \x1b[31mred text\x1b[0m ${"X".repeat(300)}`;
+            const messages = [
+                { role: "toolResult", toolUseId: "t1", content: [{ type: "text", text: ansiText }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with long URLs", () => {
+            const url = "https://example.com/" + "a/b/c/d/e/".repeat(30) + "?q=" + "x".repeat(100);
+            const messages = [
+                { role: "assistant", content: [{ type: "text", text: `Check this link: ${url}` }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with wide table-like content", () => {
+            const header = "| " + Array.from({ length: 20 }, (_, i) => `Column${i}`).join(" | ") + " |";
+            const dataRow = "| " + Array.from({ length: 20 }, () => "value123").join(" | ") + " |";
+            const table = [header, dataRow, dataRow, dataRow].join("\n");
+            const messages = [
+                { role: "toolResult", toolUseId: "t1", content: [{ type: "text", text: table }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with bashExecution messages", () => {
+            const messages = [
+                {
+                    role: "bashExecution", command: "cat " + "/very/long/path/".repeat(20) + "file.txt",
+                    output: "O".repeat(600),
+                    exitCode: 0, cancelled: false, truncated: false, timestamp: Date.now(),
+                },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with running activity indicator", () => {
+            const activity = {
+                activeTools: new Map([["read", "file.ts"], ["grep", "pattern"]]),
+                toolUses: 5, tokens: "10k", responseText: "R".repeat(400),
+                session: { getSessionStats: () => ({ tokens: { total: 50000 } }) },
+            };
+            const messages = [
+                { role: "user", content: "do the thing" },
+                { role: "assistant", content: [{ type: "text", text: "working on it" }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord({ status: "running" }), activity, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with tool calls", () => {
+            const messages = [
+                {
+                    role: "assistant",
+                    content: [
+                        { type: "text", text: "Let me check that." },
+                        { type: "toolCall", toolUseId: "t1", name: "very_long_tool_name_" + "x".repeat(200), input: {} },
+                    ],
+                },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width at narrow terminal", () => {
+            const messages = [
+                { role: "user", content: "Hello world, this is a normal sentence." },
+                { role: "assistant", content: [{ type: "text", text: "Sure, here's the answer." }] },
+            ];
+            for (const w of [8, 10, 15, 20]) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+        it("no line exceeds width with mixed ANSI + unicode content", () => {
+            const text = `\x1b[32m✓\x1b[0m Test passed — 日本語テスト ${"あ".repeat(50)} \x1b[33m⚠\x1b[0m`;
+            const messages = [
+                { role: "toolResult", toolUseId: "t1", content: [{ type: "text", text }] },
+            ];
+            for (const w of widths) {
+                const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+                assertAllLinesFit(viewer.render(w), w);
+            }
+        });
+    });
+    describe("safety net against upstream wrapTextWithAnsi bugs", () => {
+        // These tests call buildContentLines() directly (via the private method)
+        // because render() has its own truncation via row(). The safety net in
+        // buildContentLines is what prevents the TUI crash — it must clamp
+        // independently of render().
+        /** Call the private buildContentLines method directly. */
+        function callBuildContentLines(viewer, width) {
+            return viewer.buildContentLines(width);
+        }
+        it("mock is intercepting wrapTextWithAnsi", async () => {
+            const { wrapTextWithAnsi } = await import("@mariozechner/pi-tui");
+            wrapOverride = () => ["MOCK_SENTINEL"];
+            expect(wrapTextWithAnsi("anything", 10)).toEqual(["MOCK_SENTINEL"]);
+            wrapOverride = null;
+        });
+        it("clamps overwidth lines from toolResult content", () => {
+            const w = 80;
+            wrapOverride = () => ["X".repeat(w + 50)];
+            const messages = [
+                { role: "toolResult", toolUseId: "t1", content: [{ type: "text", text: "output" }] },
+            ];
+            const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+            assertAllLinesFit(callBuildContentLines(viewer, w), w);
+        });
+        it("clamps overwidth lines from user message content", () => {
+            const w = 80;
+            wrapOverride = () => ["Y".repeat(w + 100)];
+            const messages = [{ role: "user", content: "hello" }];
+            const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+            assertAllLinesFit(callBuildContentLines(viewer, w), w);
+        });
+        it("clamps overwidth lines from assistant message content", () => {
+            const w = 80;
+            wrapOverride = () => ["Z".repeat(w + 100)];
+            const messages = [
+                { role: "assistant", content: [{ type: "text", text: "response" }] },
+            ];
+            const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+            assertAllLinesFit(callBuildContentLines(viewer, w), w);
+        });
+        it("clamps overwidth lines from bashExecution output", () => {
+            const w = 80;
+            wrapOverride = () => ["B".repeat(w + 100)];
+            const messages = [
+                {
+                    role: "bashExecution", command: "ls", output: "out",
+                    exitCode: 0, cancelled: false, truncated: false, timestamp: Date.now(),
+                },
+            ];
+            const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+            assertAllLinesFit(callBuildContentLines(viewer, w), w);
+        });
+        it("clamps overwidth lines that also contain ANSI codes", () => {
+            const w = 80;
+            wrapOverride = () => [`\x1b[1m\x1b[31m${"W".repeat(w + 30)}\x1b[0m`];
+            const messages = [
+                { role: "toolResult", toolUseId: "t1", content: [{ type: "text", text: "output" }] },
+            ];
+            const viewer = new ConversationViewer(mockTui(30, w), mockSession(messages), mockRecord(), undefined, ansiTheme(), vi.fn());
+            assertAllLinesFit(callBuildContentLines(viewer, w), w);
+        });
+    });
+});

package/dist/worktree.d.ts

@@ -0,0 +1,36 @@
+/**
+ * worktree.ts — Git worktree isolation for agents.
+ *
+ * Creates a temporary git worktree so the agent works on an isolated copy of the repo.
+ * On completion, if no changes were made, the worktree is cleaned up.
+ * If changes exist, a branch is created and returned in the result.
+ */
+export interface WorktreeInfo {
+    /** Absolute path to the worktree directory. */
+    path: string;
+    /** Branch name created for this worktree (if changes exist). */
+    branch: string;
+}
+export interface WorktreeCleanupResult {
+    /** Whether changes were found in the worktree. */
+    hasChanges: boolean;
+    /** Branch name if changes were committed. */
+    branch?: string;
+    /** Worktree path if it was kept. */
+    path?: string;
+}
+/**
+ * Create a temporary git worktree for an agent.
+ * Returns the worktree path, or undefined if not in a git repo.
+ */
+export declare function createWorktree(cwd: string, agentId: string): WorktreeInfo | undefined;
+/**
+ * Clean up a worktree after agent completion.
+ * - If no changes: remove worktree entirely.
+ * - If changes exist: create a branch, commit changes, return branch info.
+ */
+export declare function cleanupWorktree(cwd: string, worktree: WorktreeInfo, agentDescription: string): WorktreeCleanupResult;
+/**
+ * Prune any orphaned worktrees (crash recovery).
+ */
+export declare function pruneWorktrees(cwd: string): void;

package/dist/worktree.js

@@ -0,0 +1,139 @@
+/**
+ * worktree.ts — Git worktree isolation for agents.
+ *
+ * Creates a temporary git worktree so the agent works on an isolated copy of the repo.
+ * On completion, if no changes were made, the worktree is cleaned up.
+ * If changes exist, a branch is created and returned in the result.
+ */
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Create a temporary git worktree for an agent.
+ * Returns the worktree path, or undefined if not in a git repo.
+ */
+export function createWorktree(cwd, agentId) {
+    // Verify we're in a git repo with at least one commit (HEAD must exist)
+    try {
+        execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe", timeout: 5000 });
+        execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: "pipe", timeout: 5000 });
+    }
+    catch {
+        return undefined;
+    }
+    const branch = `pi-agent-${agentId}`;
+    const suffix = randomUUID().slice(0, 8);
+    const worktreePath = join(tmpdir(), `pi-agent-${agentId}-${suffix}`);
+    try {
+        // Create detached worktree at HEAD
+        execFileSync("git", ["worktree", "add", "--detach", worktreePath, "HEAD"], {
+            cwd,
+            stdio: "pipe",
+            timeout: 30000,
+        });
+        return { path: worktreePath, branch };
+    }
+    catch {
+        // If worktree creation fails, return undefined (agent runs in normal cwd)
+        return undefined;
+    }
+}
+/**
+ * Clean up a worktree after agent completion.
+ * - If no changes: remove worktree entirely.
+ * - If changes exist: create a branch, commit changes, return branch info.
+ */
+export function cleanupWorktree(cwd, worktree, agentDescription) {
+    if (!existsSync(worktree.path)) {
+        return { hasChanges: false };
+    }
+    try {
+        // Check for uncommitted changes in the worktree
+        const status = execFileSync("git", ["status", "--porcelain"], {
+            cwd: worktree.path,
+            stdio: "pipe",
+            timeout: 10000,
+        }).toString().trim();
+        if (!status) {
+            // No changes — remove worktree
+            removeWorktree(cwd, worktree.path);
+            return { hasChanges: false };
+        }
+        // Changes exist — stage, commit, and create a branch
+        execFileSync("git", ["add", "-A"], { cwd: worktree.path, stdio: "pipe", timeout: 10000 });
+        // Truncate description for commit message (no shell sanitization needed — execFileSync uses argv)
+        const safeDesc = agentDescription.slice(0, 200);
+        const commitMsg = `pi-agent: ${safeDesc}`;
+        execFileSync("git", ["commit", "-m", commitMsg], {
+            cwd: worktree.path,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+        // Create a branch pointing to the worktree's HEAD.
+        // If the branch already exists, append a suffix to avoid overwriting previous work.
+        let branchName = worktree.branch;
+        try {
+            execFileSync("git", ["branch", branchName], {
+                cwd: worktree.path,
+                stdio: "pipe",
+                timeout: 5000,
+            });
+        }
+        catch {
+            // Branch already exists — use a unique suffix
+            branchName = `${worktree.branch}-${Date.now()}`;
+            execFileSync("git", ["branch", branchName], {
+                cwd: worktree.path,
+                stdio: "pipe",
+                timeout: 5000,
+            });
+        }
+        // Update branch name in worktree info for the caller
+        worktree.branch = branchName;
+        // Remove the worktree (branch persists in main repo)
+        removeWorktree(cwd, worktree.path);
+        return {
+            hasChanges: true,
+            branch: worktree.branch,
+            path: worktree.path,
+        };
+    }
+    catch {
+        // Best effort cleanup on error
+        try {
+            removeWorktree(cwd, worktree.path);
+        }
+        catch { /* ignore */ }
+        return { hasChanges: false };
+    }
+}
+/**
+ * Force-remove a worktree.
+ */
+function removeWorktree(cwd, worktreePath) {
+    try {
+        execFileSync("git", ["worktree", "remove", "--force", worktreePath], {
+            cwd,
+            stdio: "pipe",
+            timeout: 10000,
+        });
+    }
+    catch {
+        // If git worktree remove fails, try pruning
+        try {
+            execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Prune any orphaned worktrees (crash recovery).
+ */
+export function pruneWorktrees(cwd) {
+    try {
+        execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
+    }
+    catch { /* ignore */ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tintinweb/pi-subagents",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "description": "A pi extension extension that brings smart Claude Code-style autonomous sub-agents to pi.",
   "author": "tintinweb",
   "license": "MIT",
@@ -21,12 +21,14 @@
     "autonomous"
   ],
   "dependencies": {
-    "@mariozechner/pi-ai": "^0.60.0",
-    "@mariozechner/pi-coding-agent": "^0.60.0",
-    "@mariozechner/pi-tui": "^0.60.0",
+    "@mariozechner/pi-ai": "^0.61.1",
+    "@mariozechner/pi-coding-agent": "^0.61.1",
+    "@mariozechner/pi-tui": "^0.61.1",
     "@sinclair/typebox": "latest"
   },
   "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run lint && npm run typecheck && npm run test && npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit",
@@ -34,9 +36,9 @@
     "lint:fix": "biome check --fix src/ test/"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
     "@biomejs/biome": "^2.3.5",
+    "@types/node": "^25.5.0",
+    "typescript": "^5.0.0",
     "vitest": "^4.0.18"
   },
   "pi": {

package/src/agent-runner.ts

@@ -393,7 +393,7 @@ export function getAgentConversation(session: AgentSession): string {
       const toolCalls: string[] = [];
       for (const c of msg.content) {
         if (c.type === "text" && c.text) textParts.push(c.text);
-        else if (c.type === "toolCall") toolCalls.push(`  Tool: ${(c as any).toolName ?? "unknown"}`);
+        else if (c.type === "toolCall") toolCalls.push(`  Tool: ${(c as any).name ?? (c as any).toolName ?? "unknown"}`);
       }
       if (textParts.length > 0) parts.push(`[Assistant]: ${textParts.join("\n")}`);
       if (toolCalls.length > 0) parts.push(`[Tool Calls]:\n${toolCalls.join("\n")}`);

package/src/cross-extension-rpc.ts

@@ -1,8 +1,12 @@
 /**
  * Cross-extension RPC handlers for the subagents extension.
  *
- * Exposes ping and spawn RPCs over the pi.events event bus,
+ * Exposes ping, spawn, and stop RPCs over the pi.events event bus,
  * using per-request scoped reply channels.
+ *
+ * Reply envelope follows pi-mono convention:
+ *   success → { success: true, data?: T }
+ *   error   → { success: false, error: string }
  */
 
 /** Minimal event bus interface needed by the RPC handlers. */
@@ -11,9 +15,18 @@ export interface EventBus {
   emit(event: string, data: unknown): void;
 }
 
-/** Minimal AgentManager interface needed by the spawn RPC. */
+/** RPC reply envelope — matches pi-mono's RpcResponse shape. */
+export type RpcReply<T = void> =
+  | { success: true; data?: T }
+  | { success: false; error: string };
+
+/** RPC protocol version — bumped when the envelope or method contracts change. */
+export const PROTOCOL_VERSION = 2;
+
+/** Minimal AgentManager interface needed by the spawn/stop RPCs. */
 export interface SpawnCapable {
   spawn(pi: unknown, ctx: unknown, type: string, prompt: string, options: any): string;
+  abort(id: string): boolean;
 }
 
 export interface RpcDeps {
@@ -26,36 +39,57 @@ export interface RpcDeps {
 export interface RpcHandle {
   unsubPing: () => void;
   unsubSpawn: () => void;
+  unsubStop: () => void;
 }
 
 /**
- * Register ping and spawn RPC handlers on the event bus.
+ * Wire a single RPC handler: listen on `channel`, run `fn(params)`,
+ * emit the reply envelope on `channel:reply:${requestId}`.
+ */
+function handleRpc<P extends { requestId: string }>(
+  events: EventBus,
+  channel: string,
+  fn: (params: P) => unknown | Promise<unknown>,
+): () => void {
+  return events.on(channel, async (raw: unknown) => {
+    const params = raw as P;
+    try {
+      const data = await fn(params);
+      const reply: { success: true; data?: unknown } = { success: true };
+      if (data !== undefined) reply.data = data;
+      events.emit(`${channel}:reply:${params.requestId}`, reply);
+    } catch (err: any) {
+      events.emit(`${channel}:reply:${params.requestId}`, {
+        success: false, error: err?.message ?? String(err),
+      });
+    }
+  });
+}
+
+/**
+ * Register ping, spawn, and stop RPC handlers on the event bus.
  * Returns unsub functions for cleanup.
  */
 export function registerRpcHandlers(deps: RpcDeps): RpcHandle {
   const { events, pi, getCtx, manager } = deps;
 
-  const unsubPing = events.on("subagents:rpc:ping", (raw: unknown) => {
-    const { requestId } = raw as { requestId: string };
-    events.emit(`subagents:rpc:ping:reply:${requestId}`, {});
+  const unsubPing = handleRpc(events, "subagents:rpc:ping", () => {
+    return { version: PROTOCOL_VERSION };
   });
 
-  const unsubSpawn = events.on("subagents:rpc:spawn", async (raw: unknown) => {
-    const { requestId, type, prompt, options } = raw as {
-      requestId: string; type: string; prompt: string; options?: any;
-    };
-    const ctx = getCtx();
-    if (!ctx) {
-      events.emit(`subagents:rpc:spawn:reply:${requestId}`, { error: "No active session" });
-      return;
-    }
-    try {
-      const id = manager.spawn(pi, ctx, type, prompt, options ?? {});
-      events.emit(`subagents:rpc:spawn:reply:${requestId}`, { id });
-    } catch (err: any) {
-      events.emit(`subagents:rpc:spawn:reply:${requestId}`, { error: err.message });
-    }
-  });
+  const unsubSpawn = handleRpc<{ requestId: string; type: string; prompt: string; options?: any }>(
+    events, "subagents:rpc:spawn", ({ type, prompt, options }) => {
+      const ctx = getCtx();
+      if (!ctx) throw new Error("No active session");
+      return { id: manager.spawn(pi, ctx, type, prompt, options ?? {}) };
+    },
+  );
+
+  const unsubStop = handleRpc<{ requestId: string; agentId: string }>(
+    events, "subagents:rpc:stop", ({ agentId }) => {
+      if (!manager.abort(agentId)) throw new Error("Agent not found");
+    },
+  );
 
-  return { unsubPing, unsubSpawn };
+  return { unsubPing, unsubSpawn, unsubStop };
 }

package/src/index.ts

@@ -289,7 +289,7 @@ export default function (pi: ExtensionAPI) {
       content: notification + footer,
       display: true,
       details: buildNotificationDetails(record, 500, agentActivity.get(record.id)),
-    }, { deliverAs: "followUp" });
+    }, { deliverAs: "followUp", triggerTurn: true });
   }
 
   function sendIndividualNudge(record: AgentRecord) {
@@ -326,7 +326,7 @@ export default function (pi: ExtensionAPI) {
           content: `Background agent group completed: ${label}\n\n${notifications}\n\nUse get_subagent_result for full output.`,
           display: true,
           details,
-        }, { deliverAs: "followUp" });
+        }, { deliverAs: "followUp", triggerTurn: true });
       });
       widget.update();
     },
@@ -431,7 +431,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_switch", () => { manager.clearCompleted(); });
 
-  const { unsubPing: unsubPingRpc, unsubSpawn: unsubSpawnRpc } = registerRpcHandlers({
+  const { unsubPing: unsubPingRpc, unsubSpawn: unsubSpawnRpc, unsubStop: unsubStopRpc } = registerRpcHandlers({
     events: pi.events,
     pi,
     getCtx: () => currentCtx,
@@ -445,6 +445,7 @@ export default function (pi: ExtensionAPI) {
   // If the session is going down, there's nothing left to consume agent results.
   pi.on("session_shutdown", async () => {
     unsubSpawnRpc();
+    unsubStopRpc();
     unsubPingRpc();
     currentCtx = undefined;
     delete (globalThis as any)[MANAGER_KEY];

package/src/ui/conversation-viewer.ts

@@ -191,7 +191,7 @@ export class ConversationViewer implements Component {
         for (const c of msg.content) {
           if (c.type === "text" && c.text) textParts.push(c.text);
           else if (c.type === "toolCall") {
-            toolCalls.push((c as any).toolName ?? "unknown");
+            toolCalls.push((c as any).name ?? (c as any).toolName ?? "unknown");
           }
         }
         if (needsSeparator) lines.push(th.fg("dim", "───"));