pi-subagents 0.77.0 → 0.79.0

package/src/runs/foreground/execution.js

@@ -10,7 +10,7 @@ import { ensureArtifactsDir, formatOutputArtifactContent, getArtifactPaths, writ
 import { createChildTranscriptWriter } from "../../shared/child-transcript.js";
 import { DEFAULT_MAX_OUTPUT, INTERCOM_DETACH_REQUEST_EVENT, INTERCOM_DETACH_RESPONSE_EVENT, truncateOutput, } from "../../shared/types.js";
 import { DEFAULT_CONTROL_CONFIG, buildControlEvent, claimControlNotification, deriveActivityState, shouldEmitOpenToolAttention, shouldNotifyControlEvent, } from "../shared/subagent-control.js";
-import { getFinalOutput, findLatestSessionFile, detectSubagentError, hasEmptyTerminalAssistantResponse, formatEmptyTerminalAssistantResponseError, extractToolArgsPreview, extractTextFromContent, MAX_STREAMED_RECENT_TOOLS, boundStreamedRecentTools, boundStreamedRecentOutput, boundStreamedToolCalls, } from "../../shared/utils.js";
+import { getFinalOutput, findLatestSessionFile, detectSubagentError, hasEmptyTerminalAssistantResponse, formatEmptyTerminalAssistantResponseError, extractToolArgsPreview, assistantMessageError, extractTextFromContent, MAX_STREAMED_RECENT_TOOLS, boundStreamedRecentTools, boundStreamedRecentOutput, boundStreamedToolCalls, } from "../../shared/utils.js";
 import { resolveSkillsWithFallback } from "../../agents/skills.js";
 import { createPartialOutputTracker, formatPartialOutput } from "../shared/partial-output.js";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, resolveToolTimeoutMs, toolTimeoutCallKey, toolTimeoutFromEnv } from "../shared/tool-timeout.js";
@@ -18,7 +18,8 @@ import { preflightLaunchCwd } from "../shared/launch-cwd.js";
 import { createJsonlWriter } from "../../shared/jsonl-writer.js";
 import { createOrcaProgressTab } from "../shared/orca-progress-tabs.js";
 import { resolvePermissionRules } from "../shared/permissions.js";
-import { applyThinkingSuffix, deriveForkPromptCacheKey } from "../shared/child-tool-plan.js";
+import { applyThinkingSuffix, deriveForkPromptCacheKey, supervisorChannelDir } from "../shared/child-tool-plan.js";
+import { retainsChildCommand } from "../shared/child-commands.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
 import { qualifyModelWithProvider, resolveEffectiveThinking } from "../../shared/model-info.js";
@@ -29,7 +30,7 @@ import { formatChildToolDiagnostic } from "../shared/tool-availability.js";
 import { formatChildModelResolutionDiagnostic, formatInheritedProviderDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
 import { planAbortRecovery } from "../shared/abort-recovery.js";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.js";
-import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, hasSingleOutputChangedSinceSnapshot, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, hasSingleOutputChangedSinceSnapshot, isSettlementFatalOutputError, resolveSingleOutput, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import { formatSubagentModelVerificationError, isContextOverflow, resolveModelSelection, } from "../shared/model-resolution.js";
 import { createMutatingFailureState, didMutatingToolFail, isMutatingTool, nextLongRunningTrigger, recordMutatingFailure, resetMutatingFailureState, resolveCurrentPath, shouldEscalateMutatingFailures, summarizeRecentMutatingFailures, } from "../shared/long-running-guard.js";
 import { acceptanceFailureMessage, buildSkippedAcceptanceLedger, captureStagedIndexBaseline, evaluateAcceptance, formatAcceptancePrompt, resolveEffectiveAcceptance, stripAcceptanceReport, validateAcceptanceInput, typedVerifyOutput } from "../shared/acceptance.js";
@@ -485,8 +486,12 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 timeoutHardFinishTimer = undefined;
             }
         };
+        const startup = new AbortController();
         const abortChild = () => {
-            if (!session || sessionSettled || lifecycleFinished)
+            if (sessionSettled || lifecycleFinished)
+                return;
+            startup.abort();
+            if (!session)
                 return;
             void session.abort().catch(() => {
                 // The session settles through its prompt promise; abort failures are not separately actionable.
@@ -707,6 +712,9 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             return events;
         };
         let activeLongRunningNotified = false;
+        // Pi's parallel tool execution emits every tool_execution_start before the first result message,
+        // so results are matched to their call by toolCallId; the last-started slot covers events without one.
+        const pendingToolResultsByCallId = new Map();
         let pendingToolResult;
         let activeToolSequence = 0;
         const activeToolCalls = new Map();
@@ -792,6 +800,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 toolCount: progress.toolCount,
                 currentTool: input.currentTool ?? progress.currentTool,
                 toolCallId: input.toolCallId,
+                hasCommandController: input.hasCommandController,
                 currentToolDurationMs: input.currentToolDurationMs ?? currentToolDurationMs(now),
                 currentPath: input.currentPath ?? progress.currentPath,
                 recentFailureSummary: input.recentFailureSummary,
@@ -846,11 +855,13 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             if (toolAttentionTarget) {
                 toolAttentionTarget.attentionEmitted = true;
                 const durationMs = Math.max(0, now - toolAttentionTarget.startedAt);
+                const toolCallId = toolAttentionTarget.key.startsWith("id:") ? toolAttentionTarget.key.slice(3) : undefined;
                 return emitNeedsAttention(now, {
                     message: `${agent.name} has had tool '${toolAttentionTarget.tool}' open for ${Math.floor(durationMs / 1000)}s`,
                     reason: "tool_open_threshold",
                     currentTool: toolAttentionTarget.tool,
-                    toolCallId: toolAttentionTarget.key.startsWith("id:") ? toolAttentionTarget.key.slice(3) : undefined,
+                    toolCallId,
+                    hasCommandController: Boolean(toolCallId && retainsChildCommand(supervisorChannelDir(options.runId, agent.name, options.index ?? 0), toolCallId)),
                     currentPath: toolAttentionTarget.path,
                     currentToolDurationMs: durationMs,
                 });
@@ -980,10 +991,12 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 }
                 progress.toolCount++;
                 if (options.toolBudget) {
-                    result.toolBudget = toolBudgetState(options.toolBudget, progress.toolCount);
+                    result.toolBudget = toolBudgetState(options.toolBudget, progress.toolCount, result.toolBudget?.blockedTool);
                 }
                 const mutates = isMutatingTool(evt.toolName, toolArgs, agent.mutationTools);
                 pendingToolResult = { tool: evt.toolName ?? "tool", path: activeTool?.path, mutates, startedAt: now };
+                if (typeof evt.toolCallId === "string" && evt.toolCallId)
+                    pendingToolResultsByCallId.set(evt.toolCallId, pendingToolResult);
                 fireUpdate();
             }
             if (evt.type === "tool_execution_end") {
@@ -1043,7 +1056,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                         }
                     }
                     if (evt.message.errorMessage)
-                        assistantError = evt.message.errorMessage;
+                        assistantError = assistantMessageError(evt.message);
                     else if (hasToolCall && evt.message.stopReason === "toolUse") {
                         // A recovered request can finish via a terminating tool, without a text stop.
                         assistantError = undefined;
@@ -1062,59 +1075,50 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                         applyChildLifecycle(projectChildLifecycle(evt, true, childLifecycleState));
                     }
                 }
-                updateActivityState(now);
-                fireUpdate();
-            }
-            if (evt.type === "tool_result_end" && evt.message) {
-                const toolResultCompletion = {
-                    toolCallId: evt.message.toolCallId ?? evt.toolCallId,
-                    toolName: evt.message.toolName ?? evt.toolName,
-                };
-                clearActiveToolTimeout(toolResultCompletion);
-                const endedTool = removeActiveToolCall(toolResultCompletion);
-                if (endedTool) {
-                    progress.recentTools.push({
-                        tool: endedTool.tool,
-                        args: endedTool.args,
-                        endMs: now,
-                    });
-                    refreshCurrentTool();
-                }
-                result.messages.push(evt.message);
-                const resultText = extractTextFromContent(evt.message.content);
-                // The result event's own tool name is authoritative; the single pending slot can
-                // describe a different, overlapping call and serves only as a fallback.
-                const blockedTool = (typeof toolResultCompletion.toolName === "string" && toolResultCompletion.toolName.length > 0
-                    ? toolResultCompletion.toolName
-                    : undefined) ?? pendingToolResult?.tool;
-                if (options.toolBudget && isToolBudgetBlockedMessage(options.toolBudget, resultText, blockedTool)) {
-                    result.toolBudgetBlocked = true;
-                    result.toolBudget = toolBudgetState(options.toolBudget, Math.max(progress.toolCount, options.toolBudget.hard + 1), blockedTool);
-                }
-                appendRecentOutput(progress, resultText.split("\n").slice(-10));
-                const toolSnapshot = pendingToolResult;
-                pendingToolResult = undefined;
-                if (toolSnapshot?.mutates && didMutatingToolFail(resultText)) {
-                    recordMutatingFailure(mutatingFailures, {
-                        tool: toolSnapshot.tool,
-                        path: toolSnapshot.path,
-                        error: resultText.split("\n").find((line) => line.trim())?.trim().slice(0, 180) ?? "mutating tool failed",
-                        ts: now,
-                    }, mutatingFailureWindowMs);
-                    if (shouldEscalateMutatingFailures(mutatingFailures, controlConfig.failedToolAttemptsBeforeAttention)) {
-                        emitNeedsAttention(now, {
-                            message: `${agent.name} needs attention after repeated mutating tool failures`,
-                            reason: "tool_failures",
-                            currentTool: toolSnapshot.tool,
-                            currentPath: toolSnapshot.path,
-                            currentToolDurationMs: toolSnapshot.startedAt ? Math.max(0, now - toolSnapshot.startedAt) : undefined,
-                            recentFailureSummary: summarizeRecentMutatingFailures(mutatingFailures),
-                        });
+                // Pi delivers every tool result, including a call blocked by a tool_call handler, as a
+                // toolResult message after tool_execution_end; it emits no separate result event.
+                if (evt.message.role === "toolResult") {
+                    const resultText = extractTextFromContent(evt.message.content);
+                    const resultCallId = evt.message.toolCallId;
+                    const keyedSnapshot = typeof resultCallId === "string" ? pendingToolResultsByCallId.get(resultCallId) : undefined;
+                    if (keyedSnapshot)
+                        pendingToolResultsByCallId.delete(resultCallId);
+                    const toolSnapshot = keyedSnapshot ?? pendingToolResult;
+                    if (!keyedSnapshot || pendingToolResult === keyedSnapshot)
+                        pendingToolResult = undefined;
+                    // The result message's own tool name is authoritative; the pending snapshot is only a fallback.
+                    const resultToolName = evt.message.toolName;
+                    const blockedTool = (typeof resultToolName === "string" && resultToolName.length > 0 ? resultToolName : undefined) ?? toolSnapshot?.tool;
+                    const budgetBlocked = Boolean(options.toolBudget && isToolBudgetBlockedMessage(options.toolBudget, resultText, blockedTool));
+                    if (options.toolBudget && budgetBlocked) {
+                        result.toolBudgetBlocked = true;
+                        result.toolBudget = toolBudgetState(options.toolBudget, Math.max(progress.toolCount, options.toolBudget.hard + 1), blockedTool);
+                    }
+                    appendRecentOutput(progress, resultText.split("\n").slice(-10));
+                    // A budget block has its own signal; it is not a failing mutation.
+                    if (toolSnapshot?.mutates && !budgetBlocked && didMutatingToolFail(evt.message)) {
+                        recordMutatingFailure(mutatingFailures, {
+                            tool: toolSnapshot.tool,
+                            path: toolSnapshot.path,
+                            error: resultText.split("\n").find((line) => line.trim())?.trim().slice(0, 180) ?? "mutating tool failed",
+                            ts: now,
+                        }, mutatingFailureWindowMs);
+                        if (shouldEscalateMutatingFailures(mutatingFailures, controlConfig.failedToolAttemptsBeforeAttention)) {
+                            emitNeedsAttention(now, {
+                                message: `${agent.name} needs attention after repeated mutating tool failures`,
+                                reason: "tool_failures",
+                                currentTool: toolSnapshot.tool,
+                                currentPath: toolSnapshot.path,
+                                currentToolDurationMs: toolSnapshot.startedAt ? Math.max(0, now - toolSnapshot.startedAt) : undefined,
+                                recentFailureSummary: summarizeRecentMutatingFailures(mutatingFailures),
+                            });
+                        }
+                    }
+                    else if (toolSnapshot?.mutates) {
+                        resetMutatingFailureState(mutatingFailures);
                     }
                 }
-                else if (toolSnapshot?.mutates) {
-                    resetMutatingFailureState(mutatingFailures);
-                }
+                updateActivityState(now);
                 fireUpdate();
             }
         };
@@ -1354,6 +1358,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         void (async () => {
             try {
                 const input = createReportedChildSessionInput(launch, shared.transcriptWriter);
+                input.signal = startup.signal;
                 const created = await childSessions.create(input);
                 if (lifecycleFinished) {
                     void created.dispose();
@@ -1541,9 +1546,11 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
         result.savedOutputPath = resolvedOutput.savedPath;
         result.outputSaveError = resolvedOutput.saveError;
-        if (resolvedOutput.fatalError) {
+        if (isSettlementFatalOutputError(resolvedOutput, options.outputMode)) {
             result.exitCode = 1;
             result.error = result.error ? `${result.error}\n${resolvedOutput.saveError}` : resolvedOutput.saveError;
+            progress.status = "failed";
+            progress.error = result.error;
         }
         if (resolvedOutput.savedPath) {
             result.outputReference = formatSavedOutputReference(resolvedOutput.savedPath, fullOutput);
@@ -1721,7 +1728,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
             error: "Skills not found: pi-subagents",
         }, options.context));
     }
-    const systemPrompt = buildEffectiveSystemPrompt({ agent, resolvedSkills, cwd: skillCwd, ...(options.outputPath ? { outputPath: options.outputPath } : {}) });
+    const systemPrompt = buildEffectiveSystemPrompt({ agent, resolvedSkills, cwd: skillCwd });
     const { model: selectedModel, requestedModel } = resolveModelSelection(options.modelOverride ?? agent.model, options.availableModels, agent.modelProvider ?? options.preferredModelProvider, {
         scope: options.modelScope,
         primaryModelFromParent: options.modelOverrideFromParent,