@geminixiang/mikan 1.0.0-beta.9 → 1.0.0-beta.90

package/dist/office/types.d.ts

@@ -0,0 +1,44 @@
+import type { ContainerMount, OfficeAddress, OfficeKey, WorkspaceVisibility } from "../types.js";
+export interface GithubConversationRef {
+    owner: string;
+    repo: string;
+    number: number;
+}
+export interface Workspace {
+    readonly root: string;
+    readonly stateDir: string;
+    readonly memoryPath: string;
+    readonly skillsDir: string;
+    readonly agentsDir: string;
+    readonly reservedNames: ReadonlySet<string>;
+    office(address: OfficeAddress): Office;
+}
+export interface Office {
+    readonly address: OfficeAddress;
+    readonly key: OfficeKey;
+    readonly dir: string;
+    readonly memoryPath: string;
+    readonly skillsDir: string;
+    readonly sessionsPath: string;
+    readonly attachmentsDir: string;
+    readonly logPath: string;
+    readonly stateDir: string;
+    readonly workspace: Workspace;
+    ensure(): string;
+}
+export type PlatformChannelKind = "public_channel" | "private_channel" | "im" | "external";
+interface WorkspacePromptSources {
+    conversationMemoryPath: string;
+    conversationSkillsDir: string;
+    globalMemoryPath: string;
+    globalSkillsDir: string;
+    globalKnowledgeReadOnly?: boolean;
+}
+export interface WorkspaceProjection {
+    visibility: WorkspaceVisibility;
+    source: "platform" | "override" | "unknown";
+    mounts: ContainerMount[];
+    promptSources: WorkspacePromptSources;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/office/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/office/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEjG,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAC9B,MAAM,IAAI,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,IAAI,GAAG,UAAU,CAAC;AAE3F,UAAU,sBAAsB;IAC9B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,mBAAmB,CAAC;IAChC,MAAM,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IAC5C,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,aAAa,EAAE,sBAAsB,CAAC;CACvC"}

package/dist/office/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/office/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/office/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ContainerMount, OfficeAddress, OfficeKey, WorkspaceVisibility } from \"../types.js\";\n\nexport interface GithubConversationRef {\n  owner: string;\n  repo: string;\n  number: number;\n}\n\nexport interface Workspace {\n  readonly root: string;\n  readonly stateDir: string;\n  readonly memoryPath: string;\n  readonly skillsDir: string;\n  readonly agentsDir: string;\n  readonly reservedNames: ReadonlySet<string>;\n  office(address: OfficeAddress): Office;\n}\n\nexport interface Office {\n  readonly address: OfficeAddress;\n  readonly key: OfficeKey;\n  readonly dir: string;\n  readonly memoryPath: string;\n  readonly skillsDir: string;\n  readonly sessionsPath: string;\n  readonly attachmentsDir: string;\n  readonly logPath: string;\n  readonly stateDir: string;\n  readonly workspace: Workspace;\n  ensure(): string;\n}\n\nexport type PlatformChannelKind = \"public_channel\" | \"private_channel\" | \"im\" | \"external\";\n\ninterface WorkspacePromptSources {\n  conversationMemoryPath: string;\n  conversationSkillsDir: string;\n  globalMemoryPath: string;\n  globalSkillsDir: string;\n  globalKnowledgeReadOnly?: boolean;\n}\n\nexport interface WorkspaceProjection {\n  visibility: WorkspaceVisibility;\n  source: \"platform\" | \"override\" | \"unknown\";\n  mounts: ContainerMount[];\n  promptSources: WorkspacePromptSources;\n}\n"]}

package/dist/runtime/conversation-runtime.d.ts

@@ -1,4 +1,3 @@
-export type { CreateSessionSandboxOptions, RunSessionOptions, ConversationRuntime, ConversationRuntimeOptions, } from "./types.js";
 import type { ConversationRuntime, ConversationRuntimeOptions } from "./types.js";
 export declare function createConversationRuntime(options: ConversationRuntimeOptions): ConversationRuntime;
 //# sourceMappingURL=conversation-runtime.d.ts.map

package/dist/runtime/conversation-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conversation-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/conversation-runtime.ts"],"names":[],"mappings":"AAuBA,YAAY,EACV,2BAA2B,EAC3B,iBAAiB,EACjB,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAGV,mBAAmB,EACnB,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAiBpB,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,0BAA0B,GAClC,mBAAmB,CAErB"}
+{"version":3,"file":"conversation-runtime.d.ts","sourceRoot":"","sources":["../../src/runtime/conversation-runtime.ts"],"names":[],"mappings":"AAmDA,OAAO,KAAK,EAEV,mBAAmB,EACnB,0BAA0B,EAE3B,MAAM,YAAY,CAAC;AA0CpB,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,0BAA0B,GAClC,mBAAmB,CAErB"}

package/dist/runtime/conversation-runtime.js

@@ -1,18 +1,45 @@
-import { createRunner } from "../agent.js";
-import { defaultCommandHandlers } from "../commands/registry.js";
+import { createRunner } from "../harness/runner.js";
+import { MikanModels } from "../harness/models.js";
+import { isCommandText } from "../adapters/commands/manifest.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 { assertSessionKeyBelongsToConversation, deriveSessionKey, threadSuffixOf, } from "../sessions/session-key.js";
+import { formatNothingRunning, formatRestarting, formatStopped, formatStopping, } from "../adapters/messages.js";
+import { disabledVaultManager } from "../vault/index.js";
+import { SessionLifecycle } from "./session-lifecycle.js";
+import { errorMessage } from "../unknown-values.js";
+function portalNotConfiguredTokenStore(portal) {
+    return {
+        create: () => {
+            throw new Error(`${portal} portal not configured`);
+        },
+    };
+}
+function requestStop(state) {
+    state.stopRequested = true;
+    state.runner.abort();
+}
+async function postAbortNotice(state, bot, conversationId, platformName) {
+    if (state.shutdownAborted) {
+        recordCounter("agent.run.shutdown_aborted", 1, { platform: platformName });
+        const text = formatRestarting(bot);
+        const ts = await bot.postMessage(conversationId, text);
+        bot.logBotResponse?.(conversationId, text, ts);
+        return;
+    }
+    if (!state.stopRequested)
+        return;
+    if (state.stopNoticeOwned)
+        return;
+    const thread = threadSuffixOf(state.sessionKey) ?? undefined;
+    const text = formatStopped(bot);
+    const ts = thread && bot.postInThread
+        ? await bot.postInThread(conversationId, thread, text)
+        : await bot.postMessage(conversationId, text);
+    bot.logBotResponse?.(conversationId, text, ts, thread);
 }
 export function createConversationRuntime(options) {
     return new ConversationRuntimeImpl(options);
@@ -20,203 +47,386 @@ 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({ isCommandText });
         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.memoryCapture = options.memoryCapture?.(this.resolvedModels);
+        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,
+                    stopping: state.stopRequested ? true : undefined,
                 });
             }
         }
         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 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 = async (text) => {
+            const ts = replyThreadTs && bot.postInThread
+                ? await bot.postInThread(address.conversationId, replyThreadTs, text)
+                : await bot.postMessage(address.conversationId, text);
+            bot.logBotResponse?.(address.conversationId, text, ts, replyThreadTs);
+            return ts;
+        };
+        const state = this.sessions.get(address, sessionKey);
+        if (!state?.running) {
+            await post(formatNothingRunning(bot));
+            return;
         }
-        else {
-            await bot.postMessage(conversationId, formatNothingRunning(bot));
+        const settlement = state.runSettlement;
+        state.stopNoticeOwned = true;
+        requestStop(state);
+        try {
+            const ts = await post(formatStopping(bot));
+            await settlement;
+            const stoppedText = formatStopped(bot);
+            await bot.updateMessage(address.conversationId, ts, stoppedText);
+            bot.logBotResponse?.(address.conversationId, stoppedText, ts, replyThreadTs);
+        }
+        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({ bot, message }) {
+        const { address, sessionKey } = message;
+        assertSessionKeyBelongsToConversation(sessionKey, address.conversationId);
+        const activeState = this.sessions.get(address, sessionKey);
+        if (activeState?.runSettlement) {
+            if (activeState.running)
+                requestStop(activeState);
+            await activeState.runSettlement;
         }
-        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);
+        await this.sessions.runConversationMaintenance(address, async () => {
+            await this.resetSession(address, sessionKey, bot);
+        });
+    }
+    async resetSession(address, sessionKey, bot) {
+        const conversationId = address.conversationId;
+        const office = this.options.workspace.office(address);
+        await this.sessions.discardAndWait(address, sessionKey);
+        await this.chatSessionManager.resetSession({ office, 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) {
+        const { event } = options;
+        const conversationId = event.address.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))
+            return;
+        const address = event.address;
+        const releaseConversationWork = await this.sessions.acquireConversationWork(address);
         try {
-            await next;
+            await this.waitForParentSession(address, sessionKey);
+            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 });
+    async handledBeforeRun(options, sessionKey) {
+        const { event } = options;
+        if (await this.dispatchSessionCommand(options, sessionKey))
+            return true;
+        const activeSettlement = this.sessions.get(event.address, sessionKey)?.runSettlement;
+        if (activeSettlement)
+            await activeSettlement;
+        return false;
     }
-    async createSessionSandbox(options) {
-        const state = await this.getOrCreateState(options);
-        return state.runner;
+    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.address.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`);
+    async executeRun({ event, bot, context }, sessionKey, state) {
+        const conversationId = event.address.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);
+            }
+            if (result) {
+                this.memoryCapture?.capture({
+                    office: this.options.workspace.office(event.address),
+                    message: context.message,
+                    stopReason: result.stopReason,
+                    reply: result.finalText ?? "",
+                });
+            }
+        }
+        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) {
+        const conversationId = address.conversationId;
+        const office = this.options.workspace.office(address);
+        const waited = await waitForThreadSessionBootstrap({
+            parentSessionKey: conversationId,
+            sessionKey,
+            hasThreadSession: () => hasMaterializedChatSession({ office, 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.address.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,
+            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,
+            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`, errorMessage(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;
     }
-    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);
+    invalidateOffice(address, reason) {
+        const cleared = this.sessions.invalidateConversation(address);
+        if (cleared) {
+            log.logInfo(`[${address.conversationId}] ${reason}; cleared cached session runners`);
+        }
+        return cleared;
+    }
+    async createCurrentRunner(options, sessionScope, signal) {
+        const runnerFactory = this.options.runnerFactory ?? createRunner;
+        return runnerFactory({
+            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,
+            chatHistory: this.chatSessionManager,
+            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,
+            runEvents: this.options.runEvents,
+        });
+    }
+    acquireState(options) {
+        const { address, sessionKey } = options;
+        const office = this.options.workspace.office(address);
+        return this.sessions.acquire(address, sessionKey, (signal) => this.materializeState(options, office, signal));
+    }
+    async materializeState(options, office, signal) {
+        signal.throwIfAborted();
+        const { address, sessionKey, currentMessageId } = options;
         const sessionScope = await this.chatSessionManager.resolveSessionScope({
-            conversationDir,
+            office,
             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, this.options.platformPrCreator),
+            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