@bastani/atomic 0.8.21 → 0.8.22

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

@@ -4,7 +4,6 @@
 
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
@@ -19,6 +18,11 @@ import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } f
 import { resolveChildCwd } from "../../shared/utils.ts";
 import { buildModelCandidates, resolveModelCandidate, type AvailableModelInfo } from "../shared/model-fallback.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
+import {
+	getSubagentCodexFastModeSettings,
+	resolveSubagentCodexFastModeScope,
+	resolveSubagentModelFastModeMetadata,
+} from "../../shared/fast-mode.ts";
 import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.ts";
 import {
 	type ArtifactConfig,
@@ -254,6 +258,7 @@ export function executeAsyncChain(
 	const resultMode = params.resultMode ?? "chain";
 	const chainSkills = params.chainSkills ?? [];
 	const availableModels = params.availableModels;
+	const fastModeScope = resolveSubagentCodexFastModeScope(workflowStageSubagentGuard);
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
 	const firstStep = chain[0];
 	const originalTask = params.task ?? (firstStep
@@ -329,15 +334,20 @@ export function executeAsyncChain(
 
 		const primaryModel = resolveModelCandidate(behavior.model ?? a.model, availableModels, ctx.currentModelProvider);
 		const model = applyThinkingSuffix(primaryModel, a.thinking);
+		const modelCandidates = buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel)
+			.map((candidate) => applyThinkingSuffix(candidate, a.thinking))
+			.filter((candidate): candidate is string => typeof candidate === "string");
+		const fastModeSettings = getSubagentCodexFastModeSettings(stepCwd);
 		return {
 			agent: s.agent,
 			task,
 			cwd: stepCwd,
 			model,
 			thinking: resolveEffectiveThinking(model, a.thinking),
-			modelCandidates: buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel)
-				.map((candidate) => applyThinkingSuffix(candidate, a.thinking))
-				.filter((candidate): candidate is string => typeof candidate === "string"),
+			...resolveSubagentModelFastModeMetadata({ model, modelCandidates, cwd: stepCwd, settings: fastModeSettings, scope: fastModeScope }),
+			modelCandidates,
+			codexFastModeSettings: fastModeSettings,
+			codexFastModeScope: fastModeScope,
 			tools: a.tools,
 			extensions: a.extensions,
 			mcpDirectTools: a.mcpDirectTools,
@@ -602,6 +612,11 @@ export function executeAsyncSingle(
 		resolveModelCandidate(params.modelOverride ?? agentConfig.model, availableModels, ctx.currentModelProvider),
 		agentConfig.thinking,
 	);
+	const modelCandidates = buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel)
+		.map((candidate) => applyThinkingSuffix(candidate, agentConfig.thinking))
+		.filter((candidate): candidate is string => typeof candidate === "string");
+	const fastModeSettings = getSubagentCodexFastModeSettings(runnerCwd);
+	const fastModeScope = resolveSubagentCodexFastModeScope(workflowStageSubagentGuard);
 	let spawnResult: { pid?: number; error?: string } = {};
 	try {
 		spawnResult = spawnRunner(
@@ -614,9 +629,10 @@ export function executeAsyncSingle(
 						cwd: runnerCwd,
 						model,
 						thinking: resolveEffectiveThinking(model, agentConfig.thinking),
-						modelCandidates: buildModelCandidates(params.modelOverride ?? agentConfig.model, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, ctx.currentModel)
-							.map((candidate) => applyThinkingSuffix(candidate, agentConfig.thinking))
-							.filter((candidate): candidate is string => typeof candidate === "string"),
+						...resolveSubagentModelFastModeMetadata({ model, modelCandidates, cwd: runnerCwd, settings: fastModeSettings, scope: fastModeScope }),
+						modelCandidates,
+						codexFastModeSettings: fastModeSettings,
+						codexFastModeScope: fastModeScope,
 						tools: agentConfig.tools,
 						extensions: agentConfig.extensions,
 						mcpDirectTools: agentConfig.mcpDirectTools,

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

@@ -14,6 +14,7 @@ import {
 	SUBAGENT_CONTROL_INTERCOM_EVENT,
 } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
+import { listAsyncRuns, type AsyncRunSummary } from "./async-status.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 import { hasLiveNestedDescendants, updateAsyncJobNestedProjection } from "../shared/nested-events.ts";
@@ -26,18 +27,77 @@ interface AsyncJobTrackerOptions {
 	now?: () => number;
 }
 
+const ACTIVE_HYDRATION_STATES: Array<AsyncRunSummary["state"]> = ["queued", "running"];
+
+function cwdMatches(summaryCwd: string | undefined, currentCwd: string | undefined): boolean {
+	return Boolean(summaryCwd && currentCwd && path.resolve(summaryCwd) === path.resolve(currentCwd));
+}
+
+function shouldHydrateRunForCurrentUi(summary: AsyncRunSummary, currentSessionId: string | null, currentCwd: string | undefined): boolean {
+	if (summary.sessionId && currentSessionId) return summary.sessionId === currentSessionId;
+	return cwdMatches(summary.cwd, currentCwd);
+}
+
+function asyncRunSummaryToJobState(summary: AsyncRunSummary, existing?: AsyncJobState): AsyncJobState {
+	const chainStepCount = summary.chainStepCount ?? summary.steps.length;
+	const groups = normalizeParallelGroups(summary.parallelGroups, summary.steps.length, chainStepCount);
+	const activeGroup = summary.currentStep !== undefined
+		? groups.find((group) => summary.currentStep! >= group.start && summary.currentStep! < group.start + group.count)
+		: undefined;
+	const steps = activeGroup
+		? summary.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count).map((step, index) => ({ ...step, index: activeGroup.start + index }))
+		: summary.steps.map((step, index) => ({ ...step, index: step.index ?? index }));
+	const agents = steps.map((step) => step.agent);
+	const stepsTotal = steps.length > 0 ? steps.length : existing?.stepsTotal ?? (agents.length > 0 ? agents.length : undefined);
+	const completedSteps = summary.state === "complete"
+		? steps.length
+		: steps.filter((step) => step.status === "complete" || step.status === "completed").length;
+	return {
+		...existing,
+		asyncId: summary.id,
+		asyncDir: summary.asyncDir,
+		status: summary.state,
+		sessionId: summary.sessionId ?? existing?.sessionId,
+		activityState: summary.activityState,
+		lastActivityAt: summary.lastActivityAt,
+		currentTool: summary.currentTool,
+		currentToolStartedAt: summary.currentToolStartedAt,
+		currentPath: summary.currentPath,
+		turnCount: summary.turnCount,
+		toolCount: summary.toolCount,
+		mode: summary.mode,
+		agents: agents.length > 0 ? agents : existing?.agents,
+		currentStep: summary.currentStep,
+		chainStepCount: summary.chainStepCount ?? existing?.chainStepCount,
+		parallelGroups: groups,
+		steps: steps.length > 0 ? steps : existing?.steps,
+		stepsTotal,
+		runningSteps: steps.filter((step) => step.status === "running").length,
+		completedSteps,
+		hasParallelGroups: groups.length > 0,
+		activeParallelGroup: Boolean(activeGroup),
+		startedAt: summary.startedAt,
+		updatedAt: summary.lastUpdate ?? summary.startedAt,
+		sessionDir: summary.sessionDir ?? existing?.sessionDir,
+		outputFile: summary.outputFile ?? existing?.outputFile,
+		totalTokens: summary.totalTokens,
+		sessionFile: summary.sessionFile ?? existing?.sessionFile,
+		nestedChildren: summary.nestedChildren,
+	};
+}
+
 export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: SubagentState, asyncDirRoot: string, options: AsyncJobTrackerOptions = {}): {
 	ensurePoller: () => void;
 	handleStarted: (data: unknown) => void;
 	handleComplete: (data: unknown) => void;
 	resetJobs: (ctx?: ExtensionContext) => void;
+	hydrateActiveJobs: (ctx?: ExtensionContext) => void;
 } {
 	const completionRetentionMs = options.completionRetentionMs ?? 10000;
 	const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
 	const resultsDir = options.resultsDir ?? RESULTS_DIR;
 	const rerenderWidget = (ctx: ExtensionContext, jobs = Array.from(state.asyncJobs.values())) => {
 		renderWidget(ctx, jobs);
-		ctx.ui.requestRender?.();
 	};
 	const cancelCleanup = (asyncId: string) => {
 		const existingTimer = state.cleanupTimers.get(asyncId);
@@ -233,12 +293,47 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		state.poller.unref?.();
 	};
 
+	const hydrateActiveJobs = (ctx?: ExtensionContext) => {
+		if (ctx?.hasUI) state.lastUiContext = ctx;
+		const renderCtx = state.lastUiContext?.hasUI ? state.lastUiContext : undefined;
+		const currentCwd = (ctx?.cwd ?? state.lastUiContext?.cwd ?? state.baseCwd) || undefined;
+		let summaries: AsyncRunSummary[];
+		try {
+			summaries = listAsyncRuns(asyncDirRoot, {
+				states: ACTIVE_HYDRATION_STATES,
+				resultsDir,
+				kill: options.kill,
+				now: options.now,
+			});
+		} catch (error) {
+			console.error(`Failed to hydrate active async jobs from '${asyncDirRoot}':`, error);
+			if (renderCtx) rerenderWidget(renderCtx);
+			return;
+		}
+
+		for (const summary of summaries) {
+			if (!shouldHydrateRunForCurrentUi(summary, state.currentSessionId, currentCwd)) continue;
+			cancelCleanup(summary.id);
+			state.asyncJobs.set(summary.id, asyncRunSummaryToJobState(summary, state.asyncJobs.get(summary.id)));
+		}
+
+		if (state.asyncJobs.size > 0) ensurePoller();
+		if (renderCtx) rerenderWidget(renderCtx);
+	};
+
 	const handleStarted = (data: unknown) => {
 		const info = data as AsyncStartedEvent;
 		if (!info.id) return;
 		const now = Date.now();
 		const asyncDir = info.asyncDir ?? path.join(asyncDirRoot, info.id);
-		const rawAgents = info.agents?.length ? info.agents : info.chain && info.chain.length > 0 ? info.chain : info.agent ? [info.agent] : undefined;
+		let rawAgents: string[] | undefined;
+		if (info.agents?.length) {
+			rawAgents = info.agents;
+		} else if (info.chain && info.chain.length > 0) {
+			rawAgents = info.chain;
+		} else if (info.agent) {
+			rawAgents = [info.agent];
+		}
 		const validParallelGroups = normalizeParallelGroups(info.parallelGroups, Number.MAX_SAFE_INTEGER, info.chainStepCount ?? Number.MAX_SAFE_INTEGER);
 		const firstGroup = validParallelGroups.find((group) => group.start === 0);
 		const firstGroupCount = firstGroup?.count;
@@ -306,5 +401,5 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		}
 	};
 
-	return { ensurePoller, handleStarted, handleComplete, resetJobs };
+	return { ensurePoller, handleStarted, handleComplete, resetJobs, hydrateActiveJobs };
 }

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

@@ -28,6 +28,7 @@ interface AsyncRunStepSummary {
 	skills?: string[];
 	model?: string;
 	thinking?: string;
+	fastMode?: boolean;
 	attemptedModels?: string[];
 	error?: string;
 	children?: NestedRunSummary[];
@@ -155,6 +156,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.skills ? { skills: step.skills } : {}),
 			...(step.model ? { model: step.model } : {}),
 			...(step.thinking ? { thinking: step.thinking } : {}),
+			...(step.fastMode !== undefined ? { fastMode: step.fastMode } : {}),
 			...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
 			...(step.error ? { error: step.error } : {}),
 			...(step.children?.length ? { children: step.children } : {}),
@@ -262,7 +264,7 @@ function formatStepLine(step: AsyncRunStepSummary): string {
 	const parts = [`${step.index + 1}. ${step.agent}`, step.status];
 	const activity = formatActivityFacts(step);
 	if (activity) parts.push(activity);
-	const modelThinking = formatModelThinking(step.model, step.thinking);
+	const modelThinking = formatModelThinking(step.model, step.thinking, step.fastMode);
 	if (modelThinking) parts.push(modelThinking);
 	if (step.durationMs !== undefined) parts.push(formatDuration(step.durationMs));
 	if (step.tokens) parts.push(`${formatTokens(step.tokens.total)} tok`);

package/dist/builtin/subagents/src/runs/background/run-status.ts

@@ -213,7 +213,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			].filter((line): line is string => Boolean(line));
 			for (const [index, step] of (status.steps ?? []).entries()) {
 				const stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
-				const modelThinking = formatModelThinking(step.model, step.thinking);
+				const modelThinking = formatModelThinking(step.model, step.thinking, step.fastMode);
 				const modelText = modelThinking ? ` (${modelThinking})` : "";
 				const errorText = step.error ? `, error: ${step.error}` : "";
 				lines.push(`${stepLineLabel(status, index)}: ${step.agent} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${errorText}`);

package/dist/builtin/subagents/src/runs/background/stale-run-reconciler.ts

@@ -79,6 +79,7 @@ interface ResultChildOutcome {
 	error?: string;
 	sessionFile?: string;
 	model?: string;
+	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: NonNullable<AsyncStatus["steps"]>[number]["modelAttempts"];
 }
@@ -123,6 +124,7 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 			error: state === "failed" ? step.error ?? child?.error : step.error,
 			sessionFile: step.sessionFile ?? child?.sessionFile,
 			model: step.model ?? child?.model,
+			fastMode: step.fastMode ?? child?.fastMode,
 			attemptedModels: step.attemptedModels ?? child?.attemptedModels,
 			modelAttempts: step.modelAttempts ?? child?.modelAttempts,
 		};
@@ -205,6 +207,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 				error: step.status === "complete" || step.status === "completed" ? undefined : step.error ?? message,
 				success: step.status === "complete" || step.status === "completed",
 				model: step.model,
+				fastMode: step.fastMode,
 				attemptedModels: step.attemptedModels,
 				modelAttempts: step.modelAttempts,
 				sessionFile: step.sessionFile,

package/dist/builtin/subagents/src/runs/background/subagent-runner.ts

@@ -108,6 +108,7 @@ interface StepResult {
 	sessionFile?: string;
 	intercomTarget?: string;
 	model?: string;
+	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
 	artifactPaths?: ArtifactPaths;
@@ -166,6 +167,14 @@ function resetStepLiveDetail(step: RunnerStatusStep): void {
 	step.recentOutput = [];
 }
 
+function fastModeForStepAttempt(step: SubagentStep, model: string | undefined): boolean | undefined {
+	if (model && step.modelFastModes && Object.prototype.hasOwnProperty.call(step.modelFastModes, model)) {
+		return step.modelFastModes[model];
+	}
+	if (model === undefined || model === step.model) return step.fastMode;
+	return undefined;
+}
+
 interface ChildEventContext {
 	eventsPath: string;
 	runId: string;
@@ -565,7 +574,7 @@ interface SingleStepContext {
 	childIntercomTarget?: string;
 	orchestratorIntercomTarget?: string;
 	nestedRoute?: NestedRouteInfo;
-	onAttemptStart?: (attempt: { model?: string; thinking?: string }) => void;
+	onAttemptStart?: (attempt: { model?: string; thinking?: string; fastMode?: boolean }) => void;
 	onChildEvent?: (event: ChildEvent) => void;
 	workflowStageSubagentGuard?: boolean;
 }
@@ -580,6 +589,7 @@ async function runSingleStep(
 	exitCode: number | null;
 	error?: string;
 	model?: string;
+	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
 	artifactPaths?: ArtifactPaths;
@@ -613,12 +623,14 @@ async function runSingleStep(
 	const attemptNotes: string[] = [];
 	const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
 	let finalResult: RunPiStreamingResult | undefined;
+	let finalFastMode: boolean | undefined;
 	let finalOutputSnapshot: SingleOutputSnapshot | undefined;
 	let completionGuardTriggeredFinal = false;
 
 	for (let index = 0; index < candidates.length; index++) {
 		const candidate = candidates[index];
-		ctx.onAttemptStart?.({ model: candidate, thinking: resolveEffectiveThinking(candidate, step.thinking) });
+		const attemptFastMode = fastModeForStepAttempt(step, candidate);
+		ctx.onAttemptStart?.({ model: candidate, thinking: resolveEffectiveThinking(candidate, step.thinking), fastMode: attemptFastMode ? true : undefined });
 		const outputSnapshot = captureSingleOutputSnapshot(step.outputPath);
 		const { args, env, tempDir } = buildPiArgs({
 			baseArgs: ["--mode", "json", "-p"],
@@ -645,6 +657,8 @@ async function runSingleStep(
 			parentControlInbox: ctx.nestedRoute?.controlInbox,
 			parentRootRunId: ctx.nestedRoute?.rootRunId,
 			parentCapabilityToken: ctx.nestedRoute?.capabilityToken,
+			codexFastModeSettings: step.codexFastModeSettings,
+			codexFastModeScope: step.codexFastModeScope,
 		});
 		const run = await runPiStreaming(
 			args,
@@ -698,6 +712,7 @@ async function runSingleStep(
 		modelAttempts.push(attempt);
 		if (candidate) attemptedModels.push(candidate);
 		completionGuardTriggeredFinal = completionGuardTriggered;
+		finalFastMode = attemptFastMode;
 		finalOutputSnapshot = outputSnapshot;
 		finalResult = { ...run, exitCode: effectiveExitCode, model: candidate ?? run.model, error };
 		if (attempt.success || completionGuardTriggered) break;
@@ -739,6 +754,7 @@ async function runSingleStep(
 					task,
 					exitCode: finalResult?.exitCode,
 					model: finalResult?.model,
+					...(finalFastMode ? { fastMode: true } : {}),
 					attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
 					modelAttempts,
 					skills: step.skills,
@@ -757,6 +773,7 @@ async function runSingleStep(
 		sessionFile: step.sessionFile,
 		intercomTarget: ctx.childIntercomTarget,
 		model: finalResult?.model,
+		...(finalFastMode ? { fastMode: true } : {}),
 		attemptedModels: attemptedModels.length > 0 ? attemptedModels : undefined,
 		modelAttempts,
 		artifactPaths,
@@ -944,6 +961,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			skills: step.skills,
 			model: step.model,
 			thinking: step.thinking,
+			...(step.fastMode ? { fastMode: true } : {}),
 			attemptedModels: step.modelCandidates && step.modelCandidates.length > 0 ? step.modelCandidates : step.model ? [step.model] : undefined,
 			recentTools: [],
 			recentOutput: [],
@@ -1065,11 +1083,12 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		appendControlEvent(event);
 		return true;
 	};
-	const updateStepModel = (flatIndex: number, model: string | undefined, thinking: string | undefined, now = Date.now()): void => {
+	const updateStepModel = (flatIndex: number, model: string | undefined, thinking: string | undefined, fastMode: boolean | undefined, now = Date.now()): void => {
 		const step = statusPayload.steps[flatIndex];
 		if (!step) return;
 		step.model = model;
 		step.thinking = thinking;
+		step.fastMode = fastMode ? true : undefined;
 		statusPayload.lastUpdate = now;
 		writeStatusPayload();
 	};
@@ -1399,7 +1418,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 							registerInterrupt: (interrupt) => {
 								activeChildInterrupt = interrupt;
 							},
-							onAttemptStart: (attempt) => updateStepModel(fi, attempt.model, attempt.thinking),
+							onAttemptStart: (attempt) => updateStepModel(fi, attempt.model, attempt.thinking, attempt.fastMode),
 							onChildEvent: (event) => updateStepFromChildEvent(fi, event),
 							workflowStageSubagentGuard: config.workflowStageSubagentGuard,
 						});
@@ -1416,6 +1435,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						statusPayload.steps[fi].exitCode = singleResult.exitCode;
 						statusPayload.steps[fi].model = singleResult.model;
 						statusPayload.steps[fi].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[fi].thinking);
+						statusPayload.steps[fi].fastMode = singleResult.fastMode ? true : undefined;
 						statusPayload.steps[fi].attemptedModels = singleResult.attemptedModels;
 						statusPayload.steps[fi].modelAttempts = singleResult.modelAttempts;
 						statusPayload.steps[fi].error = singleResult.error;
@@ -1476,6 +1496,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 						sessionFile: pr.sessionFile,
 						intercomTarget: pr.intercomTarget,
 						model: pr.model,
+						fastMode: pr.fastMode,
 						attemptedModels: pr.attemptedModels,
 						modelAttempts: pr.modelAttempts,
 						artifactPaths: pr.artifactPaths,
@@ -1484,13 +1505,14 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 				previousOutput = aggregateParallelOutputs(
 					parallelResults.map((r) => ({
-					agent: r.agent,
-					output: r.output,
-					exitCode: r.exitCode,
-					error: r.error,
-					model: r.model,
-					attemptedModels: r.attemptedModels,
-				})),
+						agent: r.agent,
+						output: r.output,
+						exitCode: r.exitCode,
+						error: r.error,
+						model: r.model,
+						fastMode: r.fastMode,
+						attemptedModels: r.attemptedModels,
+					})),
 				);
 				previousOutput = appendParallelWorktreeSummary(previousOutput, worktreeSetup, asyncDir, stepIndex, group);
 
@@ -1546,7 +1568,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				registerInterrupt: (interrupt) => {
 					activeChildInterrupt = interrupt;
 				},
-				onAttemptStart: (attempt) => updateStepModel(flatIndex, attempt.model, attempt.thinking),
+				onAttemptStart: (attempt) => updateStepModel(flatIndex, attempt.model, attempt.thinking, attempt.fastMode),
 				onChildEvent: (event) => updateStepFromChildEvent(flatIndex, event),
 				workflowStageSubagentGuard: config.workflowStageSubagentGuard,
 			});
@@ -1563,6 +1585,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				sessionFile: singleResult.sessionFile,
 				intercomTarget: singleResult.intercomTarget,
 				model: singleResult.model,
+				fastMode: singleResult.fastMode,
 				attemptedModels: singleResult.attemptedModels,
 				modelAttempts: singleResult.modelAttempts,
 				artifactPaths: singleResult.artifactPaths,
@@ -1596,6 +1619,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			statusPayload.steps[flatIndex].exitCode = singleResult.exitCode;
 			statusPayload.steps[flatIndex].model = singleResult.model;
 			statusPayload.steps[flatIndex].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[flatIndex].thinking);
+			statusPayload.steps[flatIndex].fastMode = singleResult.fastMode ? true : undefined;
 			statusPayload.steps[flatIndex].attemptedModels = singleResult.attemptedModels;
 			statusPayload.steps[flatIndex].modelAttempts = singleResult.modelAttempts;
 			statusPayload.steps[flatIndex].error = singleResult.error;
@@ -1753,6 +1777,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				sessionFile: r.sessionFile,
 				intercomTarget: r.intercomTarget,
 				model: r.model,
+				fastMode: r.fastMode,
 				attemptedModels: r.attemptedModels,
 				modelAttempts: r.modelAttempts,
 				artifactPaths: r.artifactPaths,

package/dist/builtin/subagents/src/runs/foreground/chain-clarify.ts

@@ -340,10 +340,10 @@ export class ChainClarifyComponent implements Component {
 			? rawAgentName.slice(0, maxAgentLen - 1) + "…"
 			: rawAgentName;
 		// Use mode-appropriate terminology
-		const stepLabel = this.mode === 'single' 
-			? agentName 
-			: this.mode === 'parallel' 
-				? `Task ${this.editingStep! + 1}: ${agentName}` 
+		const stepLabel = this.mode === 'single'
+			? agentName
+			: this.mode === 'parallel'
+				? `Task ${this.editingStep! + 1}: ${agentName}`
 				: `Step ${this.editingStep! + 1}: ${agentName}`;
 		const headerText = ` Editing ${fieldName} (${stepLabel}) `;
 		lines.push(this.renderHeader(headerText));
@@ -859,7 +859,7 @@ export class ChainClarifyComponent implements Component {
 		// Check all downstream steps (steps that come after the changed step)
 		for (let i = changedStepIndex + 1; i < this.agentConfigs.length; i++) {
 			const behavior = this.getEffectiveBehavior(i);
-			
+
 			// Skip if reads is disabled or empty
 			if (behavior.reads === false || !behavior.reads || behavior.reads.length === 0) {
 				continue;
@@ -868,7 +868,7 @@ export class ChainClarifyComponent implements Component {
 			// Check if this step reads the old output file
 			const readsArray = behavior.reads;
 			const oldIndex = readsArray.indexOf(oldOutput);
-			
+
 			if (oldIndex !== -1) {
 				// Replace old filename with new filename in reads
 				const newReads = [...readsArray];
@@ -906,10 +906,10 @@ export class ChainClarifyComponent implements Component {
 
 		// Header (mode-aware terminology)
 		const agentName = this.agentConfigs[this.editingStep!]?.name ?? "unknown";
-		const stepLabel = this.mode === 'single' 
-			? agentName 
-			: this.mode === 'parallel' 
-				? `Task ${this.editingStep! + 1}: ${agentName}` 
+		const stepLabel = this.mode === 'single'
+			? agentName
+			: this.mode === 'parallel'
+				? `Task ${this.editingStep! + 1}: ${agentName}`
 				: `Step ${this.editingStep! + 1}: ${agentName}`;
 		const headerText = ` Select Model (${stepLabel}) `;
 		lines.push(this.renderHeader(headerText));
@@ -980,10 +980,10 @@ export class ChainClarifyComponent implements Component {
 		const lines: string[] = [];
 
 		const agentName = this.agentConfigs[this.editingStep!]?.name ?? "unknown";
-		const stepLabel = this.mode === 'single' 
-			? agentName 
-			: this.mode === 'parallel' 
-				? `Task ${this.editingStep! + 1}: ${agentName}` 
+		const stepLabel = this.mode === 'single'
+			? agentName
+			: this.mode === 'parallel'
+				? `Task ${this.editingStep! + 1}: ${agentName}`
 				: `Step ${this.editingStep! + 1}: ${agentName}`;
 		const headerText = ` Thinking Level (${stepLabel}) `;
 		lines.push(this.renderHeader(headerText));
@@ -1301,7 +1301,7 @@ export class ChainClarifyComponent implements Component {
 
 			if (progressEnabled) {
 				const isFirstStep = i === 0;
-				const progressAction = isFirstStep 
+				const progressAction = isFirstStep
 					? th.fg("success", "writes progress.md")
 					: th.fg("accent", "reads progress.md");
 				const progressLabel = th.fg("dim", "progress: ");

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

@@ -5,6 +5,7 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import type { Message } from "@earendil-works/pi-ai";
+import type { CodexFastModeResolvedSettings, CodexFastModeScope } from "@bastani/atomic";
 import type { AgentConfig } from "../../agents/agents.ts";
 import {
 	ensureArtifactsDir,
@@ -63,6 +64,11 @@ import {
 	shouldEscalateMutatingFailures,
 	summarizeRecentMutatingFailures,
 } from "../shared/long-running-guard.ts";
+import {
+	getSubagentCodexFastModeSettings,
+	resolveSubagentCodexFastModeScope,
+	resolveSubagentModelFastMode,
+} from "../../shared/fast-mode.ts";
 
 const artifactOutputByResult = new WeakMap<SingleResult, string>();
 
@@ -133,9 +139,18 @@ async function runSingleAttempt(
 		artifactPaths?: ArtifactPaths;
 		attemptNotes: string[];
 		outputSnapshot?: SingleOutputSnapshot;
+		fastModeSettings: CodexFastModeResolvedSettings;
+		fastModeScope: CodexFastModeScope;
 	},
 ): Promise<SingleResult> {
 	const modelArg = applyThinkingSuffix(model, agent.thinking);
+	const runCwd = options.cwd ?? runtimeCwd;
+	const fastMode = resolveSubagentModelFastMode({
+		model: modelArg,
+		cwd: runCwd,
+		settings: shared.fastModeSettings,
+		scope: shared.fastModeScope,
+	});
 	const { args, env: sharedEnv, tempDir } = buildPiArgs({
 		baseArgs: ["--mode", "json", "-p"],
 		task,
@@ -151,7 +166,7 @@ async function runSingleAttempt(
 		extensions: agent.extensions,
 		systemPrompt: shared.systemPrompt,
 		mcpDirectTools: agent.mcpDirectTools,
-		cwd: options.cwd ?? runtimeCwd,
+		cwd: runCwd,
 		promptFileStem: agent.name,
 		intercomSessionName: options.intercomSessionName,
 		orchestratorIntercomTarget: options.orchestratorIntercomTarget,
@@ -162,6 +177,8 @@ async function runSingleAttempt(
 		parentControlInbox: options.nestedRoute?.controlInbox,
 		parentRootRunId: options.nestedRoute?.rootRunId,
 		parentCapabilityToken: options.nestedRoute?.capabilityToken,
+		codexFastModeSettings: shared.fastModeSettings,
+		codexFastModeScope: shared.fastModeScope,
 	});
 
 	const result: SingleResult = {
@@ -171,6 +188,7 @@ async function runSingleAttempt(
 		messages: [],
 		usage: emptyUsage(),
 		model: modelArg,
+		...(fastMode ? { fastMode } : {}),
 		artifactPaths: shared.artifactPaths,
 		skills: shared.resolvedSkillNames,
 		skillsWarning: shared.skillsWarning,
@@ -215,7 +233,7 @@ async function runSingleAttempt(
 	const exitCode = await new Promise<number>((resolve) => {
 		const spawnSpec = getPiSpawnCommand(args);
 		const proc = spawn(spawnSpec.command, spawnSpec.args, {
-			cwd: options.cwd ?? runtimeCwd,
+			cwd: runCwd,
 			env: spawnEnv,
 			stdio: ["ignore", "pipe", "pipe"],
 			windowsHide: true,
@@ -797,6 +815,9 @@ export async function runSync(
 		options.preferredModelProvider,
 		options.currentModel,
 	);
+	const fastModeCwd = options.cwd ?? runtimeCwd;
+	const fastModeSettings = getSubagentCodexFastModeSettings(fastModeCwd);
+	const fastModeScope = resolveSubagentCodexFastModeScope(options.workflowStageSubagentGuard);
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [];
 	const aggregateUsage = emptyUsage();
@@ -832,6 +853,8 @@ export async function runSync(
 			artifactPaths: artifactPathsResult,
 			attemptNotes,
 			outputSnapshot,
+			fastModeSettings,
+			fastModeScope,
 		});
 		lastResult = result;
 		sumUsage(aggregateUsage, result.usage);
@@ -892,6 +915,7 @@ export async function runSync(
 				exitCode: result.exitCode,
 				usage: result.usage,
 				model: result.model,
+				fastMode: result.fastMode,
 				attemptedModels: result.attemptedModels,
 				modelAttempts: result.modelAttempts,
 				durationMs: result.progressSummary?.durationMs,

package/dist/builtin/subagents/src/runs/shared/nested-render.ts

@@ -1,6 +1,6 @@
 import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.ts";
 import { formatActivityLabel } from "../../shared/status-format.ts";
-import type { ActivityState, NestedRunSummary, NestedStepSummary } from "../../shared/types.ts";
+import type { ActivityState, NestedRunSummary } from "../../shared/types.ts";
 
 export interface NestedRunCounts {
 	total: number;

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

@@ -1,10 +1,16 @@
+import type { CodexFastModeResolvedSettings, CodexFastModeScope } from "@bastani/atomic";
+
 export interface RunnerSubagentStep {
 	agent: string;
 	task: string;
 	cwd?: string;
 	model?: string;
 	thinking?: string;
+	fastMode?: boolean;
+	modelFastModes?: Record<string, boolean>;
 	modelCandidates?: string[];
+	codexFastModeSettings?: CodexFastModeResolvedSettings;
+	codexFastModeScope?: CodexFastModeScope;
 	tools?: string[];
 	extensions?: string[];
 	mcpDirectTools?: string[];
@@ -75,6 +81,7 @@ export interface ParallelTaskResult {
 	exitCode: number | null;
 	error?: string;
 	model?: string;
+	fastMode?: boolean;
 	attemptedModels?: string[];
 	outputTargetPath?: string;
 	outputTargetExists?: boolean;