@geminixiang/mikan 1.0.0-beta.7 → 1.0.0-beta.70

package/dist/runtime/conversation-runtime.js

@@ -1,18 +1,55 @@
-import { createRunner } from "../agent.js";
-import { defaultCommandHandlers } from "../commands/registry.js";
+import { createRunner } from "../harness/runner.js";
+import { commitOfficeDream, generateMemoryAnchor, prepareOfficeDream } from "../dream/index.js";
+import { MikanModels } from "../harness/index.js";
+import { defaultCommandHandlers, dispatchCommand } from "../adapters/commands/registry.js";
+import { isPrivateConversation } from "../adapters/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 * 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;
-function runtimeCwdForSandbox(sandbox, hostWorkspaceRoot, conversationId) {
-    const runtimeWorkspaceRoot = getUnresolvedSandboxPathContext(sandbox, hostWorkspaceRoot).runtimeWorkspaceRoot;
-    return `${runtimeWorkspaceRoot.replace(/\/+$/, "")}/${conversationId}`;
+import { addLifecycleEvent, createRunAttributionAttributes, recordCounter, recordDistribution, recordGauge, reportUserFacingError, withRunSpan, } from "../observability/index.js";
+import { ChatHistorySync, hasMaterializedChatSession, waitForThreadSessionBootstrap, } from "../sessions/chat-history-sync.js";
+import { getThreadSessionFile, resolveChannelSessionFile, shouldRotateTopLevelSession, tryResolveThreadSession, } from "../sessions/store.js";
+import { assertSessionKeyBelongsToConversation, deriveSessionKey, threadSuffixOf, } from "../sessions/session-key.js";
+import { formatNothingRunning, formatRestarting, formatStopped, formatStopping, } from "../adapters/messages.js";
+import { getUnresolvedSandboxPathContext } from "../sandbox/index.js";
+import { disabledVaultManager } from "../vault/index.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, workspace, address) {
+    const runtimeWorkspaceRoot = getUnresolvedSandboxPathContext(sandbox, workspace.root).runtimeWorkspaceRoot;
+    // The office key names the same segment on the host and in the runtime.
+    return `${runtimeWorkspaceRoot.replace(/\/+$/, "")}/${workspace.office(address).key}`;
+}
+/** Ask a running session to stop; the run settles through its own abort path. */
+function requestStop(state) {
+    state.stopRequested = true;
+    state.runner.abort();
+}
+/** Tell the conversation why its reply stopped: an operator stop, or a shutdown deadline. */
+async function postAbortNotice(state, bot, conversationId, platformName) {
+    if (state.shutdownAborted) {
+        recordCounter("agent.run.shutdown_aborted", 1, { platform: platformName });
+        await bot.postMessage(conversationId, formatRestarting(bot));
+        return;
+    }
+    if (!state.stopRequested)
+        return;
+    if (state.stopNoticeOwned)
+        return;
+    const thread = threadSuffixOf(state.sessionKey);
+    if (thread && bot.postInThread)
+        await bot.postInThread(conversationId, thread, formatStopped(bot));
+    else
+        await bot.postMessage(conversationId, formatStopped(bot));
 }
 export function createConversationRuntime(options) {
     return new ConversationRuntimeImpl(options);
@@ -20,203 +57,437 @@ export function createConversationRuntime(options) {
 class ConversationRuntimeImpl {
     constructor(options) {
         this.options = options;
-        this.conversationStates = new Map();
-        this.sessionQueues = new Map();
-        this.inFlightRuns = new Set();
-        this.chatSessionManager = new AgentMemoryFileManager();
+        this.sessions = new SessionLifecycle();
+        this.chatSessionManager = new ChatHistorySync();
         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);
-        return !!state?.running;
+    isRunning(address, sessionKey) {
+        return this.sessions.get(address, sessionKey)?.running === true;
     }
     getRunningSessions() {
         const sessions = [];
-        for (const [sessionKey, state] of this.conversationStates) {
-            if (state.running && state.startedAt) {
+        for (const state of this.sessions.runningStates()) {
+            if (state.startedAt) {
                 const currentStep = state.runner.getCurrentStep();
                 sessions.push({
-                    sessionKey,
+                    address: state.address,
+                    sessionKey: state.sessionKey,
                     startedAt: state.startedAt,
                     lastActivityAt: state.lastActivityAt,
                     currentTool: currentStep?.label || currentStep?.toolName,
+                    ...(state.stopRequested ? { stopping: true } : {}),
                 });
             }
         }
         return sessions;
     }
-    async handleStop(sessionKey, conversationId, bot) {
-        const state = this.conversationStates.get(sessionKey);
-        if (state?.running) {
-            state.stopRequested = true;
-            state.runner.abort();
-            const ts = await bot.postMessage(conversationId, formatStopping(bot));
-            state.stopMessageTs = ts;
+    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 steer(message) {
+        const state = this.sessions.get(message.address, message.sessionKey);
+        if (!state?.running)
+            return false;
+        return state.runner.steer ? state.runner.steer(message) : false;
+    }
+    async handleStop(address, sessionKey, bot, replyThreadTs) {
+        assertSessionKeyBelongsToConversation(sessionKey, address.conversationId);
+        const post = (text) => replyThreadTs && bot.postInThread
+            ? bot.postInThread(address.conversationId, replyThreadTs, text)
+            : bot.postMessage(address.conversationId, text);
+        const state = this.sessions.get(address, sessionKey);
+        if (!state?.running) {
+            await post(formatNothingRunning(bot));
+            return;
+        }
+        const settlement = state.runSettlement;
+        state.stopNoticeOwned = true;
+        requestStop(state);
+        try {
+            const ts = await post(formatStopping(bot));
+            await settlement;
+            await bot.updateMessage(address.conversationId, ts, formatStopped(bot));
         }
-        else {
-            await bot.postMessage(conversationId, formatNothingRunning(bot));
+        finally {
+            state.stopNoticeOwned = false;
         }
     }
-    forceStop(sessionKey) {
-        const state = this.conversationStates.get(sessionKey);
+    forceStop(address, sessionKey) {
+        const state = this.sessions.get(address, sessionKey);
         if (state?.running) {
             log.logInfo(`[Force Stop] Force stopping session: ${sessionKey}`);
-            state.stopRequested = true;
-            state.runner.abort();
-            state.running = false;
+            requestStop(state);
         }
     }
-    async handleNewCommand(sessionKey, conversationId, bot) {
-        const state = this.conversationStates.get(sessionKey);
-        if (state?.running) {
-            state.stopRequested = true;
-            state.runner.abort();
+    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 ` +
+                JSON.stringify(address.conversationId));
         }
-        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);
+        assertSessionKeyBelongsToConversation(sessionKey, address.conversationId);
+        const activeState = this.sessions.get(address, sessionKey);
+        if (activeState?.runSettlement) {
+            if (activeState.running)
+                requestStop(activeState);
+            await activeState.runSettlement;
+        }
+        await this.sessions.runConversationMaintenance(address, async () => {
+            await this.resetSession(address, sessionKey, bot);
+        });
+    }
+    scheduleSharedSessionRotation({ event, bot, context }, sessionKey) {
+        const { address, conversationId } = event;
+        if (context.message.conversationKind !== "shared" || sessionKey !== conversationId)
+            return false;
+        const conversationDir = this.options.workspace.office(address).dir;
+        const currentSession = resolveChannelSessionFile(conversationDir);
+        if (!currentSession || !shouldRotateTopLevelSession(currentSession, new Date()))
+            return false;
+        void this.sessions
+            .runConversationMaintenance(address, async () => {
+            const session = resolveChannelSessionFile(conversationDir);
+            if (!session || !shouldRotateTopLevelSession(session, new Date())) {
+                await this.runSession({ event, bot, context }, true);
+                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}] Rotated session: ${sessionKey}`);
+            await this.runSession({ event, bot, context }, true);
+        })
+            .catch((err) => {
+            reportUserFacingError(err, {
+                domain: "mikan",
+                surface: "session_rotation",
+                operation: "rotate_shared_session_in_background",
+            });
+        });
+        return true;
+    }
+    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);
+        await this.chatSessionManager.resetSession({ conversationDir, sessionKey, cwd: runtimeCwd });
+        await this.sessions.discardAndWait(address, 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(event.address, sessionKey, () => this.runSession({ event, bot, context }));
+    }
+    async runSession(options, skipRotation = false) {
+        const { event } = options;
+        const conversationId = event.conversationId;
+        if (this.isShuttingDown) {
+            log.logInfo(`[${conversationId}] Rejected event during shutdown: ${event.text.substring(0, 50)}`);
+            return;
+        }
+        const sessionKey = deriveSessionKey(event);
+        if (await this.handledBeforeRun(options, sessionKey, skipRotation))
+            return;
+        const address = event.address;
+        const releaseConversationWork = skipRotation
+            ? () => { }
+            : await this.sessions.acquireConversationWork(address);
         try {
-            await next;
+            const conversationDir = this.options.workspace.office(address).dir;
+            await this.waitForParentSession(address, sessionKey, conversationDir);
+            const lease = await this.acquireRunLease(options, sessionKey);
+            const { state } = lease;
+            log.logInfo(`[${conversationId}] Starting run: ${event.text.substring(0, 50)}`);
+            const runPromise = this.sessions.settle(state, () => this.executeRun(options, sessionKey, state));
+            lease.release();
+            recordGauge("agent.sessions.active", this.sessions.settlementCount());
+            await runPromise;
         }
         finally {
-            if (this.sessionQueues.get(sessionKey) === next) {
-                this.sessionQueues.delete(sessionKey);
-            }
+            releaseConversationWork();
         }
     }
-    async runSession({ event, bot, context }) {
-        await this.orchestrator.runSession({ event, bot, context });
+    /**
+     * Guards that can settle an event before any runner work: a session command,
+     * an in-flight run for the same session, or a shared-session rotation.
+     * Returns true when the event needs no run of its own.
+     */
+    async handledBeforeRun(options, sessionKey, skipRotation) {
+        const { event } = options;
+        if (!skipRotation && (await this.dispatchSessionCommand(options, sessionKey)))
+            return true;
+        const activeSettlement = this.sessions.get(event.address, sessionKey)?.runSettlement;
+        if (activeSettlement)
+            await activeSettlement;
+        return (!skipRotation &&
+            sessionKey === event.conversationId &&
+            this.scheduleSharedSessionRotation(options, sessionKey));
     }
-    async createSessionSandbox(options) {
-        const state = await this.getOrCreateState(options);
-        return state.runner;
+    /** Lease the runner for a run, reporting session-setup failures before rethrowing. */
+    async acquireRunLease({ event, context }, sessionKey) {
+        let lease;
+        try {
+            lease = await this.acquireState({
+                address: event.address,
+                sessionKey,
+                currentMessageId: event.ts,
+                trustModel: context.platform.trustModel ?? "membership",
+                platformWorkspaceId: context.platform.workspaceId,
+            });
+            await lease.state.runner.syncChatHistory(event.ts);
+            return lease;
+        }
+        catch (err) {
+            lease?.release();
+            reportUserFacingError(err, {
+                domain: "mikan",
+                surface: "session_setup",
+                operation: "get_or_create_state",
+                severity: "error",
+                platform: context.platform.name,
+                context: {
+                    conversationId: event.conversationId,
+                    sessionKey,
+                    messageId: context.message.id,
+                    threadTs: context.message.threadTs,
+                    attachmentCount: context.message.attachments?.length ?? 0,
+                },
+            });
+            throw err;
+        }
     }
-    switchConversationModel(conversationId, _provider, _model) {
-        return this.clearConversationStates(conversationId, `[${conversationId}] Model switched; cleared cached session runners`);
+    /** The instrumented agent run, with typing/working indicators and abort notice. */
+    async executeRun({ event, bot, context }, sessionKey, state) {
+        const conversationId = event.conversationId;
+        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") {
+                await postAbortNotice(state, bot, conversationId, context.platform.name);
+            }
+        }
+        finally {
+            recordGauge("agent.sessions.active", this.sessions.settlementCount() - 1);
+        }
     }
-    refreshConversationEnvironment(conversationId) {
-        return this.clearConversationStates(conversationId, `[${conversationId}] Environment refreshed; cleared cached session runners`);
+    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}`);
+        }
     }
-    isConversationSession(sessionKey, conversationId) {
-        return sessionKey === conversationId || sessionKey.startsWith(`${conversationId}:`);
+    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,
+        });
     }
-    clearConversationStates(conversationId, message) {
-        for (const [sessionKey, state] of this.conversationStates) {
-            if (this.isConversationSession(sessionKey, conversationId) && state.running) {
-                return false;
+    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,
+            conversationKind: message.conversationKind,
+            userId: message.userId,
+            userName: message.userName,
+            threadTs: message.threadTs,
+        });
+        recordCounter("agent.run.started", 1, attribution);
+        return withRunSpan({
+            conversationId,
+            sessionKey,
+            messageId: message.id,
+            platform: platform.name,
+            conversationKind: message.conversationKind,
+            userId: message.userId,
+            userName: message.userName,
+            threadTs: message.threadTs,
+        }, async () => {
+            addLifecycleEvent("agent.run.started", {
+                channel_id: attribution.channel_id,
+                platform: platform.name,
+                conversation_kind: message.conversationKind,
+                has_attachments: (message.attachments?.length ?? 0) > 0,
+            });
+            try {
+                const result = await body();
+                const durationMs = Date.now() - startedAt;
+                const completionAttrs = {
+                    ...attribution,
+                    stop_reason: result.stopReason,
+                };
+                recordDistribution("agent.run.duration", durationMs, {
+                    unit: "millisecond",
+                    attributes: completionAttrs,
+                });
+                recordCounter("agent.run.completed", 1, completionAttrs);
+                addLifecycleEvent("agent.run.completed", {
+                    channel_id: attribution.channel_id,
+                    platform: platform.name,
+                    stop_reason: result.stopReason,
+                    duration_ms: durationMs,
+                });
+                return result;
             }
-        }
-        for (const sessionKey of Array.from(this.conversationStates.keys())) {
-            if (this.isConversationSession(sessionKey, conversationId)) {
-                this.conversationStates.delete(sessionKey);
+            catch (err) {
+                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,
+                    },
+                });
+                recordCounter("agent.run.errors", 1, attribution);
+                log.logWarning(`[${conversationId}] Run error`, err instanceof Error ? err.message : String(err));
+                await context.responder
+                    .replaceResponse("Could not complete the request. Please reply to retry or revise it.")
+                    .catch(() => { });
+                return undefined;
             }
+        });
+    }
+    switchConversationModel(address, _provider, _model) {
+        return this.invalidateOffice(address, "Model switched");
+    }
+    refreshConversationEnvironment(address) {
+        return this.invalidateOffice(address, "Environment refreshed");
+    }
+    refreshAllConversations() {
+        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`);
         }
-        log.logInfo(message);
-        return true;
+        return result;
+    }
+    invalidateOffice(address, reason) {
+        const cleared = this.sessions.invalidateConversation(address);
+        if (cleared) {
+            log.logInfo(`[${address.conversationId}] ${reason}; cleared cached session runners`);
+        }
+        return cleared;
     }
-    async getOrCreateState(options) {
-        const { conversationId, sessionKey, currentMessageId } = options;
-        const existing = this.conversationStates.get(sessionKey);
-        if (existing?.running)
-            return existing;
-        const conversationDir = join(this.options.workingDir, conversationId);
-        const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workingDir, conversationId);
+    async createCurrentRunner(options, sessionScope, signal) {
+        return createRunner({
+            sandboxConfig: this.options.sandbox,
+            sessionKey: options.sessionKey,
+            office: this.options.workspace.office(options.address),
+            trustModel: options.trustModel,
+            platformWorkspaceId: options.platformWorkspaceId,
+            openConnector: this.options.openConnector,
+            eventScheduler: this.options.eventScheduler?.(),
+            sessionScope,
+            signal,
+            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,
+        });
+    }
+    acquireState(options) {
+        const { address, sessionKey } = options;
+        const conversationDir = this.options.workspace.office(address).dir;
+        return this.sessions.acquire(address, sessionKey, () => sessionKey === address.conversationId
+            ? resolveChannelSessionFile(conversationDir)
+            : tryResolveThreadSession(getThreadSessionFile(conversationDir, sessionKey)), (signal) => this.materializeState(options, conversationDir, signal));
+    }
+    async materializeState(options, conversationDir, signal) {
+        signal.throwIfAborted();
+        const { address, sessionKey, currentMessageId } = options;
+        const runtimeCwd = runtimeCwdForSandbox(this.options.sandbox, this.options.workspace, address);
         const sessionScope = await this.chatSessionManager.resolveSessionScope({
             conversationDir,
             sessionKey,
             cwd: runtimeCwd,
             currentMessageId,
-            rotateTopLevelSession: options.conversationKind === "shared" && sessionKey === conversationId,
         });
-        if (existing && existing.sessionFile === sessionScope.contextFile) {
-            existing.lastAccessedAt = Date.now();
-            return existing;
-        }
-        const state = {
+        signal.throwIfAborted();
+        return {
+            address,
+            sessionKey,
             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, this.options.platformReactor),
+            runner: await this.createCurrentRunner(options, sessionScope, signal),
             stopRequested: false,
             lastAccessedAt: Date.now(),
             sessionFile: sessionScope.contextFile,
             startedAt: 0,
         };
-        this.conversationStates.set(sessionKey, 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(`Forcing exit with ${this.inFlightRuns.size} runs still in progress`);
-            reportUserFacingError(new Error("Shutdown forced with in-flight agent runs"), {
-                domain: "mikan",
-                surface: "shutdown",
-                operation: "force_exit_with_inflight_runs",
-                severity: "warning",
-                context: { inFlightRuns: this.inFlightRuns.size, timeoutMs },
-            });
-        }
-    }
-    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);
-            }
-        }
+        await this.sessions.shutdown(timeoutMs);
     }
 }
 //# sourceMappingURL=conversation-runtime.js.map