@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.11

package/src/prompts/tools/task.md

@@ -31,10 +31,9 @@ Subagents have no conversation history. Every fact, file path, and direction the
 
 <rules>
 - **Maximize batch width.** Spawn the widest parallel set the work decomposes into. NEVER spawn a single-task batch for divisible work, or defer work that could have been concurrent.
-- NEVER assign tasks to run project-wide build/test/lint. Caller verifies after the batch.
-- **Subagents do not verify, lint, or format.** Every assignment MUST instruct the subagent to skip all gates and formatters. You run them once at the end across the union of changed files — avoids redundant runs and racing formatter passes.
+- **Subagents do not verify, lint, or format.** Every assignment MUST instruct the subagent to skip all gates, formatters, and project-wide build/test/lint. You run them once at the end across the union of changed files — avoids redundant runs and racing formatter passes.
 - No globs, no "update all", no package-wide scope. Fan out.
-- Do not concern yourself with how agents might overlap on certain actions. Never use it as an excuse to go slower: they can resolve collisions in real-time with the harness facilities.
+- NEVER slow down or serialize because tasks might overlap on some files. Agents resolve collisions among themselves in real time.
 - Pass large payloads via `local://<path>` URIs, not inline. {{#if contextEnabled}} (other than the context){{/if}}
 {{#if contextEnabled}}- Put shared constraints in `context` once; do not duplicate across assignments.{{/if}}
 - Prefer agents that investigate **and** edit in one pass; only spin a read-only discovery step when affected files are genuinely unknown.

package/src/prompts/tools/todo.md

@@ -12,7 +12,7 @@ Allowed `op` values are only `init`, `start`, `done`, `drop`, `rm`, `append`, `n
 |`start`|`task`|Mark in progress|
 |`done`|`task` or `phase`|Mark completed|
 |`drop`|`task` or `phase`|Mark abandoned|
-|`rm`|`task` or `phase`|Remove|
+|`rm`|`task` or `phase` (optional)|Remove task or phase's tasks; omit both to clear the entire list|
 |`append`|`phase`, `items: string[]`|Append tasks to `phase`; lazily creates phase|
 |`note`|`task`, `text`|Append a note to a task. Reminders for future-you only.|
 |`view`|—|Read-only: echo the current list without modifying it|

package/src/sdk.ts

@@ -19,6 +19,7 @@ import {
 	getOpenAICodexTransportDetails,
 	prewarmOpenAICodexResponses,
 } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
+import { DEFAULT_MODEL_PER_PROVIDER } from "@oh-my-pi/pi-catalog/provider-models";
 import type { Component } from "@oh-my-pi/pi-tui";
 import {
 	$env,
@@ -41,7 +42,6 @@ import { createApiKeyResolver } from "./config/api-key-resolver";
 import { shouldEnableAppendOnlyContext } from "./config/append-only-context-mode";
 import { ModelRegistry } from "./config/model-registry";
 import {
-	defaultModelPerProvider,
 	formatModelString,
 	getModelMatchPreferences,
 	parseModelPattern,
@@ -531,11 +531,18 @@ function resolveSnapshotTtlMs(): number {
  * override to re-mint access tokens when needed.
  */
 export async function discoverAuthStorage(agentDir: string = getDefaultAgentDir()): Promise<AuthStorage> {
-	const brokerConfig = await resolveAuthBrokerConfig();
+	const brokerConfigPromise = resolveAuthBrokerConfig();
+	const cachePath = getAuthBrokerSnapshotCachePath();
+	// Warm the encrypted snapshot cache into the page cache while the broker
+	// config resolves (it may shell out for a `!command` token). Decryption
+	// needs the resolved token, so the real cache read cannot start earlier.
+	void Bun.file(cachePath)
+		.arrayBuffer()
+		.catch(() => undefined);
+	const brokerConfig = await brokerConfigPromise;
 	if (brokerConfig) {
 		const client = new AuthBrokerClient({ url: brokerConfig.url, token: brokerConfig.token });
 		const ttlMs = resolveSnapshotTtlMs();
-		const cachePath = getAuthBrokerSnapshotCachePath();
 		const persist =
 			ttlMs > 0
 				? (snapshot: SnapshotResponse): void => {
@@ -1730,7 +1737,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// the winning provider (e.g. anthropic's claude-3-5-sonnet-20240620)
 			// instead of the intended provider default (claude-sonnet-4-6). Mirrors
 			// findInitialModel's precedence.
-			for (const [provider, defaultId] of Object.entries(defaultModelPerProvider)) {
+			for (const [provider, defaultId] of Object.entries(DEFAULT_MODEL_PER_PROVIDER)) {
 				const preferred = fallbackCandidates.find(
 					candidate => candidate.provider === provider && candidate.id === defaultId,
 				);
@@ -2342,7 +2349,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 
 		if (model?.api === "openai-codex-responses") {
-			const codexModel = model;
+			// `.api` equality doesn't narrow the generic; the guard makes this cast sound.
+			const codexModel = model as Model<"openai-codex-responses">;
 			const codexTransport = getOpenAICodexTransportDetails(codexModel, {
 				sessionId: providerSessionId,
 				baseUrl: codexModel.baseUrl,
@@ -2373,12 +2381,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 
 		// Start LSP warmup in the background so startup does not block on language server initialization.
-		// Print/script invocations (`hasUI=false`) don't render the warmup status indicator AND typically
-		// finish before LSP servers would have stabilized — warming them just spends CPU parsing big
-		// `initialize` responses concurrently with the LLM stream consumer, jittering perceived latency.
-		// Tools that need an LSP server still spin one up on demand through `getOrCreateClient`.
+		// With `lsp.lazy` (the default) the warmup is skipped: recognized servers are still discovered and
+		// surfaced in the UI as "available", but cold-start on first use — the lsp tool or an edit/write
+		// touching a matching file type — through `getOrCreateClient`.
+		// Print/script invocations (`hasUI=false`) skip it regardless: they don't render the warmup status
+		// indicator AND typically finish before LSP servers would have stabilized — warming them just spends
+		// CPU parsing big `initialize` responses concurrently with the LLM stream consumer, jittering
+		// perceived latency.
 		let lspServers: CreateAgentSessionResult["lspServers"];
-		if (enableLsp && options.hasUI && settings.get("lsp.diagnosticsOnWrite")) {
+		if (enableLsp && options.hasUI && settings.get("lsp.lazy")) {
+			lspServers = discoverStartupLspServers(cwd, "available");
+		} else if (enableLsp && options.hasUI) {
 			lspServers = discoverStartupLspServers(cwd);
 			if (lspServers.length > 0) {
 				void (async () => {

package/src/session/agent-session.ts

@@ -79,14 +79,14 @@ import {
 	clearAnthropicFastModeFallback,
 	deriveClaudeDeviceId,
 	Effort,
-	getSupportedEfforts,
 	isContextOverflow,
 	isUsageLimitError,
-	modelsAreEqual,
 	parseRateLimitReason,
 	resolveServiceTier,
 	streamSimple,
 } from "@oh-my-pi/pi-ai";
+import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
+import { modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { countTokens, MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
 import {
 	extractRetryHint,
@@ -105,7 +105,7 @@ import { classifyDifficulty } from "../auto-thinking/classifier";
 import { reset as resetCapabilities } from "../capability";
 import type { Rule } from "../capability/rule";
 import { shouldEnableAppendOnlyContext } from "../config/append-only-context-mode";
-import { MODEL_ROLE_IDS, type ModelRegistry } from "../config/model-registry";
+import type { ModelRegistry } from "../config/model-registry";
 import {
 	extractExplicitThinkingSelector,
 	formatModelSelectorValue,
@@ -115,6 +115,7 @@ import {
 	type ResolvedModelRoleValue,
 	resolveModelRoleValue,
 } from "../config/model-resolver";
+import { MODEL_ROLE_IDS } from "../config/model-roles";
 import { expandPromptTemplate, type PromptTemplate } from "../config/prompt-templates";
 import type { Settings, SkillsSettings } from "../config/settings";
 import { onAppendOnlyModeChanged } from "../config/settings";
@@ -287,6 +288,20 @@ export type AgentSessionEventListener = (event: AgentSessionEvent) => void;
 export type AsyncJobSnapshotItem = Pick<AsyncJob, "id" | "type" | "status" | "label" | "startTime">;
 
 const EMPTY_STOP_MAX_RETRIES = 3;
+const RETRY_BACKOFF_MAX_DELAY_MS = 8_000;
+const RETRY_BACKOFF_JITTER_RATIO = 0.25;
+
+function calculateRetryBackoffDelayMs(baseDelayMs: number, attempt: number): number {
+	const cappedDelayMs = Math.min(Math.max(0, baseDelayMs) * 2 ** Math.max(0, attempt - 1), RETRY_BACKOFF_MAX_DELAY_MS);
+	const jitter = 1 - Math.random() * RETRY_BACKOFF_JITTER_RATIO;
+	return cappedDelayMs * jitter;
+}
+
+/**
+ * Slack added past a sibling credential's block expiry before retrying, so
+ * the next getApiKey lands after the block has actually lapsed.
+ */
+const SIBLING_UNBLOCK_BUFFER_MS = 1_000;
 const NON_WHITESPACE_RE = /\S/;
 
 function hasNonWhitespace(value: string): boolean {
@@ -8307,13 +8322,16 @@ export class AgentSession {
 
 		const errorMessage = message.errorMessage || "Unknown error";
 		const parsedRetryAfterMs = this.#parseRetryAfterMsFromError(errorMessage);
-		let delayMs = retrySettings.baseDelayMs * 2 ** (this.#retryAttempt - 1);
+		let delayMs = calculateRetryBackoffDelayMs(retrySettings.baseDelayMs, this.#retryAttempt);
 		let switchedCredential = false;
 		let switchedModel = false;
+		// Set when a usage-limit error pinned the wait to credential
+		// availability — suppresses the generic retry-after bump below.
+		let usageLimitWaitMs: number | undefined;
 
 		if (this.model && isUsageLimitError(errorMessage)) {
 			const retryAfterMs = parsedRetryAfterMs ?? calculateRateLimitBackoffMs(parseRateLimitReason(errorMessage));
-			const switched = await this.#modelRegistry.authStorage.markUsageLimitReached(
+			const outcome = await this.#modelRegistry.authStorage.markUsageLimitReached(
 				this.model.provider,
 				this.sessionId,
 				{
@@ -8321,12 +8339,28 @@ export class AgentSession {
 					baseUrl: this.model.baseUrl,
 				},
 			);
-			if (switched) {
+			if (outcome.switched) {
 				switchedCredential = true;
 				delayMs = 0;
-			} else if (retryAfterMs > delayMs) {
-				// No more accounts to switch to — wait out the backoff
-				delayMs = retryAfterMs;
+			} else {
+				// No sibling credential is usable right now. Wait for whichever
+				// comes first: the provider's retry-after window for the current
+				// account, or the earliest moment a temporarily blocked sibling
+				// frees up (e.g. a 60s post-401 block or a 5-min usage-probe
+				// block) — the next attempt's getApiKey re-ranks and picks it up.
+				// Without this, one short-lived sibling block escalates a
+				// recoverable situation into the provider's multi-hour wait and
+				// trips the fail-fast cap below.
+				usageLimitWaitMs = retryAfterMs;
+				if (outcome.retryAtMs !== undefined) {
+					const siblingWaitMs = Math.max(0, outcome.retryAtMs - Date.now()) + SIBLING_UNBLOCK_BUFFER_MS;
+					if (siblingWaitMs < usageLimitWaitMs) {
+						usageLimitWaitMs = siblingWaitMs;
+					}
+				}
+				if (usageLimitWaitMs > delayMs) {
+					delayMs = usageLimitWaitMs;
+				}
 			}
 		}
 
@@ -8338,7 +8372,7 @@ export class AgentSession {
 			}
 			if (switchedModel) {
 				delayMs = 0;
-			} else if (parsedRetryAfterMs && parsedRetryAfterMs > delayMs) {
+			} else if (usageLimitWaitMs === undefined && parsedRetryAfterMs && parsedRetryAfterMs > delayMs) {
 				delayMs = parsedRetryAfterMs;
 			}
 		}

package/src/session/auth-broker-config.ts

@@ -65,13 +65,42 @@ async function readConfigYaml(): Promise<ConfigSnapshot> {
 	}
 }
 
+/**
+ * Process-lifetime memo for {@link resolveAuthBrokerConfig}. Keyed on the env
+ * inputs (plus agent dir, which decides which config.yml is read) so tests
+ * that flip `OMP_AUTH_BROKER_*` between cases still observe the change, while
+ * repeated resolution within one CLI invocation (startup, subagent sessions)
+ * skips the config.yml read and any `!command` token resolution.
+ */
+let cachedConfigKey: string | null = null;
+let cachedConfigPromise: Promise<AuthBrokerClientConfig | null> | null = null;
+
 /**
  * Read broker configuration. Returns null when the URL is missing
  * (broker disabled — local store is used). Throws when URL is set but no
  * token is available — the caller cannot fall back silently because the
  * user explicitly asked to use the broker.
+ *
+ * Successful resolutions (including "no broker configured") are memoized for
+ * the process lifetime; failures are not, so a missing token can be fixed and
+ * retried. Concurrent callers share one in-flight resolution.
  */
-export async function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null> {
+export function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null> {
+	const key = `${process.env.OMP_AUTH_BROKER_URL ?? ""}\u0000${process.env.OMP_AUTH_BROKER_TOKEN ?? ""}\u0000${getAgentDir()}`;
+	if (cachedConfigPromise && cachedConfigKey === key) return cachedConfigPromise;
+	const promise = resolveAuthBrokerConfigUncached();
+	cachedConfigKey = key;
+	cachedConfigPromise = promise;
+	promise.catch(() => {
+		if (cachedConfigPromise === promise) {
+			cachedConfigPromise = null;
+			cachedConfigKey = null;
+		}
+	});
+	return promise;
+}
+
+async function resolveAuthBrokerConfigUncached(): Promise<AuthBrokerClientConfig | null> {
 	const envUrl = process.env.OMP_AUTH_BROKER_URL;
 	const envToken = process.env.OMP_AUTH_BROKER_TOKEN;
 

package/src/session/session-manager.ts

@@ -1516,10 +1516,10 @@ class NdjsonFileWriter {
 	}
 }
 
-/** Get recent sessions for display in welcome screen */
+/** Get recent sessions for display in welcome screen (which reserves WELCOME_SESSION_SLOTS rows) */
 export async function getRecentSessions(
 	sessionDir: string,
-	limit = 3,
+	limit = 4,
 	storage: SessionStorage = new FileSessionStorage(),
 ): Promise<RecentSessionInfo[]> {
 	const sessions = await getSortedSessions(sessionDir, storage);

package/src/session/streaming-output.ts

@@ -650,6 +650,7 @@ export class OutputSink {
 	#sawData = false;
 	#truncated = false;
 	#lastChunkTime = 0;
+	#pendingChunk = "";
 
 	// Per-line column cap streaming state (persists across `push` calls so a
 	// long line split across chunks still trips the same trigger).
@@ -701,14 +702,20 @@ export class OutputSink {
 	push(chunk: string): void {
 		chunk = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
 
-		// Throttled onChunk: only call the callback when enough time has passed.
+		// Throttled onChunk: coalesce chunks arriving inside the throttle window
+		// and flush the buffered concatenation on the next eligible tick (plus a
+		// final flush in dump()) so the preview never has silent gaps.
 		// Live preview gets the raw (pre-cap) chunk so the TUI never lags behind
 		// what reached the sink — the column cap is for the persisted LLM view.
 		if (this.#onChunk) {
 			const now = Date.now();
 			if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
 				this.#lastChunkTime = now;
-				this.#onChunk(chunk);
+				const merged = this.#pendingChunk + chunk;
+				this.#pendingChunk = "";
+				this.#onChunk(merged);
+			} else {
+				this.#pendingChunk += chunk;
 			}
 		}
 
@@ -880,6 +887,11 @@ export class OutputSink {
 			const sink = Bun.file(this.#artifactPath).writer();
 			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
 
+			// Head-retained bytes precede the rolling tail buffer in the capture.
+			if (this.#head.length > 0) {
+				sink.write(this.#head);
+			}
+
 			// Flush existing buffer to file BEFORE it gets trimmed further.
 			if (this.#buffer.length > 0) {
 				sink.write(this.#buffer);
@@ -946,10 +958,19 @@ export class OutputSink {
 		this.#columnEllipsisAdded = false;
 		this.#columnDroppedBytes = 0;
 		this.#columnTruncatedLines = 0;
+		this.#pendingChunk = "";
 	}
 
 	async dump(notice?: string): Promise<OutputSummary> {
 		const noticeLine = notice ? `[${notice}]\n` : "";
+
+		// Flush any chunk still held back by the throttle so the live preview
+		// ends with the complete stream.
+		if (this.#onChunk && this.#pendingChunk.length > 0) {
+			const pending = this.#pendingChunk;
+			this.#pendingChunk = "";
+			this.#onChunk(pending);
+		}
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
 
 		if (this.#file) await this.#file.sink.end();

package/src/slash-commands/builtin-registry.ts

@@ -30,6 +30,7 @@ import { createMarketplaceManager } from "./helpers/marketplace-manager";
 import { handleMcpAcp } from "./helpers/mcp";
 import { commandConsumed, errorMessage, parseSlashCommand, parseSubcommand, usage } from "./helpers/parse";
 import { handleSshAcp } from "./helpers/ssh";
+import { launchStatsDashboard, parseStatsDashboardArgs } from "./helpers/stats-dashboard";
 import { handleTodoAcp } from "./helpers/todo";
 import { buildUsageReportText } from "./helpers/usage-report";
 import { parseMarketplaceInstallArgs, parsePluginScopeArgs } from "./marketplace-install-parser";
@@ -542,6 +543,25 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "stats",
+		description: "Launch the local stats dashboard",
+		inlineHint: "[--port <port>]",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const parsed = parseStatsDashboardArgs(command.args);
+			if ("error" in parsed) return usage(parsed.error, runtime);
+
+			await runtime.output("Syncing session files...");
+			try {
+				const result = await launchStatsDashboard(parsed);
+				await runtime.output(result.message);
+			} catch (error) {
+				await runtime.output(`Stats dashboard failed: ${errorMessage(error)}`);
+			}
+			return commandConsumed();
+		},
+	},
 	{
 		name: "changelog",
 		description: "Show changelog entries",

package/src/slash-commands/helpers/stats-dashboard.ts

@@ -0,0 +1,85 @@
+import * as stats from "@oh-my-pi/omp-stats";
+import * as openUtils from "../../utils/open";
+
+export const DEFAULT_STATS_DASHBOARD_PORT = 3847;
+
+interface StatsDashboardServer {
+	port: number;
+	stop: () => void;
+}
+
+export interface StatsDashboardArgs {
+	port: number;
+}
+
+export interface StatsDashboardLaunchResult {
+	url: string;
+	message: string;
+}
+
+let activeStatsServer: StatsDashboardServer | undefined;
+
+const STATS_DASHBOARD_USAGE = "Usage: /stats [--port <port>]";
+
+function parsePort(value: string | undefined): number | string {
+	if (!value) return `Missing port. ${STATS_DASHBOARD_USAGE}`;
+	if (!/^\d+$/.test(value)) return `Invalid port: ${value}`;
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 0 || port > 65_535) return `Invalid port: ${value}`;
+	return port;
+}
+
+export function parseStatsDashboardArgs(args: string): StatsDashboardArgs | { error: string } {
+	const tokens = args.split(/\s+/).filter(Boolean);
+	let port = DEFAULT_STATS_DASHBOARD_PORT;
+
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token === "--port" || token === "-p") {
+			const parsed = parsePort(tokens[++i]);
+			if (typeof parsed === "string") return { error: parsed };
+			port = parsed;
+			continue;
+		}
+		if (token.startsWith("--port=")) {
+			const parsed = parsePort(token.slice("--port=".length));
+			if (typeof parsed === "string") return { error: parsed };
+			port = parsed;
+			continue;
+		}
+		return { error: `Unknown option: ${token}. ${STATS_DASHBOARD_USAGE}` };
+	}
+
+	return { port };
+}
+
+export async function launchStatsDashboard(args: StatsDashboardArgs): Promise<StatsDashboardLaunchResult> {
+	const { processed, files } = await stats.syncAllSessions();
+	const total = await stats.getTotalMessageCount();
+	let requestedPortIgnored = false;
+
+	if (!activeStatsServer) {
+		activeStatsServer = await stats.startServer(args.port);
+	} else if (args.port !== activeStatsServer.port) {
+		requestedPortIgnored = true;
+	}
+
+	const url = `http://localhost:${activeStatsServer.port}`;
+	openUtils.openPath(url);
+
+	const serverLine = requestedPortIgnored
+		? `Dashboard already running at: ${url} (requested port ${args.port} ignored)`
+		: `Dashboard available at: ${url}`;
+
+	return {
+		url,
+		message: `Synced ${processed} new entries from ${files} files (${total} total)\n${serverLine}`,
+	};
+}
+
+export function stopStatsDashboard(): void {
+	if (!activeStatsServer) return;
+	activeStatsServer.stop();
+	activeStatsServer = undefined;
+	stats.closeDb();
+}

package/src/ssh/connection-manager.ts

@@ -355,6 +355,33 @@ export async function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSH
 	return await loadHostInfoFromDisk(host);
 }
 
+/**
+ * Synchronous, probe-free host info lookup for startup paths.
+ *
+ * Checks the in-memory cache, then falls back to a synchronous read of the
+ * persisted host-info cache file. Never opens a connection or probes the
+ * remote host — callers get `undefined` when nothing is cached yet.
+ */
+export function getCachedHostInfoSync(host: SSHConnectionTarget): SSHHostInfo | undefined {
+	const cached = hostInfoCache.get(host.name);
+	if (cached) {
+		const resolved = applyCompatOverride(host, cached);
+		if (resolved !== cached) hostInfoCache.set(host.name, resolved);
+		return resolved;
+	}
+	try {
+		const parsed = parseHostInfo(JSON.parse(fs.readFileSync(getHostInfoPath(host.name), "utf-8")));
+		if (!parsed) return undefined;
+		const resolved = applyCompatOverride(host, parsed);
+		hostInfoCache.set(host.name, resolved);
+		return resolved;
+	} catch (err) {
+		if (isEnoent(err)) return undefined;
+		logger.warn("Failed to load SSH host info", { host: host.name, error: String(err) });
+		return undefined;
+	}
+}
+
 export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const cached = hostInfoCache.get(host.name);
 	if (cached) {

package/src/task/commands.ts

@@ -120,7 +120,8 @@ export function getCommand(commands: WorkflowCommand[], name: string): WorkflowC
  * Replaces $@ with the provided input.
  */
 export function expandCommand(command: WorkflowCommand, input: string): string {
-	return command.instructions.replace(/\$@/g, input);
+	// Function replacement so `$`-patterns in user input ($$, $&, ...) stay literal.
+	return command.instructions.replace(/\$@/g, () => input);
 }
 
 /**

package/src/task/executor.ts

@@ -1285,59 +1285,67 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const { normalized: normalizedOutputSchema } = normalizeSchema(outputSchema);
 
-			const { session } = await awaitAbortable(
-				createAgentSession({
-					cwd: worktree ?? cwd,
-					authStorage,
-					modelRegistry,
-					settings: subagentSettings,
-					model,
-					thinkingLevel: effectiveThinkingLevel,
-					toolNames,
-					outputSchema,
-					requireYieldTool: true,
-					contextFiles: options.contextFiles,
-					skills: options.skills,
-					promptTemplates: options.promptTemplates,
-					workspaceTree: options.workspaceTree,
-					rules: options.rules,
-					preloadedExtensionPaths: options.preloadedExtensionPaths,
-					preloadedCustomToolPaths: options.preloadedCustomToolPaths,
-					systemPrompt: defaultPrompt => {
-						const subagentPrompt = prompt.render(subagentSystemPromptTemplate, {
-							agent: agent.systemPrompt,
-							context: options.context?.trim() ?? "",
-							planReference: options.planReference?.content ?? "",
-							planReferencePath: options.planReference?.path ?? "",
-							worktree: worktree ?? "",
-							outputSchema: normalizedOutputSchema,
-							contextFile: contextFileForPrompt,
-							ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
-							ircSelfId: ircEnabled ? id : "",
-						});
-						return defaultPrompt.length === 0
-							? [subagentPrompt]
-							: [...defaultPrompt.slice(0, -1), subagentPrompt, defaultPrompt[defaultPrompt.length - 1]];
-					},
-					sessionManager,
-					hasUI: false,
-					spawns: spawnsEnv,
-					taskDepth: childDepth,
-					parentHindsightSessionState: options.parentHindsightSessionState,
-					parentMnemopiSessionState: options.parentMnemopiSessionState,
-					parentTaskPrefix: id,
-					agentId: id,
-					agentDisplayName: agent.name,
-					enableLsp: lspEnabled,
-					skipPythonPreflight,
-					enableMCP,
-					mcpManager: options.mcpManager,
-					customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
-					localProtocolOptions: options.localProtocolOptions,
-					telemetry: subagentTelemetry,
-					parentEvalSessionId: options.parentEvalSessionId,
-				}),
-			);
+			const sessionPromise = createAgentSession({
+				cwd: worktree ?? cwd,
+				authStorage,
+				modelRegistry,
+				settings: subagentSettings,
+				model,
+				thinkingLevel: effectiveThinkingLevel,
+				toolNames,
+				outputSchema,
+				requireYieldTool: true,
+				contextFiles: options.contextFiles,
+				skills: options.skills,
+				promptTemplates: options.promptTemplates,
+				workspaceTree: options.workspaceTree,
+				rules: options.rules,
+				preloadedExtensionPaths: options.preloadedExtensionPaths,
+				preloadedCustomToolPaths: options.preloadedCustomToolPaths,
+				systemPrompt: defaultPrompt => {
+					const subagentPrompt = prompt.render(subagentSystemPromptTemplate, {
+						agent: agent.systemPrompt,
+						context: options.context?.trim() ?? "",
+						planReference: options.planReference?.content ?? "",
+						planReferencePath: options.planReference?.path ?? "",
+						worktree: worktree ?? "",
+						outputSchema: normalizedOutputSchema,
+						contextFile: contextFileForPrompt,
+						ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
+						ircSelfId: ircEnabled ? id : "",
+					});
+					return defaultPrompt.length === 0
+						? [subagentPrompt]
+						: [...defaultPrompt.slice(0, -1), subagentPrompt, defaultPrompt[defaultPrompt.length - 1]];
+				},
+				sessionManager,
+				hasUI: false,
+				spawns: spawnsEnv,
+				taskDepth: childDepth,
+				parentHindsightSessionState: options.parentHindsightSessionState,
+				parentMnemopiSessionState: options.parentMnemopiSessionState,
+				parentTaskPrefix: id,
+				agentId: id,
+				agentDisplayName: agent.name,
+				enableLsp: lspEnabled,
+				skipPythonPreflight,
+				enableMCP,
+				mcpManager: options.mcpManager,
+				customTools: mcpProxyTools.length > 0 ? mcpProxyTools : undefined,
+				localProtocolOptions: options.localProtocolOptions,
+				telemetry: subagentTelemetry,
+				parentEvalSessionId: options.parentEvalSessionId,
+			});
+			let session: AgentSession;
+			try {
+				({ session } = await awaitAbortable(sessionPromise));
+			} catch (err) {
+				// Abort raced session startup. The session may still resolve later
+				// holding live LSP/MCP child processes — dispose it when it does so
+				// a cancelled subagent cannot leak them.
+				void sessionPromise.then(created => created.session.dispose()).catch(() => {});
+				throw err;
+			}
 
 			activeSession = session;