@pi-archimedes/subagent 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/subagent",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -11,7 +11,7 @@
   ],
   "main": "./src/index.ts",
   "dependencies": {
-    "@pi-archimedes/core": "0.6.0"
+    "@pi-archimedes/core": "0.8.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",

package/src/compact.ts

@@ -7,46 +7,61 @@ type RenderContext = { state: Record<string, unknown>; invalidate: () => void };
 
 // ── Activity line builder ───────────────────────────────────────────────────
 
+interface ActivityData {
+  currentTool: string | undefined;
+  currentToolArgs: string | undefined;
+  currentToolStartedAt: number | undefined;
+  finalOutput: string | undefined;
+  status: "running" | "completed" | "failed" | undefined;
+  error: string | undefined;
+  toolCalls?: string[] | undefined;
+}
+
 export function buildActivityLine(
-  progress: {
-    currentTool: string | undefined;
-    currentToolArgs: string | undefined;
-    currentToolStartedAt: number | undefined;
-    finalOutput: string | undefined;
-    status: "running" | "completed" | "failed" | undefined;
-    error: string | undefined;
-  },
+  data: ActivityData,
   theme: Theme,
 ): string {
-  const prefix = theme.fg("dim", "  ⎿  ");
-
-  if (progress.error) {
-    return prefix + theme.fg("error", truncLine(progress.error, 80));
+  if (data.error) {
+    return theme.fg("error", "✗ " + truncLine(data.error, 80));
   }
 
-  if (progress.currentTool) {
-    const argsPreview = progress.currentToolArgs
-      ? truncLine(progress.currentToolArgs ?? "", 60)
+  if (data.currentTool) {
+    const arrow = theme.fg("muted", "↳ ");
+    const argsPreview = data.currentToolArgs
+      ? truncLine(data.currentToolArgs ?? "", 60)
       : "";
-    const durationPart = progress.currentToolStartedAt
-      ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
+    const durationPart = data.currentToolStartedAt
+      ? " | " + formatDuration(Date.now() - data.currentToolStartedAt)
       : "";
-    let line = theme.fg("syntaxFunction", progress.currentTool);
+    let line = theme.fg("syntaxFunction", data.currentTool);
     if (argsPreview) {
       line += theme.fg("dim", ": " + argsPreview);
     }
     if (durationPart) {
       line += theme.fg("dim", durationPart);
     }
-    return prefix + line;
+    return arrow + line;
+  }
+
+  // Show last completed tool call from history
+  if (data.toolCalls && data.toolCalls.length > 0) {
+    const lastCall = data.toolCalls[data.toolCalls.length - 1];
+    if (lastCall) return theme.fg("muted", "↳ " + lastCall);
+  }
+
+  if (data.finalOutput) {
+    const firstLine = data.finalOutput.split("\n")[0] ?? "";
+    return theme.fg("muted", "↳ " + truncLine(firstLine, 80));
   }
 
-  if (progress.finalOutput) {
-    const firstLine = progress.finalOutput.split("\n")[0] ?? "";
-    return prefix + truncLine(firstLine, 80);
+  // Running with no tool info yet
+  if (data.status === "running") {
+    return theme.fg("muted", "↳ Starting...");
   }
 
-  return "";
+  return data.status === "completed"
+    ? theme.fg("success", "✓ Done")
+    : theme.fg("error", "✗ Failed");
 }
 
 // ── Status glyph ────────────────────────────────────────────────────────────
@@ -90,40 +105,18 @@ export function renderCompactSingle(
   };
   const statsLine = buildStatsLine(statsData, theme);
 
-  const statsPart = statsLine ?? "";
+  const statsPart = statsLine;
 
   // Activity: arrow + current tool if running, status if finished
-  let activityLine: string;
-  if (isRunning) {
-    const arrow = theme.fg("muted", "↳ ");
-    if (progress?.currentTool) {
-      const argsPreview = progress.currentToolArgs
-        ? truncLine(progress.currentToolArgs ?? "", 60)
-        : "";
-      const durationPart = progress.currentToolStartedAt
-        ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
-        : "";
-      let line = theme.fg("syntaxFunction", progress.currentTool);
-      if (argsPreview) {
-        line += theme.fg("dim", ": " + argsPreview);
-      }
-      if (durationPart) {
-        line += theme.fg("dim", durationPart);
-      }
-      activityLine = arrow + line;
-    } else if (progress?.toolCalls && progress.toolCalls.length > 0) {
-      const lastCall = progress.toolCalls[progress.toolCalls.length - 1];
-      activityLine = theme.fg("dim", "  ⎿  ") + theme.fg("muted", lastCall ?? "");
-    } else {
-      activityLine = theme.fg("muted", "  ⎿  Working...");
-    }
-  } else if (result.error) {
-    activityLine = theme.fg("error", "✗ " + truncLine(result.error, 80));
-  } else if (status === "completed") {
-    activityLine = theme.fg("success", "✓ Done");
-  } else {
-    activityLine = theme.fg("error", "✗ Failed");
-  }
+  const activityLine = buildActivityLine({
+    currentTool: progress?.currentTool,
+    currentToolArgs: progress?.currentToolArgs,
+    currentToolStartedAt: progress?.currentToolStartedAt,
+    finalOutput: result.finalOutput,
+    status: isRunning ? "running" : status,
+    error: result.error,
+    toolCalls: progress?.toolCalls,
+  }, theme);
 
   const modelName = progress?.model ?? result.model;
   const modelLabel = modelName
@@ -176,6 +169,7 @@ export function renderCompactParallel(
       finalOutput: result.finalOutput,
       status,
       error: result.error,
+      toolCalls: progress?.toolCalls,
     };
     const activityLine = buildActivityLine(activityData, theme);
 
@@ -228,42 +222,20 @@ export function renderCompactProgress(
   const statsLine = buildStatsLine(statsData, theme);
 
   // Activity: arrow + current tool if running, status if finished
-  let activityLine: string;
-  if (isRunning) {
-    const arrow = theme.fg("muted", "↳ ");
-    if (progress.currentTool) {
-      const argsPreview = progress.currentToolArgs
-        ? truncLine(progress.currentToolArgs ?? "", 60)
-        : "";
-      const durationPart = progress.currentToolStartedAt
-        ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
-        : "";
-      let line = theme.fg("syntaxFunction", progress.currentTool);
-      if (argsPreview) {
-        line += theme.fg("dim", ": " + argsPreview);
-      }
-      if (durationPart) {
-        line += theme.fg("dim", durationPart);
-      }
-      activityLine = arrow + line;
-    } else if (progress.toolCalls && progress.toolCalls.length > 0) {
-      const lastCall = progress.toolCalls[progress.toolCalls.length - 1];
-      activityLine = arrow + theme.fg("muted", lastCall ?? "");
-    } else {
-      activityLine = arrow + theme.fg("muted", "Working...");
-    }
-  } else if (progress.error) {
-    activityLine = theme.fg("error", "✗ " + truncLine(progress.error, 80));
-  } else if (status === "completed") {
-    activityLine = theme.fg("success", "✓ Done");
-  } else {
-    activityLine = theme.fg("error", "✗ Failed");
-  }
+  const activityLine = buildActivityLine({
+    currentTool: progress.currentTool,
+    currentToolArgs: progress.currentToolArgs,
+    currentToolStartedAt: progress.currentToolStartedAt,
+    finalOutput: undefined,
+    status,
+    error: progress.error,
+    toolCalls: progress.toolCalls,
+  }, theme);
 
   const modelLabel = progress.model
     ? theme.fg("accent", progress.model)
     : "";
-  const statsPart = statsLine ?? "";
+  const statsPart = statsLine;
   const expandHint = theme.fg("muted", "(ctrl+o)");
   let output = [modelLabel, statsPart, expandHint].filter(Boolean).join(" ");
   output += "\n" + activityLine;
@@ -309,6 +281,7 @@ export function renderCompactParallelProgress(
       finalOutput: undefined,
       status,
       error: progress.error,
+      toolCalls: progress.toolCalls,
     };
     const activityLine = buildActivityLine(activityData, theme);
 

package/src/execute.ts

@@ -21,20 +21,20 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
   const agentName = options.agent ?? "subagent";
   const startTime = Date.now();
 
-  const child = spawnSubagent({
-    task: options.task,
-    model: options.model,
-    cwd: options.cwd,
-    signal: options.signal,
-    agent: options.agentConfig,
-  });
-
   // Track previously emitted values to only emit deltas
   let lastEmittedInput = 0;
   let lastEmittedOutput = 0;
   let lastEmittedCost = 0;
 
   try {
+    const child = spawnSubagent({
+      task: options.task,
+      model: options.model,
+      cwd: options.cwd,
+      signal: options.signal,
+      agent: options.agentConfig,
+    });
+
     const result = await streamEvents(child, {
       agent: agentName,
       task: options.task,

package/src/handlers.ts

@@ -19,11 +19,14 @@ export function extractArgsPreview(args: unknown): string {
   if (args && typeof args === "object" && !Array.isArray(args)) {
     const obj = args as Record<string, unknown>;
     const keys = Object.keys(obj);
-    // Single-key object: just show the value
+    // Single-key object: show the value directly (or serialize if complex)
     if (keys.length === 1) {
       const v = obj[keys[0]!];
       if (typeof v === "string") return v.slice(0, ARGS_PREVIEW_MAX);
       if (typeof v === "number" || typeof v === "boolean") return String(v);
+      // Complex value (array/nested object) — serialize just this value
+      const serialized = JSON.stringify(v);
+      if (serialized) return serialized.slice(0, ARGS_PREVIEW_MAX);
     }
     // Multi-key: find the longest string value (likely the main payload)
     let best: string | undefined;
@@ -104,7 +107,7 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
     state.model = message.model as string;
   }
 
-  // Collect text output
+  // Collect text + thinking output
   const content = message.content as Array<Record<string, unknown>> | string | undefined;
   if (typeof content === "string" && content.trim()) {
     state.accumulatedOutput.push(content);
@@ -117,6 +120,11 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
         state.accumulatedOutput.push(text);
         const lines = text.split("\n").filter((l) => l.trim());
         state.recentOutput.push(...lines.slice(-10));
+      } else if (part.type === "thinking" && (part.thinking as string)?.trim()) {
+        const thinking = part.thinking as string;
+        state.accumulatedOutput.push(`[thinking] ${thinking.trim()}`);
+        const lines = thinking.split("\n").filter((l) => l.trim());
+        state.recentOutput.push(...lines.slice(-5).map((l) => `[thinking] ${l}`));
       }
     }
   }
@@ -139,26 +147,28 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
 }
 
 /**
- * Handle an agent_end event — collect all assistant text for final output.
+ * Handle an agent_end event — extract final output from the last assistant message.
  */
 export function handleAgentEnd(state: StreamState, event: JsonEvent): void {
   const messages = event.messages as Array<Record<string, unknown>> | undefined;
   if (!messages || messages.length === 0) return;
 
+  // Use only the last assistant message for final output
+  const lastAssistant = [...messages].reverse().find((m) => m.role === "assistant");
+  if (!lastAssistant) return;
+
   const allText: string[] = [];
-  for (const msg of messages) {
-    if (msg.role === "assistant") {
-      const content = msg.content as Array<Record<string, unknown>> | string | undefined;
-      if (typeof content === "string" && content.trim()) {
-        allText.push(content);
-      } else if (Array.isArray(content)) {
-        for (const part of content) {
-          if (part.type === "text" && (part.text as string)?.trim()) {
-            allText.push(part.text as string);
-          }
-        }
+  const content = lastAssistant.content as Array<Record<string, unknown>> | string | undefined;
+  if (typeof content === "string" && content.trim()) {
+    allText.push(content);
+  } else if (Array.isArray(content)) {
+    for (const part of content) {
+      if (part.type === "text" && (part.text as string)?.trim()) {
+        allText.push(part.text as string);
+      } else if (part.type === "thinking" && (part.thinking as string)?.trim()) {
+        allText.push(`[thinking] ${(part.thinking as string).trim()}`);
       }
     }
   }
-  state.finalOutput = allText.join("\n\n");
+  state.finalOutput = allText.length > 0 ? allText.join("\n\n") : undefined;
 }

package/src/spawn.ts

@@ -1,10 +1,21 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import { execSync } from "node:child_process";
-import { existsSync, writeFileSync, unlinkSync, mkdtempSync, rmdirSync } from "node:fs";
+import { existsSync, writeFileSync, unlinkSync, mkdtempSync, rmdirSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 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;
@@ -42,6 +53,7 @@ export function resolvePiCommand(): { command: string; args: string[] } {
 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 };
@@ -55,7 +67,10 @@ function cleanupTempFiles(dir: string | null, filePath: string | null): void {
     try { unlinkSync(filePath); } catch { /* ignore */ }
   }
   if (dir) {
-    try { rmdirSync(dir); } catch { /* ignore */ }
+    try {
+      rmdirSync(dir);
+      tempDirs.delete(dir);
+    } catch { /* leave in Set so exit handler can retry with rmSync */ }
   }
 }
 

package/src/stream.ts

@@ -25,10 +25,29 @@ export function streamEvents(
 ): Promise<SubagentResult> {
   return new Promise((resolve, reject) => {
     const startTime = Date.now();
-    const timeout = setTimeout(() => {
+
+    // 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.
+    const STARTUP_TIMEOUT_MS = 2 * 60 * 1000;
+
+    let startupTimer: NodeJS.Timeout | undefined = setTimeout(() => {
       child.kill("SIGKILL");
-      reject(new Error("subagent timed out after 5 minutes"));
-    }, 5 * 60 * 1000);
+      reject(new Error(
+        `subagent timed out: no model output within ${STARTUP_TIMEOUT_MS / 60_000} minutes of startup`,
+      ));
+    }, STARTUP_TIMEOUT_MS);
+
+    const clearStartupTimer = (): void => {
+      if (startupTimer) {
+        clearTimeout(startupTimer);
+        startupTimer = undefined;
+      }
+    };
 
     const state: StreamState = {
       toolCount: 0,
@@ -97,6 +116,10 @@ export function streamEvents(
         return; // Skip non-JSON lines
       }
 
+      // First event received from the child means the model has engaged —
+      // from here on, the user controls lifetime via the abort signal.
+      clearStartupTimer();
+
       switch (event.type) {
         case "tool_execution_start": {
           handleToolStart(state, event);
@@ -131,7 +154,7 @@ export function streamEvents(
 
     // Handle process exit
     child.on("close", (code) => {
-      clearTimeout(timeout);
+      clearStartupTimer();
       clearInterval(heartbeat);
       const durationMs = Date.now() - startTime;
       const exitCode = code ?? 1;
@@ -174,7 +197,7 @@ export function streamEvents(
     });
 
     child.on("error", (err) => {
-      clearTimeout(timeout);
+      clearStartupTimer();
       clearInterval(heartbeat);
       reject(err);
     });