@mystilleef/pi-subagent 0.8.0 → 0.10.1

package/src/child/process.ts

@@ -17,39 +17,43 @@ 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,
   resolveAgentSkillArgs,
   subagentDepthEnv,
   truncateOutput,
   writePromptToTempFile,
 } from "../shared/utils.js";
 import {
+  type ChildEventParseResult,
   type ChildKnownEvent,
   parseChildEventLine,
   TOOL_EXECUTION_UPDATE_EVENT,
 } from "./child-events.js";
 import { appendSubagentResultContract } from "./prompt-contract.js";
 import {
+  acquireChildSleepInhibitor,
   getProcessTreeSpawnOptions,
+  isFinitePid,
+  makeHostSleepInhibitorAdapter,
+  type SleepInhibitorHandle,
   terminateChildProcess,
 } from "./termination.js";
 
-const MAX_STDERR_BYTES = 10_000;
-const AGENT_END_GRACE_MS = 250;
 export function resolveThinkingLevel(
   requested: ThinkingLevel,
   provider: string,
@@ -73,15 +77,25 @@ export function resolveThinkingLevel(
   return { level: clamped, warning: mkWarning(clamped) };
 }
 
-const MAX_SUBAGENT_DEPTH = 3;
-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 {
-  constructor(public readonly result: SingleResult) {
+  readonly result: SingleResult;
+  constructor(result: SingleResult) {
     super("Subagent was aborted");
     this.name = "SubagentAbortError";
+    this.result = result;
   }
 }
 
@@ -91,6 +105,7 @@ type PromptSetupResult = { tmpPrompt: TempPrompt | null } | { error: unknown };
 
 interface SubagentState {
   result: RuntimeResult;
+  runtimeLimits: RuntimeLimits;
   spawnError?: Error;
   wasAborted: boolean;
   agentEndGraceTimer?: ReturnType<typeof setTimeout>;
@@ -99,30 +114,47 @@ interface SubagentState {
 
 function appendWithByteLimit(
   current: string,
-  data: string,
+  data: string | Buffer,
   max: number,
 ): string {
-  if (current.length >= max) return current;
-  return current + data.slice(0, max - current.length);
+  const currentBytes = Buffer.from(current, "utf-8");
+  if (currentBytes.length >= max) return current;
+  const incomingBytes = Buffer.isBuffer(data)
+    ? data
+    : Buffer.from(data, "utf-8");
+  const combined = Buffer.concat([currentBytes, incomingBytes]);
+  if (combined.length <= max) return combined.toString("utf-8");
+  return truncateValidUtf8(combined, max);
+}
+
+function truncateValidUtf8(buffer: Buffer, max: number): string {
+  let end = Math.min(max, buffer.length);
+  while (end > 0) {
+    const candidate = buffer.subarray(0, end).toString("utf-8");
+    if (!candidate.endsWith("�")) return candidate;
+    end -= 1;
+  }
+  return "";
 }
 
 /**
- * Attempts to resolve the context window token limit for a given message's model.
  * Rationale: Subagent usage reporting needs context window awareness to provide
  * meaningful "context full" indicators to the parent.
  */
 function resolveContextWindowTokens(msg: Message): number | undefined {
   const m = msg as unknown as Record<string, unknown>;
-  if (typeof m.provider !== "string" || typeof m.model !== "string") return;
+  if (typeof m["provider"] !== "string" || typeof m["model"] !== "string")
+    return;
   try {
     const contextWindow = getModel(
-      m.provider as never,
-      m.model as never,
+      m["provider"] as never,
+      m["model"] as never,
     )?.contextWindow;
     return Number.isFinite(contextWindow) && contextWindow > 0
       ? contextWindow
       : undefined;
   } catch {
+    /* model lookup failures return undefined to skip context window tracking */
     return;
   }
 }
@@ -134,11 +166,56 @@ function getAbortReason(signal: AbortSignal): string {
   return "abort";
 }
 
-/**
- * Verifies if the agent produced any textual output or final response.
- * Precondition: Called after process exit to distinguish between clean completion
- * and silent failures where the process exited 0 but did nothing.
- */
+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(
@@ -151,7 +228,6 @@ function hasCompletedAgentOutput(result: RuntimeResult): boolean {
 }
 
 /**
- * Determines the exit code for processes terminated via the agent_end timeout.
  * Rationale: `pi` processes in JSON mode might hang after finishing their task;
  * we force-kill them after a grace period and treat it as success (0) if they
  * actually produced output.
@@ -168,7 +244,6 @@ function getAgentEndTimeoutExitCode(
 }
 
 /**
- * Orchestrates the cleanup and exit code capture of a child process.
  * 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.
  */
@@ -229,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 = {
@@ -278,8 +360,9 @@ function accumulateUsage(result: RuntimeResult, msg: Message): void {
   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;
+  const ctxWindowTokens = resolveContextWindowTokens(msg);
+  if (ctxWindowTokens !== undefined)
+    result.usage.contextWindowTokens = ctxWindowTokens;
 }
 
 function addMessageToResult(result: RuntimeResult, msg: Message): void {
@@ -288,7 +371,7 @@ function addMessageToResult(result: RuntimeResult, msg: Message): void {
   if (msg.role === "toolResult" && msg.isError) {
     result.errorMessage ||= TOOL_RESULT_FAILED_MESSAGE;
   } else if (result.errorMessage === TOOL_RESULT_FAILED_MESSAGE) {
-    result.errorMessage = undefined;
+    delete result.errorMessage;
   }
   if (msg.role === "assistant") {
     accumulateUsage(result, msg);
@@ -336,13 +419,14 @@ function errorForDepthLimit(
   source: "user" | "project" | "unknown",
   task: string,
   depth: number,
+  maxDepth: number,
   model?: string,
 ): SingleResult {
   return createErrorResult(
     agentName,
     source,
     task,
-    `Subagent nesting limit reached (depth ${depth}/${MAX_SUBAGENT_DEPTH}).`,
+    `Subagent nesting limit reached (depth ${depth}/${maxDepth}).`,
     model,
   );
 }
@@ -352,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 */
   }
 }
 
@@ -373,26 +457,9 @@ 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);
 }
 
-/**
- * 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;
@@ -410,22 +477,76 @@ function deriveStreamingProgress(messages: Message[]): StreamingProgress {
       activeToolActivity = { toolName: part.name, inputSummary: preview };
     }
   }
+  const activityText = renderToolActivity(activeToolActivity);
   return {
     activeToolActivity,
-    activityText: renderToolActivity(activeToolActivity),
+    activityText,
     toolCalls,
     lastToolPreview,
   };
 }
 
-/**
- * Prevents leaking secrets in the CLI progress display.
- * Redacts values if the preview contains sensitive keywords.
- */
 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,
@@ -443,41 +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;
-      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;
+    if (options) {
+      applyActivityUpdates(
+        progress,
+        options,
+        result.progress?.activeToolActivity,
+      );
     }
     result.progress = progress;
     onUpdate?.({
@@ -515,7 +607,7 @@ function makeRequestTerminator(
 function clearGraceTimer(state: SubagentState): void {
   if (!state.agentEndGraceTimer) return;
   clearTimeout(state.agentEndGraceTimer);
-  state.agentEndGraceTimer = undefined;
+  delete state.agentEndGraceTimer;
 }
 
 function handleMessageEvent(
@@ -563,12 +655,25 @@ function handleAgentEndEvent(
   }
   if (state.agentEndGraceTimer || state.terminationPromise) return;
   state.agentEndGraceTimer = setTimeout(() => {
-    state.agentEndGraceTimer = undefined;
+    delete state.agentEndGraceTimer;
     void requestTermination("agent_end_timeout");
-  }, AGENT_END_GRACE_MS);
+  }, state.runtimeLimits.agentEndGraceMs);
   state.agentEndGraceTimer.unref?.();
 }
 
+function formatUnknownEventDiagnostic(
+  line: string,
+  parseResult: Exclude<ChildEventParseResult, { kind: "known" }>,
+): string {
+  if (parseResult.kind === "invalid" && !line.trim()) {
+    return "[pi-subagent:unknown-event] blank";
+  }
+  if (parseResult.kind === "invalid") {
+    return `[pi-subagent:unknown-event] malformed: ${line}`;
+  }
+  return `[pi-subagent:unknown-event] unknown: ${JSON.stringify(parseResult.event)}`;
+}
+
 function processEventLine(
   line: string,
   state: SubagentState,
@@ -577,9 +682,17 @@ function processEventLine(
     toolResultCompleted?: boolean;
   }) => void,
   requestTermination: (reason: string) => Promise<unknown>,
+  debugEventDiagnostics: boolean,
 ): void {
   const parseResult = parseChildEventLine(line);
-  if (parseResult.kind !== "known") return;
+  if (parseResult.kind !== "known") {
+    if (debugEventDiagnostics) {
+      process.stderr.write(
+        `${formatUnknownEventDiagnostic(line, parseResult)}\n`,
+      );
+    }
+    return;
+  }
   const { event } = parseResult;
   handleMessageEvent(event, state, emitUpdate);
   handleToolExecutionUpdateEvent(event, emitUpdate);
@@ -606,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);
-  }
+  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);
@@ -639,28 +764,35 @@ function setupChildProcess(
     toolResultCompleted?: boolean;
   }) => void,
   requestTermination: (reason: string) => Promise<unknown>,
+  debugEventDiagnostics: boolean,
 ): void {
   proc.once("error", (error) => {
     state.spawnError = error;
     state.result.stderr = appendWithByteLimit(
       state.result.stderr,
       error.message,
-      MAX_STDERR_BYTES,
+      state.runtimeLimits.maxStderrBytes,
     );
   });
   if (proc.stdout) {
     readline
       .createInterface({ input: proc.stdout })
       .on("line", (line) =>
-        processEventLine(line, state, emitUpdate, requestTermination),
+        processEventLine(
+          line,
+          state,
+          emitUpdate,
+          requestTermination,
+          debugEventDiagnostics,
+        ),
       );
   }
   if (proc.stderr) {
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       state.result.stderr = appendWithByteLimit(
         state.result.stderr,
-        data.toString(),
-        MAX_STDERR_BYTES,
+        data,
+        state.runtimeLimits.maxStderrBytes,
       );
     });
   }
@@ -684,13 +816,17 @@ 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;
 }
 
 /**
- * Executes a single subagent task.
- *
  * Rationale: Subagents run in isolated child processes to protect the parent's
  * context window and allow specialized system prompts/tools without polluting
  * the main conversation.
@@ -714,24 +850,35 @@ 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);
+  const runtimeLimits = getSubagentRuntimeLimits();
   const depth = getSubagentDepth();
-  if (depth >= MAX_SUBAGENT_DEPTH) {
-    return errorForDepthLimit(agentName, agent.source, task, depth);
+  if (depth >= runtimeLimits.maxDepth) {
+    return errorForDepthLimit(
+      agentName,
+      agent.source,
+      task,
+      depth,
+      runtimeLimits.maxDepth,
+    );
   }
   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)
@@ -754,6 +901,7 @@ export async function runSingleAgent(
   const startedAt = Date.now();
   const state: SubagentState = {
     result: initRuntimeResult(agentName, agent.source, task, modelDisplay),
+    runtimeLimits,
     wasAborted: false,
   };
   if (thinkingWarning) state.result.thinkingWarning = thinkingWarning;
@@ -762,7 +910,7 @@ export async function runSingleAgent(
     const args = buildPiArgs(
       agent,
       task,
-      parentModel,
+      effectiveModel,
       thinking,
       resolvedSkills,
       tmpPrompt,
@@ -787,19 +935,34 @@ export async function runSingleAgent(
       terminateOptions,
       state,
     );
-    setupChildProcess(proc, state, emitUpdate, requestTermination);
+    setupChildProcess(
+      proc,
+      state,
+      emitUpdate,
+      requestTermination,
+      debugEventDiagnostics,
+    );
     const onAbort = setupAbortHandler(
       signal,
       state,
       () => 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);