@emiliosp/pi-maestro 0.7.4 → 0.9.0

package/node_modules/pi-subagents/src/runs/foreground/execution.js

@@ -21,15 +21,15 @@ import { resolvePermissionRules } from "../shared/permissions.js";
 import { applyThinkingSuffix, deriveForkPromptCacheKey } from "../shared/child-tool-plan.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
-import { resolveEffectiveThinking } from "../../shared/model-info.js";
+import { qualifyModelWithProvider, resolveEffectiveThinking } from "../../shared/model-info.js";
 import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.js";
 import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.js";
 import { formatMidToolExitError, isOrdinaryToolForMidToolExit } from "../shared/process-signal.js";
 import { formatChildToolDiagnostic } from "../shared/tool-availability.js";
-import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.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";
@@ -75,6 +75,7 @@ function persistSingleResultMetadata(input) {
     const target = input.result;
     writeMetadata(input.metadataPath, {
         runId: input.runId,
+        parentSessionId: input.parentSessionId,
         agent: input.agent,
         task: PROMPT_REDACTED,
         exitCode: target.exitCode,
@@ -102,9 +103,6 @@ function persistSingleResultMetadata(input) {
         timestamp: Date.now(),
     });
 }
-function formatTimeoutMessage(timeoutMs) {
-    return `Subagent timed out after ${timeoutMs}ms.`;
-}
 function resolveAttemptTimeout(options) {
     if (options.timeoutMs === undefined)
         return undefined;
@@ -112,7 +110,7 @@ function resolveAttemptTimeout(options) {
     return {
         timeoutMs: options.timeoutMs,
         remainingMs: Math.max(0, deadlineAt - Date.now()),
-        message: formatTimeoutMessage(options.timeoutMs),
+        message: `Subagent timed out after ${options.timeoutMs}ms.`,
     };
 }
 function buildPendingAcceptanceLedger(acceptance) {
@@ -193,8 +191,7 @@ function snapshotResult(result, progress) {
  * foreground detach receipts and terminal consumers use snapshotResult directly.
  */
 function snapshotStreamResult(result, progress) {
-    const snapshot = snapshotResult(result, progress);
-    snapshot.messages = undefined;
+    const snapshot = snapshotResult({ ...result, messages: undefined }, progress);
     snapshot.toolCalls = boundStreamedToolCalls(result);
     return snapshot;
 }
@@ -300,6 +297,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         nestedRoute: options.nestedRoute,
         runFanoutBudget: options.runFanoutBudget,
         parentSessionId: options.parentSessionId,
+        parentSessionFile: options.parentSessionFile,
         forkCacheKey: options.context === "fork" ? deriveForkPromptCacheKey(options.parentSessionId) : undefined,
         structuredOutput: options.structuredOutput,
         fast: options.fast ?? agent.fast,
@@ -419,6 +417,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             delete progress.cacheWrite;
     };
     const attemptTimeout = resolveAttemptTimeout(options);
+    let timeoutCause;
     if (attemptTimeout?.remainingMs === 0) {
         result.exitCode = 1;
         result.timedOut = true;
@@ -468,6 +467,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         let sessionSettled = false;
         let lifecycleFinished = false;
         let detached = false;
+        let hostStopReason;
         let intercomStarted = false;
         let assistantError;
         let removeAbortListener;
@@ -707,6 +707,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();
@@ -980,10 +983,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") {
@@ -1032,9 +1037,10 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                     }
                     projectCompleteUsage();
                     if (evt.message.model) {
-                        progress.model = evt.message.model;
+                        const observedModel = qualifyModelWithProvider(evt.message.model, evt.message.provider, options.availableModels);
+                        progress.model = observedModel;
                         if (!result.model)
-                            result.model = evt.message.model;
+                            result.model = observedModel;
                         if (expectedModelForVerification && !hasToolCall) {
                             const modelVerificationError = formatSubagentModelVerificationError(expectedModelForVerification, evt.message.model, options.availableModels, options.modelResponseAliases, session?.virtualModelId);
                             if (modelVerificationError && !result.error)
@@ -1061,59 +1067,48 @@ 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;
+                    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));
+                    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),
+                            });
+                        }
+                    }
+                    else if (toolSnapshot?.mutates) {
+                        resetMutatingFailureState(mutatingFailures);
                     }
                 }
-                else if (toolSnapshot?.mutates) {
-                    resetMutatingFailureState(mutatingFailures);
-                }
+                updateActivityState(now);
                 fireUpdate();
             }
         };
@@ -1131,9 +1126,10 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         }
         if (attemptTimeout) {
             timeoutTimer = setTimeout(() => {
-                if (sessionSettled || lifecycleFinished || interruptedByControl)
+                if (sessionSettled || lifecycleFinished || interruptedByControl || result.timedOut)
                     return;
                 result.timedOut = true;
+                timeoutCause = attemptTimeout.message;
                 clearAllToolTimeouts();
                 result.error = attemptTimeout.message;
                 result.finalOutput = attemptTimeout.message;
@@ -1187,9 +1183,11 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             }
         };
         const terminateForToolTimeout = (message) => {
-            if (sessionSettled || lifecycleFinished || interruptedByControl)
+            if (sessionSettled || lifecycleFinished || interruptedByControl || result.timedOut)
                 return;
+            clearTimeout(timeoutTimer);
             result.timedOut = true;
+            timeoutCause = message;
             result.error = message;
             result.finalOutput = message;
             progress.status = "failed";
@@ -1243,10 +1241,11 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             if (!closeError && promptErrorMessage !== undefined) {
                 closeError = promptErrorMessage;
             }
-            // A foreground child never loads the parent's ambient extensions, so a
-            // provider one registers resolves as "not found" before the child starts.
-            // Annotate only a creation/prompt failure that produced no turn; keep the
-            // core error and add the host rule and both remedies after it.
+            // A foreground child never loads the parent's ambient extensions. A model
+            // whose provider the parent registry does not serve resolves as "not found"
+            // before the child starts; a provider it does serve is inherited without its
+            // extension's session hooks and can fail the first request. Keep the
+            // original error first and add the host rule and remedies after it.
             if (promptErrorMessage !== undefined
                 && closeError === promptErrorMessage
                 && isChildModelResolutionFailure(promptErrorMessage)
@@ -1255,11 +1254,20 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 && !launch.session.ambientExtensions) {
                 closeError = `${promptErrorMessage}\n\n${formatChildModelResolutionDiagnostic({ agent: agent.name, model: launch.session.model, host: "parent", capabilityCeiling: launch.toolPlan.capabilityCeiling })}`;
             }
+            else if (session?.inheritedProvider
+                && closeError !== undefined
+                && (closeError === promptErrorMessage || closeError === assistantError)
+                && progress.toolCount === 0
+                && (result.messages ?? []).every((message) => message.role !== "assistant" || message.stopReason === "error")) {
+                closeError = `${closeError}\n\n${formatInheritedProviderDiagnostic({ agent: agent.name, model: launch.session.model, provider: session.inheritedProvider, capabilityCeiling: launch.toolPlan.capabilityCeiling })}`;
+            }
             const forcedDrainAfterFinalSuccess = (forced || forcedTermination) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !closeError;
             const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(result.messages ?? []);
-            if (!closeError && (abortedBySignal || session?.shutDown) && !result.interrupted && !result.timedOut) {
-                closeError = session?.shutDown ? "Subagent stopped because the parent session shut down." : STOPPED_BEFORE_COMPLETION_ERROR;
+            if (!closeError && (abortedBySignal || session?.shutDown || hostStopReason) && !result.interrupted && !result.timedOut) {
+                closeError = hostStopReason ?? (session?.shutDown ? "Subagent stopped because the parent session shut down." : STOPPED_BEFORE_COMPLETION_ERROR);
             }
+            if (hostStopReason && !result.interrupted && !result.timedOut)
+                result.stopped = true;
             // A workflow child ended by the workflow's abort signal was stopped, not failed.
             if (options.abortedAsStopped && abortedBySignal && !session?.shutDown && !result.interrupted && !result.timedOut)
                 result.stopped = true;
@@ -1363,9 +1371,20 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
                 if (abortedBySignal || interruptedByControl || result.timedOut) {
                     abortChild();
                 }
-                options.onChildSession?.({ steer: (text) => created.steer(text), followUp: (text) => created.followUp(text) });
+                options.onChildSession?.({
+                    steer: (text) => created.steer(text),
+                    followUp: (text) => created.followUp(text),
+                    stop: (reason) => {
+                        if (sessionSettled || lifecycleFinished)
+                            return;
+                        hostStopReason = reason;
+                        abortChild();
+                    },
+                });
                 messageBaseline = created.messages.length;
-                await created.prompt(`Task: ${task}`);
+                // A runtime replacement can stop a child that detached while it was still being created.
+                if (!hostStopReason)
+                    await created.prompt(`Task: ${task}`);
                 settle(undefined);
             }
             catch (error) {
@@ -1486,8 +1505,7 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
         result.outputPartial = true;
     }
     result.outputState = fullOutput.trim() || result.structuredOutput !== undefined ? "present" : "absent";
-    if (result.timedOut) {
-        const timeoutMessage = formatTimeoutMessage(options.timeoutMs ?? 0);
+    if (timeoutCause) {
         let requiredOutputMissing;
         if (options.outputMode === "file-only" && options.outputPath) {
             const outputChanged = hasSingleOutputChangedSinceSnapshot(options.outputPath, shared.outputSnapshot);
@@ -1508,8 +1526,8 @@ async function runSingleAttempt(runtimeCwd, agent, task, model, options, shared)
             artifactPaths: shared.artifactPaths,
         });
         fullOutput = fullOutput.trim()
-            ? `${timeoutMessage}\n\n${result.timeoutRecovery.message}\n\nPartial output before timeout:\n${fullOutput}`
-            : `${timeoutMessage}\n\n${result.timeoutRecovery.message}`;
+            ? `${timeoutCause}\n\n${result.timeoutRecovery.message}\n\nPartial output before timeout:\n${fullOutput}`
+            : `${timeoutCause}\n\n${result.timeoutRecovery.message}`;
     }
     if (options.outputPath && result.exitCode === 0) {
         // The schema is the caller's contract: a bound output file holds the structured result, not closing prose.
@@ -1517,9 +1535,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);
@@ -1697,7 +1717,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,
@@ -1760,6 +1780,7 @@ async function runSyncCompletionInner(runtimeCwd, agents, agentName, task, optio
             metadataPath: artifactPathsResult?.metadataPath,
             enabled: options.artifactConfig?.enabled !== false && options.artifactConfig?.includeMetadata !== false,
             runId: options.runId,
+            parentSessionId: options.parentSessionId,
             agent: agentName,
             task,
             result: target,
@@ -2124,6 +2145,7 @@ export async function runSync(runtimeCwd, agents, agentName, task, options) {
                 metadataPath: failedResult.artifactPaths?.metadataPath,
                 enabled: options.artifactConfig?.enabled !== false && options.artifactConfig?.includeMetadata !== false,
                 runId: options.runId,
+                parentSessionId: options.parentSessionId,
                 agent: failedResult.agent,
                 task: failedResult.task,
                 result: failedResult,