@getpaseo/server 0.1.59 → 0.1.61

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

@@ -3,7 +3,11 @@ import { resolve } from "node:path";
 import { stat } from "node:fs/promises";
 import { AGENT_LIFECYCLE_STATUSES, } from "../../shared/agent-lifecycle.js";
 import { z } from "zod";
+import { InMemoryAgentTimelineStore, } from "./agent-timeline-store.js";
+import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS, AgentStreamCoalescer, } from "./agent-stream-coalescer.js";
 import { getAgentProviderDefinition } from "./provider-manifest.js";
+const RELOAD_SESSION_CLOSE_TIMEOUT_MS = 3000;
+const INTERRUPT_SESSION_TIMEOUT_MS = 2000;
 export { AGENT_LIFECYCLE_STATUSES };
 const SYSTEM_ERROR_PREFIX = "[System Error]";
 function attachPersistenceCwd(handle, cwd) {
@@ -18,7 +22,6 @@ function attachPersistenceCwd(handle, cwd) {
         },
     };
 }
-const DEFAULT_TIMELINE_FETCH_LIMIT = 200;
 const BUSY_STATUSES = ["initializing", "running"];
 const AgentIdSchema = z.string().uuid();
 function isAgentBusy(status) {
@@ -56,22 +59,31 @@ export class AgentManager {
     constructor(options) {
         this.clients = new Map();
         this.agents = new Map();
+        this.timelineStore = new InMemoryAgentTimelineStore();
+        this.agentsAwaitingInitialSnapshotPersist = new Set();
+        this.sessionEventTails = new Map();
         this.pendingForegroundRuns = new Map();
         this.subscribers = new Set();
         this.previousStatuses = new Map();
         this.backgroundTasks = new Set();
-        const maxTimelineItems = options?.maxTimelineItems;
-        this.maxTimelineItems =
-            typeof maxTimelineItems === "number" &&
-                Number.isFinite(maxTimelineItems) &&
-                maxTimelineItems >= 0
-                ? Math.floor(maxTimelineItems)
-                : null;
         this.idFactory = options?.idFactory ?? (() => randomUUID());
         this.registry = options?.registry;
+        this.durableTimelineStore = options?.durableTimelineStore;
         this.onAgentAttention = options?.onAgentAttention;
         this.mcpBaseUrl = options?.mcpBaseUrl ?? null;
         this.logger = options.logger.child({ module: "agent", component: "agent-manager" });
+        this.rescueTimeouts = {
+            reloadSessionCloseMs: options.rescueTimeouts?.reloadSessionCloseMs ?? RELOAD_SESSION_CLOSE_TIMEOUT_MS,
+            interruptSessionMs: options.rescueTimeouts?.interruptSessionMs ?? INTERRUPT_SESSION_TIMEOUT_MS,
+        };
+        this.agentStreamCoalescer = new AgentStreamCoalescer({
+            windowMs: options.agentStreamCoalesceWindowMs ?? AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS,
+            timers: { setTimeout, clearTimeout },
+            onFlush: ({ agentId, item, provider, turnId }) => {
+                const event = this.recordAndDispatchTimelineItem(agentId, item, provider, turnId);
+                this.notifyForegroundTurnWaiters(agentId, event);
+            },
+        });
         if (options?.clients) {
             for (const [provider, client] of Object.entries(options.clients)) {
                 if (client) {
@@ -102,7 +114,10 @@ export class AgentManager {
             if (agent.activeForegroundTurnId !== null) {
                 withActiveForegroundTurn++;
             }
-            const len = agent.timeline.length;
+            if (!this.timelineStore.has(agent.id)) {
+                continue;
+            }
+            const len = this.timelineStore.getItems(agent.id).length;
             totalItems += len;
             if (len > maxItemsPerAgent) {
                 maxItemsPerAgent = len;
@@ -282,130 +297,19 @@ export class AgentManager {
         return agent ? { ...agent } : null;
     }
     getTimeline(id) {
-        const agent = this.requireAgent(id);
-        return [...agent.timeline];
+        this.requireAgent(id);
+        return this.timelineStore.getItems(id);
     }
-    getTimelineRows(id) {
-        const agent = this.requireAgent(id);
-        const { rows } = this.ensureTimelineState(agent);
-        return rows.map((row) => ({ ...row }));
+    async getTimelineRows(id) {
+        this.requireAgent(id);
+        if (this.durableTimelineStore) {
+            return await this.durableTimelineStore.getCommittedRows(id);
+        }
+        return this.timelineStore.getRows(id);
     }
     fetchTimeline(id, options) {
-        const agent = this.requireAgent(id);
-        const { rows, epoch, nextSeq, minSeq, maxSeq } = this.ensureTimelineState(agent);
-        const direction = options?.direction ?? "tail";
-        const requestedLimit = options?.limit;
-        const limit = requestedLimit === undefined
-            ? DEFAULT_TIMELINE_FETCH_LIMIT
-            : Math.max(0, Math.floor(requestedLimit));
-        const cursor = options?.cursor;
-        const window = { minSeq, maxSeq, nextSeq };
-        if (cursor && cursor.epoch !== epoch) {
-            return {
-                epoch,
-                direction,
-                reset: true,
-                staleCursor: true,
-                gap: false,
-                window,
-                hasOlder: false,
-                hasNewer: false,
-                rows: rows.map((row) => ({ ...row })),
-            };
-        }
-        const selectAll = limit === 0;
-        const cloneRows = (items) => items.map((row) => ({ ...row }));
-        if (direction === "after" && cursor && rows.length > 0 && cursor.seq < minSeq - 1) {
-            return {
-                epoch,
-                direction,
-                reset: true,
-                staleCursor: false,
-                gap: true,
-                window,
-                hasOlder: false,
-                hasNewer: false,
-                rows: cloneRows(rows),
-            };
-        }
-        if (rows.length === 0) {
-            return {
-                epoch,
-                direction,
-                reset: false,
-                staleCursor: false,
-                gap: false,
-                window,
-                hasOlder: false,
-                hasNewer: false,
-                rows: [],
-            };
-        }
-        if (direction === "tail") {
-            const selected = selectAll || limit >= rows.length ? rows : rows.slice(rows.length - limit);
-            const hasOlder = selected.length > 0 && selected[0].seq > minSeq;
-            return {
-                epoch,
-                direction,
-                reset: false,
-                staleCursor: false,
-                gap: false,
-                window,
-                hasOlder,
-                hasNewer: false,
-                rows: cloneRows(selected),
-            };
-        }
-        if (direction === "after") {
-            const baseSeq = cursor?.seq ?? 0;
-            const startIdx = rows.findIndex((row) => row.seq > baseSeq);
-            if (startIdx < 0) {
-                return {
-                    epoch,
-                    direction,
-                    reset: false,
-                    staleCursor: false,
-                    gap: false,
-                    window,
-                    hasOlder: baseSeq >= minSeq,
-                    hasNewer: false,
-                    rows: [],
-                };
-            }
-            const selected = selectAll ? rows.slice(startIdx) : rows.slice(startIdx, startIdx + limit);
-            const lastSelected = selected[selected.length - 1];
-            return {
-                epoch,
-                direction,
-                reset: false,
-                staleCursor: false,
-                gap: false,
-                window,
-                hasOlder: selected[0].seq > minSeq,
-                hasNewer: Boolean(lastSelected && lastSelected.seq < maxSeq),
-                rows: cloneRows(selected),
-            };
-        }
-        // direction === "before"
-        const beforeSeq = cursor?.seq ?? nextSeq;
-        const endExclusive = rows.findIndex((row) => row.seq >= beforeSeq);
-        const boundedRows = endExclusive < 0 ? rows : rows.slice(0, endExclusive);
-        const selected = selectAll || limit >= boundedRows.length
-            ? boundedRows
-            : boundedRows.slice(boundedRows.length - limit);
-        const hasOlder = selected.length > 0 && selected[0].seq > minSeq;
-        const hasNewer = endExclusive >= 0;
-        return {
-            epoch,
-            direction,
-            reset: false,
-            staleCursor: false,
-            gap: false,
-            window,
-            hasOlder,
-            hasNewer,
-            rows: cloneRows(selected),
-        };
+        this.requireAgent(id);
+        return this.timelineStore.fetch(id, options);
     }
     async createAgent(config, agentId, options) {
         const resolvedAgentId = validateAgentId(agentId ?? this.idFactory(), "createAgent");
@@ -431,6 +335,7 @@ export class AgentManager {
         const session = await client.createSession(normalizedConfig, launchContext);
         return this.registerSession(session, normalizedConfig, resolvedAgentId, {
             labels: options?.labels,
+            workspaceId: options?.workspaceId,
         });
     }
     // Reconstruct an agent from provider persistence. Callers should explicitly
@@ -459,16 +364,11 @@ export class AgentManager {
     // Hot-reload an active agent session with config overrides while preserving
     // in-memory timeline state.
     async reloadAgentSession(agentId, overrides) {
-        let existing = this.requireAgent(agentId);
+        let existing = this.requireSessionAgent(agentId);
         if (this.hasInFlightRun(agentId)) {
             await this.cancelAgentRun(agentId);
-            existing = this.requireAgent(agentId);
+            existing = this.requireSessionAgent(agentId);
         }
-        const timelineState = this.ensureTimelineState(existing);
-        const preservedTimeline = [...existing.timeline];
-        const preservedTimelineRows = timelineState.rows.map((row) => ({ ...row }));
-        const preservedTimelineEpoch = timelineState.epoch;
-        const preservedTimelineNextSeq = timelineState.nextSeq;
         const preservedHistoryPrimed = existing.historyPrimed;
         const preservedLastUsage = existing.lastUsage;
         const preservedLastError = existing.lastError;
@@ -486,6 +386,7 @@ export class AgentManager {
         const session = handle
             ? await client.resumeSession(handle, normalizedConfig, launchContext)
             : await client.createSession(normalizedConfig, launchContext);
+        this.agentStreamCoalescer.flushAndDiscard(agentId);
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
         if (existing.unsubscribeSession) {
@@ -497,28 +398,65 @@ export class AgentManager {
         }
         existing.foregroundTurnWaiters.clear();
         this.settlePendingForegroundRun(agentId);
-        try {
-            await existing.session.close();
-        }
-        catch (error) {
-            this.logger.warn({ err: error, agentId }, "Failed to close previous session during refresh");
-        }
+        await this.closeReloadedSession(existing.session, agentId);
         // Preserve existing labels and timeline during reload.
         return this.registerSession(session, normalizedConfig, agentId, {
             labels: existing.labels,
             createdAt: existing.createdAt,
             updatedAt: existing.updatedAt,
             lastUserMessageAt: existing.lastUserMessageAt,
-            timeline: preservedTimeline,
-            timelineRows: preservedTimelineRows,
-            timelineEpoch: preservedTimelineEpoch,
-            timelineNextSeq: preservedTimelineNextSeq,
             historyPrimed: preservedHistoryPrimed,
             lastUsage: preservedLastUsage,
             lastError: preservedLastError,
             attention: preservedAttention,
         });
     }
+    async closeReloadedSession(session, agentId) {
+        try {
+            const result = await this.waitWithTimeout({
+                operation: session.close(),
+                timeoutMs: this.rescueTimeouts.reloadSessionCloseMs,
+                onLateError: (error) => {
+                    this.logger.warn({ err: error, agentId }, "Previous session close failed after refresh timeout");
+                },
+            });
+            if (result === "timed_out") {
+                this.logger.warn({ agentId, timeoutMs: this.rescueTimeouts.reloadSessionCloseMs }, "Timed out closing previous session during refresh");
+            }
+        }
+        catch (error) {
+            this.logger.warn({ err: error, agentId }, "Failed to close previous session during refresh");
+        }
+    }
+    async waitWithTimeout(options) {
+        let didTimeOut = false;
+        let timer = null;
+        const operation = options.operation
+            .then(() => "completed")
+            .catch((error) => {
+            if (didTimeOut) {
+                options.onLateError?.(error);
+                return "timed_out";
+            }
+            throw error;
+        });
+        try {
+            return await Promise.race([
+                operation,
+                new Promise((resolve) => {
+                    timer = setTimeout(() => {
+                        didTimeOut = true;
+                        resolve("timed_out");
+                    }, options.timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+    }
     async closeAgent(agentId) {
         const agent = this.requireAgent(agentId);
         this.logger.trace({
@@ -527,34 +465,11 @@ export class AgentManager {
             activeForegroundTurnId: agent.activeForegroundTurnId,
             pendingPermissions: agent.pendingPermissions.size,
         }, "closeAgent: start");
-        this.agents.delete(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,
-            activeForegroundTurnId: null,
-        };
-        await session.close();
-        this.emitState(closedAgent);
+        const closedAgent = this.prepareAgentForClosure(agent, "agent closed");
+        await agent.session.close();
+        this.timelineStore.delete(agentId);
+        await this.persistSnapshot(closedAgent);
+        this.emitClosedAgent(closedAgent, { persist: false });
         this.logger.trace({ agentId }, "closeAgent: completed");
     }
     async archiveAgent(agentId) {
@@ -587,7 +502,7 @@ export class AgentManager {
         return { archivedAt };
     }
     async setAgentMode(agentId, modeId) {
-        const agent = this.requireAgent(agentId);
+        const agent = this.requireSessionAgent(agentId);
         await agent.session.setMode(modeId);
         agent.config.modeId = modeId;
         agent.currentModeId = modeId;
@@ -599,7 +514,7 @@ export class AgentManager {
         this.emitState(agent);
     }
     async setAgentModel(agentId, modelId) {
-        const agent = this.requireAgent(agentId);
+        const agent = this.requireSessionAgent(agentId);
         const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
         if (agent.session.setModel) {
             await agent.session.setModel(normalizedModelId);
@@ -612,7 +527,7 @@ export class AgentManager {
         this.emitState(agent);
     }
     async setAgentThinkingOption(agentId, thinkingOptionId) {
-        const agent = this.requireAgent(agentId);
+        const agent = this.requireSessionAgent(agentId);
         const normalizedThinkingOptionId = typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0
             ? thinkingOptionId
             : null;
@@ -620,6 +535,12 @@ export class AgentManager {
             await agent.session.setThinkingOption(normalizedThinkingOptionId);
         }
         agent.config.thinkingOptionId = normalizedThinkingOptionId ?? undefined;
+        if (agent.runtimeInfo) {
+            agent.runtimeInfo = {
+                ...agent.runtimeInfo,
+                thinkingOptionId: normalizedThinkingOptionId,
+            };
+        }
         this.touchUpdatedAt(agent);
         this.emitState(agent);
     }
@@ -639,16 +560,21 @@ export class AgentManager {
         if (!normalizedTitle) {
             return;
         }
+        if (this.agentsAwaitingInitialSnapshotPersist.has(agent.id) &&
+            this.registry &&
+            (await this.registry.get(agent.id)) === null) {
+            return;
+        }
         this.touchUpdatedAt(agent);
         await this.persistSnapshot(agent, { title: normalizedTitle });
-        this.emitState(agent);
+        this.emitState(agent, { persist: false });
     }
     async setLabels(agentId, labels) {
         const agent = this.requireAgent(agentId);
         agent.labels = { ...agent.labels, ...labels };
-        await this.persistSnapshot(agent);
         this.touchUpdatedAt(agent);
-        this.emitState(agent);
+        await this.persistSnapshot(agent);
+        this.emitState(agent, { persist: false });
     }
     notifyAgentState(agentId) {
         const agent = this.agents.get(agentId);
@@ -663,8 +589,81 @@ export class AgentManager {
         if (agent.attention.requiresAttention) {
             agent.attention = { requiresAttention: false };
             await this.persistSnapshot(agent);
-            this.emitState(agent);
+            this.emitState(agent, { persist: false });
+        }
+    }
+    async archiveSnapshot(agentId, archivedAt) {
+        const registry = this.requireRegistry();
+        const liveAgent = this.getAgent(agentId);
+        if (liveAgent) {
+            await this.persistSnapshot(liveAgent, {
+                internal: liveAgent.internal,
+            });
+        }
+        const record = await registry.get(agentId);
+        if (!record) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        const normalizedStatus = record.lastStatus === "running" || record.lastStatus === "initializing"
+            ? "idle"
+            : record.lastStatus;
+        const nextRecord = {
+            ...record,
+            archivedAt,
+            lastStatus: normalizedStatus,
+            requiresAttention: false,
+            attentionReason: null,
+            attentionTimestamp: null,
+        };
+        await registry.upsert(nextRecord);
+        return nextRecord;
+    }
+    async unarchiveSnapshot(agentId) {
+        const registry = this.requireRegistry();
+        const record = await registry.get(agentId);
+        if (!record || !record.archivedAt) {
+            return false;
+        }
+        await registry.upsert({
+            ...record,
+            archivedAt: null,
+        });
+        if (this.getAgent(agentId)) {
+            this.notifyAgentState(agentId);
+        }
+        return true;
+    }
+    async unarchiveSnapshotByHandle(handle) {
+        const registry = this.requireRegistry();
+        const records = await registry.list();
+        const matched = records.find((record) => record.persistence?.provider === handle.provider &&
+            record.persistence?.sessionId === handle.sessionId);
+        if (!matched) {
+            return;
         }
+        await this.unarchiveSnapshot(matched.id);
+    }
+    async updateAgentMetadata(agentId, updates) {
+        const liveAgent = this.getAgent(agentId);
+        if (liveAgent) {
+            if (updates.title) {
+                await this.setTitle(agentId, updates.title);
+            }
+            if (updates.labels) {
+                await this.setLabels(agentId, updates.labels);
+            }
+            return;
+        }
+        const registry = this.requireRegistry();
+        const existing = await registry.get(agentId);
+        if (!existing) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        await registry.upsert({
+            ...existing,
+            ...(updates.title ? { title: updates.title } : {}),
+            ...(updates.labels ? { labels: { ...existing.labels, ...updates.labels } } : {}),
+        });
     }
     async runAgent(agentId, prompt, options) {
         const events = this.streamAgent(agentId, prompt, options);
@@ -710,14 +709,14 @@ export class AgentManager {
         };
         const updatedAt = this.touchUpdatedAt(agent);
         agent.lastUserMessageAt = updatedAt;
-        const row = this.recordTimeline(agent, item);
+        const row = this.recordTimeline(agentId, item);
         this.dispatchStream(agentId, {
             type: "timeline",
             item,
             provider: agent.provider,
         }, {
             seq: row.seq,
-            epoch: this.ensureTimelineState(agent).epoch,
+            epoch: this.timelineStore.getEpoch(agentId),
         });
         if (options?.emitState !== false) {
             this.emitState(agent);
@@ -726,14 +725,14 @@ export class AgentManager {
     async appendTimelineItem(agentId, item) {
         const agent = this.requireAgent(agentId);
         this.touchUpdatedAt(agent);
-        const row = this.recordTimeline(agent, item);
+        const row = this.recordTimeline(agentId, item);
         this.dispatchStream(agentId, {
             type: "timeline",
             item,
             provider: agent.provider,
         }, {
             seq: row.seq,
-            epoch: this.ensureTimelineState(agent).epoch,
+            epoch: this.timelineStore.getEpoch(agentId),
         });
         await this.persistSnapshot(agent);
     }
@@ -747,7 +746,7 @@ export class AgentManager {
         });
     }
     streamAgent(agentId, prompt, options) {
-        const existingAgent = this.requireAgent(agentId);
+        const existingAgent = this.requireSessionAgent(agentId);
         this.logger.trace({
             agentId,
             lifecycle: existingAgent.lifecycle,
@@ -852,8 +851,11 @@ export class AgentManager {
         })();
         return streamForwarder;
     }
-    finalizeForegroundTurn(agent) {
+    finalizeForegroundTurn(agent, turnId) {
         const mutableAgent = agent;
+        if (turnId) {
+            this.rememberFinalizedForegroundTurn(mutableAgent, turnId);
+        }
         mutableAgent.activeForegroundTurnId = null;
         const terminalError = mutableAgent.lastError;
         const shouldHoldBusyForReplacement = mutableAgent.pendingReplacement && !terminalError;
@@ -887,8 +889,11 @@ export class AgentManager {
             !this.hasPendingForegroundRun(agentId)) {
             return this.streamAgent(agentId, prompt, options);
         }
-        const agent = snapshot;
+        const agent = this.requireSessionAgent(agentId);
         agent.pendingReplacement = true;
+        agent.lifecycle = "running";
+        this.touchUpdatedAt(agent);
+        this.emitState(agent);
         const self = this;
         return (async function* replaceRunForwarder() {
             try {
@@ -1026,7 +1031,7 @@ export class AgentManager {
         }
     }
     async cancelAgentRun(agentId) {
-        const agent = this.requireAgent(agentId);
+        const agent = this.requireSessionAgent(agentId);
         const pendingRun = this.getPendingForegroundRun(agentId);
         const foregroundTurnId = agent.activeForegroundTurnId;
         const hasForegroundTurn = Boolean(foregroundTurnId);
@@ -1034,12 +1039,7 @@ export class AgentManager {
         if (!hasForegroundTurn && !isAutonomousRunning && !pendingRun) {
             return false;
         }
-        try {
-            await agent.session.interrupt();
-        }
-        catch (error) {
-            this.logger.error({ err: error, agentId }, "Failed to interrupt session");
-        }
+        await this.interruptSession(agent.session, agentId);
         // 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.
@@ -1110,28 +1110,60 @@ export class AgentManager {
         }
         return true;
     }
+    async interruptSession(session, agentId) {
+        try {
+            const result = await this.waitWithTimeout({
+                operation: session.interrupt(),
+                timeoutMs: this.rescueTimeouts.interruptSessionMs,
+                onLateError: (error) => {
+                    this.logger.warn({ err: error, agentId }, "Session interrupt failed after timeout during cancel");
+                },
+            });
+            if (result === "timed_out") {
+                this.logger.warn({ agentId, timeoutMs: this.rescueTimeouts.interruptSessionMs }, "Timed out interrupting session during cancel");
+            }
+        }
+        catch (error) {
+            this.logger.error({ err: error, agentId }, "Failed to interrupt session");
+        }
+    }
     getPendingPermissions(agentId) {
-        const agent = this.requireAgent(agentId);
+        const agent = this.requireSessionAgent(agentId);
         return Array.from(agent.pendingPermissions.values());
     }
     peekPendingPermission(agent) {
         const iterator = agent.pendingPermissions.values().next();
         return iterator.done ? null : iterator.value;
     }
+    /**
+     * Hydrates the timeline from provider history if the agent's durable
+     * timeline is empty (e.g., imported agents that have provider history
+     * on disk but no persisted timeline rows). No-ops if already hydrated.
+     */
     async hydrateTimelineFromProvider(agentId) {
-        const agent = this.requireAgent(agentId);
-        await this.hydrateTimeline(agent);
+        const agent = this.requireSessionAgent(agentId);
+        await this.hydrateTimelineFromLegacyProviderHistory(agent);
     }
-    getLastAssistantMessage(agentId) {
+    async deleteCommittedTimeline(agentId) {
+        if (!this.durableTimelineStore) {
+            return;
+        }
+        await this.durableTimelineStore.deleteAgent(agentId);
+    }
+    async getLastAssistantMessage(agentId) {
         const agent = this.agents.get(agentId);
         if (!agent) {
             return null;
         }
-        return this.getLastAssistantMessageFromTimeline(agent.timeline);
+        return await this.getLastAssistantMessageFromStores(agentId);
     }
     getLastAssistantMessageFromTimeline(timeline) {
+        return this.getLastAssistantMessageSegmentFromTimeline(timeline)?.text ?? null;
+    }
+    getLastAssistantMessageSegmentFromTimeline(timeline) {
         // Collect the last contiguous assistant messages (Claude streams chunks)
         const chunks = [];
+        let startsAtBeginning = false;
         for (let i = timeline.length - 1; i >= 0; i--) {
             const item = timeline[i];
             if (item.type !== "assistant_message") {
@@ -1141,11 +1173,53 @@ export class AgentManager {
                 continue;
             }
             chunks.push(item.text);
+            startsAtBeginning = i === 0;
         }
         if (!chunks.length) {
             return null;
         }
-        return chunks.reverse().join("");
+        return {
+            text: chunks.reverse().join(""),
+            startsAtBeginning,
+        };
+    }
+    async getLastAssistantMessageFromStores(agentId) {
+        const liveTimeline = this.timelineStore.getItems(agentId);
+        const liveSegment = this.getLastAssistantMessageSegmentFromTimeline(liveTimeline);
+        if (!this.durableTimelineStore) {
+            return liveSegment?.text ?? null;
+        }
+        if (!liveSegment) {
+            return await this.durableTimelineStore.getLastAssistantMessage(agentId);
+        }
+        if (!liveSegment.startsAtBeginning) {
+            return liveSegment.text;
+        }
+        const lastDurableItem = await this.durableTimelineStore.getLastItem(agentId);
+        if (lastDurableItem?.type !== "assistant_message") {
+            return liveSegment.text;
+        }
+        const durableMessage = await this.durableTimelineStore.getLastAssistantMessage(agentId);
+        return durableMessage ? `${durableMessage}${liveSegment.text}` : liveSegment.text;
+    }
+    async getLastItemFromStores(agentId) {
+        const lastLiveItem = this.timelineStore.getLastItem(agentId);
+        if (lastLiveItem) {
+            return lastLiveItem;
+        }
+        if (!this.durableTimelineStore) {
+            return null;
+        }
+        return await this.durableTimelineStore.getLastItem(agentId);
+    }
+    async hasCommittedUserMessageFromStores(agentId, options) {
+        if (this.timelineStore.hasCommittedUserMessage(agentId, options)) {
+            return true;
+        }
+        if (!this.durableTimelineStore) {
+            return false;
+        }
+        return await this.durableTimelineStore.hasCommittedUserMessage(agentId, options);
     }
     async waitForAgentEvent(agentId, options) {
         const snapshot = this.getAgent(agentId);
@@ -1159,7 +1233,7 @@ export class AgentManager {
             return {
                 status: snapshot.lifecycle,
                 permission: immediatePermission,
-                lastMessage: this.getLastAssistantMessage(agentId),
+                lastMessage: await this.getLastAssistantMessage(agentId),
             };
         }
         const initialStatus = snapshot.lifecycle;
@@ -1169,14 +1243,14 @@ export class AgentManager {
             return {
                 status: initialStatus,
                 permission: null,
-                lastMessage: this.getLastAssistantMessage(agentId),
+                lastMessage: await this.getLastAssistantMessage(agentId),
             };
         }
         if (waitForActive && !initialBusy && !hasForegroundTurn) {
             return {
                 status: initialStatus,
                 permission: null,
-                lastMessage: this.getLastAssistantMessage(agentId),
+                lastMessage: await this.getLastAssistantMessage(agentId),
             };
         }
         if (options?.signal?.aborted) {
@@ -1194,6 +1268,7 @@ export class AgentManager {
                 Boolean(snapshot.activeForegroundTurnId) ||
                 Boolean(pendingForegroundRun?.started);
             let terminalStatusOverride = null;
+            let finished = false;
             // Bug #3 Fix: Declare unsubscribe and abortHandler upfront so cleanup can reference them
             let unsubscribe = null;
             let abortHandler = null;
@@ -1220,12 +1295,20 @@ export class AgentManager {
                 }
             };
             const finish = (permission) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
                 cleanup();
-                resolve({
-                    status: currentStatus,
-                    permission,
-                    lastMessage: this.getLastAssistantMessage(agentId),
-                });
+                void this.getLastAssistantMessage(agentId)
+                    .then((lastMessage) => {
+                    resolve({
+                        status: currentStatus,
+                        permission,
+                        lastMessage,
+                    });
+                })
+                    .catch(reject);
             };
             // Bug #3 Fix: Set up abort handler BEFORE subscription
             // to ensure cleanup handlers exist before callback can fire
@@ -1285,14 +1368,30 @@ export class AgentManager {
         }
         const initialPersistedTitle = await this.resolveInitialPersistedTitle(resolvedAgentId, config);
         const now = new Date();
-        const initialTimeline = options?.timeline ? [...options.timeline] : [];
-        const initialTimelineRows = options?.timelineRows?.length
-            ? options.timelineRows.map((row) => ({ ...row }))
-            : this.buildTimelineRowsFromItems(initialTimeline, options?.timelineNextSeq ?? 1, (options?.updatedAt ?? options?.createdAt ?? now).toISOString());
-        const derivedNextSeq = options?.timelineNextSeq ??
-            (initialTimelineRows.length
-                ? initialTimelineRows[initialTimelineRows.length - 1].seq + 1
-                : 1);
+        const explicitTimelineSeed = options?.timeline?.length ||
+            options?.timelineRows?.length ||
+            options?.timelineNextSeq !== undefined
+            ? {
+                items: options?.timeline,
+                rows: options?.timelineRows,
+                nextSeq: options?.timelineNextSeq,
+                timestamp: (options?.updatedAt ?? options?.createdAt ?? now).toISOString(),
+            }
+            : null;
+        const shouldSeedFromDurable = !explicitTimelineSeed &&
+            !this.timelineStore.has(resolvedAgentId) &&
+            this.durableTimelineStore !== undefined;
+        const durableTimelineSeed = shouldSeedFromDurable
+            ? await this.loadCommittedTimelineSeed(resolvedAgentId, now)
+            : null;
+        const durableTimelineHasRows = durableTimelineSeed != null && (durableTimelineSeed.nextSeq ?? 1) > 1;
+        const timelineSeed = explicitTimelineSeed ?? durableTimelineSeed;
+        if (timelineSeed || !this.timelineStore.has(resolvedAgentId)) {
+            this.timelineStore.initialize(resolvedAgentId, timelineSeed ?? { timestamp: now.toISOString() });
+        }
+        if (options?.timelineRows?.length) {
+            this.enqueueDurableTimelineBulkInsert(resolvedAgentId, options.timelineRows);
+        }
         const managed = {
             id: resolvedAgentId,
             provider: config.provider,
@@ -1312,13 +1411,10 @@ export class AgentManager {
             pendingReplacement: false,
             activeForegroundTurnId: null,
             foregroundTurnWaiters: new Set(),
+            finalizedForegroundTurnIds: new Set(),
             unsubscribeSession: null,
-            timeline: initialTimeline,
-            timelineRows: initialTimelineRows,
-            timelineEpoch: options?.timelineEpoch ?? randomUUID(),
-            timelineNextSeq: derivedNextSeq,
             persistence: attachPersistenceCwd(session.describePersistence(), config.cwd),
-            historyPrimed: options?.historyPrimed ?? false,
+            historyPrimed: options?.historyPrimed ?? durableTimelineHasRows,
             lastUserMessageAt: options?.lastUserMessageAt ?? null,
             lastUsage: options?.lastUsage,
             lastError: options?.lastError,
@@ -1339,36 +1435,99 @@ export class AgentManager {
         this.previousStatuses.set(resolvedAgentId, managed.lifecycle);
         await this.refreshRuntimeInfo(managed);
         await this.persistSnapshot(managed, {
+            workspaceId: options?.workspaceId,
             title: initialPersistedTitle,
         });
-        this.emitState(managed);
+        this.emitState(managed, { persist: false });
         await this.refreshSessionState(managed);
         managed.lifecycle = "idle";
-        await this.persistSnapshot(managed);
-        this.emitState(managed);
+        await this.persistSnapshot(managed, { workspaceId: options?.workspaceId });
+        this.emitState(managed, { persist: false });
         this.subscribeToSession(managed);
         return { ...managed };
     }
+    async loadCommittedTimelineSeed(agentId, now) {
+        if (!this.durableTimelineStore) {
+            return { timestamp: now.toISOString() };
+        }
+        return {
+            nextSeq: (await this.durableTimelineStore.getLatestCommittedSeq(agentId)) + 1,
+            timestamp: now.toISOString(),
+        };
+    }
+    prepareAgentForClosure(agent, cancelReason) {
+        this.agentStreamCoalescer.flushAndDiscard(agent.id);
+        this.agents.delete(agent.id);
+        this.previousStatuses.delete(agent.id);
+        if (agent.unsubscribeSession) {
+            agent.unsubscribeSession();
+            agent.unsubscribeSession = null;
+        }
+        for (const waiter of agent.foregroundTurnWaiters) {
+            waiter.callback({
+                type: "turn_canceled",
+                provider: agent.provider,
+                reason: cancelReason,
+                turnId: waiter.turnId,
+            });
+            this.settleForegroundTurnWaiter(waiter);
+        }
+        agent.foregroundTurnWaiters.clear();
+        this.settlePendingForegroundRun(agent.id);
+        return {
+            ...agent,
+            lifecycle: "closed",
+            session: null,
+            activeForegroundTurnId: null,
+        };
+    }
+    emitClosedAgent(agent, options) {
+        this.emitState(agent, options);
+    }
     subscribeToSession(agent) {
         if (agent.unsubscribeSession) {
             return;
         }
         const agentId = agent.id;
         const unsubscribe = agent.session.subscribe((event) => {
+            this.enqueueSessionEvent(agentId, event);
+        });
+        agent.unsubscribeSession = unsubscribe;
+    }
+    enqueueSessionEvent(agentId, event) {
+        const previous = this.sessionEventTails.get(agentId) ?? Promise.resolve();
+        const next = previous
+            .catch(() => undefined)
+            .then(async () => {
             const current = this.agents.get(agentId);
             if (!current) {
                 return;
             }
-            this.dispatchSessionEvent(current, event);
+            if (current.session == null) {
+                return;
+            }
+            await this.dispatchSessionEvent(current, event);
+        })
+            .catch((err) => {
+            this.logger.error({ err, agentId, eventType: event.type }, "Failed to process session event");
+        });
+        this.sessionEventTails.set(agentId, next);
+        this.trackBackgroundTask(next);
+        void next.finally(() => {
+            if (this.sessionEventTails.get(agentId) === next) {
+                this.sessionEventTails.delete(agentId);
+            }
         });
-        agent.unsubscribeSession = unsubscribe;
     }
-    dispatchSessionEvent(agent, event) {
+    async 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);
+        const shouldNotifyWaiters = await this.handleStreamEvent(agent, event);
+        if (!shouldNotifyWaiters) {
+            return;
+        }
         for (const waiter of matchingWaiters) {
             waiter.callback(event);
             if (isTurnTerminalEvent(event)) {
@@ -1383,6 +1542,16 @@ export class AgentManager {
         waiter.settled = true;
         waiter.resolveSettled();
     }
+    rememberFinalizedForegroundTurn(agent, turnId) {
+        agent.finalizedForegroundTurnIds.add(turnId);
+        if (agent.finalizedForegroundTurnIds.size <= 50) {
+            return;
+        }
+        const oldest = agent.finalizedForegroundTurnIds.values().next().value;
+        if (oldest) {
+            agent.finalizedForegroundTurnIds.delete(oldest);
+        }
+    }
     createPendingForegroundRun() {
         let resolveSettled;
         const settledPromise = new Promise((resolve) => {
@@ -1427,31 +1596,6 @@ export class AgentManager {
         }
         return null;
     }
-    buildTimelineRowsFromItems(items, startSeq, timestamp) {
-        let nextSeq = startSeq;
-        return items.map((item) => {
-            const row = {
-                seq: nextSeq,
-                timestamp,
-                item,
-            };
-            nextSeq += 1;
-            return row;
-        });
-    }
-    ensureTimelineState(agent) {
-        const minSeq = agent.timelineRows.length ? agent.timelineRows[0].seq : 0;
-        const maxSeq = agent.timelineRows.length
-            ? agent.timelineRows[agent.timelineRows.length - 1].seq
-            : 0;
-        return {
-            rows: agent.timelineRows,
-            epoch: agent.timelineEpoch,
-            nextSeq: agent.timelineNextSeq,
-            minSeq,
-            maxSeq,
-        };
-    }
     async persistSnapshot(agent, options) {
         if (!this.registry) {
             return;
@@ -1460,8 +1604,18 @@ export class AgentManager {
         if (agent.internal) {
             return;
         }
+        if (options?.workspaceId !== undefined) {
+            await this.registry.applySnapshot(agent, options.workspaceId, options);
+            return;
+        }
         await this.registry.applySnapshot(agent, options);
     }
+    requireRegistry() {
+        if (!this.registry) {
+            throw new Error("Agent storage unavailable");
+        }
+        return this.registry;
+    }
     async refreshSessionState(agent) {
         try {
             const modes = await agent.session.getAvailableModes();
@@ -1506,42 +1660,66 @@ export class AgentManager {
             // Keep existing runtimeInfo if refresh fails.
         }
     }
-    async hydrateTimeline(agent) {
+    async hydrateTimelineFromLegacyProviderHistory(agent) {
         if (agent.historyPrimed) {
             return;
         }
         agent.historyPrimed = true;
-        const canonicalUserMessagesById = new Map(agent.timelineRows.flatMap((row) => {
-            if (row.item.type !== "user_message") {
-                return [];
-            }
-            const messageId = normalizeMessageId(row.item.messageId);
-            if (!messageId) {
-                return [];
-            }
-            return [[messageId, row.item.text]];
-        }));
+        const canonicalUserMessagesById = this.timelineStore.getCanonicalUserMessagesById(agent.id);
         try {
             for await (const event of agent.session.streamHistory()) {
-                this.handleStreamEvent(agent, event, {
-                    fromHistory: true,
-                    canonicalUserMessagesById: canonicalUserMessagesById.size > 0 ? canonicalUserMessagesById : undefined,
-                });
+                if (event.type !== "timeline") {
+                    continue;
+                }
+                if (event.item.type === "user_message") {
+                    const eventMessageId = normalizeMessageId(event.item.messageId);
+                    if (eventMessageId) {
+                        const canonicalText = canonicalUserMessagesById.get(eventMessageId);
+                        if (canonicalText === event.item.text) {
+                            continue;
+                        }
+                    }
+                }
+                this.recordTimeline(agent.id, event.item);
             }
         }
         catch {
             // ignore history failures
         }
     }
-    handleStreamEvent(agent, event, options) {
+    notifyForegroundTurnWaiters(agentId, event) {
+        const turnId = event.turnId;
+        if (turnId == null) {
+            return;
+        }
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            return;
+        }
+        for (const waiter of agent.foregroundTurnWaiters) {
+            if (waiter.turnId === turnId && !waiter.settled) {
+                waiter.callback(event);
+            }
+        }
+    }
+    async handleStreamEvent(agent, event, options) {
         const eventTurnId = event.turnId;
         const isForegroundEvent = Boolean(eventTurnId && agent.activeForegroundTurnId === eventTurnId);
+        if (eventTurnId &&
+            isTurnTerminalEvent(event) &&
+            agent.finalizedForegroundTurnIds.has(eventTurnId)) {
+            return false;
+        }
         // Only update timestamp for live events, not history replay
         if (!options?.fromHistory) {
             this.touchUpdatedAt(agent);
+            if (this.agentStreamCoalescer.handle(agent.id, event)) {
+                return false;
+            }
+            this.agentStreamCoalescer.flushFor(agent.id);
         }
-        let timelineRow = null;
         let shouldDispatchEvent = true;
+        let shouldNotifyWaiters = true;
         switch (event.type) {
             case "thread_started":
                 {
@@ -1561,38 +1739,43 @@ export class AgentManager {
                 this.emitState(agent);
                 break;
             case "timeline":
-                // Skip provider-replayed user_message items during history hydration.
-                if (options?.fromHistory && event.item.type === "user_message") {
-                    const eventMessageId = normalizeMessageId(event.item.messageId);
-                    if (eventMessageId) {
-                        const canonicalText = options?.canonicalUserMessagesById?.get(eventMessageId);
-                        if (canonicalText === event.item.text) {
-                            break;
+                {
+                    // Skip provider-replayed user_message items during history hydration.
+                    if (options?.fromHistory && event.item.type === "user_message") {
+                        const eventMessageId = normalizeMessageId(event.item.messageId);
+                        if (eventMessageId) {
+                            const canonicalText = options?.canonicalUserMessagesById?.get(eventMessageId);
+                            if (canonicalText === event.item.text) {
+                                shouldDispatchEvent = false;
+                                shouldNotifyWaiters = false;
+                                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) {
+                    // Suppress user_message echoes for the active foreground turn.
+                    if (!options?.fromHistory && event.item.type === "user_message" && isForegroundEvent) {
+                        const eventMessageId = normalizeMessageId(event.item.messageId);
+                        if (eventMessageId &&
+                            (await this.hasCommittedUserMessageFromStores(agent.id, {
+                                messageId: eventMessageId,
+                                text: event.item.text,
+                            }))) {
                             break;
                         }
                     }
-                }
-                timelineRow = this.recordTimeline(agent, event.item);
-                if (!options?.fromHistory && event.item.type === "user_message") {
-                    agent.lastUserMessageAt = new Date();
-                    this.emitState(agent);
+                    if (options?.fromHistory) {
+                        this.recordTimeline(agent.id, event.item);
+                        shouldDispatchEvent = false;
+                        shouldNotifyWaiters = false;
+                        break;
+                    }
+                    this.recordAndDispatchTimelineItem(agent.id, event.item, event.provider, event.turnId);
+                    if (event.item.type === "user_message") {
+                        agent.lastUserMessageAt = new Date();
+                        this.emitState(agent);
+                    }
+                    shouldDispatchEvent = false;
+                    shouldNotifyWaiters = true;
                 }
                 break;
             case "turn_completed":
@@ -1627,7 +1810,7 @@ export class AgentManager {
                     agent.lifecycle = "error";
                 }
                 agent.lastError = event.error;
-                this.appendSystemErrorTimelineMessage(agent, event.provider, this.formatTurnFailedMessage(event), options);
+                await this.appendSystemErrorTimelineMessage(agent, event.provider, this.formatTurnFailedMessage(event), options);
                 for (const [requestId] of agent.pendingPermissions) {
                     agent.pendingPermissions.delete(requestId);
                     if (!options?.fromHistory) {
@@ -1707,19 +1890,29 @@ export class AgentManager {
                 break;
         }
         if (!options?.fromHistory && isForegroundEvent && isTurnTerminalEvent(event)) {
-            this.finalizeForegroundTurn(agent);
+            this.finalizeForegroundTurn(agent, eventTurnId);
         }
         // Skip dispatching individual stream events during history replay.
         if (!options?.fromHistory && shouldDispatchEvent) {
-            this.dispatchStream(agent.id, event, timelineRow
-                ? {
-                    seq: timelineRow.seq,
-                    epoch: this.ensureTimelineState(agent).epoch,
-                }
-                : undefined);
+            this.dispatchStream(agent.id, event);
         }
+        return shouldNotifyWaiters;
+    }
+    recordAndDispatchTimelineItem(agentId, item, provider, turnId) {
+        const row = this.recordTimeline(agentId, item);
+        const event = {
+            type: "timeline",
+            item,
+            provider,
+            ...(turnId !== undefined ? { turnId } : {}),
+        };
+        this.dispatchStream(agentId, event, {
+            seq: row.seq,
+            epoch: this.timelineStore.getEpoch(agentId),
+        });
+        return event;
     }
-    appendSystemErrorTimelineMessage(agent, provider, message, options) {
+    async appendSystemErrorTimelineMessage(agent, provider, message, options) {
         if (options?.fromHistory) {
             return;
         }
@@ -1728,19 +1921,19 @@ export class AgentManager {
             return;
         }
         const text = `${SYSTEM_ERROR_PREFIX} ${normalized}`;
-        const lastItem = agent.timelineRows[agent.timelineRows.length - 1]?.item;
+        const lastItem = await this.getLastItemFromStores(agent.id);
         if (lastItem?.type === "assistant_message" && lastItem.text === text) {
             return;
         }
         const item = { type: "assistant_message", text };
-        const row = this.recordTimeline(agent, item);
+        const row = this.recordTimeline(agent.id, item);
         this.dispatchStream(agent.id, {
             type: "timeline",
             item,
             provider,
         }, {
             seq: row.seq,
-            epoch: this.ensureTimelineState(agent).epoch,
+            epoch: this.timelineStore.getEpoch(agent.id),
         });
     }
     formatTurnFailedMessage(event) {
@@ -1756,27 +1949,17 @@ export class AgentManager {
         }
         return parts.join("\n\n");
     }
-    recordTimeline(agent, item) {
-        const timelineState = this.ensureTimelineState(agent);
-        const row = {
-            seq: timelineState.nextSeq,
-            timestamp: new Date().toISOString(),
-            item,
-        };
-        agent.timelineNextSeq = timelineState.nextSeq + 1;
-        agent.timeline.push(item);
-        timelineState.rows.push(row);
-        if (typeof this.maxTimelineItems === "number" &&
-            agent.timeline.length > this.maxTimelineItems) {
-            const removeCount = agent.timeline.length - this.maxTimelineItems;
-            agent.timeline.splice(0, removeCount);
-            timelineState.rows.splice(0, removeCount);
-        }
+    recordTimeline(agentId, item) {
+        const row = this.timelineStore.append(agentId, item);
+        this.enqueueDurableTimelineAppend(agentId, row);
         return row;
     }
-    emitState(agent) {
+    emitState(agent, options) {
         // Keep attention as an edge-triggered unread signal, not a level signal.
         this.checkAndSetAttention(agent);
+        if (options?.persist !== false) {
+            this.enqueueBackgroundPersist(agent);
+        }
         this.syncFeaturesFromSession(agent);
         this.dispatch({
             type: "agent_state",
@@ -1809,7 +1992,6 @@ export class AgentManager {
                 attentionTimestamp: new Date(),
             };
             this.broadcastAgentAttention(agent, "finished");
-            this.enqueueBackgroundPersist(agent);
             return;
         }
         // Check if agent entered error state
@@ -1820,7 +2002,6 @@ export class AgentManager {
                 attentionTimestamp: new Date(),
             };
             this.broadcastAgentAttention(agent, "error");
-            this.enqueueBackgroundPersist(agent);
             return;
         }
     }
@@ -1830,6 +2011,27 @@ export class AgentManager {
         });
         this.trackBackgroundTask(task);
     }
+    enqueueDurableTimelineAppend(agentId, row) {
+        if (!this.durableTimelineStore) {
+            return;
+        }
+        const task = this.durableTimelineStore
+            .bulkInsert(agentId, [row])
+            .then(() => undefined)
+            .catch((err) => {
+            this.logger.error({ err, agentId, seq: row.seq, itemType: row.item.type }, "Failed to append timeline row to durable store");
+        });
+        this.trackBackgroundTask(task);
+    }
+    enqueueDurableTimelineBulkInsert(agentId, rows) {
+        if (!this.durableTimelineStore || rows.length === 0) {
+            return;
+        }
+        const task = this.durableTimelineStore.bulkInsert(agentId, rows).catch((err) => {
+            this.logger.error({ err, agentId, rowCount: rows.length }, "Failed to seed durable timeline store");
+        });
+        this.trackBackgroundTask(task);
+    }
     trackBackgroundTask(task) {
         this.backgroundTasks.add(task);
         void task.finally(() => {
@@ -1841,6 +2043,7 @@ export class AgentManager {
      * Used by daemon shutdown paths to avoid unhandled rejections after cleanup.
      */
     async flush() {
+        this.agentStreamCoalescer.flushAll();
         // Drain tasks, including tasks spawned while awaiting.
         while (this.backgroundTasks.size > 0) {
             const pending = Array.from(this.backgroundTasks);
@@ -1915,7 +2118,7 @@ export class AgentManager {
             const client = this.clients.get(normalized.provider);
             if (client) {
                 try {
-                    const models = await client.listModels();
+                    const models = await client.listModels({ cwd: normalized.cwd, force: false });
                     const defaultModel = models.find((model) => model.isDefault) ?? models[0];
                     if (defaultModel) {
                         normalized.model = defaultModel.id;
@@ -1959,5 +2162,12 @@ export class AgentManager {
         }
         return agent;
     }
+    requireSessionAgent(id) {
+        const agent = this.requireAgent(id);
+        if (agent.session === null) {
+            throw new Error(`Agent '${agent.id}' has no managed session`);
+        }
+        return agent;
+    }
 }
 //# sourceMappingURL=agent-manager.js.map