pi-subagents 0.83.0 → 0.84.0

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

@@ -87,7 +87,7 @@ import { formatHerdrMachineRunnerUnsupported, resolveMachinePlacement } from "..
 import { lookupRunnerLauncher, resolveAgentRunnerLauncher } from "../shared/runner-launcher.js";
 import { applyForceTopLevelAsyncOverride } from "../background/top-level-async.js";
 import { handleMissionAction, MISSION_ACTIONS } from "../../missions/actions.js";
-import { attachMissionToLaunchResult, prepareMissionLaunch, writeMissionAsyncBinding } from "../../missions/lifecycle.js";
+import { attachMissionToLaunchResult, missionAcceptanceStatus, prepareMissionLaunch, writeMissionAsyncBinding } from "../../missions/lifecycle.js";
 import { MissionNotFoundError, updateMission } from "../../missions/store.js";
 import { createMissionWorkflowState } from "../../missions/workflow-state.js";
 import { resolveAuthorityDecision } from "../../policy/authority.js";
@@ -678,9 +678,6 @@ function resolveForegroundResumeTarget(params, state, options = {}) {
         ...(child.capabilityCeiling ? { capabilityCeiling: child.capabilityCeiling } : {}),
     };
 }
-function isAsyncRunNotFound(error) {
-    return error instanceof Error && error.message.startsWith("Async run not found.");
-}
 function isMissingExactAsyncStatusFile(error, requested) {
     return error instanceof Error && error.message === `Status file not found for async run '${requested}'.`;
 }
@@ -750,38 +747,12 @@ function resolveResumeTarget(params, state, options = {}) {
             throw foregroundError;
         return asyncTarget;
     }
-    if (foregroundError && !isAsyncRunNotFound(asyncError))
-        throw foregroundError;
     if (foregroundError)
         throw foregroundError;
     if (asyncError)
         throw asyncError;
     throw new Error("Run not found. Provide id or runId.");
 }
-function getAsyncInterruptTarget(state, runId, location, options = {}) {
-    if (location?.asyncDir) {
-        return {
-            asyncId: location.resolvedId ?? runId ?? path.basename(location.asyncDir),
-            asyncDir: location.asyncDir,
-        };
-    }
-    if (runId) {
-        const direct = state.asyncJobs.get(runId);
-        if (direct)
-            return { asyncId: direct.asyncId, asyncDir: direct.asyncDir };
-        if (options.fallbackToNewest === false)
-            return undefined;
-    }
-    let newest;
-    for (const job of state.asyncJobs.values()) {
-        if (job.status !== "running")
-            continue;
-        if (!newest || (job.updatedAt ?? 0) > newest.updatedAt) {
-            newest = { asyncId: job.asyncId, asyncDir: job.asyncDir, updatedAt: job.updatedAt ?? 0 };
-        }
-    }
-    return newest ? { asyncId: newest.asyncId, asyncDir: newest.asyncDir } : undefined;
-}
 function isStaleExtensionContextError(error) {
     if (!(error instanceof Error))
         return false;
@@ -853,13 +824,13 @@ function emitControlNotification(input) {
     }
 }
 function interruptAsyncRun(state, runId, kill, location) {
-    const target = getAsyncInterruptTarget(state, runId, location, { fallbackToNewest: runId === undefined });
+    const target = location?.asyncDir ? { asyncId: location.resolvedId ?? runId, asyncDir: location.asyncDir } : state.asyncJobs.get(runId);
     if (!target)
         return null;
     const status = reconcileAsyncRun(target.asyncDir, omitUndefinedProperties({ kill })).status;
     if (!status || status.state !== "running" || typeof status.pid !== "number") {
         return {
-            content: [{ type: "text", text: `No running async run with an interrupt-capable pid was found for '${runId ?? "current"}'.` }],
+            content: [{ type: "text", text: `No running async run with an interrupt-capable pid was found for '${runId}'.` }],
             isError: true,
             details: { mode: "management", results: [] },
         };
@@ -1047,6 +1018,7 @@ function appendStepToAsyncChain(input) {
         parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
         parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
         currentModelProvider: parentModel?.provider,
+        parentProviderRegistry: input.ctx.modelRegistry,
         currentModel: parentModel,
         scopedModelIds: scopedModelIdsFromContext(input.ctx),
         modelScope: discoveredForAppend.modelScope,
@@ -1086,7 +1058,7 @@ function appendStepToAsyncChain(input) {
         worktreeBranchPrefix: input.deps.config.worktreeBranchPrefix,
         asyncDir: resolved.location.asyncDir,
         validateOutputBindings: false,
-        capabilityCeiling: intersectSubagentCapabilityCeilings(status.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(asyncCtx.currentSessionId)),
+        capabilityCeiling: intersectSubagentCapabilityCeilings(status.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(asyncCtx.parentSessionId)),
         requiredExtensions: retainedRequiredExtensions,
     }));
     if ("error" in built) {
@@ -1534,6 +1506,7 @@ async function resumeExternalJobFollowUp(input) {
             parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
             parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
             currentModelProvider: parentModel?.provider,
+            parentProviderRegistry: input.ctx.modelRegistry,
             currentModel: parentModel,
             scopedModelIds: scopedModelIdsFromContext(input.ctx),
             modelScope: input.modelScope,
@@ -1562,7 +1535,7 @@ async function resumeExternalJobFollowUp(input) {
         availableModels: input.ctx.modelRegistry.getAvailable().map(toModelInfo),
         outputBaseDir: resolveSingleRunOutputBaseDir(input.deps, artifactsDir, runId),
         ...(input.absoluteDeadlineAt !== undefined ? { absoluteDeadlineAt: input.absoluteDeadlineAt } : {}),
-        capabilityCeiling: resolveCurrentSubagentCapabilityCeiling(currentSessionId),
+        capabilityCeiling: resolveCurrentSubagentCapabilityCeiling(input.ctx.sessionManager.getSessionId() ?? undefined),
         runFanoutBudget: createRunFanoutBudget(runId, resolveMaxSubagentSpawnsPerRun(input.deps.config.maxSubagentSpawnsPerRun)),
         activeAsyncCapacity,
         externalJobFollowUp: { sourceRunId: input.target.runId, sourceStepIndex: input.target.index, parentProviderJobId: externalJob.providerJobId, requestId, requestDigest },
@@ -1822,6 +1795,7 @@ async function resumeAsyncRun(input) {
                 parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
                 parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
                 currentModelProvider: parentModel?.provider,
+                parentProviderRegistry: input.ctx.modelRegistry,
                 currentModel: parentModel,
                 scopedModelIds: scopedModelIdsFromContext(input.ctx),
                 modelScope,
@@ -1858,7 +1832,7 @@ async function resumeAsyncRun(input) {
             childIntercomTarget: intercomBridge.active ? (agent, index) => resolveSubagentIntercomTarget(runId, agent, index) : undefined,
             globalConcurrencyLimit: input.deps.config.globalConcurrencyLimit,
             runFanoutBudget: createRunFanoutBudget(runId, resolveMaxSubagentSpawnsPerRun(input.deps.config.maxSubagentSpawnsPerRun)),
-            capabilityCeiling: intersectSubagentCapabilityCeilings("capabilityCeiling" in target ? target.capabilityCeiling : undefined, resolveCurrentSubagentCapabilityCeiling(input.deps.state.currentSessionId)),
+            capabilityCeiling: intersectSubagentCapabilityCeilings("capabilityCeiling" in target ? target.capabilityCeiling : undefined, resolveCurrentSubagentCapabilityCeiling(input.ctx.sessionManager.getSessionId() ?? undefined)),
             thinkingCeiling: target.thinkingCeiling,
             activeAsyncCapacity,
         }));
@@ -1963,6 +1937,7 @@ async function resumeAsyncRun(input) {
             parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
             parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
             currentModelProvider: parentModel?.provider,
+            parentProviderRegistry: input.ctx.modelRegistry,
             currentModel: parentModel,
             scopedModelIds: scopedModelIdsFromContext(input.ctx),
             modelScope,
@@ -2028,7 +2003,7 @@ async function resumeAsyncRun(input) {
         ...(input.params.toolBudget !== undefined ? { toolBudget: input.params.toolBudget } : {}),
         // Recovery descriptors, remembered foreground runs, and current workflow roots
         // preserve parent authority before the selected agent's descendant ceiling.
-        capabilityCeiling: intersectSubagentCapabilityCeilings(recoveryDescriptor?.capabilityCeiling ?? (target.source === "foreground" || (target.source === "async" && target.mode === "workflow") ? target.capabilityCeiling : undefined), resolveCurrentSubagentCapabilityCeiling(input.deps.state.currentSessionId)),
+        capabilityCeiling: intersectSubagentCapabilityCeilings(recoveryDescriptor?.capabilityCeiling ?? (target.source === "foreground" || (target.source === "async" && target.mode === "workflow") ? target.capabilityCeiling : undefined), resolveCurrentSubagentCapabilityCeiling(input.ctx.sessionManager.getSessionId() ?? undefined)),
         runFanoutBudget: input.params.runFanoutBudget ?? recoveryDescriptor?.runFanoutBudget ?? createRunFanoutBudget(runId, resolveMaxSubagentSpawnsPerRun(input.deps.config.maxSubagentSpawnsPerRun)),
         parentWorkflowRunId: input.params.workflowParentRunId,
         workflowKey: input.params.workflowKey,
@@ -3134,6 +3109,7 @@ async function runAsyncPath(data, deps) {
         parentSessionId: data.parentPiSessionId,
         parentSessionFile: ctx.sessionManager.getSessionFile() ?? undefined,
         currentModelProvider: parentModel?.provider,
+        parentProviderRegistry: ctx.modelRegistry,
         currentModel: parentModel,
         scopedModelIds: data.scopedModelIds,
         modelScope: data.modelScope,
@@ -5093,7 +5069,7 @@ export function createSubagentExecutor(deps) {
                 const eventsPath = path.join(asyncDir, "events.jsonl");
                 const startedAt = Date.now();
                 const currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
-                const workflowCapabilityCeiling = intersectSubagentCapabilityCeilings(requestParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(currentSessionId));
+                const workflowCapabilityCeiling = intersectSubagentCapabilityCeilings(requestParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(ctx.sessionManager.getSessionId() ?? undefined));
                 const completionOwnerId = deps.state.completionOwnerId ?? currentCompletionOwnerId();
                 deps.state.completionOwnerId = completionOwnerId;
                 const workflowScriptSourceDigest = workflowScriptDigest(requestParams.workflowScript);
@@ -5971,6 +5947,7 @@ export function createSubagentExecutor(deps) {
                                     ...(result.details.results[0]?.sessionFile ? { sessionPath: result.details.results[0].sessionFile } : {}),
                                     artifactPaths: child.artifactPaths,
                                     ...(["completed", "failed"].includes(childStatus) ? { completedAt: new Date().toISOString() } : {}),
+                                    acceptanceStatus: missionAcceptanceStatus(result.details.results),
                                     heartbeat: { status: childStatus, ...(childPhase ? { phase: childPhase } : {}) },
                                 });
                                 if (result.details.asyncId) {
@@ -6137,7 +6114,7 @@ export function createSubagentExecutor(deps) {
             let lastProgressAt = 0;
             let workflowProgressClosed = false;
             const workflowDeadlineAt = timeout === undefined ? undefined : Date.now() + timeout;
-            const workflowCapabilityCeiling = intersectSubagentCapabilityCeilings(requestParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(resolveCurrentSessionId(ctx.sessionManager)));
+            const workflowCapabilityCeiling = intersectSubagentCapabilityCeilings(requestParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(ctx.sessionManager.getSessionId() ?? undefined));
             const sendWorkflowProgress = () => {
                 if (workflowProgressClosed)
                     return;
@@ -6294,6 +6271,7 @@ export function createSubagentExecutor(deps) {
                             ...(result.details.results[0]?.sessionFile ? { sessionPath: result.details.results[0].sessionFile } : {}),
                             artifactPaths: child.artifactPaths,
                             ...(["completed", "failed"].includes(childStatus) ? { completedAt: new Date().toISOString() } : {}),
+                            acceptanceStatus: missionAcceptanceStatus(result.details.results),
                             heartbeat: { status: childStatus, ...(childPhase ? { phase: childPhase } : {}) },
                         });
                         return child;
@@ -7061,22 +7039,22 @@ export function createSubagentExecutor(deps) {
                 if (stopResult)
                     return stopResult;
                 return {
-                    content: [{ type: "text", text: "No stoppable async run found in this session." }],
+                    content: [{ type: "text", text: `No stoppable async run found for '${targetRunId}'.` }],
                     isError: true,
                     details: { mode: "management", results: [] },
                 };
             }
             if (action === "interrupt") {
                 const targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
+                if (!targetRunId)
+                    return { content: [{ type: "text", text: "action='interrupt' requires id." }], isError: true, details: { mode: "management", results: [] } };
                 let resolved;
-                if (targetRunId) {
-                    try {
-                        resolved = resolveSubagentRunId(targetRunId, omitUndefinedProperties({ state: deps.state, nested: nestedResolutionScopeForExecutor(deps) }));
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
-                    }
+                try {
+                    resolved = resolveSubagentRunId(targetRunId, omitUndefinedProperties({ state: deps.state, nested: nestedResolutionScopeForExecutor(deps) }));
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
                 }
                 if (resolved?.kind === "nested")
                     return interruptNestedRun(resolved);
@@ -7101,7 +7079,7 @@ export function createSubagentExecutor(deps) {
                 if (asyncInterruptResult)
                     return asyncInterruptResult;
                 return {
-                    content: [{ type: "text", text: "No interrupt-capable run found in this session." }],
+                    content: [{ type: "text", text: `No interrupt-capable run found for '${targetRunId}'.` }],
                     isError: true,
                     details: { mode: "management", results: [] },
                 };
@@ -7117,7 +7095,7 @@ export function createSubagentExecutor(deps) {
                 ...ctx,
                 cwd: requestCwd,
                 config: deps.config,
-                currentSessionId: deps.state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined,
+                piSessionId: ctx.sessionManager.getSessionId() ?? undefined,
                 discoverAgentsAll: deps.discoverAgentsAll,
                 runtimeAgentOwner: deps.pi,
                 onAgentsChanged: deps.onAgentsChanged,
@@ -7218,7 +7196,7 @@ export function createSubagentExecutor(deps) {
         let prepareForkSessionForIndex = async () => { };
         // Check before pruner/session preparation, then recheck immediately before each fork
         // because the session capability ceiling can tighten while preparation awaits.
-        const launchCapabilityCeiling = () => intersectSubagentCapabilityCeilings(intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestSessionId)), deps.childRuntime?.capabilityCeiling);
+        const launchCapabilityCeiling = () => intersectSubagentCapabilityCeilings(intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestPiSessionId)), deps.childRuntime?.capabilityCeiling);
         const assertLaunchableAgentsAllowedBeforeFork = () => {
             if (!contextPolicy.usesFork)
                 return;
@@ -7499,7 +7477,7 @@ export function createSubagentExecutor(deps) {
             scopedModelIds: scopedModelIdsFromContext(ctx),
             parentSessionId: requestSessionId,
             parentPiSessionId: requestPiSessionId,
-            capabilityCeiling: intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestSessionId)),
+            capabilityCeiling: intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestPiSessionId)),
             runFanoutBudget,
             topLevelAsyncCapacityEligible,
             activeAsyncCapacity,

package/src/runs/shared/capability-ceiling.d.ts

@@ -48,7 +48,8 @@ export declare function parseSubagentCapabilityCeiling(value: unknown, field?: s
 export declare function registerSubagentCapabilityCeiling(options: RegisterSubagentCapabilityCeilingOptions): SubagentCapabilityCeilingHandle;
 export declare function intersectSubagentCapabilityCeilings(...ceilings: Array<ResolvedSubagentCapabilityCeiling | undefined>): ResolvedSubagentCapabilityCeiling | undefined;
 export declare function resolveSubagentCapabilityCeiling(sessionId: string | undefined, inherited?: ResolvedSubagentCapabilityCeiling): ResolvedSubagentCapabilityCeiling | undefined;
-export declare function resolveCurrentSubagentCapabilityCeiling(sessionId: string | undefined): ResolvedSubagentCapabilityCeiling | undefined;
+/** Ceilings are registered under `ctx.sessionManager.getSessionId()`; pass that id, never the session file path. */
+export declare function resolveCurrentSubagentCapabilityCeiling(piSessionId: string | undefined): ResolvedSubagentCapabilityCeiling | undefined;
 export declare function isAgentAllowedByCapabilityCeiling(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): boolean;
 export declare function capabilityCeilingAgentRestrictionMessage(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): string | undefined;
 export declare function assertAgentAllowedByCapabilityCeiling(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): void;

package/src/runs/shared/capability-ceiling.js

@@ -135,8 +135,9 @@ export function resolveSubagentCapabilityCeiling(sessionId, inherited) {
     }
     return intersectSubagentCapabilityCeilings(inherited, ...active);
 }
-export function resolveCurrentSubagentCapabilityCeiling(sessionId) {
-    return resolveSubagentCapabilityCeiling(sessionId, undefined);
+/** Ceilings are registered under `ctx.sessionManager.getSessionId()`; pass that id, never the session file path. */
+export function resolveCurrentSubagentCapabilityCeiling(piSessionId) {
+    return resolveSubagentCapabilityCeiling(piSessionId, undefined);
 }
 export function isAgentAllowedByCapabilityCeiling(agentName, ceiling) {
     return ceiling?.allowedAgents === undefined || ceiling.allowedAgents.includes(agentName);

package/src/runs/shared/child-session.d.ts

@@ -109,6 +109,8 @@ export interface ChildSession {
     readonly modelId: string | undefined;
     /** Provider id of the selected model when this child inherited that provider from the parent's registry instead of loading its extension. */
     readonly inheritedProvider?: string;
+    /** Provider id of the selected model when an extension in this child's model runtime registered that provider, at load or later (e.g. on `session_start`). */
+    readonly claimedProvider?: string;
     /** Live provider/id of the selected model when Pi marks it virtual (`api === "pi-virtual"`); assistant messages then name the dispatched physical model. */
     readonly virtualModelId?: string;
     readonly contextWindow?: number;

package/src/runs/shared/child-session.js

@@ -633,6 +633,7 @@ export function createDefaultChildSessionFactory(options = {}) {
                 get sessionId() { return session.sessionId; },
                 get modelId() { return session.model ? `${session.model.provider}/${session.model.id}` : undefined; },
                 get inheritedProvider() { return session.model && inheritedProviders.has(session.model.provider) ? session.model.provider : undefined; },
+                get claimedProvider() { return session.model && !inheritedProviders.has(session.model.provider) && modelRuntime.getRegisteredProviderIds().includes(session.model.provider) ? session.model.provider : undefined; },
                 get virtualModelId() { return session.model?.api === "pi-virtual" ? `${session.model.provider}/${session.model.id}` : undefined; },
                 get contextWindow() { return session.model?.contextWindow; },
             };

package/src/runs/shared/model-resolution-diagnostic.d.ts

@@ -31,3 +31,14 @@ export declare function formatChildModelResolutionDiagnostic(diagnostic: ChildMo
 export declare function formatInheritedProviderDiagnostic(diagnostic: ChildModelResolutionDiagnostic & {
     provider: string;
 }): string;
+/**
+ * Explain a background child that failed before any successful response on a
+ * provider a parent extension registered, when that extension did not load in
+ * the child. A parent extension can register a provider under a built-in id,
+ * so the model still resolves in the child, through the built-in provider
+ * rather than the parent's. Whether that caused this failure is unknown here,
+ * hence the conditional wording.
+ */
+export declare function formatMissingParentProviderDiagnostic(diagnostic: ChildModelResolutionDiagnostic & {
+    provider: string;
+}): string;

package/src/runs/shared/model-resolution-diagnostic.js

@@ -89,3 +89,28 @@ export function formatInheritedProviderDiagnostic(diagnostic) {
         `If ${provider} depends on those hooks, run this agent with \`async: true\` (a background child loads the ambient extensions unless the agent sets \`extensions\`), or load the extension for this agent with \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter.`,
     ].join("\n");
 }
+/**
+ * Explain a background child that failed before any successful response on a
+ * provider a parent extension registered, when that extension did not load in
+ * the child. A parent extension can register a provider under a built-in id,
+ * so the model still resolves in the child, through the built-in provider
+ * rather than the parent's. Whether that caused this failure is unknown here,
+ * hence the conditional wording.
+ */
+export function formatMissingParentProviderDiagnostic(diagnostic) {
+    const subject = diagnostic.agent ? `Agent '${diagnostic.agent}'` : "Subagent";
+    const model = diagnostic.model ? `'${diagnostic.model}'` : "this model";
+    const provider = `'${diagnostic.provider}'`;
+    const facts = `${subject} ran as a background child without the ambient extensions. In the parent, provider ${provider} for ${model} is registered by an extension that did not load in this child, so the child sent its requests without that extension's provider, through the built-in provider of the same id if there is one.`;
+    if (capabilityCeilingDeniesExtensions(diagnostic)) {
+        return [
+            facts,
+            `${denyExtensionsClause(diagnostic)}, so that extension cannot load for this child: listed \`subagentOnlyExtensions\` or \`extensions\` entries are suppressed, and leaving \`extensions\` unset does not enable ambient loading.`,
+            `If ${provider} depends on that extension, relax the capability ceiling to allow extensions, or use a model whose provider does not.`,
+        ].join("\n");
+    }
+    return [
+        facts,
+        `If ${provider} depends on that extension, list it in \`subagentOnlyExtensions\` or \`extensions\` in the agent frontmatter, leave \`extensions\` unset so the child loads the ambient extensions, or register it from the host with \`registerRequiredChildExtensions\` so it loads for every launch.`,
+    ].join("\n");
+}

package/src/runs/shared/parallel-handoff.d.ts

@@ -23,7 +23,7 @@ export declare function resolveParallelHandoffChild(input: {
     child: ParallelHandoffGroup["children"][number];
 } | undefined;
 export declare function protectRetainedWorktreeForResume(manifestPath: string, runId: string, childIndex: number, signal?: AbortSignal): Promise<string>;
-export declare function resolveRetainedWorktreeCwd(manifestPath: string, runId: string, childIndex: number): string | undefined;
+export declare function resolveRetainedWorktreeCwd(manifestPath: string, runId: string, childIndex: number, recordedWorktreePath?: string): string | undefined;
 export declare function isTerminalParallelHandoffChildStatus(status: unknown): boolean;
 export declare function formatStoredParallelHandoffCleanup(manifestPath: string, manifest?: ParallelHandoffManifest): string;
 export interface ParallelHandoffEvidenceResult {

package/src/runs/shared/parallel-handoff.js

@@ -165,17 +165,18 @@ export async function protectRetainedWorktreeForResume(manifestPath, runId, chil
         return cwd;
     }), { signal }));
 }
-export function resolveRetainedWorktreeCwd(manifestPath, runId, childIndex) {
+export function resolveRetainedWorktreeCwd(manifestPath, runId, childIndex, recordedWorktreePath) {
     const manifest = readParallelHandoffManifest(manifestPath);
-    if (!manifest)
-        return undefined;
-    if (manifest.runId !== runId)
+    if (manifest && manifest.runId !== runId)
         throw new Error(`Managed worktree handoff belongs to run '${manifest.runId}', not '${runId}'.`);
-    const match = manifest.groups
+    const match = manifest?.groups
         .flatMap((group) => group.children.map((child) => ({ group, child })))
         .find(({ child }) => child.index === childIndex);
-    if (!match)
+    if (!manifest || !match) {
+        if (recordedWorktreePath)
+            throw new Error(`Async run '${runId}' child ${childIndex} ran in managed worktree ${recordedWorktreePath}, but its handoff has no resumable record yet. Retry after the run settles; if it already ended, inspect ${manifestPath}.`);
         return undefined;
+    }
     const cleanup = match.group.cleanup.tasks.find((task) => task.index === match.child.taskIndex);
     if (!cleanup)
         throw new Error(`Async run '${runId}' child ${childIndex} has no managed worktree cleanup record.`);
@@ -185,6 +186,9 @@ export function resolveRetainedWorktreeCwd(manifestPath, runId, childIndex) {
     const requiredCwd = path.join(cleanup.path, relativeCwd);
     if (cleanup.worktreeRemoved || cleanup.branchRemoved)
         throw new Error(`Async run '${runId}' required managed worktree was removed: ${requiredCwd}`);
+    // The runner removes the worktree right after this marker, without the locks that guard resume admission.
+    if (cleanup.reason?.includes("pending durable handoff capture"))
+        throw new Error(`Async run '${runId}' child ${childIndex} is still finalizing its managed worktree: ${requiredCwd}. Retry after the run settles; if it already ended, inspect ${manifestPath}.`);
     let worktreeRoot = "";
     let resolvedRequiredCwd = "";
     try {

package/src/runs/shared/parallel-utils.d.ts

@@ -55,6 +55,8 @@ export interface RunnerSubagentStep {
     }>;
     modelResponseAliases?: Record<string, string[]>;
     tools?: string[];
+    /** Provider of `model` that a parent extension registers; set only when this child loads no ambient extensions. */
+    parentExtensionProvider?: string;
     excludeTools?: string[];
     allowNestedSubagents?: boolean;
     /** Resolved selected-agent policy for launches made by this child. */

package/src/shared/types.d.ts

@@ -1936,7 +1936,7 @@ export interface AsyncStatus {
         label?: string;
         workflowKey?: string;
         lane?: WorkflowLaneMetadata;
-        /** Display-only worktree path copied at launch; handoff remains authoritative. */
+        /** Worktree path copied at setup; the handoff stays authoritative for the cwd. */
         worktreePath?: string;
         /** Display-only branch copied at launch; handoff remains authoritative. */
         branch?: string;

package/src/workflows/scripted-workflow.js

@@ -774,17 +774,22 @@ export function validateWorkflowScript(script, options = {}) {
         : undefined;
     const workflowBody = wrapper && astNode(wrapper.body) ? wrapper.body : root;
     // A rebound `runs` may not be the workflow API, so its calls prove nothing about child launches.
-    const agentNameError = options.agentNameError && !invalidatesRunsBinding(workflowBody) ? options.agentNameError : undefined;
+    const runsRebound = invalidatesRunsBinding(workflowBody);
+    const agentNameError = options.agentNameError && !runsRebound ? options.agentNameError : undefined;
     walkAst(workflowBody, (node) => {
         if (node !== wrapper && node.async === true && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")) {
             errors.push({ message: "workflowScript does not support nested async functions. Use top-level await, plain helper functions that return runs.run(...), or explicit Promise chains.", ...nodeLocation(node) });
         }
+        if (node.type === "ImportExpression")
+            errors.push({ message: "workflowScript cannot load modules with import().", ...nodeLocation(node) });
         if (directRunsCall(node, "run")) {
             const args = Array.isArray(node.arguments) ? node.arguments : [];
             const keyNode = astNode(args[0]) ? args[0] : undefined;
             const key = literalString(keyNode);
             if (keyNode && key !== undefined && !KEY_PATTERN.test(key))
                 errors.push({ message: "runs.run key must be 1-128 characters using letters, numbers, '.', '_' or '-', and start with a letter or number.", ...nodeLocation(keyNode) });
+            if (keyNode?.type === "ObjectExpression" && !runsRebound)
+                errors.push({ message: `runs.run expects (key, params); got an object as the first argument. Use runs.run("plan", { agent, task }) or runs.all([{ key, agent, task }]).`, ...nodeLocation(keyNode) });
             if (astNode(args[1])) {
                 errors.push(...validateStaticBaseRef(args[1], "runs.run"));
                 const message = definitelyNonJson(args[1]);