pi-subagents 0.34.0 → 0.35.0

package/src/runs/shared/child-protocol.ts

@@ -0,0 +1,121 @@
+import { Buffer } from "node:buffer";
+import type { ProtocolOutputLimit } from "../../shared/types.ts";
+
+export type { ProtocolOutputLimit } from "../../shared/types.ts";
+
+export const MAX_CHILD_PENDING_LINE_BYTES = 4 * 1024 * 1024;
+export const MAX_CHILD_STDERR_BYTES = 128 * 1024;
+const MAX_PROTOCOL_DIAGNOSTIC_BYTES = 4096;
+
+export function formatProtocolOutputLimit(limit: ProtocolOutputLimit): string {
+	return `${limit.code}: child ${limit.stream} line exceeded ${limit.limitBytes} bytes (observed at least ${limit.observedBytes} bytes without a newline).`;
+}
+
+export function createBoundedLineReader(options: {
+	stream?: "stdout" | "stderr";
+	maxPendingLineBytes?: number;
+	onLine: (line: string) => void;
+	onLimit: (limit: ProtocolOutputLimit) => void;
+}): {
+	push(chunk: Buffer | string): void;
+	end(): void;
+	exceeded(): boolean;
+} {
+	const maxPendingLineBytes = options.maxPendingLineBytes ?? MAX_CHILD_PENDING_LINE_BYTES;
+	if (!Number.isInteger(maxPendingLineBytes) || maxPendingLineBytes < 1) {
+		throw new Error("maxPendingLineBytes must be a positive integer.");
+	}
+	let pending: Buffer[] = [];
+	let pendingBytes = 0;
+	let limitExceeded = false;
+
+	const emitPending = (): void => {
+		if (pendingBytes === 0) return;
+		options.onLine(Buffer.concat(pending, pendingBytes).toString("utf8"));
+		pending = [];
+		pendingBytes = 0;
+	};
+
+	const append = (segment: Buffer): boolean => {
+		if (segment.length === 0) return true;
+		const observedBytes = pendingBytes + segment.length;
+		if (observedBytes > maxPendingLineBytes) {
+			const prior = pendingBytes > 0 ? Buffer.concat(pending, pendingBytes) : Buffer.alloc(0);
+			const prefixFromPrior = prior.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES);
+			const prefix = prefixFromPrior.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
+				? prefixFromPrior
+				: Buffer.concat([prefixFromPrior, segment.subarray(0, MAX_PROTOCOL_DIAGNOSTIC_BYTES - prefixFromPrior.length)]);
+			const tailFromSegment = segment.subarray(Math.max(0, segment.length - MAX_PROTOCOL_DIAGNOSTIC_BYTES));
+			const tail = tailFromSegment.length === MAX_PROTOCOL_DIAGNOSTIC_BYTES
+				? tailFromSegment
+				: Buffer.concat([prior.subarray(Math.max(0, prior.length - (MAX_PROTOCOL_DIAGNOSTIC_BYTES - tailFromSegment.length))), tailFromSegment]);
+			limitExceeded = true;
+			pending = [];
+			pendingBytes = 0;
+			options.onLimit({
+				code: "protocol_output_limit",
+				stream: options.stream ?? "stdout",
+				limitBytes: maxPendingLineBytes,
+				observedBytes,
+				diagnosticPrefix: prefix.toString("utf8"),
+				diagnosticTail: tail.toString("utf8"),
+			});
+			return false;
+		}
+		pending.push(segment);
+		pendingBytes = observedBytes;
+		return true;
+	};
+
+	return {
+		push(chunk) {
+			if (limitExceeded) return;
+			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			let start = 0;
+			for (let index = 0; index < bytes.length; index++) {
+				if (bytes[index] !== 0x0a) continue;
+				if (!append(bytes.subarray(start, index))) return;
+				emitPending();
+				start = index + 1;
+			}
+			append(bytes.subarray(start));
+		},
+		end() {
+			if (!limitExceeded) emitPending();
+		},
+		exceeded: () => limitExceeded,
+	};
+}
+
+function trimToUtf8Boundary(buffer: Buffer, maxBytes: number): Buffer {
+	if (buffer.length <= maxBytes) return buffer;
+	let start = buffer.length - maxBytes;
+	while (start < buffer.length && (buffer[start]! & 0xc0) === 0x80) start++;
+	return buffer.subarray(start);
+}
+
+export function createBoundedByteTail(maxBytes = MAX_CHILD_STDERR_BYTES): {
+	push(chunk: Buffer | string): void;
+	text(): string;
+	byteLength(): number;
+} {
+	if (!Number.isInteger(maxBytes) || maxBytes < 1) throw new Error("maxBytes must be a positive integer.");
+	let tail = Buffer.alloc(0);
+	return {
+		push(chunk) {
+			const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			tail = trimToUtf8Boundary(Buffer.concat([tail, bytes]), maxBytes);
+		},
+		text: () => tail.toString("utf8"),
+		byteLength: () => tail.length,
+	};
+}
+
+export type ChildLifecycleAction = "start-drain" | "cancel-drain" | "none";
+
+export function projectChildLifecycle(event: { type?: string; willRetry?: unknown }, terminalAssistantStop = false): ChildLifecycleAction {
+	if (event.type === "agent_end" && event.willRetry === true) return "cancel-drain";
+	if (event.type === "agent_settled") return "start-drain";
+	if (terminalAssistantStop) return "start-drain";
+	return "none";
+}

package/src/runs/shared/completion-guard.ts

@@ -1,76 +1,8 @@
 import type { Message } from "@earendil-works/pi-ai";
 import { isMutatingBashCommand } from "./long-running-guard.ts";
+import { expectsImplementationMutation } from "./task-intent.ts";
 
-const REVIEW_ONLY_PATTERNS = [
-	/\breview only\b/i,
-	/\bsuggest fixes only\b/i,
-	/\bonly return findings\b/i,
-	/\breturn findings only\b/i,
-];
-
-const REVIEWER_REQUIRED_EDIT_PATTERNS = [
-	/\bmust\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-	/\brequired\s+to\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-	/\bregardless\s+of\s+findings\b/i,
-	/\balways\s+(?:edit|modify|change|fix|patch|apply)\b/i,
-	/\bapply\s+(?:the\s+)?fix(?:es)?\s+directly\b/i,
-	/\bmake\s+(?:the\s+)?code\s+changes\b/i,
-];
-
-const EXPLICIT_NO_EDIT_PATTERNS = [
-	/\bdo not edit\b/i,
-	/\bdon't edit\b/i,
-	/\bdo not modify\b/i,
-	/\bdo not change files\b/i,
-];
-
-const SCOPED_NO_EDIT_CONSTRAINT_PATTERNS = [
-	/\bdo not edit files?\s+outside\b/i,
-	/\bdo not edit\s+outside\b/i,
-	/\bdo not edit\s+unrelated files?\b/i,
-	/\bdo not change\s+unrelated files?\b/i,
-	/\bdo not modify\s+unrelated files?\b/i,
-];
-
-const NO_TOOL_INTENT_PATTERNS = [
-	/\bno tools? needed\b/i,
-	/\bno tools? required\b/i,
-	/\bwithout using tools\b/i,
-	/\bdo not use tools\b/i,
-	/\bdon't use tools\b/i,
-];
-
-const READ_ONLY_DELIVERABLE_PATTERNS = [
-	/\b(?:draft|write|compose|prepare|produce)\s+(?:(?:a|an|the)\s+)?(?:github\s+)?(?:issue|bug report|issue draft|issue body|proposal|plan|report|summary|findings?|analysis|recommendations?)\b/i,
-	/\b(?:issue|bug report)\s+(?:draft|body|template)\b/i,
-	/\b(?:return|provide|produce)\s+(?:text|markdown|answer|findings?|recommendations?)\s+only\b/i,
-];
-
-const RESEARCH_AGENT_PATTERNS = [
-	/\binvestigate\b/i,
-	/\bscout\b/i,
-	/\bresearch(?:er)?\b/i,
-];
-
-const FIX_OR_PATCH_IMPLEMENTATION_PATTERN = /\b(?:fix|patch)\s+(?:(?:it|this|that|them|each|any|all|these|those)\b|(?:(?:a|an|the|any|all)\s+)?(?:(?:failing|failed|broken|flaky|red|cold|start|current|existing|reported|approved|known|regression|unit|integration|e2e|source|typescript|type-?script|ts|type-?check|compiler)\s+)*(?:bug|defect|issues?|problems?|failures?|regressions?|tests?|errors?|items?|typos?|code|source|implementation|component|function|module|class|method|logic|file|files|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command|lint(?:ing)?|build|ci|type-?check|type\s+checking)\b)/i;
-
-const WORKER_IMPLEMENTATION_PATTERNS = [
-	/\b(?:implement|edit|modify|refactor|delete)\b/i,
-	FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
-	/\b(?:update|add|remove|replace|create)\b(?!\s+(?:(?:a|an|the)\s+)?(?:report|summary|findings?)(?:\b|$))/i,
-	/\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-	/\bmake\s+(?:the\s+)?changes\b/i,
-	/\bdo those fixes\b/i,
-];
-
-const GENERAL_IMPLEMENTATION_PATTERNS = [
-	/\b(?:implement|edit|modify|refactor)\b/i,
-	FIX_OR_PATCH_IMPLEMENTATION_PATTERN,
-	/\bapply\s+(?:the\s+)?(?:(?:suggested|proposed|recommended)\s+)?(?:changes?|fix(?:es)?|patch)\b/i,
-	/\bmake\s+(?:the\s+)?changes\b/i,
-	/\bdo those fixes\b/i,
-	/\b(?:update|add|remove|replace|delete|create)\s+(?:the\s+)?(?:file|files|code|source|implementation|test|tests|component|function|module|class|method|logic|import|imports|readme|docs?|changelog|package\.json|config|manifest|extension|prompt|command)\b/i,
-];
+export { expectsImplementationMutation };
 
 const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"read",
@@ -98,60 +30,9 @@ interface CompletionMutationGuardResult {
 	triggered: boolean;
 }
 
-type TaskMutationIntent = { kind: "implementation" } | { kind: "read-only" } | { kind: "unknown" };
-
-type ToolMutationCapability = { kind: "mutation-capable" } | { kind: "read-only" };
-
-function stripFrameworkInstructions(task: string): string {
-	return task
-		.split("\n")
-		.filter((line) => !/^\s*\[(?:Write to|Read from):/i.test(line))
-		.filter((line) => !/^\s*(?:Create and maintain progress at:|Update progress at:|\*\*Output:\*\*|Write your findings to(?: exactly this path)?:|This path is authoritative for this run\.|Ignore any other output filename or output path mentioned elsewhere)/i.test(line))
-		.join("\n");
-}
-
-function stripScopedNoEditConstraints(task: string): string {
-	let stripped = task;
-	for (const pattern of SCOPED_NO_EDIT_CONSTRAINT_PATTERNS) {
-		stripped = stripped.replace(pattern, " ");
-	}
-	return stripped;
-}
-
-function taskHasExplicitReadOnlyIntent(taskText: string): boolean {
-	return REVIEW_ONLY_PATTERNS.some((pattern) => pattern.test(taskText))
-		|| EXPLICIT_NO_EDIT_PATTERNS.some((pattern) => pattern.test(taskText))
-		|| NO_TOOL_INTENT_PATTERNS.some((pattern) => pattern.test(taskText));
-}
-
-function taskHasReadOnlyDeliverable(taskText: string): boolean {
-	return READ_ONLY_DELIVERABLE_PATTERNS.some((pattern) => pattern.test(taskText));
-}
-
-function toolMutationCapability(tools: string[] | undefined, mcpDirectTools: string[] | undefined): ToolMutationCapability {
-	if (tools === undefined || tools.length === 0 || (mcpDirectTools?.length ?? 0) > 0) return { kind: "mutation-capable" };
-	return tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool)) ? { kind: "read-only" } : { kind: "mutation-capable" };
-}
-
-function classifyTaskMutationIntent(agent: string, task: string): TaskMutationIntent {
-	const taskText = stripFrameworkInstructions(task);
-	const taskTextWithoutScopedConstraints = stripScopedNoEditConstraints(taskText);
-	if (taskHasExplicitReadOnlyIntent(taskTextWithoutScopedConstraints)) return { kind: "read-only" };
-
-	if (RESEARCH_AGENT_PATTERNS.some((pattern) => pattern.test(agent))) return { kind: "read-only" };
-	if (/\breviewer\b/i.test(agent)) {
-		return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText)) ? { kind: "implementation" } : { kind: "read-only" };
-	}
-
-	const workerIntent = agent === "worker" && WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));
-	if (workerIntent) return { kind: "implementation" };
-
-	if (GENERAL_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText))) return { kind: "implementation" };
-	return taskHasReadOnlyDeliverable(taskTextWithoutScopedConstraints) ? { kind: "read-only" } : { kind: "unknown" };
-}
-
-export function expectsImplementationMutation(agent: string, task: string): boolean {
-	return classifyTaskMutationIntent(agent, task).kind === "implementation";
+export function hasMutationToolCapability(tools: string[] | undefined, mcpDirectTools: string[] | undefined): boolean {
+	if (tools === undefined || tools.length === 0 || (mcpDirectTools?.length ?? 0) > 0) return true;
+	return !tools.every((tool) => READ_ONLY_BUILTIN_TOOLS.has(tool));
 }
 
 export function hasMutationToolCall(messages: Message[]): boolean {
@@ -171,9 +52,9 @@ export function hasMutationToolCall(messages: Message[]): boolean {
 }
 
 export function evaluateCompletionMutationGuard(input: CompletionMutationGuardInput): CompletionMutationGuardResult {
-	const expectedMutation = toolMutationCapability(input.tools, input.mcpDirectTools).kind === "read-only"
-		? false
-		: expectsImplementationMutation(input.agent, input.task);
+	const expectedMutation = hasMutationToolCapability(input.tools, input.mcpDirectTools)
+		? expectsImplementationMutation(input.agent, input.task)
+		: false;
 	const attemptedMutation = hasMutationToolCall(input.messages);
 	return {
 		expectedMutation,

package/src/runs/shared/dynamic-fanout.ts

@@ -27,6 +27,7 @@ export interface DynamicCollectedResult {
 	structured?: unknown;
 	error?: string;
 	timedOut?: boolean;
+	stopped?: boolean;
 	outputPath?: string;
 	artifactPaths?: ArtifactPaths;
 }
@@ -42,15 +43,15 @@ const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
 const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
 const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance"]);
-const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "sessionFiles", "thinkingOverrides"]);
+const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "sessionFiles", "thinkingOverrides"]);
 const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
 const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
 const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "toolBudget", "acceptance"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
-	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "maxSubagentDepth",
+	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "waitToolEnabled",
 	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "completionGuard", "systemPrompt",
-	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "parentSessionId",
+	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 
@@ -263,7 +264,7 @@ export function materializeDynamicParallelStep(step: DynamicParallelStep, output
 export function collectDynamicResults(
 	step: DynamicParallelStep,
 	items: DynamicMaterializedItem[],
-	results: Array<Pick<SingleResult, "agent" | "exitCode" | "error" | "timedOut" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { output?: string; finalOutput?: string }>,
+	results: Array<Pick<SingleResult, "agent" | "exitCode" | "error" | "timedOut" | "stopped" | "structuredOutput" | "artifactPaths" | "savedOutputPath"> & { output?: string; finalOutput?: string }>,
 ): DynamicCollectedResult[] {
 	return items.map((entry, index) => {
 		const result = results[index];
@@ -280,6 +281,7 @@ export function collectDynamicResults(
 			...(result?.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
 			...(result?.error ? { error: result.error } : {}),
 			...(result?.timedOut ? { timedOut: true } : {}),
+			...(result?.stopped ? { stopped: true } : {}),
 			...(result?.savedOutputPath ? { outputPath: result.savedOutputPath } : {}),
 			...(result?.artifactPaths ? { artifactPaths: result.artifactPaths } : {}),
 		};

package/src/runs/shared/model-fallback.ts

@@ -211,6 +211,31 @@ export function resolveSubagentModelOverride(
 	return resolved;
 }
 
+export function resolveEffectiveSubagentModel(
+	explicitModel: string | boolean | undefined,
+	agentModel: string | boolean | undefined,
+	parentModel: ParentModel | undefined,
+	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
+	options?: Omit<ResolveSubagentModelOverrideOptions, "source">,
+): string | undefined {
+	const resolved = resolveSubagentModelOverride(
+		explicitModel ?? agentModel,
+		parentModel,
+		availableModels,
+		preferredProvider,
+		{ ...options, source: explicitModel !== undefined ? "explicit" : "inherited" },
+	);
+	if (resolved || explicitModel === undefined) return resolved;
+	return resolveSubagentModelOverride(
+		agentModel,
+		parentModel,
+		availableModels,
+		preferredProvider,
+		{ ...options, source: "inherited" },
+	);
+}
+
 export interface BuildModelCandidatesOptions {
 	/** Fallback models are inherited agent config and warn, rather than error, when out of scope. */
 	scope?: ModelScopeConfig;
@@ -267,6 +292,7 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
 	/fetch failed/i,
 	/network error/i,
 	/socket hang up/i,
+	/stream ended without finish_reason/i,
 	/upstream/i,
 	/timed? out/i,
 	/timeout/i,
@@ -279,8 +305,18 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
 	/model.*(?:load|fail|error)/i,
 ];
 
+/**
+ * Failures reported as `<tool> failed (exit N): ...` or `<tool> failed with
+ * exit code N` come from a tool call inside the child's task, not from the
+ * provider/model, however network-flavored their details read. Retrying a
+ * different model cannot fix them and would rerun the whole task. Tool names
+ * include namespaced forms like `mcp.server/write`.
+ */
+const TOOL_FAILURE_PREFIX = /^[\w.:@/-]+ failed (?:(?:\(exit \d+\):)|(?:with exit code \d+))(?:\s|$)/i;
+
 export function isRetryableModelFailure(error: string | undefined): boolean {
 	if (!error) return false;
+	if (TOOL_FAILURE_PREFIX.test(error.trim())) return false;
 	return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
 }
 

package/src/runs/shared/nested-events.ts

@@ -202,7 +202,7 @@ function sanitizeTurnBudget(value: unknown): TurnBudgetState | undefined {
 	const maxTurns = clampNumber(raw.maxTurns);
 	const graceTurns = clampNumber(raw.graceTurns);
 	const turnCount = clampNumber(raw.turnCount);
-	const outcome = raw.outcome === "within-budget" || raw.outcome === "wrap-up-requested" || raw.outcome === "exceeded" ? raw.outcome : undefined;
+	const outcome = raw.outcome === "within-budget" || raw.outcome === "wrap-up-requested" || raw.outcome === "termination-deferred" || raw.outcome === "exceeded" ? raw.outcome : undefined;
 	if (maxTurns === undefined || graceTurns === undefined || turnCount === undefined || !outcome) return undefined;
 	return {
 		maxTurns,
@@ -210,12 +210,13 @@ function sanitizeTurnBudget(value: unknown): TurnBudgetState | undefined {
 		turnCount,
 		outcome,
 		...(clampNumber(raw.wrapUpRequestedAtTurn) !== undefined ? { wrapUpRequestedAtTurn: clampNumber(raw.wrapUpRequestedAtTurn) } : {}),
+		...(clampNumber(raw.terminationDeferredAtTurn) !== undefined ? { terminationDeferredAtTurn: clampNumber(raw.terminationDeferredAtTurn) } : {}),
 		...(clampNumber(raw.exceededAtTurn) !== undefined ? { exceededAtTurn: clampNumber(raw.exceededAtTurn) } : {}),
 	};
 }
 
 function sanitizeState(value: unknown, fallback: NestedRunState): NestedRunState {
-	return value === "queued" || value === "running" || value === "complete" || value === "failed" || value === "paused"
+	return value === "queued" || value === "running" || value === "complete" || value === "failed" || value === "paused" || value === "stopped"
 		? value
 		: fallback;
 }
@@ -225,7 +226,7 @@ function sanitizeStep(input: unknown, depth: number): NestedStepSummary | undefi
 	const raw = input as Record<string, unknown>;
 	const agent = stringValue(raw.agent, 128);
 	if (!agent) return undefined;
-	const status = raw.status === "pending" || raw.status === "running" || raw.status === "complete" || raw.status === "completed" || raw.status === "failed" || raw.status === "paused"
+	const status = raw.status === "pending" || raw.status === "running" || raw.status === "complete" || raw.status === "completed" || raw.status === "failed" || raw.status === "paused" || raw.status === "stopped"
 		? raw.status
 		: "pending";
 	return {
@@ -243,6 +244,7 @@ function sanitizeStep(input: unknown, depth: number): NestedStepSummary | undefi
 		...(clampNumber(raw.endedAt) !== undefined ? { endedAt: clampNumber(raw.endedAt) } : {}),
 		...(stringValue(raw.error, 1024) ? { error: stringValue(raw.error, 1024) } : {}),
 		...(raw.timedOut === true ? { timedOut: true } : {}),
+		...(raw.stopped === true ? { stopped: true } : {}),
 		...(sanitizeTurnBudget(raw.turnBudget) ? { turnBudget: sanitizeTurnBudget(raw.turnBudget) } : {}),
 		...(raw.turnBudgetExceeded === true ? { turnBudgetExceeded: true } : {}),
 		...(raw.wrapUpRequested === true ? { wrapUpRequested: true } : {}),
@@ -298,6 +300,7 @@ export function sanitizeSummary(input: unknown, depth = 0): NestedRunSummary | u
 		...(clampNumber(raw.timeoutMs) !== undefined ? { timeoutMs: clampNumber(raw.timeoutMs) } : {}),
 		...(clampNumber(raw.deadlineAt) !== undefined ? { deadlineAt: clampNumber(raw.deadlineAt) } : {}),
 		...(raw.timedOut === true ? { timedOut: true } : {}),
+		...(raw.stopped === true ? { stopped: true } : {}),
 		...(sanitizeTurnBudget(raw.turnBudget) ? { turnBudget: sanitizeTurnBudget(raw.turnBudget) } : {}),
 		...(raw.turnBudgetExceeded === true ? { turnBudgetExceeded: true } : {}),
 		...(raw.wrapUpRequested === true ? { wrapUpRequested: true } : {}),
@@ -353,7 +356,7 @@ export function parseNestedEventRecords(content: string, route: NestedRoute): Ne
 }
 
 function terminal(state: NestedRunState): boolean {
-	return state === "complete" || state === "failed" || state === "paused";
+	return state === "complete" || state === "failed" || state === "paused" || state === "stopped";
 }
 
 function mergeSummary(existing: NestedRunSummary | undefined, event: NestedEventRecord): NestedRunSummary {
@@ -859,6 +862,7 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 		...(status.timeoutMs !== undefined ? { timeoutMs: status.timeoutMs } : {}),
 		...(status.deadlineAt !== undefined ? { deadlineAt: status.deadlineAt } : {}),
 		...(status.timedOut !== undefined ? { timedOut: status.timedOut } : {}),
+		...(status.stopped !== undefined ? { stopped: status.stopped } : {}),
 		...(status.turnBudget ? { turnBudget: status.turnBudget } : {}),
 		...(status.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: status.turnBudgetExceeded } : {}),
 		...(status.wrapUpRequested !== undefined ? { wrapUpRequested: status.wrapUpRequested } : {}),
@@ -882,6 +886,7 @@ export function nestedSummaryFromAsyncStatus(status: AsyncStatus, asyncDir: stri
 			...(step.endedAt !== undefined ? { endedAt: step.endedAt } : {}),
 			...(step.error ? { error: step.error } : {}),
 			...(step.timedOut !== undefined ? { timedOut: step.timedOut } : {}),
+			...(step.stopped !== undefined ? { stopped: step.stopped } : {}),
 			...(step.turnBudget ? { turnBudget: step.turnBudget } : {}),
 			...(step.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: step.turnBudgetExceeded } : {}),
 			...(step.wrapUpRequested !== undefined ? { wrapUpRequested: step.wrapUpRequested } : {}),

package/src/runs/shared/nested-render.ts

@@ -8,11 +8,12 @@ export interface NestedRunCounts {
 	paused: number;
 	complete: number;
 	failed: number;
+	stopped: number;
 	queued: number;
 }
 
 export function countNestedRuns(children: NestedRunSummary[] | undefined): NestedRunCounts {
-	const counts: NestedRunCounts = { total: 0, running: 0, paused: 0, complete: 0, failed: 0, queued: 0 };
+	const counts: NestedRunCounts = { total: 0, running: 0, paused: 0, complete: 0, failed: 0, stopped: 0, queued: 0 };
 	for (const child of children ?? []) {
 		counts.total++;
 		counts[child.state]++;
@@ -22,6 +23,7 @@ export function countNestedRuns(children: NestedRunSummary[] | undefined): Neste
 		counts.paused += nested.paused;
 		counts.complete += nested.complete;
 		counts.failed += nested.failed;
+		counts.stopped += nested.stopped;
 		counts.queued += nested.queued;
 	}
 	return counts;
@@ -34,6 +36,7 @@ export function formatNestedAggregate(children: NestedRunSummary[] | undefined):
 		counts.running > 0 ? `${counts.running} running` : "",
 		counts.paused > 0 ? `${counts.paused} paused` : "",
 		counts.failed > 0 ? `${counts.failed} failed` : "",
+		counts.stopped > 0 ? `${counts.stopped} stopped` : "",
 		counts.complete > 0 ? `${counts.complete} complete` : "",
 		counts.queued > 0 ? `${counts.queued} queued` : "",
 	].filter(Boolean);

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

@@ -28,9 +28,12 @@ export interface RunnerSubagentStep {
 	inheritSkills: boolean;
 	skills?: string[];
 	outputPath?: string;
+	/** Defer the authoritative output instruction until a dynamic fanout item is materialized. */
+	namespaceOutputPath?: boolean;
 	outputMode?: "inline" | "file-only";
 	sessionFile?: string;
 	maxSubagentDepth?: number;
+	waitToolEnabled?: boolean;
 	structuredOutput?: {
 		schema: import("../../shared/types.ts").JsonSchemaObject;
 		schemaPath: string;
@@ -38,6 +41,8 @@ export interface RunnerSubagentStep {
 	};
 	structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
 	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
+	acceptanceInput?: import("../../shared/types.ts").AcceptanceInput;
+	acceptanceRole?: import("../../shared/types.ts").AcceptanceRole;
 	toolBudget?: import("../../shared/types.ts").ResolvedToolBudget;
 }
 
@@ -59,6 +64,8 @@ export interface DynamicRunnerGroup {
 	sessionFiles?: (string | undefined)[];
 	thinkingOverrides?: (string | undefined)[];
 	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
+	acceptanceInput?: import("../../shared/types.ts").AcceptanceInput;
+	acceptanceRole?: import("../../shared/types.ts").AcceptanceRole;
 }
 
 export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;

package/src/runs/shared/pi-args.ts

@@ -6,9 +6,12 @@ import { encodeNestedPathEnv, parseNestedPathEnv, type NestedPathEntry } from ".
 import { resolveMcpDirectToolNames } from "./mcp-direct-tool-allowlist.ts";
 import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "./structured-output.ts";
 import { TEMP_ROOT_DIR, type JsonSchemaObject, type ResolvedToolBudget } from "../../shared/types.ts";
+import { THINKING_LEVELS } from "../../shared/model-info.ts";
 import { TOOL_BUDGET_ENV, encodeToolBudgetEnv } from "./tool-budget.ts";
+import { CHILD_TOOL_DIAGNOSTIC_PATH_ENV, REQUIRED_CHILD_TOOLS_ENV } from "./tool-availability.ts";
+import { CHILD_WATCHDOG_CONFIG_ENV, encodeChildWatchdogConfig, type ChildWatchdogConfig } from "../../watchdog/child-status.ts";
+import { WAIT_TOOL_ENABLED_ENV } from "../background/wait-config.ts";
 
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
 const TASK_ARG_LIMIT = 8000;
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-prompt-runtime.ts");
 const FANOUT_CHILD_EXTENSION_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "extension", "fanout-child.ts");
@@ -30,6 +33,8 @@ export const SUBAGENT_PARENT_PATH_ENV = "PI_SUBAGENT_PARENT_PATH";
 export const SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV = "PI_SUBAGENT_PARENT_CAPABILITY_TOKEN";
 export const SUBAGENT_PARENT_SESSION_ENV = "PI_SUBAGENT_PARENT_SESSION";
 export const SUBAGENT_STEER_INBOX_ENV = "PI_SUBAGENT_STEER_INBOX";
+export const SUBAGENT_STEER_CAPABILITY_ENV = "PI_SUBAGENT_STEER_CAPABILITY";
+export const SUBAGENT_STEER_ACK_DIR_ENV = "PI_SUBAGENT_STEER_ACK_DIR";
 
 interface BuildPiArgsInput {
 	parentSessionId?: string;
@@ -65,18 +70,23 @@ interface BuildPiArgsInput {
 	parentPath?: NestedPathEntry[];
 	parentCapabilityToken?: string;
 	steerInboxDir?: string;
+	steerCapabilityPath?: string;
+	steerAckDir?: string;
 	structuredOutput?: {
 		schema: JsonSchemaObject;
 		schemaPath: string;
 		outputPath: string;
 	};
 	toolBudget?: ResolvedToolBudget;
+	childWatchdog?: ChildWatchdogConfig;
+	waitToolEnabled?: boolean;
 }
 
 interface BuildPiArgsResult {
 	args: string[];
 	env: Record<string, string | undefined>;
 	tempDir?: string;
+	toolDiagnosticPath?: string;
 }
 
 function sanitizeSupervisorChannelSegment(value: string): string {
@@ -90,7 +100,7 @@ function supervisorChannelDir(runId: string, agent: string, childIndex: number):
 export function applyThinkingSuffix(model: string | undefined, thinking: string | false | undefined, replaceExisting = false): string | undefined {
 	if (!model || !thinking) return model;
 	const colonIdx = model.lastIndexOf(":");
-	if (colonIdx !== -1 && THINKING_LEVELS.includes(model.substring(colonIdx + 1))) {
+	if (colonIdx !== -1 && THINKING_LEVELS.some((level) => level === model.substring(colonIdx + 1))) {
 		return replaceExisting ? `${model.slice(0, colonIdx)}:${thinking}` : model;
 	}
 	return `${model}:${thinking}`;
@@ -123,18 +133,21 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 		: declaredBuiltinToolsBase;
 	const fanoutAuthorized = declaredBuiltinTools.includes("subagent");
 	const toolExtensionPaths: string[] = [];
+	let requiredChildTools: string[] = [];
 	if (input.tools?.length) {
-		const builtinTools = [...declaredBuiltinTools];
+		const allowedTools = [...declaredBuiltinTools];
 		for (const tool of input.tools) {
 			if (!declaredBuiltinTools.includes(tool) && (tool.includes("/") || tool.endsWith(".ts") || tool.endsWith(".js"))) {
 				toolExtensionPaths.push(tool);
 			}
 		}
-		if (builtinTools.length > 0) {
+		if (allowedTools.length > 0) {
 			if (input.mcpDirectTools?.length) {
-				builtinTools.push(...resolveMcpDirectToolNames(input.mcpDirectTools, input.cwd));
+				allowedTools.push(...resolveMcpDirectToolNames(input.mcpDirectTools, input.cwd));
 			}
-			args.push("--tools", builtinTools.join(","));
+			if (input.structuredOutput) allowedTools.push("structured_output");
+			requiredChildTools = [...new Set(allowedTools)];
+			args.push("--tools", requiredChildTools.join(","));
 		}
 	}
 
@@ -177,8 +190,18 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	}
 
 	const env: Record<string, string | undefined> = {};
+	let toolDiagnosticPath: string | undefined;
+	if (requiredChildTools.length > 0) {
+		if (!tempDir) tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+		toolDiagnosticPath = path.join(tempDir, "tool-diagnostic.json");
+		env[REQUIRED_CHILD_TOOLS_ENV] = JSON.stringify(requiredChildTools);
+		env[CHILD_TOOL_DIAGNOSTIC_PATH_ENV] = toolDiagnosticPath;
+	}
 	env[SUBAGENT_CHILD_ENV] = "1";
 	env[SUBAGENT_FANOUT_CHILD_ENV] = fanoutAuthorized ? "1" : "0";
+	if (input.waitToolEnabled !== undefined) {
+		env[WAIT_TOOL_ENABLED_ENV] = input.waitToolEnabled ? "true" : "false";
+	}
 	const inheritedNestedRoute = Boolean(process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] && process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] && process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]);
 	const parentRunId = input.parentRunId ?? input.runId ?? (inheritedNestedRoute ? process.env[SUBAGENT_RUN_ID_ENV] : undefined) ?? process.env[SUBAGENT_PARENT_RUN_ID_ENV] ?? "";
 	const parentChildIndex = input.parentChildIndex !== undefined
@@ -251,12 +274,16 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	if (input.steerInboxDir) {
 		env[SUBAGENT_STEER_INBOX_ENV] = input.steerInboxDir;
 	}
+	if (input.steerCapabilityPath) env[SUBAGENT_STEER_CAPABILITY_ENV] = input.steerCapabilityPath;
+	if (input.steerAckDir) env[SUBAGENT_STEER_ACK_DIR_ENV] = input.steerAckDir;
 	const encodedToolBudget = encodeToolBudgetEnv(input.toolBudget);
 	if (encodedToolBudget) env[TOOL_BUDGET_ENV] = encodedToolBudget;
+	const encodedChildWatchdog = encodeChildWatchdogConfig(input.childWatchdog);
+	if (encodedChildWatchdog) env[CHILD_WATCHDOG_CONFIG_ENV] = encodedChildWatchdog;
 
 	env[SUBAGENT_PARENT_SESSION_ENV] = input.parentSessionId ?? process.env[SUBAGENT_PARENT_SESSION_ENV] ?? "";
 
-	return { args, env, tempDir };
+	return { args, env, tempDir, toolDiagnosticPath };
 }
 
 export const parseParentPathEnv = parseNestedPathEnv;