pi-subagents 0.77.0 → 0.78.0

package/src/runs/foreground/subagent-executor.js

@@ -27,7 +27,6 @@ import { normalizeParentModel, resolveEffectiveSubagentModel, resolveModelOrigin
 import { projectChainOutputSchemas, resolveEffectiveOutputSchema } from "../shared/child-launch-plan.js";
 import { formatRetainedChildren, listRetainedChildren } from "../background/retained-children.js";
 import { resolveModelScopesForAgent } from "../shared/model-scope.js";
-import { recordRun } from "../shared/run-history.js";
 import { getStepAgents, isParallelStep, isDynamicParallelStep, resolveExistingReadPaths, } from "../../shared/settings.js";
 import { normalizeSkillInput } from "../../agents/skills.js";
 import { buildAsyncRunnerSteps, DEFAULT_ASYNC_TIMEOUT_MS, executeAsyncChain, executeAsyncSingle, formatAsyncStartedMessage, isAsyncAvailable, workflowAwaitedAsyncResultPath } from "../background/async-execution.js";
@@ -637,6 +636,7 @@ function resolveForegroundResumeTarget(params, state, options = {}) {
         ...(child.thinking ? { thinking: child.thinking } : {}),
         ...(child.launchContractDigest ? { launchContractDigest: child.launchContractDigest } : {}),
         ...(child.resumeContract ? { resumeContract: child.resumeContract } : {}),
+        ...(child.savedOutputPath ? { savedOutputPath: child.savedOutputPath } : {}),
         ...(child.extensionBindings ? { extensionBindings: normalizeExtensionBindings(child.extensionBindings).value } : {}),
         ...(child.requiredExtensions ? { requiredExtensions: child.requiredExtensions } : {}),
         ...(child.capabilityCeiling ? { capabilityCeiling: child.capabilityCeiling } : {}),
@@ -1882,6 +1882,13 @@ async function resumeAsyncRun(input) {
     const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
     const parentModel = input.parentModel;
     const revivalAsyncDir = path.join(DIRS.async, runId);
+    const revivalOutputBaseDir = resolveSingleRunOutputBaseDir(input.deps, artifactsDir, runId);
+    const inheritedOutput = foregroundContract?.output ?? recoveryDescriptor?.outputPath;
+    // The original run owns its saved output, so a resume without its own output writes next to it instead of over it.
+    // Workflow resumes are routed by the workflow's output claims instead.
+    const inheritedOutputPath = input.params.output === undefined && input.params.workflowParentRunId === undefined
+        ? (target.source === "foreground" ? target.savedOutputPath : undefined) ?? resolveSingleOutputPath(inheritedOutput, input.requestCwd, effectiveCwd, revivalOutputBaseDir)
+        : undefined;
     const result = await executeAsyncSingle(runId, compactOptional({
         agent: target.agent,
         task: buildRevivedAsyncTask(target, effectiveFollowUp),
@@ -1929,7 +1936,7 @@ async function resumeAsyncRun(input) {
         thinkingCeiling: recoveryDescriptor?.thinkingCeiling ?? ("thinkingCeiling" in target ? target.thinkingCeiling : undefined),
         extensionBindings: recoveryDescriptor?.extensionBindings ?? ("extensionBindings" in target ? target.extensionBindings : undefined),
         requiredExtensions: recoveryDescriptor?.requiredExtensions ?? target.requiredExtensions,
-        outputBaseDir: resolveSingleRunOutputBaseDir(input.deps, artifactsDir, runId),
+        outputBaseDir: revivalOutputBaseDir,
         maxSubagentDepth: recoveryDescriptor?.maxSubagentDepth ?? resolveCurrentMaxSubagentDepth(input.deps.config.maxSubagentDepth, input.deps.childRuntime),
         waitToolEnabled: input.deps.waitToolEnabled,
         waitToolDefaultTimeoutMs: input.deps.waitToolDefaultTimeoutMs,
@@ -1948,7 +1955,7 @@ async function resumeAsyncRun(input) {
         controlIntercomTarget: intercomBridge.active ? intercomBridge.orchestratorTarget : undefined,
         childIntercomTarget: intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(runId, agent, index) : undefined,
         availableModels,
-        output: input.params.output !== undefined ? input.params.output : foregroundContract?.output ?? recoveryDescriptor?.outputPath,
+        output: input.params.output !== undefined ? input.params.output : inheritedOutputPath ? suffixedOutputPath(inheritedOutputPath, runId.slice(0, 8)) : inheritedOutput,
         outputMode: input.params.outputMode ?? foregroundContract?.outputMode ?? recoveryDescriptor?.outputMode,
         outputClaimPath: input.params.workflowOutputClaimPath,
         ...(agentContract ? { agentContract } : {}),
@@ -3231,11 +3238,14 @@ export function sanitizeRunPathSegment(value, maxBytes = 120) {
 function resolveSingleRunOutputBaseDir(deps, artifactsDir, runId) {
     return resolveConfiguredSingleRunOutputBaseDir(deps) ?? path.join(artifactsDir, "outputs", sanitizeRunPathSegment(runId));
 }
+/** `<dir>/<name>.<suffix><ext>` next to outputPath, with `.md` when it has no extension. */
+function suffixedOutputPath(outputPath, suffix) {
+    const parsed = path.parse(outputPath);
+    return path.join(parsed.dir, `${parsed.name}.${suffix}${parsed.ext || ".md"}`);
+}
 function workflowChildDefaultOutput(aggregateOutputPath, artifactsDir, workflowRunId, workflowKey) {
-    if (aggregateOutputPath) {
-        const parsed = path.parse(aggregateOutputPath);
-        return path.join(parsed.dir, `${parsed.name}.${workflowKey}${parsed.ext || ".md"}`);
-    }
+    if (aggregateOutputPath)
+        return suffixedOutputPath(aggregateOutputPath, workflowKey);
     return path.join(artifactsDir, "outputs", sanitizeRunPathSegment(workflowRunId), `${workflowKey}.md`);
 }
 function workflowHostCommandRunner(input) {
@@ -3328,9 +3338,8 @@ function resolveWorkflowChildOutputPath(input) {
         const recoveryOutput = "recoveryDescriptor" in target ? target.recoveryDescriptor?.outputPath : undefined;
         if (hasExplicitOutput)
             return { path: recoveryOutput, inherited: false };
-        // An output-less foreground resume reuses its recorded output; only an absolute path is known before the new run id exists.
-        const foregroundOutput = target.source === "foreground" ? target.resumeContract?.output : undefined;
-        return { path: recoveryOutput, inherited: false, resumedOutput: recoveryOutput ?? (typeof foregroundOutput === "string" && path.isAbsolute(foregroundOutput) ? foregroundOutput : undefined) };
+        const savedPath = recoveryOutput ?? (target.source === "foreground" ? target.savedOutputPath ?? resolveSingleOutputPath(target.resumeContract?.output, input.ctxCwd) : undefined);
+        return { inherited: false, ...(savedPath ? { resumedSavedPath: savedPath } : {}) };
     }
     const childCwd = resolveWorkflowChildLocalCwd(input);
     let agentOutput;
@@ -3370,10 +3379,12 @@ function workflowChildOutputClaims(input) {
     }
     const overrides = new Map();
     for (const entry of resolvedEntries) {
-        // An output-less resume keeps its retained path unless an earlier child of this workflow already owns it.
-        const resumeCollides = entry.resumedOutput !== undefined && input.claimedOutputPaths.has(resolveWorkflowHostOutputClaimPath(entry.resumedOutput));
-        if (resumeCollides || (entry.inherited && entry.path && (paths.get(resolveWorkflowHostOutputClaimPath(entry.path)) ?? 0) > 1)) {
-            const output = workflowChildDefaultOutput(input.aggregateOutputPath, input.artifactsDir, input.workflowRunId, entry.key);
+        // The resumed run owns the report it saved, inside or outside this workflow, so an output-less resume writes its own.
+        if (entry.resumedSavedPath || (entry.inherited && entry.path && (paths.get(resolveWorkflowHostOutputClaimPath(entry.path)) ?? 0) > 1)) {
+            let output = workflowChildDefaultOutput(input.aggregateOutputPath, input.artifactsDir, input.workflowRunId, entry.key);
+            // A rerun of the same workflow and key generates the very file the resumed run saved.
+            if (entry.resumedSavedPath && resolveWorkflowHostOutputClaimPath(output) === resolveWorkflowHostOutputClaimPath(entry.resumedSavedPath))
+                output = suffixedOutputPath(output, input.workflowRunId.slice(0, 8));
             overrides.set(entry.key, output);
             entry.path = output;
         }
@@ -3390,16 +3401,6 @@ function workflowChildOutputClaims(input) {
         claims.set(claimPath, key);
         childClaims.set(key, claimPath);
     }
-    // Record a discovered output-less resume path for later admissions without adding same-batch duplicate errors.
-    for (const { key, path: resolved, resumedOutput } of resolvedEntries) {
-        if (resolved || !resumedOutput)
-            continue;
-        const claimPath = resolveWorkflowHostOutputClaimPath(resumedOutput);
-        if (claims.has(claimPath))
-            continue;
-        claims.set(claimPath, key);
-        childClaims.set(key, claimPath);
-    }
     return { claims, childClaims, overrides };
 }
 function applyWorkflowChildOutputClaims(target, claims) {
@@ -3622,7 +3623,6 @@ async function runSinglePath(data, deps) {
     if (shouldForkAgent(contextPolicy, params.agent)) {
         task = wrapForkTask(task);
     }
-    const cleanTask = task;
     const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, singleCwd, resolveSingleRunOutputBaseDir(deps, artifactsDir, runId));
     const validationError = validateFileOnlyOutputMode(effectiveOutputMode, outputPath, `Single run (${params.agent})`);
     if (validationError) {
@@ -3839,7 +3839,6 @@ async function runSinglePath(data, deps) {
                         }
                     }
                 }
-                recordRun(params.agent, cleanTask, result.exitCode, result.progressSummary?.durationMs ?? 0, result);
             },
             timeoutMs: data.timeoutMs,
             deadlineAt,
@@ -3880,9 +3879,6 @@ async function runSinglePath(data, deps) {
             finishTrackedForegroundChild();
         }
     }
-    if (!r.detached) {
-        recordRun(params.agent, cleanTask, r.exitCode, r.progressSummary?.durationMs ?? 0, r);
-    }
     let worktreeHandoff;
     if (worktreeSetup) {
         worktreeHandoff = r.detached
@@ -4820,12 +4816,7 @@ export function createSubagentExecutor(deps) {
             if (launchBlockingErrors.length > 0) {
                 return buildRequestedModeError(requestParams, `Workflow '${_id}' validation failed before child launch; no children launched. ${launchBlockingErrors.map((error) => error.message).join(" ")}`);
             }
-            // A package chain's per-step stop check defeats static launch counting; runtime fan-out enforcement still applies.
-            const structuredResource = workflowResource?.provenance.name === "chain" || workflowResource?.provenance.name === "tasks";
-            for (const warning of workflowValidation.warnings ?? []) {
-                if (!(structuredResource && warning.kind === "dynamic-spawn-count"))
-                    console.warn(`[pi-subagents] ${warning.message}`);
-            }
+            // Validation warnings belong to the validate action; a launch does not repeat them on every run.
             const acceptanceErrors = validateAcceptanceInput(requestParams.acceptance);
             if (acceptanceErrors.length > 0)
                 return buildRequestedModeError(requestParams, acceptanceErrors.join(" "));