@selesai/code 0.5.28 → 0.5.29

package/dist/extensions/pi-subagents/src/runs/shared/acceptance.ts

@@ -32,7 +32,7 @@ const LEVEL_RANK: Record<Exclude<AcceptanceLevel, "auto">, number> = {
 };
 
 const VALID_LEVELS = new Set<AcceptanceLevel>(["auto", "none", "attested", "checked", "verified"]);
-const VALID_EVIDENCE = new Set<AcceptanceEvidenceKind>([
+const VALID_EVIDENCE_KINDS: AcceptanceEvidenceKind[] = [
 	"changed-files",
 	"tests-added",
 	"commands-run",
@@ -42,7 +42,10 @@ const VALID_EVIDENCE = new Set<AcceptanceEvidenceKind>([
 	"diff-summary",
 	"review-findings",
 	"manual-notes",
-]);
+];
+const VALID_EVIDENCE = new Set<AcceptanceEvidenceKind>(VALID_EVIDENCE_KINDS);
+const ACCEPTANCE_EVIDENCE_HELP = `Supported evidence kinds: ${VALID_EVIDENCE_KINDS.join(", ")}. Example: { level: "checked", evidence: ["commands-run", "changed-files"] }.`;
+const ACCEPTANCE_OBJECT_EXAMPLE = "Example: { level: \"checked\", evidence: [\"commands-run\", \"changed-files\"] }.";
 const ACCEPTANCE_CONFIG_KEYS = new Set(["level", "criteria", "evidence", "verify", "review", "stopRules", "reason"]);
 const ACCEPTANCE_GATE_KEYS = new Set(["id", "must", "evidence", "severity"]);
 const ACCEPTANCE_VERIFY_KEYS = new Set(["id", "command", "timeoutMs", "cwd", "env", "allowFailure"]);
@@ -153,6 +156,11 @@ function explicitAcceptanceCanDisable(explicit: AcceptanceConfig): boolean {
 	return explicit.level === "none" && typeof explicit.reason === "string" && explicit.reason.trim().length > 0;
 }
 
+function unsupportedEvidenceKindMessage(pathLabel: string, item: unknown): string {
+	const value = typeof item === "string" ? ` "${item}"` : "";
+	return `${pathLabel}${value} is not a supported evidence kind. ${ACCEPTANCE_EVIDENCE_HELP}`;
+}
+
 export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"): string[] {
 	const errors: string[] = [];
 	if (input === undefined) return errors;
@@ -164,7 +172,7 @@ export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"
 		return errors;
 	}
 	if (!input || typeof input !== "object" || Array.isArray(input)) {
-		errors.push(`${pathLabel} must be a string level, false, or an object.`);
+		errors.push(`${pathLabel} must be a string level, false, or an object. ${ACCEPTANCE_OBJECT_EXAMPLE}`);
 		return errors;
 	}
 	const value = input as Record<string, unknown>;
@@ -202,11 +210,11 @@ export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"
 				criterionIds.add(normalizedId);
 			}
 			if (typeof gate.must !== "string" || !gate.must.trim()) errors.push(`${criterionPath}.must is required.`);
-			if (gate.evidence !== undefined && !Array.isArray(gate.evidence)) errors.push(`${criterionPath}.evidence must be an array.`);
+			if (gate.evidence !== undefined && !Array.isArray(gate.evidence)) errors.push(`${criterionPath}.evidence must be an array. ${ACCEPTANCE_EVIDENCE_HELP}`);
 			if (Array.isArray(gate.evidence)) {
 				for (const [evidenceIndex, item] of gate.evidence.entries()) {
 					if (typeof item !== "string" || !VALID_EVIDENCE.has(item as AcceptanceEvidenceKind)) {
-						errors.push(`${criterionPath}.evidence[${evidenceIndex}] is not a supported evidence kind.`);
+						errors.push(unsupportedEvidenceKindMessage(`${criterionPath}.evidence[${evidenceIndex}]`, item));
 					}
 				}
 			}
@@ -218,11 +226,11 @@ export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"
 	if (Array.isArray(value.evidence)) {
 		for (const [index, item] of value.evidence.entries()) {
 			if (typeof item !== "string" || !VALID_EVIDENCE.has(item as AcceptanceEvidenceKind)) {
-				errors.push(`${pathLabel}.evidence[${index}] is not a supported evidence kind.`);
+				errors.push(unsupportedEvidenceKindMessage(`${pathLabel}.evidence[${index}]`, item));
 			}
 		}
 	} else if (value.evidence !== undefined) {
-		errors.push(`${pathLabel}.evidence must be an array.`);
+		errors.push(`${pathLabel}.evidence must be an array. ${ACCEPTANCE_EVIDENCE_HELP}`);
 	}
 	if (value.verify !== undefined && !Array.isArray(value.verify)) errors.push(`${pathLabel}.verify must be an array.`);
 	if (Array.isArray(value.verify)) {

package/dist/extensions/pi-subagents/src/runs/shared/capability-ceiling.ts

@@ -6,12 +6,14 @@ export const SUBAGENT_CAPABILITY_CEILING_REGISTRY_KEY = "pi-subagents.capability
 export const SUBAGENT_CAPABILITY_CEILING_ENV = "SELESAI_SUBAGENT_CAPABILITY_CEILING_V1";
 
 export type SubagentCapabilityCeiling =
-	| { allowedTools: readonly string[]; denyExtensions?: boolean }
-	| { allowedTools?: readonly string[]; denyExtensions: boolean };
+	| { allowedTools: readonly string[]; allowedAgents?: readonly string[]; denyExtensions?: boolean }
+	| { allowedTools?: readonly string[]; allowedAgents?: readonly string[]; denyExtensions: boolean }
+	| { allowedTools?: readonly string[]; allowedAgents: readonly string[]; denyExtensions?: boolean };
 
 export interface ResolvedSubagentCapabilityCeiling {
 	version: typeof SUBAGENT_CAPABILITY_CEILING_VERSION;
 	allowedTools?: string[];
+	allowedAgents?: string[];
 	denyExtensions: boolean;
 	sources: string[];
 }
@@ -26,6 +28,8 @@ export interface SubagentCapabilityAudit {
 	removedExtensionCount: number;
 	requestedMcpToolCount: number;
 	effectiveMcpTools: string[];
+	agentAllowed: boolean;
+	agentRestrictionSources?: string[];
 }
 
 export interface RegisterSubagentCapabilityCeilingOptions {
@@ -62,23 +66,28 @@ function validateText(value: unknown, field: string): string {
 function normalizeCeiling(ceiling: SubagentCapabilityCeiling): ResolvedSubagentCapabilityCeiling {
 	if (!ceiling || typeof ceiling !== "object" || Array.isArray(ceiling)) throw new Error("Invalid capability ceiling; expected an object.");
 	const hasAllowedTools = Object.hasOwn(ceiling, "allowedTools");
+	const hasAllowedAgents = Object.hasOwn(ceiling, "allowedAgents");
 	const hasDenyExtensions = Object.hasOwn(ceiling, "denyExtensions");
-	if (!hasAllowedTools && !hasDenyExtensions) throw new Error("Invalid capability ceiling; expected allowedTools or denyExtensions.");
+	if (!hasAllowedTools && !hasAllowedAgents && !hasDenyExtensions) throw new Error("Invalid capability ceiling; expected allowedTools, allowedAgents, or denyExtensions.");
 	if (hasDenyExtensions && typeof ceiling.denyExtensions !== "boolean") throw new Error("Invalid capability ceiling denyExtensions; expected a boolean.");
-	let allowedTools: string[] | undefined;
-	if (hasAllowedTools) {
-		if (!Array.isArray(ceiling.allowedTools)) throw new Error("Invalid capability ceiling allowedTools; expected an array.");
-		if (ceiling.allowedTools.length > 256) throw new Error("Invalid capability ceiling allowedTools; expected at most 256 names.");
-		allowedTools = [...new Set(ceiling.allowedTools.map((tool) => {
-			const name = validateText(tool, "allowedTools entry");
-			if (!/^[A-Za-z0-9_.:-]+$/u.test(name)) throw new Error(`Invalid capability ceiling allowedTools entry '${name}'.`);
-			if (Buffer.byteLength(name, "utf8") > 128) throw new Error(`Invalid capability ceiling allowedTools entry '${name}'; max 128 UTF-8 bytes.`);
+	const normalizeList = (field: "allowedTools" | "allowedAgents", pattern: RegExp): string[] | undefined => {
+		if (!Object.hasOwn(ceiling, field)) return undefined;
+		const values = ceiling[field];
+		if (!Array.isArray(values)) throw new Error(`Invalid capability ceiling ${field}; expected an array.`);
+		if (values.length > 256) throw new Error(`Invalid capability ceiling ${field}; expected at most 256 names.`);
+		return [...new Set(values.map((entry) => {
+			const name = validateText(entry, `${field} entry`);
+			if (!pattern.test(name)) throw new Error(`Invalid capability ceiling ${field} entry '${name}'.`);
+			if (Buffer.byteLength(name, "utf8") > 128) throw new Error(`Invalid capability ceiling ${field} entry '${name}'; max 128 UTF-8 bytes.`);
 			return name;
 		}))].sort();
-	}
+	};
+	const allowedTools = normalizeList("allowedTools", /^[A-Za-z0-9_.:-]+$/u);
+	const allowedAgents = normalizeList("allowedAgents", /^[A-Za-z0-9_.:-]+$/u);
 	return {
 		version: SUBAGENT_CAPABILITY_CEILING_VERSION,
-		...(allowedTools ? { allowedTools } : {}),
+		...(allowedTools !== undefined ? { allowedTools } : {}),
+		...(allowedAgents !== undefined ? { allowedAgents } : {}),
 		denyExtensions: ceiling.denyExtensions === true,
 		sources: [],
 	};
@@ -132,14 +141,17 @@ export function registerSubagentCapabilityCeiling(options: RegisterSubagentCapab
 export function intersectSubagentCapabilityCeilings(...ceilings: Array<ResolvedSubagentCapabilityCeiling | undefined>): ResolvedSubagentCapabilityCeiling | undefined {
 	const active = ceilings.filter((ceiling): ceiling is ResolvedSubagentCapabilityCeiling => ceiling !== undefined);
 	if (active.length === 0) return undefined;
-	const definedLists = active.filter((ceiling) => ceiling.allowedTools !== undefined).map((ceiling) => new Set(ceiling.allowedTools));
-	let allowedTools: string[] | undefined;
-	if (definedLists.length > 0) {
-		allowedTools = [...definedLists[0]!].filter((tool) => definedLists.every((list) => list.has(tool))).sort();
-	}
+	const intersectLists = (field: "allowedTools" | "allowedAgents"): string[] | undefined => {
+		const definedLists = active.filter((ceiling) => ceiling[field] !== undefined).map((ceiling) => new Set(ceiling[field]));
+		if (definedLists.length === 0) return undefined;
+		return [...definedLists[0]!].filter((entry) => definedLists.every((list) => list.has(entry))).sort();
+	};
+	const allowedTools = intersectLists("allowedTools");
+	const allowedAgents = intersectLists("allowedAgents");
 	return {
 		version: SUBAGENT_CAPABILITY_CEILING_VERSION,
-		...(allowedTools ? { allowedTools } : {}),
+		...(allowedTools !== undefined ? { allowedTools } : {}),
+		...(allowedAgents !== undefined ? { allowedAgents } : {}),
 		denyExtensions: active.some((ceiling) => ceiling.denyExtensions),
 		sources: [...new Set(active.flatMap((ceiling) => ceiling.sources))].sort(),
 	};
@@ -158,6 +170,26 @@ export function resolveCurrentSubagentCapabilityCeiling(sessionId: string | unde
 	return resolveSubagentCapabilityCeiling(sessionId, decodeSubagentCapabilityCeiling(process.env[SUBAGENT_CAPABILITY_CEILING_ENV]));
 }
 
+export function isAgentAllowedByCapabilityCeiling(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): boolean {
+	return ceiling?.allowedAgents === undefined || ceiling.allowedAgents.includes(agentName);
+}
+
+export function capabilityCeilingAgentRestrictionMessage(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): string | undefined {
+	if (isAgentAllowedByCapabilityCeiling(agentName, ceiling)) return undefined;
+	const sources = ceiling?.sources.length ? ceiling.sources.join(", ") : "unknown source";
+	const allowed = ceiling?.allowedAgents?.length ? ceiling.allowedAgents.join(", ") : "(none)";
+	return `Capability ceiling from ${sources} does not allow agent '${agentName}'. Allowed agents: ${allowed}.`;
+}
+
+export function assertAgentAllowedByCapabilityCeiling(agentName: string, ceiling: ResolvedSubagentCapabilityCeiling | undefined): void {
+	const message = capabilityCeilingAgentRestrictionMessage(agentName, ceiling);
+	if (message) throw new Error(message);
+}
+
+export function capabilityCeilingAgentRestrictionSources(ceiling: ResolvedSubagentCapabilityCeiling | undefined): string[] | undefined {
+	return ceiling?.allowedAgents === undefined ? undefined : [...ceiling.sources];
+}
+
 export function encodeSubagentCapabilityCeiling(ceiling: ResolvedSubagentCapabilityCeiling | undefined): string | undefined {
 	if (!ceiling) return undefined;
 	return Buffer.from(JSON.stringify(ceiling), "utf8").toString("base64url");

package/dist/extensions/pi-subagents/src/runs/shared/chain-outputs.ts

@@ -1,4 +1,4 @@
-import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { isCheckpointStep, isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
 import type { ChainOutputMap, ChainOutputMapEntry, SingleResult } from "../../shared/types.ts";
 import { getSingleResultOutput } from "../../shared/utils.ts";
 import { DynamicFanoutError, hasDynamicFanoutFields, type DynamicFanoutConfig, validateDynamicStepShape } from "./dynamic-fanout.ts";
@@ -14,6 +14,7 @@ export interface ChainOutputValidationContext {
 }
 
 function outputNamesForStep(step: ChainStep): string[] {
+	if (isCheckpointStep(step)) return [];
 	if (isParallelStep(step)) return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
 	if (isDynamicParallelStep(step)) return [step.collect.as];
 	const name = (step as SequentialStep).as;
@@ -21,6 +22,7 @@ function outputNamesForStep(step: ChainStep): string[] {
 }
 
 function taskTemplatesForStep(step: ChainStep): string[] {
+	if (isCheckpointStep(step)) return [];
 	if (isParallelStep(step)) return step.parallel.map((task) => task.task ?? "{previous}");
 	if (isDynamicParallelStep(step)) return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
 	return [(step as SequentialStep).task ?? "{previous}"];

package/dist/extensions/pi-subagents/src/runs/shared/dynamic-fanout.ts

@@ -51,7 +51,7 @@ const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
 	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "waitToolEnabled",
 	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "capabilityCeiling", "completionGuard", "systemPrompt",
-	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId",
+	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId", "launchResolvedExtensions",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 

package/dist/extensions/pi-subagents/src/runs/shared/mcp-direct-tool-allowlist.ts

@@ -27,6 +27,7 @@ type ImportKind = keyof typeof IMPORT_PATHS;
 interface ServerEntry {
 	command?: string;
 	args?: string[];
+	socket?: string;
 	env?: Record<string, string>;
 	cwd?: string;
 	url?: string;
@@ -35,6 +36,7 @@ interface ServerEntry {
 	bearerToken?: string;
 	bearerTokenEnv?: string;
 	exposeResources?: boolean;
+	includeTools?: string[];
 	excludeTools?: string[];
 	directTools?: boolean | string[];
 }
@@ -271,14 +273,16 @@ export function computeMcpServerHash(definition: ServerEntry): string {
 	const identity: Record<string, unknown> = {
 		command: definition.command,
 		args: definition.args,
+		socket: resolveConfigPath(definition.socket),
 		env: interpolateEnvRecord(definition.env),
 		cwd: resolveConfigPath(definition.cwd),
-		url: definition.url,
+		url: resolveServerUrl(definition),
 		headers: interpolateEnvRecord(definition.headers),
 		auth: definition.auth,
 		bearerToken: resolveBearerToken(definition),
 		bearerTokenEnv: definition.bearerTokenEnv,
 		exposeResources: definition.exposeResources,
+		includeTools: definition.includeTools,
 		excludeTools: definition.excludeTools,
 	};
 	return createHash("sha256").update(stableStringify(identity)).digest("hex");
@@ -333,22 +337,51 @@ function resourceNameToToolName(name: string): string {
 }
 
 function interpolateEnvRecord(values: Record<string, string> | undefined): Record<string, string> | undefined {
-	if (!values || typeof values !== "object" || Array.isArray(values)) return undefined;
-	const resolved: Record<string, string> = {};
-	for (const [key, value] of Object.entries(values)) {
-		if (typeof value === "string") resolved[key] = interpolateEnvVars(value);
-	}
-	return resolved;
+	if (!values) return undefined;
+	return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, interpolateSecretExpression(value)]));
 }
 
 function interpolateEnvVars(value: string): string {
 	return value
 		.replace(/\$\{(\w+)\}/g, (_, name: string) => process.env[name] ?? "")
-		.replace(/\$env:(\w+)/g, (_, name: string) => process.env[name] ?? "");
+		.replace(/\$env:(\w+)/g, (_, name: string) => process.env[name] ?? "")
+		.replace(/\{env:(\w+)\}/g, (_, name: string) => process.env[name] ?? "");
+}
+
+function interpolateSecretExpression(value: string): string {
+	if (value.startsWith("!!")) return interpolateEnvVars(value.slice(1));
+	return value.startsWith("!") ? value : interpolateEnvVars(value);
+}
+
+function getMissingEnvVars(value: string): string[] {
+	const missing = new Set<string>();
+	for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+		const name = match[1] ?? match[2] ?? match[3];
+		if (name && process.env[name] === undefined) missing.add(name);
+	}
+	return [...missing];
+}
+
+function resolveServerUrl(definition: Pick<ServerEntry, "url">): string | undefined {
+	if (definition.url == null) return undefined;
+	if (typeof definition.url !== "string") throw new Error("MCP server URL must be a string");
+
+	const missing = getMissingEnvVars(definition.url);
+	if (missing.length > 0) {
+		throw new Error(`Missing environment variable${missing.length === 1 ? "" : "s"} in MCP server URL: ${missing.join(", ")}`);
+	}
+
+	const resolved = interpolateEnvVars(definition.url);
+	try {
+		new URL(resolved);
+	} catch (error) {
+		throw new Error(`Invalid MCP server URL after environment interpolation: ${resolved}`, { cause: error });
+	}
+	return resolved;
 }
 
 function resolveConfigPath(value: string | undefined): string | undefined {
-	if (typeof value !== "string") return undefined;
+	if (value === undefined) return undefined;
 	const resolved = interpolateEnvVars(value);
 	if (resolved === "~") return os.homedir();
 	if (resolved.startsWith("~/") || resolved.startsWith("~\\")) return path.join(os.homedir(), resolved.slice(2));
@@ -356,8 +389,8 @@ function resolveConfigPath(value: string | undefined): string | undefined {
 }
 
 function resolveBearerToken(definition: Pick<ServerEntry, "bearerToken" | "bearerTokenEnv">): string | undefined {
-	if (typeof definition.bearerToken === "string") return interpolateEnvVars(definition.bearerToken);
-	return typeof definition.bearerTokenEnv === "string" ? process.env[definition.bearerTokenEnv] : undefined;
+	if (definition.bearerToken !== undefined) return interpolateSecretExpression(definition.bearerToken);
+	return definition.bearerTokenEnv ? process.env[definition.bearerTokenEnv] : undefined;
 }
 
 function stableStringify(value: unknown): string {

package/dist/extensions/pi-subagents/src/runs/shared/model-fallback.ts

@@ -30,6 +30,14 @@ export interface ParentModel {
 	id: string;
 }
 
+export function normalizeParentModel(model: unknown): ParentModel | undefined {
+	if (!model || typeof model !== "object") return undefined;
+	const candidate = model as { provider?: unknown; id?: unknown };
+	if (typeof candidate.provider !== "string" || typeof candidate.id !== "string") return undefined;
+	if (!candidate.provider || !candidate.id) return undefined;
+	return { provider: candidate.provider, id: candidate.id };
+}
+
 /**
  * Normalize a model id or provider segment for fuzzy comparison: case-fold,
  * treat dots/underscores as dashes (so `4.5` matches `4-5`), and collapse

package/dist/extensions/pi-subagents/src/runs/shared/nested-events.ts

@@ -7,6 +7,8 @@ import {
 	TEMP_ROOT_DIR,
 	type AsyncJobState,
 	type AsyncStatus,
+	type LaunchResolvedChildExtensionsV1,
+	type RuntimeAcknowledgedChildExtensionsV1,
 	type NestedRouteInfo,
 	type TurnBudgetState,
 	type NestedRunSummary,
@@ -197,6 +199,55 @@ function sanitizeCost(value: unknown): NestedRunSummary["totalCost"] | undefined
 		: undefined;
 }
 
+function sanitizeLaunchResolvedExtensions(value: unknown): LaunchResolvedChildExtensionsV1 | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (raw.version !== 1 || raw.source !== "launch-resolved" || typeof raw.disableAmbientExtensions !== "boolean") return undefined;
+	const stringList = (input: unknown): string[] => Array.isArray(input)
+		? input.filter((item): item is string => typeof item === "string" && /^sha256:[a-f0-9]{16}$/.test(item)).slice(0, 32)
+		: [];
+	const omitted = raw.omitted && typeof raw.omitted === "object" ? raw.omitted as Record<string, unknown> : {};
+	const omittedCount = (key: string): number => Math.max(0, Math.floor(clampNumber(omitted[key]) ?? 0));
+	return {
+		version: 1,
+		source: "launch-resolved",
+		disableAmbientExtensions: raw.disableAmbientExtensions,
+		runtime: stringList(raw.runtime),
+		configured: stringList(raw.configured),
+		effective: stringList(raw.effective),
+		omitted: {
+			runtime: omittedCount("runtime"),
+			configured: omittedCount("configured"),
+			effective: omittedCount("effective"),
+		},
+	};
+}
+
+function sanitizeRuntimeAcknowledgedExtensions(value: unknown): RuntimeAcknowledgedChildExtensionsV1 | undefined {
+	if (!value || typeof value !== "object") return undefined;
+	const raw = value as Record<string, unknown>;
+	if (raw.version !== 1 || raw.source !== "child-runtime" || !Array.isArray(raw.ids)) return undefined;
+	const ids: string[] = [];
+	const seen = new Set<string>();
+	for (const item of raw.ids) {
+		if (typeof item !== "string" || item.length === 0 || item.length > 128 || !/^[A-Za-z0-9._:@+-]+$/.test(item) || item.includes("..") || item.includes("/") || item.includes("\\") || seen.has(item)) continue;
+		seen.add(item);
+		ids.push(item);
+	}
+	if (ids.length === 0) return undefined;
+	return {
+		version: 1,
+		source: "child-runtime",
+		ids: ids.slice(0, 32),
+		omitted: Math.max(0, ids.length - 32) + Math.max(0, Math.floor(clampNumber(raw.omitted) ?? 0)),
+	};
+}
+
+function runtimeAcknowledgedEntry(value: unknown): { runtimeAcknowledgedExtensions: RuntimeAcknowledgedChildExtensionsV1 } | Record<string, never> {
+	const sanitized = sanitizeRuntimeAcknowledgedExtensions(value);
+	return sanitized ? { runtimeAcknowledgedExtensions: sanitized } : {};
+}
+
 function sanitizeTurnBudget(value: unknown): TurnBudgetState | undefined {
 	if (!value || typeof value !== "object") return undefined;
 	const raw = value as Record<string, unknown>;
@@ -249,6 +300,8 @@ function sanitizeStep(input: unknown, depth: number): NestedStepSummary | undefi
 		...(sanitizeTurnBudget(raw.turnBudget) ? { turnBudget: sanitizeTurnBudget(raw.turnBudget) } : {}),
 		...(raw.turnBudgetExceeded === true ? { turnBudgetExceeded: true } : {}),
 		...(raw.wrapUpRequested === true ? { wrapUpRequested: true } : {}),
+		...(sanitizeLaunchResolvedExtensions(raw.launchResolvedExtensions) ? { launchResolvedExtensions: sanitizeLaunchResolvedExtensions(raw.launchResolvedExtensions) } : {}),
+		...(sanitizeRuntimeAcknowledgedExtensions(raw.runtimeAcknowledgedExtensions) ? { runtimeAcknowledgedExtensions: sanitizeRuntimeAcknowledgedExtensions(raw.runtimeAcknowledgedExtensions) } : {}),
 		...(depth < MAX_DEPTH && Array.isArray(raw.children) ? { children: raw.children.map((child) => sanitizeSummary(child, depth + 1)).filter((child): child is NestedRunSummary => Boolean(child)).slice(0, MAX_CHILDREN) } : {}),
 	};
 }
@@ -306,6 +359,8 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		...(raw.turnBudgetExceeded === true ? { turnBudgetExceeded: true } : {}),
 		...(raw.wrapUpRequested === true ? { wrapUpRequested: true } : {}),
 		...(stringValue(raw.error, 1024) ? { error: stringValue(raw.error, 1024) } : {}),
+		...(sanitizeLaunchResolvedExtensions(raw.launchResolvedExtensions) ? { launchResolvedExtensions: sanitizeLaunchResolvedExtensions(raw.launchResolvedExtensions) } : {}),
+		...(sanitizeRuntimeAcknowledgedExtensions(raw.runtimeAcknowledgedExtensions) ? { runtimeAcknowledgedExtensions: sanitizeRuntimeAcknowledgedExtensions(raw.runtimeAcknowledgedExtensions) } : {}),
 		...(steps && steps.length > 0 ? { steps } : {}),
 		...(depth < MAX_DEPTH && Array.isArray(raw.children) ? { children: raw.children.map((child) => sanitizeSummary(child, depth + 1)).filter((child): child is NestedRunSummary => Boolean(child)).slice(0, MAX_CHILDREN) } : {}),
 	};
@@ -788,32 +843,50 @@ export function writeNestedControlResult(route: NestedRoute, result: Omit<Nested
 	writeRouteRecord(route.eventSink, sanitized.ts, sanitized);
 }
 
-export function readNestedControlResults(route: NestedRoute): NestedControlResultRecord[] {
+function readControlResultsFromFile(route: NestedRoute, eventPath: string): NestedControlResultRecord[] {
+	if (!containedPath(route.eventSink, eventPath)) return [];
+	try {
+		const stat = fs.statSync(eventPath);
+		if (!stat.isFile() || stat.size > MAX_EVENT_BYTES) return [];
+		const content = fs.readFileSync(eventPath, "utf-8");
+		const lines = content.includes("\n") ? content.split("\n").filter((line) => line.trim()) : [content];
+		return lines.map((line) => parseControlResult(line, route)).filter((result): result is NestedControlResultRecord => Boolean(result));
+	} catch {
+		return [];
+	}
+}
+
+function listNestedEventFiles(route: NestedRoute): string[] {
 	validateRouteShape(route);
-	let entries: string[] = [];
 	try {
-		entries = fs.readdirSync(route.eventSink).filter((entry) => entry.endsWith(".json") || entry.endsWith(".jsonl")).sort();
+		return fs.readdirSync(route.eventSink).filter((entry) => entry.endsWith(".json") || entry.endsWith(".jsonl"));
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return [];
+		throw error;
 	}
-	const results: NestedControlResultRecord[] = [];
+}
+
+export function snapshotNestedEventFiles(route: NestedRoute): Set<string> {
+	return new Set(listNestedEventFiles(route));
+}
+
+export function findNestedControlResult(route: NestedRoute, requestId: string, targetRunId: string, ignoredFiles: ReadonlySet<string>): NestedControlResultRecord | undefined {
+	const entries = listNestedEventFiles(route)
+		.filter((entry) => !ignoredFiles.has(entry))
+		.sort()
+		.reverse();
 	for (const entry of entries) {
-		const eventPath = path.join(route.eventSink, entry);
-		if (!containedPath(route.eventSink, eventPath)) continue;
-		try {
-			const stat = fs.statSync(eventPath);
-			if (!stat.isFile() || stat.size > MAX_EVENT_BYTES) continue;
-			const content = fs.readFileSync(eventPath, "utf-8");
-			const lines = content.includes("\n") ? content.split("\n").filter((line) => line.trim()) : [content];
-			for (const line of lines) {
-				const result = parseControlResult(line, route);
-				if (result) results.push(result);
-			}
-		} catch {
-			continue;
-		}
+		const result = readControlResultsFromFile(route, path.join(route.eventSink, entry))
+			.find((candidate) => candidate.requestId === requestId && candidate.targetRunId === targetRunId);
+		if (result) return result;
 	}
-	return results;
+	return undefined;
+}
+
+export function readNestedControlResults(route: NestedRoute): NestedControlResultRecord[] {
+	return listNestedEventFiles(route)
+		.sort()
+		.flatMap((entry) => readControlResultsFromFile(route, path.join(route.eventSink, entry)));
 }
 
 export function nestedRouteEnv(route: NestedRoute): Record<string, string> {
@@ -875,6 +948,8 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 		...(status.sessionId ? { sessionId: status.sessionId } : {}),
 		mode: status.mode ?? fallback.mode,
 		...(status.processTerminal ? { processTerminal: sanitizeProcessTerminal(status.processTerminal, { runId: status.runId || fallback.id, runnerProcessInstanceId: status.processTerminal.runnerProcessInstanceId }, `${asyncDir}/status.json`) } : {}),
+		...(status.launchResolvedExtensions ? { launchResolvedExtensions: status.launchResolvedExtensions } : {}),
+		...runtimeAcknowledgedEntry(status.runtimeAcknowledgedExtensions),
 		...(status.capabilityCeiling ? { capabilityCeiling: status.capabilityCeiling } : {}),
 		...(status.capabilityAudit ? { capabilityAudit: status.capabilityAudit } : {}),
 		state: status.state,
@@ -914,6 +989,8 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 			...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
 			...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
 			...(step.error ? { error: step.error } : {}),
+			...(step.launchResolvedExtensions ? { launchResolvedExtensions: step.launchResolvedExtensions } : {}),
+			...runtimeAcknowledgedEntry(step.runtimeAcknowledgedExtensions),
 			...(step.timedOut !== undefined ? { timedOut: step.timedOut } : {}),
 			...(step.stopped !== undefined ? { stopped: step.stopped } : {}),
 			...(step.turnBudget ? { turnBudget: step.turnBudget } : {}),

package/dist/extensions/pi-subagents/src/runs/shared/parallel-utils.ts

@@ -46,6 +46,8 @@ export interface RunnerSubagentStep {
 	definitionDigest?: string;
 	launchBindingTask?: string;
 	launchContractDigest?: string;
+	launchResolvedExtensions?: import("../../shared/types.ts").LaunchResolvedChildExtensionsV1;
+	runtimeAcknowledgedExtensions?: import("../../shared/types.ts").RuntimeAcknowledgedChildExtensionsV1;
 	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 	acceptanceInput?: import("../../shared/types.ts").AcceptanceInput;
 	acceptanceRole?: import("../../shared/types.ts").AcceptanceRole;
@@ -55,6 +57,13 @@ export interface RunnerSubagentStep {
 	capabilityAudit?: import("./capability-ceiling.ts").SubagentCapabilityAudit;
 }
 
+export interface RunnerCheckpointStep {
+	checkpoint: string;
+	message?: string;
+	phase?: string;
+	label?: string;
+}
+
 export interface ParallelStepGroup {
 	parallel: RunnerSubagentStep[];
 	concurrency?: number;
@@ -79,7 +88,11 @@ export interface DynamicRunnerGroup {
 	gateOn?: import("../../shared/types.ts").ChainGateLayer;
 }
 
-export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;
+export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup | RunnerCheckpointStep;
+
+export function isCheckpointRunnerStep(step: RunnerStep): step is RunnerCheckpointStep {
+	return "checkpoint" in step;
+}
 
 export function isParallelGroup(step: RunnerStep): step is ParallelStepGroup {
 	return "parallel" in step && Array.isArray(step.parallel);
@@ -92,7 +105,9 @@ export function isDynamicRunnerGroup(step: RunnerStep): step is DynamicRunnerGro
 export function flattenSteps(steps: RunnerStep[]): RunnerSubagentStep[] {
 	const flat: RunnerSubagentStep[] = [];
 	for (const step of steps) {
-		if (isParallelGroup(step)) {
+		if (isCheckpointRunnerStep(step)) {
+			continue;
+		} else if (isParallelGroup(step)) {
 			for (const task of step.parallel) flat.push(task);
 		} else if (isDynamicRunnerGroup(step)) {
 			continue;
@@ -144,29 +159,45 @@ export async function mapConcurrent<T, R>(
 	limit: number,
 	fn: (item: T, i: number) => Promise<R>,
 	globalSemaphore?: Semaphore,
+	/** Invoked after every worker has stopped, including workers outliving an early rejection. */
+	onSchedulingSettled?: () => void,
 ): Promise<R[]> {
 	const safeLimit = Math.max(1, Math.floor(limit) || 1);
 	const results: R[] = new Array(items.length);
 	let next = 0;
+	let liveWorkers = Math.min(safeLimit, items.length);
+	const notifySchedulingSettled = () => {
+		try {
+			onSchedulingSettled?.();
+		} catch {
+			// Scheduling lifecycle cleanup must not replace the worker result.
+		}
+	};
 
 	async function worker(_workerIndex: number): Promise<void> {
-		while (next < items.length) {
-			const i = next++;
-			if (globalSemaphore) {
-				await globalSemaphore.acquire();
-				try {
+		try {
+			while (next < items.length) {
+				const i = next++;
+				if (globalSemaphore) {
+					await globalSemaphore.acquire();
+					try {
+						results[i] = await fn(items[i], i);
+					} finally {
+						globalSemaphore.release();
+					}
+				} else {
 					results[i] = await fn(items[i], i);
-				} finally {
-					globalSemaphore.release();
 				}
-			} else {
-				results[i] = await fn(items[i], i);
 			}
+		} finally {
+			liveWorkers--;
+			if (liveWorkers === 0) notifySchedulingSettled();
 		}
 	}
 
+	if (liveWorkers === 0) notifySchedulingSettled();
 	await Promise.all(
-		Array.from({ length: Math.min(safeLimit, items.length) }, (_, wi) => worker(wi)),
+		Array.from({ length: liveWorkers }, (_, wi) => worker(wi)),
 	);
 	return results;
 }