@mystilleef/pi-subagent 0.6.0 → 0.7.0

package/src/child/process.ts

@@ -16,13 +16,17 @@ import {
 } from "@earendil-works/pi-ai";
 import type { AgentConfig, ThinkingLevel } from "../agent/agents.js";
 import { getFinalOutput } from "../output/ui.js";
-import { makeToolPreview } from "../progress/progress.js";
-import { isToolCallPart } from "../progress/progress-state.js";
+import { makeToolPreview, renderToolActivity } from "../progress/progress.js";
+import {
+  isToolCallPart,
+  SENSITIVE_PATTERN,
+} from "../progress/progress-state.js";
 import type {
   OnUpdateCallback,
   SingleResult,
   StreamingProgress,
   SubagentDetails,
+  ToolActivity,
 } from "../shared/types.js";
 import {
   detectMessageError,
@@ -33,7 +37,11 @@ import {
   truncateOutput,
   writePromptToTempFile,
 } from "../shared/utils.js";
-import { parseChildEventLine } from "./child-events.js";
+import {
+  type ChildKnownEvent,
+  parseChildEventLine,
+  TOOL_EXECUTION_UPDATE_EVENT,
+} from "./child-events.js";
 import { appendSubagentResultContract } from "./prompt-contract.js";
 import {
   getProcessTreeSpawnOptions,
@@ -42,16 +50,6 @@ import {
 
 const MAX_STDERR_BYTES = 10_000;
 const AGENT_END_GRACE_MS = 250;
-
-function thinkingWarningFor(
-  requested: ThinkingLevel,
-  effective: ThinkingLevel,
-  provider: string,
-  modelId: string,
-): string {
-  return `Thinking level "${requested}" not supported by model "${provider}/${modelId}"; using "${effective}" instead`;
-}
-
 export function resolveThinkingLevel(
   requested: ThinkingLevel,
   provider: string,
@@ -59,11 +57,10 @@ export function resolveThinkingLevel(
 ): { level: ThinkingLevel; warning?: string } {
   const model = getModel(provider as never, modelId as never);
   if (!model) return { level: requested };
+  const mkWarning = (effective: ThinkingLevel) =>
+    `Thinking level "${requested}" not supported by model "${provider}/${modelId}"; using "${effective}" instead`;
   if (model.reasoning === false) {
-    return {
-      level: "off",
-      warning: thinkingWarningFor(requested, "off", provider, modelId),
-    };
+    return { level: "off", warning: mkWarning("off") };
   }
   if (!model.thinkingLevelMap) return { level: requested };
   const supported = getSupportedThinkingLevels(model);
@@ -73,17 +70,21 @@ export function resolveThinkingLevel(
     requested as ModelThinkingLevel,
   ) as ThinkingLevel;
   if (clamped === requested) return { level: requested };
-  return {
-    level: clamped,
-    warning: thinkingWarningFor(requested, clamped, provider, modelId),
-  };
+  return { level: clamped, warning: mkWarning(clamped) };
 }
 
-const MAX_SUBAGENT_DEPTH = 1;
+const MAX_SUBAGENT_DEPTH = 2;
 export const TOOL_RESULT_FAILED_MESSAGE = "Subagent tool result failed.";
 
 type RuntimeResult = SingleResult & { messages: Message[] };
 
+export class SubagentAbortError extends Error {
+  constructor(public readonly result: SingleResult) {
+    super("Subagent was aborted");
+    this.name = "SubagentAbortError";
+  }
+}
+
 type TempPrompt = { dir: string; filePath: string };
 
 type PromptSetupResult = { tmpPrompt: TempPrompt | null } | { error: unknown };
@@ -96,10 +97,6 @@ interface SubagentState {
   terminationPromise?: Promise<unknown>;
 }
 
-/**
- * Appends data to a string while ensuring the result does not exceed a maximum byte limit.
- * Used to prevent memory exhaustion when capturing child process stderr.
- */
 function appendWithByteLimit(
   current: string,
   data: string,
@@ -130,9 +127,6 @@ function resolveContextWindowTokens(msg: Message): number | undefined {
   }
 }
 
-/**
- * Normalizes AbortSignal reasons into human-readable strings.
- */
 function getAbortReason(signal: AbortSignal): string {
   const { reason } = signal;
   if (reason instanceof Error && reason.message) return reason.message;
@@ -178,6 +172,25 @@ function getAgentEndTimeoutExitCode(
  * Safety: Implements a dual-timer strategy (idle and hard) to ensure streams
  * are destroyed and promises settled even if the process or its pipes hang.
  */
+function createProcessCleanup(proc: ChildProcess, idleMs: number) {
+  let idleTimer: NodeJS.Timeout | undefined;
+  const destroyStreams = () => {
+    proc.stdout?.destroy();
+    proc.stderr?.destroy();
+  };
+  return {
+    armIdleTimer: () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(destroyStreams, idleMs);
+      idleTimer.unref?.();
+    },
+    clearIdleTimer: () => {
+      if (idleTimer) clearTimeout(idleTimer);
+    },
+    destroyStreams,
+  };
+}
+
 async function waitForSubagentProcess(
   proc: ChildProcess,
   idleMs = 100,
@@ -187,23 +200,13 @@ async function waitForSubagentProcess(
     let exitCode: number | null = null;
     let exited = false;
     let settled = false;
-    let idleTimer: NodeJS.Timeout | undefined;
+    const cleanup = createProcessCleanup(proc, idleMs);
     const done = () => {
       if (settled) return;
       settled = true;
-      if (idleTimer) clearTimeout(idleTimer);
+      cleanup.clearIdleTimer();
       resolve(exitCode);
     };
-    const destroyStreams = () => {
-      proc.stdout?.destroy();
-      proc.stderr?.destroy();
-    };
-    const armIdleTimer = () => {
-      if (!exited) return;
-      if (idleTimer) clearTimeout(idleTimer);
-      idleTimer = setTimeout(destroyStreams, idleMs);
-      idleTimer.unref?.();
-    };
     proc.on("close", done);
     proc.on("error", () => {
       exitCode = 1;
@@ -213,12 +216,15 @@ async function waitForSubagentProcess(
     proc.on("exit", (code) => {
       exitCode = code;
       exited = true;
-      armIdleTimer();
-      const hardTimer = setTimeout(destroyStreams, hardMs);
+      cleanup.armIdleTimer();
+      const hardTimer = setTimeout(cleanup.destroyStreams, hardMs);
       hardTimer.unref?.();
     });
-    proc.stdout?.on("data", armIdleTimer);
-    proc.stderr?.on("data", armIdleTimer);
+    const onStreamData = () => {
+      if (exited) cleanup.armIdleTimer();
+    };
+    proc.stdout?.on("data", onStreamData);
+    proc.stderr?.on("data", onStreamData);
   });
 }
 
@@ -232,6 +238,16 @@ function buildModelDisplay(
   return thinking ? `thinking:${thinking}` : undefined;
 }
 
+const EMPTY_USAGE = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  cost: 0,
+  contextTokens: 0,
+  turns: 0,
+};
+
 function initRuntimeResult(
   agentName: string,
   source: "user" | "project" | "unknown",
@@ -246,19 +262,26 @@ function initRuntimeResult(
     finalOutput: "",
     messages: [],
     stderr: "",
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      cost: 0,
-      contextTokens: 0,
-      turns: 0,
-    },
+    usage: { ...EMPTY_USAGE },
     model: modelDisplay,
   };
 }
 
+function accumulateUsage(result: RuntimeResult, msg: Message): void {
+  if (msg.role !== "assistant") return;
+  result.usage.turns++;
+  const { usage } = msg;
+  if (!usage) return;
+  result.usage.input += usage.input || 0;
+  result.usage.output += usage.output || 0;
+  result.usage.cacheRead += usage.cacheRead || 0;
+  result.usage.cacheWrite += usage.cacheWrite || 0;
+  result.usage.cost += usage.cost?.total || 0;
+  result.usage.contextTokens = usage.totalTokens || 0;
+  result.usage.contextWindowTokens =
+    resolveContextWindowTokens(msg) ?? result.usage.contextWindowTokens;
+}
+
 function addMessageToResult(result: RuntimeResult, msg: Message): void {
   result.messages.push(msg);
   result.finalOutput = truncateOutput(getFinalOutput(result.messages));
@@ -267,27 +290,14 @@ function addMessageToResult(result: RuntimeResult, msg: Message): void {
   } else if (result.errorMessage === TOOL_RESULT_FAILED_MESSAGE) {
     result.errorMessage = undefined;
   }
-  if (msg.role !== "assistant") return;
-  result.usage.turns++;
-  const { usage } = msg;
-  if (usage) {
-    result.usage.input += usage.input || 0;
-    result.usage.output += usage.output || 0;
-    result.usage.cacheRead += usage.cacheRead || 0;
-    result.usage.cacheWrite += usage.cacheWrite || 0;
-    result.usage.cost += usage.cost?.total || 0;
-    result.usage.contextTokens = usage.totalTokens || 0;
-    result.usage.contextWindowTokens =
-      resolveContextWindowTokens(msg) ?? result.usage.contextWindowTokens;
+  if (msg.role === "assistant") {
+    accumulateUsage(result, msg);
+    if (!result.model && msg.model) result.model = msg.model;
+    if (msg.stopReason) result.stopReason = msg.stopReason;
+    if (msg.errorMessage) result.errorMessage = msg.errorMessage;
   }
-  if (!result.model && msg.model) result.model = msg.model;
-  if (msg.stopReason) result.stopReason = msg.stopReason;
-  if (msg.errorMessage) result.errorMessage = msg.errorMessage;
 }
 
-/**
- * Standardized error result generator.
- */
 function createErrorResult(
   agent: string,
   source: "user" | "project" | "unknown",
@@ -302,15 +312,7 @@ function createErrorResult(
     exitCode: 1,
     finalOutput: "",
     stderr: error,
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      cost: 0,
-      contextTokens: 0,
-      turns: 0,
-    },
+    usage: { ...EMPTY_USAGE },
     model,
   };
 }
@@ -388,10 +390,13 @@ function findRecentMessagesAnchor(messages: Message[]): number {
 /**
  * Derives current execution progress from accumulated messages.
  * Maps tool calls to UI-safe previews for real-time feedback.
+ * Builds activeToolActivity from the most recent tool call, providing
+ * a compact parent summary for subagent tools before nested child data arrives.
  */
 function deriveStreamingProgress(messages: Message[]): StreamingProgress {
   const toolCalls: { id: string; preview: string }[] = [];
   let lastToolPreview: string | undefined;
+  let activeToolActivity: ToolActivity | undefined;
   for (const msg of messages) {
     if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
     for (const part of msg.content) {
@@ -402,9 +407,15 @@ function deriveStreamingProgress(messages: Message[]): StreamingProgress {
       );
       toolCalls.push({ id: part.id, preview });
       lastToolPreview = preview;
+      activeToolActivity = { toolName: part.name, inputSummary: preview };
     }
   }
-  return { activityText: lastToolPreview, toolCalls, lastToolPreview };
+  return {
+    activeToolActivity,
+    activityText: renderToolActivity(activeToolActivity),
+    toolCalls,
+    lastToolPreview,
+  };
 }
 
 /**
@@ -412,23 +423,62 @@ function deriveStreamingProgress(messages: Message[]): StreamingProgress {
  * Redacts values if the preview contains sensitive keywords.
  */
 function sanitizeProgressPreview(preview: string, toolName: string): string {
-  return /secret|token|password/i.test(preview) ? toolName : preview;
+  return SENSITIVE_PATTERN.test(preview) ? toolName : preview;
 }
 
-function makeEmitUpdate(
+export function makeEmitUpdate(
   result: RuntimeResult,
   onUpdate: OnUpdateCallback | undefined,
   makeDetails: (
     results: RuntimeResult[],
     options?: { includeMessages?: boolean; recentMessages?: Message[] },
   ) => SubagentDetails,
-): () => void {
-  return () => {
+): (options?: {
+  toolActivity?: ToolActivity;
+  toolResultCompleted?: boolean;
+}) => void {
+  return (options) => {
     const msgs = result.messages;
     const anchorIdx = findRecentMessagesAnchor(msgs);
     const recentMessages =
       anchorIdx >= 0 ? msgs.slice(anchorIdx) : msgs.slice(-5);
     const progress = deriveStreamingProgress(msgs);
+    // Preserve stored activity tree for tool-result completion signals
+    // so the parent retains nested context until newer activity arrives
+    if (options?.toolResultCompleted && result.progress?.activeToolActivity) {
+      progress.activeToolActivity = result.progress.activeToolActivity;
+      progress.activityText = renderToolActivity(progress.activeToolActivity);
+    }
+    // Handle parsed tool activity from child events
+    // Merge with parent activity if this is a nested update
+    if (options?.toolActivity) {
+      if (
+        progress.activeToolActivity &&
+        progress.activeToolActivity.toolName === options.toolActivity.toolName
+      ) {
+        // Merge: prefer parser inputSummary when non-empty and richer than bare toolName fallback
+        const incomingSummary = options.toolActivity.inputSummary;
+        const preferIncoming =
+          incomingSummary && incomingSummary !== options.toolActivity.toolName;
+        progress.activeToolActivity = {
+          ...progress.activeToolActivity,
+          inputSummary: preferIncoming
+            ? incomingSummary
+            : progress.activeToolActivity.inputSummary,
+          instanceName:
+            options.toolActivity.instanceName ??
+            progress.activeToolActivity.instanceName,
+          child:
+            options.toolActivity.child ?? progress.activeToolActivity.child,
+        };
+      } else {
+        progress.activeToolActivity = options.toolActivity;
+      }
+      progress.activityText = renderToolActivity(progress.activeToolActivity);
+    }
+    if (options?.toolResultCompleted) {
+      progress.toolResultCompleted = true;
+    }
     result.progress = progress;
     onUpdate?.({
       content: [
@@ -468,22 +518,42 @@ function clearGraceTimer(state: SubagentState): void {
   state.agentEndGraceTimer = undefined;
 }
 
-function processEventLine(
-  line: string,
+function handleMessageEvent(
+  event: ChildKnownEvent,
   state: SubagentState,
-  emitUpdate: () => void,
-  requestTermination: (reason: string) => Promise<unknown>,
+  emitUpdate: (options?: {
+    toolActivity?: ToolActivity;
+    toolResultCompleted?: boolean;
+  }) => void,
 ): void {
-  const parseResult = parseChildEventLine(line);
-  if (parseResult.kind !== "known") return;
-  const { event } = parseResult;
-  if (
-    (event.type === "message_end" || event.type === "tool_result_end") &&
-    event.message
-  ) {
+  if (event.type !== "message_end" && event.type !== "tool_result_end") return;
+  if (event.message) {
     addMessageToResult(state.result, event.message as Message);
-    emitUpdate();
+    const toolResultCompleted = event.type === "tool_result_end";
+    emitUpdate({ toolResultCompleted });
   }
+}
+
+function handleToolExecutionUpdateEvent(
+  event: ChildKnownEvent,
+  emitUpdate: (options?: {
+    toolActivity?: ToolActivity;
+    toolResultCompleted?: boolean;
+  }) => void,
+): void {
+  if (event.type !== TOOL_EXECUTION_UPDATE_EVENT) return;
+  emitUpdate({ toolActivity: event.toolActivity });
+}
+
+function handleAgentEndEvent(
+  event: ChildKnownEvent,
+  state: SubagentState,
+  emitUpdate: (options?: {
+    toolActivity?: ToolActivity;
+    toolResultCompleted?: boolean;
+  }) => void,
+  requestTermination: (reason: string) => Promise<unknown>,
+): void {
   if (event.type !== "agent_end") return;
   if (state.result.messages.length === 0 && Array.isArray(event.messages)) {
     for (const msg of event.messages as Message[]) {
@@ -499,6 +569,23 @@ function processEventLine(
   state.agentEndGraceTimer.unref?.();
 }
 
+function processEventLine(
+  line: string,
+  state: SubagentState,
+  emitUpdate: (options?: {
+    toolActivity?: ToolActivity;
+    toolResultCompleted?: boolean;
+  }) => void,
+  requestTermination: (reason: string) => Promise<unknown>,
+): void {
+  const parseResult = parseChildEventLine(line);
+  if (parseResult.kind !== "known") return;
+  const { event } = parseResult;
+  handleMessageEvent(event, state, emitUpdate);
+  handleToolExecutionUpdateEvent(event, emitUpdate);
+  handleAgentEndEvent(event, state, emitUpdate, requestTermination);
+}
+
 function setupAbortHandler(
   signal: AbortSignal | undefined,
   state: SubagentState,
@@ -547,7 +634,10 @@ function buildPiArgs(
 function setupChildProcess(
   proc: ChildProcess,
   state: SubagentState,
-  emitUpdate: () => void,
+  emitUpdate: (options?: {
+    toolActivity?: ToolActivity;
+    toolResultCompleted?: boolean;
+  }) => void,
   requestTermination: (reason: string) => Promise<unknown>,
 ): void {
   proc.once("error", (error) => {
@@ -594,7 +684,7 @@ async function finalizeResult(
   if (agentEndTimeoutExitCode !== undefined) {
     state.result.exitCode = agentEndTimeoutExitCode;
   }
-  if (state.wasAborted) throw new Error("Subagent was aborted");
+  if (state.wasAborted) throw new SubagentAbortError(state.result);
   return state.result;
 }
 
@@ -606,7 +696,7 @@ async function finalizeResult(
  * the main conversation.
  *
  * Safety:
- * - Enforces a strict recursion limit (depth 1) via environment variables.
+ * - Enforces a strict recursion limit (depth 2) via environment variables.
  * - Uses temporary prompt files to pass large system prompts without shell limits.
  * - Streams JSON events from the child to provide real-time UI updates to the parent.
  * - Implements aggressive process tree termination to prevent orphan processes.

package/src/index.ts

@@ -6,16 +6,17 @@ import {
   getCachedAgentCompletions,
   resetAgentDiscoveryCache,
 } from "./agent/agent-cache.js";
+import { isDirectoryAsync } from "./agent/agents.js";
 import { cancelSubagentCommandHandler } from "./orchestration/cancel-command.js";
 import { jobsCommandHandler } from "./orchestration/jobs-command.js";
 import { renderSubagentResultMessage } from "./orchestration/run.js";
 import { runCommandHandler } from "./orchestration/run-command.js";
 import {
-  formatStartJobStatus,
+  formatSubagentToolResult,
   SubagentParams,
   startSubagentJob,
 } from "./orchestration/subagent-orchestrator.js";
-import { renderSubagentCall, renderSubagentResult } from "./output/ui.js";
+import { renderSubagentCall, renderSubagentToolResult } from "./output/ui.js";
 import { renderSubagentProgress } from "./progress/progress.js";
 
 export { SubagentParams };
@@ -24,15 +25,40 @@ export function resetAgentCache() {
   resetAgentDiscoveryCache();
 }
 
+function normalizeWorkspaceRoot(cwd: string | undefined): string | undefined {
+  if (typeof cwd !== "string") return undefined;
+  const root = cwd.trim();
+  return root.length > 0 ? root : undefined;
+}
+
 export default function registerSubagentExtension(pi: ExtensionAPI) {
+  let activeWorkspaceRoot: string | undefined;
+  const setActiveWorkspaceRoot = (
+    cwd: string | undefined,
+    fallback?: string,
+  ) => {
+    activeWorkspaceRoot = normalizeWorkspaceRoot(cwd ?? fallback);
+  };
+  const getRunArgumentCompletions = async (prefix: string) => {
+    if (!activeWorkspaceRoot) return [];
+    if (!(await isDirectoryAsync(activeWorkspaceRoot))) return [];
+    return getCachedAgentCompletions(prefix, activeWorkspaceRoot);
+  };
+  pi.on("resources_discover", (event, ctx) => {
+    setActiveWorkspaceRoot(ctx.cwd, event.cwd);
+  });
+  pi.on("session_start", (_event, ctx) => {
+    setActiveWorkspaceRoot(ctx.cwd);
+  });
   pi.registerMessageRenderer("subagent-progress", renderSubagentProgress);
   pi.registerMessageRenderer("subagent-result", renderSubagentResultMessage);
   pi.registerCommand("run", {
     description: "Run a subagent directly: /run <agent> [task]",
-    getArgumentCompletions: (prefix: string) =>
-      getCachedAgentCompletions(prefix),
-    handler: async (args, ctx) =>
-      runCommandHandler(pi, ctx as ExtensionContext, args),
+    getArgumentCompletions: getRunArgumentCompletions,
+    handler: async (args, ctx) => {
+      setActiveWorkspaceRoot(ctx.cwd);
+      return runCommandHandler(pi, ctx as ExtensionContext, args);
+    },
   });
   pi.registerCommand("cancel-subagent", {
     description:
@@ -48,28 +74,21 @@ export default function registerSubagentExtension(pi: ExtensionAPI) {
     label: "Subagent",
     description: "Delegate a task to a subagent with isolated context.",
     parameters: SubagentParams,
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const result = await startSubagentJob(
         pi,
         ctx,
         params,
         signal ?? undefined,
+        onUpdate ?? undefined,
       );
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: formatStartJobStatus(params.agent, result),
-          },
-        ],
-        details: result.makeDetails([]),
-      };
+      return formatSubagentToolResult(params.agent, result);
     },
     renderCall(args, theme, _context) {
       return renderSubagentCall(args, theme);
     },
     renderResult(result, display, theme, _context) {
-      return renderSubagentResult(result, theme, display);
+      return renderSubagentToolResult(result, theme, display);
     },
   });
 }