pi-subagents 0.83.0 → 0.84.0

package/src/agents/frontmatter.js

@@ -97,22 +97,15 @@ export function parseFrontmatter(content) {
         // neither end a pending list block nor become part of its value.
         if (trimmed.startsWith("#") && !currentFolded && !currentLiteral)
             continue;
-        if (currentKey !== null && currentBlockLines !== null && (indent > (currentIndent ?? 0) || ((currentFolded || currentLiteral) && trimmed === ""))) {
+        // Exactly-empty lines belong to any pending block, not only to | and > scalars.
+        if (currentKey !== null && currentBlockLines !== null && (indent > (currentIndent ?? 0) || trimmed === "")) {
             // This line is part of the current block value
             currentBlockLines.push(line);
             continue;
         }
         // Flush any pending block value
         if (currentKey !== null && currentBlockLines !== null) {
-            // Strip the common leading whitespace from the block so the
-            // serializer can add its own indentation level.
-            const rawBlock = currentBlockLines.join("\n");
-            const leadingSpaces = rawBlock.match(/^[ \t]+(?=\S)/m);
-            const prefix = leadingSpaces?.[0] ?? "";
-            const stripped = prefix
-                ? rawBlock.replace(new RegExp(`^${escapeRegex(prefix)}`, "gm"), "").replace(/^\n/, "")
-                : rawBlock;
-            frontmatter[currentKey] = currentFolded ? foldBlock(stripped) : stripped;
+            frontmatter[currentKey] = flushBlockLines(currentBlockLines, currentFolded, currentLiteral);
             currentKey = null;
             currentBlockLines = null;
             currentIndent = null;
@@ -146,17 +139,28 @@ export function parseFrontmatter(content) {
                 frontmatter[key] = value;
             }
         }
-        // Lines that don't match a key pattern (e.g., comments, empty lines) are ignored
     }
     // Flush final block value
     if (currentKey !== null && currentBlockLines !== null) {
-        const rawBlock = currentBlockLines.join("\n");
-        const leadingSpaces = rawBlock.match(/^[ \t]+(?=\S)/m);
-        const prefix = leadingSpaces?.[0] ?? "";
-        const stripped = prefix
-            ? rawBlock.replace(new RegExp(`^${escapeRegex(prefix)}`, "gm"), "").replace(/^\n/, "")
-            : rawBlock;
-        frontmatter[currentKey] = currentFolded ? foldBlock(stripped) : stripped;
+        frontmatter[currentKey] = flushBlockLines(currentBlockLines, currentFolded, currentLiteral);
     }
     return { frontmatter, body };
 }
+function flushBlockLines(blockLines, folded, literal) {
+    let lines = blockLines;
+    if (!folded && !literal) {
+        // Drop exactly-empty edge lines, and every line from the first exactly-empty one after
+        // the last content line, so nested values without inner blank lines parse as before.
+        const end = lines.indexOf("", lines.findLastIndex((line) => line.trim() !== "") + 1);
+        lines = lines.slice(lines.findIndex((line) => line !== ""), end < 0 ? lines.length : end);
+    }
+    // Strip the common leading whitespace from the block so the
+    // serializer can add its own indentation level.
+    const rawBlock = lines.join("\n");
+    const leadingSpaces = rawBlock.match(/^[ \t]+(?=\S)/m);
+    const prefix = leadingSpaces?.[0] ?? "";
+    const stripped = prefix
+        ? rawBlock.replace(new RegExp(`^${escapeRegex(prefix)}`, "gm"), "").replace(/^\n/, "")
+        : rawBlock;
+    return folded ? foldBlock(stripped) : stripped;
+}

package/src/extension/index.js

@@ -735,7 +735,7 @@ export default function registerSubagentExtension(pi) {
             event.systemPromptOptions.sections.active_subagents = activeRuns;
         if (!event.systemPromptOptions.selectedTools.includes("subagent"))
             return;
-        const catalog = buildAdvertisedAgentCatalog(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(sessionId), recordedPromptSection(pi, "advertised_subagents"));
+        const catalog = buildAdvertisedAgentCatalog(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(ctx.sessionManager.getSessionId() ?? undefined), recordedPromptSection(pi, "advertised_subagents"));
         if (catalog)
             event.systemPromptOptions.sections.advertised_subagents = catalog;
     });
@@ -1207,7 +1207,7 @@ export default function registerSubagentExtension(pi) {
         hasPendingSupervisorRequest: () => [...supervisorChannel.pending.values()].some((request) => request.expectsReply),
         advertisedPrompt: async () => {
             await waitForAdvertisement();
-            return buildAdvertisedAgentPrompt(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(state.currentSessionId ?? undefined));
+            return buildAdvertisedAgentPrompt(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(state.supervisorOwnerSessionId ?? undefined));
         },
     });
 }

package/src/missions/actions.js

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { MISSION_STATUSES, } from "./types.js";
 import { missionStatePath } from "./workflow-state.js";
+import { finishedMissionStatus, missionAcceptanceStatus, readMissionBinding } from "./lifecycle.js";
 import { createMission, listGlobalMissions, listMissions, missionRecordPath, readMission, resolveMissionStoreLocation, updateMission, validateMissionId, } from "./store.js";
 export const MISSION_ACTIONS = [
     "mission.create",
@@ -184,6 +185,7 @@ function validateMissionUpdate(value) {
 }
 function refreshLinkedRunStatus(location, record) {
     const warnings = [];
+    const runAcceptance = [];
     const updates = record.runs.flatMap((run) => {
         if (!run.asyncDir)
             return [];
@@ -207,6 +209,7 @@ function refreshLinkedRunStatus(location, record) {
             warnings.push(`Linked run status '${statusPath}' is missing state`);
             return [];
         }
+        runAcceptance.push({ runId: run.runId, status: missionAcceptanceStatus(status.steps) });
         if (state === run.status)
             return [];
         return [{
@@ -232,7 +235,8 @@ function refreshLinkedRunStatus(location, record) {
                         : states.some((state) => state === "stopped" || state === "rejected" || state === "cancelled")
                             ? "cancelled"
                             : states.length > 0 && states.every((state) => state === "complete" || state === "completed")
-                                ? "completed"
+                                // A run without a binding counts as auto-created.
+                                ? finishedMissionStatus(record, !merged.some((run) => run.asyncDir && readMissionBinding(run.asyncDir)?.autoCreated === false), runAcceptance)
                                 : record.status;
     return { record: updateMission(location, record.id, { status, addRuns: updates }), warnings };
 }
@@ -261,7 +265,8 @@ function formatMission(record) {
             const identity = child.runId ? `${child.key} (${child.runId})` : child.key;
             const heartbeat = child.heartbeat ? `; heartbeat ${child.heartbeat.status ?? child.status}${child.heartbeat.phase ? `/${child.heartbeat.phase}` : ""} at ${child.heartbeat.updatedAt}` : "";
             const recovery = child.sessionPath ? `; session ${child.sessionPath}` : child.artifactPaths.length ? `; artifacts ${child.artifactPaths.length}` : "";
-            lines.push(`  ${identity}: ${child.status}${child.agent ? ` — ${child.agent}` : ""}${child.phase ? ` [${child.phase}]` : ""}; updated ${child.updatedAt}${heartbeat}${recovery}`);
+            const acceptance = child.acceptanceStatus ? `; acceptance ${child.acceptanceStatus}` : "";
+            lines.push(`  ${identity}: ${child.status}${child.agent ? ` — ${child.agent}` : ""}${child.phase ? ` [${child.phase}]` : ""}${acceptance}; updated ${child.updatedAt}${heartbeat}${recovery}`);
         }
     }
     if (record.decisions.length) {

package/src/missions/lifecycle.d.ts

@@ -21,6 +21,7 @@ export interface MissionLaunchParams {
 export interface MissionLaunchBinding {
     missionId: string;
     location: MissionStoreLocation;
+    /** True when the launch made the mission without a `mission` or `missionId` request. */
     autoCreated: boolean;
     announceInContent?: boolean;
 }
@@ -30,6 +31,16 @@ export declare function prepareMissionLaunch(input: {
     config?: MissionStoreConfig;
     ownerSessionId?: string;
 }): MissionLaunchBinding | undefined;
+/** The first unaccepted acceptance status among child results, else the first status found. */
+export declare function missionAcceptanceStatus(results: unknown): string | undefined;
+/**
+ * The status of a mission whose runs all finished successfully. Every path that
+ * completes a mission from run state goes through here.
+ */
+export declare function finishedMissionStatus(record: MissionRecord, autoCreated: boolean, runAcceptance: ReadonlyArray<{
+    runId: string;
+    status: string | undefined;
+}>): "completed" | "waiting";
 export declare function writeMissionAsyncBinding(asyncDir: string, binding: MissionLaunchBinding): void;
 export declare function attachMissionToLaunchResult(input: {
     binding: MissionLaunchBinding;

package/src/missions/lifecycle.js

@@ -50,7 +50,7 @@ export function prepareMissionLaunch(input) {
         ...(mission?.labels ? { labels: mission.labels } : {}),
         ...(input.ownerSessionId ? { ownerSessionId: input.ownerSessionId } : {}),
     }, new Date(), input.config?.retainTerminal);
-    return { missionId: record.id, location, autoCreated: true, announceInContent: true };
+    return { missionId: record.id, location, autoCreated: input.params.mission === undefined, announceInContent: true };
 }
 function toolResultIsError(result) {
     return "isError" in result && result.isError === true;
@@ -67,7 +67,30 @@ function runStatusForResult(result) {
         return "failed";
     return "completed";
 }
-function missionStatusForRun(record, runId, runStatus) {
+/** Acceptance statuses that mean nobody accepted the child's result. */
+const UNACCEPTED_ACCEPTANCE_STATUSES = new Set(["pending", "claimed", "review-required", "rejected"]);
+/** The first unaccepted acceptance status among child results, else the first status found. */
+export function missionAcceptanceStatus(results) {
+    const statuses = (Array.isArray(results) ? results : [])
+        .map((result) => result?.acceptance?.status)
+        .filter((status) => typeof status === "string" && status.trim() !== "");
+    return statuses.find((status) => UNACCEPTED_ACCEPTANCE_STATUSES.has(status)) ?? statuses[0];
+}
+/**
+ * The status of a mission whose runs all finished successfully. Every path that
+ * completes a mission from run state goes through here.
+ */
+export function finishedMissionStatus(record, autoCreated, runAcceptance) {
+    // Nobody is expected to close a mission made by default for an ordinary launch.
+    if (autoCreated)
+        return "completed";
+    if (runAcceptance.some((run) => UNACCEPTED_ACCEPTANCE_STATUSES.has(run.status)))
+        return "waiting";
+    // A run reported here supersedes its older workflow child record.
+    const reported = new Set(runAcceptance.map((run) => run.runId));
+    return record.workflowChildren.some((child) => !reported.has(child.runId) && UNACCEPTED_ACCEPTANCE_STATUSES.has(child.acceptanceStatus)) ? "waiting" : "completed";
+}
+function missionStatusForRun(record, runId, runStatus, acceptanceStatus, autoCreated) {
     if (record.status === "completed" || record.status === "failed" || record.status === "cancelled")
         return record.status;
     if (runStatus === "active" || runStatus === "queued" || runStatus === "running")
@@ -80,7 +103,7 @@ function missionStatusForRun(record, runId, runStatus) {
     if (otherActive)
         return "active";
     if (runStatus === "completed" || runStatus === "complete")
-        return "completed";
+        return finishedMissionStatus(record, autoCreated, [{ runId, status: acceptanceStatus }]);
     if (runStatus === "stopped" || runStatus === "rejected" || runStatus === "cancelled")
         return "cancelled";
     return "failed";
@@ -129,6 +152,7 @@ function persistedBinding(binding) {
         globalIndexDir: binding.location.globalIndexDir,
         writeGlobalIndex: binding.location.writeGlobalIndex,
         ...(binding.location.retainTerminal !== undefined ? { retainTerminal: binding.location.retainTerminal } : {}),
+        autoCreated: binding.autoCreated,
     };
 }
 export function writeMissionAsyncBinding(asyncDir, binding) {
@@ -170,7 +194,7 @@ export function attachMissionToLaunchResult(input) {
         ...(usage ? { usage } : {}),
     };
     let mission = updateMission(input.binding.location, input.binding.missionId, {
-        status: missionStatusForRun(current, runId, runStatus),
+        status: missionStatusForRun(current, runId, runStatus, missionAcceptanceStatus(input.result.details.results), input.binding.autoCreated),
         addRuns: [run],
         addArtifacts: artifactsForResult(input.result),
         ...(firstText(input.result) && runStatus !== "active" ? { summary: firstText(input.result) } : {}),
@@ -188,6 +212,8 @@ export function attachMissionToLaunchResult(input) {
                         asyncDir: input.result.details.asyncDir,
                         mode: input.result.details.mode,
                         state: status.state,
+                        // A run that finished before this launch result was attached keeps its acceptance in the status steps.
+                        ...(Array.isArray(status.steps) ? { results: status.steps.map((step) => ({ acceptance: step?.acceptance })) } : {}),
                         ...(firstText(input.result) ? { summary: firstText(input.result) } : {}),
                     }) ?? mission;
                 }
@@ -237,9 +263,12 @@ function parsePersistedBinding(value, source) {
         throw new Error(`${source}.writeGlobalIndex must be boolean`);
     if (input.retainTerminal !== undefined && (!Number.isInteger(input.retainTerminal) || input.retainTerminal < 1))
         throw new Error(`${source}.retainTerminal must be a positive integer`);
+    if (input.autoCreated !== undefined && typeof input.autoCreated !== "boolean")
+        throw new Error(`${source}.autoCreated must be boolean`);
     return {
         missionId: validateMissionId(input.missionId, `${source}.missionId`),
-        autoCreated: false,
+        // Bindings saved before this field existed belong to runs that completed their mission without an acceptance check.
+        autoCreated: input.autoCreated !== false,
         location: {
             projectRoot: input.projectRoot,
             missionDir: input.missionDir,
@@ -339,8 +368,9 @@ export function syncMissionFromAsyncCompletion(value) {
                 ? "stopped"
                 : "failed";
     const workflowChildTerminal = !["running", "queued", "active", "paused"].includes(workflowChildStatus);
+    const acceptanceStatus = missionAcceptanceStatus(event.results);
     return updateMission(binding.location, binding.missionId, {
-        status: missionStatusForRun(current, runId, runStatus),
+        status: missionStatusForRun(current, runId, runStatus, acceptanceStatus, binding.autoCreated),
         addRuns: [{ runId, mode: typeof event.mode === "string" && ["single", "parallel", "chain", "workflow"].includes(event.mode) ? event.mode : "external", asyncDir: event.asyncDir, status: runStatus, completedAt, ...(usage && usage.tokens > 0 ? { usage } : {}) }],
         addArtifacts: artifacts,
         ...(workflowRunId && workflowKey ? { upsertWorkflowChildren: [{
@@ -350,6 +380,7 @@ export function syncMissionFromAsyncCompletion(value) {
                     status: workflowChildStatus,
                     artifactPaths: artifacts.map((artifact) => artifact.path),
                     ...(workflowChildTerminal ? { completedAt } : {}),
+                    ...(acceptanceStatus ? { acceptanceStatus } : {}),
                     heartbeat: { status: workflowChildStatus, ...(summary ? { message: summary } : {}) },
                 }] } : {}),
         ...(summary ? { summary } : {}),

package/src/missions/store.js

@@ -133,6 +133,7 @@ function parseWorkflowChild(value, label) {
         ...(optionalString(input.phase, `${label}.phase`) ? { phase: input.phase } : {}),
         ...(input.completedAt !== undefined ? { completedAt: timestamp(input.completedAt, `${label}.completedAt`) } : {}),
         ...(optionalString(input.sessionPath, `${label}.sessionPath`) ? { sessionPath: input.sessionPath } : {}),
+        ...(optionalString(input.acceptanceStatus, `${label}.acceptanceStatus`) ? { acceptanceStatus: input.acceptanceStatus } : {}),
         ...(heartbeat ? { heartbeat: {
                 updatedAt: timestamp(heartbeat.updatedAt, `${label}.heartbeat.updatedAt`),
                 ...(optionalString(heartbeat.status, `${label}.heartbeat.status`) ? { status: heartbeat.status } : {}),

package/src/missions/types.d.ts

@@ -57,6 +57,8 @@ export interface MissionWorkflowChild {
     sessionPath?: string;
     artifactPaths: string[];
     heartbeat?: MissionChildHeartbeat;
+    /** Latest acceptance ledger status reported for the child. */
+    acceptanceStatus?: string;
 }
 export type MissionWorkflowChildUpdate = Pick<MissionWorkflowChild, "workflowRunId" | "key" | "status"> & Partial<Omit<MissionWorkflowChild, "workflowRunId" | "key" | "status" | "startedAt" | "updatedAt" | "artifactPaths" | "heartbeat">> & {
     startedAt?: string;

package/src/runs/background/async-execution.d.ts

@@ -2,6 +2,7 @@
  * Async execution logic for subagent tool
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ParentProviderRegistry } from "../shared/child-session.ts";
 import { type AgentConfig, type UnknownAgentDiagnosticContext } from "../../agents/agents.ts";
 import { type ClaudeCodeOverride } from "../shared/claude-code-adapter.ts";
 import { type ChainStep } from "../../shared/settings.ts";
@@ -25,7 +26,7 @@ interface AsyncExecutionContext {
     cwd: string;
     currentSessionId: string;
     completionOwnerId?: string;
-    /** Parent session id used by permission-system ask forwarding. */
+    /** Parent Pi session id (`getSessionId()`): keys permission-system ask forwarding and capability ceilings. */
     parentSessionId?: string;
     /** Parent session file, recorded as each new child session's `parentSession` header. */
     parentSessionFile?: string;
@@ -44,6 +45,8 @@ interface AsyncExecutionContext {
     childRuntime?: ChildRuntimeConfig;
     /** The launching session's project trust; undefined when the host has no trust concept. */
     projectTrusted?: boolean;
+    /** The parent's model registry, read at launch to name a provider an extension registered there. */
+    parentProviderRegistry?: Pick<ParentProviderRegistry, "getRegisteredProviderIds">;
 }
 export declare const DEFAULT_ASYNC_TIMEOUT_MS: number;
 interface AsyncChainParams {

package/src/runs/background/async-execution.js

@@ -135,6 +135,17 @@ function supportsNativeRunner(nodeExecutable) {
         && nodeExecutable === process.execPath
         && !sourceUnderNodeModules();
 }
+/**
+ * A runner child without the ambient extensions does not load the parent extension that
+ * registered its model's provider, and still resolves the model when a built-in provider
+ * has the same id. Name that provider so a failed run can say so.
+ */
+function parentExtensionProviderForChild(ctx, disableAmbientExtensions, model, availableModels, preferredProvider) {
+    if (!disableAmbientExtensions || !ctx.parentProviderRegistry)
+        return undefined;
+    const provider = findModelInfo(model, availableModels, preferredProvider)?.provider;
+    return provider && ctx.parentProviderRegistry.getRegisteredProviderIds().includes(provider) ? provider : undefined;
+}
 export const DEFAULT_ASYNC_TIMEOUT_MS = 30 * 60 * 1000;
 export function formatAsyncStartedMessage(headline, interactive) {
     const guidance = interactive
@@ -997,6 +1008,7 @@ export function buildAsyncRunnerSteps(id, params) {
             runtimeSnapshotHost: ctx.pi,
         });
         const launchResolvedExtensions = externalRunner ? undefined : projectLaunchResolvedChildExtensions(toolPlan);
+        const parentExtensionProvider = externalRunner || machine ? undefined : parentExtensionProviderForChild(ctx, toolPlan.disableAmbientExtensions, selectedModel, availableModels, a.modelProvider ?? ctx.currentModelProvider);
         if (externalRunner && permissionRules) {
             throw new AsyncStartValidationError(`Agent '${a.name}' uses runner.type='${externalRunnerType}', which cannot enforce native Pi child permission rules.`);
         }
@@ -1026,6 +1038,7 @@ export function buildAsyncRunnerSteps(id, params) {
             thinking: resolveEffectiveThinking(selectedModel, effectiveThinking),
             ...(thinkingCeiling ? { thinkingCeiling } : {}),
             launchResolvedExtensions,
+            ...(parentExtensionProvider ? { parentExtensionProvider } : {}),
             ...(requestedModel ? { requestedModel } : {}),
             ...(primaryModelFromParent ? { skipPrimaryModelVerification: true } : {}),
             ...(availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {}),
@@ -1233,7 +1246,8 @@ export function executeAsyncChain(id, params) {
         .find((name) => name !== undefined && !lookupRunnerLauncher(ctx.runnerLaunchers, name));
     if (undefinedLauncher !== undefined)
         return formatAsyncStartError(resultMode, `Launcher '${undefinedLauncher}' used by this ${resultMode} is not defined in runnerLaunchers in the user subagent config.`);
-    const capabilityCeiling = params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId);
+    const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
+    const capabilityCeiling = params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(launchParentSessionId);
     const inheritedNestedRoute = inheritedNestedRouteOf(ctx.childRuntime);
     const nestedAddress = inheritedNestedRoute ? inheritedNestedParentAddressOf(ctx.childRuntime) : undefined;
     const asyncDir = inheritedNestedRoute
@@ -1336,7 +1350,6 @@ export function executeAsyncChain(id, params) {
     const initialStatusAt = Date.now();
     const initialCompletionOwnerId = ctx.completionOwnerId ?? currentCompletionOwnerId();
     const completionOwnerProcess = currentRecordedPid();
-    const launchParentSessionId = ctx.parentSessionId ?? ctx.currentSessionId;
     try {
         writeRetainedRequiredChildExtensions(asyncDir, params.requiredExtensions ?? ctx.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(launchParentSessionId ?? undefined));
     }
@@ -1600,7 +1613,7 @@ export function executeAsyncSingle(id, params) {
         if (unsupported.length > 0)
             return formatAsyncStartError("single", `Agent '${agentConfig.name}' uses runner.type='${externalRunnerType}' and does not support: ${unsupported.join(", ")}.`);
     }
-    const capabilityCeiling = intersectSubagentCapabilityCeilings(params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.currentSessionId), ctx.childRuntime?.capabilityCeiling);
+    const capabilityCeiling = intersectSubagentCapabilityCeilings(params.capabilityCeiling ?? resolveCurrentSubagentCapabilityCeiling(ctx.parentSessionId ?? ctx.currentSessionId), ctx.childRuntime?.capabilityCeiling);
     try {
         assertAgentAllowedByCapabilityCeiling(agentConfig.name, capabilityCeiling);
     }
@@ -1811,6 +1824,7 @@ export function executeAsyncSingle(id, params) {
         runtimeSnapshotHost: ctx.pi,
     });
     const launchResolvedExtensions = externalRunner ? undefined : projectLaunchResolvedChildExtensions(toolPlan);
+    const parentExtensionProvider = externalRunner || machine ? undefined : parentExtensionProviderForChild(ctx, toolPlan.disableAmbientExtensions, selectedModel, availableModels, agentConfig.modelProvider ?? ctx.currentModelProvider);
     const fast = params.fast ?? agentConfig.fast;
     const launchThinking = resolveEffectiveThinking(selectedModel, effectiveThinking);
     const { definitionDigest, launchContractDigest } = resolveLaunchBinding({
@@ -1933,6 +1947,7 @@ export function executeAsyncSingle(id, params) {
                     ...(params.fast ?? agentConfig.fast ? { fast: params.fast ?? agentConfig.fast } : {}),
                     thinking: resolveEffectiveThinking(selectedModel, effectiveThinking),
                     ...(thinkingCeiling ? { thinkingCeiling } : {}),
+                    ...(parentExtensionProvider ? { parentExtensionProvider } : {}),
                     ...(requestedModel ? { requestedModel } : {}),
                     ...(modelOrigin === "inherited" ? { skipPrimaryModelVerification: true } : {}),
                     ...(availableModels && availableModels.length > 0 ? { modelVerificationRegistry: availableModels } : {}),

package/src/runs/background/async-resume.js

@@ -484,7 +484,8 @@ export function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
     const requireSessionFile = options.requireSessionFile ?? true;
     const location = resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
     if (!location.asyncDir && !location.resultPath) {
-        throw new Error("Async run not found. Provide id or dir.");
+        const requested = params.id ?? params.runId;
+        throw new Error(requested ? `Async run not found for '${requested}'.` : "Async run not found. Provide id or dir.");
     }
     const reconciliation = location.asyncDir
         ? reconcileAsyncRun(location.asyncDir, { resultsDir, kill: deps.kill, now: deps.now })
@@ -606,7 +607,7 @@ export function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
         ? intersectSubagentCapabilityCeilings(status?.admissionCapabilityCeiling, result?.admissionCapabilityCeiling)
         : intersectSubagentCapabilityCeilings(status?.capabilityCeiling, statusSteps[index]?.capabilityCeiling, result?.capabilityCeiling, resultSteps[index]?.capabilityCeiling);
     const managedWorktreeCwd = location.asyncDir
-        ? resolveRetainedWorktreeCwd(parallelHandoffPath(location.asyncDir), runId, index)
+        ? resolveRetainedWorktreeCwd(parallelHandoffPath(location.asyncDir), runId, index, statusSteps[index]?.worktreePath)
         : undefined;
     const resumeCwd = validateResumeCwd(runId, managedWorktreeCwd ?? status?.cwd ?? result?.cwd ?? recoveryDescriptor?.cwd);
     return {

package/src/runs/background/async-retention.d.ts

@@ -3,6 +3,7 @@ export declare const ASYNC_RETENTION_DAYS = 30;
 export declare const ASYNC_RETENTION_BATCH_SIZE = 100;
 export declare const ASYNC_RETENTION_DELAY_MS = 60000;
 export declare const ASYNC_RETENTION_TOMBSTONE_GRACE_MS: number;
+export declare const RESUMABLE_RETENTION_DAYS = 90;
 export interface AsyncRetentionOptions {
     asyncDirRoot: string;
     resultsDir: string;

package/src/runs/background/async-retention.js

@@ -15,7 +15,11 @@ export const ASYNC_RETENTION_DAYS = 30;
 export const ASYNC_RETENTION_BATCH_SIZE = 100;
 export const ASYNC_RETENTION_DELAY_MS = 60_000;
 export const ASYNC_RETENTION_TOMBSTONE_GRACE_MS = 24 * 60 * 60 * 1000;
+// A run or result whose session file still exists can be resumed, so it is kept this long
+// instead of ASYNC_RETENTION_DAYS. Session files outlive run dirs, so without a ceiling it is kept forever.
+export const RESUMABLE_RETENTION_DAYS = 90;
 const RETENTION_MS = ASYNC_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+const RESUMABLE_RETENTION_MS = RESUMABLE_RETENTION_DAYS * 24 * 60 * 60 * 1000;
 const LOCK_NAME = ".async-retention.lock";
 const CURSOR_NAME = ".async-retention-cursor.json";
 const LOG_NAME = "async-retention-maintenance.jsonl";
@@ -239,9 +243,10 @@ function runSkipReason(input) {
         return "mission-reference";
     if (hasUnresolvedRunHandoff(runDir, status))
         return "handoff-reference";
-    if (hasResumableContract(runDir, status))
-        return "resumable";
     const timestamp = statusTimestamp(status, runDir);
+    // Unknown ages stay protected.
+    if (hasResumableContract(runDir, status) && (timestamp === undefined || timestamp > input.resumableCutoff))
+        return "resumable";
     if (timestamp === undefined)
         return "unknown-age";
     if (timestamp > input.cutoff)
@@ -464,13 +469,13 @@ function resultSkipReason(input) {
         return "workflow-reference";
     if (hasUnresolvedResultHandoff(input.data))
         return "handoff-reference";
-    if (resultHasResumableSession(input.data))
+    const timestamp = resultTimestamp(input.data, input.candidate.path);
+    if (resultHasResumableSession(input.data) && (timestamp === undefined || timestamp > input.resumableCutoff))
         return "resumable";
     if (input.candidate.kind === "archive" && fs.existsSync(path.join(input.resultsDir, "completion-replay", `${encodeURIComponent(runId)}.json`)))
         return "replay-reference";
     if (!terminalResult(input.data) && input.candidate.kind !== "replay" && input.candidate.kind !== "archive" && input.candidate.kind !== "tombstone")
         return "non-terminal-result";
-    const timestamp = resultTimestamp(input.data, input.candidate.path);
     if (timestamp === undefined)
         return "unknown-age";
     if (timestamp > input.cutoff)
@@ -690,6 +695,7 @@ export async function cleanupAsyncRetention(options) {
             return finish();
         const protectedRunIds = new Set(options.protectedRunIds ?? []);
         const cutoff = currentTime - retentionMs;
+        const resumableCutoff = currentTime - RESUMABLE_RETENTION_MS;
         const cursor = readCursor(maintenanceRoot);
         const runBudget = Math.ceil(batchSize / 2);
         const resultBudget = batchSize - runBudget;
@@ -765,7 +771,7 @@ export async function cleanupAsyncRetention(options) {
                     if (reconciliation.repaired)
                         result.repairedRuns += 1;
                 }
-                const initialReason = runSkipReason({ runDir, status, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, cutoff, protectedRunIds, waitRunIds: waitReferences.runIds });
+                const initialReason = runSkipReason({ runDir, status, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, cutoff, resumableCutoff, protectedRunIds, waitRunIds: waitReferences.runIds });
                 if (initialReason) {
                     increment(result.skipped, initialReason);
                     continue;
@@ -780,7 +786,7 @@ export async function cleanupAsyncRetention(options) {
                         continue;
                     }
                     const freshWaitReferences = parseWaitRunIds(waitSubscriptionsDir);
-                    const finalReason = freshWaitReferences.safe ? runSkipReason({ runDir, status, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, cutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
+                    const finalReason = freshWaitReferences.safe ? runSkipReason({ runDir, status, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, cutoff, resumableCutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
                     if (finalReason) {
                         increment(result.skipped, `recheck-${finalReason}`);
                         continue;
@@ -805,7 +811,7 @@ export async function cleanupAsyncRetention(options) {
                 }
                 const recheckStatus = readStatus(tombstone);
                 const freshWaitReferences = parseWaitRunIds(waitSubscriptionsDir);
-                const recheckReason = freshWaitReferences.safe ? runSkipReason({ runDir: tombstone, status: recheckStatus, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, cutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
+                const recheckReason = freshWaitReferences.safe ? runSkipReason({ runDir: tombstone, status: recheckStatus, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, cutoff, resumableCutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
                 if (recheckReason) {
                     if (!fs.existsSync(runDir)) {
                         fs.renameSync(tombstone, runDir);
@@ -842,7 +848,7 @@ export async function cleanupAsyncRetention(options) {
                     continue;
                 }
                 const data = readJson(candidate.path);
-                const reason = resultSkipReason({ candidate, data, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, maintenanceRoot, cutoff, protectedRunIds, waitRunIds: waitReferences.runIds });
+                const reason = resultSkipReason({ candidate, data, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, maintenanceRoot, cutoff, resumableCutoff, protectedRunIds, waitRunIds: waitReferences.runIds });
                 if (reason) {
                     increment(result.skipped, reason);
                     continue;
@@ -853,7 +859,7 @@ export async function cleanupAsyncRetention(options) {
                         continue;
                     }
                     const freshWaitReferences = parseWaitRunIds(waitSubscriptionsDir);
-                    const finalReason = freshWaitReferences.safe ? resultSkipReason({ candidate, data, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, maintenanceRoot, cutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
+                    const finalReason = freshWaitReferences.safe ? resultSkipReason({ candidate, data, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, maintenanceRoot, cutoff, resumableCutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
                     if (finalReason) {
                         increment(result.skipped, `recheck-${finalReason}`);
                         continue;
@@ -870,7 +876,7 @@ export async function cleanupAsyncRetention(options) {
                 const tombstoneCandidate = { ...candidate, path: tombstone, kind: "tombstone" };
                 const recheckData = readJson(tombstone);
                 const freshWaitReferences = parseWaitRunIds(waitSubscriptionsDir);
-                const recheckReason = freshWaitReferences.safe ? resultSkipReason({ candidate: tombstoneCandidate, data: recheckData, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, maintenanceRoot, cutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
+                const recheckReason = freshWaitReferences.safe ? resultSkipReason({ candidate: tombstoneCandidate, data: recheckData, asyncDirRoot: options.asyncDirRoot, resultsDir: options.resultsDir, maintenanceRoot, cutoff, resumableCutoff, protectedRunIds, waitRunIds: freshWaitReferences.runIds }) : "wait-references-unknown";
                 if (recheckReason) {
                     if (!fs.existsSync(candidate.path)) {
                         fs.renameSync(tombstone, candidate.path);

package/src/runs/background/retained-children.js

@@ -52,7 +52,7 @@ function childResumability(run, step) {
     }
     let requiredCwd;
     try {
-        requiredCwd = resolveRetainedWorktreeCwd(parallelHandoffPath(run.asyncDir), run.id, step.index) ?? recoveryDescriptor.cwd ?? run.cwd;
+        requiredCwd = resolveRetainedWorktreeCwd(parallelHandoffPath(run.asyncDir), run.id, step.index, step.worktreePath) ?? recoveryDescriptor.cwd ?? run.cwd;
         if (!requiredCwd || !fs.statSync(requiredCwd).isDirectory())
             return { state: "not-resumable", reason: `required cwd is missing: ${requiredCwd ?? "unknown"}` };
     }

package/src/runs/background/run-child-session.d.ts

@@ -83,6 +83,8 @@ export interface RunChildSessionInput {
     }>;
     modelResponseAliases?: Record<string, string[]>;
     mutationTools?: readonly string[];
+    /** Provider of the launch model that a parent extension registered and this child does not load. */
+    parentExtensionProvider?: string;
 }
 export interface RunChildSessionResult {
     exitCode: number;

package/src/runs/background/run-child-session.js

@@ -3,7 +3,7 @@ import { qualifyModelWithProvider } from "../../shared/model-info.js";
 import { acceptChildWatchdogEvent, applyChildWatchdogMessage, childWatchdogIsActive, isChildWatchdogStatusEvent, } from "../../watchdog/child-status.js";
 import { projectChildLifecycle } from "../shared/child-lifecycle.js";
 import { formatSubagentModelVerificationError } from "../shared/model-resolution.js";
-import { formatChildModelResolutionDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
+import { formatChildModelResolutionDiagnostic, formatMissingParentProviderDiagnostic, isChildModelResolutionFailure } from "../shared/model-resolution-diagnostic.js";
 import { isMutatingTool, resolveCurrentPath } from "../shared/long-running-guard.js";
 import { effectiveToolTimeoutMs, formatToolTimeoutMessage, toolTimeoutCallKey } from "../shared/tool-timeout.js";
 import { createReportedChildSessionInput } from "../shared/child-launch.js";
@@ -520,6 +520,14 @@ export function runChildSession(input) {
                 && !input.launch.session.ambientExtensions) {
                 finalError = `${promptErrorMessage}\n\n${formatChildModelResolutionDiagnostic({ agent: input.launch.config.agent, model: input.launch.session.model, host: "runner", capabilityCeiling: input.launch.toolPlan.capabilityCeiling })}`;
             }
+            else if (input.parentExtensionProvider
+                && session?.claimedProvider !== input.parentExtensionProvider
+                && finalError !== undefined
+                && (finalError === promptErrorMessage || finalError === assistantError)
+                && toolCount === 0
+                && messages.every((message) => message.role !== "assistant" || message.stopReason === "error")) {
+                finalError = `${finalError}\n\n${formatMissingParentProviderDiagnostic({ agent: input.launch.config.agent, model: input.launch.session.model, provider: input.parentExtensionProvider, capabilityCeiling: input.launch.toolPlan.capabilityCeiling })}`;
+            }
             const forcedDrainAfterFinalSuccess = (forced || forcedTermination) && (cleanTerminalAssistantStopReceived || agentSettledReceived) && !finalError;
             const forcedDrainAfterEmptyTerminal = forcedDrainAfterFinalSuccess && hasEmptyTerminalAssistantResponse(messages);
             if (!finalError && forced && !forcedDrainAfterFinalSuccess && !interrupted && !timedOut && !stopped) {

package/src/runs/background/subagent-runner.js

@@ -938,6 +938,7 @@ export async function runSingleStepInner(step, ctx) {
             modelVerificationRegistry: step.modelVerificationRegistry,
             modelResponseAliases: step.modelResponseAliases,
             mutationTools: step.mutationTools,
+            parentExtensionProvider: step.parentExtensionProvider,
         }));
         launched = true;
         aggregateUsage.input += run.usage.input;