oira666_pi-subagent 0.3.15 → 0.3.16

package/README.md

@@ -171,12 +171,14 @@ semantics. Embedded hosts without a script entrypoint can use
 ## Subagent Liveness Timeouts
 
 A delegated process cannot block its parents forever. The runner applies a
-startup timeout before the first model turn and a semantic-inactivity timeout
-after startup. Tool/turn events and changed nested-agent state reset the idle
-timer; repeated unchanged progress heartbeats do not. On timeout or
-cancellation, the runner terminates the child process tree and bounds cleanup;
-even if a wedged OS process never reports `close`, the tool returns an error
-result so every waiting parent can settle.
+startup timeout before the first model turn and an agent-inactivity timeout
+after startup. The inactivity watchdog is paused while any tool call is in
+progress, so tool executions can run for unlimited time; a fresh full idle
+window starts after the last concurrent tool finishes. Agent/turn events and
+changed nested-agent state reset the idle timer; repeated unchanged progress
+heartbeats do not. On timeout or cancellation, the runner terminates the child
+process tree and bounds cleanup; even if a wedged OS process never reports
+`close`, the tool returns an error result so every waiting parent can settle.
 
 RPC completion is based on Pi's `agent_settled` event—not `agent_end`.
 `agent_end` is only a low-level run boundary and may be followed by Pi's normal
@@ -188,7 +190,7 @@ reported immediately as failures.
 | --- | --- | --- |
 | `PI_SUBAGENT_STARTUP_TIMEOUT` | `120000` | Milliseconds allowed to reach the first model turn; `0` disables |
 | `PI_SUBAGENT_STARTUP_RETRIES` | `2` | Fresh retries after a startup timeout |
-| `PI_SUBAGENT_IDLE_TIMEOUT` | `1200000` | Milliseconds without new semantic RPC activity after startup; `0` disables |
+| `PI_SUBAGENT_IDLE_TIMEOUT` | `1200000` | Milliseconds without agent activity after startup, excluding time spent in ongoing tool calls; `0` disables |
 
 ## Timestamps & Status Footer
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",

package/runner.ts

@@ -45,8 +45,9 @@ const RETRY_WAIT_GRACE_MS = 60_000;
 const DEFAULT_STARTUP_TIMEOUT_MS = 120_000; // only for startup (before first assistant turn)
 const SUBAGENT_STARTUP_TIMEOUT_ENV = "PI_SUBAGENT_STARTUP_TIMEOUT";
 // Once startup succeeds, a child can otherwise remain alive forever if Pi loses
-// the next model/RPC turn after a tool result. Bound semantic inactivity (not
-// repeated progress heartbeats) so every delegation eventually settles.
+// the next model/RPC turn after a tool result. Bound agent inactivity (not
+// repeated progress heartbeats), but never while one of its tools is executing:
+// tool runtimes are intentionally unbounded.
 const DEFAULT_IDLE_TIMEOUT_MS = 20 * 60_000;
 const SUBAGENT_IDLE_TIMEOUT_ENV = "PI_SUBAGENT_IDLE_TIMEOUT";
 // A startup timeout is almost always a transient cold-start stall (slow cli /
@@ -874,6 +875,10 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       let agentSettled = false;
       let forcedExitCode: number | undefined;
       let lastNestedProgressSignature: string | undefined;
+      // Track only tool calls from this process attempt. Persisted live render
+      // state may contain a tool that was interrupted before a resume and must
+      // not disable the new process's watchdog forever.
+      const activeToolCallIds = new Set<string>();
       let abortHandler: (() => void) | undefined;
       const promptRequestId = `pi-subagent-${process.pid}-${Date.now()}-${attempt}`;
       let steeringRequest = 0;
@@ -982,12 +987,18 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       })();
 
       const noteSemanticActivity = (minimumQuietPeriodMs = 0) => {
+        if (idleTimer) { clearTimeout(idleTimer); idleTimer = undefined; }
         if (!receivedFirstEvent || idleTimeoutMs === 0 || resolved) return;
-        if (idleTimer) clearTimeout(idleTimer);
+        // The idle timeout measures the agent itself, not tools it has invoked.
+        // A tool may legitimately be silent for longer than the configured
+        // timeout, so leave the watchdog disarmed until every concurrent tool
+        // execution has ended. tool_execution_end will call this again and
+        // start a fresh full inactivity window.
+        if (activeToolCallIds.size > 0) return;
         const quietPeriodMs = Math.max(idleTimeoutMs, minimumQuietPeriodMs);
         idleTimer = setTimeout(() => {
           if (resolved) return;
-          const message = `Subagent inactivity timeout: no new RPC activity for ${quietPeriodMs}ms.`;
+          const message = `Subagent inactivity timeout: no agent activity for ${quietPeriodMs}ms.`;
           forcedExitCode = 1;
           result.stopReason = "error";
           result.errorMessage = message;
@@ -1001,6 +1012,12 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
         let event: any;
         try { event = JSON.parse(line); } catch { event = null; }
 
+        if (event?.type === "tool_execution_start" && typeof event.toolCallId === "string") {
+          activeToolCallIds.add(event.toolCallId);
+        } else if (event?.type === "tool_execution_end" && typeof event.toolCallId === "string") {
+          activeToolCallIds.delete(event.toolCallId);
+        }
+
         if (
           event?.type === "response" &&
           event.id === promptRequestId &&