@pi-archimedes/subagent 0.3.2 → 0.4.0

package/package.json

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

package/src/compact.ts

@@ -9,12 +9,12 @@ type RenderContext = { state: Record<string, unknown>; invalidate: () => void };
 
 export function buildActivityLine(
   progress: {
-    currentTool?: string;
-    currentToolArgs?: string;
-    currentToolStartedAt?: number;
-    finalOutput?: string;
-    status?: "running" | "completed" | "failed";
-    error?: string;
+    currentTool: string | undefined;
+    currentToolArgs: string | undefined;
+    currentToolStartedAt: number | undefined;
+    finalOutput: string | undefined;
+    status: "running" | "completed" | "failed" | undefined;
+    error: string | undefined;
   },
   theme: Theme,
 ): string {
@@ -26,7 +26,7 @@ export function buildActivityLine(
 
   if (progress.currentTool) {
     const argsPreview = progress.currentToolArgs
-      ? truncLine(progress.currentToolArgs, 60)
+      ? truncLine(progress.currentToolArgs ?? "", 60)
       : "";
     const durationPart = progress.currentToolStartedAt
       ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
@@ -51,6 +51,8 @@ export function buildActivityLine(
 
 // ── Spinner helper ──────────────────────────────────────────────────────────
 
+const SPINNER_INTERVAL_MS = 80;
+
 function getSpinnerGlyph(agentName: string, isRunning: boolean, status: string, context: RenderContext): string {
   if (isRunning) {
     const timerKey = "_subagentTimer_" + agentName;
@@ -60,24 +62,33 @@ function getSpinnerGlyph(agentName: string, isRunning: boolean, status: string,
       const timer = setInterval(() => {
         context.state[frameKey] = ((context.state[frameKey] as number) + 1) % SPINNER_FRAMES.length;
         context.invalidate();
-      }, 80);
+      }, SPINNER_INTERVAL_MS);
       context.state[timerKey] = timer;
     }
-    return SPINNER_FRAMES[context.state[frameKey] as number];
+    return SPINNER_FRAMES[context.state[frameKey] as number]!;
   }
   return status === "completed" ? "✓" : "✗";
 }
 
-function cleanupTimer(agentName: string, context: RenderContext) {
+function cleanupTimer(agentName: string, context: RenderContext): void {
   const timerKey = "_subagentTimer_" + agentName;
   const frameKey = "_subagentFrame_" + agentName;
-  if (context.state[timerKey]) {
-    clearInterval(context.state[timerKey] as ReturnType<typeof setInterval>);
+  const timer = context.state[timerKey] as ReturnType<typeof setInterval> | undefined;
+  if (timer) {
+    clearInterval(timer);
     delete context.state[timerKey];
   }
   delete context.state[frameKey];
 }
 
+/** Cleanup ALL timers for a given agent — idempotent. */
+function cleanupAllTimers(agentName: string, context: RenderContext): void {
+  cleanupTimer(agentName, context);
+  // Also clean up start time tracker
+  const timeKey = "_subagentStartTime_" + agentName;
+  delete context.state[timeKey];
+}
+
 // ── Compact single agent ────────────────────────────────────────────────────
 
 export function renderCompactSingle(
@@ -92,23 +103,20 @@ export function renderCompactSingle(
   const isRunning = progress?.status === "running";
   const status = isRunning ? "running" : (result.exitCode === 0 ? "completed" : "failed");
 
-  // Manage timer for spinner on line 3
+  // Manage timer for spinner
   if (isRunning) {
     getSpinnerGlyph(agentName, true, "running", context);
   } else {
-    cleanupTimer(agentName, context);
+    cleanupAllTimers(agentName, context);
   }
 
   // Track start time for live duration
   const timeKey = "_subagentStartTime_" + agentName;
-  if (isRunning && !context.state[timeKey]) {
+  if (isRunning && context.state[timeKey] === undefined) {
     // Estimate start time from current duration
     const currentDuration = summary.durationMs || (progress?.durationMs ?? 0);
     context.state[timeKey] = Date.now() - currentDuration;
   }
-  if (!isRunning) {
-    delete context.state[timeKey];
-  }
   const liveDuration = isRunning && context.state[timeKey]
     ? Date.now() - (context.state[timeKey] as number)
     : summary.durationMs;
@@ -128,10 +136,10 @@ export function renderCompactSingle(
   let activityLine: string;
   if (isRunning) {
     const spinner = SPINNER_FRAMES[(context.state["_subagentFrame_" + agentName] as number) ?? 0];
-    const spinnerColored = theme.fg("muted", spinner);
+    const spinnerColored = theme.fg("muted", spinner ?? "");
     if (progress?.currentTool) {
       const argsPreview = progress.currentToolArgs
-        ? truncLine(progress.currentToolArgs, 60)
+        ? truncLine(progress.currentToolArgs ?? "", 60)
         : "";
       const durationPart = progress.currentToolStartedAt
         ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
@@ -146,7 +154,7 @@ export function renderCompactSingle(
       activityLine = spinnerColored + " " + 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);
+      activityLine = theme.fg("dim", "  ⎿  ") + theme.fg("muted", lastCall ?? "");
     } else {
       activityLine = theme.fg("muted", "  ⎿  Working...");
     }
@@ -182,9 +190,17 @@ export function renderCompactParallel(
     const progress = details.progress?.[i];
     const agentName = result.agent ?? "agent-" + i;
     const summary = result.progressSummary ?? { toolCount: 0, tokens: 0, durationMs: 0 };
+    const isRunning = progress?.status === "running";
     const status = progress?.status ?? (result.exitCode === 0 ? "completed" : "failed");
 
-    let glyph = status === "completed" ? "✓" : status === "failed" ? "✗" : "⠋";
+    // Use animated spinner for running agents
+    let glyph: string;
+    if (isRunning) {
+      glyph = getSpinnerGlyph(agentName, true, "running", context);
+    } else {
+      cleanupTimer(agentName, context);
+      glyph = status === "completed" ? "✓" : "✗";
+    }
     const glyphColored = status === "completed"
       ? theme.fg("success", glyph)
       : status === "failed"
@@ -243,13 +259,13 @@ export function renderCompactProgress(
 
   // Track start time for live duration
   const timeKey = "_subagentStartTime_" + agentName;
-  if (isRunning && !context.state[timeKey]) {
+  if (isRunning && context.state[timeKey] === undefined) {
     context.state[timeKey] = Date.now() - (progress.durationMs ?? 0);
   }
   if (!isRunning) {
-    delete context.state[timeKey];
+    cleanupAllTimers(agentName, context);
   }
-  const liveDuration = isRunning && context.state[timeKey]
+  const liveDuration = isRunning && context.state[timeKey] !== undefined
     ? Date.now() - (context.state[timeKey] as number)
     : progress.durationMs;
 
@@ -266,10 +282,10 @@ export function renderCompactProgress(
   let activityLine: string;
   if (isRunning) {
     const spinner = SPINNER_FRAMES[(context.state["_subagentFrame_" + agentName] as number) ?? 0];
-    const spinnerColored = theme.fg("muted", spinner);
+    const spinnerColored = theme.fg("muted", spinner ?? "");
     if (progress.currentTool) {
       const argsPreview = progress.currentToolArgs
-        ? truncLine(progress.currentToolArgs, 60)
+        ? truncLine(progress.currentToolArgs ?? "", 60)
         : "";
       const durationPart = progress.currentToolStartedAt
         ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
@@ -284,7 +300,7 @@ export function renderCompactProgress(
       activityLine = spinnerColored + " " + line;
     } else if (progress.toolCalls && progress.toolCalls.length > 0) {
       const lastCall = progress.toolCalls[progress.toolCalls.length - 1];
-      activityLine = spinnerColored + " " + theme.fg("muted", lastCall);
+      activityLine = spinnerColored + " " + theme.fg("muted", lastCall ?? "");
     } else {
       activityLine = spinnerColored + " " + theme.fg("muted", "Working...");
     }

package/src/execute.ts

@@ -4,12 +4,12 @@ import { emitCostUpdate } from "./cost.js";
 import type { SubagentProgress, SubagentResult, SubagentUsage } from "./types.js";
 
 export interface ExecuteOptions {
-  agent?: string;
+  agent: string | undefined;
   task: string;
-  model?: string;
-  cwd?: string;
-  signal?: AbortSignal;
-  onUpdate?: (progress: SubagentProgress) => void;
+  model: string | undefined;
+  cwd: string | undefined;
+  signal: AbortSignal | undefined;
+  onUpdate: ((progress: SubagentProgress) => void) | undefined;
 }
 
 /**
@@ -80,7 +80,10 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
         cost: 0,
         turns: 0,
       } as SubagentUsage,
+      model: undefined,
+      finalOutput: undefined,
       error: err instanceof Error ? err.message : String(err),
+      progress: undefined,
       progressSummary: { toolCount: 0, tokens: 0, durationMs: Date.now() - startTime },
     };
   }
@@ -90,19 +93,23 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
  * Execute multiple subagents in parallel.
  */
 export async function executeParallel(options: {
-  tasks: Array<{ agent?: string; task: string; count?: number; model?: string; cwd?: string }>;
-  signal?: AbortSignal;
-  onUpdate?: (progress: SubagentProgress[]) => void;
+  tasks: Array<{ agent: string | undefined; task: string; model: string | undefined; cwd: string | undefined }>;
+  signal: AbortSignal | undefined;
+  onUpdate: ((progress: SubagentProgress[]) => void) | undefined;
 }): Promise<SubagentResult[]> {
+  // Collect latest progress per agent for aggregated reporting
+  const latestProgress = new Map<string, SubagentProgress>();
+
   const results = await Promise.all(
     options.tasks.map((taskDef) =>
       executeSubagent({
         ...taskDef,
         signal: options.signal,
         onUpdate: (progress: SubagentProgress) => {
-          // Collect all parallel progress updates
-          // This is a simplified approach — each task fires independently
-          options.onUpdate?.([progress]);
+          // Store latest progress keyed by agent name
+          latestProgress.set(progress.agent, progress);
+          // Emit aggregated progress across ALL agents
+          options.onUpdate?.([...latestProgress.values()]);
         },
       }),
     ),

package/src/expanded.ts

@@ -88,6 +88,7 @@ export function renderProgressExpanded(
   // Stats line (same as compact view)
   const modelLabel = progress.model ? theme.fg("accent", progress.model) : "";
   const statsLine = buildStatsLine({
+    turns: undefined,
     toolCount: progress.toolCount,
     tokens: progress.tokens,
     durationMs: progress.durationMs,
@@ -160,6 +161,7 @@ export function buildProgressExpandedText(
   // Stats line (same as compact view)
   const modelLabel = progress.model ? theme.fg("accent", progress.model) : "";
   const statsLine = buildStatsLine({
+    turns: undefined,
     toolCount: progress.toolCount,
     tokens: progress.tokens,
     durationMs: progress.durationMs,

package/src/format.ts

@@ -9,7 +9,8 @@ export function formatTokens(n: number): string {
 }
 
 export function formatDuration(ms: number): string {
-  if (ms < 1000) return "0s";
+  if (ms < 100) return "<0.1s";
+  if (ms < 1000) return (ms / 1000).toFixed(1) + "s";
   const seconds = Math.floor(ms / 1000);
   if (seconds < 60) return seconds + "s";
   const minutes = Math.floor(seconds / 60);
@@ -28,11 +29,11 @@ export function truncLine(text: string, width: number): string {
 }
 
 export interface StatsData {
-  turns?: number;
-  toolCount?: number;
-  tokens?: number;
-  durationMs?: number;
-  cost?: number;
+  turns: number | undefined;
+  toolCount: number | undefined;
+  tokens: number | undefined;
+  durationMs: number | undefined;
+  cost: number | undefined;
 }
 
 export interface StatsTheme {

package/src/handlers.ts

@@ -1,5 +1,10 @@
 import type { StreamState } from "./types.js";
 
+// Truncation limits for previews
+const ARGS_PREVIEW_MAX = 120;
+const TOOL_CALLS_MAX = 50;
+const RECENT_OUTPUT_MAX = 50;
+
 export interface JsonEvent {
   type: string;
   [key: string]: unknown;
@@ -10,14 +15,14 @@ export interface JsonEvent {
  * Generic: no hardcoded tool names.
  */
 export function extractArgsPreview(args: unknown): string {
-  if (typeof args === "string") return args.slice(0, 120);
+  if (typeof args === "string") return args.slice(0, ARGS_PREVIEW_MAX);
   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
     if (keys.length === 1) {
-      const v = obj[keys[0]];
-      if (typeof v === "string") return v.slice(0, 120);
+      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);
     }
     // Multi-key: find the longest string value (likely the main payload)
@@ -27,9 +32,10 @@ export function extractArgsPreview(args: unknown): string {
         best = v;
       }
     }
-    if (best) return best.slice(0, 120);
+    if (best) return best.slice(0, ARGS_PREVIEW_MAX);
   }
-  return JSON.stringify(args)?.slice(0, 120) ?? "";
+  const serialized = JSON.stringify(args);
+  return serialized?.slice(0, ARGS_PREVIEW_MAX) ?? "";
 }
 
 /**
@@ -43,8 +49,8 @@ export function handleToolStart(state: StreamState, event: JsonEvent): void {
   // Record tool call with args preview
   const argsPreview = extractArgsPreview(event.args);
   state.toolCalls.push(`${state.currentTool}: ${argsPreview}`);
-  if (state.toolCalls.length > 50) {
-    state.toolCalls.splice(0, state.toolCalls.length - 50);
+  if (state.toolCalls.length > TOOL_CALLS_MAX) {
+    state.toolCalls.splice(0, state.toolCalls.length - TOOL_CALLS_MAX);
   }
 }
 
@@ -69,20 +75,20 @@ export function handleToolResult(state: StreamState, event: JsonEvent): void {
 
   if (typeof toolContent === "string" && toolContent.trim()) {
     const lines = toolContent.split("\n").filter((l) => l.trim());
-    state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, 120)}`);
+    state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, ARGS_PREVIEW_MAX)}`);
   } else if (Array.isArray(toolContent)) {
     for (const part of toolContent) {
       if (part.type === "text" && (part.text as string)?.trim()) {
         const text = part.text as string;
         const lines = text.split("\n").filter((l) => l.trim());
-        state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, 120)}`);
+        state.recentOutput.push(`[${toolName}] ${lines[0]?.slice(0, ARGS_PREVIEW_MAX)}`);
         break;
       }
     }
   }
 
-  if (state.recentOutput.length > 50) {
-    state.recentOutput.splice(0, state.recentOutput.length - 50);
+  if (state.recentOutput.length > RECENT_OUTPUT_MAX) {
+    state.recentOutput.splice(0, state.recentOutput.length - RECENT_OUTPUT_MAX);
   }
 }
 
@@ -115,9 +121,9 @@ export function handleMessageEnd(state: StreamState, event: JsonEvent): void {
     }
   }
 
-  // Cap recentOutput at 50 lines
-  if (state.recentOutput.length > 50) {
-    state.recentOutput.splice(0, state.recentOutput.length - 50);
+  // Cap recentOutput
+  if (state.recentOutput.length > RECENT_OUTPUT_MAX) {
+    state.recentOutput.splice(0, state.recentOutput.length - RECENT_OUTPUT_MAX);
   }
 
   // Extract usage (turnCount tracked via turn_start in stream.ts)

package/src/index.ts

@@ -15,7 +15,6 @@ import type {
 const TaskItem = Type.Object({
   agent: Type.Optional(Type.String()),
   task: Type.String(),
-  count: Type.Optional(Type.Number()),
   model: Type.Optional(Type.String()),
   cwd: Type.Optional(Type.String()),
 });
@@ -75,8 +74,13 @@ export function registerSubagent(pi: ExtensionAPI): void {
       // Parallel mode
       if (params.tasks && params.tasks.length > 0) {
         const results: SubagentResult[] = await executeParallel({
-          tasks: params.tasks,
-          signal,
+          tasks: params.tasks.map((t) => ({
+            agent: t.agent ?? undefined,
+            task: t.task,
+            model: t.model ?? undefined,
+            cwd: t.cwd ?? undefined,
+          })),
+          signal: signal ?? undefined,
           onUpdate: (progress: SubagentProgress[]) => {
             onUpdate?.({
               content: [],
@@ -102,11 +106,11 @@ export function registerSubagent(pi: ExtensionAPI): void {
       // Single mode
       if (params.task) {
         const result: SubagentResult = await executeSubagent({
-          agent: params.agent,
+          agent: params.agent ?? undefined,
           task: params.task,
-          model: params.model,
-          cwd: params.cwd,
-          signal,
+          model: params.model ?? undefined,
+          cwd: params.cwd ?? undefined,
+          signal: signal ?? undefined,
           onUpdate: (progress: SubagentProgress) => {
             onUpdate?.({
               content: [],
@@ -135,6 +139,7 @@ export function registerSubagent(pi: ExtensionAPI): void {
         details: {
           mode: "single",
           results: [],
+          progress: undefined,
         },
         isError: true,
       };

package/src/render.ts

@@ -40,7 +40,7 @@ export function renderSubagentResult(
   // ── Streaming progress (results empty but progress has data) ──────────
   if (details.results.length === 0 && details.progress && details.progress.length > 0) {
     if (details.progress.length === 1) {
-      return renderProgressUpdate(text, details.progress[0], expanded, theme, context);
+      return renderProgressUpdate(text, details.progress[0]!, expanded, theme, context);
     }
     return renderProgressUpdatesParallel(text, details, expanded, theme, context);
   }
@@ -52,7 +52,7 @@ export function renderSubagentResult(
 
   // ── Single agent ────────────────────────────────────────────────────────
   if (details.mode === "single" || details.results.length === 1) {
-    return renderSingleAgent(text, details.results[0], details.progress?.[0], expanded, theme, context);
+    return renderSingleAgent(text, details.results[0]!, details.progress?.[0], expanded, theme, context);
   }
 
   // ── Parallel agents ─────────────────────────────────────────────────────

package/src/spawn.ts

@@ -4,9 +4,9 @@ import { existsSync } from "node:fs";
 
 export interface SpawnOptions {
   task: string;
-  model?: string;
-  cwd?: string;
-  signal?: AbortSignal;
+  model: string | undefined;
+  cwd: string | undefined;
+  signal: AbortSignal | undefined;
 }
 
 /**
@@ -69,5 +69,13 @@ export function spawnSubagent(options: SpawnOptions): ChildProcess {
     options.signal.addEventListener("abort", cleanup, { once: true });
   }
 
+  // Clean up on normal exit to prevent forceKill firing after process ends
+  const exitCleanup = (): void => {
+    child.removeListener("exit", exitCleanup);
+    child.removeListener("error", exitCleanup);
+  };
+  child.on("exit", exitCleanup);
+  child.on("error", exitCleanup);
+
   return child;
 }

package/src/types.ts

@@ -11,24 +11,24 @@ export interface SubagentProgress {
   agent: string;
   status: "running" | "completed" | "failed";
   task: string;
-  currentTool?: string;
-  currentToolArgs?: string;
-  currentToolStartedAt?: number;
+  currentTool: string | undefined;
+  currentToolArgs: string | undefined;
+  currentToolStartedAt: number | undefined;
   toolCount: number;
   inputTokens: number;
   outputTokens: number;
   tokens: number;
   cost: number;
   durationMs: number;
-  error?: string;
+  error: string | undefined;
   /** Model used by the subagent */
-  model?: string;
+  model: string | undefined;
   /** Accumulated assistant text output during streaming */
-  output?: string;
+  output: string | undefined;
   /** Last N lines of assistant text for live display */
-  recentOutput?: string[];
+  recentOutput: string[] | undefined;
   /** History of tool calls: "toolName: args_preview" */
-  toolCalls?: string[];
+  toolCalls: string[] | undefined;
 }
 
 export interface SubagentResult {
@@ -36,11 +36,11 @@ export interface SubagentResult {
   task: string;
   exitCode: number;
   usage: SubagentUsage;
-  model?: string;
-  finalOutput?: string;
-  error?: string;
-  progress?: SubagentProgress;
-  progressSummary?: { toolCount: number; tokens: number; durationMs: number };
+  model: string | undefined;
+  finalOutput: string | undefined;
+  error: string | undefined;
+  progress: SubagentProgress | undefined;
+  progressSummary: { toolCount: number; tokens: number; durationMs: number } | undefined;
 }
 
 export interface SubagentToolResult {
@@ -52,7 +52,7 @@ export interface SubagentToolResult {
 export interface SubagentDetails {
   mode: "single" | "parallel";
   results: SubagentResult[];
-  progress?: SubagentProgress[];
+  progress: SubagentProgress[] | undefined;
 }
 
 /** Mutable state during streaming — shared between stream.ts and handlers.ts */