fix(am): Improve agent manager and agent startup performance (#4567)

* tmp

* feat(agent-manager): add CliSessionLauncher with pre-warming support

- Extract CLI session launching logic into dedicated CliSessionLauncher class
- Pre-warm slow lookups (CLI path: 500-2000ms, git URL: 50-100ms) on panel open
- Run CLI path, git URL, and API config lookups in parallel during spawn
- Add handleSessionRenamed callback for provisional session upgrades
- Clear pre-warm state when panel closes or on dispose

* Extract and simplify

* Extract renameMapKey

Author: marius-kilocode

src/core/kilocode/agent-manager/AgentManagerProvider.ts

@@ -3,27 +3,27 @@ import * as fs from "node:fs"
 import * as path from "node:path"
 import { t } from "i18next"
 import { AgentRegistry } from "./AgentRegistry"
+import { renameMapKey } from "./mapUtils"
 import {
 	parseParallelModeBranch,
 	parseParallelModeWorktreePath,
 	isParallelModeCompletionMessage,
 	parseParallelModeCompletionBranch,
 } from "./parallelModeParser"
-import { findKilocodeCli } from "./CliPathResolver"
 import { canInstallCli, getCliInstallCommand, getLocalCliInstallCommand, getLocalCliBinDir } from "./CliInstaller"
 import { CliProcessHandler, type CliProcessHandlerCallbacks } from "./CliProcessHandler"
 import type { StreamEvent, KilocodeStreamEvent, KilocodePayload, WelcomeStreamEvent } from "./CliOutputParser"
 import { extractRawText, tryParsePayloadJson } from "./askErrorParser"
 import { RemoteSessionService } from "./RemoteSessionService"
 import { KilocodeEventProcessor } from "./KilocodeEventProcessor"
+import { CliSessionLauncher } from "./CliSessionLauncher"
 import type { RemoteSession } from "./types"
 import { getUri } from "../../webview/getUri"
 import { getNonce } from "../../webview/getNonce"
 import { getViteDevServerConfig } from "../../webview/getViteDevServerConfig"
 import { getRemoteUrl } from "../../../services/code-index/managed/git-utils"
 import { normalizeGitUrl } from "./normalizeGitUrl"
-import type { ClineMessage } from "@roo-code/types"
-import type { ProviderSettings } from "@roo-code/types"
+import type { ClineMessage, ProviderSettings } from "@roo-code/types"
 import {
 	captureAgentManagerOpened,
 	captureAgentManagerSessionStarted,
@@ -53,6 +53,7 @@ export class AgentManagerProvider implements vscode.Disposable {
 	private remoteSessionService: RemoteSessionService
 	private processHandler: CliProcessHandler
 	private eventProcessor: KilocodeEventProcessor
+	private sessionLauncher: CliSessionLauncher
 	private sessionMessages: Map<string, ClineMessage[]> = new Map()
 	// Track first api_req_started per session to filter user-input echoes
 	private firstApiReqStarted: Map<string, boolean> = new Map()
@@ -72,6 +73,12 @@ export class AgentManagerProvider implements vscode.Disposable {
 		this.registry = new AgentRegistry()
 		this.remoteSessionService = new RemoteSessionService({ outputChannel })
 
+		// Initialize session launcher with pre-warming
+		// Pre-warming starts slow lookups (CLI: 500-2000ms, git: 50-100ms) immediately
+		// so they complete before the user clicks "Start" to reduce time-to-first-token
+		this.sessionLauncher = new CliSessionLauncher(outputChannel, () => this.getApiConfigurationForCli())
+		this.sessionLauncher.startPrewarm()
+
 		// Initialize currentGitUrl from workspace
 		void this.initializeCurrentGitUrl()
 
@@ -142,6 +149,7 @@ export class AgentManagerProvider implements vscode.Disposable {
 				})
 			},
 			onPaymentRequiredPrompt: (payload) => this.showPaymentRequiredPrompt(payload),
+			onSessionRenamed: (oldId, newId) => this.handleSessionRenamed(oldId, newId),
 		}
 
 		this.processHandler = new CliProcessHandler(this.registry, callbacks)
@@ -196,6 +204,8 @@ export class AgentManagerProvider implements vscode.Disposable {
 			() => {
 				this.panel = undefined
 				this.stopAllAgents()
+				// Clear pre-warm state when panel closes
+				this.sessionLauncher.clearPrewarm()
 			},
 			null,
 			this.disposables,
@@ -207,6 +217,21 @@ export class AgentManagerProvider implements vscode.Disposable {
 		captureAgentManagerOpened()
 	}
 
+	/** Rename session key in all session-keyed maps. */
+	private handleSessionRenamed(oldId: string, newId: string): void {
+		this.outputChannel.appendLine(`[AgentManager] Renaming session: ${oldId} -> ${newId}`)
+
+		renameMapKey(this.sessionMessages, oldId, newId)
+		renameMapKey(this.firstApiReqStarted, oldId, newId)
+		renameMapKey(this.processStartTimes, oldId, newId)
+		renameMapKey(this.sendingMessageMap, oldId, newId)
+
+		const messages = this.sessionMessages.get(newId)
+		if (messages) {
+			this.postMessage({ type: "agentManager.chatMessages", sessionId: newId, messages })
+		}
+	}
+
 	private handleMessage(message: { type: string; [key: string]: unknown }): void {
 		this.outputChannel.appendLine(`Agent Manager received message: ${JSON.stringify(message)}`)
 
@@ -419,36 +444,23 @@ export class AgentManagerProvider implements vscode.Disposable {
 			return
 		}
 
-		// Get workspace folder early to fetch git URL before spawning
 		// Note: we intentionally allow starting parallel mode from within an existing git worktree.
 		// Git worktrees share a common .git dir, so `git worktree add/remove` still works from a worktree root.
 		const workspaceFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
 
-		// Get git URL for the workspace (used for filtering sessions)
-		let gitUrl: string | undefined
-		if (workspaceFolder) {
-			try {
-				gitUrl = normalizeGitUrl(await getRemoteUrl(workspaceFolder))
-			} catch (error) {
-				this.outputChannel.appendLine(
-					`[AgentManager] Could not get git URL: ${error instanceof Error ? error.message : String(error)}`,
-				)
-			}
-		}
-
 		const onSetupFailed = () => {
 			if (!workspaceFolder) {
 				void vscode.window.showErrorMessage("Please open a folder before starting an agent.")
 			}
 			this.postMessage({ type: "agentManager.startSessionFailed" })
 		}
 
+		// Git URL lookup is now handled by spawnCliWithCommonSetup using pre-warmed promise
 		await this.spawnCliWithCommonSetup(
 			prompt,
 			{
 				parallelMode: options?.parallelMode,
 				label: options?.labelOverride,
-				gitUrl,
 				existingBranch: options?.existingBranch,
 			},
 			onSetupFailed,
@@ -462,7 +474,7 @@ export class AgentManagerProvider implements vscode.Disposable {
 
 	/**
 	 * Common helper to spawn a CLI process with standard setup.
-	 * Handles CLI path lookup, workspace folder validation, API config, and event callback wiring.
+	 * Delegates to CliSessionLauncher for pre-warming and spawning.
 	 * @returns true if process was spawned, false if setup failed
 	 */
 	private async spawnCliWithCommonSetup(
@@ -476,47 +488,23 @@ export class AgentManagerProvider implements vscode.Disposable {
 		},
 		onSetupFailed?: () => void,
 	): Promise<boolean> {
-		const workspaceFolder = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
-		if (!workspaceFolder) {
-			this.outputChannel.appendLine("ERROR: No workspace folder open")
-			onSetupFailed?.()
-			return false
-		}
-
-		const cliPath = await findKilocodeCli((msg) => this.outputChannel.appendLine(`[AgentManager] ${msg}`))
-		if (!cliPath) {
-			this.outputChannel.appendLine("ERROR: kilocode CLI not found")
-			this.showCliNotFoundError()
-			onSetupFailed?.()
-			return false
-		}
-
-		const processStartTime = Date.now()
-		let apiConfiguration: ProviderSettings | undefined
-		try {
-			apiConfiguration = await this.getApiConfigurationForCli()
-		} catch (error) {
-			this.outputChannel.appendLine(
-				`[AgentManager] Failed to read provider settings for CLI: ${
-					error instanceof Error ? error.message : String(error)
-				}`,
-			)
-		}
-
-		this.processHandler.spawnProcess(
-			cliPath,
-			workspaceFolder,
+		const result = await this.sessionLauncher.spawn(
 			prompt,
-			{ ...options, apiConfiguration },
+			options,
+			this.processHandler,
 			(sid, event) => {
-				if (!this.processStartTimes.has(sid)) {
-					this.processStartTimes.set(sid, processStartTime)
+				if (result.processStartTime && !this.processStartTimes.has(sid)) {
+					this.processStartTimes.set(sid, result.processStartTime)
 				}
 				this.handleCliEvent(sid, event)
 			},
+			() => {
+				this.showCliNotFoundError()
+				onSetupFailed?.()
+			},
 		)
 
-		return true
+		return result.success
 	}
 
 	/**
@@ -1150,7 +1138,7 @@ export class AgentManagerProvider implements vscode.Disposable {
 		this.processHandler.dispose()
 		this.sessionMessages.clear()
 		this.firstApiReqStarted.clear()
-
+		this.sessionLauncher.clearPrewarm()
 		this.panel?.dispose()
 		this.disposables.forEach((d) => d.dispose())
 	}

src/core/kilocode/agent-manager/AgentRegistry.ts

@@ -209,6 +209,31 @@ export class AgentRegistry {
 		return this.sessions.delete(sessionId)
 	}
 
+	/**
+	 * Rename a session from one ID to another.
+	 * Used when upgrading a provisional session to a real session ID.
+	 */
+	public renameSession(oldId: string, newId: string): boolean {
+		const session = this.sessions.get(oldId)
+		if (!session) {
+			return false
+		}
+
+		// Update the session's internal ID
+		session.sessionId = newId
+
+		// Move in the map
+		this.sessions.delete(oldId)
+		this.sessions.set(newId, session)
+
+		// Update selectedId if it was pointing to the old ID
+		if (this._selectedId === oldId) {
+			this._selectedId = newId
+		}
+
+		return true
+	}
+
 	private pruneOldSessions(): void {
 		const sessions = this.getSessions()
 		const overflow = sessions.length - MAX_SESSIONS

src/core/kilocode/agent-manager/CliProcessHandler.ts

@@ -37,6 +37,7 @@ interface PendingProcessInfo {
 	gitUrl?: string
 	stderrBuffer: string[] // Capture stderr for error detection
 	timeoutId?: NodeJS.Timeout // Timer for auto-failing stuck pending sessions
+	provisionalSessionId?: string // Temporary session ID created when api_req_started arrives (before session_created)
 }
 
 interface ActiveProcessInfo {
@@ -60,6 +61,7 @@ export interface CliProcessHandlerCallbacks {
 	onSessionCreated: (sawApiReqStarted: boolean) => void
 	onPaymentRequiredPrompt?: (payload: KilocodePayload) => void
 	onSessionCompleted?: (sessionId: string, exitCode: number | null) => void // Called when process exits successfully
+	onSessionRenamed?: (oldId: string, newId: string) => void // Called when provisional session is upgraded to real session ID
 }
 
 export class CliProcessHandler {
@@ -365,10 +367,11 @@ export class CliProcessHandler {
 				}
 				return
 			}
-			// Track api_req_started that arrives before session_created
-			// This is needed so KilocodeEventProcessor knows the user echo has already happened
+			// Handle kilocode events during pending state
 			if (event.streamEventType === "kilocode") {
 				const payload = (event as KilocodeStreamEvent).payload
+
+				// Handle error cases that should abort session creation
 				if (payload?.ask === "payment_required_prompt") {
 					this.handlePaymentRequiredDuringPending(payload)
 					return
@@ -377,11 +380,34 @@ export class CliProcessHandler {
 					this.handleApiReqFailedDuringPending(payload)
 					return
 				}
+
+				// Track api_req_started for KilocodeEventProcessor
 				if (payload?.say === "api_req_started") {
 					this.pendingProcess.sawApiReqStarted = true
 					this.debugLog(`Captured api_req_started before session_created`)
 				}
+
+				// Create provisional session on first content event (text, api_req_started, etc.)
+				// This ensures we don't lose the user's prompt echo or other early events
+				if (!this.pendingProcess.provisionalSessionId) {
+					this.createProvisionalSession(proc)
+				}
+
+				// Forward the event to the provisional session
+				if (this.pendingProcess?.provisionalSessionId) {
+					onCliEvent(this.pendingProcess.provisionalSessionId, event)
+					this.callbacks.onStateChanged()
+				}
+				return
+			}
+
+			// If we have a provisional session, forward non-kilocode events to it
+			if (this.pendingProcess?.provisionalSessionId) {
+				onCliEvent(this.pendingProcess.provisionalSessionId, event)
+				this.callbacks.onStateChanged()
+				return
 			}
+
 			// Events before session_created are typically status messages
 			if (event.streamEventType === "status") {
 				this.debugLog(`Pending session status: ${event.message}`)
@@ -397,6 +423,64 @@ export class CliProcessHandler {
 		}
 	}
 
+	/** Create a provisional session to show streaming content before session_created arrives. */
+	private createProvisionalSession(proc: ChildProcess): void {
+		if (!this.pendingProcess || this.pendingProcess.provisionalSessionId) {
+			return
+		}
+
+		const provisionalId = `provisional-${Date.now()}`
+		this.pendingProcess.provisionalSessionId = provisionalId
+
+		const { prompt, startTime, parallelMode, desiredLabel, gitUrl, parser } = this.pendingProcess
+
+		this.registry.createSession(provisionalId, prompt, startTime, {
+			parallelMode,
+			labelOverride: desiredLabel,
+			gitUrl,
+		})
+
+		this.activeSessions.set(provisionalId, { process: proc, parser })
+
+		if (proc.pid) {
+			this.registry.setSessionPid(provisionalId, proc.pid)
+		}
+
+		this.registry.clearPendingSession()
+		this.callbacks.onPendingSessionChanged(null)
+		this.callbacks.onSessionCreated(this.pendingProcess?.sawApiReqStarted ?? false)
+
+		this.debugLog(`Created provisional session: ${provisionalId}`)
+		this.callbacks.onStateChanged()
+	}
+
+	/** Upgrade provisional session to real session ID when session_created arrives. */
+	private upgradeProvisionalSession(
+		provisionalSessionId: string,
+		realSessionId: string,
+		worktreeBranch: string | undefined,
+		parallelMode: boolean | undefined,
+	): void {
+		this.debugLog(`Upgrading provisional session ${provisionalSessionId} -> ${realSessionId}`)
+
+		this.registry.renameSession(provisionalSessionId, realSessionId)
+
+		const activeInfo = this.activeSessions.get(provisionalSessionId)
+		if (activeInfo) {
+			this.activeSessions.delete(provisionalSessionId)
+			this.activeSessions.set(realSessionId, activeInfo)
+		}
+
+		this.callbacks.onSessionRenamed?.(provisionalSessionId, realSessionId)
+
+		if (worktreeBranch && parallelMode) {
+			this.registry.updateParallelModeInfo(realSessionId, { branch: worktreeBranch })
+		}
+
+		this.pendingProcess = null
+		this.callbacks.onStateChanged()
+	}
+
 	private handlePendingTimeout(): void {
 		if (!this.pendingProcess) {
 			return
@@ -445,10 +529,19 @@ export class CliProcessHandler {
 			desiredLabel,
 			sawApiReqStarted,
 			gitUrl,
+			provisionalSessionId,
 		} = this.pendingProcess
 
 		// Use desired sessionId when provided (resuming) to keep UI continuity
 		const sessionId = desiredSessionId ?? event.sessionId
+
+		// Handle provisional session upgrade if one exists
+		if (provisionalSessionId) {
+			this.upgradeProvisionalSession(provisionalSessionId, sessionId, worktreeBranch, parallelMode)
+			return
+		}
+
+		// Normal path: no provisional session, create the session now
 		const existing = this.registry.getSession(sessionId)
 
 		let session: ReturnType<typeof this.registry.createSession>