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

package/dist/builtin/subagents/src/intercom/intercom-bridge.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { APP_NAME, getEnvValue, getProjectConfigDirs } from "@bastani/atomic";
+import { APP_NAME, createChildProcessEnvironment, getEnvValue, getProjectConfigDirs } from "@bastani/atomic";
 import type { AgentConfig } from "../agents/agents.ts";
 import type { ExtensionConfig, IntercomBridgeConfig, IntercomBridgeMode } from "../shared/types.ts";
 import { getAgentDir } from "../shared/utils.ts";
@@ -83,7 +83,7 @@ export function resolveIntercomSessionTarget(sessionName: string | undefined, se
 	const trimmedName = sessionName?.trim();
 	if (trimmedName) return trimmedName;
 	const normalizedSessionId = sessionId.startsWith("session-") ? sessionId.slice("session-".length) : sessionId;
-	return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId.slice(0, 8)}`;
+	return `${DEFAULT_INTERCOM_TARGET_PREFIX}-${normalizedSessionId}`;
 }
 
 function sanitizeIntercomTargetPart(value: string): string {
@@ -207,7 +207,11 @@ let cachedGlobalNpmRoot: string | null | undefined;
 function getGlobalNpmRoot(): string | null {
 	if (cachedGlobalNpmRoot !== undefined) return cachedGlobalNpmRoot;
 	try {
-		cachedGlobalNpmRoot = execSync("npm root -g", { encoding: "utf-8", timeout: 5000 }).trim();
+		cachedGlobalNpmRoot = execSync("npm root -g", {
+			encoding: "utf-8",
+			timeout: 5000,
+			env: createChildProcessEnvironment(),
+		}).trim();
 		return cachedGlobalNpmRoot;
 	} catch {
 		cachedGlobalNpmRoot = null;

package/dist/builtin/subagents/src/intercom/result-intercom.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import {
 	type Details,
 	type IntercomEventBus,
@@ -75,7 +75,6 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 			...(part.stepIndex !== undefined ? { stepIndex: part.stepIndex } : {}),
 			...(part.agent ? { agent: part.agent } : {}),
 		})),
-		...(run.asyncDir ? { asyncDir: run.asyncDir } : {}),
 		...(run.sessionId ? { sessionId: run.sessionId } : {}),
 		...(run.sessionFile ? { sessionFile: run.sessionFile } : {}),
 		...(run.intercomTarget ? { intercomTarget: run.intercomTarget } : {}),
@@ -86,9 +85,6 @@ function compactNestedRun(run: NestedRunSummary | PublicNestedRunSummary, depth
 		state: run.state,
 		...(run.agent ? { agent: run.agent } : {}),
 		...(run.agents?.length ? { agents: run.agents.slice(0, 12) } : {}),
-		...(run.currentStep !== undefined ? { currentStep: run.currentStep } : {}),
-		...(run.chainStepCount !== undefined ? { chainStepCount: run.chainStepCount } : {}),
-		...(run.parallelGroups?.length ? { parallelGroups: run.parallelGroups.slice(0, 8) } : {}),
 		...(run.activityState ? { activityState: run.activityState } : {}),
 		...(run.lastActivityAt !== undefined ? { lastActivityAt: run.lastActivityAt } : {}),
 		...(run.currentTool ? { currentTool: run.currentTool } : {}),
@@ -193,41 +189,14 @@ export interface GroupedResultIntercomMessageInput {
 	to: string;
 	runId: string;
 	mode: SubagentRunMode;
-	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-	asyncDir?: string;
-	chainSteps?: number;
-}
-
-function asyncResumeGuidance(input: {
-	source: "foreground" | "async";
-	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-}): string | undefined {
-	if (input.source !== "async" || !input.asyncId) return undefined;
-	const resumable = input.children.filter(
-		(child) => typeof child.sessionPath === "string" && fs.existsSync(child.sessionPath),
-	);
-	if (input.children.length === 1 && resumable.length === 1) {
-		return `Revive: subagent({ action: "resume", id: "${input.asyncId}", message: "..." })`;
-	}
-	if (resumable.length > 0) {
-		const firstIndex = resumable[0]?.index ?? input.children.indexOf(resumable[0]!);
-		return `Revive child: subagent({ action: "resume", id: "${input.asyncId}", index: ${firstIndex}, message: "..." })`;
-	}
-	return "Resume: unavailable; no child session file was persisted.";
 }
 
 function formatSubagentResultIntercomMessage(input: {
 	runId: string;
 	mode: SubagentRunMode;
 	status: SubagentResultStatus;
-	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
-	asyncId?: string;
-	asyncDir?: string;
-	chainSteps?: number;
 }): string {
 	const counts = countStatuses(input.children);
 	const lines: string[] = [
@@ -238,35 +207,21 @@ function formatSubagentResultIntercomMessage(input: {
 		`Status: ${input.status}`,
 		`Children: ${formatStatusCounts(counts)}`,
 	];
-	if (input.mode === "chain" && typeof input.chainSteps === "number") {
-		lines.push(`Chain steps: ${input.chainSteps}`);
-	}
-	if (input.asyncId) lines.push(`Async id: ${input.asyncId}`);
-	if (input.asyncDir) lines.push(`Async dir: ${input.asyncDir}`);
-	const resumeGuidance = asyncResumeGuidance(input);
-	if (resumeGuidance) lines.push(resumeGuidance);
 	if (input.children.some((child) => child.intercomTarget)) {
-		lines.push("");
 		lines.push(
-			input.source === "async"
-				? "Previous intercom targets below identify child sessions used while they were running. Inspect artifacts or session logs if resume is unavailable."
-				: "Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.",
+			"",
+			"Intercom targets below identify child sessions used while they were running; completed child sessions may no longer be reachable. Inspect artifacts or session logs for follow-up.",
 		);
 	}
 
 	for (let index = 0; index < input.children.length; index++) {
 		const child = input.children[index]!;
-		lines.push("");
-		lines.push(`${index + 1}. ${child.agent} — ${child.status}`);
-		if (child.intercomTarget)
-			lines.push(
-				`${input.source === "async" ? "Previous intercom target" : "Run intercom target"}: ${child.intercomTarget}`,
-			);
+		lines.push("", `${index + 1}. ${child.agent} — ${child.status}`);
+		if (child.intercomTarget) lines.push(`Run intercom target: ${child.intercomTarget}`);
 		if (child.artifactPath) lines.push(`Output artifact: ${child.artifactPath}`);
 		if (child.sessionPath) lines.push(`Session: ${child.sessionPath}`);
 		lines.push(...formatNestedResultLines(child.children));
-		lines.push("Summary:");
-		lines.push(child.summary);
+		lines.push("Summary:", child.summary);
 	}
 
 	return lines.join("\n");
@@ -289,11 +244,7 @@ export function buildSubagentResultIntercomPayload(
 		mode: input.mode,
 		status,
 		summary,
-		source: input.source,
 		children,
-		...(input.asyncId ? { asyncId: input.asyncId } : {}),
-		...(input.asyncDir ? { asyncDir: input.asyncDir } : {}),
-		...(typeof input.chainSteps === "number" ? { chainSteps: input.chainSteps } : {}),
 		...(firstChild?.agent ? { agent: firstChild.agent } : {}),
 		...(firstChild?.index !== undefined ? { index: firstChild.index } : {}),
 		...(firstChild?.artifactPath ? { artifactPath: firstChild.artifactPath } : {}),
@@ -335,15 +286,26 @@ export async function deliverSubagentIntercomMessageEvent(
 			if (settled) return;
 			settled = true;
 			if (timer) clearTimeout(timer);
-			unsubscribe?.();
+			try {
+				unsubscribe?.();
+			} catch (error) {
+				if (!isStaleExtensionContextError(error)) throw error;
+				// Stale event-bus cleanup must not change the delivery result.
+			}
 			resolve(delivered);
 		};
-		unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
-			if (!data || typeof data !== "object") return;
-			const delivery = data as { requestId?: unknown; delivered?: unknown };
-			if (delivery.requestId !== requestId) return;
-			finish(delivery.delivered === true);
-		});
+		try {
+			unsubscribe = events.on(SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT, (data) => {
+				if (!data || typeof data !== "object") return;
+				const delivery = data as { requestId?: unknown; delivered?: unknown };
+				if (delivery.requestId !== requestId) return;
+				finish(delivery.delivered === true);
+			});
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			finish(false);
+			return;
+		}
 		if (timeoutMs !== false) timer = setTimeout(() => finish(false), timeoutMs);
 		try {
 			events.emit(SUBAGENT_RESULT_INTERCOM_EVENT, { ...extra, to, message, requestId });
@@ -375,12 +337,7 @@ export function formatSubagentResultReceipt(input: {
 	payload: SubagentResultIntercomPayload;
 }): string {
 	const counts = countStatuses(input.payload.children);
-	const modeLabel =
-		input.mode === "single"
-			? "single subagent result"
-			: input.mode === "parallel"
-				? "parallel subagent results"
-				: "chain subagent results";
+	const modeLabel = input.mode === "single" ? "single subagent result" : "parallel subagent results";
 	const lines = [
 		`Delivered ${modeLabel} via intercom.`,
 		`Run: ${input.runId}`,

package/dist/builtin/subagents/src/intercom/supervisor-authorization.ts

@@ -1,3 +1,4 @@
+import { isStaleExtensionContextError } from "@bastani/atomic";
 import type { IntercomEventBus } from "../shared/types.ts";
 
 export const SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT = "subagent:supervisor-authorization";
@@ -18,6 +19,12 @@ export async function requestSupervisorAuthorization(
 	const request: { childName: string; completion?: Promise<SupervisorAuthorization> } = {
 		childName: normalizedChildName,
 	};
-	events.emit(SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT, request);
-	return request.completion ? await request.completion : undefined;
+	try {
+		events.emit(SUBAGENT_SUPERVISOR_AUTHORIZATION_EVENT, request);
+		return request.completion ? await request.completion : undefined;
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// Authorization is advisory when a child outlives its parent runtime.
+		return undefined;
+	}
 }

package/dist/builtin/subagents/src/runs/{background → foreground}/completion-notification.ts

@@ -1,5 +1,5 @@
 import type { IntercomEventBus } from "../../shared/types.ts";
-import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.ts";
+import { SUBAGENT_COMPLETE_EVENT } from "../../shared/types.ts";
 
 export interface CompletionNotificationEnvelope extends Record<string, unknown> {
 	notificationId: string;
@@ -12,7 +12,7 @@ export function deliverLocalCompletionNotification(
 	payload: Record<string, unknown>,
 	notificationId: string,
 ): Promise<boolean> {
-	return new Promise((resolve) => {
+	return new Promise((resolve, reject) => {
 		let settled = false;
 		let deferred = false;
 		const finish = (delivered: boolean) => {
@@ -20,8 +20,13 @@ export function deliverLocalCompletionNotification(
 			settled = true;
 			resolve(delivered);
 		};
+		const fail = (error: unknown) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		};
 		try {
-			events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+			events.emit(SUBAGENT_COMPLETE_EVENT, {
 				...payload,
 				notificationId,
 				defer: () => {
@@ -30,8 +35,8 @@ export function deliverLocalCompletionNotification(
 				acknowledge: finish,
 			} satisfies CompletionNotificationEnvelope);
 			if (!deferred) finish(true);
-		} catch {
-			finish(false);
+		} catch (error) {
+			fail(error);
 		}
 	});
 }

package/dist/builtin/subagents/src/runs/foreground/execution-updates.ts

@@ -1,7 +1,6 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Details } from "../../shared/types.ts";
 import { isRetryableModelFailure } from "../shared/model-fallback.ts";
-import { isStructuredOutputContractError } from "../shared/structured-output.ts";
 
 export type RunSyncUpdate = AgentToolResult<Details>;
 
@@ -25,7 +24,3 @@ function terminalUpdateFailureText(update: RunSyncUpdate): string | undefined {
 export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
 	return isRetryableModelFailure(terminalUpdateFailureText(update));
 }
-
-export function shouldSuppressIntermediateStructuredOutputFailureUpdate(update: RunSyncUpdate): boolean {
-	return isStructuredOutputContractError(terminalUpdateFailureText(update));
-}

package/dist/builtin/subagents/src/runs/foreground/execution.ts

@@ -3,7 +3,4 @@
  */
 
 export { runSync } from "./execution-run-sync.ts";
-export {
-	shouldSuppressIntermediateRetryableFailureUpdate,
-	shouldSuppressIntermediateStructuredOutputFailureUpdate,
-} from "./execution-updates.ts";
+export { shouldSuppressIntermediateRetryableFailureUpdate } from "./execution-updates.ts";

package/dist/builtin/subagents/src/runs/foreground/inprocess-run-sync.ts

@@ -1,7 +1,13 @@
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
+import type { CodexFastModeResolvedSettings, CodexFastModeScope } from "@bastani/atomic";
 import type { AgentConfig } from "../../agents/agent-types.ts";
 import { ensureArtifactsDir, getArtifactPaths, writeArtifact } from "../../shared/artifacts.ts";
+import {
+	getSubagentCodexFastModeSettings,
+	resolveSubagentCodexFastModeScope,
+	resolveSubagentModelFastMode,
+} from "../../shared/fast-mode.ts";
 import type {
 	AgentProgress,
 	ArtifactPaths,
@@ -55,14 +61,22 @@ function workflowOrchestrationContext(options: RunSyncOptions): ParentContext["o
 		...(options.intercomGroup ? { intercomGroup: options.intercomGroup } : {}),
 	};
 }
-
-function progressFor(agent: AgentConfig, task: string, outcome: AttemptOutcome, startedAt: number): AgentProgress {
+function progressFor(
+	agent: AgentConfig,
+	task: string,
+	outcome: AttemptOutcome,
+	startedAt: number,
+	fastMode: boolean,
+): AgentProgress {
 	const status = outcome.status === "ok" ? "completed" : outcome.status === "interrupted" ? "failed" : "failed";
 	return {
 		index: 0,
 		agent: agent.name,
 		status,
 		task,
+		...(outcome.model === undefined ? {} : { model: outcome.model }),
+		...(outcome.thinking === undefined ? {} : { thinking: outcome.thinking }),
+		...(fastMode ? { fastMode: true } : {}),
 		recentTools: [],
 		recentOutput: outcome.envelope ? outcome.envelope.split("\n").slice(-10) : [],
 		toolCount: outcome.stats.toolCalls,
@@ -79,10 +93,23 @@ function resultFromOutcome(
 	task: string,
 	outcome: AttemptOutcome,
 	startedAt: number,
-	artifactPaths?: ArtifactPaths,
+	artifactPaths: ArtifactPaths | undefined,
+	fastMode: {
+		cwd: string;
+		settings: CodexFastModeResolvedSettings;
+		scope: CodexFastModeScope;
+	},
 ): SingleResult {
 	const status = outcome.status;
 	const output = outcome.status === "ok" ? outcome.output : outcome.envelope;
+	const model = outcome.model;
+	const thinking = outcome.thinking;
+	const fastModeEnabled = resolveSubagentModelFastMode({
+		model,
+		cwd: fastMode.cwd,
+		settings: fastMode.settings,
+		scope: fastMode.scope,
+	});
 	const result: SingleResult = {
 		agent: agent.name,
 		task,
@@ -94,7 +121,9 @@ function resultFromOutcome(
 		interrupted: status === "interrupted" ? true : undefined,
 		messages: [],
 		usage: usageFromStats(outcome.stats),
-		model: outcome.status === "ok" || outcome.status === "error" ? outcome.model : undefined,
+		...(model === undefined ? {} : { model }),
+		...(thinking === undefined ? {} : { thinking }),
+		...(fastModeEnabled ? { fastMode: true } : {}),
 		...(outcome.status === "ok" || outcome.status === "error"
 			? outcome.attemptedModels?.length
 				? { attemptedModels: [...outcome.attemptedModels] }
@@ -102,10 +131,7 @@ function resultFromOutcome(
 			: {}),
 		finalOutput: output,
 		sessionFile: outcome.sessionFile,
-		...(outcome.status === "ok" && outcome.structuredOutput !== undefined
-			? { structuredOutput: outcome.structuredOutput }
-			: {}),
-		progress: progressFor(agent, task, outcome, startedAt),
+		progress: progressFor(agent, task, outcome, startedAt, fastModeEnabled),
 		progressSummary: {
 			toolCount: outcome.stats.toolCalls,
 			tokens: outcome.stats.tokens.total,
@@ -173,11 +199,30 @@ export async function runSingleInProcess(
 		return noSpawnableCandidatesResult(agent, task, filteredCandidates.skippedAttempts);
 	const candidate = filteredCandidates.candidates[0];
 	const fallbackCandidates = filteredCandidates.candidates.slice(1);
+	// The candidate is only a string. `createAgentSession` selects a model from a
+	// `Model<Api>` object and otherwise restores the model persisted in the
+	// session file — which, for a fork-context child, is the parent's model.
+	// Resolving the candidate here is what makes the agent's configured model win.
+	const resolvedCandidate = candidate ? options.resolveCandidateModel?.(candidate) : undefined;
+	const fastModeSettings = getSubagentCodexFastModeSettings(cwd);
 	const orchestrationContext = workflowOrchestrationContext(options);
+	const fastModeScope = resolveSubagentCodexFastModeScope(
+		options.workflowStageSubagentGuard ?? orchestrationContext?.kind === "workflow-stage",
+	);
+	const fastModeForModel = (model: string | undefined): boolean =>
+		resolveSubagentModelFastMode({
+			model,
+			cwd,
+			settings: fastModeSettings,
+			scope: fastModeScope,
+		});
 	const parent: ParentContext = {
 		path: options.runId,
-		depth: 0,
+		depth: options.parentDepth ?? 0,
 		...(options.intercomGroup ? { intercomGroup: options.intercomGroup } : {}),
+		...(options.workflowStageSubagentGuard === undefined
+			? {}
+			: { workflowStageSubagentGuard: options.workflowStageSubagentGuard }),
 		...(orchestrationContext ? { orchestrationContext } : {}),
 	};
 	const sessionRoot = options.sessionDir ?? join(options.artifactsDir ?? cwd, ".atomic", "subagents");
@@ -204,14 +249,12 @@ export async function runSingleInProcess(
 		cwd,
 		testSession: testSession,
 		sessionFile: options.sessionFile,
-		structuredOutput: options.structuredOutput
-			? { schema: options.structuredOutput.schema, outputPath: options.structuredOutput.outputPath }
-			: undefined,
+		...(options.maxSubagentDepth === undefined ? {} : { maxSubagentDepth: options.maxSubagentDepth }),
 		tools: agent.tools,
 		mcpDirectTools: agent.mcpDirectTools,
 		skills: options.skills ?? agent.skills,
-		model: undefined,
-		thinkingLevel: agent.thinking as ChildSpec["thinkingLevel"],
+		model: resolvedCandidate?.model,
+		thinkingLevel: (resolvedCandidate?.thinkingLevel ?? agent.thinking) as ChildSpec["thinkingLevel"],
 		parent,
 		intercom: options.orchestratorIntercomTarget
 			? {
@@ -235,12 +278,18 @@ export async function runSingleInProcess(
 		onProgress: options.onUpdate
 			? (progress) => {
 					const liveProgress = { ...progress, index: options.index ?? 0 };
+					const liveModel = liveProgress.model ?? candidate;
+					const liveThinking = liveProgress.thinking;
+					const liveFastMode = fastModeForModel(liveModel);
 					const liveResult: SingleResult = {
 						agent: agent.name,
 						task,
 						status: "continued",
 						messages: [],
 						usage: emptyUsage(),
+						...(liveModel === undefined ? {} : { model: liveModel }),
+						...(liveThinking === undefined ? {} : { thinking: liveThinking }),
+						...(liveFastMode ? { fastMode: true } : {}),
 						progress: liveProgress,
 					};
 					options.onUpdate?.({
@@ -261,69 +310,36 @@ export async function runSingleInProcess(
 	const neverAbort = new AbortController().signal;
 	const running = control.startAttempt(
 		admission.admitted,
-		{ modelId: candidate, thinkingLevel: spec.thinkingLevel },
+		{ model: resolvedCandidate?.model, modelId: candidate, thinkingLevel: spec.thinkingLevel },
 		{
 			abort: options.signal ?? neverAbort,
 			interrupt: options.interruptSignal ?? neverAbort,
 		},
+		{ fastModeForModel },
 	);
-	control.registerNestedAttempt(options.runId, running, { modelId: candidate, thinkingLevel: spec.thinkingLevel });
-	if (options.backgroundContinuation) {
-		control.continueInBackground(running, "async-requested");
-		void running.promise.then(
-			async (backgroundOutcome) => {
-				const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths);
-				await control.deliverChildResult(
-					{
-						path: backgroundOutcome.path,
-						status: backgroundOutcome.status,
-						...(backgroundOutcome.status === "error" ? { cause: backgroundOutcome.cause } : {}),
-						stats: backgroundOutcome.stats,
-						envelope: backgroundOutcome.envelope,
-						sessionFile: backgroundOutcome.sessionFile,
-						timestamp: Date.now(),
-						artifactsDir: options.artifactsDir,
-					},
-					{ artifactsDir: options.artifactsDir, artifactPaths, artifactsDisabled, maxOutput: options.maxOutput },
-				);
-				const delivered = control.getDeliveredResult(backgroundOutcome.path);
-				if (delivered) {
-					recovered.envelope = delivered.envelope;
-					recovered.finalOutput = delivered.envelope;
-				}
-				options.onDetachedExit?.(recovered);
-			},
-			() => undefined,
-		);
-		const continuedResult: SingleResult = {
+	if (options.onUpdate) {
+		const launchModel = running.currentModel ?? candidate;
+		spec.onProgress?.({
+			index: options.index ?? 0,
 			agent: agent.name,
+			status: "running",
 			task,
-			status: "continued",
-			path: admission.admitted.identity.path,
-			envelope: "Child continued in background.",
-			detached: true,
-			detachedReason: "async-requested",
-			messages: [],
-			usage: emptyUsage(),
-			progress: {
-				index: options.index ?? 0,
-				agent: agent.name,
-				status: "running",
-				task,
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: Math.max(0, Date.now() - startedAt),
-				lastActivityAt: Date.now(),
-			},
-		};
-		options.onUpdate?.({
-			content: [{ type: "text", text: continuedResult.envelope ?? "" }],
-			details: { mode: "single", runId: options.runId, results: [continuedResult] } satisfies Details,
+			...(launchModel === undefined ? {} : { model: launchModel }),
+			...(running.currentThinking === undefined ? {} : { thinking: running.currentThinking }),
+			fastMode: running.currentFastMode ?? fastModeForModel(launchModel),
+			recentTools: [],
+			recentOutput: [],
+			toolCount: 0,
+			tokens: 0,
+			durationMs: Math.max(0, Date.now() - startedAt),
+			lastActivityAt: Date.now(),
 		});
-		return continuedResult;
 	}
+	control.registerNestedAttempt(options.runId, running, {
+		model: resolvedCandidate?.model,
+		modelId: candidate,
+		thinkingLevel: spec.thinkingLevel,
+	});
 	let detached = false;
 	let resolveContinuation!: () => void;
 	const continuation = new Promise<void>((resolve) => {
@@ -335,7 +351,7 @@ export async function runSingleInProcess(
 		detach: () => {
 			if (detached) return;
 			detached = true;
-			control.continueInBackground(running, "intercom-coordination");
+			control.continueDetached(running, "intercom-coordination");
 			resolveContinuation();
 		},
 	});
@@ -343,43 +359,59 @@ export async function runSingleInProcess(
 	const winner = await Promise.race([terminal, continuation.then(() => ({ kind: "continued" as const }))]);
 	if (winner.kind === "continued") {
 		detachCleanup();
-		void running.promise.then(async (backgroundOutcome) => {
-			const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths);
+		void running.promise.then(async (continuedOutcome) => {
+			const recovered = resultFromOutcome(agent, task, continuedOutcome, startedAt, artifactPaths, {
+				cwd,
+				settings: fastModeSettings,
+				scope: fastModeScope,
+			});
 			await control.deliverChildResult(
 				{
-					path: backgroundOutcome.path,
-					status: backgroundOutcome.status,
-					...(backgroundOutcome.status === "error" ? { cause: backgroundOutcome.cause } : {}),
-					stats: backgroundOutcome.stats,
-					envelope: backgroundOutcome.envelope,
-					sessionFile: backgroundOutcome.sessionFile,
+					path: continuedOutcome.path,
+					status: continuedOutcome.status,
+					...(continuedOutcome.status === "error" ? { cause: continuedOutcome.cause } : {}),
+					stats: continuedOutcome.stats,
+					envelope: continuedOutcome.envelope,
+					...(recovered.model === undefined ? {} : { model: recovered.model }),
+					...(recovered.thinking === undefined ? {} : { thinking: recovered.thinking }),
+					...(recovered.fastMode ? { fastMode: true } : {}),
+					sessionFile: continuedOutcome.sessionFile,
 					timestamp: Date.now(),
 					artifactsDir: options.artifactsDir,
 				},
 				{ artifactsDir: options.artifactsDir, artifactPaths, artifactsDisabled, maxOutput: options.maxOutput },
 			);
-			const delivered = control.getDeliveredResult(backgroundOutcome.path);
+			const delivered = control.getDeliveredResult(continuedOutcome.path);
 			if (delivered) {
 				recovered.envelope = delivered.envelope;
 				recovered.finalOutput = delivered.envelope;
 			}
 			options.onDetachedExit?.(recovered);
 		});
+		const continuedModel = running.currentModel ?? candidate;
+		const continuedFastMode = fastModeForModel(continuedModel);
+		const continuedThinking = running.currentThinking;
 		const continuedResult: SingleResult = {
 			agent: agent.name,
 			task,
 			status: "continued",
 			path: admission.admitted.identity.path,
-			envelope: "Child continued in background.",
+			envelope: "Child detached for intercom coordination.",
 			detached: true,
 			detachedReason: "intercom-coordination",
 			messages: [],
 			usage: emptyUsage(),
+			...(continuedModel === undefined ? {} : { model: continuedModel }),
+			...(continuedThinking === undefined ? {} : { thinking: continuedThinking }),
+			...(continuedFastMode ? { fastMode: true } : {}),
 			progress: {
 				index: options.index ?? 0,
 				agent: agent.name,
 				status: "running",
 				task,
+				...(continuedModel === undefined ? {} : { model: continuedModel }),
+				...(continuedThinking === undefined ? {} : { thinking: continuedThinking }),
+				fastMode: continuedFastMode,
 				recentTools: [],
 				recentOutput: [],
 				toolCount: 0,
@@ -396,7 +428,11 @@ export async function runSingleInProcess(
 	}
 	detachCleanup();
 	const outcome = winner.value;
-	const result = resultFromOutcome(agent, task, outcome, startedAt, artifactPaths);
+	const result = resultFromOutcome(agent, task, outcome, startedAt, artifactPaths, {
+		cwd,
+		settings: fastModeSettings,
+		scope: fastModeScope,
+	});
 	if (filteredCandidates.skippedAttempts.length)
 		result.modelAttempts = [...filteredCandidates.skippedAttempts, ...(result.modelAttempts ?? [])];
 	await control.deliverChildResult(
@@ -406,6 +442,9 @@ export async function runSingleInProcess(
 			...(outcome.status === "error" ? { cause: outcome.cause } : {}),
 			stats: outcome.stats,
 			envelope: outcome.envelope,
+			...(result.model === undefined ? {} : { model: result.model }),
+			...(result.thinking === undefined ? {} : { thinking: result.thinking }),
+			...(result.fastMode ? { fastMode: true } : {}),
 			sessionFile: outcome.sessionFile,
 			timestamp: Date.now(),
 			artifactsDir: options.artifactsDir,