@mystilleef/pi-subagent 0.9.0 → 0.10.2

package/src/child/process.ts

@@ -17,19 +17,19 @@ import {
 import type { AgentConfig, ThinkingLevel } from "../agent/agents.js";
 import { getFinalOutput } from "../output/ui.js";
 import { makeToolPreview, renderToolActivity } from "../progress/progress.js";
+import { SENSITIVE_PATTERN } from "../progress/progress-format.js";
+import { isToolCallPart } from "../progress/progress-state.js";
 import {
-  isToolCallPart,
-  SENSITIVE_PATTERN,
-} from "../progress/progress-state.js";
-import type {
-  OnUpdateCallback,
-  SingleResult,
-  StreamingProgress,
-  SubagentDetails,
-  ToolActivity,
+  type OnUpdateCallback,
+  type SingleResult,
+  type StreamingProgress,
+  type SubagentDetails,
+  TOOL_RESULT_FAILED_MESSAGE,
+  type ToolActivity,
 } from "../shared/types.js";
 import {
   detectMessageError,
+  findLastAssistantTextMessage,
   getPiInvocation,
   getSubagentDepth,
   getSubagentRuntimeLimits,
@@ -46,7 +46,11 @@ import {
 } from "./child-events.js";
 import { appendSubagentResultContract } from "./prompt-contract.js";
 import {
+  acquireChildSleepInhibitor,
   getProcessTreeSpawnOptions,
+  isFinitePid,
+  makeHostSleepInhibitorAdapter,
+  type SleepInhibitorHandle,
   terminateChildProcess,
 } from "./termination.js";
 
@@ -73,10 +77,18 @@ export function resolveThinkingLevel(
   return { level: clamped, warning: mkWarning(clamped) };
 }
 
-export const TOOL_RESULT_FAILED_MESSAGE = "Subagent tool result failed.";
-
 type RuntimeLimits = ReturnType<typeof getSubagentRuntimeLimits>;
 type RuntimeResult = SingleResult & { messages: Message[] };
+type ChildModelSettings = {
+  provider?: string | undefined;
+  id?: string | undefined;
+};
+type SleepInhibitorAcquirer = (pid: number) => Promise<SleepInhibitorHandle>;
+
+type RunSingleAgentOptions = {
+  acquireSleepInhibitor?: SleepInhibitorAcquirer;
+  getOrchestratorPid?: () => unknown;
+};
 
 export class SubagentAbortError extends Error {
   readonly result: SingleResult;
@@ -142,6 +154,7 @@ function resolveContextWindowTokens(msg: Message): number | undefined {
       ? contextWindow
       : undefined;
   } catch {
+    /* model lookup failures return undefined to skip context window tracking */
     return;
   }
 }
@@ -153,6 +166,56 @@ function getAbortReason(signal: AbortSignal): string {
   return "abort";
 }
 
+const hostSleepInhibitorAdapter = makeHostSleepInhibitorAdapter();
+
+async function acquireDefaultSleepInhibitor(
+  pid: number,
+): Promise<SleepInhibitorHandle> {
+  return acquireChildSleepInhibitor(pid, hostSleepInhibitorAdapter);
+}
+
+async function acquireSubagentSleepInhibitor(
+  pid: number,
+  acquireSleepInhibitor: SleepInhibitorAcquirer,
+): Promise<SleepInhibitorHandle | undefined> {
+  try {
+    return await acquireSleepInhibitor(pid);
+  } catch {
+    /* acquisition failures degrade gracefully to no inhibitor */
+    return undefined;
+  }
+}
+
+function getValidatedOrchestratorPid(
+  options: RunSingleAgentOptions,
+): number | undefined {
+  try {
+    const pid = options.getOrchestratorPid
+      ? options.getOrchestratorPid()
+      : process.pid;
+    return isFinitePid(pid) ? pid : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+async function releaseSleepInhibitor(
+  handle: SleepInhibitorHandle | undefined,
+): Promise<void> {
+  if (!handle) return;
+  try {
+    await handle.release();
+  } catch {
+    /* release failures are non-fatal */
+  }
+}
+
+function startSleepInhibitorRelease(
+  acquisitionPromise: Promise<SleepInhibitorHandle | undefined>,
+): Promise<void> {
+  return acquisitionPromise.then(releaseSleepInhibitor, () => {});
+}
+
 function hasCompletedAgentOutput(result: RuntimeResult): boolean {
   if (result.finalOutput.trim()) return true;
   return result.messages.some(
@@ -241,13 +304,20 @@ async function waitForSubagentProcess(
 }
 
 function buildModelDisplay(
-  parentModel: { provider: string; id: string } | undefined,
+  effectiveModel: ChildModelSettings,
   thinking: ThinkingLevel,
 ): string | undefined {
-  if (parentModel) {
-    return `${parentModel.provider}/${parentModel.id}${thinking ? `:${thinking}` : ""}`;
+  const parts: string[] = [];
+  if (effectiveModel.provider) {
+    parts.push(effectiveModel.provider);
+  }
+  if (effectiveModel.id) {
+    parts.push(effectiveModel.id);
+  }
+  if (thinking) {
+    parts.push(thinking);
   }
-  return thinking ? `thinking:${thinking}` : undefined;
+  return parts.length > 0 ? parts.join(" ･ ") : undefined;
 }
 
 const EMPTY_USAGE = {
@@ -366,7 +436,7 @@ async function cleanupTempPrompt(tmpPrompt: TempPrompt): Promise<void> {
     await fs.promises.unlink(tmpPrompt.filePath);
     await fs.promises.rmdir(tmpPrompt.dir);
   } catch {
-    /* ignore */
+    /* temp file cleanup failures are non-fatal; OS will clean up eventually */
   }
 }
 
@@ -387,18 +457,7 @@ async function cleanupPromptSetupResult(
 }
 
 function findRecentMessagesAnchor(messages: Message[]): number {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const msg = messages[i];
-    if (
-      msg?.role === "assistant" &&
-      msg.content.some(
-        (c) => c.type === "text" && (c as { text?: string }).text?.trim(),
-      )
-    ) {
-      return i;
-    }
-  }
-  return -1;
+  return findLastAssistantTextMessage(messages);
 }
 
 function deriveStreamingProgress(messages: Message[]): StreamingProgress {
@@ -431,6 +490,63 @@ function sanitizeProgressPreview(preview: string, toolName: string): string {
   return SENSITIVE_PATTERN.test(preview) ? toolName : preview;
 }
 
+/**
+ * Merge incoming tool activity with existing progress activity.
+ * When tool names match, prefer richer inputSummary from incoming.
+ * Otherwise, replace entirely with incoming activity.
+ */
+function mergeToolActivity(
+  existing: ToolActivity | undefined,
+  incoming: ToolActivity,
+): ToolActivity {
+  if (existing && existing.toolName === incoming.toolName) {
+    const incomingSummary = incoming.inputSummary;
+    const preferIncoming =
+      incomingSummary && incomingSummary !== incoming.toolName;
+    return {
+      ...existing,
+      inputSummary: preferIncoming ? incomingSummary : existing.inputSummary,
+      instanceName: incoming.instanceName ?? existing.instanceName,
+      child: incoming.child ?? existing.child,
+    };
+  }
+  return incoming;
+}
+
+/**
+ * Apply tool activity and result completion updates to progress state.
+ * Handles merging of child events with parent activity tree.
+ */
+function applyActivityUpdates(
+  progress: StreamingProgress,
+  options: { toolActivity?: ToolActivity; toolResultCompleted?: boolean },
+  previousActivity?: ToolActivity,
+): void {
+  // Preserve stored activity tree for tool-result completion signals
+  // so the parent retains nested context until newer activity arrives
+  if (options.toolResultCompleted && previousActivity) {
+    progress.activeToolActivity = previousActivity;
+    const renderedText = renderToolActivity(previousActivity);
+    if (renderedText !== undefined) progress.activityText = renderedText;
+    else delete progress.activityText;
+  }
+  // Handle parsed tool activity from child events
+  // Merge with parent activity if this is a nested update
+  if (options.toolActivity) {
+    progress.activeToolActivity = mergeToolActivity(
+      progress.activeToolActivity,
+      options.toolActivity,
+    );
+    const renderedActivity = renderToolActivity(progress.activeToolActivity);
+    if (renderedActivity !== undefined)
+      progress.activityText = renderedActivity;
+    else delete progress.activityText;
+  }
+  if (options.toolResultCompleted) {
+    progress.toolResultCompleted = true;
+  }
+}
+
 export function makeEmitUpdate(
   result: RuntimeResult,
   onUpdate: OnUpdateCallback | undefined,
@@ -448,46 +564,12 @@ export function makeEmitUpdate(
     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;
-      const renderedText = renderToolActivity(progress.activeToolActivity);
-      if (renderedText !== undefined) progress.activityText = renderedText;
-      else delete progress.activityText;
-    }
-    // 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;
-      }
-      const renderedActivity = renderToolActivity(progress.activeToolActivity);
-      if (renderedActivity !== undefined)
-        progress.activityText = renderedActivity;
-      else delete progress.activityText;
-    }
-    if (options?.toolResultCompleted) {
-      progress.toolResultCompleted = true;
+    if (options) {
+      applyActivityUpdates(
+        progress,
+        options,
+        result.progress?.activeToolActivity,
+      );
     }
     result.progress = progress;
     onUpdate?.({
@@ -637,18 +719,30 @@ function setupAbortHandler(
   return onAbort;
 }
 
+function resolveEffectiveChildModelSettings(
+  agent: AgentConfig,
+  parentModel: ChildModelSettings | undefined,
+): ChildModelSettings {
+  return {
+    provider: agent.provider ?? parentModel?.provider,
+    id:
+      agent.model ??
+      (agent.provider === undefined ? parentModel?.id : undefined),
+  };
+}
+
 function buildPiArgs(
   agent: AgentConfig,
   task: string,
-  parentModel: { provider: string; id: string } | undefined,
+  effectiveModel: ChildModelSettings,
   thinking: ThinkingLevel,
   resolvedSkills: { args: string[] },
   tmpPrompt: { filePath: string } | null,
 ): string[] {
-  const args: string[] = ["--mode", "json", "-p", "--no-session"];
-  if (parentModel) {
-    args.push("--provider", parentModel.provider, "--model", parentModel.id);
-  }
+  const args: string[] = ["--mode", "json", "-p", "--no-session", "--approve"];
+  if (effectiveModel.provider && effectiveModel.id)
+    args.push("--provider", effectiveModel.provider);
+  if (effectiveModel.id) args.push("--model", effectiveModel.id);
   args.push("--thinking", thinking);
   if (agent.tools?.length) args.push("--tools", agent.tools.join(","));
   if (agent.skills) args.push("--no-skills", ...resolvedSkills.args);
@@ -722,7 +816,13 @@ async function finalizeResult(
   if (agentEndTimeoutExitCode !== undefined) {
     state.result.exitCode = agentEndTimeoutExitCode;
   }
-  if (state.wasAborted) throw new SubagentAbortError(state.result);
+  if (state.result.termination?.cancelReason === "agent_end_timeout") {
+    state.result.stderr = state.result.stderr.replace(/^Terminated\r?\n/gm, "");
+  }
+  if (state.wasAborted) {
+    state.result.stderr = "";
+    throw new SubagentAbortError(state.result);
+  }
   return state.result;
 }
 
@@ -750,9 +850,10 @@ export async function runSingleAgent(
     results: RuntimeResult[],
     options?: { includeMessages?: boolean; recentMessages?: Message[] },
   ) => SubagentDetails,
-  parentModel: { provider: string; id: string } | undefined,
+  parentModel: ChildModelSettings | undefined,
   parentThinking: ThinkingLevel,
   debugEventDiagnostics = false,
+  options: RunSingleAgentOptions = {},
 ): Promise<SingleResult> {
   const agent = agents.find((a) => a.name === agentName);
   if (!agent) return errorForUnknownAgent(agentName, agents, task);
@@ -768,14 +869,16 @@ export async function runSingleAgent(
     );
   }
   const requestedThinking = agent.thinking ?? parentThinking;
-  const { level: thinking, warning: thinkingWarning } = parentModel
-    ? resolveThinkingLevel(
-        requestedThinking,
-        parentModel.provider,
-        parentModel.id,
-      )
-    : { level: requestedThinking };
-  const modelDisplay = buildModelDisplay(parentModel, thinking);
+  const effectiveModel = resolveEffectiveChildModelSettings(agent, parentModel);
+  const { level: thinking, warning: thinkingWarning } =
+    effectiveModel.provider && effectiveModel.id
+      ? resolveThinkingLevel(
+          requestedThinking,
+          effectiveModel.provider,
+          effectiveModel.id,
+        )
+      : { level: requestedThinking };
+  const modelDisplay = buildModelDisplay(effectiveModel, thinking);
   const resolvedSkillsPromise: Promise<{ args: string[] } | { error: string }> =
     agent.skills
       ? resolveAgentSkillArgs(defaultCwd, agent.skills)
@@ -807,7 +910,7 @@ export async function runSingleAgent(
     const args = buildPiArgs(
       agent,
       task,
-      parentModel,
+      effectiveModel,
       thinking,
       resolvedSkills,
       tmpPrompt,
@@ -845,12 +948,21 @@ export async function runSingleAgent(
       () => clearGraceTimer(state),
       requestTermination,
     );
+    const orchestratorPid = getValidatedOrchestratorPid(options);
+    const sleepInhibitorPromise =
+      orchestratorPid !== undefined
+        ? acquireSubagentSleepInhibitor(
+            orchestratorPid,
+            options.acquireSleepInhibitor ?? acquireDefaultSleepInhibitor,
+          )
+        : Promise.resolve(undefined);
     try {
       state.result.exitCode = (await processDone) ?? 0;
       return await finalizeResult(state, startedAt);
     } finally {
       clearGraceTimer(state);
       if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+      void startSleepInhibitorRelease(sleepInhibitorPromise);
     }
   } finally {
     if (tmpPrompt) await cleanupTempPrompt(tmpPrompt);