@geminixiang/mikan 1.0.0-beta.44 → 1.0.0-beta.46

package/dist/runtime/conversation-runtime.js

@@ -1,18 +1,18 @@
-import { createOfficeAddress, officeKey } from "../office/index.js";
-import { createRunner } from "../agent/index.js";
+import { createRunner } from "../agent/runner.js";
+import { commitOfficeDream, generateMemoryAnchor, prepareOfficeDream } from "../dream/index.js";
 import { MikanModels } from "../harness/index.js";
 import { defaultCommandHandlers, dispatchCommand } from "../commands/registry.js";
 import { isPrivateConversation } from "../commands/utils.js";
 import * as log from "../log.js";
 import { addLifecycleBreadcrumb, applyRunScope, createRunAttributionAttributes, registerTraceAttribution, reportUserFacingError, } from "../observability/sentry.js";
 import { ChatHistorySync, hasMaterializedChatSession, waitForThreadSessionBootstrap, } from "../sessions/chat-history-sync.js";
-import { shouldRotateTopLevelSession } from "../sessions/rotation.js";
+import { shouldRotateTopLevelSession } from "../sessions/store.js";
 import { getThreadSessionFile, resolveChannelSessionFile, tryResolveThreadSession, } from "../sessions/store.js";
-import { assertSessionKeyBelongsToConversation, deriveSessionKey, inferConversationKind, } from "../sessions/session-key.js";
+import { assertSessionKeyBelongsToConversation, deriveSessionKey, } from "../sessions/session-key.js";
 import { formatNothingRunning, formatStopped, formatStopping } from "../platform-messages.js";
 import * as Sentry from "@sentry/node";
 import { getUnresolvedSandboxPathContext } from "../sandbox/index.js";
-import { disabledVaultManager } from "../vault/disabled.js";
+import { disabledVaultManager } from "../vault/index.js";
 import { SessionLifecycle } from "./session-lifecycle.js";
 /**
  * Placeholder token store for embedders that run without the web portal.
@@ -38,11 +38,7 @@ class ConversationRuntimeImpl {
     constructor(options) {
         this.options = options;
         this.sessions = new SessionLifecycle();
-        this.inFlightRuns = new Set();
-        this.sessionDreamSettlements = new Set();
         this.chatSessionManager = new ChatHistorySync();
-        this.globalRunnerGeneration = 0;
-        this.conversationRunnerGenerations = new Map();
         this.isShuttingDown = false;
         this.resolvedModels = options.models ?? MikanModels.create();
         this.commandServices = {
@@ -57,7 +53,7 @@ class ConversationRuntimeImpl {
         this.commandHandlers = options.commandHandlers ?? defaultCommandHandlers(this.resolvedModels);
     }
     isRunning(address, sessionKey) {
-        return this.sessions.isRunning(address, sessionKey);
+        return this.sessions.get(address, sessionKey)?.running === true;
     }
     getRunningSessions() {
         const sessions = [];
@@ -75,6 +71,18 @@ class ConversationRuntimeImpl {
         }
         return sessions;
     }
+    async runDream(address, now = new Date()) {
+        return this.sessions.runConversationMaintenance(address, async () => {
+            const office = this.options.workspace.office(address);
+            const plan = await prepareOfficeDream(office, now);
+            if (!plan)
+                return false;
+            const memory = await generateMemoryAnchor(office, plan, this.resolvedModels);
+            commitOfficeDream(office, plan, memory);
+            log.logInfo(`[${address.conversationId}] Dream updated the Memory anchor`);
+            return true;
+        });
+    }
     async handleStop(address, sessionKey, bot) {
         assertSessionKeyBelongsToConversation(sessionKey, address.conversationId);
         const state = this.sessions.get(address, sessionKey);
@@ -96,9 +104,7 @@ class ConversationRuntimeImpl {
             state.runner.abort();
         }
     }
-    async handleNewCommand(sessionKey, conversationId, bot, message, responder, platform) {
-        // The message's address is the authority; the raw id is still passed for
-        // filesystem layout, so a disagreement must fail loudly, not pick one.
+    async handleNewCommand({ sessionKey, conversationId, bot, message, }) {
         const address = message.address;
         if (conversationId !== address.conversationId) {
             throw new Error(`Conversation id ${JSON.stringify(conversationId)} does not match office ` +
@@ -106,116 +112,20 @@ class ConversationRuntimeImpl {
         }
         assertSessionKeyBelongsToConversation(sessionKey, address.conversationId);
         const activeState = this.sessions.get(address, sessionKey);
-        if (activeState?.running ||
-            (activeState?.runSettlement && this.sessionDreamSettlements.has(activeState.runSettlement))) {
-            const activeSettlement = activeState.runSettlement;
-            if (activeSettlement && this.sessionDreamSettlements.has(activeSettlement)) {
-                await activeSettlement;
-                return;
-            }
-            activeState.stopRequested = true;
-            activeState.runner.abort();
-            await activeSettlement;
-        }
-        const state = await this.getOrCreateState({
-            address,
-            conversationId,
-            sessionKey,
-            conversationKind: message.conversationKind,
-        });
-        // Scope resolution only materializes; the Session Dream below reads the
-        // session, so bring it up to date with the log first.
-        await state.runner.syncChatHistory(message.id);
-        if (state.running ||
-            (state.runSettlement && this.sessionDreamSettlements.has(state.runSettlement))) {
-            const activeSettlement = state.runSettlement;
-            if (activeSettlement && this.sessionDreamSettlements.has(activeSettlement)) {
-                await activeSettlement;
-                return;
+        if (activeState?.runSettlement) {
+            if (activeState.running) {
+                activeState.stopRequested = true;
+                activeState.runner.abort();
             }
-            state.stopRequested = true;
-            state.runner.abort();
-            await activeSettlement;
-            return this.handleNewCommand(sessionKey, conversationId, bot, message, responder, platform);
+            await activeState.runSettlement;
         }
-        const dreamSettlement = this.startSessionDream(state, async () => {
-            let working = false;
-            try {
-                await responder.setWorking(true);
-                working = true;
-                const result = await this.dreamSessionMemory(state, message, platform);
-                if (!result.success) {
-                    const detail = result.errorMessage ? ` ${result.errorMessage}` : "";
-                    await responder.respondDiagnostic(`Could not preserve memory, so the current conversation was not reset.${detail}`, { style: "error" });
-                    return;
-                }
-                await responder.setWorking(false);
-                working = false;
-                await this.resetSession(state, bot);
-            }
-            finally {
-                if (working)
-                    await responder.setWorking(false);
-            }
+        await this.sessions.runConversationMaintenance(address, async () => {
+            await this.resetSession(address, sessionKey, bot);
         });
-        void dreamSettlement
-            .catch((err) => {
-            reportUserFacingError(err, {
-                domain: "mikan",
-                surface: "session_dream",
-                operation: "run_new_command_in_background",
-            });
-        })
-            .finally(() => this.finishSessionDream(state, dreamSettlement));
-    }
-    startSessionDream(state, dream, markRunning = true) {
-        if (markRunning) {
-            state.running = true;
-            state.stopRequested = false;
-            state.startedAt = Date.now();
-            state.lastActivityAt = Date.now();
-        }
-        const settlement = Promise.resolve().then(dream);
-        state.runSettlement = settlement;
-        this.sessionDreamSettlements.add(settlement);
-        this.inFlightRuns.add(settlement);
-        return settlement;
-    }
-    finishSessionDream(state, settlement) {
-        this.sessionDreamSettlements.delete(settlement);
-        this.inFlightRuns.delete(settlement);
-        if (state.runSettlement !== settlement)
-            return;
-        state.runSettlement = undefined;
-        state.running = false;
-        state.startedAt = 0;
-        state.lastAccessedAt = Date.now();
-        this.sessions.onSettlement(state.address);
-        this.sessions.evictIdle();
-    }
-    async dreamSessionMemory(state, message, platform) {
-        try {
-            const result = await state.runner.dreamSessionMemory(message, platform);
-            // Only a clean stop means the dream finished its work. Everything else —
-            // budget abort, length cutoff, error, blocked — leaves memory unwritten,
-            // and treating it as success resets the session and loses it silently.
-            // Listed as a whitelist so a new stop reason fails safe.
-            if (result.stopReason !== "stop") {
-                return {
-                    success: false,
-                    errorMessage: result.errorMessage ?? `Session Dream stopped early (${result.stopReason})`,
-                };
-            }
-            return { success: true };
-        }
-        catch (err) {
-            return { success: false, errorMessage: err instanceof Error ? err.message : String(err) };
-        }
     }
     scheduleSharedSessionRotation({ event, bot, context }, sessionKey) {
         const { address, conversationId } = event;
-        const { message, platform } = context;
-        if (message.conversationKind !== "shared" || sessionKey !== conversationId)
+        if (context.message.conversationKind !== "shared" || sessionKey !== conversationId)
             return false;
         const conversationDir = this.options.workspace.office(address).dir;
         const currentSession = resolveChannelSessionFile(conversationDir);
@@ -228,51 +138,26 @@ class ConversationRuntimeImpl {
                 await this.runSession({ event, bot, context }, true);
                 return;
             }
-            const state = await this.getOrCreateState({
-                address,
-                conversationId,
+            const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workspace, address);
+            await this.chatSessionManager.resetSession({
+                conversationDir,
                 sessionKey,
-                conversationKind: message.conversationKind,
-                currentMessageId: message.id,
+                cwd: runtimeCwd,
             });
-            // The rotation Dream summarizes the session; sync the log into it
-            // first (scope resolution only materializes).
-            await state.runner.syncChatHistory(message.id);
-            const dreamSettlement = this.startSessionDream(state, async () => {
-                const result = await this.dreamSessionMemory(state, message, platform);
-                if (!result.success) {
-                    const detail = result.errorMessage ? `: ${result.errorMessage}` : "";
-                    log.logWarning(`[${conversationId}] Automatic Session Dream failed${detail}`);
-                    return;
-                }
-                const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workspace, address);
-                await this.chatSessionManager.resetSession({
-                    conversationDir,
-                    sessionKey,
-                    cwd: runtimeCwd,
-                });
-                await this.sessions.discardAndWait(address, sessionKey);
-                log.logInfo(`[${conversationId}] Session Dream completed; rotated session: ${sessionKey}`);
-            }, false);
-            try {
-                await dreamSettlement;
-            }
-            finally {
-                this.finishSessionDream(state, dreamSettlement);
-            }
+            await this.sessions.discardAndWait(address, sessionKey);
+            log.logInfo(`[${conversationId}] Rotated session: ${sessionKey}`);
             await this.runSession({ event, bot, context }, true);
         })
             .catch((err) => {
             reportUserFacingError(err, {
                 domain: "mikan",
-                surface: "session_dream",
+                surface: "session_rotation",
                 operation: "rotate_shared_session_in_background",
             });
         });
         return true;
     }
-    async resetSession(state, bot) {
-        const { address, sessionKey } = state;
+    async resetSession(address, sessionKey, bot) {
         const conversationId = address.conversationId;
         const conversationDir = this.options.workspace.office(address).dir;
         const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workspace, address);
@@ -285,75 +170,6 @@ class ConversationRuntimeImpl {
         const sessionKey = deriveSessionKey(event);
         await this.sessions.enqueue(event.address, sessionKey, () => this.runSession({ event, bot, context }));
     }
-    /**
-     * Dispatch an extension-owned interactive block action: materialize the
-     * conversation's harness instance (activating its extensions) and run the
-     * matching onAction handler — deterministic, no agent run. Serialized on
-     * the session queue so rapid interactions (votes) never interleave.
-     */
-    async handleExtensionAction(params) {
-        if (this.isShuttingDown)
-            return false;
-        const { address, sessionKey, conversationKind, slug, action } = params;
-        const conversationId = address.conversationId;
-        let consumed = false;
-        await this.sessions.enqueue(address, sessionKey, async () => {
-            try {
-                const state = await this.getOrCreateState({
-                    address,
-                    conversationId,
-                    sessionKey,
-                    currentMessageId: action.messageTs ?? sessionKey,
-                    conversationKind,
-                });
-                consumed = await state.runner.tryExtensionAction(slug, action);
-                if (consumed)
-                    state.lastAccessedAt = Date.now();
-            }
-            catch (err) {
-                log.logWarning(`[${conversationId}] Extension action dispatch failed (${slug}:${action.actionId})`, err instanceof Error ? err.message : String(err));
-            }
-        });
-        return consumed;
-    }
-    /**
-     * Dispatch a fired extension callback schedule: materialize the
-     * conversation's harness instance (activating its extensions) and run the
-     * matching `onCallback` handler — deterministic, no agent run, no model
-     * call. Serialized on the session queue so fires never interleave with
-     * block actions or runs in the same conversation.
-     */
-    async handleExtensionScheduleCallback(fire) {
-        if (this.isShuttingDown)
-            return false;
-        const address = createOfficeAddress(fire.platform, fire.conversationId);
-        const conversationId = fire.conversationId;
-        // Schedules belong to the conversation, not a thread: use the top-level
-        // session scope, like the schedules that fire agent runs.
-        const sessionKey = conversationId;
-        let consumed = false;
-        await this.sessions.enqueue(address, sessionKey, async () => {
-            try {
-                const state = await this.getOrCreateState({
-                    address,
-                    conversationId,
-                    sessionKey,
-                    currentMessageId: `extsched:${fire.slug}.${fire.scheduleName}`,
-                    conversationKind: inferConversationKind(fire.platform, conversationId),
-                });
-                consumed = await state.runner.tryExtensionScheduleCallback(fire.slug, fire.callback, {
-                    scheduleName: fire.scheduleName,
-                    ...(fire.args !== undefined ? { args: fire.args } : {}),
-                });
-                if (consumed)
-                    state.lastAccessedAt = Date.now();
-            }
-            catch (err) {
-                log.logWarning(`[${conversationId}] Extension schedule dispatch failed (${fire.slug}.${fire.scheduleName} → ${fire.callback})`, err instanceof Error ? err.message : String(err));
-            }
-        });
-        return consumed;
-    }
     async runSession({ event, bot, context }, skipRotation = false) {
         const conversationId = event.conversationId;
         if (this.isShuttingDown) {
@@ -361,24 +177,8 @@ class ConversationRuntimeImpl {
             return;
         }
         const sessionKey = deriveSessionKey(event);
-        if (!skipRotation) {
-            const privateConversation = isPrivateConversation(event);
-            const handledCommand = await dispatchCommand(this.commandHandlers, {
-                bot,
-                responder: context.responder,
-                platform: context.platform.name,
-                address: event.address,
-                platformUserId: event.user,
-                platformUserName: context.message.userName,
-                conversationId,
-                vaultConversationId: event.vaultConversationId,
-                sessionKey,
-                commandText: event.text,
-                privateConversation,
-                services: this.commandServices,
-            });
-            if (handledCommand)
-                return;
+        if (!skipRotation && (await this.dispatchSessionCommand({ event, bot, context }, sessionKey))) {
+            return;
         }
         const address = event.address;
         const activeSettlement = this.sessions.get(address, sessionKey)?.runSettlement;
@@ -394,42 +194,19 @@ class ConversationRuntimeImpl {
             : await this.sessions.acquireConversationWork(address);
         try {
             const conversationDir = this.options.workspace.office(address).dir;
-            const waitedForParent = await waitForThreadSessionBootstrap({
-                parentSessionKey: conversationId,
-                sessionKey,
-                hasThreadSession: () => hasMaterializedChatSession({ conversationDir, sessionKey }),
-                isParentRunning: () => this.sessions.get(address, conversationId)?.running === true,
-            });
-            if (waitedForParent) {
-                log.logInfo(`[${conversationId}] Delayed thread bootstrap until parent session sealed: ${sessionKey}`);
-            }
-            let state;
+            await this.waitForParentSession(address, sessionKey, conversationDir);
+            let lease;
             try {
-                state = await this.getOrCreateState({
+                lease = await this.acquireState({
                     address,
-                    conversationId,
                     sessionKey,
                     currentMessageId: event.ts,
-                    conversationKind: event.conversationKind,
                 });
+                const { state } = lease;
                 await state.runner.syncChatHistory(event.ts);
-                // Extension-contributed commands: deterministic dispatch, no agent run.
-                // Built-in commands already had their chance above, so extensions can
-                // never shadow them; unmatched text falls through to the agent.
-                //
-                // Where the platform eats the slash before we ever see it, the leading
-                // name alone is enough — otherwise those commands would be unreachable
-                // rather than merely awkward.
-                const bareName = context.platform.bareExtensionCommands === true;
-                if (bareName || event.text.trim().startsWith("/")) {
-                    const handled = await state.runner.tryExtensionCommand(context.message, context.responder, { bareName });
-                    if (handled) {
-                        state.lastAccessedAt = Date.now();
-                        return;
-                    }
-                }
             }
             catch (err) {
+                lease?.release();
                 reportUserFacingError(err, {
                     domain: "mikan",
                     surface: "session_setup",
@@ -446,12 +223,9 @@ class ConversationRuntimeImpl {
                 });
                 throw err;
             }
-            state.running = true;
-            state.stopRequested = false;
-            state.startedAt = Date.now();
-            state.lastActivityAt = Date.now();
+            const { state } = lease;
             log.logInfo(`[${conversationId}] Starting run: ${event.text.substring(0, 50)}`);
-            const runPromise = (async () => {
+            const runPromise = this.sessions.settle(state, async () => {
                 try {
                     const result = await this.runWithInstrumentation(context, { conversationId, sessionKey, startedAt: state.startedAt }, async () => {
                         await context.responder.setTyping(true);
@@ -474,29 +248,45 @@ class ConversationRuntimeImpl {
                     }
                 }
                 finally {
-                    state.running = false;
-                    state.lastAccessedAt = Date.now();
-                    Sentry.metrics.gauge("agent.sessions.active", this.inFlightRuns.size - 1);
+                    Sentry.metrics.gauge("agent.sessions.active", this.sessions.settlementCount() - 1);
                 }
-            })();
-            this.inFlightRuns.add(runPromise);
-            state.runSettlement = runPromise;
-            Sentry.metrics.gauge("agent.sessions.active", this.inFlightRuns.size);
-            try {
-                await runPromise;
-            }
-            finally {
-                this.inFlightRuns.delete(runPromise);
-                if (state.runSettlement === runPromise)
-                    state.runSettlement = undefined;
-                this.sessions.onSettlement(address);
-                this.sessions.evictIdle();
-            }
+            });
+            lease.release();
+            Sentry.metrics.gauge("agent.sessions.active", this.sessions.settlementCount());
+            await runPromise;
         }
         finally {
             releaseConversationWork();
         }
     }
+    async waitForParentSession(address, sessionKey, conversationDir) {
+        const conversationId = address.conversationId;
+        const waited = await waitForThreadSessionBootstrap({
+            parentSessionKey: conversationId,
+            sessionKey,
+            hasThreadSession: () => hasMaterializedChatSession({ conversationDir, sessionKey }),
+            isParentRunning: () => this.sessions.get(address, conversationId)?.running === true,
+        });
+        if (waited) {
+            log.logInfo(`[${conversationId}] Delayed thread bootstrap until parent session sealed: ${sessionKey}`);
+        }
+    }
+    async dispatchSessionCommand({ event, bot, context }, sessionKey) {
+        return dispatchCommand(this.commandHandlers, {
+            bot,
+            responder: context.responder,
+            platform: context.platform.name,
+            address: event.address,
+            platformUserId: event.user,
+            platformUserName: context.message.userName,
+            conversationId: event.conversationId,
+            vaultConversationId: event.vaultConversationId,
+            sessionKey,
+            commandText: event.text,
+            privateConversation: isPrivateConversation(event),
+            services: this.commandServices,
+        });
+    }
     async runWithInstrumentation(context, meta, body) {
         const { conversationId, sessionKey, startedAt } = meta;
         const { message, platform } = context;
@@ -579,92 +369,57 @@ class ConversationRuntimeImpl {
         }));
     }
     switchConversationModel(address, _provider, _model) {
-        this.bumpConversationRunnerGeneration(address);
-        return this.clearOffice(address, "Model switched");
+        return this.invalidateOffice(address, "Model switched");
     }
     refreshConversationEnvironment(address) {
-        this.bumpConversationRunnerGeneration(address);
-        return this.clearOffice(address, "Environment refreshed");
+        return this.invalidateOffice(address, "Environment refreshed");
     }
     refreshAllConversations() {
-        this.globalRunnerGeneration++;
-        const busy = [];
-        for (const address of this.sessions.offices()) {
-            if (!this.clearOffice(address, "Global settings changed")) {
-                this.sessions.deferConversationClear(address);
-                busy.push(address);
-            }
+        const offices = this.sessions.offices();
+        const result = this.sessions.invalidateAll();
+        const busyKeys = new Set(result.busy.map((address) => `${address.platform}:${address.conversationId}`));
+        for (const address of offices) {
+            if (busyKeys.has(`${address.platform}:${address.conversationId}`))
+                continue;
+            log.logInfo(`[${address.conversationId}] Global settings changed; cleared cached session runners`);
         }
-        return { busy };
+        return result;
     }
-    clearOffice(address, reason) {
-        const cleared = this.sessions.clearConversation(address);
+    invalidateOffice(address, reason) {
+        const cleared = this.sessions.invalidateConversation(address);
         if (cleared) {
             log.logInfo(`[${address.conversationId}] ${reason}; cleared cached session runners`);
         }
         return cleared;
     }
-    bumpConversationRunnerGeneration(address) {
-        const key = officeKey(address);
-        this.conversationRunnerGenerations.set(key, (this.conversationRunnerGenerations.get(key) ?? 0) + 1);
-    }
-    runnerGeneration(address) {
-        return `${this.globalRunnerGeneration}:${this.conversationRunnerGenerations.get(officeKey(address)) ?? 0}`;
-    }
-    async createCurrentRunner(options, conversationDir, sessionScope) {
-        while (true) {
-            const generation = this.runnerGeneration(options.address);
-            const runner = await createRunner({
-                sandboxConfig: this.options.sandbox,
-                sessionKey: options.sessionKey,
-                office: this.options.workspace.office(options.address),
-                sessionScope,
-                vaultManager: this.options.vaultManager,
-                provisioner: this.options.provisioner,
-                resourceController: this.options.resourceController,
-                sessionView: this.options.sessionViewTokenStore
-                    ? {
-                        tokenStore: this.options.sessionViewTokenStore,
-                        portalBaseUrl: this.options.portalBaseUrl,
-                    }
-                    : undefined,
-                platformNotifier: this.options.platformNotifier,
-                platformReactor: this.options.platformReactor,
-                platformUploader: this.options.platformUploader,
-                platformBlockKit: this.options.platformBlockKit,
-                platformDmOpener: this.options.platformDmOpener,
-                platformHistoryFetcher: this.options.platformHistoryFetcher,
-                platformUserLister: this.options.platformUserLister,
-                extensionScheduleEngine: this.options.extensionScheduleEngine,
-                platformToolPackFactories: this.options.platformToolPackFactories,
-                models: this.resolvedModels,
-            });
-            if (generation === this.runnerGeneration(options.address))
-                return runner;
-            await runner.dispose();
-        }
-    }
-    async getOrCreateState(options) {
-        return this.sessions.transition(options.address, options.sessionKey, () => this.getOrCreateStateExclusive(options));
+    async createCurrentRunner(options, sessionScope) {
+        return createRunner({
+            sandboxConfig: this.options.sandbox,
+            sessionKey: options.sessionKey,
+            office: this.options.workspace.office(options.address),
+            sessionScope,
+            vaultManager: this.options.vaultManager,
+            provisioner: this.options.provisioner,
+            resourceController: this.options.resourceController,
+            sessionView: this.options.sessionViewTokenStore
+                ? {
+                    tokenStore: this.options.sessionViewTokenStore,
+                    portalBaseUrl: this.options.portalBaseUrl,
+                }
+                : undefined,
+            platformToolPackFactories: this.options.platformToolPackFactories,
+            models: this.resolvedModels,
+        });
     }
-    async getOrCreateStateExclusive(options) {
-        const { address, sessionKey, currentMessageId } = options;
-        await this.sessions.waitForClose(address, sessionKey);
-        const existing = this.sessions.get(address, sessionKey);
-        // A cached runner is the sole writable pi v4 session handle for its file:
-        // reuse it before scope resolution can open the same path a second time.
+    acquireState(options) {
+        const { address, sessionKey } = options;
         const conversationDir = this.options.workspace.office(address).dir;
-        const expectedFile = sessionKey === address.conversationId
+        return this.sessions.acquire(address, sessionKey, () => sessionKey === address.conversationId
             ? resolveChannelSessionFile(conversationDir)
-            : tryResolveThreadSession(getThreadSessionFile(conversationDir, sessionKey));
-        if (existing && expectedFile === existing.sessionFile) {
-            existing.lastAccessedAt = Date.now();
-            return existing;
-        }
-        if (existing?.running)
-            return existing;
-        if (existing)
-            await this.sessions.discardAndWait(address, sessionKey);
+            : tryResolveThreadSession(getThreadSessionFile(conversationDir, sessionKey)), () => this.materializeState(options, conversationDir));
+    }
+    async materializeState(options, conversationDir) {
+        const { address, sessionKey, currentMessageId } = options;
         const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workspace, address);
         const sessionScope = await this.chatSessionManager.resolveSessionScope({
             conversationDir,
@@ -672,41 +427,23 @@ class ConversationRuntimeImpl {
             cwd: runtimeCwd,
             currentMessageId,
         });
-        const state = {
+        return {
             address,
             sessionKey,
             running: false,
-            runner: await this.createCurrentRunner(options, conversationDir, sessionScope),
+            runner: await this.createCurrentRunner(options, sessionScope),
             stopRequested: false,
             lastAccessedAt: Date.now(),
             sessionFile: sessionScope.contextFile,
             startedAt: 0,
         };
-        this.sessions.set(state);
-        return state;
     }
     async shutdown(timeoutMs = 30_000) {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
         log.logInfo("Shutting down gracefully...");
-        const timeout = Date.now() + timeoutMs;
-        while (this.inFlightRuns.size > 0 && Date.now() < timeout) {
-            await new Promise((resolve) => setTimeout(resolve, 500));
-        }
-        if (this.inFlightRuns.size > 0) {
-            log.logWarning(`Aborting ${this.inFlightRuns.size} runs after shutdown timeout`, `${timeoutMs}ms`);
-            for (const state of this.sessions.runningStates())
-                state.runner.abort();
-            const closeDeadline = Date.now() + 5_000;
-            while (this.inFlightRuns.size > 0 && Date.now() < closeDeadline) {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            }
-            if (this.inFlightRuns.size > 0) {
-                throw new Error(`Shutdown could not settle ${this.inFlightRuns.size} aborted runs within 5000ms`);
-            }
-        }
-        await this.sessions.closeAll();
+        await this.sessions.shutdown(timeoutMs);
     }
 }
 //# sourceMappingURL=conversation-runtime.js.map