@getpaseo/server 0.1.33 → 0.1.34

package/dist/src/server/agent/agent-manager.js

@@ -19,7 +19,6 @@ function attachPersistenceCwd(handle, cwd) {
     };
 }
 const DEFAULT_TIMELINE_FETCH_LIMIT = 200;
-const LIVE_BACKLOG_TERMINAL_REPLAY_DELAY_MS = 300;
 const BUSY_STATUSES = ["initializing", "running"];
 const AgentIdSchema = z.string().uuid();
 function isAgentBusy(status) {
@@ -46,10 +45,6 @@ function validateAgentId(agentId, source) {
     }
     return result.data;
 }
-function supportsLiveEventStream(session) {
-    return ("streamLiveEvents" in session &&
-        typeof session.streamLiveEvents === "function");
-}
 function normalizeMessageId(messageId) {
     if (typeof messageId !== "string") {
         return undefined;
@@ -61,12 +56,10 @@ export class AgentManager {
     constructor(options) {
         this.clients = new Map();
         this.agents = new Map();
+        this.pendingForegroundRuns = new Map();
         this.subscribers = new Set();
         this.previousStatuses = new Map();
         this.backgroundTasks = new Set();
-        this.liveEventPumps = new Map();
-        this.liveEventBacklog = new Map();
-        this.liveEventBacklogFlushTimers = new Map();
         const maxTimelineItems = options?.maxTimelineItems;
         this.maxTimelineItems =
             typeof maxTimelineItems === "number" &&
@@ -100,6 +93,15 @@ export class AgentManager {
         agent.updatedAt = next;
         return next;
     }
+    hasInFlightRun(agentId) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return false;
+        }
+        return (agent.lifecycle === "running" ||
+            Boolean(agent.activeForegroundTurnId) ||
+            this.hasPendingForegroundRun(agentId));
+    }
     subscribe(callback, options) {
         const targetAgentId = options?.agentId == null ? null : validateAgentId(options.agentId, "subscribe");
         const record = {
@@ -356,16 +358,14 @@ export class AgentManager {
     async createAgent(config, agentId, options) {
         // Generate agent ID early so we can use it in MCP config
         const resolvedAgentId = validateAgentId(agentId ?? this.idFactory(), "createAgent");
-        const normalizedConfig = await this.normalizeConfig(config, {
-            labels: options?.labels,
-            agentId: resolvedAgentId,
-        });
+        const normalizedConfig = await this.normalizeConfig(config);
+        const launchContext = this.buildLaunchContext(resolvedAgentId);
         const client = this.requireClient(normalizedConfig.provider);
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${normalizedConfig.provider}' is not available. Please ensure the CLI is installed.`);
         }
-        const session = await client.createSession(normalizedConfig);
+        const session = await client.createSession(normalizedConfig, launchContext);
         return this.registerSession(session, normalizedConfig, resolvedAgentId, {
             labels: options?.labels,
         });
@@ -384,15 +384,16 @@ export class AgentManager {
         const resumeOverrides = normalizedConfig.model !== mergedConfig.model
             ? { ...overrides, model: normalizedConfig.model }
             : overrides;
+        const launchContext = this.buildLaunchContext(resolvedAgentId);
         const client = this.requireClient(handle.provider);
-        const session = await client.resumeSession(handle, resumeOverrides);
+        const session = await client.resumeSession(handle, resumeOverrides, launchContext);
         return this.registerSession(session, normalizedConfig, resolvedAgentId, options);
     }
     // Hot-reload an active agent session with config overrides while preserving
     // in-memory timeline state.
     async reloadAgentSession(agentId, overrides) {
         let existing = this.requireAgent(agentId);
-        if (existing.lifecycle === "running" || existing.pendingRun) {
+        if (this.hasInFlightRun(agentId)) {
             await this.cancelAgentRun(agentId);
             existing = this.requireAgent(agentId);
         }
@@ -414,14 +415,21 @@ export class AgentManager {
             provider,
         };
         const normalizedConfig = await this.normalizeConfig(refreshConfig);
+        const launchContext = this.buildLaunchContext(agentId);
         const session = handle
-            ? await client.resumeSession(handle, normalizedConfig)
-            : await client.createSession(normalizedConfig);
+            ? await client.resumeSession(handle, normalizedConfig, launchContext)
+            : await client.createSession(normalizedConfig, launchContext);
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
-        this.liveEventPumps.delete(agentId);
-        this.liveEventBacklog.delete(agentId);
-        this.clearLiveEventBacklogFlushTimer(agentId);
+        if (existing.unsubscribeSession) {
+            existing.unsubscribeSession();
+            existing.unsubscribeSession = null;
+        }
+        for (const waiter of existing.foregroundTurnWaiters) {
+            this.settleForegroundTurnWaiter(waiter);
+        }
+        existing.foregroundTurnWaiters.clear();
+        this.settlePendingForegroundRun(agentId);
         try {
             await existing.session.close();
         }
@@ -449,21 +457,34 @@ export class AgentManager {
         this.logger.trace({
             agentId,
             lifecycle: agent.lifecycle,
-            hasPendingRun: Boolean(agent.pendingRun),
+            activeForegroundTurnId: agent.activeForegroundTurnId,
             pendingPermissions: agent.pendingPermissions.size,
         }, "closeAgent: start");
         this.agents.delete(agentId);
-        this.liveEventPumps.delete(agentId);
-        this.liveEventBacklog.delete(agentId);
-        this.clearLiveEventBacklogFlushTimer(agentId);
         // Clean up previousStatus to prevent memory leak
         this.previousStatuses.delete(agentId);
+        if (agent.unsubscribeSession) {
+            agent.unsubscribeSession();
+            agent.unsubscribeSession = null;
+        }
+        for (const waiter of agent.foregroundTurnWaiters) {
+            // Wake up the generator so it can exit the await loop
+            waiter.callback({
+                type: "turn_canceled",
+                provider: agent.provider,
+                reason: "agent closed",
+                turnId: waiter.turnId,
+            });
+            this.settleForegroundTurnWaiter(waiter);
+        }
+        agent.foregroundTurnWaiters.clear();
+        this.settlePendingForegroundRun(agentId);
         const session = agent.session;
         const closedAgent = {
             ...agent,
             lifecycle: "closed",
             session: null,
-            pendingRun: null,
+            activeForegroundTurnId: null,
         };
         await session.close();
         this.emitState(closedAgent);
@@ -623,128 +644,140 @@ export class AgentManager {
         this.logger.trace({
             agentId,
             lifecycle: existingAgent.lifecycle,
-            hasPendingRun: Boolean(existingAgent.pendingRun),
+            activeForegroundTurnId: existingAgent.activeForegroundTurnId,
+            hasPendingForegroundRun: this.hasPendingForegroundRun(agentId),
             promptType: typeof prompt === "string" ? "string" : "structured",
             hasRunOptions: Boolean(options),
         }, "streamAgent: requested");
-        if (existingAgent.pendingRun) {
+        if (existingAgent.activeForegroundTurnId || this.hasPendingForegroundRun(agentId)) {
             this.logger.trace({
                 agentId,
                 lifecycle: existingAgent.lifecycle,
-            }, "streamAgent: rejected because pendingRun already exists");
+                hasPendingForegroundRun: this.hasPendingForegroundRun(agentId),
+            }, "streamAgent: rejected because a foreground run is already in flight");
             throw new Error(`Agent ${agentId} already has an active run`);
         }
         const agent = existingAgent;
-        const iterator = agent.session.stream(prompt, options);
         agent.pendingReplacement = false;
         agent.lastError = undefined;
-        let finalized = false;
-        const finalize = (error) => {
-            this.logger.trace({
-                agentId,
-                error,
-                alreadyFinalized: finalized,
-                lifecycle: agent.lifecycle,
-                hasPendingRun: Boolean(agent.pendingRun),
-            }, "streamAgent.finalize: invoked");
-            if (finalized) {
-                return;
-            }
-            finalized = true;
-            if (agent.pendingRun !== streamForwarder) {
-                this.logger.trace({
-                    agentId,
-                    error,
-                    lifecycle: agent.lifecycle,
-                    hasPendingRun: Boolean(agent.pendingRun),
-                }, "streamAgent.finalize: skipped because pendingRun no longer points to streamForwarder");
-                if (error) {
-                    agent.lastError = error;
-                }
-                return;
-            }
-            const mutableAgent = agent;
-            mutableAgent.pendingRun = null;
-            const terminalError = error ?? mutableAgent.lastError;
-            const shouldHoldBusyForReplacement = mutableAgent.pendingReplacement && !terminalError;
-            mutableAgent.lifecycle = shouldHoldBusyForReplacement
-                ? "running"
-                : terminalError
-                    ? "error"
-                    : "idle";
-            mutableAgent.lastError = terminalError;
-            const persistenceHandle = mutableAgent.session.describePersistence() ??
-                (mutableAgent.runtimeInfo?.sessionId
-                    ? { provider: mutableAgent.provider, sessionId: mutableAgent.runtimeInfo.sessionId }
-                    : null);
-            if (persistenceHandle) {
-                mutableAgent.persistence = attachPersistenceCwd(persistenceHandle, mutableAgent.cwd);
-            }
-            this.logger.trace({
-                agentId,
-                lifecycle: mutableAgent.lifecycle,
-                hasPendingRun: Boolean(mutableAgent.pendingRun),
-                terminalError,
-                pendingReplacement: mutableAgent.pendingReplacement,
-            }, "streamAgent.finalize: applying terminal state");
-            if (!shouldHoldBusyForReplacement) {
-                this.touchUpdatedAt(mutableAgent);
-                this.emitState(mutableAgent);
-                this.flushLiveEventBacklog(mutableAgent);
-            }
-        };
         const self = this;
         const streamForwarder = (async function* streamForwarder() {
-            let finalizeError;
+            const pendingRun = self.createPendingForegroundRun();
+            self.pendingForegroundRuns.set(agentId, pendingRun);
+            let turnId;
+            let waiter = null;
             try {
-                for await (const event of iterator) {
-                    self.handleStreamEvent(agent, event);
-                    if (event.type === "turn_started" ||
-                        event.type === "turn_completed" ||
-                        event.type === "turn_failed" ||
-                        event.type === "turn_canceled") {
-                        self.logger.trace({
-                            agentId,
-                            eventType: event.type,
-                            lifecycle: agent.lifecycle,
-                            hasPendingRun: Boolean(agent.pendingRun),
-                        }, "streamAgent: forwarded terminal/turn event");
-                    }
-                    yield event;
-                }
+                const result = await agent.session.startTurn(prompt, options);
+                turnId = result.turnId;
             }
             catch (error) {
-                finalizeError = error instanceof Error ? error.message : "Agent stream failed";
+                const errorMsg = error instanceof Error ? error.message : "Failed to start turn";
                 self.handleStreamEvent(agent, {
                     type: "turn_failed",
                     provider: agent.provider,
-                    error: finalizeError,
+                    error: errorMsg,
                 });
+                self.finalizeForegroundTurn(agent);
                 throw error;
             }
+            pendingRun.started = true;
+            agent.activeForegroundTurnId = turnId;
+            agent.lifecycle = "running";
+            self.touchUpdatedAt(agent);
+            self.emitState(agent);
+            self.logger.trace({
+                agentId,
+                lifecycle: agent.lifecycle,
+                activeForegroundTurnId: agent.activeForegroundTurnId,
+            }, "streamAgent: started");
+            // Create a pushable queue for this foreground turn
+            const queue = [];
+            let queueResolve = null;
+            let done = false;
+            let resolveSettled;
+            const settledPromise = new Promise((resolve) => {
+                resolveSettled = resolve;
+            });
+            waiter = {
+                turnId,
+                settled: false,
+                settledPromise,
+                resolveSettled,
+                callback: (event) => {
+                    queue.push(event);
+                    if (queueResolve) {
+                        queueResolve();
+                        queueResolve = null;
+                    }
+                },
+            };
+            agent.foregroundTurnWaiters.add(waiter);
+            try {
+                while (!done) {
+                    while (queue.length > 0) {
+                        const event = queue.shift();
+                        yield event;
+                        if (isTurnTerminalEvent(event)) {
+                            done = true;
+                            break;
+                        }
+                    }
+                    if (!done && queue.length === 0) {
+                        if (waiter.settled) {
+                            break;
+                        }
+                        await new Promise((resolve) => {
+                            queueResolve = resolve;
+                        });
+                    }
+                }
+            }
             finally {
-                await self.refreshRuntimeInfo(agent);
-                // Ensure we always clear the pending run and emit state when the stream is
-                // cancelled early (e.g., via .return()) so the UI can exit the cancelling state.
-                finalize(finalizeError);
+                if (waiter) {
+                    agent.foregroundTurnWaiters.delete(waiter);
+                    self.settleForegroundTurnWaiter(waiter);
+                }
+                self.settlePendingForegroundRun(agentId, pendingRun.token);
+                if (!agent.activeForegroundTurnId) {
+                    await self.refreshRuntimeInfo(agent);
+                }
             }
         })();
-        agent.pendingRun = streamForwarder;
-        agent.lifecycle = "running";
-        // Bump updatedAt when lifecycle changes so downstream consumers can
-        // deterministically order idle->running transitions.
-        this.touchUpdatedAt(agent);
-        self.emitState(agent);
-        this.logger.trace({
-            agentId,
-            lifecycle: agent.lifecycle,
-            hasPendingRun: Boolean(agent.pendingRun),
-        }, "streamAgent: started");
         return streamForwarder;
     }
+    finalizeForegroundTurn(agent) {
+        const mutableAgent = agent;
+        mutableAgent.activeForegroundTurnId = null;
+        const terminalError = mutableAgent.lastError;
+        const shouldHoldBusyForReplacement = mutableAgent.pendingReplacement && !terminalError;
+        mutableAgent.lifecycle = shouldHoldBusyForReplacement
+            ? "running"
+            : terminalError
+                ? "error"
+                : "idle";
+        const persistenceHandle = mutableAgent.session.describePersistence() ??
+            (mutableAgent.runtimeInfo?.sessionId
+                ? { provider: mutableAgent.provider, sessionId: mutableAgent.runtimeInfo.sessionId }
+                : null);
+        if (persistenceHandle) {
+            mutableAgent.persistence = attachPersistenceCwd(persistenceHandle, mutableAgent.cwd);
+        }
+        this.logger.trace({
+            agentId: agent.id,
+            lifecycle: mutableAgent.lifecycle,
+            terminalError,
+            pendingReplacement: mutableAgent.pendingReplacement,
+        }, "finalizeForegroundTurn: applying terminal state");
+        if (!shouldHoldBusyForReplacement) {
+            this.touchUpdatedAt(mutableAgent);
+            this.emitState(mutableAgent);
+        }
+    }
     replaceAgentRun(agentId, prompt, options) {
         const snapshot = this.requireAgent(agentId);
-        if (snapshot.lifecycle !== "running" && !snapshot.pendingRun) {
+        if (snapshot.lifecycle !== "running" &&
+            !snapshot.activeForegroundTurnId &&
+            !this.hasPendingForegroundRun(agentId)) {
             return this.streamAgent(agentId, prompt, options);
         }
         const agent = snapshot;
@@ -763,13 +796,10 @@ export class AgentManager {
                 if (latest) {
                     const latestActive = latest;
                     latestActive.pendingReplacement = false;
-                    const hasForegroundRun = Boolean(latestActive.pendingRun);
-                    const lifecycle = latestActive.lifecycle;
-                    if (!hasForegroundRun && lifecycle === "running") {
+                    if (!latestActive.activeForegroundTurnId && latestActive.lifecycle === "running") {
                         latestActive.lifecycle = "idle";
                         self.touchUpdatedAt(latestActive);
                         self.emitState(latestActive);
-                        self.flushLiveEventBacklog(latestActive);
                     }
                 }
                 throw error;
@@ -781,10 +811,12 @@ export class AgentManager {
         if (!snapshot) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        if (snapshot.lifecycle === "running" && !snapshot.pendingReplacement) {
+        const pendingRun = this.getPendingForegroundRun(agentId);
+        if ((snapshot.lifecycle === "running" || pendingRun?.started) &&
+            !snapshot.pendingReplacement) {
             return;
         }
-        if ((!("pendingRun" in snapshot) || !snapshot.pendingRun) && !snapshot.pendingReplacement) {
+        if (!snapshot.activeForegroundTurnId && !pendingRun && !snapshot.pendingReplacement) {
             throw new Error(`Agent ${agentId} has no pending run`);
         }
         if (options?.signal?.aborted) {
@@ -829,26 +861,37 @@ export class AgentManager {
                 abortHandler = () => finishErr(createAbortError(options.signal, "wait_for_agent_start aborted"));
                 options.signal.addEventListener("abort", abortHandler, { once: true });
             }
+            const checkCurrentState = () => {
+                const current = this.getAgent(agentId);
+                if (!current) {
+                    finishErr(new Error(`Agent ${agentId} not found`));
+                    return true;
+                }
+                const currentPendingRun = this.getPendingForegroundRun(agentId);
+                if ((current.lifecycle === "running" || currentPendingRun?.started) &&
+                    !current.pendingReplacement) {
+                    finishOk();
+                    return true;
+                }
+                if (current.lifecycle === "error" && !currentPendingRun?.started) {
+                    finishErr(new Error(current.lastError ?? `Agent ${agentId} failed to start`));
+                    return true;
+                }
+                if (!currentPendingRun &&
+                    !current.activeForegroundTurnId &&
+                    !current.pendingReplacement) {
+                    finishErr(new Error(`Agent ${agentId} run finished before starting`));
+                    return true;
+                }
+                return false;
+            };
             unsubscribe = this.subscribe((event) => {
-                if (event.type === "agent_state") {
-                    if (event.agent.id !== agentId) {
-                        return;
-                    }
-                    if (event.agent.lifecycle === "running" && !event.agent.pendingReplacement) {
-                        finishOk();
-                        return;
-                    }
-                    if (event.agent.lifecycle === "error") {
-                        finishErr(new Error(event.agent.lastError ?? `Agent ${agentId} failed to start`));
-                        return;
-                    }
-                    if ("pendingRun" in event.agent && !event.agent.pendingRun) {
-                        finishErr(new Error(`Agent ${agentId} run finished before starting`));
-                        return;
-                    }
+                if (event.type !== "agent_state" || event.agent.id !== agentId) {
                     return;
                 }
-            }, { agentId, replayState: true });
+                checkCurrentState();
+            }, { agentId, replayState: false });
+            checkCurrentState();
         });
     }
     async respondToPermission(agentId, requestId, response) {
@@ -867,10 +910,11 @@ export class AgentManager {
     }
     async cancelAgentRun(agentId) {
         const agent = this.requireAgent(agentId);
-        const pendingRun = agent.pendingRun;
-        const hasForegroundPendingRun = Boolean(pendingRun) && typeof pendingRun?.return === "function";
-        const isAutonomousRunning = agent.lifecycle === "running" && !hasForegroundPendingRun;
-        if (!hasForegroundPendingRun && !isAutonomousRunning) {
+        const pendingRun = this.getPendingForegroundRun(agentId);
+        const foregroundTurnId = agent.activeForegroundTurnId;
+        const hasForegroundTurn = Boolean(foregroundTurnId);
+        const isAutonomousRunning = agent.lifecycle === "running" && !hasForegroundTurn && !pendingRun;
+        if (!hasForegroundTurn && !isAutonomousRunning && !pendingRun) {
             return false;
         }
         try {
@@ -879,20 +923,61 @@ export class AgentManager {
         catch (error) {
             this.logger.error({ err: error, agentId }, "Failed to interrupt session");
         }
-        if (hasForegroundPendingRun && pendingRun) {
-            try {
-                // Await the generator's .return() to ensure the finally block runs
-                // and pendingRun is properly cleared before we return.
-                await pendingRun.return(undefined);
+        // The interrupt will produce a turn_canceled/turn_failed event via subscribe(),
+        // which flows through the session event dispatcher and settles the foreground turn waiter.
+        // Wait briefly for the event to propagate if there's an active foreground turn.
+        if (foregroundTurnId) {
+            const waiter = Array.from(agent.foregroundTurnWaiters).find((candidate) => candidate.turnId === foregroundTurnId);
+            const timeout = new Promise((resolve) => setTimeout(resolve, 2000));
+            if (waiter) {
+                await Promise.race([waiter.settledPromise, timeout]);
             }
-            catch (error) {
-                this.logger.error({ err: error, agentId }, "Failed to cancel run");
-                throw error;
+            else if (agent.activeForegroundTurnId === foregroundTurnId) {
+                await Promise.race([
+                    new Promise((resolve) => {
+                        const unsubscribe = this.subscribe((event) => {
+                            if (event.type === "agent_state" &&
+                                event.agent.id === agentId &&
+                                !event.agent.activeForegroundTurnId) {
+                                unsubscribe();
+                                resolve();
+                            }
+                        }, { agentId, replayState: false });
+                    }),
+                    timeout,
+                ]);
+            }
+            // The waiter settling wakes up the streamForwarder generator, but its
+            // finally block (which deletes the pendingForegroundRun) runs asynchronously.
+            // Wait for the pending run to be fully cleaned up so the next streamAgent
+            // call doesn't see a stale entry and reject with "already has an active run".
+            if (pendingRun && !pendingRun.settled) {
+                await Promise.race([pendingRun.settledPromise, timeout]);
+            }
+        }
+        else if (pendingRun) {
+            const timeout = new Promise((resolve) => setTimeout(resolve, 2000));
+            await Promise.race([pendingRun.settledPromise, timeout]);
+        }
+        // If the foreground turn is still stuck after the timeout, force-dispatch a
+        // synthetic turn_canceled so the normal event pipeline cleans up
+        // activeForegroundTurnId, settles waiters, and unblocks the streamForwarder.
+        if (foregroundTurnId && agent.activeForegroundTurnId === foregroundTurnId) {
+            this.logger.warn({ agentId, foregroundTurnId }, "cancelAgentRun: foreground turn still active after timeout, force-canceling");
+            this.dispatchSessionEvent(agent, {
+                type: "turn_canceled",
+                provider: agent.provider,
+                reason: "interrupted",
+                turnId: foregroundTurnId,
+            });
+            // The synthetic event unblocks the streamForwarder generator, whose finally
+            // block settles the pending foreground run asynchronously. Wait for it.
+            const staleRun = this.getPendingForegroundRun(agentId);
+            if (staleRun && !staleRun.settled) {
+                await staleRun.settledPromise;
             }
         }
         // Clear any pending permissions that weren't cleaned up by handleStreamEvent.
-        // Due to microtask ordering, .return() may force the generator to its finally
-        // block before it consumes the turn_canceled event, skipping our cleanup code.
         if (agent.pendingPermissions.size > 0) {
             for (const [requestId] of agent.pendingPermissions) {
                 this.dispatchStream(agent.id, {
@@ -950,7 +1035,7 @@ export class AgentManager {
         if (!snapshot) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        const hasPendingRun = "pendingRun" in snapshot && Boolean(snapshot.pendingRun);
+        const hasForegroundTurn = Boolean(snapshot.activeForegroundTurnId) || this.hasPendingForegroundRun(agentId);
         const immediatePermission = this.peekPendingPermission(snapshot);
         if (immediatePermission) {
             return {
@@ -960,7 +1045,7 @@ export class AgentManager {
             };
         }
         const initialStatus = snapshot.lifecycle;
-        const initialBusy = isAgentBusy(initialStatus) || hasPendingRun;
+        const initialBusy = isAgentBusy(initialStatus) || hasForegroundTurn;
         const waitForActive = options?.waitForActive ?? false;
         if (!waitForActive && !initialBusy) {
             return {
@@ -969,7 +1054,7 @@ export class AgentManager {
                 lastMessage: this.getLastAssistantMessage(agentId),
             };
         }
-        if (waitForActive && !initialBusy && !hasPendingRun) {
+        if (waitForActive && !initialBusy && !hasForegroundTurn) {
             return {
                 status: initialStatus,
                 permission: null,
@@ -987,7 +1072,7 @@ export class AgentManager {
                 return;
             }
             let currentStatus = initialStatus;
-            let hasStarted = initialBusy || hasPendingRun;
+            let hasStarted = initialBusy || hasForegroundTurn;
             let terminalStatusOverride = null;
             // Bug #3 Fix: Declare unsubscribe and abortHandler upfront so cleanup can reference them
             let unsubscribe = null;
@@ -1103,7 +1188,9 @@ export class AgentManager {
             currentModeId: null,
             pendingPermissions: new Map(),
             pendingReplacement: false,
-            pendingRun: null,
+            activeForegroundTurnId: null,
+            foregroundTurnWaiters: new Set(),
+            unsubscribeSession: null,
             timeline: initialTimeline,
             timelineRows: initialTimelineRows,
             timelineEpoch: options?.timelineEpoch ?? randomUUID(),
@@ -1137,9 +1224,77 @@ export class AgentManager {
         managed.lifecycle = "idle";
         await this.persistSnapshot(managed);
         this.emitState(managed);
-        this.startLiveEventPump(managed);
+        this.subscribeToSession(managed);
         return { ...managed };
     }
+    subscribeToSession(agent) {
+        if (agent.unsubscribeSession) {
+            return;
+        }
+        const agentId = agent.id;
+        const unsubscribe = agent.session.subscribe((event) => {
+            const current = this.agents.get(agentId);
+            if (!current) {
+                return;
+            }
+            this.dispatchSessionEvent(current, event);
+        });
+        agent.unsubscribeSession = unsubscribe;
+    }
+    dispatchSessionEvent(agent, event) {
+        const turnId = event.turnId;
+        const matchingWaiters = turnId == null
+            ? []
+            : Array.from(agent.foregroundTurnWaiters).filter((waiter) => waiter.turnId === turnId && !waiter.settled);
+        this.handleStreamEvent(agent, event);
+        for (const waiter of matchingWaiters) {
+            waiter.callback(event);
+            if (isTurnTerminalEvent(event)) {
+                this.settleForegroundTurnWaiter(waiter);
+            }
+        }
+    }
+    settleForegroundTurnWaiter(waiter) {
+        if (waiter.settled) {
+            return;
+        }
+        waiter.settled = true;
+        waiter.resolveSettled();
+    }
+    createPendingForegroundRun() {
+        let resolveSettled;
+        const settledPromise = new Promise((resolve) => {
+            resolveSettled = resolve;
+        });
+        return {
+            token: randomUUID(),
+            started: false,
+            settled: false,
+            settledPromise,
+            resolveSettled,
+        };
+    }
+    getPendingForegroundRun(agentId) {
+        return this.pendingForegroundRuns.get(agentId) ?? null;
+    }
+    hasPendingForegroundRun(agentId) {
+        return this.pendingForegroundRuns.has(agentId);
+    }
+    settlePendingForegroundRun(agentId, token) {
+        const pendingRun = this.pendingForegroundRuns.get(agentId);
+        if (!pendingRun) {
+            return;
+        }
+        if (token && pendingRun.token !== token) {
+            return;
+        }
+        this.pendingForegroundRuns.delete(agentId);
+        if (pendingRun.settled) {
+            return;
+        }
+        pendingRun.settled = true;
+        pendingRun.resolveSettled();
+    }
     async resolveInitialPersistedTitle(agentId, config) {
         const existing = await this.registry?.get(agentId);
         if (existing) {
@@ -1256,6 +1411,8 @@ export class AgentManager {
         }
     }
     handleStreamEvent(agent, event, options) {
+        const eventTurnId = event.turnId;
+        const isForegroundEvent = Boolean(eventTurnId && agent.activeForegroundTurnId === eventTurnId);
         // Only update timestamp for live events, not history replay
         if (!options?.fromHistory) {
             this.touchUpdatedAt(agent);
@@ -1263,8 +1420,6 @@ export class AgentManager {
         let timelineRow = null;
         switch (event.type) {
             case "thread_started":
-                // Update persistence with the new session ID from the provider.
-                // persistence.sessionId is the single source of truth for session identity.
                 {
                     const previousSessionId = agent.persistence?.sessionId ?? null;
                     const handle = agent.session.describePersistence();
@@ -1274,13 +1429,11 @@ export class AgentManager {
                             this.emitState(agent);
                         }
                     }
+                    void this.refreshRuntimeInfo(agent);
                 }
                 break;
             case "timeline":
                 // Skip provider-replayed user_message items during history hydration.
-                // These are already canonically recorded by recordUserMessage() and replaying them would
-                // create duplicates. Match by messageId (not text) to avoid dropping legitimate
-                // provider-origin messages that happen to reuse the same text.
                 if (options?.fromHistory && event.item.type === "user_message") {
                     const eventMessageId = normalizeMessageId(event.item.messageId);
                     if (eventMessageId) {
@@ -1290,8 +1443,25 @@ export class AgentManager {
                         }
                     }
                 }
-                if (this.shouldSuppressLiveUserMessageEcho(agent, event, options)) {
-                    break;
+                // Suppress user_message echoes for the active foreground turn —
+                // these are already recorded by recordUserMessage().
+                if (!options?.fromHistory &&
+                    event.item.type === "user_message" &&
+                    isForegroundEvent) {
+                    const eventMessageId = normalizeMessageId(event.item.messageId);
+                    const eventText = event.item.text;
+                    if (eventMessageId) {
+                        const alreadyRecorded = agent.timelineRows.some((row) => {
+                            if (row.item.type !== "user_message") {
+                                return false;
+                            }
+                            const rowMessageId = normalizeMessageId(row.item.messageId);
+                            return rowMessageId === eventMessageId && row.item.text === eventText;
+                        });
+                        if (alreadyRecorded) {
+                            break;
+                        }
+                    }
                 }
                 timelineRow = this.recordTimeline(agent, event.item);
                 if (!options?.fromHistory && event.item.type === "user_message") {
@@ -1303,18 +1473,33 @@ export class AgentManager {
                 this.logger.trace({
                     agentId: agent.id,
                     lifecycle: agent.lifecycle,
-                    hasPendingRun: Boolean(agent.pendingRun),
+                    activeForegroundTurnId: agent.activeForegroundTurnId,
+                    eventTurnId,
                 }, "handleStreamEvent: turn_completed");
                 agent.lastUsage = event.usage;
                 agent.lastError = undefined;
-                if (!agent.pendingRun && agent.lifecycle !== "idle") {
+                // For autonomous turns (not foreground), transition to idle
+                // unless a replacement is pending (avoid idle flash during replace)
+                if (!isForegroundEvent && agent.lifecycle !== "idle" && !agent.pendingReplacement) {
                     agent.lifecycle = "idle";
                     this.emitState(agent);
                 }
                 void this.refreshRuntimeInfo(agent);
                 break;
             case "turn_failed":
-                agent.lifecycle = "error";
+                this.logger.trace({
+                    agentId: agent.id,
+                    lifecycle: agent.lifecycle,
+                    activeForegroundTurnId: agent.activeForegroundTurnId,
+                    eventTurnId,
+                    error: event.error,
+                    code: event.code,
+                    diagnostic: event.diagnostic,
+                }, "handleStreamEvent: turn_failed");
+                // For autonomous turns, set error state directly
+                if (!isForegroundEvent) {
+                    agent.lifecycle = "error";
+                }
                 agent.lastError = event.error;
                 this.appendSystemErrorTimelineMessage(agent, event.provider, this.formatTurnFailedMessage(event), options);
                 for (const [requestId] of agent.pendingPermissions) {
@@ -1328,15 +1513,20 @@ export class AgentManager {
                         });
                     }
                 }
-                this.emitState(agent);
+                if (!isForegroundEvent) {
+                    this.emitState(agent);
+                }
                 break;
             case "turn_canceled":
                 this.logger.trace({
                     agentId: agent.id,
                     lifecycle: agent.lifecycle,
-                    hasPendingRun: Boolean(agent.pendingRun),
+                    activeForegroundTurnId: agent.activeForegroundTurnId,
+                    eventTurnId,
                 }, "handleStreamEvent: turn_canceled");
-                if (!agent.pendingRun) {
+                // For autonomous turns, transition to idle
+                // unless a replacement is pending (avoid idle flash during replace)
+                if (!isForegroundEvent && !agent.pendingReplacement) {
                     agent.lifecycle = "idle";
                 }
                 agent.lastError = undefined;
@@ -1351,15 +1541,19 @@ export class AgentManager {
                         });
                     }
                 }
-                this.emitState(agent);
+                if (!isForegroundEvent) {
+                    this.emitState(agent);
+                }
                 break;
             case "turn_started":
                 this.logger.trace({
                     agentId: agent.id,
                     lifecycle: agent.lifecycle,
-                    hasPendingRun: Boolean(agent.pendingRun),
+                    activeForegroundTurnId: agent.activeForegroundTurnId,
+                    eventTurnId,
                 }, "handleStreamEvent: turn_started");
-                if (!agent.pendingRun) {
+                // For autonomous turn_started (no foreground match), set running
+                if (!isForegroundEvent) {
                     agent.lifecycle = "running";
                     this.emitState(agent);
                 }
@@ -1381,6 +1575,9 @@ export class AgentManager {
             default:
                 break;
         }
+        if (!options?.fromHistory && isForegroundEvent && isTurnTerminalEvent(event)) {
+            this.finalizeForegroundTurn(agent);
+        }
         // Skip dispatching individual stream events during history replay.
         if (!options?.fromHistory) {
             this.dispatchStream(agent.id, event, timelineRow
@@ -1428,27 +1625,6 @@ export class AgentManager {
         }
         return parts.join("\n\n");
     }
-    shouldSuppressLiveUserMessageEcho(agent, event, options) {
-        if (options?.fromHistory || event.type !== "timeline") {
-            return false;
-        }
-        if (event.item.type !== "user_message" || !agent.pendingRun) {
-            return false;
-        }
-        const eventMessageId = normalizeMessageId(event.item.messageId);
-        const eventText = event.item.text;
-        if (!eventMessageId) {
-            return false;
-        }
-        return agent.timelineRows.some((row) => {
-            const rowItem = row.item;
-            if (rowItem.type !== "user_message") {
-                return false;
-            }
-            const rowMessageId = normalizeMessageId(rowItem.messageId);
-            return rowMessageId === eventMessageId && rowItem.text === eventText;
-        });
-    }
     recordTimeline(agent, item) {
         const timelineState = this.ensureTimelineState(agent);
         const row = {
@@ -1571,7 +1747,7 @@ export class AgentManager {
             subscriber.callback(event);
         }
     }
-    async normalizeConfig(config, _options) {
+    async normalizeConfig(config) {
         const normalized = { ...config };
         // Always resolve cwd to absolute path for consistent history file lookup
         if (normalized.cwd) {
@@ -1596,11 +1772,17 @@ export class AgentManager {
         }
         if (typeof normalized.model === "string") {
             const trimmed = normalized.model.trim();
-            const normalizedId = trimmed.toLowerCase();
-            normalized.model = trimmed.length > 0 && normalizedId !== "default" ? trimmed : undefined;
+            normalized.model = trimmed.length > 0 ? trimmed : undefined;
         }
         return normalized;
     }
+    buildLaunchContext(agentId) {
+        return {
+            env: {
+                PASEO_AGENT_ID: agentId,
+            },
+        };
+    }
     requireClient(provider) {
         const client = this.clients.get(provider);
         if (!client) {
@@ -1616,141 +1798,5 @@ export class AgentManager {
         }
         return agent;
     }
-    startLiveEventPump(agent) {
-        if (!supportsLiveEventStream(agent.session)) {
-            return;
-        }
-        if (this.liveEventPumps.has(agent.id)) {
-            return;
-        }
-        const pump = (async () => {
-            while (true) {
-                const current = this.agents.get(agent.id);
-                if (!current) {
-                    return;
-                }
-                if (!supportsLiveEventStream(current.session)) {
-                    return;
-                }
-                try {
-                    for await (const event of current.session.streamLiveEvents()) {
-                        const latest = this.agents.get(agent.id);
-                        if (!latest) {
-                            return;
-                        }
-                        // Keep consuming provider events even during an active foreground run,
-                        // then replay them immediately once that run settles.
-                        if (latest.pendingRun) {
-                            this.logger.trace({
-                                agentId: latest.id,
-                                eventType: event.type,
-                                backlogSize: (this.liveEventBacklog.get(latest.id)?.length ?? 0) + 1,
-                            }, "Live event pump: queued event because pendingRun is active");
-                            this.enqueueLiveEvent(latest.id, event);
-                            continue;
-                        }
-                        this.flushLiveEventBacklog(latest);
-                        this.handleStreamEvent(latest, event);
-                    }
-                    this.logger.warn({ agentId: agent.id }, "Live event pump stream ended; restarting");
-                }
-                catch (error) {
-                    this.logger.warn({ err: error, agentId: agent.id }, "Live event pump failed");
-                }
-                // Keep pump alive unless the agent is gone.
-                await new Promise((resolve) => setTimeout(resolve, 250));
-                const latest = this.agents.get(agent.id);
-                if (!latest) {
-                    return;
-                }
-                if (!latest.pendingRun) {
-                    this.flushLiveEventBacklog(latest);
-                }
-            }
-        })();
-        this.liveEventPumps.set(agent.id, pump);
-        pump.finally(() => {
-            const current = this.liveEventPumps.get(agent.id);
-            if (current === pump) {
-                this.liveEventPumps.delete(agent.id);
-            }
-        });
-    }
-    enqueueLiveEvent(agentId, event) {
-        const existing = this.liveEventBacklog.get(agentId);
-        if (existing) {
-            existing.push(event);
-            return;
-        }
-        this.liveEventBacklog.set(agentId, [event]);
-    }
-    clearLiveEventBacklogFlushTimer(agentId) {
-        const timer = this.liveEventBacklogFlushTimers.get(agentId);
-        if (!timer) {
-            return;
-        }
-        clearTimeout(timer);
-        this.liveEventBacklogFlushTimers.delete(agentId);
-    }
-    scheduleLiveEventBacklogFlush(agentId, delayMs) {
-        if (this.liveEventBacklogFlushTimers.has(agentId)) {
-            return;
-        }
-        const timer = setTimeout(() => {
-            this.liveEventBacklogFlushTimers.delete(agentId);
-            const latest = this.agents.get(agentId);
-            if (!latest) {
-                return;
-            }
-            if (latest.pendingRun) {
-                this.scheduleLiveEventBacklogFlush(agentId, LIVE_BACKLOG_TERMINAL_REPLAY_DELAY_MS);
-                return;
-            }
-            this.flushLiveEventBacklog(latest);
-        }, delayMs);
-        this.liveEventBacklogFlushTimers.set(agentId, timer);
-    }
-    flushLiveEventBacklog(agent) {
-        if (agent.pendingRun) {
-            return;
-        }
-        const pending = this.liveEventBacklog.get(agent.id);
-        if (!pending || pending.length === 0) {
-            return;
-        }
-        this.clearLiveEventBacklogFlushTimer(agent.id);
-        this.liveEventBacklog.delete(agent.id);
-        const immediate = [];
-        const deferred = [];
-        let sawTurnStarted = false;
-        let deferRemainder = false;
-        for (const event of pending) {
-            if (!deferRemainder && sawTurnStarted && isTurnTerminalEvent(event)) {
-                deferRemainder = true;
-            }
-            if (deferRemainder) {
-                deferred.push(event);
-                continue;
-            }
-            immediate.push(event);
-            if (event.type === "turn_started") {
-                sawTurnStarted = true;
-            }
-        }
-        for (const event of immediate) {
-            this.handleStreamEvent(agent, event);
-        }
-        if (deferred.length === 0) {
-            return;
-        }
-        const existing = this.liveEventBacklog.get(agent.id);
-        if (existing && existing.length > 0) {
-            this.liveEventBacklog.set(agent.id, [...deferred, ...existing]);
-        }
-        else {
-            this.liveEventBacklog.set(agent.id, deferred);
-        }
-        this.scheduleLiveEventBacklogFlush(agent.id, LIVE_BACKLOG_TERMINAL_REPLAY_DELAY_MS);
-    }
 }
 //# sourceMappingURL=agent-manager.js.map