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

package/dist/harness/runner.js

@@ -1,440 +1,575 @@
-/**
- * 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
- * - extension hook dispatch ({@link ExtensionRegistry})
- *
- * 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, } from "@earendil-works/pi-agent-core";
-import { isContextOverflow, } 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 "../settings/index.js";
+import { ensureDefaultOpenConnector } from "./open-connector.js";
+import { OfficeEventStore } from "../events/index.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";
-// Transient provider failures worth retrying: overload/rate-limit responses,
-// 5xx statuses, and network/stream interruptions.
-const RETRYABLE_ERROR_PATTERN = /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i;
-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.filter((tool) => !["start_task", "task_status"].includes(tool.name)),
+        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.tally = { tokens: 0, costUsd: 0, llmCalls: 0, startedAt: 0 };
-        this.runBudget = {};
-        this.models = options.models;
-        this.sessionStore = options.sessionStore;
-        this.settings = resolveHarnessSettings(options.settings);
-        this.extensions = options.extensions;
-        const tools = [...options.tools, ...(options.extensions?.getContributedTools() ?? [])];
-        this.agent = new Agent({
-            initialState: {
-                systemPrompt: options.systemPrompt,
-                model: options.model,
-                thinkingLevel: options.thinkingLevel,
-                tools,
-            },
-            convertToLlm,
-            streamFn: (model, context, streamOptions) => this.models.models.streamSimple(model, context, streamOptions),
-            beforeToolCall: async ({ toolCall, args }) => {
-                if (!this.extensions?.hasHandlers("tool_call"))
-                    return undefined;
-                const result = await this.extensions.emit("tool_call", {
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    args,
-                });
-                return result ?? undefined;
-            },
-            afterToolCall: async ({ toolCall, args, result, isError }) => {
-                if (this.extensions?.hasHandlers("tool_result")) {
-                    await this.extensions.emit("tool_result", {
-                        toolCallId: toolCall.id,
-                        toolName: toolCall.name,
-                        args,
-                        content: result.content,
-                        isError,
-                    });
-                }
-                return undefined;
-            },
-        });
-        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;
-    }
-    subscribe(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    /** Replace the agent transcript from the persisted session tree. */
-    reloadFromSession() {
-        const context = 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. Resolves when the turn (and any
-     * recovery continuations) settles.
-     *
-     * @param options.budget Per-run resource ceilings that override the session
-     *   defaults. Autonomous (event / trigger) runs should pass a budget so a
-     *   runaway loop is stopped even with no human watching.
-     */
-    async prompt(text, options) {
-        if (this.agent.state.isStreaming) {
-            throw new Error("Agent is already processing a prompt");
-        }
-        const model = this.agent.state.model;
-        await this.ensureAuthConfigured(model);
-        this.retryAttempt = 0;
-        this.overflowRecoveryAttempted = false;
-        this.runBudget = { ...this.settings.budget, ...options?.budget };
-        this.budgetExceededReason = undefined;
-        this.tally = { tokens: 0, costUsd: 0, llmCalls: 0, startedAt: Date.now() };
-        // 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);
-        }
-        let systemPrompt = this.agent.state.systemPrompt;
-        if (this.extensions?.hasHandlers("before_agent_start")) {
-            const result = await this.extensions.emit("before_agent_start", {
-                prompt: text,
-                images: options?.images,
-                systemPrompt,
-            });
-            if (result?.systemPrompt && result.systemPrompt !== systemPrompt) {
-                // An extension rewrote the system prompt for this turn. Log the new
-                // size so the diagnostic in agent.ts (which logs the pre-hook prompt)
-                // isn't mistaken for the final prompt sent to the model.
-                log.logInfo(`Extension rewrote system prompt: ${systemPrompt.length} → ${result.systemPrompt.length} chars`);
-                systemPrompt = result.systemPrompt;
-                this.agent.state.systemPrompt = systemPrompt;
+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,
+                };
             }
-        }
-        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();
-        }
-        if (this.extensions?.hasHandlers("turn_end")) {
-            await this.extensions.emit("turn_end", { messages: this.agent.state.messages });
-        }
-    }
-    /** 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 or add it to auth.json.`);
-        }
+            const office = workspace.office(context.address);
+            const projection = resolveWorkspaceProjection(office);
+            assertSandboxSupportsWorkspacePolicy(sandboxConfig, projection.visibility, office.key);
+            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}`;
+}
+/**
+ * Fill in the deployment's default OpenConnector entry before settings are
+ * read, so the runner then sees only ordinary MCP configuration. A failed
+ * default is reported and skipped; the office keeps its other servers.
+ */
+async function ensureDefaultMcpServers(options) {
+    if (options.trustModel === "open-trigger")
+        return;
+    try {
+        await ensureDefaultOpenConnector(options.office, options.platformWorkspaceId, options.openConnector, options.signal);
     }
-    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));
-            }
-        }
+    catch (error) {
+        options.signal?.throwIfAborted();
+        log.logWarning(`[${options.office.address.conversationId}] OpenConnector default provisioning failed`, error instanceof Error ? error.message : String(error));
     }
-    async handleAgentEvent(event) {
-        await this.emit(event);
-        if (event.type !== "message_end")
-            return;
-        const message = event.message;
-        if (message.role === "user" || message.role === "assistant" || message.role === "toolResult") {
-            this.sessionStore.appendMessage(message);
-        }
-        else if (message.role === "custom") {
-            const custom = message;
-            this.sessionStore.appendCustomMessageEntry(custom.customType, custom.content, custom.display, custom.details);
-        }
-        if (this.extensions?.hasHandlers("message_end")) {
-            await this.extensions.emit("message_end", { message });
-        }
-        if (message.role === "assistant") {
-            this.recordUsage(message);
-            await this.enforceBudget();
-            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;
-                }
-            }
-        }
+}
+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 turn's usage into the running per-run tally. */
-    recordUsage(message) {
-        this.tally.llmCalls += 1;
-        const usage = message.usage;
-        if (!usage)
-            return;
-        this.tally.tokens += usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
-        this.tally.costUsd += usage.cost?.total ?? 0;
+    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, bindTasks, 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.
+    bindTasks(responder);
+    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() {
-        if (this.budgetExceededReason)
-            return;
-        const reason = this.overBudgetReason();
-        if (!reason)
-            return;
-        this.budgetExceededReason = reason;
-        await this.emit({
-            type: "budget_exceeded",
-            reason,
-            tokens: this.tally.tokens,
-            costUsd: this.tally.costUsd,
-            llmCalls: this.tally.llmCalls,
-            durationMs: Date.now() - this.tally.startedAt,
-        });
-        log.logWarning("Run budget exceeded — aborting", reason);
-        this.agent.abort();
+    catch (error) {
+        log.logWarning(`Runner rollback failed to ${label}`, String(error));
     }
-    overBudgetReason() {
-        const { maxTokens, maxCostUsd, maxDurationMs, maxLlmCalls } = this.runBudget;
-        if (maxLlmCalls !== undefined && this.tally.llmCalls >= maxLlmCalls) {
-            return `${this.tally.llmCalls} LLM calls >= ${maxLlmCalls} limit`;
-        }
-        if (maxTokens !== undefined && this.tally.tokens >= maxTokens) {
-            return `${this.tally.tokens} tokens >= ${maxTokens} limit`;
-        }
-        if (maxCostUsd !== undefined && this.tally.costUsd >= maxCostUsd) {
-            return `cost ${this.tally.costUsd.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`;
+}
+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 undefined;
+        return sessionManager;
     }
-    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;
+    catch (error) {
+        await rollbackRunnerResource("close the session writer", () => sessionManager.close());
+        throw error;
     }
-    /** 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 (this.isRetryableError(lastAssistant)) {
-                return this.prepareRetry(lastAssistant);
-            }
-            return false;
-        }
-        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.",
-            });
-            return false;
-        }
-        this.overflowRecoveryAttempted = true;
-        this.dropTrailingErrorMessage();
-        return this.runCompaction("overflow", true);
+}
+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);
     }
-    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;
+    updateActiveSpanAttribution({
+        provider: model.provider,
+        model: model.id,
+        channel_id: prepared.sessionConversation,
+        session_id: sessionUuid,
+        "mikan.input.message_count": 1,
+        "mikan.input.characters": prepared.userMessage.length,
+        "mikan.input.attachment_count": message.attachments?.length ?? 0,
+        "mikan.input.image_count": prepared.imageAttachments.length,
+        "mikan.input.has_text": prepared.userMessage.length > 0,
+    });
+    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, {
+        allowTaskHandoff: responder.startTask !== undefined,
+        allowTaskStatus: responder.getTaskStatus !== undefined,
+        ...(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 sessionViewLink;
         }
-        if (!shouldCompact(contextTokens, contextWindow, settings))
-            return false;
-        return this.runCompaction("threshold", false);
+        : undefined;
+    await finalizeRunResponse(responder, session, runState, {
+        initialTask: message.id.startsWith("task:"),
+        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 };
+}
+async function steerRun(session, activeMessage, message) {
+    if (!activeMessage)
+        return false;
+    // Claimed by the control path, including rejected/cancelled inputs: history sync
+    // must not turn a rejected control into a new instruction on the next run.
+    await session.sessionStore.appendCustomEntry("mikan.control_input", { messageId: message.id });
+    if (!session.isActiveRun)
+        throw new Error("Task is preparing or settling. Please retry this update shortly.");
+    if (message.userId !== activeMessage.userId)
+        throw new Error("Only the task's current actor can guide this run.");
+    if (message.attachments?.length)
+        throw new Error("Stop the task before continuing with new attachments.");
+    if (!(await session.steer(`[${message.userName ?? message.userId}]: ${message.text}`))) {
+        throw new Error("Task settled while receiving this update. Please send it again to continue.");
     }
-    async runCompaction(reason, willRetry) {
-        let started = false;
-        try {
-            const pathEntries = 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.models.models, this.agent.state.model, undefined, signal, this.agent.state.thinkingLevel));
-            if (signal.aborted) {
-                await this.emit({ type: "compaction_end", reason, aborted: true });
-                return false;
-            }
-            const entryId = this.sessionStore.appendCompaction(result.summary, result.firstKeptEntryId, result.tokensBefore, result.details);
-            const context = this.sessionStore.buildSessionContext();
-            this.agent.state.messages = context.messages;
-            if (this.extensions?.hasHandlers("session_compact")) {
-                const entry = this.sessionStore.getEntry(entryId);
-                if (entry?.type === "compaction") {
-                    await this.extensions.emit("session_compact", {
-                        entry: entry,
-                        reason,
-                    });
-                }
-            }
-            await this.emit({
-                type: "compaction_end",
-                reason,
-                result: {
-                    summary: result.summary,
-                    firstKeptEntryId: result.firstKeptEntryId,
-                    tokensBefore: result.tokensBefore,
-                },
-                aborted: false,
+    return true;
+}
+function createRunnerInterface(params) {
+    const { conversationId, conversationDir, sessionKey, office, sessionUuid, contextFile, sessionView, runState, executor, resolveForRun, session, model, agentConfig, sessionManager, chatSessionManager, toolBindings, } = params;
+    let activeMessage;
+    let stopped = false;
+    return {
+        steer: (message) => steerRun(session, activeMessage, message),
+        async syncChatHistory(currentMessageId) {
+            await chatSessionManager.syncSessionManager({
+                conversationDir,
+                sessionKey,
+                sessionManager,
+                currentMessageId,
             });
-            if (willRetry) {
-                this.dropTrailingErrorMessage();
-                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}`,
+        },
+        async run(message, responder, platform) {
+            activeMessage = message;
+            stopped = false;
+            let presentation;
+            try {
+                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,
+                    bindTasks: toolBindings.bindTasks,
+                    bindPlatformToolPacks: toolBindings.bindPlatformToolPacks,
+                });
+                if (stopped)
+                    return { stopReason: "aborted" };
+                presentation = activateRunPresentation(runState, {
+                    responder,
+                    sessionConversation: prepared.sessionConversation,
+                    userName: message.userName,
+                    sessionUuid,
+                    triggerAttribution: prepared.triggerAttribution,
+                });
+                return await runPreparedTurn({
+                    prepared,
+                    presentation,
+                    message,
+                    responder,
+                    platform,
+                    runState,
+                    session,
+                    model,
+                    agentConfig,
+                    sessionUuid,
+                    conversationId,
+                    contextFile,
+                    sessionView,
                 });
             }
-            else {
-                log.logWarning("Compaction preparation failed", errorMessage);
+            finally {
+                activeMessage = undefined;
+                presentation?.dispose();
             }
-            return false;
-        }
-        finally {
-            this.compactionAbortController = undefined;
-        }
-    }
-    isRetryableError(message) {
-        if (message.stopReason !== "error" || !message.errorMessage)
-            return false;
-        return RETRYABLE_ERROR_PATTERN.test(message.errorMessage);
-    }
-    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",
+        },
+        abort() {
+            stopped = true;
+            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,
+        });
+        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.length > 0 && 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;
+    await ensureDefaultMcpServers({
+        office,
+        trustModel,
+        platformWorkspaceId: options.platformWorkspaceId,
+        openConnector: options.openConnector,
+        signal: options.signal,
+    });
+    options.signal?.throwIfAborted();
+    const resolvedAgentConfig = resolveConversationSettings(office);
+    // open-trigger conversations get no MCP tools at all (see ARCHITECTURE.md).
+    const agentConfig = {
+        ...resolvedAgentConfig,
+        mcpServers: trustModel === "open-trigger" ? {} : (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.visibility, office.key);
+    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, new OfficeEventStore(office, options.eventScheduler), { 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