@geminixiang/mikan 1.0.0-beta.53 → 1.0.0-beta.55

package/dist/harness/runner.js

@@ -1,491 +1,523 @@
-/**
- * MikanAgentSession — mikan's agent run loop.
- *
- * Owns a pi-agent-core `Agent` and layers on the behaviors mikan needs for
- * long-lived chat conversations:
- *
- * - message persistence into the conversation's {@link SessionStore}
- * - automatic context compaction (threshold and overflow recovery), using
- *   pi-agent-core's compaction pipeline over the session tree
- * - automatic retry with exponential backoff on transient provider errors
- *
- * Events mirror the agent's lifecycle events plus `compaction_start/_end`
- * and `auto_retry_start/_end`, preserving the event surface mikan's
- * platform adapters already render.
- */
-import { Agent, calculateContextTokens, compact, convertToLlm, estimateContextTokens, getOrThrow, prepareCompaction, shouldCompact, TODO_CONTEXT, withAbortSignal, } from "@earendil-works/pi-agent-core";
-import { isContextOverflow, isRetryableAssistantError, } from "@earendil-works/pi-ai";
+import { MikanModels } from "./models.js";
+import { MikanAgentSession, DEFAULT_EVENT_BUDGET } from "./session.js";
+import { runSubagent, DEFAULT_GLOBAL_SUBAGENT_SLOTS, SubagentSlotPool } from "./subagent.js";
+import { loadSubagentProfiles } from "./subagent-profiles.js";
+import { createMikanTools, createSubagentTool } from "./tools/index.js";
+import { adaptAgentTool } from "./tools/pi-tools.js";
+import { createSandboxExecutionEnv } from "./execution-env.js";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ActorExecutionResolver } from "./execution-resolver.js";
+import { assertSandboxSupportsWorkspacePolicy, createExecutor, getUnresolvedSandboxPathContext, } from "../sandbox/index.js";
+import { resolveWorkspaceProjection } from "../office/projection.js";
+import { createHash } from "node:crypto";
+import { resolveConversationSettings } from "../config.js";
+import { provisionOfficeOpenConnectorToken } from "./open-connector.js";
+import { addLifecycleEvent, updateActiveSpanAttribution } from "../observability/index.js";
+import { ChatHistorySync } from "../sessions/chat-history-sync.js";
+import { conversationIdOf, isThreadSessionKey } from "../sessions/session-key.js";
+import { extractSessionUuid, openManagedSession, } from "../sessions/store.js";
+import { loadMikanSkills } from "./skills.js";
+import { normalizeAttachRuntimePath, withStagedRuntimeFile, buildPromptPayload, buildSystemPrompt, buildTurnInstructions, getMemory, resolveTriggerAttribution, } from "./prompt.js";
+import { attachSessionEventHandlers, activateRunPresentation, createRunState, finalizeRunResponse, isEventTriggerAttribution, reportUsageSummary, } from "./presenter.js";
 import * as log from "../log.js";
-import { resolveHarnessSettings } from "./settings.js";
-import { addUsage, copyUsage, createEmptyUsage } from "./usage.js";
-function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        if (signal.aborted) {
-            reject(new Error("aborted"));
-            return;
-        }
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new Error("aborted"));
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
+// One process-wide fan-out account: per-conversation queues serialize runs,
+// but each run can fan out up to the per-run cap — without this shared
+// ceiling, N busy conversations hold N × cap live subagent sessions.
+const globalSubagentSlots = new SubagentSlotPool(DEFAULT_GLOBAL_SUBAGENT_SLOTS);
+async function createConfiguredAgentSession(params) {
+    const { workspaceDir, systemPrompt, model, thinkingLevel, tools, toolContext, sessionStore, models, } = params;
+    const loadedProfiles = loadSubagentProfiles(workspaceDir);
+    for (const diagnostic of loadedProfiles.diagnostics) {
+        log.logWarning(`Subagent profile ignored: ${diagnostic.path}`, diagnostic.message);
+    }
+    const availableToolNames = new Set(tools.map((tool) => tool.name));
+    const runnableProfiles = new Map([...loadedProfiles.profiles].filter(([, profile]) => profile.tools.every((tool) => availableToolNames.has(tool))));
+    let session;
+    const subagentTool = createSubagentTool((request, hooks) => runSubagent({
+        request,
+        ...(hooks?.onActivity ? { onActivity: hooks.onActivity } : {}),
+        defaultModel: model,
+        thinkingLevel,
+        models,
+        workspaceDir,
+        availableTools: tools,
+        profiles: runnableProfiles,
+        slots: globalSubagentSlots,
+        toolContext,
+        parentMessages: [...session.messages],
+        onUsage: session.captureExternalUsageSink(),
+    }), runnableProfiles);
+    session = new MikanAgentSession({
+        systemPrompt,
+        model,
+        thinkingLevel,
+        tools: [...tools, adaptAgentTool(subagentTool)],
+        toolContext,
+        models,
+        sessionStore,
     });
+    const reloaded = await session.reloadFromSession();
+    if (reloaded > 0)
+        log.logInfo(`Reloaded ${reloaded} messages from session context`);
+    return session;
 }
-export class MikanAgentSession {
-    constructor(options) {
-        this.listeners = new Set();
-        this.retryAttempt = 0;
-        this.overflowRecoveryAttempted = false;
-        this.runActive = false;
-        this.tally = {
-            usage: createEmptyUsage(),
-            llmCalls: 0,
-            toolCalls: 0,
-            toolCallCounts: {},
-            startedAt: 0,
-        };
-        this.runBudget = {};
-        this.models = options.models;
-        this.sessionStore = options.sessionStore;
-        this.settings = resolveHarnessSettings(options.settings);
-        this.agent = new Agent({
-            initialState: {
-                systemPrompt: options.systemPrompt,
-                model: options.model,
-                thinkingLevel: options.thinkingLevel,
-                tools: options.tools,
-            },
-            convertToLlm,
-            streamFn: (model, context, streamOptions) => this.models.models.streamSimple(model, context, streamOptions),
-        });
-        this.agent.subscribe(async (event) => {
-            await this.handleAgentEvent(event);
-        });
-    }
-    /** Conversation transcript currently held by the agent. */
-    get messages() {
-        return this.agent.state.messages;
-    }
-    get model() {
-        return this.agent.state.model;
-    }
-    /** Whether this session currently owns a prompt, including pre-model hooks. */
-    get isActiveRun() {
-        return this.runActive;
-    }
-    /** Resource totals and terminal budget state from the most recent prompt. */
-    getLastRunStats() {
-        return {
-            usage: copyUsage(this.tally.usage),
-            tokens: this.tally.usage.totalTokens,
-            costUsd: this.tally.usage.cost.total,
-            llmCalls: this.tally.llmCalls,
-            toolCalls: this.tally.toolCalls,
-            toolCallCounts: { ...this.tally.toolCallCounts },
-            durationMs: this.tally.startedAt > 0 ? Date.now() - this.tally.startedAt : 0,
-            ...(this.budgetExceededReason ? { budgetExceededReason: this.budgetExceededReason } : {}),
-        };
-    }
-    /**
-     * Fold spend incurred outside this session's own LLM calls — e.g. subagent
-     * runs launched by a tool during the current prompt — into the run tally
-     * and enforce the run budget at the fold itself: a fold that lands over a
-     * resource ceiling aborts the run now instead of waiting for a next
-     * assistant message that may never come (and would be paid for). Complete
-     * usage is folded; external runs are not this session's turns.
-     */
-    /** Capture a usage sink bound to the tally owned by the current prompt run. */
-    captureExternalUsageSink() {
-        const tally = this.tally;
-        return async (usage) => {
-            addUsage(tally.usage, usage);
-            if (this.tally !== tally || this.budgetExceededReason || !this.runActive)
-                return;
-            const reason = this.resourceOverBudgetReason();
-            if (reason)
-                await this.exceedBudget(reason);
-        };
-    }
-    async foldExternalUsage(usage) {
-        await this.captureExternalUsageSink()(usage);
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    /** Replace the agent transcript from the persisted session tree. */
-    async reloadFromSession() {
-        const context = await this.sessionStore.buildSessionContext();
-        if (context.messages.length > 0) {
-            this.agent.state.messages = context.messages;
-        }
-        return context.messages.length;
-    }
-    /**
-     * Send a user prompt and run the agent loop to completion, including
-     * automatic retries and compaction.
-     *
-     * @param options.budget Per-run resource ceilings that override the session
-     *   defaults. Autonomous event runs should pass a budget so a runaway loop
-     *   is stopped even with no human watching.
-     */
-    async prompt(text, options) {
-        if (this.runActive)
-            throw new Error("Agent is already processing a prompt");
-        this.runActive = true;
-        const runSystemPrompt = this.agent.state.systemPrompt;
-        const runTools = this.agent.state.tools;
-        if (options?.tools)
-            this.agent.state.tools = options.tools;
-        try {
-            await this.runPrompt(text, options);
-        }
-        finally {
-            this.agent.state.systemPrompt = runSystemPrompt;
-            this.agent.state.tools = runTools;
-            this.runActive = false;
-        }
-    }
-    async runPrompt(text, options) {
-        this.retryAttempt = 0;
-        this.overflowRecoveryAttempted = false;
-        this.runBudget = { ...this.settings.budget, ...options?.budget };
-        this.budgetExceededReason = undefined;
-        this.tally = {
-            usage: createEmptyUsage(),
-            llmCalls: 0,
-            toolCalls: 0,
-            toolCallCounts: {},
-            startedAt: Date.now(),
-        };
-        await this.ensureAuthConfigured(this.agent.state.model);
-        // A previous turn may have ended over the threshold (for example after an
-        // abort); compact before adding new context on top.
-        const lastAssistant = this.findLastAssistantMessage();
-        if (lastAssistant && lastAssistant.stopReason !== "error") {
-            await this.checkThresholdCompaction(lastAssistant);
-        }
-        const userMessage = {
-            role: "user",
-            content: [{ type: "text", text }, ...(options?.images ?? [])],
-            timestamp: Date.now(),
-        };
-        await this.agent.prompt([userMessage]);
-        while (await this.handlePostRun())
-            await this.agent.continue();
-    }
-    /** Abort the active run, pending retry backoff, and in-flight compaction. */
-    abort() {
-        this.retryAbortController?.abort();
-        this.compactionAbortController?.abort();
-        this.agent.abort();
-    }
-    async ensureAuthConfigured(model) {
-        const auth = await this.models.getAuth(model);
-        if (!auth) {
-            throw new Error(`No credentials for provider "${model.provider}". Set the provider API key environment variable.`);
-        }
-    }
-    async emit(event) {
-        for (const listener of this.listeners) {
-            try {
-                await listener(event);
-            }
-            catch (err) {
-                log.logWarning("Harness event listener failed", err instanceof Error ? err.message : String(err));
+function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspace) {
+    const executionResolver = vaultManager && sandboxConfig.type !== "host"
+        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspace)
+        : undefined;
+    // activeExecutor is replaced at the start of each run() call when executionResolver
+    // is present, so the stable `executor` wrapper always delegates to the latest resolved value.
+    let activeExecutor = executionResolver !== undefined
+        ? createExecutor({ type: "host" })
+        : createExecutor(sandboxConfig);
+    const executor = {
+        exec(command, options) {
+            return activeExecutor.exec(command, options);
+        },
+        readFile(path, options) {
+            return activeExecutor.readFile(path, options);
+        },
+        readFileBase64(path, options) {
+            return activeExecutor.readFileBase64(path, options);
+        },
+        writeFile(path, content, options) {
+            return activeExecutor.writeFile(path, content, options);
+        },
+        getWorkspacePath(hostPath) {
+            return activeExecutor.getWorkspacePath(hostPath);
+        },
+        getSandboxConfig() {
+            return activeExecutor.getSandboxConfig();
+        },
+        getPathContext(hostWorkspaceRoot) {
+            return activeExecutor.getPathContext(hostWorkspaceRoot);
+        },
+    };
+    return {
+        executor,
+        async resolveForRun(context) {
+            if (executionResolver) {
+                const decision = await executionResolver.resolve(context);
+                activeExecutor = decision.executor;
+                return {
+                    pathContext: decision.pathContext,
+                    projection: decision.projection,
+                };
             }
-        }
-    }
-    async handleAgentEvent(event) {
-        if (event.type === "tool_execution_start") {
-            this.tally.toolCalls += 1;
-            this.tally.toolCallCounts[event.toolName] =
-                (this.tally.toolCallCounts[event.toolName] ?? 0) + 1;
-        }
-        if (event.type !== "message_end") {
-            await this.emit(event);
-            return;
-        }
-        const message = event.message;
-        if (message.role === "user" || message.role === "assistant" || message.role === "toolResult") {
-            await this.sessionStore.appendMessage(message);
-        }
-        else if (message.role === "custom") {
-            const custom = message;
-            await this.sessionStore.appendCustomMessageEntry(custom.customType, custom.content, custom.display, custom.details);
-        }
-        await this.emit({ ...event, message });
-        if (message.role === "assistant") {
-            this.recordUsage(message);
-            await this.enforceBudget(message);
-            if (message.stopReason !== "error") {
-                this.overflowRecoveryAttempted = false;
-                if (this.retryAttempt > 0) {
-                    await this.emit({ type: "auto_retry_end", success: true, attempt: this.retryAttempt });
-                    this.retryAttempt = 0;
-                }
-            }
-        }
+            const office = workspace.office(context.address);
+            const projection = resolveWorkspaceProjection(office);
+            assertSandboxSupportsWorkspacePolicy(sandboxConfig, projection.doorPolicy, projection.promptSources.globalMemoryReadOnly === true);
+            return {
+                pathContext: executor.getPathContext(workspace.root),
+                projection,
+            };
+        },
+    };
+}
+function buildThreadSessionName(message) {
+    const text = message?.text?.trim();
+    if (!text)
+        return undefined;
+    const userLabel = message?.userName || message?.user || "unknown";
+    return `[${userLabel}]: ${text}`;
+}
+async function resolveRunnerMcpServers(options) {
+    if (options.trustModel === "open-trigger")
+        return {};
+    return provisionOfficeOpenConnectorToken(options.office, options.platformWorkspaceId, options.servers, options.openConnector, options.signal);
+}
+async function preparePromptContext(params) {
+    const { message, platform, office, executor, resolveForRun, session } = params;
+    const conversationId = office.address.conversationId;
+    const decision = await resolveForRun({
+        address: message.address,
+        userId: message.userId,
+        trustModel: platform.trustModel,
+    });
+    const { pathContext, projection } = decision;
+    const reloaded = await session.reloadFromSession();
+    if (reloaded > 0) {
+        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from context`);
     }
-    /** Fold one assistant completion's usage into the running per-run tally. */
-    recordUsage(message) {
-        this.tally.llmCalls += 1;
-        const usage = message.usage;
-        if (!usage)
-            return;
-        addUsage(this.tally.usage, usage);
+    const memory = await getMemory(projection);
+    const conversationSkillLoad = loadMikanSkills(office, pathContext.runtimeWorkspaceRoot, projection);
+    const triggerAttribution = resolveTriggerAttribution(message);
+    const systemPrompt = buildSystemPrompt({
+        workspacePath: pathContext.runtimeWorkspaceRoot,
+        office,
+        memory,
+        sandboxConfig: executor.getSandboxConfig(),
+        platform,
+        skills: conversationSkillLoad.skills,
+        projection,
+        skippedSkillLinks: conversationSkillLoad.skippedSkillLinks,
+    });
+    session.setSystemPrompt(systemPrompt);
+    // A stable hash across turns verifies that turn-specific data did not leak
+    // into the provider-cacheable system prompt.
+    const promptHash = createHash("sha256").update(systemPrompt).digest("hex").slice(0, 8);
+    log.logInfo(`[${conversationId}] System prompt (base): ${systemPrompt.length} chars, sha ${promptHash}`);
+    return { pathContext, memory, systemPrompt, triggerAttribution };
+}
+function bindRunCapabilities(params, pathContext) {
+    const { message, responder, platform, office, executor, setEventContext, setSandboxContext, setUploadFunction, setImageUploadFunction, setReactFunction, bindPlatformToolPacks, } = params;
+    setEventContext({
+        platform: platform.name,
+        conversationId: office.address.conversationId,
+        conversationKind: message.conversationKind,
+        userId: message.userId,
+    });
+    setSandboxContext({ address: message.address, userId: message.userId });
+    setUploadFunction(async (filePath, title) => {
+        const runtimePath = normalizeAttachRuntimePath(filePath, pathContext.runtimeWorkspaceRoot);
+        await withStagedRuntimeFile(executor, runtimePath, (stagedPath) => responder.uploadFile(stagedPath, title));
+    });
+    // Generated images already live host-side and must not be staged through a sandbox.
+    setImageUploadFunction(async (hostPath, title) => {
+        await responder.uploadFile(hostPath, title);
+    });
+    // Unset reaction support when the active responder cannot react.
+    setReactFunction(responder.react ? async (emoji) => responder.react(emoji) : null);
+    bindPlatformToolPacks({
+        conversationId: office.address.conversationId,
+        platformName: platform.name,
+        threadTs: message.threadTs,
+    });
+}
+async function prepareRunContext(params) {
+    const { message, platform, office, executor } = params;
+    const sessionConversation = conversationIdOf(message.sessionKey);
+    await mkdir(join(office.dir, "scratch"), { recursive: true });
+    const { pathContext, memory, systemPrompt, triggerAttribution } = await preparePromptContext(params);
+    bindRunCapabilities(params, pathContext);
+    log.logInfo(`Context sizes - system: ${systemPrompt.length} chars, memory: ${memory.length} chars`);
+    log.logInfo(`Channels: ${platform.channels.length}, Users: ${platform.users.length}`);
+    const { userMessage, imageAttachments } = await buildPromptPayload(message, pathContext.runtimeWorkspaceRoot, pathContext, (runtimePath) => executor.readFileBase64(runtimePath));
+    const turnInstructions = buildTurnInstructions(message.id.startsWith("event:"), triggerAttribution, platform.name);
+    const finalUserMessage = turnInstructions ? `${turnInstructions}\n\n${userMessage}` : userMessage;
+    return {
+        sessionConversation,
+        userMessage: finalUserMessage,
+        imageAttachments,
+        triggerAttribution,
+    };
+}
+async function buildInitialSystemPrompt(params) {
+    const { office, pathContext, projection, sandboxConfig } = params;
+    const memory = await getMemory(projection);
+    const { skills, skippedSkillLinks } = loadMikanSkills(office, pathContext.runtimeWorkspaceRoot, projection);
+    return buildSystemPrompt({
+        workspacePath: pathContext.runtimeWorkspaceRoot,
+        office,
+        memory,
+        sandboxConfig,
+        platform: {
+            name: "chat",
+            formattingGuide: "",
+            channels: [],
+            users: [],
+            trustModel: "membership",
+        },
+        skills,
+        projection,
+        skippedSkillLinks,
+    });
+}
+async function rollbackRunnerResource(label, cleanup) {
+    try {
+        await cleanup();
     }
-    /** Compare the tally against the run budget; abort the run when a cap is exceeded. */
-    async enforceBudget(message) {
-        if (this.budgetExceededReason)
-            return;
-        const reason = this.overBudgetReason(message);
-        if (!reason)
-            return;
-        await this.exceedBudget(reason);
+    catch (error) {
+        log.logWarning(`Runner rollback failed to ${label}`, String(error));
     }
-    /** Mark the run over budget, notify listeners, and abort the agent. */
-    async exceedBudget(reason) {
-        if (this.budgetExceededReason)
-            return;
-        this.budgetExceededReason = reason;
-        await this.emit({
-            type: "budget_exceeded",
-            reason,
-            tokens: this.tally.usage.totalTokens,
-            costUsd: this.tally.usage.cost.total,
-            llmCalls: this.tally.llmCalls,
-            durationMs: Date.now() - this.tally.startedAt,
-        });
-        log.logWarning("Run budget exceeded — aborting", reason);
-        this.agent.abort();
-    }
-    overBudgetReason(message) {
-        const { maxLlmCalls } = this.runBudget;
-        const needsAnotherCall = message.stopReason === "error" || message.content.some((part) => part.type === "toolCall");
-        if (needsAnotherCall && maxLlmCalls !== undefined && this.tally.llmCalls >= maxLlmCalls) {
-            return `${this.tally.llmCalls} LLM calls >= ${maxLlmCalls} limit`;
+}
+async function openRunnerSessionManager(params) {
+    const { contextFile, runtimeWorkspaceRoot, sessionKey, threadRootMessage } = params;
+    const sessionManager = await openManagedSession(contextFile, runtimeWorkspaceRoot);
+    try {
+        const threadSessionName = buildThreadSessionName(threadRootMessage);
+        if (isThreadSessionKey(sessionKey) &&
+            threadSessionName &&
+            (await sessionManager.getSessionName()) !== threadSessionName) {
+            await sessionManager.setSessionName(threadSessionName);
         }
-        return this.resourceOverBudgetReason();
+        return sessionManager;
     }
-    /** The message-independent budget checks, shared with external-spend folds. */
-    resourceOverBudgetReason() {
-        const { maxTokens, maxCostUsd, maxDurationMs } = this.runBudget;
-        if (maxTokens !== undefined && this.tally.usage.totalTokens >= maxTokens) {
-            return `${this.tally.usage.totalTokens} tokens >= ${maxTokens} limit`;
-        }
-        if (maxCostUsd !== undefined && this.tally.usage.cost.total >= maxCostUsd) {
-            return `cost ${this.tally.usage.cost.total.toFixed(2)} USD >= ${maxCostUsd} USD limit`;
-        }
-        if (maxDurationMs !== undefined && Date.now() - this.tally.startedAt >= maxDurationMs) {
-            return `${Date.now() - this.tally.startedAt}ms >= ${maxDurationMs}ms limit`;
-        }
-        return undefined;
+    catch (error) {
+        await rollbackRunnerResource("close the session writer", () => sessionManager.close());
+        throw error;
     }
-    findLastAssistantMessage() {
-        const messages = this.agent.state.messages;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const message = messages[i];
-            if (message?.role === "assistant")
-                return message;
-        }
-        return undefined;
+}
+async function createRunnerAgentSession(params) {
+    const { workspaceDir, systemPrompt, model, agentConfig, tools, toolContext, sessionManager, modelRegistry, signal, } = params;
+    const mcpTools = await sessionManager.connectMcp(agentConfig.mcpServers ?? {}, signal);
+    return createConfiguredAgentSession({
+        workspaceDir,
+        systemPrompt,
+        model,
+        thinkingLevel: agentConfig.thinkingLevel,
+        tools: [...tools, ...mcpTools.map(adaptAgentTool)],
+        toolContext,
+        sessionStore: sessionManager,
+        models: modelRegistry,
+    });
+}
+async function runPreparedTurn(params) {
+    const { prepared, presentation, message, responder, platform, runState, session, model, agentConfig, sessionUuid, conversationId, contextFile, sessionView, } = params;
+    if (runState.logCtx) {
+        log.logAgentRunStart(runState.logCtx, model.provider, model.id, model.name);
     }
-    /** Decide what to do after a run settles. Returns true when the agent should continue. */
-    async handlePostRun() {
-        // A run stopped for going over budget must not be retried or compacted back
-        // into another continuation — that would defeat the circuit breaker.
-        if (this.budgetExceededReason)
-            return false;
-        const lastAssistant = this.findLastAssistantMessage();
-        if (!lastAssistant)
-            return false;
-        if (lastAssistant.stopReason === "error") {
-            const contextWindow = this.agent.state.model.contextWindow || 0;
-            if (isContextOverflow(lastAssistant, contextWindow)) {
-                return this.handleOverflow();
-            }
-            if (isRetryableAssistantError(lastAssistant)) {
-                return this.prepareRetry(lastAssistant);
+    updateActiveSpanAttribution({
+        provider: model.provider,
+        model: agentConfig.model,
+        channel_id: prepared.sessionConversation,
+        session_id: sessionUuid,
+    });
+    addLifecycleEvent("agent.prompt.sent", {
+        provider: model.provider,
+        model: agentConfig.model,
+        channel_id: prepared.sessionConversation,
+        session_id: sessionUuid,
+        attachment_count: message.attachments?.length ?? 0,
+        image_attachment_count: prepared.imageAttachments.length,
+    });
+    const isEventRun = message.id.startsWith("event:");
+    await session.prompt(prepared.userMessage, {
+        ...(prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : {}),
+        ...(isEventRun ? { budget: DEFAULT_EVENT_BUDGET } : {}),
+    });
+    await presentation.wait();
+    const sessionViewTokenStore = sessionView?.tokenStore;
+    const sessionViewPortalBaseUrl = sessionView?.portalBaseUrl;
+    let sessionViewLink;
+    const createSessionViewLink = sessionViewTokenStore && sessionViewPortalBaseUrl
+        ? () => {
+            if (!sessionViewLink) {
+                const token = sessionViewTokenStore.create({
+                    platform: platform.name,
+                    platformUserId: message.userId,
+                    conversationId,
+                    sessionKey: message.sessionKey,
+                    sessionFile: contextFile,
+                    platformUserName: message.userName,
+                });
+                sessionViewLink = `${sessionViewPortalBaseUrl}/session?token=${token.token}`;
             }
-            return false;
+            return sessionViewLink;
         }
-        return this.checkThresholdCompaction(lastAssistant);
-    }
-    async handleOverflow() {
-        if (this.overflowRecoveryAttempted) {
-            await this.emit({
-                type: "compaction_end",
-                reason: "overflow",
-                aborted: false,
-                errorMessage: "Context overflow recovery failed after one compact-and-retry attempt. Try /new or a larger-context model.",
+        : undefined;
+    await finalizeRunResponse(responder, session, runState, {
+        triggerSessionLink: isEventTriggerAttribution(prepared.triggerAttribution)
+            ? createSessionViewLink?.()
+            : undefined,
+        createOverflowLink: createSessionViewLink,
+        platform: platform.name,
+        model,
+        sessionConversation: prepared.sessionConversation,
+        sessionUuid,
+    });
+    await reportUsageSummary({
+        session,
+        runState,
+        responder,
+        platform,
+        model,
+        agentConfig,
+        sessionConversation: prepared.sessionConversation,
+        sessionUuid,
+        waitForQueue: presentation.wait,
+    });
+    return { stopReason: runState.stopReason, errorMessage: runState.errorMessage };
+}
+function createRunnerInterface(params) {
+    const { conversationId, conversationDir, sessionKey, office, sessionUuid, contextFile, sessionView, runState, executor, resolveForRun, session, model, agentConfig, sessionManager, chatSessionManager, toolBindings, } = params;
+    return {
+        async syncChatHistory(currentMessageId) {
+            await chatSessionManager.syncSessionManager({
+                conversationDir,
+                sessionKey,
+                sessionManager,
+                currentMessageId,
             });
-            return false;
-        }
-        this.overflowRecoveryAttempted = true;
-        this.dropTrailingErrorMessage();
-        return this.runCompaction("overflow", true);
-    }
-    async checkThresholdCompaction(lastAssistant) {
-        const settings = this.settings.compaction;
-        if (!settings.enabled)
-            return false;
-        const contextWindow = this.agent.state.model.contextWindow || 0;
-        if (contextWindow <= 0)
-            return false;
-        let contextTokens = lastAssistant.usage ? calculateContextTokens(lastAssistant.usage) : 0;
-        if (contextTokens === 0) {
-            const estimate = estimateContextTokens(this.agent.state.messages);
-            if (estimate.lastUsageIndex === null)
-                return false;
-            contextTokens = estimate.tokens;
-        }
-        if (!shouldCompact(contextTokens, contextWindow, settings))
-            return false;
-        return this.runCompaction("threshold", false);
-    }
-    async runCompaction(reason, willRetry) {
-        let started = false;
-        try {
-            const pathEntries = await this.sessionStore.getBranch();
-            const preparation = getOrThrow(prepareCompaction(pathEntries, this.settings.compaction));
-            if (!preparation)
-                return false;
-            await this.emit({ type: "compaction_start", reason });
-            started = true;
-            this.compactionAbortController = new AbortController();
-            const signal = this.compactionAbortController.signal;
-            const result = getOrThrow(await compact(preparation, this.createCompactionModels(), this.agent.state.model, undefined, this.agent.state.thinkingLevel, undefined, undefined, withAbortSignal(signal, TODO_CONTEXT)));
-            if (signal.aborted) {
-                await this.emit({ type: "compaction_end", reason, aborted: true });
-                return false;
-            }
-            await this.sessionStore.appendCompaction(result.summary, result.retainedTail, result.tokensBefore, result.details);
-            const context = await this.sessionStore.buildSessionContext();
-            this.agent.state.messages = context.messages;
-            await this.emit({
-                type: "compaction_end",
-                reason,
-                result: {
-                    summary: result.summary,
-                    retainedMessages: result.retainedTail.length,
-                    tokensBefore: result.tokensBefore,
-                },
-                aborted: false,
+        },
+        async run(message, responder, platform) {
+            const prepared = await prepareRunContext({
+                message,
+                responder,
+                platform,
+                office,
+                executor,
+                resolveForRun,
+                session,
+                setEventContext: toolBindings.setEventContext,
+                setSandboxContext: toolBindings.setSandboxContext,
+                setUploadFunction: toolBindings.setUploadFunction,
+                setImageUploadFunction: toolBindings.setImageUploadFunction,
+                setReactFunction: toolBindings.setReactFunction,
+                bindPlatformToolPacks: toolBindings.bindPlatformToolPacks,
             });
-            if (this.budgetExceededReason)
-                return false;
-            // Messages here were just rebuilt from the store, which already filters
-            // error assistants out of context — nothing left for the drop to target.
-            if (willRetry)
-                return true;
-            return this.agent.hasQueuedMessages();
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "compaction failed";
-            if (started) {
-                await this.emit({
-                    type: "compaction_end",
-                    reason,
-                    aborted: false,
-                    errorMessage: reason === "overflow"
-                        ? `Context overflow recovery failed: ${errorMessage}`
-                        : `Auto-compaction failed: ${errorMessage}`,
+            const presentation = activateRunPresentation(runState, {
+                responder,
+                sessionConversation: prepared.sessionConversation,
+                userName: message.userName,
+                sessionUuid,
+                triggerAttribution: prepared.triggerAttribution,
+            });
+            try {
+                return await runPreparedTurn({
+                    prepared,
+                    presentation,
+                    message,
+                    responder,
+                    platform,
+                    runState,
+                    session,
+                    model,
+                    agentConfig,
+                    sessionUuid,
+                    conversationId,
+                    contextFile,
+                    sessionView,
                 });
             }
-            else {
-                log.logWarning("Compaction preparation failed", errorMessage);
+            finally {
+                presentation.dispose();
             }
-            return false;
-        }
-        finally {
-            this.compactionAbortController = undefined;
-        }
-    }
-    /**
-     * Compaction can make one completion, or two when its cut splits a turn.
-     * Intercept only those opaque upstream calls so each returned assistant
-     * message is tallied exactly once. A call at maxLlmCalls is not started;
-     * the cap is otherwise enforced before any post-compaction continuation.
-     */
-    createCompactionModels() {
-        const models = this.models.models;
-        return new Proxy(models, {
-            get: (target, property) => {
-                if (property === "completeSimple") {
-                    return async (...args) => {
-                        const maxLlmCalls = this.runBudget.maxLlmCalls;
-                        if (maxLlmCalls !== undefined && this.tally.llmCalls >= maxLlmCalls) {
-                            await this.exceedBudget(`${this.tally.llmCalls} LLM calls >= ${maxLlmCalls} limit`);
-                            throw new Error("Compaction LLM-call budget exhausted");
-                        }
-                        const message = await target.completeSimple(...args);
-                        this.recordUsage(message);
-                        const reason = this.resourceOverBudgetReason();
-                        if (reason)
-                            await this.exceedBudget(reason);
-                        return message;
-                    };
-                }
-                const value = Reflect.get(target, property, target);
-                return typeof value === "function" ? value.bind(target) : value;
-            },
+        },
+        abort() {
+            session.abort();
+        },
+        async dispose() {
+            await sessionManager.close();
+        },
+        getCurrentStep() {
+            const first = runState.pendingTools.values().next().value;
+            if (!first)
+                return undefined;
+            return {
+                toolName: first.toolName,
+                label: first.args?.label,
+            };
+        },
+    };
+}
+async function finishRunnerCreation(params) {
+    const { options, conversationId, conversationDir, workspaceDir, executor, resolveForRun, model, modelRegistry, agentConfig, systemPrompt, sessionManager, toolBindings, toolContext, } = params;
+    const { sessionKey, office, sessionScope, sessionView } = options;
+    const { contextFile } = sessionScope;
+    try {
+        const sessionUuid = extractSessionUuid(contextFile);
+        const chatSessionManager = new ChatHistorySync();
+        const session = await createRunnerAgentSession({
+            workspaceDir,
+            systemPrompt,
+            model,
+            agentConfig,
+            tools: toolBindings.tools,
+            toolContext,
+            sessionManager,
+            modelRegistry,
+            conversationId,
+            signal: options.signal,
         });
-    }
-    async prepareRetry(message) {
-        const settings = this.settings.retry;
-        if (!settings.enabled)
-            return false;
-        this.retryAttempt++;
-        if (this.retryAttempt > settings.maxRetries) {
-            this.retryAttempt--;
-            await this.emit({
-                type: "auto_retry_end",
-                success: false,
-                attempt: this.retryAttempt,
-                finalError: message.errorMessage,
-            });
-            this.retryAttempt = 0;
-            return false;
-        }
-        const delayMs = settings.baseDelayMs * 2 ** (this.retryAttempt - 1);
-        await this.emit({
-            type: "auto_retry_start",
-            attempt: this.retryAttempt,
-            maxAttempts: settings.maxRetries,
-            delayMs,
-            errorMessage: message.errorMessage || "Unknown error",
+        options.signal?.throwIfAborted();
+        const runState = createRunState();
+        attachSessionEventHandlers({ session, runState, model, agentConfig });
+        return createRunnerInterface({
+            conversationId,
+            conversationDir,
+            sessionKey,
+            office,
+            sessionUuid,
+            contextFile,
+            sessionView,
+            runState,
+            executor,
+            resolveForRun,
+            session,
+            model,
+            agentConfig,
+            sessionManager,
+            chatSessionManager,
+            toolBindings,
         });
-        this.dropTrailingErrorMessage();
-        this.retryAbortController = new AbortController();
-        try {
-            await sleep(delayMs, this.retryAbortController.signal);
-        }
-        catch {
-            const attempt = this.retryAttempt;
-            this.retryAttempt = 0;
-            await this.emit({
-                type: "auto_retry_end",
-                success: false,
-                attempt,
-                finalError: "Retry cancelled",
-            });
-            return false;
-        }
-        finally {
-            this.retryAbortController = undefined;
-        }
-        return true;
     }
-    dropTrailingErrorMessage() {
-        const messages = this.agent.state.messages;
-        if (messages[messages.length - 1]?.role === "assistant") {
-            this.agent.state.messages = messages.slice(0, -1);
-        }
+    catch (error) {
+        await rollbackRunnerResource("close the session writer", () => sessionManager.close());
+        throw error;
     }
 }
+export async function createRunner(options) {
+    options.signal?.throwIfAborted();
+    const { sandboxConfig, sessionKey, office, trustModel, sessionScope, vaultManager, provisioner, resourceController, platformToolPackFactories, } = options;
+    const conversationId = office.address.conversationId;
+    const conversationDir = office.dir;
+    const workspaceDir = office.workspace.root;
+    const resolvedAgentConfig = resolveConversationSettings(office);
+    const mcpServers = await resolveRunnerMcpServers({
+        office,
+        trustModel,
+        platformWorkspaceId: options.platformWorkspaceId,
+        servers: resolvedAgentConfig.mcpServers,
+        openConnector: options.openConnector,
+        signal: options.signal,
+    });
+    options.signal?.throwIfAborted();
+    const agentConfig = { ...resolvedAgentConfig, mcpServers };
+    const projection = resolveWorkspaceProjection(office);
+    // Bootstrap validation fails runner creation early. resolveForRun repeats
+    // the check against the actor-specific decision before any provider call.
+    assertSandboxSupportsWorkspacePolicy(sandboxConfig, projection.doorPolicy, projection.promptSources.globalMemoryReadOnly === true);
+    const { executor, resolveForRun } = createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, office.workspace);
+    const pathContext = getUnresolvedSandboxPathContext(sandboxConfig, workspaceDir);
+    // The env wraps the stable executor wrapper, which delegates to the
+    // actor-resolved executor per call, so one env serves every run.
+    const toolContext = {
+        env: createSandboxExecutionEnv(executor, sandboxConfig.type, pathContext.runtimeWorkspaceRoot),
+    };
+    const modelRegistry = options.models ?? MikanModels.create();
+    if (modelRegistry.getError()) {
+        log.logWarning("models.json load error", modelRegistry.getError());
+    }
+    const model = modelRegistry.resolve(agentConfig.provider, agentConfig.model);
+    // Create tools (per-runner, with per-runner upload function setter)
+    const toolBindings = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, resourceController: resourceController ?? provisioner }, platformToolPackFactories ?? [], {
+        model,
+        getApiKey: () => modelRegistry.getApiKeyForProvider(model.provider),
+        // The conversation's own office dir: mounted into the sandbox, unlike
+        // the workspace base — generated images must land somewhere the agent
+        // (and a future run) can still reach.
+        outputDir: conversationDir,
+    });
+    const systemPrompt = await buildInitialSystemPrompt({
+        office,
+        pathContext,
+        projection,
+        sandboxConfig,
+    });
+    options.signal?.throwIfAborted();
+    const { contextFile, threadRootMessage } = sessionScope;
+    const sessionManager = await openRunnerSessionManager({
+        contextFile,
+        runtimeWorkspaceRoot: pathContext.runtimeWorkspaceRoot,
+        sessionKey,
+        threadRootMessage,
+    });
+    return finishRunnerCreation({
+        options,
+        conversationId,
+        conversationDir,
+        workspaceDir,
+        executor,
+        resolveForRun,
+        model,
+        modelRegistry,
+        agentConfig,
+        systemPrompt,
+        sessionManager,
+        toolBindings,
+        toolContext,
+    });
+}
 //# sourceMappingURL=runner.js.map