@bastani/atomic 0.8.21-0 → 0.8.22-0

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;

package/dist/builtin/subagents/src/runs/shared/pi-args.ts

@@ -2,7 +2,13 @@ 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 } from "@bastani/atomic";
+import {
+	APP_NAME,
+	ENV_CODEX_FAST_MODE,
+	getEnvValue,
+	type CodexFastModeResolvedSettings,
+	type CodexFastModeScope,
+} from "@bastani/atomic";
 import { encodeNestedPathEnv, parseNestedPathEnv, type NestedPathEntry } from "./nested-path.ts";
 import { resolveMcpDirectToolNames } from "./mcp-direct-tool-allowlist.ts";
 
@@ -60,6 +66,8 @@ interface BuildPiArgsInput {
 	parentDepth?: number;
 	parentPath?: NestedPathEntry[];
 	parentCapabilityToken?: string;
+	codexFastModeSettings?: CodexFastModeResolvedSettings;
+	codexFastModeScope?: CodexFastModeScope;
 }
 
 interface BuildPiArgsResult {
@@ -75,6 +83,20 @@ export function applyThinkingSuffix(model: string | undefined, thinking: string
 	return `${model}:${thinking}`;
 }
 
+function serializeChildCodexFastModeSettings(settings: CodexFastModeResolvedSettings): string {
+	return `chat=${settings.chat ? "1" : "0"};workflow=${settings.workflow ? "1" : "0"}`;
+}
+
+function mapChildCodexFastModeSettings(
+	settings: CodexFastModeResolvedSettings,
+	scope: CodexFastModeScope,
+): CodexFastModeResolvedSettings {
+	return {
+		chat: settings[scope],
+		workflow: settings.workflow,
+	};
+}
+
 export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	const args = [...input.baseArgs];
 
@@ -155,6 +177,11 @@ export function buildPiArgs(input: BuildPiArgsInput): BuildPiArgsResult {
 	const env: Record<string, string | undefined> = {};
 	env[SUBAGENT_CHILD_ENV] = "1";
 	env[SUBAGENT_FANOUT_CHILD_ENV] = fanoutAuthorized ? "1" : "0";
+	if (input.codexFastModeSettings) {
+		env[ENV_CODEX_FAST_MODE] = serializeChildCodexFastModeSettings(
+			mapChildCodexFastModeSettings(input.codexFastModeSettings, input.codexFastModeScope ?? "chat"),
+		);
+	}
 	const parentEventSinkEnv = getEnvValue(SUBAGENT_PARENT_EVENT_SINK_ENV);
 	const parentControlInboxEnv = getEnvValue(SUBAGENT_PARENT_CONTROL_INBOX_ENV);
 	const parentRootRunIdEnv = getEnvValue(SUBAGENT_PARENT_ROOT_RUN_ID_ENV);

package/dist/builtin/subagents/src/shared/fast-mode.ts

@@ -0,0 +1,80 @@
+import {
+	SettingsManager,
+	isCodexFastModeCandidateModelId,
+	shouldApplyCodexFastModeForScope,
+	type CodexFastModeResolvedSettings,
+	type CodexFastModeScope,
+} from "@bastani/atomic";
+import { splitKnownThinkingSuffix } from "./model-info.ts";
+
+export interface ResolveSubagentModelFastModeInput {
+	model?: string;
+	cwd: string;
+	settings?: CodexFastModeResolvedSettings;
+	scope?: CodexFastModeScope;
+}
+
+export interface ResolveSubagentModelFastModeMapInput {
+	models: readonly (string | undefined)[];
+	cwd: string;
+	settings?: CodexFastModeResolvedSettings;
+	scope?: CodexFastModeScope;
+}
+
+export interface ResolveSubagentModelFastModeMetadataInput {
+	model?: string;
+	modelCandidates: readonly (string | undefined)[];
+	cwd: string;
+	settings?: CodexFastModeResolvedSettings;
+	scope?: CodexFastModeScope;
+}
+
+export interface SubagentModelFastModeMetadata {
+	fastMode?: true;
+	modelFastModes: Record<string, boolean>;
+}
+
+export function getSubagentCodexFastModeSettings(cwd: string): CodexFastModeResolvedSettings {
+	try {
+		return SettingsManager.create(cwd).getCodexFastModeSettings();
+	} catch {
+		return { chat: false, workflow: false };
+	}
+}
+
+function providerFromModelId(model: string | undefined): string | undefined {
+	if (!model) return undefined;
+	const { baseModel } = splitKnownThinkingSuffix(model);
+	if (!isCodexFastModeCandidateModelId(baseModel)) return undefined;
+	return baseModel.split("/", 1)[0];
+}
+
+export function resolveSubagentCodexFastModeScope(workflowStageSubagentGuard: boolean | undefined): CodexFastModeScope {
+	return workflowStageSubagentGuard ? "workflow" : "chat";
+}
+
+export function resolveSubagentModelFastMode(input: ResolveSubagentModelFastModeInput): boolean {
+	const provider = providerFromModelId(input.model);
+	if (!provider) return false;
+	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
+	return shouldApplyCodexFastModeForScope({ provider }, settings, input.scope ?? "chat");
+}
+
+export function resolveSubagentModelFastModeMap(input: ResolveSubagentModelFastModeMapInput): Record<string, boolean> {
+	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
+	const fastModes: Record<string, boolean> = {};
+	for (const model of input.models) {
+		if (!model || Object.prototype.hasOwnProperty.call(fastModes, model)) continue;
+		fastModes[model] = resolveSubagentModelFastMode({ model, cwd: input.cwd, settings, scope: input.scope });
+	}
+	return fastModes;
+}
+
+export function resolveSubagentModelFastModeMetadata(input: ResolveSubagentModelFastModeMetadataInput): SubagentModelFastModeMetadata {
+	const settings = input.settings ?? getSubagentCodexFastModeSettings(input.cwd);
+	const fastMode = resolveSubagentModelFastMode({ model: input.model, cwd: input.cwd, settings, scope: input.scope });
+	return {
+		...(fastMode ? { fastMode: true as const } : {}),
+		modelFastModes: resolveSubagentModelFastModeMap({ models: input.modelCandidates, cwd: input.cwd, settings, scope: input.scope }),
+	};
+}

package/dist/builtin/subagents/src/shared/formatters.ts

@@ -16,7 +16,7 @@ export function formatTokens(n: number): string {
 	return n < 1000 ? String(n) : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
 }
 
-export function formatModelThinking(model?: string, thinking?: string): string {
+export function formatModelThinking(model?: string, thinking?: string, fastMode?: boolean): string {
 	const parsed = model ? splitKnownThinkingSuffix(model) : undefined;
 	let displayModel = parsed?.baseModel ?? model;
 	const explicitThinking = THINKING_LEVELS.find((level) => level === thinking?.trim());
@@ -25,7 +25,9 @@ export function formatModelThinking(model?: string, thinking?: string): string {
 		const slashIdx = displayModel.lastIndexOf("/");
 		if (slashIdx !== -1) displayModel = displayModel.slice(slashIdx + 1);
 	}
-	return [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean).join(" · ");
+	const parts = [displayModel, displayThinking ? `thinking ${displayThinking}` : undefined].filter(Boolean);
+	if (fastMode && parts.length > 0) parts.push("fast");
+	return parts.join(" · ");
 }
 
 /**

package/dist/builtin/subagents/src/shared/types.ts

@@ -211,6 +211,7 @@ export interface SingleResult {
 	messages?: Message[];
 	usage: Usage;
 	model?: string;
+	fastMode?: boolean;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
 	controlEvents?: ControlEvent[];
@@ -416,6 +417,7 @@ export interface AsyncStatus {
 		skills?: string[];
 		model?: string;
 		thinking?: string;
+		fastMode?: boolean;
 		attemptedModels?: string[];
 		modelAttempts?: ModelAttempt[];
 		error?: string;
@@ -522,8 +524,8 @@ export interface SubagentState {
 // Display
 // ============================================================================
 
-export type DisplayItem = 
-	| { type: "text"; text: string } 
+export type DisplayItem =
+	| { type: "text"; text: string }
 	| { type: "tool"; name: string; args: Record<string, unknown> };
 
 // ============================================================================