@pi-archimedes/subagent 1.3.0 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/subagent",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -11,9 +11,10 @@
   ],
   "main": "./src/index.ts",
   "dependencies": {
-    "@pi-archimedes/core": "1.3.0"
+    "@pi-archimedes/core": "1.3.2"
   },
   "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.1.0",
     "@earendil-works/pi-coding-agent": ">=0.1.0",
     "@earendil-works/pi-tui": ">=0.1.0",
     "typebox": ">=1.1.0"
@@ -21,7 +22,7 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "typebox": "^1.1.38",
-    "typescript": "^6.0.0"
+    "typescript": "^6.0.3"
   },
   "pi": {
     "extensions": [

package/src/handlers.ts

@@ -67,20 +67,23 @@ export function handleToolEnd(state: StreamState): void {
 }
 
 /**
- * Handle a tool_result_end event — capture tool output for live display.
+ * Handle a tool_execution_end event — capture tool result output for live display.
+ * The result is in event.result (the tool's return value).
  */
 export function handleToolResult(state: StreamState, event: JsonEvent): void {
-  const toolMessage = event.message as Record<string, unknown> | undefined;
-  if (!toolMessage || toolMessage.role !== "toolResult") return;
+  const result = event.result as Record<string, unknown> | undefined;
+  if (!result) return;
 
-  const toolContent = toolMessage.content as Array<Record<string, unknown>> | string | undefined;
-  const toolName = (toolMessage.toolName as string) ?? "tool";
+  const toolName = (event.toolName as string) ?? "tool";
 
-  if (typeof toolContent === "string" && toolContent.trim()) {
-    const lines = toolContent.split("\n").filter((l) => l.trim());
+  // Extract text content from tool result
+  const content = result.content as Array<Record<string, unknown>> | string | undefined;
+
+  if (typeof content === "string" && content.trim()) {
+    const lines = content.split("\n").filter((l) => l.trim());
     state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, ARGS_PREVIEW_MAX)}`);
-  } else if (Array.isArray(toolContent)) {
-    for (const part of toolContent) {
+  } else if (Array.isArray(content)) {
+    for (const part of content) {
       if (part.type === "text" && (part.text as string)?.trim()) {
         const text = part.text as string;
         const lines = text.split("\n").filter((l) => l.trim());

package/src/index.ts

@@ -98,7 +98,7 @@ export function registerSubagent(pi: ExtensionAPI): void {
             agentConfig: t.agent ? findAgent(agents, t.agent) : undefined,
             task: t.task,
             model: t.model,
-            activeModel: ctx.model?.id,
+            activeModel: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
             cwd: t.cwd ?? undefined,
           })),
           signal: signal ?? undefined,
@@ -148,7 +148,7 @@ export function registerSubagent(pi: ExtensionAPI): void {
           agentConfig,
           task: params.task,
           model: params.model,
-          activeModel: ctx.model?.id,
+          activeModel: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
           cwd: params.cwd ?? undefined,
           signal: signal ?? undefined,
           onUpdate: (progress: SubagentProgress) => {

package/src/spawn.ts

@@ -1,23 +1,12 @@
 import { spawn, type ChildProcess } from "node:child_process";
-import { execSync } from "node:child_process";
-import { existsSync, writeFileSync, unlinkSync, mkdtempSync, rmdirSync, rmSync } from "node:fs";
-import { createServer, type Socket } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
 import { getBus, Events } from "@pi-archimedes/core/bus";
 import type { AgentConfig } from "./agents.js";
 
-// Track all temp dirs for cleanup on process exit (graceful shutdown only).
-// Note: SIGKILL/OOM cannot be caught — the exit handler only fires for
-// normal exits and catchable signals (SIGTERM, SIGINT, SIGHUP, etc.).
-const tempDirs = new Set<string>();
-
-process.on("exit", () => {
-  for (const dir of tempDirs) {
-    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-  }
-});
-
 export interface SpawnOptions {
   task: string;
   model: string | undefined;
@@ -28,209 +17,216 @@ export interface SpawnOptions {
 }
 
 /**
- * Resolve the `pi` command — finds it on PATH.
+ * Resolve the pi binary path.
+ *
+ * Walk up from process.argv[1] (the pi CLI entry point) looking for the
+ * @earendil-works/pi-coding-agent package root, then resolve its bin.pi field.
+ * Falls back to "pi" (PATH lookup) if resolution fails.
  */
-export function resolvePiCommand(): { command: string; args: string[] } {
-  let piPath: string;
+function resolvePiBinary(): string {
   try {
-    piPath = execSync(process.platform === "win32" ? 'where pi' : 'which pi', {
-      encoding: "utf-8",
-    }).trim();
-  } catch {
-    throw new Error("pi command not found on PATH. Is pi installed?");
-  }
-
-  // On Windows, the CLI might be a .cmd script
-  if (process.platform === "win32" && !piPath.endsWith(".cmd") && !piPath.endsWith(".exe")) {
-    const cmdPath = piPath + ".cmd";
-    if (existsSync(cmdPath)) {
-      return { command: "cmd", args: ["/c", cmdPath] };
+    const entry = process.argv[1];
+    if (!entry) return "pi";
+
+    let dir = path.dirname(fs.realpathSync(entry));
+    const root = path.parse(dir).root;
+
+    while (dir !== root) {
+      const pkgPath = path.join(dir, "package.json");
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as {
+          name?: string;
+          bin?: string | Record<string, string>;
+        };
+        if (pkg.name === "@earendil-works/pi-coding-agent") {
+          const binField = pkg.bin;
+          const binRelative =
+            typeof binField === "string"
+              ? binField
+              : binField?.pi ?? Object.values(binField ?? {})[0];
+          if (binRelative) {
+            const resolved = path.resolve(dir, binRelative);
+            if (fs.existsSync(resolved)) return resolved;
+          }
+          break;
+        }
+      } catch {
+        // package.json missing or invalid — keep walking
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
     }
+  } catch {
+    // fall through
   }
-  return { command: piPath, args: [] };
+  return "pi";
 }
 
 /**
- * Write system prompt to a temp file for --append-system-prompt.
+ * Start a Unix socket server that bridges the child's ask tool to the parent bus.
+ *
+ * The child's ask tool (in packages/ask) connects to PI_SUBAGENT_SOCKET and sends:
+ *   { type: "ask_request", requestId, questions } as a JSON line
+ * and waits for:
+ *   { type: "ask_response", requestId, cancelled, results } as a JSON line
+ *
+ * We forward the request onto the bus (ASK_REQUEST), the ask package shows the
+ * parent TUI dialog, then emits ASK_RESPONSE on the bus, and we write it back
+ * to the socket connection.
+ *
+ * Returns the socket path and a cleanup function.
  */
-function writePromptToFile(agentName: string, prompt: string): { dir: string; filePath: string } {
-  const safeName = agentName.replace(/[^\w.-]+/g, "_");
-  const tmpDir = mkdtempSync(join(tmpdir(), "pi-subagent-"));
-  tempDirs.add(tmpDir);
-  const filePath = join(tmpDir, `prompt-${safeName}.md`);
-  writeFileSync(filePath, prompt, { encoding: "utf-8" });
-  return { dir: tmpDir, filePath };
-}
-
-/**
- * Clean up temp prompt file and directory.
- */
-function cleanupTempFiles(dir: string | null, filePath: string | null): void {
-  if (filePath) {
-    try { unlinkSync(filePath); } catch { /* ignore */ }
-  }
-  if (dir) {
-    try {
-      rmdirSync(dir);
-      tempDirs.delete(dir);
-    } catch { /* leave in Set so exit handler can retry with rmSync */ }
-  }
-}
+function startAskSocketServer(agentName: string): { socketPath: string; cleanup: () => void } {
+  // Keep the socket path short — Linux limit is 108 chars.
+  const socketPath = path.join(os.tmpdir(), `pi-ask-${randomUUID().slice(0, 8)}.sock`);
+
+  // Map of pending ask requests: requestId → write-back callback
+  const pending = new Map<string, (response: unknown) => void>();
+
+  // Listen for ASK_RESPONSE from the bus and route back to the waiting socket conn
+  const unsubResponse = getBus().on(Events.ASK_RESPONSE, (payload: unknown) => {
+    const data = payload as {
+      requestId: string;
+      cancelled: boolean;
+      results: Array<{ id: string; selectedOptions: string[]; customInput?: string }>;
+    };
+    const send = pending.get(data.requestId);
+    if (send) {
+      pending.delete(data.requestId);
+      send({
+        type: "ask_response",
+        requestId: data.requestId,
+        cancelled: data.cancelled,
+        results: data.results,
+      });
+    }
+  });
 
-/**
- * Spawn a child `pi` process in JSON mode.
- */
-export function spawnSubagent(options: SpawnOptions): ChildProcess {
-  const { command, args: baseArgs } = resolvePiCommand();
-  const args: string[] = [
-    ...baseArgs,
-    "--mode", "json",
-    "-p",
-    "--no-session",
-  ];
-
-  // Create IPC socket for ask tool responses.
-  // On Unix: filesystem Unix domain socket. On Windows: named pipe (\\.\pipe\).
-  const socketName = `pi-subagent-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const socketPath = process.platform === "win32"
-    ? `\\\\.\\pipe\\${socketName}`
-    : join(tmpdir(), socketName);
-  // Only Unix socket files need pre-unlinking; Windows named pipes auto-clean.
-  if (process.platform !== "win32") {
-    try { unlinkSync(socketPath); } catch { /* doesn't exist yet */ }
-  }
-  let clientSocket: Socket | undefined;
-  const pendingAsks = new Map<string, Socket>();
-  const server = createServer((socket: Socket) => {
-    clientSocket = socket;
-    (child as ChildProcess & { clientSocket: Socket | undefined }).clientSocket = socket;
-    // Parse incoming lines from the child's ask tool (ask_request) and forward to bus
+  const server = net.createServer((socket) => {
     let buffer = "";
-    socket.on("data", (data: Buffer) => {
-      buffer += data.toString();
+
+    socket.on("data", (chunk: Buffer) => {
+      buffer += chunk.toString("utf-8");
       const lines = buffer.split("\n");
       buffer = lines.pop() ?? "";
+
       for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
         try {
-          const msg = JSON.parse(line);
-          if (msg.type === "ask_request" && msg.requestId) {
-            pendingAsks.set(msg.requestId, socket);
+          const msg = JSON.parse(trimmed) as {
+            type: string;
+            requestId: string;
+            questions: unknown[];
+          };
+          if (msg.type === "ask_request") {
+            // Register write-back so ASK_RESPONSE handler can find this socket
+            pending.set(msg.requestId, (response) => {
+              try {
+                socket.write(JSON.stringify(response) + "\n");
+              } catch {
+                // socket already closed
+              }
+            });
+            // Forward to bus — ask package will show the TUI dialog
             getBus().emit(Events.ASK_REQUEST, {
-              source: `subagent:${options.agent?.name ?? "general"}`,
+              source: `subagent:${agentName}`,
               requestId: msg.requestId,
               questions: msg.questions,
             });
           }
-        } catch { /* ignore non-JSON */ }
-      }
-    });
-    socket.on("close", () => {
-      clientSocket = undefined;
-      (child as ChildProcess & { clientSocket: Socket | undefined }).clientSocket = undefined;
-      // Clean up any pending asks tied to this socket
-      for (const [id, s] of pendingAsks) {
-        if (s === socket) pendingAsks.delete(id);
+        } catch {
+          // malformed JSON — ignore
+        }
       }
     });
+
+    socket.on("error", () => { /* connection dropped */ });
   });
-  server.listen(socketPath); // async, non-blocking
-
-  // Write ask responses back to the child over the originating socket
-  const unsubAskResponse = getBus().on(Events.ASK_RESPONSE, (payload: unknown) => {
-    const data = payload as { requestId: string; cancelled: boolean; results: Array<{ id: string; selectedOptions: string[]; customInput?: string }> };
-    const socket = pendingAsks.get(data.requestId);
-    if (socket && socket.writable) {
-      pendingAsks.delete(data.requestId);
-      socket.write(JSON.stringify({
-        type: "ask_response",
-        requestId: data.requestId,
-        cancelled: data.cancelled,
-        results: data.results,
-      }) + "\n");
-    }
-  });
-  server.on("close", () => {
-    if (process.platform !== "win32") {
-      try { unlinkSync(socketPath); } catch { /* ignore */ }
-    }
-  });
 
-  // Resolve model with correct priority:
-  // 1. frontmatter model (agent.model)
-  // 2. explicit tool-call model (options.model)
-  // 3. currently active model (options.activeModel)
-  // 4. no --model flag → pi default
-  const modelToUse = options.agent?.model ?? options.model ?? options.activeModel;
-  if (modelToUse) {
-    args.push("--model", modelToUse);
+  server.listen(socketPath);
+
+  const cleanup = () => {
+    unsubResponse();
+    server.close();
+    try { fs.unlinkSync(socketPath); } catch { /* already gone */ }
+  };
+
+  return { socketPath, cleanup };
+}
+
+/**
+ * Spawn a subagent as a fresh `pi --mode json --no-session -p <task>` process.
+ *
+ * A Unix socket server is started in the parent to bridge the child's ask tool
+ * back to the parent's TUI dialog. The socket path is passed via PI_SUBAGENT_SOCKET.
+ */
+export function spawnSubagent(options: SpawnOptions): ChildProcess {
+  const piBinary = resolvePiBinary();
+  const agentName = options.agent?.name ?? "general";
+
+  // Start ask bridge socket before spawning so the env var is ready
+  const { socketPath, cleanup: cleanupSocket } = startAskSocketServer(agentName);
+
+  // Build CLI args
+  const args: string[] = ["--mode", "json", "--no-session", "-p"];
+
+  // Model: agent.model > options.model > options.activeModel
+  const model = options.agent?.model ?? options.model ?? options.activeModel;
+  if (model) {
+    args.push("--model", model);
   }
 
-  // Apply other agent config options
-  if (options.agent) {
-    const agent = options.agent;
-    if (agent.thinking) {
-      args.push("--thinking", agent.thinking);
-    }
-    if (agent.tools && agent.tools.length > 0) {
-      args.push("--tools", agent.tools.join(","));
-    }
+  // Thinking level from agent config
+  if (options.agent?.thinking) {
+    args.push("--thinking", options.agent.thinking);
+  }
+
+  // Tool allowlist from agent config
+  if (options.agent?.tools && options.agent.tools.length > 0) {
+    args.push("--tools", options.agent.tools.join(","));
   }
 
-  // Temp files for system prompt
-  let tmpDir: string | null = null;
-  let tmpPath: string | null = null;
+  // Always exclude the subagent tool itself to prevent infinite recursion
+  args.push("--exclude-tools", "subagent");
 
-  if (options.agent && options.agent.systemPrompt.trim()) {
-    const tmp = writePromptToFile(options.agent.name, options.agent.systemPrompt);
-    tmpDir = tmp.dir;
-    tmpPath = tmp.filePath;
-    args.push("--append-system-prompt", tmpPath);
+  // Agent system prompt
+  const systemPrompt = options.agent?.systemPrompt?.trim();
+  if (systemPrompt) {
+    args.push("--system-prompt", systemPrompt);
   }
 
+  // The task is the final positional argument
   args.push(options.task);
 
-  const child = spawn(command, args, {
+  const child = spawn(piBinary, args, {
     cwd: options.cwd || process.cwd(),
-    stdio: ["ignore", "pipe", "pipe"],
     env: {
       ...process.env,
       PI_SUBAGENT_SOCKET: socketPath,
     },
+    stdio: ["ignore", "pipe", "pipe"],
   });
 
+  // Clean up socket server when child exits
+  child.on("exit", cleanupSocket);
+  child.on("error", cleanupSocket);
+
   // Handle abort signal
-  let abortHandler: (() => void) | undefined;
   if (options.signal) {
-    abortHandler = () => {
+    const abortHandler = () => {
       if (child.pid && !child.killed) {
         child.kill("SIGTERM");
         const forceKill = setTimeout(() => {
-          if (!child.killed) {
-            child.kill("SIGKILL");
-          }
+          if (!child.killed) child.kill("SIGKILL");
         }, 3000);
         forceKill.unref();
       }
     };
     options.signal.addEventListener("abort", abortHandler, { once: true });
+    child.on("exit", () => options.signal!.removeEventListener("abort", abortHandler));
   }
 
-  // Clean up temp files and listeners on exit
-  const exitCleanup = (): void => {
-    child.removeListener("exit", exitCleanup);
-    child.removeListener("error", exitCleanup);
-    if (abortHandler && options.signal) {
-      options.signal.removeEventListener("abort", abortHandler);
-    }
-    server.close();
-    unsubAskResponse();
-    if (clientSocket) clientSocket.destroy();
-    cleanupTempFiles(tmpDir, tmpPath);
-  };
-  child.on("exit", exitCleanup);
-  child.on("error", exitCleanup);
-
-  // Attach client socket reference to child for streamEvents
-  (child as ChildProcess & { clientSocket: Socket | undefined }).clientSocket = clientSocket;
   return child;
 }

package/src/stream.ts

@@ -18,7 +18,11 @@ export interface StreamCallbacks {
 }
 
 /**
- * Stream JSON events from a child pi process and build progress/result.
+ * Stream JSON events from a child `pi --mode json` process and build progress/result.
+ *
+ * The child writes one JSON object per line to stdout. We read each line via
+ * readline, parse it, and dispatch to the same handler functions used previously.
+ * stderr is drained silently (captured as the error string on non-zero exit).
  */
 export function streamEvents(
   child: ChildProcess,
@@ -27,20 +31,15 @@ export function streamEvents(
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
 
-    // Startup safeguard: if the child produces no JSON event within
-    // STARTUP_TIMEOUT_MS, kill it. This guards against hangs during pi
-    // initialization (model never loads, auth fails, etc.) and is the only
-    // automatic timeout. Once any event arrives the model is considered
-    // active and runtime is controlled entirely by the user's abort
-    // signal — a model that is REALLY thinking is left alone until the
-    // user explicitly cancels.
+    // Startup safeguard: if no JSON event arrives within 2 minutes, kill the child.
     const STARTUP_TIMEOUT_MS = 2 * 60 * 1000;
-
     let startupTimer: NodeJS.Timeout | undefined = setTimeout(() => {
       child.kill("SIGKILL");
-      reject(new Error(
-        `subagent timed out: no model output within ${STARTUP_TIMEOUT_MS / 60_000} minutes of startup`,
-      ));
+      reject(
+        new Error(
+          `subagent timed out: no output within ${STARTUP_TIMEOUT_MS / 60_000} minutes of startup`,
+        ),
+      );
     }, STARTUP_TIMEOUT_MS);
 
     const clearStartupTimer = (): void => {
@@ -67,9 +66,13 @@ export function streamEvents(
       toolCalls: [],
       finalOutput: undefined,
     };
+
+    // Collect stderr for error reporting
+    const stderrChunks: Buffer[] = [];
+    child.stderr?.on("data", (chunk: Buffer) => stderrChunks.push(chunk));
+
     let error: string | undefined;
 
-    // Build progress from state
     const buildProgress = (): SubagentProgress => ({
       agent: callbacks.agent ?? "subagent",
       status: "running",
@@ -84,48 +87,50 @@ export function streamEvents(
       cost: state.totalCost,
       durationMs: Date.now() - startTime,
       error,
-      output: state.accumulatedOutput.length > 0 ? state.accumulatedOutput.join("\n\n") : undefined,
+      output:
+        state.accumulatedOutput.length > 0
+          ? state.accumulatedOutput.join("\n\n")
+          : undefined,
       recentOutput: state.recentOutput.length > 0 ? state.recentOutput : undefined,
       toolCalls: state.toolCalls.length > 0 ? state.toolCalls : undefined,
       model: state.model,
     });
 
-    const emitProgress = () => {
-      callbacks.onProgress?.(buildProgress());
-    };
+    const emitProgress = () => callbacks.onProgress?.(buildProgress());
 
-    // Periodic progress updates for live duration display
+    // Periodic heartbeat for live duration display
     const heartbeat = setInterval(emitProgress, 1000);
 
-    // Collect stderr
-    const stderrParts: string[] = [];
-    child.stderr?.on("data", (data: Buffer) => {
-      stderrParts.push(data.toString());
-    });
+    // Read stdout as newline-delimited JSON
+    if (!child.stdout) {
+      clearStartupTimer();
+      clearInterval(heartbeat);
+      reject(new Error("subagent child has no stdout pipe"));
+      return;
+    }
 
-    // Parse JSON lines from stdout
-    const rl = createInterface({
-      input: child.stdout!,
-      crlfDelay: Infinity,
-    });
+    const rl = createInterface({ input: child.stdout, crlfDelay: Infinity });
+
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
 
-    rl.on("line", (line: string) => {
       let event: JsonEvent;
       try {
-        event = JSON.parse(line);
+        event = JSON.parse(trimmed) as JsonEvent;
       } catch {
-        return; // Skip non-JSON lines
+        // Non-JSON output — ignore (can happen from pi startup messages)
+        return;
       }
 
-      // First event received from the child means the model has engaged —
-      // from here on, the user controls lifetime via the abort signal.
+      // First real event means model has engaged — cancel startup watchdog
       clearStartupTimer();
 
       switch (event.type) {
         case "tool_execution_start": {
           handleToolStart(state, event);
           emitProgress();
-          // Forward manage_todo_list writes to the bus for parent widget
+          // Forward manage_todo_list writes to the parent's todo widget
           if (event.toolName === "manage_todo_list") {
             const args = event.args as Record<string, unknown> | undefined;
             const todoList = args?.todoList as Array<unknown> | undefined;
@@ -141,17 +146,14 @@ export function streamEvents(
         case "tool_execution_end": {
           handleToolEnd(state);
           emitProgress();
+          handleToolResult(state, event);
+          emitProgress();
           break;
         }
         case "turn_start": {
           state.turnCount++;
           break;
         }
-        case "tool_result_end": {
-          handleToolResult(state, event);
-          emitProgress();
-          break;
-        }
         case "message_end": {
           handleMessageEnd(state, event);
           emitProgress();
@@ -161,6 +163,7 @@ export function streamEvents(
           handleAgentEnd(state, event);
           break;
         }
+        // Ignore: session, agent_start, message_start, message_update, turn_end, tool_execution_update
       }
     });
 
@@ -171,8 +174,10 @@ export function streamEvents(
       const durationMs = Date.now() - startTime;
       const exitCode = code ?? 1;
 
-      if (stderrParts.length > 0 && exitCode !== 0) {
-        error = stderrParts.join("").trim();
+      // Surface stderr as error if the process failed and we have no other error
+      if (exitCode !== 0 && !error) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        if (stderr) error = stderr;
       }
 
       const result: SubagentResult = {
@@ -202,10 +207,9 @@ export function streamEvents(
         },
       };
 
-      // Final progress update
       callbacks.onProgress?.(result.progress!);
 
-      // Clear subagent todos from the bus on process exit
+      // Clear subagent todos from the bus on exit
       getBus().emit(Events.TODOS_CLEAR, {
         source: `subagent:${callbacks.agent ?? "general"}`,
       });