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

package/dist/builtin/subagents/src/runs/background/async-job-tracker.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
-import type { AsyncJobState, AsyncStartedEvent, AsyncStatus, SubagentState } from "../../shared/types.ts";
+import type { AsyncJobState, AsyncJobStep, AsyncStartedEvent, AsyncStatus, SubagentState } from "../../shared/types.ts";
 import { renderWidget } from "../../tui/render.ts";
 import { listSubagentControls } from "../inprocess/control-registry.ts";
 
@@ -51,15 +51,10 @@ function stateFromStatus(status: AsyncStatus, asyncDir: string): AsyncJobState {
 		...(status.toolCount !== undefined ? { toolCount: status.toolCount } : {}),
 		mode: status.mode,
 		agents: steps.map((step) => step.agent),
-		currentStep: status.currentStep,
-		chainStepCount: status.chainStepCount,
-		parallelGroups: status.parallelGroups,
 		steps,
 		stepsTotal: steps.length,
 		runningSteps: steps.filter((step) => step.status === "running").length,
 		completedSteps: status.state === "complete" ? steps.length : completedSteps,
-		hasParallelGroups: (status.parallelGroups?.length ?? 0) > 0,
-		activeParallelGroup: (status.parallelGroups?.length ?? 0) > 0 && status.state === "running",
 		startedAt: status.startedAt,
 		updatedAt: status.lastUpdate ?? status.startedAt,
 		...(status.sessionDir ? { sessionDir: status.sessionDir } : {}),
@@ -97,8 +92,60 @@ function readActiveFileJobs(
 	}
 	return jobs;
 }
+function stepFromStartedEvent(info: AsyncStartedEvent): AsyncJobStep | undefined {
+	if (!info.agent) return undefined;
+	return {
+		index: 0,
+		agent: info.agent,
+		status: "running",
+		...(info.model !== undefined ? { model: info.model } : {}),
+		...(info.thinking !== undefined ? { thinking: info.thinking } : {}),
+		...(info.fastMode !== undefined ? { fastMode: info.fastMode } : {}),
+	};
+}
+
+function mergeRegistryJob(previous: AsyncJobState | undefined, next: AsyncJobState): AsyncJobState {
+	if (!previous) return next;
+	const previousSteps = previous.steps ?? [];
+	const steps = next.steps?.map((step, index) => {
+		const previousStep = previousSteps.find(
+			(candidate, candidateIndex) =>
+				(candidate.index ?? candidateIndex) === (step.index ?? index) && candidate.agent === step.agent,
+		);
+		if (!previousStep) return step;
+		return {
+			...step,
+			...previousStep,
+			index: step.index,
+			agent: step.agent,
+			status: step.status,
+			...(step.model !== undefined ? { model: step.model } : {}),
+			...(step.thinking !== undefined ? { thinking: step.thinking } : {}),
+			...(step.fastMode !== undefined ? { fastMode: step.fastMode } : {}),
+		};
+	});
+	return {
+		...next,
+		asyncDir: previous.asyncDir,
+		...(previous.sessionId !== undefined ? { sessionId: previous.sessionId } : {}),
+		...(previous.mode !== undefined ? { mode: previous.mode } : {}),
+		...(previous.agents !== undefined ? { agents: [...previous.agents] } : {}),
+		...(previous.startedAt !== undefined ? { startedAt: previous.startedAt } : {}),
+		...(previous.sessionDir !== undefined ? { sessionDir: previous.sessionDir } : {}),
+		...(previous.outputFile !== undefined ? { outputFile: previous.outputFile } : {}),
+		...(previous.sessionFile !== undefined ? { sessionFile: previous.sessionFile } : {}),
+		...(previous.updatedAt !== undefined
+			? { updatedAt: Math.max(previous.updatedAt, next.updatedAt ?? previous.updatedAt) }
+			: {}),
+		...(steps ? { steps } : {}),
+	};
+}
 
-function hydrateRegistryJobs(_state: SubagentState, currentSessionId: string | null): Map<string, AsyncJobState> {
+function hydrateRegistryJobs(
+	state: SubagentState,
+	currentSessionId: string | null,
+	fileJobs?: Map<string, AsyncJobState>,
+): Map<string, AsyncJobState> {
 	const jobs = new Map<string, AsyncJobState>();
 	for (const control of listSubagentControls()) {
 		const children = control.listChildren();
@@ -116,6 +163,7 @@ function hydrateRegistryJobs(_state: SubagentState, currentSessionId: string | n
 							: child.status === "running" || child.status === "continued"
 								? ("running" as const)
 								: ("pending" as const),
+			...control.getChildMetadata(child.path),
 		}));
 		const status: AsyncJobState["status"] = steps.some(
 			(step) => step.status === "running" || step.status === "pending",
@@ -127,7 +175,7 @@ function hydrateRegistryJobs(_state: SubagentState, currentSessionId: string | n
 					? "paused"
 					: "complete";
 		if (status !== "running") continue;
-		jobs.set(control.parent.path, {
+		const next: AsyncJobState = {
 			asyncId: control.parent.path,
 			asyncDir: control.parent.path,
 			status,
@@ -138,11 +186,12 @@ function hydrateRegistryJobs(_state: SubagentState, currentSessionId: string | n
 			stepsTotal: steps.length,
 			runningSteps: steps.filter((step) => step.status === "running").length,
 			completedSteps: steps.filter((step) => step.status === "complete").length,
-			hasParallelGroups: steps.length > 1,
 			activeParallelGroup: steps.some((step) => step.status === "running"),
 			startedAt: Date.now(),
 			updatedAt: Date.now(),
-		});
+		};
+		const previous = state.asyncJobs.get(control.parent.path) ?? fileJobs?.get(control.parent.path);
+		jobs.set(control.parent.path, mergeRegistryJob(previous, next));
 	}
 	return jobs;
 }
@@ -193,34 +242,66 @@ export function createAsyncJobTracker(
 		if (ctxHasUI(ctx)) state.lastUiContext = ctx!;
 		const currentCwd = cwdOverride ?? safeCtxCwd(ctx) ?? state.baseCwd;
 		const fileJobs = readActiveFileJobs(asyncDirRoot, state.currentSessionId, currentCwd);
-		const registryJobs = hydrateRegistryJobs(state, state.currentSessionId);
+		const registryJobs = hydrateRegistryJobs(state, state.currentSessionId, fileJobs);
 		const next = new Map([...fileJobs, ...registryJobs]);
-		for (const id of state.asyncJobs.keys()) if (!next.has(id)) state.asyncJobs.delete(id);
+		for (const id of state.asyncJobs.keys())
+			if (!next.has(id) && !state.cleanupTimers.has(id)) state.asyncJobs.delete(id);
 		for (const [id, job] of next) state.asyncJobs.set(id, job);
 		rerender();
 	};
+	function terminalStepStatus(result: { success?: boolean; status?: string }): "complete" | "failed" | "paused" {
+		return result.status === "interrupted"
+			? "paused"
+			: result.status === "error" || result.status === "skipped" || result.success === false
+				? "failed"
+				: "complete";
+	}
 	const handleStarted = (data: unknown) => {
 		const info = data as AsyncStartedEvent;
 		if (!info.id) return;
 		const now = Date.now();
+		const step = stepFromStartedEvent(info);
 		state.asyncJobs.set(info.id, {
 			asyncId: info.id,
 			asyncDir: info.asyncDir ?? path.join(asyncDirRoot, info.id),
 			status: "running",
 			sessionId: info.sessionId,
-			mode: info.mode ?? (info.chain ? "chain" : "single"),
-			agents: info.agents ?? info.chain ?? (info.agent ? [info.agent] : undefined),
+			mode: info.mode ?? (info.agents && info.agents.length > 1 ? "parallel" : "single"),
+			agents: info.agents ?? (info.agent ? [info.agent] : undefined),
+			...(step ? { steps: [step], stepsTotal: 1, runningSteps: 1, completedSteps: 0 } : {}),
 			startedAt: now,
 			updatedAt: now,
 		});
 		rerender();
 	};
 	const handleComplete = (data: unknown) => {
-		const result = data as { id?: string; success?: boolean; status?: string };
+		const result = data as {
+			id?: string;
+			success?: boolean;
+			status?: string;
+			result?: { model?: string; thinking?: string; fastMode?: boolean };
+		};
 		if (!result.id) return;
 		const job = state.asyncJobs.get(result.id);
 		if (job) {
-			job.status = result.status === "interrupted" ? "paused" : result.success === false ? "failed" : "complete";
+			const stepStatus = terminalStepStatus(result);
+			job.status = stepStatus;
+			if (job.steps?.length) {
+				const completed = result.result;
+				job.steps = job.steps.map((step, index) =>
+					index !== 0
+						? step
+						: {
+								...step,
+								status: stepStatus,
+								...(completed?.model !== undefined ? { model: completed.model } : {}),
+								...(completed?.thinking !== undefined ? { thinking: completed.thinking } : {}),
+								...(completed ? { fastMode: completed.fastMode ?? false } : {}),
+							},
+				);
+				job.runningSteps = job.steps.filter((step) => step.status === "running").length;
+				job.completedSteps = job.steps.filter((step) => step.status === "complete").length;
+			}
 			job.updatedAt = Date.now();
 			scheduleCleanup(result.id);
 		}

package/dist/builtin/subagents/src/runs/background/completion-notification.ts

@@ -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,6 +20,11 @@ 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, {
 				...payload,
@@ -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/background/notify.ts

@@ -2,7 +2,7 @@
  * Subagent completion notifications.
  */
 
-import type { ExtensionAPI } from "@bastani/atomic";
+import { type ExtensionAPI, isStaleExtensionContextError } from "@bastani/atomic";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import {
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
@@ -11,7 +11,7 @@ import {
 } from "../../shared/types.ts";
 import type { CompletionNotificationEnvelope } from "./completion-notification.ts";
 
-interface ChainStepResult {
+interface SubagentStepResult {
 	agent: string;
 	output: string;
 	status: SubagentAttemptStatus;
@@ -43,7 +43,7 @@ interface SubagentResult {
 	shareUrl?: string;
 	gistUrl?: string;
 	shareError?: string;
-	results?: ChainStepResult[];
+	results?: SubagentStepResult[];
 	taskIndex?: number;
 	totalTasks?: number;
 	noticeLabel?: string;
@@ -134,13 +134,6 @@ async function dispatchFallback(
 export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 	const registry = getNotifyRegistry();
 	const previous = registry.get(pi);
-	if (previous) {
-		try {
-			previous.unsubscribe();
-		} catch {
-			// Best effort cleanup for stale handlers from an older reload.
-		}
-	}
 	const seen = getNotifySeen(pi);
 	const ttlMs = 10 * 60 * 1000;
 
@@ -166,24 +159,35 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 		const terminalId = result.notificationId?.startsWith("completion-notify-")
 			? result.notificationId.slice("completion-notify-".length)
 			: result.notificationId;
+		let dispatchStarted = false;
+		const barrierDispatch = dispatch
+			? (prefix: TerminalPreludeMessage[]) => {
+					dispatchStarted = true;
+					return dispatch(prefix);
+				}
+			: undefined;
 		const payload = {
 			runId,
 			...(terminalId ? { terminalId } : {}),
 			terminalAt: Number.isFinite(result.timestamp) ? result.timestamp : Date.now(),
 			source: "background-notify" as const,
 			sourceSessionTargets,
-			...(dispatch ? { dispatch } : {}),
+			...(barrierDispatch ? { dispatch: barrierDispatch } : {}),
 		};
 		Object.defineProperty(payload, "terminalOwner", { value: pi });
-		pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		try {
+			pi.events.emit(SUBAGENT_TERMINAL_ORDERING_BARRIER_EVENT, payload);
+		} catch (error) {
+			if (!isStaleExtensionContextError(error) || dispatchStarted) throw error;
+		}
 		const globalHandler = (globalThis as Record<string, unknown>).__atomicTerminalOrderingBarrierHandler;
 		if (typeof globalHandler === "function") (globalHandler as (value: unknown) => void)(payload);
 		return (payload as typeof payload & { completion?: Promise<void> }).completion;
 	};
 	const inFlight = new Map<string, Promise<void>>();
-	let registration: NotifyRegistration;
+	let registration: NotifyRegistration | undefined;
 	const handleComplete = (data: unknown): void => {
-		if (registry.get(pi) !== registration) return;
+		if (!registration || registry.get(pi) !== registration) return;
 		const result = data as SubagentResult & Partial<CompletionNotificationEnvelope>;
 		const now = Date.now();
 		const key = result.notificationId
@@ -308,13 +312,45 @@ export default function registerSubagentNotify(pi: ExtensionAPI): () => void {
 			fail(error);
 		}
 	};
-
-	const unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+	let unsubscribe: () => void;
+	try {
+		unsubscribe = pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete);
+	} catch (error) {
+		if (!isStaleExtensionContextError(error)) throw error;
+		// A stale API cannot accept a new subscription; keep the prior one usable.
+		return () => {};
+	}
 	registration = { unsubscribe };
 	registry.set(pi, registration);
+	if (previous) {
+		try {
+			previous.unsubscribe();
+		} catch (error) {
+			if (isStaleExtensionContextError(error)) {
+				// The old handler is inert because the registry now belongs to this registration.
+			} else {
+				// A failed replacement cleanup aborts activation; remove the new entry before rethrowing.
+				if (registry.get(pi) === registration) registry.delete(pi);
+				try {
+					unsubscribe();
+				} catch (rollbackError) {
+					if (!isStaleExtensionContextError(rollbackError)) {
+						throw new AggregateError([error, rollbackError], "Failed to roll back notification registration");
+					}
+					// Stale cleanup is best effort after the registry rollback.
+				}
+				throw error;
+			}
+		}
+	}
 	return () => {
-		if (registry.get(pi) !== registration) return;
+		if (!registration || registry.get(pi) !== registration) return;
 		registry.delete(pi);
-		unsubscribe();
+		try {
+			unsubscribe();
+		} catch (error) {
+			if (!isStaleExtensionContextError(error)) throw error;
+			// Stale event-bus cleanup is best effort.
+		}
 	};
 }

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,25 @@ export async function runSingleInProcess(
 		return noSpawnableCandidatesResult(agent, task, filteredCandidates.skippedAttempts);
 	const candidate = filteredCandidates.candidates[0];
 	const fallbackCandidates = filteredCandidates.candidates.slice(1);
+	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,9 +244,7 @@ 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,
@@ -235,12 +273,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?.({
@@ -266,13 +310,36 @@ export async function runSingleInProcess(
 			abort: options.signal ?? neverAbort,
 			interrupt: options.interruptSignal ?? neverAbort,
 		},
+		{ fastModeForModel },
 	);
+	if (options.onUpdate && !options.backgroundContinuation) {
+		const launchModel = running.currentModel ?? candidate;
+		spec.onProgress?.({
+			index: options.index ?? 0,
+			agent: agent.name,
+			status: "running",
+			task,
+			...(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(),
+		});
+	}
 	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);
+				const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths, {
+					cwd,
+					settings: fastModeSettings,
+					scope: fastModeScope,
+				});
 				await control.deliverChildResult(
 					{
 						path: backgroundOutcome.path,
@@ -280,6 +347,9 @@ export async function runSingleInProcess(
 						...(backgroundOutcome.status === "error" ? { cause: backgroundOutcome.cause } : {}),
 						stats: backgroundOutcome.stats,
 						envelope: backgroundOutcome.envelope,
+						...(recovered.model === undefined ? {} : { model: recovered.model }),
+						...(recovered.thinking === undefined ? {} : { thinking: recovered.thinking }),
+						...(recovered.fastMode ? { fastMode: true } : {}),
 						sessionFile: backgroundOutcome.sessionFile,
 						timestamp: Date.now(),
 						artifactsDir: options.artifactsDir,
@@ -295,6 +365,9 @@ export async function runSingleInProcess(
 			},
 			() => undefined,
 		);
+		const continuedModel = running.currentModel ?? candidate;
+		const continuedFastMode = fastModeForModel(continuedModel);
+		const continuedThinking = running.currentThinking;
 		const continuedResult: SingleResult = {
 			agent: agent.name,
 			task,
@@ -305,11 +378,17 @@ export async function runSingleInProcess(
 			detachedReason: "async-requested",
 			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 }),
+				...(continuedFastMode ? { fastMode: true } : {}),
 				recentTools: [],
 				recentOutput: [],
 				toolCount: 0,
@@ -344,7 +423,11 @@ export async function runSingleInProcess(
 	if (winner.kind === "continued") {
 		detachCleanup();
 		void running.promise.then(async (backgroundOutcome) => {
-			const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths);
+			const recovered = resultFromOutcome(agent, task, backgroundOutcome, startedAt, artifactPaths, {
+				cwd,
+				settings: fastModeSettings,
+				scope: fastModeScope,
+			});
 			await control.deliverChildResult(
 				{
 					path: backgroundOutcome.path,
@@ -352,6 +435,9 @@ export async function runSingleInProcess(
 					...(backgroundOutcome.status === "error" ? { cause: backgroundOutcome.cause } : {}),
 					stats: backgroundOutcome.stats,
 					envelope: backgroundOutcome.envelope,
+					...(recovered.model === undefined ? {} : { model: recovered.model }),
+					...(recovered.thinking === undefined ? {} : { thinking: recovered.thinking }),
+					...(recovered.fastMode ? { fastMode: true } : {}),
 					sessionFile: backgroundOutcome.sessionFile,
 					timestamp: Date.now(),
 					artifactsDir: options.artifactsDir,
@@ -365,6 +451,9 @@ export async function runSingleInProcess(
 			}
 			options.onDetachedExit?.(recovered);
 		});
+		const continuedModel = running.currentModel ?? candidate;
+		const continuedFastMode = fastModeForModel(continuedModel);
+		const continuedThinking = running.currentThinking;
 		const continuedResult: SingleResult = {
 			agent: agent.name,
 			task,
@@ -375,11 +464,17 @@ export async function runSingleInProcess(
 			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 +491,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 +505,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,