@geminixiang/mikan 0.5.2 → 1.0.0-beta.0

package/dist/agent.js

@@ -1,10 +1,10 @@
-import { Agent } from "@earendil-works/pi-agent-core";
-import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, formatSkillsForPrompt, getAgentDir, loadSkillsFromDir, ModelRegistry, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_EVENT_BUDGET, defaultExtensionDirs, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, } from "./harness/index.js";
+import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
 import { join, posix } from "path";
 import { resolveConversationSettings } from "./config.js";
+import { readEnv } from "./utils/env.js";
 import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
 import { reportUserFacingError } from "./observability/sentry.js";
@@ -13,6 +13,7 @@ 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 { extractSessionUuid, openManagedSession, } from "./sessions/store.js";
+import { HostEventStore } from "./tools/event.js";
 import { createMikanTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
 import { formatLocalTimestamp } from "./utils/date.js";
@@ -151,7 +152,7 @@ export function resolveTriggerAttribution(message) {
         return `@${message.userName}`;
     return undefined;
 }
-function buildSystemPrompt(workspacePath, conversationId, conversationKind, currentUserId, memory, sandboxConfig, platform, skills, isEventTrigger = false, triggerAttribution) {
+function buildSystemPrompt(workspacePath, conversationId, conversationKind, currentUserId, memory, sandboxConfig, platform, skills) {
     const { workspaceRoot, conversationPath, scratchPath } = buildRuntimePaths(workspacePath, conversationId);
     const sandboxType = sandboxConfig.type;
     const isContainerLike = sandboxType === "container" || sandboxType === "image";
@@ -165,25 +166,11 @@ function buildSystemPrompt(workspacePath, conversationId, conversationKind, curr
         ? platform.users.map((u) => `${u.id}\t@${u.userName}\t${u.displayName}`).join("\n")
         : "(no users loaded)";
     const envDescription = buildEnvDescription(sandboxType, workspaceRoot);
-    const eventTriggerInstructions = isEventTrigger
-        ? `
-## Event Trigger Mode
-- You are handling a scheduled/background event, not opening a brand new chat with a stranger.
-- Treat the incoming user message as a self-contained task prepared by an earlier run.
-- Complete the task directly. Avoid generic greetings, self-introductions, or boilerplate offers to help.
-- For reminders/follow-ups, prefer a short direct response that sounds like a continuation of prior intent.
-- If the event text includes tone, brevity, or language instructions, follow them literally.
-`
-        : "";
-    const attributionInstructions = triggerAttribution
-        ? `
-## Attribution
-Always end your final ${platform.name} response and any GitHub issue/PR comments or descriptions you write via tools with:
-_Triggered by ${triggerAttribution}_
-
-Do not add this to \`[SILENT]\` responses.
-`
-        : "";
+    // Per-turn instructions (event-trigger mode, attribution) are delivered with
+    // the user message via buildTurnInstructions(), not baked in here, so this
+    // system prompt stays byte-stable across a conversation's turns and keeps the
+    // provider prompt cache warm (a changing system prefix invalidates the cache
+    // for the whole request, including the far larger conversation history).
     const slackBlockKitInstructions = platform.name === "slack"
         ? `
 ## Slack Rendering
@@ -202,7 +189,6 @@ Do not add this to \`[SILENT]\` responses.
 - Scoped/thread sessions use fixed files at \`${conversationPath}/sessions/<scope_id>.jsonl\` (for example \`${conversationPath}/sessions/1777386320.800769.jsonl\`).
 - If a user asks about something that should exist in conversation history but is not found in the current context window, do not answer "I don't know" or "I don't have that". Instead, search the thread session, top-level session, and \`log.jsonl\` before responding.
 - User messages include a \`[in-thread:TS]\` marker when sent from within a platform thread/reply (TS is the thread or parent message identifier). Without this marker, the message is a top-level conversation message.
-${eventTriggerInstructions}
 ${platform.formattingGuide}${slackBlockKitInstructions}
 
 ## Platform IDs
@@ -290,7 +276,6 @@ Format: \`{"date":"...","ts":"...","user":"...","userName":"...","text":"...","i
 The log contains user messages and your final responses (not tool calls/results).
 Use \`log.jsonl\` for quick grep-style history. Use \`${conversationPath}/sessions/\` when you need structured turns, tool outputs, or thread/session lineage.
 ${isContainerLike || isFirecracker ? "Install jq: apt-get install jq" : ""}
-${attributionInstructions}
 \`\`\`bash
 # Recent messages
 tail -30 log.jsonl | jq -c '{date: .date[0:19], user: (.userName // .user), text}'
@@ -318,6 +303,32 @@ ls -1 sessions/
 Each tool requires a "label" parameter (shown to user).
 `;
 }
+/**
+ * Instructions that vary per turn (event-trigger mode, response attribution).
+ * These are delivered with the user message rather than baked into the system
+ * prompt, so the system prompt stays cache-stable across a conversation's turns
+ * (in a multi-user channel the attribution line alone changes every turn).
+ * Returns an empty string when the turn needs no special framing.
+ */
+export function buildTurnInstructions(isEventTrigger, triggerAttribution, platformName) {
+    const parts = [];
+    if (isEventTrigger) {
+        parts.push(`## Event Trigger Mode
+- You are handling a scheduled/background event, not opening a brand new chat with a stranger.
+- Treat the incoming user message as a self-contained task prepared by an earlier run.
+- Complete the task directly. Avoid generic greetings, self-introductions, or boilerplate offers to help.
+- For reminders/follow-ups, prefer a short direct response that sounds like a continuation of prior intent.
+- If the event text includes tone, brevity, or language instructions, follow them literally.`);
+    }
+    if (triggerAttribution) {
+        parts.push(`## Attribution
+Always end your final ${platformName} response and any GitHub issue/PR comments or descriptions you write via tools with:
+_Triggered by ${triggerAttribution}_
+
+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");
@@ -325,13 +336,7 @@ export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot
     return createExecutor(sandboxConfig).getPathContext(hostWorkspaceRoot);
 }
 function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
-    const executionResolver = vaultManager &&
-        sandboxConfig.type !== "host" &&
-        (vaultManager.isEnabled() ||
-            sandboxConfig.type === "container" ||
-            sandboxConfig.type === "image" ||
-            sandboxConfig.type === "cloudflare" ||
-            sandboxConfig.type === "firecracker")
+    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
@@ -364,58 +369,81 @@ function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner,
         },
     };
 }
-async function createConfiguredAgentSession(params) {
-    const { conversationId, workspaceDir, runtimeWorkspaceRoot, systemPrompt, model, thinkingLevel, tools, sessionManager, settingsManager, modelRegistry, } = params;
-    const agent = new Agent({
-        initialState: {
-            systemPrompt,
-            model,
-            thinkingLevel,
-            tools,
+/**
+ * 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,
+            })),
         },
-        convertToLlm,
-        getApiKey: async (provider) => {
-            const key = await modelRegistry.getApiKeyForProvider(provider);
-            if (!key) {
-                throw new Error(`No API key for provider "${provider}". Set the appropriate environment variable or configure via auth.json`);
+        ...(platformNotifier ? { postMessage: platformNotifier } : {}),
+        ...(vaultManager
+            ? {
+                resolveSecrets: (slug) => vaultManager.resolve(`extensions/${slug}`)?.env ?? {},
             }
-            return key;
-        },
+            : {}),
+    };
+}
+/**
+ * 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;
+    const byName = new Map();
+    for (const skill of extension)
+        byName.set(skill.name, skill);
+    for (const skill of local)
+        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 }),
     });
-    const loadedSession = sessionManager.buildSessionContext();
-    if (loadedSession.messages.length > 0) {
-        agent.state.messages = loadedSession.messages;
-        log.logInfo(`[${conversationId}] Reloaded ${loadedSession.messages.length} messages from session context`);
+    for (const err of extensionsResult.errors) {
+        log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
     }
-    const resourceLoader = new DefaultResourceLoader({
-        cwd: workspaceDir,
-        agentDir: getAgentDir(),
+    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,
     });
-    try {
-        await resourceLoader.reload();
-        const extResult = resourceLoader.getExtensions();
-        if (extResult.errors.length > 0) {
-            for (const err of extResult.errors) {
-                log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
-            }
-        }
-        log.logInfo(`[${conversationId}] Loaded ${extResult.extensions.length} extension(s): ${extResult.extensions.map((extension) => extension.path).join(", ")}`);
-    }
-    catch (error) {
-        log.logWarning(`[${conversationId}] Failed to load resources`, String(error));
+    const reloaded = session.reloadFromSession();
+    if (reloaded > 0) {
+        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from session context`);
     }
-    const baseToolsOverride = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
-    const session = new AgentSession({
-        agent,
-        sessionManager,
-        settingsManager,
-        cwd: runtimeWorkspaceRoot,
-        modelRegistry,
-        resourceLoader,
-        baseToolsOverride,
-    });
-    return { agent, session };
+    return { session, extensionSkills: extensionsResult.skills };
 }
 function createEmptyUsageTotals() {
     return {
@@ -541,13 +569,23 @@ function getFinalAssistantText(session) {
         .map((content) => content.text)
         .join("\n") || "");
 }
-export function appendTriggerAttribution(text, triggerAttribution) {
+export function appendTriggerAttribution(text, triggerAttribution, sessionLink) {
     if (!triggerAttribution)
         return text;
-    const suffix = `_Triggered by ${triggerAttribution}_`;
-    if (text.trimEnd().endsWith(suffix))
+    const trimmed = text.trimEnd();
+    const legacySuffix = `_Triggered by ${triggerAttribution}_`;
+    const suffix = sessionLink
+        ? `_Triggered by ${triggerAttribution} · session: ${sessionLink}_`
+        : legacySuffix;
+    if (trimmed.endsWith(suffix))
         return text;
-    return `${text.trimEnd()}\n\n${suffix}`;
+    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;
 }
 function extractToolLabel(toolName, args) {
     const label = args?.label;
@@ -635,7 +673,7 @@ async function finalizeRunResponse(responder, session, runState, options) {
     if (!finalText.trim())
         return;
     try {
-        await responder.replaceResponse(appendTriggerAttribution(formatResponseWithToolProgress(finalText, runState), options?.triggerAttribution), { createOverflowLink: options?.createOverflowLink });
+        await responder.replaceResponse(appendTriggerAttribution(formatResponseWithToolProgress(finalText, runState), options?.triggerAttribution, options?.triggerSessionLink), { createOverflowLink: options?.createOverflowLink });
     }
     catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
@@ -701,15 +739,14 @@ async function reportUsageSummary(ctx) {
         await waitForQueue();
     }
 }
-function reloadSessionMessages(sessionManager, conversationId, agent) {
-    const messages = sessionManager.buildSessionContext().messages;
-    if (messages.length > 0) {
-        agent.state.messages = messages;
-        log.logInfo(`[${conversationId}] Reloaded ${messages.length} messages from context`);
+function reloadSessionMessages(session, conversationId) {
+    const reloaded = session.reloadFromSession();
+    if (reloaded > 0) {
+        log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from context`);
     }
 }
 async function prepareRunContext(params) {
-    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, sessionManager, session, agent, setEventContext, setSandboxContext, setUploadFunction, } = params;
+    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, } = params;
     let pathContext = params.pathContext;
     const sessionConversation = message.sessionKey.split(":")[0];
     await mkdir(join(conversationDir, "scratch"), { recursive: true });
@@ -721,12 +758,19 @@ async function prepareRunContext(params) {
         });
         pathContext = getPathContext();
     }
-    reloadSessionMessages(sessionManager, conversationId, agent);
+    reloadSessionMessages(session, conversationId);
     const memory = await getMemory(conversationDir);
-    const skills = loadMikanSkills(conversationDir, pathContext.runtimeWorkspaceRoot);
+    const skills = mergeExtensionSkills(loadMikanSkills(conversationDir, pathContext.runtimeWorkspaceRoot), params.extensionSkills ?? []);
     const triggerAttribution = resolveTriggerAttribution(message);
-    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, conversationId, message.conversationKind, message.userId, memory, executor.getSandboxConfig(), platform, skills, message.id.startsWith("event:"), triggerAttribution);
+    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, conversationId, message.conversationKind, message.userId, memory, executor.getSandboxConfig(), platform, skills);
     session.agent.state.systemPrompt = systemPrompt;
+    // Cache diagnosis: a byte-stable system prompt is the precondition for
+    // 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).
+    const promptHash = createHash("sha256").update(systemPrompt).digest("hex").slice(0, 8);
+    log.logInfo(`[${conversationId}] System prompt: ${systemPrompt.length} chars, sha ${promptHash}`);
     setEventContext({
         platform: platform.name,
         conversationId,
@@ -744,11 +788,13 @@ async function prepareRunContext(params) {
     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 } = buildPromptPayload(message, pathContext.runtimeWorkspaceRoot, pathContext);
-    await writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachments.length);
+    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,
-        userMessage,
+        userMessage: finalUserMessage,
         imageAttachments,
         triggerAttribution,
         pathContext,
@@ -760,6 +806,7 @@ function formatAgentActorName(userName, fallback) {
 function sendAgentEvent(payload) {
     emitAgentEvent({ source: "mikan", ...payload });
 }
+// ponytail: additive SSE mirror only; keep responder rendering here until another frontend needs the same stream.
 function attachSessionEventHandlers(params) {
     const { session, runState, model, agentConfig } = params;
     session.subscribe(async (event) => {
@@ -860,12 +907,17 @@ function attachSessionEventHandlers(params) {
         }
         if (event.type === "message_update") {
             const assistantMessageEvent = event.assistantMessageEvent;
-            if (assistantMessageEvent?.type === "text_delta" &&
-                assistantMessageEvent.delta &&
-                responder.appendResponseDelta) {
-                queue.enqueue(async () => {
-                    await responder.appendResponseDelta?.(assistantMessageEvent.delta ?? "");
-                }, "response delta");
+            if (assistantMessageEvent?.type === "text_delta" && assistantMessageEvent.delta) {
+                sendAgentEvent({
+                    sessionId: agentEventSessionId,
+                    actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                    event: { kind: "responseDelta", delta: assistantMessageEvent.delta },
+                });
+                if (responder.appendResponseDelta) {
+                    queue.enqueue(async () => {
+                        await responder.appendResponseDelta?.(assistantMessageEvent.delta ?? "");
+                    }, "response delta");
+                }
             }
             return;
         }
@@ -948,6 +1000,11 @@ function attachSessionEventHandlers(params) {
                         return;
                     const finalText = appendTriggerAttribution(formatResponseWithToolProgress(text, runState), runState.triggerAttribution);
                     log.logResponse(logCtx, text);
+                    sendAgentEvent({
+                        sessionId: agentEventSessionId,
+                        actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                        event: { kind: "responseFinal", text: finalText },
+                    });
                     sendAgentEvent({
                         sessionId: agentEventSessionId,
                         actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
@@ -966,8 +1023,14 @@ function attachSessionEventHandlers(params) {
             return;
         }
         if (event.type === "compaction_start") {
+            const text = "_Compacting context..._";
             log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
-            queue.enqueue(() => responder.respond("_Compacting context..._"), "compaction start");
+            sendAgentEvent({
+                sessionId: agentEventSessionId,
+                actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                event: { kind: "diagnostic", text },
+            });
+            queue.enqueue(() => responder.respond(text), "compaction start");
             return;
         }
         if (event.type === "compaction_end") {
@@ -986,7 +1049,23 @@ function attachSessionEventHandlers(params) {
                 actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
                 event: { kind: "sessionStart" },
             });
-            queue.enqueue(() => responder.respond(`_Retrying (${event.attempt}/${event.maxAttempts})..._`), "retry");
+            const text = `_Retrying (${event.attempt}/${event.maxAttempts})..._`;
+            sendAgentEvent({
+                sessionId: agentEventSessionId,
+                actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                event: { kind: "diagnostic", text },
+            });
+            queue.enqueue(() => responder.respond(text), "retry");
+        }
+        if (event.type === "budget_exceeded") {
+            log.logWarning("Run stopped by budget circuit breaker", `${event.reason} (tokens=${event.tokens}, cost=${event.costUsd.toFixed(2)}, calls=${event.llmCalls}, ${event.durationMs}ms)`);
+            const text = `_Stopped: run budget exceeded (${event.reason})_`;
+            sendAgentEvent({
+                sessionId: agentEventSessionId,
+                actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                event: { kind: "diagnostic", text },
+            });
+            queue.enqueue(() => responder.respondDiagnostic(text, { style: "error" }), "budget exceeded");
         }
     });
 }
@@ -1018,15 +1097,17 @@ 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) {
+export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, sessionView, platformNotifier) {
     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 authStorage = AuthStorage.create(join(homedir(), ".pi", "mikan", "auth.json"));
-    const modelRegistry = ModelRegistry.create(authStorage);
+    const modelRegistry = MikanModels.create();
+    if (modelRegistry.getError()) {
+        log.logWarning("models.json load error", modelRegistry.getError());
+    }
     const model = resolveConfiguredModel(modelRegistry, agentConfig.provider, agentConfig.model);
     // Initial system prompt (will be updated each run with fresh memory/channels/users/skills)
     const memory = await getMemory(conversationDir);
@@ -1042,26 +1123,25 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
     // 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 { sessionDir, contextFile, threadRootMessage } = sessionScope;
-    const sessionManager = openManagedSession(contextFile, sessionDir, pathContext.runtimeWorkspaceRoot);
+    const { contextFile, threadRootMessage } = sessionScope;
+    const sessionManager = openManagedSession(contextFile, pathContext.runtimeWorkspaceRoot);
     const threadSessionName = buildThreadSessionName(threadRootMessage);
     if (isThread && threadSessionName && sessionManager.getSessionName() !== threadSessionName) {
         sessionManager.appendSessionInfo(threadSessionName);
     }
     const sessionUuid = extractSessionUuid(contextFile);
     const chatSessionManager = new AgentMemoryFileManager();
-    const settingsManager = SettingsManager.inMemory();
-    const { agent, session } = await createConfiguredAgentSession({
+    const { session, extensionSkills } = await createConfiguredAgentSession({
         conversationId,
         workspaceDir,
-        runtimeWorkspaceRoot: pathContext.runtimeWorkspaceRoot,
         systemPrompt,
         model,
         thinkingLevel: agentConfig.thinkingLevel,
         tools,
-        sessionManager,
-        settingsManager,
-        modelRegistry,
+        sessionStore: sessionManager,
+        models: modelRegistry,
+        vaultManager,
+        platformNotifier,
     });
     // Mutable per-run state - event handler references this
     const runState = createRunState();
@@ -1088,9 +1168,8 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 executionResolver,
                 resolveExecutorForRun,
                 getPathContext,
-                sessionManager,
                 session,
-                agent,
+                extensionSkills,
                 setEventContext,
                 setSandboxContext,
                 setUploadFunction,
@@ -1119,20 +1198,33 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 actorName: formatAgentActorName(message.userName, prepared.sessionConversation),
                 event: { kind: "sessionStart" },
             });
-            await session.prompt(prepared.userMessage, prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : undefined);
+            // 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, {
+                ...(prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : {}),
+                ...(isEventRun ? { budget: DEFAULT_EVENT_BUDGET } : {}),
+            });
             // Wait for queued messages
             await prepared.runQueue.wait();
             const sessionViewTokenStore = sessionView?.tokenStore;
             const sessionViewPortalBaseUrl = sessionView?.portalBaseUrl;
-            const createOverflowLink = sessionViewTokenStore && sessionViewPortalBaseUrl
+            let sessionViewLink;
+            const createSessionViewLink = sessionViewTokenStore && sessionViewPortalBaseUrl
                 ? () => {
-                    const token = sessionViewTokenStore.create(platform.name, message.userId, conversationId, message.sessionKey, contextFile, message.userName);
-                    return `${sessionViewPortalBaseUrl}/session?token=${token.token}`;
+                    if (!sessionViewLink) {
+                        const token = sessionViewTokenStore.create(platform.name, message.userId, conversationId, message.sessionKey, contextFile, message.userName);
+                        sessionViewLink = `${sessionViewPortalBaseUrl}/session?token=${token.token}`;
+                    }
+                    return sessionViewLink;
                 }
                 : undefined;
             await finalizeRunResponse(responder, session, runState, {
                 triggerAttribution: prepared.triggerAttribution,
-                createOverflowLink,
+                triggerSessionLink: isEventTriggerAttribution(prepared.triggerAttribution)
+                    ? createSessionViewLink?.()
+                    : undefined,
+                createOverflowLink: createSessionViewLink,
                 platform: platform.name,
                 model,
                 sessionConversation: prepared.sessionConversation,