@geminixiang/mikan 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/agent.js

@@ -1,24 +1,40 @@
-import { DEFAULT_EVENT_BUDGET, defaultExtensionDirs, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, } from "./harness/index.js";
+/**
+ * Agent runner: prompt construction, path translation, run lifecycle, and createRunner.
+ * Single module — do not split helpers that only this file uses.
+ */
+import { DEFAULT_EVENT_BUDGET, defaultExtensionDirs, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, parseCommandInput, } from "./harness/index.js";
+import { runSubagent } from "./harness/subagent-runner.js";
 import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile } from "fs/promises";
 import { join, posix } from "path";
 import { resolveConversationSettings } from "./config.js";
-import { readEnv } from "./utils/env.js";
+import { effectiveStateDir } from "./cli/arg-grammar.js";
 import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
-import { reportUserFacingError } from "./observability/sentry.js";
-import { createExecutor, } from "./sandbox/index.js";
-import { createMountedRuntimePathContext } from "./sandbox/path-context.js";
-import { addLifecycleBreadcrumb, metricAttributes, updateActiveSpanAttribution, } from "./observability/sentry.js";
-import { AgentMemoryFileManager } from "./sessions/agent-memory-file-manager.js";
+import { createExecutor, getUnresolvedSandboxPathContext, } from "./sandbox/index.js";
+import { addLifecycleBreadcrumb, metricAttributes, reportUserFacingError, updateActiveSpanAttribution, } from "./observability/sentry.js";
+import { ChatHistorySync } from "./sessions/chat-history-sync.js";
+import { formatHistoryLine } from "./sessions/history-line.js";
+import { conversationIdOf, isThreadSessionKey } from "./sessions/session-key.js";
 import { extractSessionUuid, openManagedSession, } from "./sessions/store.js";
 import { HostEventStore } from "./tools/event.js";
-import { createMikanTools } from "./tools/index.js";
+import { createMikanTools, createSubagentTool, DEFAULT_GLOBAL_SUBAGENT_SLOTS, SubagentSlotPool, } from "./tools/index.js";
+// 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);
 import * as Sentry from "@sentry/node";
-import { formatLocalTimestamp } from "./utils/date.js";
-import { resolveConfiguredModel } from "./model-registry.js";
 import { emitAgentEvent } from "./agent-events.js";
+export function translateRuntimePathToHost(runtimePath, pathContext) {
+    return pathContext.runtimeToHostPath?.(runtimePath) ?? runtimePath;
+}
+export function translateAttachPathToHost(filePath, pathContext) {
+    const runtimePath = posix.isAbsolute(filePath)
+        ? filePath
+        : posix.join(pathContext.runtimeWorkspaceRoot, filePath);
+    return translateRuntimePathToHost(runtimePath, pathContext);
+}
 const IMAGE_MIME_TYPES = {
     jpg: "image/jpeg",
     jpeg: "image/jpeg",
@@ -29,12 +45,46 @@ const IMAGE_MIME_TYPES = {
 function getImageMimeType(filename) {
     return IMAGE_MIME_TYPES[filename.toLowerCase().split(".").pop() || ""];
 }
-function buildThreadSessionName(message) {
-    const text = message?.text?.trim();
-    if (!text)
-        return undefined;
-    const userLabel = message?.userName || message?.user || "unknown";
-    return `[${userLabel}]: ${text}`;
+function formatTimestampedUserMessage(message) {
+    return formatHistoryLine({
+        date: new Date(),
+        userName: message.userName,
+        threadTs: message.threadTs,
+        text: message.text,
+    });
+}
+function collectMessageAttachments(message, workspacePath, pathContext) {
+    const imageAttachments = [];
+    const nonImagePaths = [];
+    for (const attachment of message.attachments || []) {
+        const runtimePath = `${workspacePath}/${attachment.localPath}`;
+        const hostPath = pathContext?.runtimeToHostPath?.(runtimePath) ?? runtimePath;
+        const mimeType = getImageMimeType(attachment.localPath);
+        if (mimeType && existsSync(hostPath)) {
+            try {
+                imageAttachments.push({
+                    type: "image",
+                    mimeType,
+                    data: readFileSync(hostPath).toString("base64"),
+                });
+            }
+            catch {
+                nonImagePaths.push(runtimePath);
+            }
+        }
+        else {
+            nonImagePaths.push(runtimePath);
+        }
+    }
+    return { imageAttachments, nonImagePaths };
+}
+export function buildPromptPayload(message, workspacePath, pathContext) {
+    let userMessage = formatTimestampedUserMessage(message);
+    const { imageAttachments, nonImagePaths } = collectMessageAttachments(message, workspacePath, pathContext);
+    if (nonImagePaths.length > 0) {
+        userMessage += `\n\n<slack_attachments>\n${nonImagePaths.join("\n")}\n</slack_attachments>`;
+    }
+    return { userMessage, imageAttachments };
 }
 async function getMemory(conversationDir) {
     const parts = [];
@@ -329,81 +379,21 @@ Do not add this to \`[SILENT]\` responses.`);
     }
     return parts.join("\n\n");
 }
-export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot) {
-    if (sandboxConfig.type === "image") {
-        return createMountedRuntimePathContext(hostWorkspaceRoot, "/workspace");
-    }
-    return createExecutor(sandboxConfig).getPathContext(hostWorkspaceRoot);
-}
-function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
-    const executionResolver = vaultManager && sandboxConfig.type !== "host"
-        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspaceDir)
-        : 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);
-        },
-        getWorkspacePath(hostPath) {
-            return activeExecutor.getWorkspacePath(hostPath);
-        },
-        getSandboxConfig() {
-            return activeExecutor.getSandboxConfig();
-        },
-        getPathContext(hostWorkspaceRoot) {
-            return activeExecutor.getPathContext(hostWorkspaceRoot);
-        },
-    };
-    return {
-        executionResolver,
-        executor,
-        getPathContext: () => executor.getPathContext(hostWorkspacePath),
-        async resolveExecutorForRun(context) {
-            if (!executionResolver)
-                return;
-            activeExecutor = await executionResolver.resolve(context);
-        },
-    };
-}
-/**
- * Extension host services over mikan's runtime infrastructure: schedules
- * become event files under `<workspaceDir>/events` (picked up live by
- * EventsWatcher), secrets come from `vaults/extensions/<slug>/env`, and
- * notify posts through the platform bots when main.ts provides a notifier.
- */
-function buildExtensionHostServices(params) {
-    const { workspaceDir, vaultManager, platformNotifier } = params;
-    const eventStore = HostEventStore.fromWorkspaceDir(workspaceDir);
-    return {
-        stateDir: readEnv("STATE_DIR"),
-        scheduleStore: {
-            write: async (filename, payload) => {
-                // Event files tolerate a missing platform (single-platform default),
-                // so the harness payload is a valid event payload as written.
-                await eventStore.write(filename, payload);
-            },
-            delete: async (filename) => (await eventStore.delete(filename)).deleted,
-            list: async () => (await eventStore.list()).map((entry) => ({
-                filename: entry.filename,
-                payload: entry.payload,
-            })),
-        },
-        ...(platformNotifier ? { postMessage: platformNotifier } : {}),
-        ...(vaultManager
-            ? {
-                resolveSecrets: (slug) => vaultManager.resolve(`extensions/${slug}`)?.env ?? {},
-            }
-            : {}),
-    };
+export function appendTriggerAttribution(text, triggerAttribution, sessionLink) {
+    if (!triggerAttribution)
+        return text;
+    const trimmed = text.trimEnd();
+    const legacySuffix = `_Triggered by ${triggerAttribution}_`;
+    // Slack mrkdwn italics cannot span a URL — a `_..._` wrapping a link renders
+    // the underscores literally. Keep the session link outside the italic span.
+    const suffix = sessionLink ? `${legacySuffix} · session: ${sessionLink}` : legacySuffix;
+    if (trimmed.endsWith(suffix))
+        return text;
+    const body = trimmed.endsWith(legacySuffix)
+        ? trimmed.slice(0, -legacySuffix.length).trimEnd()
+        : trimmed;
+    return `${body}\n\n${suffix}`;
 }
-/**
- * Local (workspace/conversation) skills override extension skills on name
- * collision: an admin's on-disk skill always beats an extension's.
- */
 function mergeExtensionSkills(local, extension) {
     if (extension.length === 0)
         return local;
@@ -414,37 +404,6 @@ function mergeExtensionSkills(local, extension) {
         byName.set(skill.name, skill);
     return [...byName.values()];
 }
-async function createConfiguredAgentSession(params) {
-    const { conversationId, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, } = params;
-    // Host-only dirs under the state dir: extension code runs in the mikan
-    // process, so it must never load from workspace paths — those are mounted
-    // into sandbox containers and agent-writable (sandbox escape otherwise).
-    const extensionsResult = await loadExtensions({
-        dirs: defaultExtensionDirs(conversationId, readEnv("STATE_DIR")),
-        context: { conversationId, workspaceDir, model, thinkingLevel },
-        services: buildExtensionHostServices({ workspaceDir, vaultManager, platformNotifier }),
-    });
-    for (const err of extensionsResult.errors) {
-        log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
-    }
-    if (extensionsResult.extensions.length > 0) {
-        log.logInfo(`[${conversationId}] Loaded ${extensionsResult.extensions.length} extension(s): ${extensionsResult.extensions.map((extension) => extension.name).join(", ")}`);
-    }
-    const session = new MikanAgentSession({
-        systemPrompt,
-        model,
-        thinkingLevel,
-        tools,
-        models,
-        sessionStore,
-        extensions: extensionsResult.registry,
-    });
-    const reloaded = session.reloadFromSession();
-    if (reloaded > 0) {
-        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from session context`);
-    }
-    return { session, extensionSkills: extensionsResult.skills };
-}
 function createEmptyUsageTotals() {
     return {
         input: 0,
@@ -461,6 +420,7 @@ function createRunState() {
         queue: null,
         pendingTools: new Map(),
         toolProgress: new Map(),
+        toolProgressTimer: undefined,
         totalUsage: createEmptyUsageTotals(),
         llmCallCount: 0,
         stopReason: "stop",
@@ -480,6 +440,9 @@ function resetRunState(runState, responder, sessionConversation, userName, sessi
     };
     runState.pendingTools.clear();
     runState.toolProgress.clear();
+    if (runState.toolProgressTimer)
+        clearTimeout(runState.toolProgressTimer);
+    runState.toolProgressTimer = undefined;
     runState.totalUsage = createEmptyUsageTotals();
     runState.llmCallCount = 0;
     runState.stopReason = "stop";
@@ -515,53 +478,6 @@ function createRunQueue(responder, runState) {
         wait: () => queueChain,
     };
 }
-function formatTimestampedUserMessage(message) {
-    const timestamp = formatLocalTimestamp(new Date());
-    const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
-    return `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
-}
-function collectMessageAttachments(message, workspacePath, pathContext) {
-    const imageAttachments = [];
-    const nonImagePaths = [];
-    for (const attachment of message.attachments || []) {
-        const runtimePath = `${workspacePath}/${attachment.localPath}`;
-        const hostPath = pathContext?.runtimeToHostPath?.(runtimePath) ?? runtimePath;
-        const mimeType = getImageMimeType(attachment.localPath);
-        if (mimeType && existsSync(hostPath)) {
-            try {
-                imageAttachments.push({
-                    type: "image",
-                    mimeType,
-                    data: readFileSync(hostPath).toString("base64"),
-                });
-            }
-            catch {
-                nonImagePaths.push(runtimePath);
-            }
-        }
-        else {
-            nonImagePaths.push(runtimePath);
-        }
-    }
-    return { imageAttachments, nonImagePaths };
-}
-export function buildPromptPayload(message, workspacePath, pathContext) {
-    let userMessage = formatTimestampedUserMessage(message);
-    const { imageAttachments, nonImagePaths } = collectMessageAttachments(message, workspacePath, pathContext);
-    if (nonImagePaths.length > 0) {
-        userMessage += `\n\n<slack_attachments>\n${nonImagePaths.join("\n")}\n</slack_attachments>`;
-    }
-    return { userMessage, imageAttachments };
-}
-async function writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachmentCount) {
-    const debugContext = {
-        systemPrompt,
-        messages: session.messages,
-        newUserMessage: userMessage,
-        imageAttachmentCount,
-    };
-    await writeFile(join(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
-}
 function getFinalAssistantText(session) {
     const lastAssistant = session.messages.findLast((message) => message.role === "assistant");
     return (lastAssistant?.content
@@ -569,21 +485,6 @@ function getFinalAssistantText(session) {
         .map((content) => content.text)
         .join("\n") || "");
 }
-export function appendTriggerAttribution(text, triggerAttribution, sessionLink) {
-    if (!triggerAttribution)
-        return text;
-    const trimmed = text.trimEnd();
-    const legacySuffix = `_Triggered by ${triggerAttribution}_`;
-    const suffix = sessionLink
-        ? `_Triggered by ${triggerAttribution} · session: ${sessionLink}_`
-        : legacySuffix;
-    if (trimmed.endsWith(suffix))
-        return text;
-    const body = trimmed.endsWith(legacySuffix)
-        ? trimmed.slice(0, -legacySuffix.length).trimEnd()
-        : trimmed;
-    return `${body}\n\n${suffix}`;
-}
 function isEventTriggerAttribution(triggerAttribution) {
     return triggerAttribution?.startsWith("[event:") === true;
 }
@@ -609,6 +510,31 @@ async function replaceResponseWithToolProgress(responder, runState) {
     if (progress)
         await responder.replaceResponse(progress);
 }
+const TOOL_PROGRESS_DEBOUNCE_MS = 500;
+function scheduleToolProgressUpdate(responder, runState) {
+    if (runState.toolProgressTimer)
+        return;
+    runState.toolProgressTimer = setTimeout(() => {
+        runState.toolProgressTimer = undefined;
+        runState.queue?.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
+    }, TOOL_PROGRESS_DEBOUNCE_MS);
+    runState.toolProgressTimer.unref();
+}
+function flushToolProgressUpdate(responder, runState) {
+    if (runState.toolProgressTimer)
+        clearTimeout(runState.toolProgressTimer);
+    runState.toolProgressTimer = undefined;
+    runState.queue?.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
+}
+function extractToolProgressLabel(partialResult) {
+    if (!partialResult || typeof partialResult !== "object")
+        return undefined;
+    const details = partialResult.details;
+    if (!details || typeof details !== "object")
+        return undefined;
+    const label = details.progressLabel;
+    return typeof label === "string" && label.trim() ? label.trim().slice(0, 1000) : undefined;
+}
 async function finalizeRunResponse(responder, session, runState, options) {
     if (runState.stopReason === "error" && runState.errorMessage) {
         if (!runState.reportedLlmError) {
@@ -739,6 +665,169 @@ async function reportUsageSummary(ctx) {
         await waitForQueue();
     }
 }
+function extractToolResultText(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (result &&
+        typeof result === "object" &&
+        "content" in result &&
+        Array.isArray(result.content)) {
+        const content = result.content;
+        const textParts = [];
+        for (const part of content) {
+            if (part.type === "text" && part.text) {
+                textParts.push(part.text);
+            }
+        }
+        if (textParts.length > 0) {
+            return textParts.join("\n");
+        }
+    }
+    return JSON.stringify(result);
+}
+function buildThreadSessionName(message) {
+    const text = message?.text?.trim();
+    if (!text)
+        return undefined;
+    const userLabel = message?.userName || message?.user || "unknown";
+    return `[${userLabel}]: ${text}`;
+}
+function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
+    const executionResolver = vaultManager && sandboxConfig.type !== "host"
+        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath)
+        : 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 {
+        executionResolver,
+        executor,
+        getPathContext: () => executor.getPathContext(hostWorkspacePath),
+        async resolveExecutorForRun(context) {
+            if (!executionResolver)
+                return;
+            activeExecutor = await executionResolver.resolve(context);
+        },
+    };
+}
+/**
+ * Extension host services over mikan's runtime infrastructure: schedules
+ * become event files under `<workspaceDir>/events` (picked up live by
+ * EventsWatcher), secrets come from `vaults/extensions/<slug>/env`, and
+ * notify posts through the platform bots when main.ts provides a notifier.
+ */
+function buildExtensionHostServices(params) {
+    const { workspaceDir, vaultManager, platformNotifier, platformReactor, platformUploader, runSubagentService, } = params;
+    const eventStore = HostEventStore.fromWorkspaceDir(workspaceDir);
+    return {
+        stateDir: effectiveStateDir(),
+        scheduleStore: {
+            write: async (filename, payload) => {
+                await eventStore.write(filename, payload);
+            },
+            delete: async (filename) => (await eventStore.delete(filename)).deleted,
+            list: async () => (await eventStore.list()).flatMap((entry) => entry.payload ? [{ filename: entry.filename, payload: entry.payload }] : []),
+        },
+        ...(platformNotifier ? { postMessage: platformNotifier } : {}),
+        ...(platformReactor ? { addReaction: platformReactor } : {}),
+        ...(platformUploader ? { uploadFile: platformUploader } : {}),
+        ...(runSubagentService ? { runSubagent: runSubagentService } : {}),
+        ...(vaultManager
+            ? {
+                resolveSecrets: (slug) => vaultManager.resolve(`extensions/${slug}`)?.env ?? {},
+            }
+            : {}),
+    };
+}
+async function createConfiguredAgentSession(params) {
+    const { conversationId, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, platformUploader, } = params;
+    // Host-only dirs under the state dir: extension code runs in the mikan
+    // process, so it must never load from workspace paths — those are mounted
+    // into sandbox containers and agent-writable (sandbox escape otherwise).
+    const extensionsResult = await loadExtensions({
+        dirs: defaultExtensionDirs(conversationId, effectiveStateDir()),
+        context: { conversationId, workspaceDir, model, thinkingLevel },
+        services: buildExtensionHostServices({
+            workspaceDir,
+            vaultManager,
+            platformNotifier,
+            platformReactor,
+            platformUploader,
+            runSubagentService: (request, extensionTools) => runSubagent({
+                request,
+                defaultModel: model,
+                thinkingLevel,
+                models,
+                workspaceDir,
+                availableTools: [...tools, ...extensionTools],
+            }),
+        }),
+    });
+    const contributedTools = extensionsResult.registry.getContributedTools();
+    for (const err of extensionsResult.errors) {
+        log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
+    }
+    if (extensionsResult.extensions.length > 0) {
+        log.logInfo(`[${conversationId}] Loaded ${extensionsResult.extensions.length} extension(s): ${extensionsResult.extensions.map((extension) => extension.name).join(", ")}`);
+    }
+    const subagentTool = createSubagentTool((request) => runSubagent({
+        request,
+        defaultModel: model,
+        thinkingLevel,
+        models,
+        workspaceDir,
+        availableTools: [...tools, ...contributedTools],
+        // `session` is the const below: the tool only executes inside that
+        // session's own prompt loop, and the temporal dead zone turns any
+        // earlier call into a loud error instead of a silently dropped fold.
+        onUsage: (usage) => session.foldExternalUsage(usage),
+    }), globalSubagentSlots);
+    const session = new MikanAgentSession({
+        systemPrompt,
+        model,
+        thinkingLevel,
+        tools: [...tools, subagentTool],
+        models,
+        sessionStore,
+        extensions: extensionsResult.registry,
+    });
+    const reloaded = session.reloadFromSession();
+    if (reloaded > 0) {
+        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from session context`);
+    }
+    return {
+        session,
+        extensionSkills: extensionsResult.skills,
+        extensionRegistry: extensionsResult.registry,
+        disposeExtensions: extensionsResult.dispose,
+    };
+}
 function reloadSessionMessages(session, conversationId) {
     const reloaded = session.reloadFromSession();
     if (reloaded > 0) {
@@ -746,15 +835,16 @@ function reloadSessionMessages(session, conversationId) {
     }
 }
 async function prepareRunContext(params) {
-    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, } = params;
+    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, setReactFunction, bindPlatformToolPacks, } = params;
     let pathContext = params.pathContext;
-    const sessionConversation = message.sessionKey.split(":")[0];
+    const sessionConversation = conversationIdOf(message.sessionKey);
     await mkdir(join(conversationDir, "scratch"), { recursive: true });
     if (executionResolver) {
         await resolveExecutorForRun({
             platform: platform.name,
             userId: message.userId,
             conversationId,
+            trustModel: platform.trustModel,
         });
         pathContext = getPathContext();
     }
@@ -768,9 +858,11 @@ async function prepareRunContext(params) {
     // provider prompt caching. If this hash changes between turns of one
     // conversation, something turn-varying leaked into the prompt; if it is
     // stable and cacheRead stays 0, the miss is provider-side (e.g. OpenRouter
-    // routing the model across upstream hosts).
+    // routing the model across upstream hosts). This is the base prompt mikan
+    // builds; a `before_agent_start` extension may still rewrite it per turn
+    // (logged separately by the runner).
     const promptHash = createHash("sha256").update(systemPrompt).digest("hex").slice(0, 8);
-    log.logInfo(`[${conversationId}] System prompt: ${systemPrompt.length} chars, sha ${promptHash}`);
+    log.logInfo(`[${conversationId}] System prompt (base): ${systemPrompt.length} chars, sha ${promptHash}`);
     setEventContext({
         platform: platform.name,
         conversationId,
@@ -782,6 +874,13 @@ async function prepareRunContext(params) {
         const hostPath = translateAttachPathToHost(filePath, pathContext);
         await responder.uploadFile(hostPath, title);
     });
+    // The react tool is available only when the responder supports reactions
+    // (interactive turns on platforms with reaction support); otherwise unset
+    // so the tool reports it is unavailable rather than silently no-op'ing.
+    setReactFunction(responder.react ? async (emoji) => responder.react(emoji) : null);
+    // Platform capability packs (e.g. GitHub PR/CI) enable themselves per run;
+    // core does not branch on platform name here.
+    bindPlatformToolPacks({ conversationId, platformName: platform.name });
     resetRunState(runState, responder, sessionConversation, message.userName, sessionUuid, triggerAttribution);
     const runQueue = createRunQueue(responder, runState);
     runState.queue = runQueue.queue;
@@ -790,7 +889,6 @@ async function prepareRunContext(params) {
     const { userMessage, imageAttachments } = buildPromptPayload(message, pathContext.runtimeWorkspaceRoot, pathContext);
     const turnInstructions = buildTurnInstructions(message.id.startsWith("event:"), triggerAttribution, platform.name);
     const finalUserMessage = turnInstructions ? `${turnInstructions}\n\n${userMessage}` : userMessage;
-    await writePromptDebugContext(conversationDir, systemPrompt, session, finalUserMessage, imageAttachments.length);
     return {
         sessionConversation,
         runQueue,
@@ -845,6 +943,15 @@ function attachSessionEventHandlers(params) {
             log.logToolStart(logCtx, event.toolName, label, event.args);
             return;
         }
+        if (event.type === "tool_execution_update") {
+            const label = extractToolProgressLabel(event.partialResult);
+            const progress = runState.toolProgress.get(event.toolCallId);
+            if (label && progress) {
+                progress.label = label;
+                scheduleToolProgressUpdate(responder, runState);
+            }
+            return;
+        }
         if (event.type === "tool_execution_end") {
             const resultStr = extractToolResultText(event.result);
             const pending = pendingTools.get(event.toolCallId);
@@ -856,7 +963,7 @@ function attachSessionEventHandlers(params) {
             const progress = runState.toolProgress.get(event.toolCallId);
             if (progress)
                 progress.status = event.isError ? "error" : "done";
-            queue.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
+            flushToolProgressUpdate(responder, runState);
             pendingTools.delete(event.toolCallId);
             const durationMs = pending ? Date.now() - pending.startTime : 0;
             Sentry.metrics.count("agent.tool.calls", 1, {
@@ -1069,27 +1176,6 @@ function attachSessionEventHandlers(params) {
         }
     });
 }
-function extractToolResultText(result) {
-    if (typeof result === "string") {
-        return result;
-    }
-    if (result &&
-        typeof result === "object" &&
-        "content" in result &&
-        Array.isArray(result.content)) {
-        const content = result.content;
-        const textParts = [];
-        for (const part of content) {
-            if (part.type === "text" && part.text) {
-                textParts.push(part.text);
-            }
-        }
-        if (textParts.length > 0) {
-            return textParts.join("\n");
-        }
-    }
-    return JSON.stringify(result);
-}
 /**
  * Create a new PiAgentWrapper for a channel.
  * Sets up the session and subscribes to events once.
@@ -1097,18 +1183,22 @@ function extractToolResultText(result) {
  * Runner caching is handled by the caller (channelStates in main.ts).
  * This is a stateless factory function.
  */
-export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, sessionView, platformNotifier) {
+export async function createRunner(options) {
+    const { sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, resourceController, sessionView, platformNotifier, platformReactor, platformUploader, platformToolPackFactories, } = options;
     const agentConfig = resolveConversationSettings(conversationDir);
     const workspaceBase = join(conversationDir, "..");
     const { executionResolver, executor, getPathContext, resolveExecutorForRun } = createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, workspaceBase);
     let pathContext = getUnresolvedSandboxPathContext(sandboxConfig, workspaceBase);
-    // Create tools (per-runner, with per-runner upload function setter)
-    const { tools, setUploadFunction, setEventContext, setSandboxContext } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner });
-    const modelRegistry = MikanModels.create();
+    const modelRegistry = options.models ?? MikanModels.create();
     if (modelRegistry.getError()) {
         log.logWarning("models.json load error", modelRegistry.getError());
     }
-    const model = resolveConfiguredModel(modelRegistry, agentConfig.provider, agentConfig.model);
+    const model = modelRegistry.resolve(agentConfig.provider, agentConfig.model);
+    // Create tools (per-runner, with per-runner upload function setter)
+    const { tools, setUploadFunction, setReactFunction, bindPlatformToolPacks, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, resourceController: resourceController ?? provisioner }, platformToolPackFactories ?? [], {
+        model,
+        getApiKey: () => modelRegistry.getApiKeyForProvider(model.provider),
+    });
     // Initial system prompt (will be updated each run with fresh memory/channels/users/skills)
     const memory = await getMemory(conversationDir);
     const skills = loadMikanSkills(conversationDir, pathContext.runtimeWorkspaceRoot);
@@ -1117,12 +1207,13 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         formattingGuide: "",
         channels: [],
         users: [],
+        trustModel: "membership",
     };
     const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, conversationId, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills);
     // Create session manager and settings manager. Top-level/private sessions
     // use the conversation's current pointer; scoped sessions use fixed files.
     // Platform-specific scope behavior is resolved before runner creation.
-    const isThread = sessionKey.includes(":");
+    const isThread = isThreadSessionKey(sessionKey);
     const { contextFile, threadRootMessage } = sessionScope;
     const sessionManager = openManagedSession(contextFile, pathContext.runtimeWorkspaceRoot);
     const threadSessionName = buildThreadSessionName(threadRootMessage);
@@ -1130,8 +1221,8 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         sessionManager.appendSessionInfo(threadSessionName);
     }
     const sessionUuid = extractSessionUuid(contextFile);
-    const chatSessionManager = new AgentMemoryFileManager();
-    const { session, extensionSkills } = await createConfiguredAgentSession({
+    const chatSessionManager = new ChatHistorySync();
+    const { session, extensionSkills, extensionRegistry, disposeExtensions } = await createConfiguredAgentSession({
         conversationId,
         workspaceDir,
         systemPrompt,
@@ -1142,6 +1233,8 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         models: modelRegistry,
         vaultManager,
         platformNotifier,
+        platformReactor,
+        platformUploader,
     });
     // Mutable per-run state - event handler references this
     const runState = createRunState();
@@ -1173,6 +1266,8 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 setEventContext,
                 setSandboxContext,
                 setUploadFunction,
+                setReactFunction,
+                bindPlatformToolPacks,
                 pathContext,
             });
             pathContext = prepared.pathContext;
@@ -1201,10 +1296,39 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             // Autonomous (event/trigger) runs get an explicit resource ceiling since
             // no human is watching the loop; interactive turns stay human-gated.
             const isEventRun = message.id.startsWith("event:");
-            await session.prompt(prepared.userMessage, {
+            // Event runs have no triggering platform message, so identity fields
+            // stay unset and extensions must null-check them.
+            const origin = isEventRun
+                ? { kind: "event", platform: platform.name }
+                : {
+                    kind: "interactive",
+                    platform: platform.name,
+                    messageTs: message.id,
+                    userId: message.userId,
+                    userName: message.userName,
+                    threadTs: message.threadTs,
+                    attachments: message.attachments,
+                };
+            const outcome = await session.prompt(prepared.userMessage, {
+                origin,
                 ...(prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : {}),
                 ...(isEventRun ? { budget: DEFAULT_EVENT_BUDGET } : {}),
             });
+            if (outcome?.blocked) {
+                const text = outcome.reason
+                    ? `_Turn blocked by an extension: ${outcome.reason}_`
+                    : "_Turn blocked by an extension._";
+                sendAgentEvent({
+                    sessionId: sessionUuid,
+                    actorName: formatAgentActorName(message.userName, prepared.sessionConversation),
+                    event: { kind: "diagnostic", text },
+                });
+                await responder.respondDiagnostic(text, { style: "muted" });
+                runState.responder = null;
+                runState.logCtx = null;
+                runState.queue = null;
+                return { stopReason: "blocked" };
+            }
             // Wait for queued messages
             await prepared.runQueue.wait();
             const sessionViewTokenStore = sessionView?.tokenStore;
@@ -1250,6 +1374,21 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         abort() {
             session.abort();
         },
+        async tryExtensionCommand(message, responder) {
+            const parsed = parseCommandInput(message.text);
+            if (!parsed)
+                return false;
+            return extensionRegistry.dispatchCommand(parsed.name, {
+                args: parsed.args,
+                conversationId,
+                userId: message.userId,
+                userName: message.userName,
+                respond: (text) => responder.respond(text),
+            });
+        },
+        async dispose() {
+            await disposeExtensions();
+        },
         getCurrentStep() {
             const pending = runState.pendingTools;
             if (pending.size === 0)
@@ -1265,13 +1404,4 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         },
     };
 }
-export function translateRuntimePathToHost(runtimePath, pathContext) {
-    return pathContext.runtimeToHostPath?.(runtimePath) ?? runtimePath;
-}
-export function translateAttachPathToHost(filePath, pathContext) {
-    const runtimePath = posix.isAbsolute(filePath)
-        ? filePath
-        : posix.join(pathContext.runtimeWorkspaceRoot, filePath);
-    return translateRuntimePathToHost(runtimePath, pathContext);
-}
 //# sourceMappingURL=agent.js.map