@geminixiang/mikan 1.0.0-beta.3 → 1.0.0-beta.30

package/dist/runtime/conversation-runtime.js

@@ -1,15 +1,31 @@
 import { createRunner } from "../agent.js";
-import { defaultCommandHandlers } from "../commands/registry.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 { reportUserFacingError } from "../observability/sentry.js";
-import { AgentMemoryFileManager, hasMaterializedChatSession, } from "../sessions/agent-memory-file-manager.js";
-import { formatNothingRunning, formatStopping } from "../platform-messages.js";
-import { AgentRunController } from "./agent-run-controller.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 { resolveChannelSessionFile } from "../sessions/store.js";
+import { assertSessionKeyBelongsToConversation, deriveSessionKey, } from "../sessions/session-key.js";
+import { formatNothingRunning, formatStopped, formatStopping } from "../platform-messages.js";
 import * as Sentry from "@sentry/node";
 import { join } from "path";
-import { getUnresolvedSandboxPathContext } from "../agent.js";
-const MAX_SESSIONS = 500;
-const IDLE_TIMEOUT_MS = 3_600_000;
+import { getUnresolvedSandboxPathContext } from "../sandbox/index.js";
+import { disabledVaultManager } from "../vault/disabled.js";
+import { SessionLifecycle } from "./session-lifecycle.js";
+/**
+ * Placeholder token store for embedders that run without the web portal.
+ * Command handlers guard on `portalBaseUrl` before minting tokens, so this
+ * only fires when a portal URL is configured without its backing store.
+ */
+function portalNotConfiguredTokenStore(portal) {
+    return {
+        create: () => {
+            throw new Error(`${portal} portal not configured`);
+        },
+    };
+}
 function runtimeCwdForSandbox(sandbox, hostWorkspaceRoot, conversationId) {
     const runtimeWorkspaceRoot = getUnresolvedSandboxPathContext(sandbox, hostWorkspaceRoot).runtimeWorkspaceRoot;
     return `${runtimeWorkspaceRoot.replace(/\/+$/, "")}/${conversationId}`;
@@ -20,42 +36,33 @@ export function createConversationRuntime(options) {
 class ConversationRuntimeImpl {
     constructor(options) {
         this.options = options;
-        this.conversationStates = new Map();
-        this.sessionQueues = new Map();
+        this.sessions = new SessionLifecycle();
         this.inFlightRuns = new Set();
-        this.chatSessionManager = new AgentMemoryFileManager();
+        this.sessionDreamSettlements = new Set();
+        this.chatSessionManager = new ChatHistorySync();
+        this.globalRunnerGeneration = 0;
+        this.conversationRunnerGenerations = new Map();
         this.isShuttingDown = false;
-        const commandServices = { ...options, runtime: this };
-        const commandHandlers = options.commandHandlers ?? defaultCommandHandlers();
-        this.orchestrator = new AgentRunController({
-            workingDir: options.workingDir,
-            commandHandlers,
-            commandServices,
-            isShuttingDown: () => this.isShuttingDown,
-            getState: (sessionKey) => this.conversationStates.get(sessionKey),
-            getOrCreateState: (createOptions) => this.getOrCreateState(createOptions),
-            hasMaterializedSession: ({ conversationDir, sessionKey }) => hasMaterializedChatSession({ conversationDir, sessionKey }),
-            beforeRunTracked: (runPromise) => {
-                this.inFlightRuns.add(runPromise);
-                Sentry.metrics.gauge("agent.sessions.active", this.inFlightRuns.size);
-            },
-            afterRunTracked: (runPromise) => {
-                this.inFlightRuns.delete(runPromise);
-            },
-            onRunFinished: () => {
-                Sentry.metrics.gauge("agent.sessions.active", this.inFlightRuns.size - 1);
-                this.evictIdleSessions();
-            },
-        });
+        this.resolvedModels = options.models ?? MikanModels.create();
+        this.commandServices = {
+            ...options,
+            resourceController: options.resourceController ?? options.provisioner,
+            vaultManager: options.vaultManager ?? disabledVaultManager,
+            linkTokenStore: options.linkTokenStore ?? portalNotConfiguredTokenStore("Login"),
+            sessionViewTokenStore: options.sessionViewTokenStore ?? portalNotConfiguredTokenStore("Session viewer"),
+            adminTokenStore: options.adminTokenStore ?? portalNotConfiguredTokenStore("Admin"),
+            runtime: this,
+        };
+        this.commandHandlers = options.commandHandlers ?? defaultCommandHandlers(this.resolvedModels);
     }
     isRunning(sessionKey) {
-        const state = this.conversationStates.get(sessionKey);
+        const state = this.sessions.get(sessionKey);
         return !!state?.running;
     }
     getRunningSessions() {
         const sessions = [];
-        for (const [sessionKey, state] of this.conversationStates) {
-            if (state.running && state.startedAt) {
+        for (const [sessionKey, state] of this.sessions.runningStates()) {
+            if (state.startedAt) {
                 const currentStep = state.runner.getCurrentStep();
                 sessions.push({
                     sessionKey,
@@ -68,7 +75,8 @@ class ConversationRuntimeImpl {
         return sessions;
     }
     async handleStop(sessionKey, conversationId, bot) {
-        const state = this.conversationStates.get(sessionKey);
+        assertSessionKeyBelongsToConversation(sessionKey, conversationId);
+        const state = this.sessions.get(sessionKey);
         if (state?.running) {
             state.stopRequested = true;
             state.runner.abort();
@@ -80,74 +88,469 @@ class ConversationRuntimeImpl {
         }
     }
     forceStop(sessionKey) {
-        const state = this.conversationStates.get(sessionKey);
+        const state = this.sessions.get(sessionKey);
         if (state?.running) {
             log.logInfo(`[Force Stop] Force stopping session: ${sessionKey}`);
             state.stopRequested = true;
             state.runner.abort();
-            state.running = false;
         }
     }
-    async handleNewCommand(sessionKey, conversationId, bot) {
-        const state = this.conversationStates.get(sessionKey);
-        if (state?.running) {
+    async handleNewCommand(sessionKey, conversationId, bot, message, responder, platform) {
+        assertSessionKeyBelongsToConversation(sessionKey, conversationId);
+        const activeState = this.sessions.get(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({
+            conversationId,
+            sessionKey,
+            conversationKind: message.conversationKind,
+        });
+        if (state.running ||
+            (state.runSettlement && this.sessionDreamSettlements.has(state.runSettlement))) {
+            const activeSettlement = state.runSettlement;
+            if (activeSettlement && this.sessionDreamSettlements.has(activeSettlement)) {
+                await activeSettlement;
+                return;
+            }
             state.stopRequested = true;
             state.runner.abort();
+            await activeSettlement;
+            return this.handleNewCommand(sessionKey, conversationId, bot, message, responder, platform);
         }
+        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(sessionKey, conversationId, bot);
+            }
+            finally {
+                if (working)
+                    await responder.setWorking(false);
+            }
+        });
+        try {
+            await dreamSettlement;
+        }
+        finally {
+            this.finishSessionDream(sessionKey, 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(sessionKey, 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(sessionKey);
+        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) };
+        }
+    }
+    async rotateSharedSessionAfterDream(conversationId, sessionKey, message, platform) {
+        if (message.conversationKind !== "shared" || sessionKey !== conversationId)
+            return;
+        const conversationDir = join(this.options.workingDir, conversationId);
+        const currentSession = resolveChannelSessionFile(conversationDir);
+        if (!currentSession || !shouldRotateTopLevelSession(currentSession, new Date()))
+            return;
+        await this.sessions.runConversationMaintenance(conversationId, async () => {
+            const session = resolveChannelSessionFile(conversationDir);
+            if (!session || !shouldRotateTopLevelSession(session, new Date()))
+                return;
+            const state = await this.getOrCreateState({
+                conversationId,
+                sessionKey,
+                conversationKind: message.conversationKind,
+                currentMessageId: 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.workingDir, conversationId);
+                this.chatSessionManager.resetSession({ conversationDir, sessionKey, cwd: runtimeCwd });
+                this.sessions.discard(sessionKey);
+                log.logInfo(`[${conversationId}] Session Dream completed; rotated session: ${sessionKey}`);
+            }, false);
+            try {
+                await dreamSettlement;
+            }
+            finally {
+                this.finishSessionDream(sessionKey, state, dreamSettlement);
+            }
+        });
+    }
+    async resetSession(sessionKey, conversationId, bot) {
         const conversationDir = join(this.options.workingDir, conversationId);
         const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workingDir, conversationId);
         this.chatSessionManager.resetSession({ conversationDir, sessionKey, cwd: runtimeCwd });
-        this.conversationStates.delete(sessionKey);
+        this.sessions.discard(sessionKey);
         log.logInfo(`[${conversationId}] Session reset: ${sessionKey}`);
         await bot.postMessage(conversationId, "Conversation reset. Send a new message to start fresh.");
     }
     async handleEvent(event, bot, context) {
-        const sessionKey = event.sessionKey ?? `${event.conversationId}:${event.thread_ts ?? event.ts}`;
-        const previous = this.sessionQueues.get(sessionKey) ?? Promise.resolve();
-        const next = previous.catch(() => { }).then(() => this.runSession({ event, bot, context }));
-        this.sessionQueues.set(sessionKey, next);
+        const sessionKey = deriveSessionKey(event);
+        await this.sessions.enqueue(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 { conversationId, sessionKey, conversationKind, slug, action } = params;
+        let consumed = false;
+        await this.sessions.enqueue(sessionKey, async () => {
+            try {
+                const state = await this.getOrCreateState({
+                    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;
+    }
+    async runSession({ event, bot, context }) {
+        const conversationId = event.conversationId;
+        if (this.isShuttingDown) {
+            log.logInfo(`[${conversationId}] Rejected event during shutdown: ${event.text.substring(0, 50)}`);
+            return;
+        }
+        const sessionKey = deriveSessionKey(event);
+        const privateConversation = isPrivateConversation(event);
+        const handledCommand = await dispatchCommand(this.commandHandlers, {
+            bot,
+            responder: context.responder,
+            platform: context.platform.name,
+            platformUserId: event.user,
+            platformUserName: context.message.userName,
+            conversationId,
+            vaultConversationId: event.vaultConversationId,
+            sessionKey,
+            commandText: event.text,
+            privateConversation,
+            services: this.commandServices,
+        });
+        if (handledCommand)
+            return;
+        const activeSettlement = this.sessions.get(sessionKey)?.runSettlement;
+        if (activeSettlement)
+            await activeSettlement;
+        if (sessionKey === conversationId) {
+            await this.rotateSharedSessionAfterDream(conversationId, sessionKey, context.message, context.platform);
+        }
+        const releaseConversationWork = await this.sessions.acquireConversationWork(conversationId);
         try {
-            await next;
+            const conversationDir = join(this.options.workingDir, conversationId);
+            const waitedForParent = await waitForThreadSessionBootstrap({
+                parentSessionKey: conversationId,
+                sessionKey,
+                hasThreadSession: () => hasMaterializedChatSession({ conversationDir, sessionKey }),
+                isParentRunning: () => this.sessions.get(conversationId)?.running === true,
+            });
+            if (waitedForParent) {
+                log.logInfo(`[${conversationId}] Delayed thread bootstrap until parent session sealed: ${sessionKey}`);
+            }
+            let state;
+            try {
+                state = await this.getOrCreateState({
+                    conversationId,
+                    sessionKey,
+                    currentMessageId: event.ts,
+                    conversationKind: event.conversationKind,
+                });
+                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 slash text falls through to the agent.
+                if (event.text.trim().startsWith("/")) {
+                    const handled = await state.runner.tryExtensionCommand(context.message, context.responder);
+                    if (handled) {
+                        state.lastAccessedAt = Date.now();
+                        return;
+                    }
+                }
+            }
+            catch (err) {
+                reportUserFacingError(err, {
+                    domain: "mikan",
+                    surface: "session_setup",
+                    operation: "get_or_create_state",
+                    severity: "error",
+                    platform: context.platform.name,
+                    context: {
+                        conversationId,
+                        sessionKey,
+                        messageId: context.message.id,
+                        threadTs: context.message.threadTs,
+                        attachmentCount: context.message.attachments?.length ?? 0,
+                    },
+                });
+                throw err;
+            }
+            state.running = true;
+            state.stopRequested = false;
+            state.startedAt = Date.now();
+            state.lastActivityAt = Date.now();
+            log.logInfo(`[${conversationId}] Starting run: ${event.text.substring(0, 50)}`);
+            const runPromise = (async () => {
+                try {
+                    const result = await this.runWithInstrumentation(context, { conversationId, sessionKey, startedAt: state.startedAt }, async () => {
+                        await context.responder.setTyping(true);
+                        await context.responder.setWorking(true);
+                        try {
+                            return await state.runner.run(context.message, context.responder, context.platform);
+                        }
+                        finally {
+                            await context.responder.setWorking(false);
+                        }
+                    });
+                    if (result?.stopReason === "aborted" && state.stopRequested) {
+                        if (state.stopMessageTs) {
+                            await bot.updateMessage(conversationId, state.stopMessageTs, formatStopped(bot));
+                            state.stopMessageTs = undefined;
+                        }
+                        else {
+                            await bot.postMessage(conversationId, formatStopped(bot));
+                        }
+                    }
+                }
+                finally {
+                    state.running = false;
+                    state.lastAccessedAt = Date.now();
+                    Sentry.metrics.gauge("agent.sessions.active", this.inFlightRuns.size - 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(sessionKey);
+                this.sessions.evictIdle();
+            }
         }
         finally {
-            if (this.sessionQueues.get(sessionKey) === next) {
-                this.sessionQueues.delete(sessionKey);
-            }
+            releaseConversationWork();
         }
     }
-    async runSession({ event, bot, context }) {
-        await this.orchestrator.runSession({ event, bot, context });
-    }
-    async createSessionSandbox(options) {
-        const state = await this.getOrCreateState(options);
-        return state.runner;
+    async runWithInstrumentation(context, meta, body) {
+        const { conversationId, sessionKey, startedAt } = meta;
+        const { message, platform } = context;
+        const attribution = createRunAttributionAttributes({
+            conversationId,
+            sessionKey,
+            messageId: message.id,
+            platform: platform.name,
+            userId: message.userId,
+            userName: message.userName,
+            threadTs: message.threadTs,
+        });
+        Sentry.metrics.count("agent.run.started", 1, {
+            attributes: attribution,
+        });
+        return Sentry.startSpan({ name: "agent.run", op: "agent", attributes: attribution }, async (span) => Sentry.withScope(async (scope) => {
+            registerTraceAttribution(span, attribution);
+            applyRunScope(scope, {
+                conversationId,
+                sessionKey,
+                messageId: message.id,
+                platform: platform.name,
+                userId: message.userId,
+                userName: message.userName,
+                threadTs: message.threadTs,
+            });
+            addLifecycleBreadcrumb("agent.run.started", {
+                channel_id: conversationId,
+                platform: platform.name,
+                has_attachments: (message.attachments?.length ?? 0) > 0,
+            });
+            try {
+                const result = await body();
+                const durationMs = Date.now() - startedAt;
+                const completionAttrs = {
+                    ...attribution,
+                    stop_reason: result.stopReason,
+                };
+                Sentry.metrics.distribution("agent.run.duration", durationMs, {
+                    unit: "millisecond",
+                    attributes: completionAttrs,
+                });
+                Sentry.metrics.count("agent.run.completed", 1, { attributes: completionAttrs });
+                addLifecycleBreadcrumb("agent.run.completed", {
+                    channel_id: conversationId,
+                    platform: platform.name,
+                    stop_reason: result.stopReason,
+                    duration_ms: durationMs,
+                });
+                return result;
+            }
+            catch (err) {
+                scope.setContext("agent_run_error", {
+                    conversationId,
+                    sessionKey,
+                    platform: platform.name,
+                    messageId: message.id,
+                    threadTs: message.threadTs,
+                });
+                reportUserFacingError(err, {
+                    domain: "mikan",
+                    surface: "agent_run",
+                    operation: "run",
+                    severity: "error",
+                    platform: platform.name,
+                    context: {
+                        conversationId,
+                        sessionKey,
+                        messageId: message.id,
+                        threadTs: message.threadTs,
+                        attachmentCount: message.attachments?.length ?? 0,
+                    },
+                });
+                Sentry.metrics.count("agent.run.errors", 1, {
+                    attributes: attribution,
+                });
+                log.logWarning(`[${conversationId}] Run error`, err instanceof Error ? err.message : String(err));
+                return undefined;
+            }
+        }));
     }
     switchConversationModel(conversationId, _provider, _model) {
+        this.bumpConversationRunnerGeneration(conversationId);
         return this.clearConversationStates(conversationId, `[${conversationId}] Model switched; cleared cached session runners`);
     }
     refreshConversationEnvironment(conversationId) {
+        this.bumpConversationRunnerGeneration(conversationId);
         return this.clearConversationStates(conversationId, `[${conversationId}] Environment refreshed; cleared cached session runners`);
     }
-    isConversationSession(sessionKey, conversationId) {
-        return sessionKey === conversationId || sessionKey.startsWith(`${conversationId}:`);
-    }
-    clearConversationStates(conversationId, message) {
-        for (const [sessionKey, state] of this.conversationStates) {
-            if (this.isConversationSession(sessionKey, conversationId) && state.running) {
-                return false;
+    refreshAllConversations() {
+        this.globalRunnerGeneration++;
+        const busy = [];
+        for (const conversationId of this.sessions.conversationIds()) {
+            const cleared = this.clearConversationStates(conversationId, `[${conversationId}] Global settings changed; cleared cached session runners`);
+            if (!cleared) {
+                this.sessions.deferConversationClear(conversationId);
+                busy.push(conversationId);
             }
         }
-        for (const sessionKey of Array.from(this.conversationStates.keys())) {
-            if (this.isConversationSession(sessionKey, conversationId)) {
-                this.conversationStates.delete(sessionKey);
-            }
+        return { busy };
+    }
+    clearConversationStates(conversationId, message) {
+        const cleared = this.sessions.clearConversation(conversationId);
+        if (cleared)
+            log.logInfo(message);
+        return cleared;
+    }
+    bumpConversationRunnerGeneration(conversationId) {
+        this.conversationRunnerGenerations.set(conversationId, (this.conversationRunnerGenerations.get(conversationId) ?? 0) + 1);
+    }
+    runnerGeneration(conversationId) {
+        return `${this.globalRunnerGeneration}:${this.conversationRunnerGenerations.get(conversationId) ?? 0}`;
+    }
+    async createCurrentRunner(options, conversationDir, sessionScope) {
+        while (true) {
+            const generation = this.runnerGeneration(options.conversationId);
+            const runner = await createRunner({
+                sandboxConfig: this.options.sandbox,
+                sessionKey: options.sessionKey,
+                conversationId: options.conversationId,
+                conversationDir,
+                workspaceDir: this.options.workingDir,
+                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,
+                platformToolPackFactories: this.options.platformToolPackFactories,
+                models: this.resolvedModels,
+            });
+            if (generation === this.runnerGeneration(options.conversationId))
+                return runner;
+            await runner.dispose();
         }
-        log.logInfo(message);
-        return true;
     }
     async getOrCreateState(options) {
         const { conversationId, sessionKey, currentMessageId } = options;
-        const existing = this.conversationStates.get(sessionKey);
+        const existing = this.sessions.get(sessionKey);
         if (existing?.running)
             return existing;
         const conversationDir = join(this.options.workingDir, conversationId);
@@ -157,24 +560,25 @@ class ConversationRuntimeImpl {
             sessionKey,
             cwd: runtimeCwd,
             currentMessageId,
-            rotateTopLevelSession: options.conversationKind === "shared" && sessionKey === conversationId,
+            rotateTopLevelSession: false,
         });
         if (existing && existing.sessionFile === sessionScope.contextFile) {
             existing.lastAccessedAt = Date.now();
             return existing;
         }
+        // A stale state (rotated session file) is being replaced: release the old
+        // runner's extension resources before the new one takes the slot.
+        if (existing)
+            this.sessions.discard(sessionKey);
         const state = {
             running: false,
-            runner: await createRunner(this.options.sandbox, sessionKey, conversationId, conversationDir, this.options.workingDir, sessionScope, this.options.vaultManager, this.options.provisioner, {
-                tokenStore: this.options.sessionViewTokenStore,
-                portalBaseUrl: this.options.portalBaseUrl,
-            }, this.options.platformNotifier),
+            runner: await this.createCurrentRunner(options, conversationDir, sessionScope),
             stopRequested: false,
             lastAccessedAt: Date.now(),
             sessionFile: sessionScope.contextFile,
             startedAt: 0,
         };
-        this.conversationStates.set(sessionKey, state);
+        this.sessions.set(sessionKey, state);
         return state;
     }
     async shutdown(timeoutMs = 30_000) {
@@ -197,26 +601,5 @@ class ConversationRuntimeImpl {
             });
         }
     }
-    evictIdleSessions() {
-        const now = Date.now();
-        for (const [key, state] of this.conversationStates) {
-            if (!state.running && now - state.lastAccessedAt > IDLE_TIMEOUT_MS) {
-                this.conversationStates.delete(key);
-            }
-        }
-        if (this.conversationStates.size > MAX_SESSIONS) {
-            const idleSessions = [];
-            for (const [key, state] of this.conversationStates) {
-                if (!state.running) {
-                    idleSessions.push({ key, lastAccessedAt: state.lastAccessedAt });
-                }
-            }
-            idleSessions.sort((a, b) => a.lastAccessedAt - b.lastAccessedAt);
-            const toEvict = this.conversationStates.size - MAX_SESSIONS;
-            for (let i = 0; i < toEvict && i < idleSessions.length; i++) {
-                this.conversationStates.delete(idleSessions[i].key);
-            }
-        }
-    }
 }
 //# sourceMappingURL=conversation-runtime.js.map