pi-subagents 0.83.0 → 0.83.1

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: [] },
         };
@@ -1086,7 +1057,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) {
@@ -1562,7 +1533,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 },
@@ -1858,7 +1829,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,
         }));
@@ -2028,7 +1999,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,
@@ -5093,7 +5064,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 +5942,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 +6109,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 +6266,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 +7034,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 +7074,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 +7090,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 +7191,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 +7472,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/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/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,7 +774,8 @@ 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) });
@@ -785,6 +786,8 @@ export function validateWorkflowScript(script, options = {}) {
             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]);

package/workflow-script-worker.cjs

@@ -307,7 +307,7 @@ function laneBoardText(value) {
   if (typeof value !== "string" || !value) return undefined;
   if (laneByteLength(value) <= MAX_LANE_BOARD_TEXT_BYTES) return value;
   const bytes = new TextEncoder().encode(value).subarray(0, MAX_LANE_BOARD_TEXT_BYTES - 3);
-  return new TextDecoder().decode(bytes) + "...";
+  return new TextDecoder().decode(bytes, { stream: true }) + "...";
 }
 
 function laneBoardPath(value) {
@@ -758,6 +758,7 @@ function launchRunsAllPermissive(items) {
 
 const runs = Object.freeze({
   run(key, params) {
+    if (key && typeof key === "object" && !Array.isArray(key)) throw new Error('runs.run expects (key, params); got an object as the first argument. Use runs.run("plan", { agent, task }) or runs.all([{ key, agent, task }]).');
     validateRunCall(key, params, "runs.run", runFingerprints);
     const launched = runHostCall(key, params, false);
     return trackRunObservation([{ key, operation: "run", callId: launched.callId }], launched.promise.then(decorateWorkflowChildResult));