@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/inprocess/runner.ts

@@ -1,5 +1,5 @@
-import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import {
 	type AgentSession,
 	type AgentSessionEvent,
@@ -8,6 +8,8 @@ import {
 	createAgentSession,
 	DefaultResourceLoader,
 	getAgentDir,
+	getBuiltinPackagePaths,
+	type PackageSource,
 	SessionManager,
 	type SessionStats,
 	SettingsManager,
@@ -24,19 +26,20 @@ import {
 import type { Api, Model } from "@earendil-works/pi-ai/compat";
 import type { AgentConfig } from "../../agents/agent-types.ts";
 import { ensureArtifactsDir, writeArtifact, writeMetadata } from "../../shared/artifacts.ts";
+import {
+	getSubagentCodexFastModeSettings,
+	resolveSubagentCodexFastModeScope,
+	resolveSubagentModelFastMode,
+} from "../../shared/fast-mode.ts";
+import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import {
 	type AgentProgress,
 	type ArtifactPaths,
 	DEFAULT_MAX_OUTPUT,
-	type JsonSchemaObject,
 	type MaxOutputConfig,
+	normalizeMaxSubagentDepth,
 	truncateOutput,
 } from "../../shared/types.ts";
-import {
-	formatStructuredOutputCorrectionPrompt,
-	readStructuredOutput,
-	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
-} from "../shared/structured-output.ts";
 import { type ChildModePolicy, resolveChildModePolicy } from "./child-policy.ts";
 import { type InProcessNestedResumeOutcome, registerInProcessNestedAttempt } from "./nested-routing.ts";
 import { createInProcessChildPromptBehavior } from "./prompt-behavior.ts";
@@ -51,17 +54,25 @@ export interface ParentContext {
 	readonly depth: number;
 	readonly sessionId?: string;
 	readonly intercomGroup?: string;
+	readonly workflowStageSubagentGuard?: boolean;
 	readonly orchestrationContext?: CreateAgentSessionOptions["orchestrationContext"];
 }
 
 export interface TestSessionOptions {
 	readonly output?: string;
-	readonly structuredOutputAfterPrompt?: number;
 	readonly promptLogPath?: string;
 	/** Hold a test prompt open until the caller releases the supplied promise. */
 	readonly promptGate?: Promise<void>;
 	/** Match AgentSession.abort() settling an active prompt without throwing. */
 	readonly abortResolvesPrompt?: boolean;
+	/** Emit a fallback event for tests that exercise live model metadata. */
+	readonly fallbackModel?: string;
+	/** Emit the effective thinking level applied to the fallback candidate. */
+	readonly fallbackThinkingLevel?: string;
+	/** Test-only session model exposed through the AgentSession accessors. */
+	readonly sessionModel?: string;
+	/** Test-only effective thinking level exposed through the AgentSession accessors. */
+	readonly sessionThinkingLevel?: string;
 }
 
 export interface ChildSpec {
@@ -80,8 +91,13 @@ export interface ChildSpec {
 	/** Typed identity/capability resolved by the parent before admission. */
 	readonly intercom?: SubagentIntercomIdentity;
 	readonly sessionFile?: string;
+	/**
+	 * Effective delegation limit for this child, already narrowed by the parent's
+	 * limit and the child agent's own `maxSubagentDepth`. Retained on the spec so
+	 * a cold reload reissues the same limit.
+	 */
+	readonly maxSubagentDepth?: number;
 	readonly testSession?: boolean | TestSessionOptions;
-	readonly structuredOutput?: { readonly schema: JsonSchemaObject; readonly outputPath: string };
 	readonly artifactJsonlPath?: string;
 	/**
 	 * Fallback model candidates (full ids, optional `:thinking` suffix) handed to
@@ -112,6 +128,40 @@ export interface ModelCandidate {
 	readonly thinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
 }
 
+function modelIdForCandidate(candidate: ModelCandidate, fallbackModel?: Model<Api>): string | undefined {
+	return (
+		candidate.modelId ??
+		(candidate.model ? `${candidate.model.provider}/${candidate.model.id}` : undefined) ??
+		(fallbackModel ? `${fallbackModel.provider}/${fallbackModel.id}` : undefined)
+	);
+}
+
+function modelIdForSession(session: AgentSession | undefined): string | undefined {
+	const model = session?.model;
+	return model ? `${model.provider}/${model.id}` : undefined;
+}
+
+function thinkingLevelForSession(session: AgentSession | undefined): string | undefined {
+	const thinking = session?.thinkingLevel;
+	return typeof thinking === "string" ? thinking : undefined;
+}
+
+function initialThinkingForAttempt(
+	model: string | undefined,
+	configuredThinking: string | undefined,
+): string | undefined {
+	return resolveEffectiveThinking(model, configuredThinking) ?? configuredThinking;
+}
+function defaultFastModeForChild(
+	cwd: string,
+	context: ParentContext["orchestrationContext"],
+	workflowStageSubagentGuard?: boolean,
+): (model?: string) => boolean {
+	const settings = getSubagentCodexFastModeSettings(cwd);
+	const scope = resolveSubagentCodexFastModeScope(workflowStageSubagentGuard ?? context?.kind === "workflow-stage");
+	return (model) => resolveSubagentModelFastMode({ model, cwd, settings, scope });
+}
+
 export interface AttemptSignals {
 	readonly abort: AbortSignal;
 	readonly interrupt: AbortSignal;
@@ -127,8 +177,8 @@ export type AttemptOutcome =
 			readonly path: string;
 			readonly envelope: string;
 			readonly sessionFile?: string;
-			readonly structuredOutput?: unknown;
 			readonly model?: string;
+			readonly thinking?: string;
 			readonly attemptedModels?: readonly string[];
 	  }
 	| {
@@ -140,6 +190,7 @@ export type AttemptOutcome =
 			readonly sessionFile?: string;
 			readonly fallbackSignal?: string;
 			readonly model?: string;
+			readonly thinking?: string;
 			readonly attemptedModels?: readonly string[];
 	  }
 	| {
@@ -148,6 +199,8 @@ export type AttemptOutcome =
 			readonly path: string;
 			readonly envelope: string;
 			readonly sessionFile?: string;
+			readonly model?: string;
+			readonly thinking?: string;
 	  }
 	| {
 			readonly status: "continued";
@@ -156,6 +209,8 @@ export type AttemptOutcome =
 			readonly path: string;
 			readonly envelope: string;
 			readonly sessionFile?: string;
+			readonly model?: string;
+			readonly thinking?: string;
 	  };
 
 export interface ResultEnvelope {
@@ -165,6 +220,8 @@ export interface ResultEnvelope {
 	readonly stats: AttemptStats;
 	readonly envelope: string;
 	readonly model?: string;
+	readonly thinking?: string;
+	readonly fastMode?: boolean;
 	readonly modelAttempts?: readonly {
 		readonly model: string;
 		readonly status: TerminalStatus;
@@ -245,9 +302,69 @@ function workflowMetadataFromContext(
 	};
 }
 
+/**
+ * Effective delegation limit for an admitted child. A caller that already
+ * narrowed the parent's limit against the agent definition puts the result on
+ * the spec; a caller admitting a child directly still gets the agent's own
+ * declared limit rather than an unbounded policy.
+ */
+export function effectiveChildMaxSubagentDepth(spec: ChildSpec): number | undefined {
+	return spec.maxSubagentDepth ?? normalizeMaxSubagentDepth(spec.agent.maxSubagentDepth);
+}
+
+/**
+ * In-process children must load the same bundled extensions as the host.
+ * Workflow extensions are disabled inside workflow-owned sessions because their
+ * startup lifecycle belongs to the parent workflow store.
+ */
+export function inProcessChildBuiltinPackagePaths(
+	context: CreateAgentSessionOptions["orchestrationContext"] | undefined,
+): PackageSource[] {
+	return getBuiltinPackagePaths().map((source) => {
+		if (context?.kind !== "workflow-stage" || basename(source) !== "workflows") return source;
+		return { source, extensions: [] };
+	});
+}
+
+/**
+ * Resource-loading options for a real (non-test) in-process child session.
+ * Omitting `builtinPackagePaths` leaves a child with no bundled extension at
+ * all — no `subagent`, `web_search`, `fetch_content`, or `intercom` — so the
+ * bundled roots belong in every child loader.
+ */
+export function inProcessChildResourceLoaderOptions(input: {
+	readonly cwd: string;
+	readonly agentDir: string;
+	readonly settingsManager: SettingsManager;
+	readonly agent: Pick<AgentConfig, "systemPrompt" | "systemPromptMode">;
+	readonly orchestrationContext: CreateAgentSessionOptions["orchestrationContext"] | undefined;
+}): ConstructorParameters<typeof DefaultResourceLoader>[0] {
+	const agentPrompt = input.agent.systemPrompt?.trim();
+	return {
+		cwd: input.cwd,
+		agentDir: input.agentDir,
+		settingsManager: input.settingsManager,
+		builtinPackagePaths: inProcessChildBuiltinPackagePaths(input.orchestrationContext),
+		...(agentPrompt && input.agent.systemPromptMode === "append"
+			? { appendSystemPrompt: [agentPrompt] }
+			: agentPrompt
+				? { systemPrompt: agentPrompt }
+				: {}),
+	};
+}
+
 function createTestSession(sessionManager: SessionManager, spec: ChildSpec): AgentSession {
 	const listeners = new Set<AgentSessionEventListener>();
 	const testOptions = typeof spec.testSession === "object" ? spec.testSession : {};
+	const sessionModel = (() => {
+		const fullId = testOptions.sessionModel;
+		if (!fullId) return undefined;
+		const slash = fullId.indexOf("/");
+		return {
+			provider: slash === -1 ? "" : fullId.slice(0, slash),
+			id: slash === -1 ? fullId : fullId.slice(slash + 1),
+		};
+	})();
 	let lastAssistantText = "";
 	let aborted = false;
 	let settlePromptAbort: (() => void) | undefined;
@@ -257,13 +374,14 @@ function createTestSession(sessionManager: SessionManager, spec: ChildSpec): Age
 			else reject(new Error("aborted"));
 		};
 	});
-	let promptCount = 0;
 	let userMessages = 0;
 	let assistantMessages = 0;
 	const zeroTokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
 	const zeroCost = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
 	return {
 		sessionFile: sessionManager.getSessionFile(),
+		model: sessionModel,
+		thinkingLevel: testOptions.sessionThinkingLevel,
 		abort: async () => {
 			aborted = true;
 			settlePromptAbort?.();
@@ -275,7 +393,6 @@ function createTestSession(sessionManager: SessionManager, spec: ChildSpec): Age
 		prompt: async (text: string) => {
 			for (const listener of listeners) listener({ type: "agent_start" } as AgentSessionEvent);
 			if (aborted) throw new Error("aborted");
-			promptCount += 1;
 			if (testOptions.promptLogPath) appendFileSync(testOptions.promptLogPath, `${text}\n---PROMPT---\n`, "utf8");
 			sessionManager.appendMessage({ role: "user", content: text, timestamp: Date.now() });
 			userMessages += 1;
@@ -286,12 +403,28 @@ function createTestSession(sessionManager: SessionManager, spec: ChildSpec): Age
 				]);
 				if (gateResult === "aborted") return "";
 			}
-			if (
-				spec.structuredOutput &&
-				testOptions.structuredOutputAfterPrompt !== undefined &&
-				promptCount >= testOptions.structuredOutputAfterPrompt
-			) {
-				writeFileSync(spec.structuredOutput.outputPath, JSON.stringify({ answer: "ok" }), "utf8");
+			if (testOptions.fallbackModel) {
+				for (const listener of listeners) {
+					listener({
+						type: "model_fallback_start",
+						from: "openai/gpt-5.1-codex",
+						to: testOptions.fallbackModel,
+						reason: "test fallback",
+						attempt: 1,
+					} as AgentSessionEvent);
+					if (testOptions.fallbackThinkingLevel) {
+						listener({
+							type: "thinking_level_changed",
+							level: testOptions.fallbackThinkingLevel,
+						} as AgentSessionEvent);
+					}
+					listener({
+						type: "tool_execution_start",
+						toolCallId: "test-fallback-tool",
+						toolName: "test-fallback-tool",
+						args: {},
+					} as AgentSessionEvent);
+				}
 			}
 			lastAssistantText = testOptions.output ?? "done";
 			sessionManager.appendMessage({
@@ -418,6 +551,40 @@ function safeArgsPreview(args: unknown): string {
 	}
 }
 
+/**
+ * How a child session event should publish {@link AgentProgress} to the host UI.
+ *
+ * - `force` — the event changed progress the live widget shows; bypass the throttle.
+ * - `throttled` — worth publishing, but subject to the 400 ms throttle.
+ * - `none` — carries nothing the widget shows; do not publish.
+ *
+ * `none` is the important case. Foreground subagent results render into chat
+ * scrollback, which can sit above pi-tui's viewport fold. Every publish rewrites
+ * `durationMs`/`lastActivityAt` and repaints the widget, and a repaint of a row
+ * above the fold makes `TUI.doRender()` take its `firstChanged < viewportTop`
+ * branch, which issues a full redraw that writes `\x1b[2J\x1b[H\x1b[3J` — clearing
+ * the user's scrollback and snapping the terminal to the bottom. A catch-all
+ * publish therefore destroyed the scrollback ~2.5x/s for the whole run, because
+ * `AgentSessionEvent` includes high-frequency traffic (`message_update` streaming
+ * deltas, `tool_execution_update`, `entry_appended`) that the widget never shows.
+ * Keep this table narrow: add an event only when the widget renders something the
+ * event changed.
+ */
+export type ProgressEmission = "force" | "throttled" | "none";
+
+export function progressEmissionFor(eventType: AgentSessionEvent["type"]): ProgressEmission {
+	switch (eventType) {
+		case "agent_start":
+		case "tool_execution_start":
+		case "tool_execution_end":
+			return "force";
+		case "message_end":
+			return "throttled";
+		default:
+			return "none";
+	}
+}
+
 function writeEvent(pathValue: string | undefined, event: AgentSessionEvent): void {
 	if (!pathValue) return;
 	mkdirSync(dirname(pathValue), { recursive: true });
@@ -469,17 +636,30 @@ export class AdmittedChild {
 	}
 }
 
+export interface ChildRuntimeMetadata {
+	model?: string;
+	thinking?: string;
+	fastMode?: boolean;
+}
+
 export interface RunningAttempt {
 	readonly id: number;
 	readonly child: AdmittedChild;
 	readonly candidate: ModelCandidate;
 	readonly startedAt: number;
+	currentModel?: string;
+	currentThinking?: string;
+	currentFastMode?: boolean;
 	status: "running" | ChildStatus;
 	promise: Promise<AttemptOutcome>;
 	terminate?: (cause: TerminationCauseName) => Promise<void>;
 	attemptToken?: number;
 }
 
+export interface StartAttemptOptions {
+	readonly fastModeForModel?: (model: string | undefined) => boolean;
+}
+
 export class SubagentControlRuntime {
 	readonly native: SubagentControl;
 	readonly parent: ParentContext;
@@ -542,6 +722,9 @@ export class SubagentControlRuntime {
 					intercomGroup: parent.intercomGroup,
 					intercom: spec.intercom,
 					depth: identity.depth,
+					...(effectiveChildMaxSubagentDepth(spec) === undefined
+						? {}
+						: { maxSubagentDepth: effectiveChildMaxSubagentDepth(spec) }),
 				},
 				sessionDir,
 				sessionFile: spec.sessionFile,
@@ -554,7 +737,14 @@ export class SubagentControlRuntime {
 		admitted: AdmittedChild,
 		candidate: ModelCandidate,
 		signals: AttemptSignals,
+		onModelChange: ((model: string | undefined, thinking?: string, fastMode?: boolean) => void) | undefined,
+		fastModeForModel: (model: string | undefined) => boolean,
 	): Promise<AttemptOutcome> {
+		const candidateModelId = modelIdForCandidate(candidate, admitted.policy.model);
+		const configuredThinking = candidate.thinkingLevel ?? admitted.policy.thinkingLevel;
+		let effectiveModelId = candidateModelId;
+		let effectiveThinking = initialThinkingForAttempt(candidateModelId, configuredThinking);
+		let attemptedModels: string[] = candidateModelId ? [candidateModelId] : [];
 		let guard: NativeExecutionGuardResult;
 		let retryDelayMs = CAPACITY_RETRY_INITIAL_DELAY_MS;
 		for (;;) {
@@ -571,6 +761,8 @@ export class SubagentControlRuntime {
 							stats,
 							path: admitted.identity.path,
 							envelope: INTERRUPTED_ENVELOPE,
+							...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+							...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
 						}
 					: {
 							status,
@@ -578,6 +770,8 @@ export class SubagentControlRuntime {
 							stats,
 							path: admitted.identity.path,
 							envelope: boundedEnvelope(waitResult),
+							...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+							...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
 						};
 			}
 			retryDelayMs = Math.min(retryDelayMs * 2, CAPACITY_RETRY_MAX_DELAY_MS);
@@ -592,6 +786,8 @@ export class SubagentControlRuntime {
 				stats,
 				path: admitted.identity.path,
 				envelope: boundedEnvelope(reason),
+				...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+				...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
 			};
 		}
 		const token = guard.token;
@@ -637,53 +833,61 @@ export class SubagentControlRuntime {
 					);
 			activeSessionManager = sessionManager;
 			if (workflow) sessionManager.markSessionInternal(workflow);
-			const settingsManager = SettingsManager.create(admitted.policy.cwd, getAgentDir());
-			const agentPrompt = admitted.spec.agent.systemPrompt?.trim();
-			const resourceLoader = new DefaultResourceLoader({
-				cwd: admitted.policy.cwd,
-				agentDir: getAgentDir(),
-				settingsManager,
-				...(agentPrompt && admitted.spec.agent.systemPromptMode === "append"
-					? { appendSystemPrompt: [agentPrompt] }
-					: agentPrompt
-						? { systemPrompt: agentPrompt }
-						: {}),
-			});
-			await resourceLoader.reload();
-			const promptBehavior = createInProcessChildPromptBehavior(admitted.policy);
-			const created = admitted.spec.testSession
-				? { session: createTestSession(sessionManager, admitted.spec) }
-				: await createAgentSession({
+			let created: { session: AgentSession };
+			if (admitted.spec.testSession) {
+				created = { session: createTestSession(sessionManager, admitted.spec) };
+			} else {
+				const settingsManager = SettingsManager.create(admitted.policy.cwd, getAgentDir());
+				const resourceLoader = new DefaultResourceLoader(
+					inProcessChildResourceLoaderOptions({
 						cwd: admitted.policy.cwd,
-						model: candidate.model ?? admitted.policy.model,
-						thinkingLevel: candidate.thinkingLevel ?? admitted.policy.thinkingLevel,
-						...(admitted.spec.fallbackModels?.length
-							? { fallbackModels: [...admitted.spec.fallbackModels] }
-							: {}),
-						tools: admitted.policy.tools ? [...admitted.policy.tools] : undefined,
-						excludedTools: admitted.policy.excludedTools ? [...admitted.policy.excludedTools] : undefined,
-						customTools: admitted.policy.customTools,
-						resourceLoader,
-						sessionManager,
+						agentDir: getAgentDir(),
 						settingsManager,
+						agent: admitted.spec.agent,
 						orchestrationContext: admitted.spec.parent?.orchestrationContext,
-						subagentPolicy: admitted.policy,
-						systemPromptTransform: promptBehavior.systemPromptTransform,
-						initialContextTransform: promptBehavior.initialContextTransform,
-					});
+					}),
+				);
+				await resourceLoader.reload();
+				const promptBehavior = createInProcessChildPromptBehavior(admitted.policy);
+				created = {
+					session: (
+						await createAgentSession({
+							cwd: admitted.policy.cwd,
+							model: candidate.model ?? admitted.policy.model,
+							thinkingLevel: candidate.thinkingLevel ?? admitted.policy.thinkingLevel,
+							...(admitted.spec.fallbackModels?.length
+								? { fallbackModels: [...admitted.spec.fallbackModels] }
+								: {}),
+							tools: admitted.policy.tools ? [...admitted.policy.tools] : undefined,
+							excludedTools: admitted.policy.excludedTools ? [...admitted.policy.excludedTools] : undefined,
+							customTools: admitted.policy.customTools,
+							resourceLoader,
+							sessionManager,
+							settingsManager,
+							orchestrationContext: admitted.spec.parent?.orchestrationContext,
+							subagentPolicy: admitted.policy,
+							systemPromptTransform: promptBehavior.systemPromptTransform,
+							initialContextTransform: promptBehavior.initialContextTransform,
+						})
+					).session,
+				};
+			}
 			session = created.session;
 			if (session.sessionFile) this.sessionFiles.set(admitted.identity.path, session.sessionFile);
 			this.sessions.set(admitted.identity.path, session);
-			const initialModelId =
-				candidate.modelId ??
-				(candidate.model ? `${candidate.model.provider}/${candidate.model.id}` : undefined) ??
-				(admitted.policy.model ? `${admitted.policy.model.provider}/${admitted.policy.model.id}` : undefined);
-			let effectiveModelId = initialModelId;
-			const attemptedModels: string[] = initialModelId ? [initialModelId] : [];
+			const initialModelId = modelIdForSession(session) ?? candidateModelId;
+			effectiveModelId = initialModelId;
+			effectiveThinking =
+				thinkingLevelForSession(session) ?? initialThinkingForAttempt(candidateModelId, configuredThinking);
+			attemptedModels = initialModelId ? [initialModelId] : [];
+			onModelChange?.(effectiveModelId, effectiveThinking, fastModeForModel(effectiveModelId));
 			const progressState: AgentProgress = {
 				index: 0,
 				agent: admitted.spec.agent.name,
 				status: "running",
+				...(initialModelId === undefined ? {} : { model: initialModelId }),
+				...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
+				fastMode: fastModeForModel(initialModelId),
 				task: admitted.spec.task,
 				recentTools: [],
 				recentOutput: [],
@@ -706,15 +910,14 @@ export class SubagentControlRuntime {
 			};
 			unsubscribe = session.subscribe((event) => {
 				writeEvent(admitted.spec.artifactJsonlPath, event);
+				const emission = progressEmissionFor(event.type);
 				if (event.type === "agent_start") {
 					this.native.publishChildStatus(admitted.identity.path, nativeStatus("running"));
-					emitProgress(true);
 				} else if (event.type === "tool_execution_start") {
 					progressState.toolCount += 1;
 					progressState.currentTool = event.toolName;
 					progressState.currentToolArgs = safeArgsPreview(event.args);
 					progressState.currentToolStartedAt = Date.now();
-					emitProgress(true);
 				} else if (event.type === "tool_execution_end") {
 					if (progressState.currentTool !== undefined) {
 						progressState.recentTools.push({
@@ -727,7 +930,6 @@ export class SubagentControlRuntime {
 					progressState.currentTool = undefined;
 					progressState.currentToolArgs = undefined;
 					progressState.currentToolStartedAt = undefined;
-					emitProgress(true);
 				} else if (event.type === "message_end") {
 					const message = (event as { message?: { role?: string; usage?: { input?: number; output?: number } } })
 						.message;
@@ -736,39 +938,25 @@ export class SubagentControlRuntime {
 						const usage = message.usage;
 						if (usage) progressState.tokens += (usage.input ?? 0) + (usage.output ?? 0);
 					}
-					emitProgress(false);
-				} else {
-					emitProgress(false);
 				}
+				if (emission !== "none") emitProgress(emission === "force");
 				if (event.type === "model_fallback_start") {
 					if (!attemptedModels.includes(event.to)) attemptedModels.push(event.to);
 					effectiveModelId = event.to;
+					progressState.model = event.to;
+					progressState.fastMode = fastModeForModel(event.to);
+					onModelChange?.(effectiveModelId, effectiveThinking, progressState.fastMode);
+				} else if (event.type === "thinking_level_changed") {
+					effectiveThinking = event.level;
+					progressState.thinking = effectiveThinking;
+					const fastMode = fastModeForModel(effectiveModelId);
+					onModelChange?.(effectiveModelId, effectiveThinking, fastMode);
+					emitProgress(true);
 				}
 			});
 			if (signals.abort.aborted) await terminate("abort");
 			if (signals.interrupt.aborted) await terminate("interrupt");
-			let structuredOutput: unknown;
-			let prompt = admitted.spec.task;
-			for (let correction = 0; ; correction += 1) {
-				await session.prompt(prompt);
-				if (!admitted.spec.structuredOutput) break;
-				const structured = readStructuredOutput({
-					schema: admitted.spec.structuredOutput.schema,
-					schemaPath: "",
-					outputPath: admitted.spec.structuredOutput.outputPath,
-				});
-				if (structured.value !== undefined) {
-					structuredOutput = structured.value;
-					break;
-				}
-				const error = structured.error ?? "Structured output contract failed.";
-				if (correction >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) throw new Error(error);
-				prompt = formatStructuredOutputCorrectionPrompt({
-					originalTask: admitted.spec.task,
-					error,
-					attempt: correction + 1,
-				});
-			}
+			await session.prompt(admitted.spec.task);
 			await terminating;
 			const stats = statsFor(session, admitted.identity.path);
 			const sessionFile = session.sessionFile;
@@ -790,8 +978,8 @@ export class SubagentControlRuntime {
 					envelope,
 					sessionFile,
 					...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+					...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
 					...(attemptedModels.length > 1 ? { attemptedModels: [...attemptedModels] } : {}),
-					...(structuredOutput === undefined ? {} : { structuredOutput }),
 				};
 			return {
 				status,
@@ -800,7 +988,8 @@ export class SubagentControlRuntime {
 				path: admitted.identity.path,
 				envelope,
 				sessionFile,
-				...(status === "error" && effectiveModelId !== undefined ? { model: effectiveModelId } : {}),
+				...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+				...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
 				...(status === "error" && attemptedModels.length > 1 ? { attemptedModels: [...attemptedModels] } : {}),
 			};
 		} catch (error) {
@@ -820,6 +1009,8 @@ export class SubagentControlRuntime {
 						path: admitted.identity.path,
 						envelope: INTERRUPTED_ENVELOPE,
 						sessionFile: session?.sessionFile,
+						...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+						...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
 					}
 				: {
 						status,
@@ -828,6 +1019,9 @@ export class SubagentControlRuntime {
 						path: admitted.identity.path,
 						envelope: boundedEnvelope(cause),
 						sessionFile: session?.sessionFile,
+						...(effectiveModelId === undefined ? {} : { model: effectiveModelId }),
+						...(effectiveThinking === undefined ? {} : { thinking: effectiveThinking }),
+						...(attemptedModels.length > 1 ? { attemptedModels: [...attemptedModels] } : {}),
 					};
 		} finally {
 			signals.abort.removeEventListener("abort", abortListener);
@@ -855,13 +1049,33 @@ export class SubagentControlRuntime {
 		}
 	}
 
-	startAttempt(admitted: AdmittedChild, candidate: ModelCandidate, signals: AttemptSignals): RunningAttempt {
+	startAttempt(
+		admitted: AdmittedChild,
+		candidate: ModelCandidate,
+		signals: AttemptSignals,
+		options: StartAttemptOptions = {},
+	): RunningAttempt {
+		const initialModel = modelIdForCandidate(candidate, admitted.policy.model);
+		const initialThinking = initialThinkingForAttempt(
+			initialModel,
+			candidate.thinkingLevel ?? admitted.policy.thinkingLevel,
+		);
+		const fastModeForModel =
+			options.fastModeForModel ??
+			defaultFastModeForChild(
+				admitted.policy.cwd,
+				admitted.spec.parent?.orchestrationContext,
+				admitted.spec.parent?.workflowStageSubagentGuard,
+			);
 		const running: RunningAttempt = {
 			id: this.nextAttemptId++,
 			child: admitted,
 			candidate,
 			status: "running",
 			startedAt: Date.now(),
+			...(initialModel === undefined ? {} : { currentModel: initialModel }),
+			currentThinking: initialThinking,
+			currentFastMode: fastModeForModel(initialModel),
 			promise: Promise.resolve({
 				status: "error",
 				cause: "uninitialized",
@@ -870,7 +1084,17 @@ export class SubagentControlRuntime {
 				envelope: "uninitialized",
 			}),
 		};
-		running.promise = this.runChildAttempt(admitted, candidate, signals).then((result) => {
+		running.promise = this.runChildAttempt(
+			admitted,
+			candidate,
+			signals,
+			(model, thinking, fastMode) => {
+				running.currentModel = model;
+				running.currentThinking = thinking;
+				running.currentFastMode = fastMode;
+			},
+			fastModeForModel,
+		).then((result) => {
 			running.status = result.status;
 			this.runningAttempts.delete(running.id);
 			return result;
@@ -939,6 +1163,23 @@ export class SubagentControlRuntime {
 		};
 	}
 
+	getChildMetadata(pathValue: string): ChildRuntimeMetadata | undefined {
+		const running = [...this.runningAttempts.values()].find(
+			(attempt) =>
+				attempt.child.identity.path === pathValue &&
+				(attempt.status === "running" || attempt.status === "continued"),
+		);
+		if (!running) return undefined;
+		const model = running.currentModel;
+		const thinking = running.currentThinking;
+		if (model === undefined && thinking === undefined && running.currentFastMode === undefined) return undefined;
+		return {
+			...(model === undefined ? {} : { model }),
+			...(thinking === undefined ? {} : { thinking }),
+			...(running.currentFastMode === undefined ? {} : { fastMode: running.currentFastMode }),
+		};
+	}
+
 	registerNestedAttempt(runId: string, running: RunningAttempt, candidate: ModelCandidate): void {
 		registerInProcessNestedAttempt({
 			runId,
@@ -1055,6 +1296,9 @@ export class SubagentControlRuntime {
 			thinkingLevel: spec.thinkingLevel ?? (spec.agent.thinking as ChildPolicy["thinkingLevel"]),
 			intercomGroup: spec.parent?.intercomGroup,
 			depth,
+			...(effectiveChildMaxSubagentDepth(spec) === undefined
+				? {}
+				: { maxSubagentDepth: effectiveChildMaxSubagentDepth(spec) }),
 		};
 	}
 
@@ -1106,7 +1350,17 @@ export function run_child_attempt(
 	candidate: ModelCandidate,
 	signals: AttemptSignals,
 ): Promise<AttemptOutcome> {
-	return control.runChildAttempt(admitted, candidate, signals);
+	return control.runChildAttempt(
+		admitted,
+		candidate,
+		signals,
+		undefined,
+		defaultFastModeForChild(
+			admitted.policy.cwd,
+			admitted.spec.parent?.orchestrationContext,
+			admitted.spec.parent?.workflowStageSubagentGuard,
+		),
+	);
 }
 
 export function continue_in_background(