pi-subagents 0.77.0 → 0.79.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";
@@ -69,6 +68,7 @@ import { canQueueRetainedAsyncFollowUp, steerAsyncRun } from "./async-steering-a
 import { resolveWorkflowForegroundSteeringTarget, steerWorkflowForegroundTarget, steerWorkflowRun, } from "./workflow-foreground-steering.js";
 import { stopAsyncRun } from "./async-stop-action.js";
 import { dismissRecoveredWorkflow } from "./async-dismiss-action.js";
+import { inheritedSessionIds } from "../../shared/session-succession.js";
 import { promotePausedWorkflowIfSettled, reconcileDetachedWorkflowChildCompletion } from "./workflow-detach-reconcile.js";
 import { reconcileAsyncRun } from "../background/stale-run-reconciler.js";
 import { resolveAsyncRootResultPath, waitForImportedAsyncRoot } from "../background/chain-root-attachment.js";
@@ -95,7 +95,7 @@ import { getInspectorPlugins } from "../../inspectors/plugins.js";
 import { handleHerdrProjectPaneAction, HERDR_PROJECT_PANE_ACTIONS } from "../../inspectors/herdr/project-panes.js";
 import { previewSimpleWorkflowRun, runWorkflowScript, validateWorkflowScript, WorkflowScriptError } from "../../workflows/scripted-workflow.js";
 import { formatIncrementalChildCompletion, incrementalChildCompletionTriggersTurn } from "../background/notify.js";
-import { appendWorkflowChildJournal, findWorkflowReuseSource, matchWorkflowReuse, workflowChildFingerprint, workflowScriptDigest, workflowStopCause, WORKFLOW_RUNTIME_REPLACED_RELAUNCH_NOTICE } from "../../workflows/workflow-reuse.js";
+import { appendWorkflowChildJournal, findWorkflowReuseSource, matchWorkflowReuse, readNamedWorkflowReuseSource, workflowChildFingerprint, workflowRuntimeReplacedRelaunchNotice, workflowScriptDigest, workflowStopCause } from "../../workflows/workflow-reuse.js";
 import { executeWorkflowHostCommand, resolveWorkflowHostOutputClaimPath } from "../../workflows/host-command.js";
 import { buildWorkflowReceipt, readWorkflowReceipt, workflowReceiptPath, resolveWorkflowReceiptResumeEntry, writeWorkflowReceipt } from "../../workflows/workflow-receipt.js";
 import { formatWorkflowKeyRevival, recordWorkflowRevival, withWorkflowRevivals } from "../../workflows/workflow-revival.js";
@@ -271,11 +271,12 @@ function nestedResolutionScopeForExecutor(deps) {
         ...(address ? { descendantOf: { parentRunId: address.parentRunId, ...(address.parentStepIndex !== undefined ? { parentStepIndex: address.parentStepIndex } : {}) } } : {}),
     };
 }
-function trustedSessionRootsForStatus(ctx, deps) {
+function trustedSessionRoots(parentSessionFile, deps) {
     const roots = deps.config.defaultSessionDir ? [path.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : [];
-    const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
+    // Inherited runs keep their children under the root of the session that launched them.
     if (parentSessionFile)
-        roots.push(deps.getSubagentSessionRoot(parentSessionFile));
+        for (const sessionFile of [parentSessionFile, ...inheritedSessionIds(parentSessionFile)])
+            roots.push(deps.getSubagentSessionRoot(sessionFile));
     return [...new Set(roots)];
 }
 /** Children follow the launching session's trust; hosts older than Pi's trust concept keep Pi's default. */
@@ -637,6 +638,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 } : {}),
@@ -1129,7 +1131,7 @@ function pathWithin(base, candidate) {
     const resolvedCandidate = path.resolve(candidate);
     return resolvedCandidate === resolvedBase || resolvedCandidate.startsWith(`${resolvedBase}${path.sep}`);
 }
-function validateNestedSessionFile(run, trustedSessionRoots) {
+function validateNestedSessionFile(run, trustedSessionRoots, resolveSource, visited = []) {
     const sessionFile = nestedRunSessionFile(run);
     if (!sessionFile)
         throw new Error(`Nested run '${run.id}' does not have a persisted session file to resume from.`);
@@ -1151,7 +1153,24 @@ function validateNestedSessionFile(run, trustedSessionRoots) {
         throw new Error(`Nested run '${run.id}' session file is outside trusted nested session roots: ${sessionFile}`);
     }
     if (!realSessionFile.split(path.sep).includes(run.id)) {
-        throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`);
+        // A resume replacement continues its source's session; accept it only when that source,
+        // resolved in the caller's own scope, is one the caller could resume itself (the states
+        // resolveNestedResumeTarget refuses), validates on its own and owns this same file.
+        const sourceId = run.revivedFrom;
+        const chain = [...visited, run.id];
+        const source = sourceId && chain.length <= 8 && !chain.includes(sourceId) ? resolveSource(sourceId) : undefined;
+        let sourceFile;
+        if (source && source.state !== "running" && source.state !== "queued" && source.state !== "stopped") {
+            try {
+                sourceFile = validateNestedSessionFile(source, trustedSessionRoots, resolveSource, chain);
+            }
+            catch {
+                sourceFile = undefined;
+            }
+        }
+        if (sourceFile !== realSessionFile) {
+            throw new Error(`Nested run '${run.id}' session file is not under that nested run's session directory: ${sessionFile}`);
+        }
     }
     return realSessionFile;
 }
@@ -1165,7 +1184,7 @@ export function readNestedRecoveryDescriptor(asyncDir, runId, agent) {
         throw new Error(`Nested run '${runId}' has a recovery descriptor for a different agent.`);
     return recoveryDescriptor;
 }
-function resolveNestedResumeTarget(match, trustedSessionRoots) {
+function resolveNestedResumeTarget(match, trustedSessionRoots, resolveSource) {
     const run = match.match.run;
     if (run.state === "running" || run.state === "queued")
         throw new Error(`Nested run '${run.id}' is live; route the follow-up to the owner process instead.`);
@@ -1185,7 +1204,7 @@ function resolveNestedResumeTarget(match, trustedSessionRoots) {
         agent,
         index: 0,
         cwd: asyncDir ? path.dirname(asyncDir) : undefined,
-        sessionFile: validateNestedSessionFile(run, trustedSessionRoots),
+        sessionFile: validateNestedSessionFile(run, trustedSessionRoots, resolveSource),
         ...(run.capabilityCeiling ? { capabilityCeiling: run.capabilityCeiling } : {}),
         ...(recoveryDescriptor ? { recoveryDescriptor } : {}),
     });
@@ -1522,9 +1541,10 @@ async function resumeExternalJobFollowUp(input) {
 }
 function resolveRequestedResumeTarget(params, deps, parentSessionFile) {
     const requestedId = params.id ?? params.runId;
+    const resolutionDeps = omitUndefinedProperties({ state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
     let resolved;
     try {
-        resolved = requestedId ? resolveSubagentRunId(requestedId, omitUndefinedProperties({ state: deps.state, nested: nestedResolutionScopeForExecutor(deps) })) : undefined;
+        resolved = requestedId ? resolveSubagentRunId(requestedId, resolutionDeps) : undefined;
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "";
@@ -1540,11 +1560,18 @@ function resolveRequestedResumeTarget(params, deps, parentSessionFile) {
         const externalJobTarget = resolveNestedExternalJobResumeTarget(resolved, params, deps);
         if (externalJobTarget)
             return externalJobTarget;
-        const trustedSessionRoots = [
-            ...(deps.config.defaultSessionDir ? [path.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : []),
-            ...(parentSessionFile ? [deps.getSubagentSessionRoot(parentSessionFile)] : []),
-        ];
-        return resolveNestedResumeTarget(resolved, trustedSessionRoots);
+        const rootRunId = resolved.match.rootRunId;
+        // The source must be a nested run the caller could address itself, in the same registry.
+        const resolveSource = (id) => {
+            try {
+                const source = resolveSubagentRunId(id, resolutionDeps);
+                return source?.kind === "nested" && source.id === id && source.match.rootRunId === rootRunId ? source.match.run : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        return resolveNestedResumeTarget(resolved, trustedSessionRoots(parentSessionFile, deps), resolveSource);
     }
     return resolveResumeTarget(params, deps.state, { asyncRequireSessionFile: false });
 }
@@ -1882,6 +1909,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 +1963,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 +1982,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 } : {}),
@@ -3005,9 +3039,9 @@ function importWorkflowAwaitedChildResult(completed, options) {
     };
 }
 // A replaced runtime leaves the child running so a relaunch of the workflow can re-attach to it.
-function stopAwaitedAsyncChildOnAbort(signal, state, runId, asyncDir, kill) {
+function stopAwaitedAsyncChildOnAbort(signal, state, runId, asyncDir, kill, reattachedFromOtherSession = false) {
     const stopOnAbort = () => { if (!workflowStopCause(signal?.reason))
-        stopAsyncRun(state, runId, kill, { asyncDir, resolvedId: runId }); };
+        stopAsyncRun(state, runId, kill, { asyncDir, resolvedId: runId, ...(reattachedFromOtherSession ? { reattachedRunId: runId } : {}) }); };
     if (signal?.aborted)
         stopOnAbort();
     else
@@ -3231,11 +3265,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 +3365,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 +3406,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 +3428,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 +3650,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 +3866,6 @@ async function runSinglePath(data, deps) {
                         }
                     }
                 }
-                recordRun(params.agent, cleanTask, result.exitCode, result.progressSummary?.durationMs ?? 0, result);
             },
             timeoutMs: data.timeoutMs,
             deadlineAt,
@@ -3880,9 +3906,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
@@ -4056,13 +4079,16 @@ export function bindMissionWorkflowChildAsyncLaunch(params, binding, asyncByDefa
 }
 function workflowChildResult(key, result, childParams = {}, resumeState, forcedTerminalOutcome) {
     const running = missionWorkflowChildStatus(result) === "running";
-    const receiptOutput = result.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+    // The receipt opens with the workflow-wide run fan-out line, which says nothing about this child.
+    const fanoutPrefix = result.details.runFanoutBudget ? `${formatRunFanoutBudget(result.details.runFanoutBudget)}\n` : undefined;
+    const fullReceipt = result.content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n");
+    const receiptOutput = fanoutPrefix && fullReceipt.startsWith(fanoutPrefix) ? fullReceipt.slice(fanoutPrefix.length) : fullReceipt;
     const output = running ? "" : result.details.results.length === 1 && result.details.results[0]?.finalOutput !== undefined
         ? result.details.results[0].finalOutput
         : receiptOutput;
     const childError = result.details.results.map((child) => child.error).find((error) => Boolean(error));
     const stopped = result.details.results.some((child) => child.stopped);
-    // A stopped child's receipt text carries the run fan-out annotation; report the structured stop reason instead.
+    // A stopped child reports its structured stop reason alone, without the receipt's output block.
     const failureErrorBase = stopped && childError
         ? childError
         : childError && receiptOutput
@@ -4820,12 +4846,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(" "));
@@ -4893,6 +4914,17 @@ export function createSubagentExecutor(deps) {
                 && !inheritedNestedRoute(deps)
                 && !requestParams.workflowParentRunId;
             const workflowRunId = asyncWorkflow ? randomUUID() : undefined;
+            if (requestParams.reuseFrom !== undefined && !topLevelAsyncWorkflow) {
+                return { content: [{ type: "text", text: "options.reuseFrom requires an async top-level workflow." }], isError: true, details: { mode: "workflow", results: [] } };
+            }
+            let namedWorkflowReuseSource;
+            try {
+                if (requestParams.reuseFrom !== undefined)
+                    namedWorkflowReuseSource = readNamedWorkflowReuseSource(DIRS.async, requestParams.reuseFrom, workflowScriptDigest(requestParams.workflowScript), workflowCwd);
+            }
+            catch (error) {
+                return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "workflow", results: [] } };
+            }
             let workflowCapacity;
             if (workflowRunId && topLevelAsyncWorkflow) {
                 const currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
@@ -4959,7 +4991,7 @@ export function createSubagentExecutor(deps) {
                 const toolCallId = _id;
                 const workflowSessionRoot = requestParams.sessionDir
                     ? path.resolve(deps.expandTilde(requestParams.sessionDir))
-                    : trustedSessionRootsForStatus(ctx, deps)[0];
+                    : trustedSessionRoots(ctx.sessionManager.getSessionFile() ?? null, deps)[0];
                 const asyncDir = path.join(DIRS.async, workflowRunId);
                 const resultPath = resultFilePath(DIRS.results, workflowRunId);
                 const statusPath = path.join(asyncDir, "status.json");
@@ -4970,7 +5002,7 @@ export function createSubagentExecutor(deps) {
                 const completionOwnerId = deps.state.completionOwnerId ?? currentCompletionOwnerId();
                 deps.state.completionOwnerId = completionOwnerId;
                 const workflowScriptSourceDigest = workflowScriptDigest(requestParams.workflowScript);
-                const workflowReuseSource = findWorkflowReuseSource(DIRS.async, currentSessionId, workflowScriptSourceDigest, workflowArgsDigest);
+                const workflowReuseSource = namedWorkflowReuseSource ?? findWorkflowReuseSource(DIRS.async, currentSessionId, workflowScriptSourceDigest, workflowArgsDigest);
                 const workflowRunEvidence = { ...workflowArgsEvidence, scriptDigest: workflowScriptSourceDigest };
                 if (workflowReuseSource)
                     workflowRunEvidence.reusedFrom = workflowReuseSource.runId;
@@ -5495,6 +5527,9 @@ export function createSubagentExecutor(deps) {
                             if (entry.state === "reused" && existing) {
                                 continue;
                             }
+                            // A runtime replacement does not stop awaited async children (stopAwaitedAsyncChildOnAbort): they keep running.
+                            if (entry.state === "stopped" && existing?.async === true && existing.runId && workflowStopCause(controller.signal.reason))
+                                continue;
                             const mapped = entry.state === "started" || entry.state === "reused"
                                 ? "running"
                                 : entry.state === "completed"
@@ -5686,7 +5721,7 @@ export function createSubagentExecutor(deps) {
                                     const priorRunId = priorChild.runId;
                                     const priorAsyncDir = path.join(DIRS.async, priorRunId);
                                     appendWorkflowChildJournal(asyncDir, { type: "start", key, fingerprint: journalFingerprint, runId: priorRunId });
-                                    const stopListener = stopAwaitedAsyncChildOnAbort(workflowSignal, deps.state, priorRunId, priorAsyncDir, deps.kill);
+                                    const stopListener = stopAwaitedAsyncChildOnAbort(workflowSignal, deps.state, priorRunId, priorAsyncDir, deps.kill, requestParams.reuseFrom !== undefined);
                                     const reattached = await awaitExistingAsyncRun(priorAsyncDir, priorRunId, workflowSignal).finally(stopListener.remove);
                                     const claimedPath = reattached.status === "settled" ? claimWorkflowAwaitedResult(priorAsyncDir, workflowRunId, { ...reattached.result.importedPublication, runId: priorRunId }) : undefined;
                                     if (reattached.status === "settled" && claimedPath) {
@@ -5883,7 +5918,7 @@ export function createSubagentExecutor(deps) {
                         const errorPreview = status.error && status.error.length > 1_000 ? `${status.error.slice(0, 1_000)}… (truncated; full error: ${statusPath} (error))` : status.error;
                         const terminalSummary = `${status.state === "complete"
                             ? "Workflow completed after detached child finished."
-                            : errorPreview ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${stopCause ? ` ${WORKFLOW_RUNTIME_REPLACED_RELAUNCH_NOTICE}` : ""}${workflowOutputPathMappingSummary(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
+                            : errorPreview ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${stopCause ? ` ${workflowRuntimeReplacedRelaunchNotice(workflowRunId)}` : ""}${workflowOutputPathMappingSummary(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
                         const outputWarning = writeWorkflowAggregateOutput(workflowAggregateOutputPath, terminalSummary, producedChildOutputPaths);
                         const resultSummary = appendWorkflowOutputWarning(terminalSummary, outputWarning);
                         const receiptState = status.state === "complete" ? "complete" : status.state === "paused" ? "paused" : status.state === "stopped" ? "stopped" : "failed";
@@ -5956,6 +5991,7 @@ export function createSubagentExecutor(deps) {
             const workflowHostSteps = new Map();
             let liveWorkflow = { trace: [], emits: [], console: [], ...(workflowResource ? { resource: workflowResource.provenance } : {}) };
             const childProgress = new Map();
+            const childLaunches = new Map();
             let activityTimer;
             let lastProgressAt = 0;
             let workflowProgressClosed = false;
@@ -5968,7 +6004,7 @@ export function createSubagentExecutor(deps) {
                     clearTimeout(activityTimer);
                 activityTimer = undefined;
                 lastProgressAt = Date.now();
-                const liveWorkflowChildren = workflowChildSummary({ parentToolCallId: _id, workflowRunId: foregroundWorkflowRunId, workflowState: "running", inventoryComplete: false, trace: liveWorkflow.trace, progress: childProgress });
+                const liveWorkflowChildren = workflowChildSummary({ parentToolCallId: _id, workflowRunId: foregroundWorkflowRunId, workflowState: "running", inventoryComplete: false, trace: liveWorkflow.trace, progress: childProgress, launches: childLaunches });
                 onUpdate?.(workflowProgressUpdate(foregroundWorkflowRunId, chatProgress, liveWorkflow, liveWorkflowChildren, workflowPreflight));
             };
             try {
@@ -6056,11 +6092,21 @@ export function createSubagentExecutor(deps) {
                                     throw new Error("Workflow child permit supports native Pi children only.");
                                 workflowPermitContexts.set(childRequest, { child: { permit: delegatedWorkflowPermit, workflowRunId: foregroundWorkflowRunId, childKey: key } });
                             }
-                            workflowLaunchObservers.set(childRequest, (launch) => recordMissionWorkflowChild(missionBinding, foregroundWorkflowRunId, key, {
-                                status: "running",
-                                agent: launch.agent,
-                                ...(launch.sessionFile ? { sessionPath: launch.sessionFile } : {}),
-                            }));
+                            workflowLaunchObservers.set(childRequest, (launch) => {
+                                childLaunches.set(key, { agent: launch.agent, ...(launch.runId ? { runId: launch.runId } : {}) });
+                                // Telemetry must not decide the child's outcome, as with onTrace in scripted-workflow.
+                                try {
+                                    sendWorkflowProgress();
+                                }
+                                catch (error) {
+                                    console.error("Workflow progress update failed:", error);
+                                }
+                                recordMissionWorkflowChild(missionBinding, foregroundWorkflowRunId, key, {
+                                    status: "running",
+                                    agent: launch.agent,
+                                    ...(launch.sessionFile ? { sessionPath: launch.sessionFile } : {}),
+                                });
+                            });
                             return execute(randomUUID(), childRequest, workflowSignal, (update) => {
                                 const progress = update.details.progress?.[0];
                                 if (!progress)
@@ -6602,7 +6648,7 @@ export function createSubagentExecutor(deps) {
                     };
                 };
                 const nestedScope = nestedResolutionScopeForExecutor(deps);
-                const sessionRoots = trustedSessionRootsForStatus(ctx, deps);
+                const sessionRoots = trustedSessionRoots(ctx.sessionManager.getSessionFile() ?? null, deps);
                 if (action === "debug.run") {
                     if (!targetRunId && !hasDirectoryTarget) {
                         return withBudget({ content: [{ type: "text", text: "action='debug.run' requires id, runId, or dir." }], isError: true, details: { mode: "management", results: [] } });
@@ -7044,12 +7090,20 @@ export function createSubagentExecutor(deps) {
         // Forked children keep their requested thinking level. Signed Anthropic thinking
         // blocks are stripped from the inherited transcript by the resolver (they are bound
         // to the parent session), which is not a reason to disable the child's own reasoning.
+        let sessionRunId;
         try {
             assertLaunchableAgentsAllowedBeforeFork();
             const pruneSession = contextPolicy.usesFork && deps.config.forkContext?.mode === "pruned"
                 ? await createPrunedForkSessionWriter(ctx, deps.config.forkContext, signal)
                 : undefined;
-            const forkContextResolver = createForkContextResolver(ctx.sessionManager, contextPolicy.usesFork ? "fork" : undefined, pruneSession ? { pruneSession } : {});
+            const forkContextResolver = createForkContextResolver(ctx.sessionManager, contextPolicy.usesFork ? "fork" : undefined, {
+                ...(pruneSession ? { pruneSession } : {}),
+                runDirName: () => {
+                    if (!sessionRunId)
+                        throw new Error("A fork session was requested before the launch's run id was assigned.");
+                    return sessionRunId;
+                },
+            });
             prepareForkSessionForIndex = forkContextResolver.prepareSessionForIndex;
             forkSessionFileForIndex = forkContextResolver.sessionFileForIndex;
         }
@@ -7152,16 +7206,19 @@ export function createSubagentExecutor(deps) {
                 console.warn(`[pi-subagents] ${warning}`);
         }
         let sessionRoot;
+        // Key the session directory by the id the run is recorded under: nested resume
+        // accepts a session file only inside a directory named by that run's id.
+        sessionRunId = effectiveAsync ? asyncRunId : runId;
         if (effectiveParams.sessionDir) {
             // An explicit sessionDir is a root keyed by this launch's run id so
             // concurrent children resolve distinct per-child session files.
-            sessionRoot = path.join(path.resolve(deps.expandTilde(effectiveParams.sessionDir)), runId);
+            sessionRoot = path.join(path.resolve(deps.expandTilde(effectiveParams.sessionDir)), sessionRunId);
         }
         else {
             const baseSessionRoot = deps.config.defaultSessionDir
                 ? path.resolve(deps.expandTilde(deps.config.defaultSessionDir))
                 : deps.getSubagentSessionRoot(parentSessionFile);
-            sessionRoot = path.join(baseSessionRoot, runId);
+            sessionRoot = path.join(baseSessionRoot, sessionRunId);
         }
         try {
             fs.mkdirSync(sessionRoot, { recursive: true });