@bastani/atomic 0.8.21 → 0.8.22-0

package/dist/builtin/subagents/skills/browser-use/references/cdp-python.md

@@ -0,0 +1,76 @@
+# Raw CDP & Python Session Reference
+
+The CLI commands handle most browser interactions. Use `browser-use python` with raw CDP when you need browser-level control the CLI doesn't expose — activating a tab so the user sees it, intercepting network requests, emulating devices, or working with Chrome target IDs directly.
+
+## How the Python session works
+
+`browser-use python "statement"` executes one Python statement per call. Variables persist across calls — set a value in one call, use it in the next.
+
+A `browser` object is pre-injected with sync wrappers for common operations (`browser.goto()`, `browser.click()`, etc.). For anything beyond those, two internals give you full access:
+
+- `browser._run(coroutine)` — run any async coroutine synchronously (60s timeout)
+- `browser._session` — the raw `BrowserSession` with full CDP client access
+
+## Getting a CDP client
+
+```bash
+browser-use python "cdp = browser._run(browser._session.get_or_create_cdp_session())"
+```
+
+After this, `cdp` persists across calls. Use `cdp.cdp_client.send.<Domain>.<method>()` for any CDP command and `cdp.session_id` for the session parameter.
+
+## Recipes
+
+### Activate a tab (make it visible to the user)
+
+The CLI's `tab switch` only changes the agent's internal focus — Chrome's visible tab doesn't change. To actually show the user a specific tab:
+
+```bash
+# Get all targets to find the target ID
+browser-use python "targets = browser._session.session_manager.get_all_page_targets()"
+browser-use python "print([(i, t.url) for i, t in enumerate(targets)])"
+
+# Activate target at index 1 so the user sees it
+browser-use python "cdp = browser._run(browser._session.get_or_create_cdp_session(target_id=None, focus=False))"
+browser-use python "browser._run(cdp.cdp_client.send.Target.activateTarget(params={'targetId': targets[1].target_id}))"
+```
+
+### List all tabs with target IDs
+
+```bash
+browser-use python "targets = browser._session.session_manager.get_all_page_targets()"
+browser-use python "
+for i, t in enumerate(targets):
+    print(f'{i}: {t.target_id[:12]}... {t.url}')
+"
+```
+
+### Run JavaScript and get the result
+
+```bash
+browser-use python "cdp = browser._run(browser._session.get_or_create_cdp_session())"
+browser-use python "result = browser._run(cdp.cdp_client.send.Runtime.evaluate(params={'expression': 'document.title', 'returnByValue': True}, session_id=cdp.session_id))"
+browser-use python "print(result['result']['value'])"
+```
+
+### Emulate a mobile device
+
+```bash
+browser-use python "cdp = browser._run(browser._session.get_or_create_cdp_session())"
+browser-use python "browser._run(cdp.cdp_client.send.Emulation.setDeviceMetricsOverride(params={'width': 375, 'height': 812, 'deviceScaleFactor': 3, 'mobile': True}, session_id=cdp.session_id))"
+```
+
+### Get cookies via CDP
+
+```bash
+browser-use python "cdp = browser._run(browser._session.get_or_create_cdp_session())"
+browser-use python "cookies = browser._run(cdp.cdp_client.send.Network.getCookies(params={}, session_id=cdp.session_id))"
+browser-use python "print(cookies)"
+```
+
+## Tips
+
+- Each `browser-use python` call is one statement. Multi-line strings work for `for` loops and `if` blocks, but you can't mix statements and expressions. Use multiple calls.
+- Variables persist: set `cdp = ...` in one call, use `cdp` in the next.
+- The `browser._run()` bridge has a 60-second timeout. For long operations, increase it or use the async internals directly.
+- All CDP domains are available via `cdp.cdp_client.send.<Domain>.<method>()`. See the [Chrome DevTools Protocol docs](https://chromedevtools.github.io/devtools-protocol/) for the full API.

package/dist/builtin/subagents/skills/browser-use/references/multi-session.md

@@ -0,0 +1,92 @@
+# Multiple Browser Sessions
+
+## Why use multiple sessions
+
+When you need more than one browser at a time:
+- Cloud browser for scraping + local Chrome for authenticated tasks
+- Two different Chrome profiles simultaneously
+- Isolated browser for testing that won't affect the user's browsing
+- Running a headed browser for debugging while headless runs in background
+
+## How sessions are isolated
+
+Each `--session NAME` gets:
+- Its own daemon process
+- Its own Unix socket (`~/.browser-use/{name}.sock`)
+- Its own PID file and state file
+- Its own browser instance (completely independent)
+- Its own tab ownership state (multi-agent locks don't cross sessions)
+
+## The `--session` flag
+
+Must be passed on every command targeting that session:
+
+```bash
+browser-use --session work open <url>      # goes to 'work' daemon
+browser-use --session work state           # reads from 'work' daemon
+browser-use state                          # goes to 'default' daemon (different browser)
+```
+
+If you forget `--session`, the command goes to the `default` session. This is the most common mistake — you'll interact with the wrong browser.
+
+## Combining sessions with browser modes
+
+```bash
+# Session 1: cloud browser
+browser-use --session cloud cloud connect
+
+# Session 2: connect to user's Chrome
+browser-use --session chrome connect
+
+# Session 3: headed Chromium for debugging
+browser-use --session debug --headed open <url>
+```
+
+Each session is fully independent. The cloud session talks to a remote browser, the chrome session talks to the user's Chrome, and the debug session manages its own Chromium — all running simultaneously.
+
+## Listing and managing sessions
+
+```bash
+browser-use sessions
+```
+
+Output:
+```
+SESSION          PHASE          PID      CONFIG
+cloud            running        12345    cloud
+chrome           running        12346    cdp
+debug            ready          12347    headed
+```
+
+PHASE shows the daemon lifecycle state: `initializing`, `ready`, `starting`, `running`, `shutting_down`, `stopped`, `failed`.
+
+```bash
+browser-use --session cloud close           # close one session
+browser-use close --all                     # close every session
+```
+
+## Common patterns
+
+**Cloud + local authenticated:**
+```bash
+browser-use --session scraper cloud connect
+browser-use --session scraper open https://example.com
+# ... scrape data ...
+
+browser-use --session auth --profile "Default" open https://github.com
+browser-use --session auth state
+# ... interact with authenticated site ...
+```
+
+**Throwaway test browser:**
+```bash
+browser-use --session test --headed open https://localhost:3000
+# ... test, debug, inspect ...
+browser-use --session test close    # done, clean up
+```
+
+**Environment variable:**
+```bash
+export BROWSER_USE_SESSION=work
+browser-use open <url>              # uses 'work' session without --session flag
+```

package/dist/builtin/subagents/skills/subagent/SKILL.md

@@ -20,7 +20,7 @@ Use this skill when the parent orchestrator needs to launch a specialized subage
 - **Parallel codebase discovery**: combine `codebase-locator`, `codebase-analyzer`, and `codebase-pattern-finder` to map where code lives, how it works, and what existing conventions look like — concurrently, with fresh context per child.
 - **Local research mining**: pair `codebase-research-locator` with `codebase-research-analyzer` to surface prior decisions in `research/` and `specs/` and extract what still applies.
 - **External research**: use `codebase-online-researcher` for authoritative web sources, with persisted findings in `research/web/`.
-- **Debug and fix**: use `debugger` to reproduce, diagnose, and patch failing behavior with `tdd` and `playwright-cli` support.
+- **Debug and fix**: use `debugger` to reproduce, diagnose, and patch failing behavior with `tdd` and `browser-use` support.
 - **Refinement**: use `code-simplifier` to clean up recently changed code without altering behavior.
 - **Adversarial review**: compose read-only specialists (`codebase-analyzer`, `codebase-pattern-finder`, `debugger` in inspect-only mode, `codebase-online-researcher`) into a parallel review pass — there is no generic `reviewer` agent.
 - **Long-running work**: launch async/background runs and inspect them later.
@@ -125,9 +125,9 @@ Builtin agents load at the lowest priority. Project agents override user agents,
 | `codebase-pattern-finder`    | Find similar implementations or conventions                       | `openai/gpt-5.4-mini` | low      | read, grep, find, ls, bash                                                             | Read-only. Returns code snippets with `file:line` references.                                              |
 | `codebase-research-locator`  | Discover prior `research/` and `specs/` docs                      | `openai/gpt-5.4-mini` | low      | read, grep, find, ls, bash                                                             | Read-only. Sorts by date, tiers by recency, flags supersession.                                            |
 | `codebase-research-analyzer` | Extract decisions and constraints from prior docs                 | `openai/gpt-5.5`      | low      | read, grep, find, ls, bash                                                             | Read-only. Filters aggressively for what still applies today.                                              |
-| `codebase-online-researcher` | Web research with authoritative sources                           | `openai/gpt-5.5`      | low      | read, grep, find, ls, bash, write, web_search, fetch_content, get_search_content       | Has the `playwright-cli` skill. Persists keepers to `research/web/`.                                       |
+| `codebase-online-researcher` | Web research with authoritative sources                           | `openai/gpt-5.5`      | low      | read, grep, find, ls, bash, write, web_search, fetch_content, get_search_content       | Has the `browser-use` skill. Persists keepers to `research/web/`.                                       |
 | `code-simplifier`            | Clean up recently changed code without changing behavior          | `openai/gpt-5.5`      | low      | read, edit, write, grep, find, ls, bash                                                | **Writer.** Scopes to recently modified code by default; preserves all observable behavior.                |
-| `debugger`                   | Reproduce, diagnose, and fix failing behavior                     | `openai/gpt-5.5`      | high     | read, edit, write, grep, find, ls, bash, web_search, fetch_content, get_search_content | **Writer.** Has the `tdd` and `playwright-cli` skills. Inspect-only mode requires an explicit instruction. |
+| `debugger`                   | Reproduce, diagnose, and fix failing behavior                     | `openai/gpt-5.5`      | high     | read, edit, write, grep, find, ls, bash, web_search, fetch_content, get_search_content | **Writer.** Has the `tdd` and `browser-use` skills. Inspect-only mode requires an explicit instruction. |
 
 Each builtin declares an explicit `model` and `fallbackModels` chain (typically `github-copilot/<same>`, then `anthropic/claude-opus-4-8`, then `github-copilot/claude-opus-4.7`). The current user-selected model is automatically appended as the last fallback and de-duplicated. Override per run with inline config:
 
@@ -153,7 +153,7 @@ A strong subagent prompt usually includes:
 - **Output**: the expected summary shape, artifact path, or finding format.
 - **Stop rules**: when to stop after enough evidence, and when not to keep searching.
 
-Avoid carrying over old prompt habits that over-specify every step. Use `must`, `always`, and `never` for real invariants; for judgment calls, give decision rules. For example, tell `codebase-analyzer` to trace the staged diff directly and report only evidence-backed findings, rather than prescribing every file or command. Tell `codebase-online-researcher` the retrieval budget: start with broad targeted searches, fetch the strongest sources via `fetch_content`, fall back to `playwright-cli` only when JS execution is required, and stop when the question is answered.
+Avoid carrying over old prompt habits that over-specify every step. Use `must`, `always`, and `never` for real invariants; for judgment calls, give decision rules. For example, tell `codebase-analyzer` to trace the staged diff directly and report only evidence-backed findings, rather than prescribing every file or command. Tell `codebase-online-researcher` the retrieval budget: start with broad targeted searches, fetch the strongest sources via `fetch_content`, fall back to `browser-use` only when JS execution is required, and stop when the question is answered.
 
 For implementation handoffs to `debugger` or `code-simplifier`, name the approved scope and success criteria more clearly than the process. Good prompts say what to change, what not to change, where the evidence lives, how to validate, and when to escalate. They should not ask the child to create another subagent plan or continue the parent conversation.
 

package/dist/builtin/subagents/src/agents/skills.ts

@@ -119,11 +119,20 @@ function extractSkillPathsFromPackageRoot(packageRoot: string, source: SkillSour
 }
 
 let cachedGlobalNpmRoot: string | null = null;
+let execSyncGlobalNpmRoot = execSync;
+const GLOBAL_NPM_ROOT_TIMEOUT_MS = 2500;
 
 function getGlobalNpmRoot(): string | null {
 	if (cachedGlobalNpmRoot !== null) return cachedGlobalNpmRoot;
 	try {
-		cachedGlobalNpmRoot = execSync("npm root -g", { encoding: "utf-8", timeout: 5000 }).trim();
+		// Keep global package probing bounded during startup while still allowing
+		// slower Windows/corporate npm wrappers enough time to launch.
+		cachedGlobalNpmRoot = execSyncGlobalNpmRoot("npm root -g", {
+			encoding: "utf-8",
+			stdio: ["ignore", "pipe", "ignore"],
+			timeout: GLOBAL_NPM_ROOT_TIMEOUT_MS,
+			windowsHide: true,
+		}).trim();
 		return cachedGlobalNpmRoot;
 	} catch {
 		// Global npm root is optional in constrained environments.
@@ -639,4 +648,13 @@ export function discoverAvailableSkills(cwd: string): Array<{
 export function clearSkillCache(): void {
 	skillCache.clear();
 	loadSkillsCache = null;
+	cachedGlobalNpmRoot = null;
+}
+
+/**
+ * @internal Test seam for unit tests that need to mock `npm root -g`.
+ */
+export function __setGlobalNpmRootExecSyncForTest(execSyncImpl?: typeof execSync): void {
+	execSyncGlobalNpmRoot = execSyncImpl ?? execSync;
+	cachedGlobalNpmRoot = null;
 }

package/dist/builtin/subagents/src/extension/index.ts

@@ -23,7 +23,7 @@ import { discoverAgents } from "../agents/agents.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
 import { resolveCurrentSessionId } from "../shared/session-identity.ts";
 import { cleanupOldChainDirs } from "../shared/settings.ts";
-import { renderWidget, renderSubagentResult, stopResultAnimations, stopWidgetAnimation, syncResultAnimation } from "../tui/render.ts";
+import { renderLiveSubagentResult, renderSubagentResult, stopResultAnimations, stopWidgetAnimation, type SubagentResultRenderState } from "../tui/render.ts";
 import { SubagentParams } from "./schemas.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import { createAsyncJobTracker } from "../runs/background/async-job-tracker.ts";
@@ -117,10 +117,12 @@ function isStaleExtensionContextError(error: unknown): boolean {
 	return error instanceof Error && error.message.includes("Extension context no longer active");
 }
 
+type SubagentToolRenderState = SubagentResultRenderState;
+
 function rebuildSlashResultContainer(
 	container: Container,
 	result: AgentToolResult<Details>,
-	options: { expanded: boolean },
+	options: { expanded: boolean; now?: number },
 	theme: ExtensionContext["ui"]["theme"],
 ): void {
 	container.clear();
@@ -135,20 +137,17 @@ function createSlashResultComponent(
 	details: SlashMessageDetails,
 	options: { expanded: boolean },
 	theme: ExtensionContext["ui"]["theme"],
-	requestRender: () => void,
 ): Container {
 	const container = new Container();
-	const animationState: { subagentResultAnimationTimer?: ReturnType<typeof setInterval> } = {};
 	let lastVersion = -1;
+	let lastSnapshotNow = 0;
 	container.render = (width: number): string[] => {
 		const snapshot = getSlashRenderableSnapshot(details);
-		if (snapshot.version !== lastVersion || isSlashResultRunning(snapshot.result)) {
+		if (snapshot.version !== lastVersion) {
 			lastVersion = snapshot.version;
-			rebuildSlashResultContainer(container, snapshot.result, options, theme);
+			lastSnapshotNow = Date.now();
+			rebuildSlashResultContainer(container, snapshot.result, { ...options, now: lastSnapshotNow }, theme);
 		}
-		// Keep the live slash card's spinner animating by scheduling steady
-		// re-renders while it runs (and tearing the timer down once it settles).
-		syncResultAnimation(snapshot.result, { state: animationState, invalidate: requestRender });
 		return Container.prototype.render.call(container, width);
 	};
 	return container;
@@ -281,7 +280,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	};
 	globalStore[runtimeCleanupStoreKey] = runtimeCleanup;
 
-	const { ensurePoller, handleStarted, handleComplete, resetJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR);
+	const { ensurePoller, handleStarted, handleComplete, resetJobs, hydrateActiveJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR);
 	const executor = createSubagentExecutor({
 		pi,
 		state,
@@ -296,7 +295,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	pi.registerMessageRenderer<SlashMessageDetails>(SLASH_RESULT_TYPE, (message, options, theme) => {
 		const details = resolveSlashMessageDetails(message.details);
 		if (!details) return undefined;
-		return createSlashResultComponent(details, options, theme, () => state.lastUiContext?.ui.requestRender?.());
+		return createSlashResultComponent(details, options, theme);
 	});
 
 	pi.registerMessageRenderer<SubagentNotifyDetails>("subagent-notify", (message, options, theme) => {
@@ -337,7 +336,10 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	});
 
 	const executeSubagentCollapsed = (id: string, params: SubagentParamsLike, signal: AbortSignal, onUpdate: ((result: AgentToolResult<Details>) => void) | undefined, ctx: ExtensionContext) => {
-		if (ctx.hasUI) ctx.ui.setToolsExpanded(false);
+		if (ctx.hasUI) {
+			state.lastUiContext = ctx;
+			ctx.ui.setToolsExpanded(false);
+		}
 		return executor.execute(id, params, signal, onUpdate, ctx);
 	};
 
@@ -394,7 +396,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		}, 0);
 	}
 
-	const tool: ToolDefinition<typeof SubagentParams, Details> = {
+	const tool: ToolDefinition<typeof SubagentParams, Details, SubagentToolRenderState> = {
 		name: "subagent",
 		label: "Subagent",
 		description: `Delegate to subagents or manage agent definitions.
@@ -465,10 +467,12 @@ DIAGNOSTICS:
 		},
 
 		renderResult(result, options, theme, context) {
-			// Animate the live subagent spinner by scheduling steady re-renders
-			// while the result is running; the timer stops once it settles.
-			syncResultAnimation(result, context);
-			return renderSubagentResult(result, options, theme);
+			// Tool-result rows live in chat scrollback. The host keeps context.state
+			// on the ToolExecutionComponent for this row, so foreground updates/ticks
+			// capture an explicit frame timestamp and arbitrary host re-renders reuse
+			// it. Running foreground rows intentionally advance via their own timer;
+			// completed scrollback remains a stable point-in-time snapshot.
+			return renderLiveSubagentResult(result, options, theme, context);
 		},
 
 	};
@@ -513,11 +517,8 @@ DIAGNOSTICS:
 		if (event.toolName !== "subagent") return;
 		if (!ctx.hasUI) return;
 		state.lastUiContext = ctx;
-		if (state.asyncJobs.size > 0) {
-			renderWidget(ctx, Array.from(state.asyncJobs.values()));
-			ctx.ui.requestRender?.();
-			ensurePoller();
-		}
+		hydrateActiveJobs(ctx);
+		if (state.asyncJobs.size > 0) ensurePoller();
 	});
 
 	const cleanupSessionArtifacts = (ctx: ExtensionContext) => {
@@ -538,6 +539,7 @@ DIAGNOSTICS:
 		cleanupSessionArtifacts(ctx);
 		clearPendingForegroundControlNotices(state);
 		resetJobs(ctx);
+		hydrateActiveJobs(ctx);
 		restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
 		primeExistingResults();
 	};

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

@@ -197,7 +197,12 @@ function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agent
 		...(projectConfigDir ? [{ file: path.join(projectConfigDir, "settings.json"), configDir: projectConfigDir, scope: "project" as const }] : []),
 		{ file: path.join(agentDir, "settings.json"), configDir: agentDir, scope: "user" as const },
 	];
-	const globalNpmRoot = input.globalNpmRoot === undefined ? getGlobalNpmRoot() : input.globalNpmRoot;
+	let resolvedGlobalNpmRoot = input.globalNpmRoot;
+	const resolveGlobalNpmRoot = (): string | null => {
+		if (resolvedGlobalNpmRoot !== undefined) return resolvedGlobalNpmRoot;
+		resolvedGlobalNpmRoot = getGlobalNpmRoot();
+		return resolvedGlobalNpmRoot;
+	};
 
 	for (const { file, configDir, scope } of settingsFiles) {
 		const settings = readJsonBestEffort(file);
@@ -211,6 +216,7 @@ function configuredPiIntercomPackageDir(input: ResolveIntercomBridgeInput, agent
 			if (!source?.startsWith("npm:")) continue;
 			const packageName = parseNpmPackageName(source);
 			if (packageName !== PI_INTERCOM_PACKAGE_NAME) continue;
+			const globalNpmRoot = scope === "user" ? resolveGlobalNpmRoot() : null;
 			const candidates = scope === "project"
 				? [path.join(configDir, "npm", "node_modules", packageName)]
 				: [

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}`);