@geminixiang/mikan 0.5.3 → 1.0.0-beta.1

package/CHANGELOG.md

@@ -9,6 +9,33 @@ any release.
 
 ## [Unreleased]
 
+## [1.0.0-beta.1]
+
+### Fixed
+
+- Accept `maxOutputTokens` as an alias for `maxTokens` in custom model configuration.
+- Restore npm release automation with compatible Node.js and npm versions.
+
+### Tests
+
+- Add coverage for production-shaped custom model configuration.
+
+## [1.0.0-beta.0]
+
+### Added
+
+- Add mikan's native agent harness with model, authentication, session, compaction, and skill support.
+- Add an extension system for hooks, schedules, notifications, data directories, secrets, and bundled skills, with an agent project manager example.
+- Add per-conversation token usage bar charts to the admin portal.
+
+### Changed
+
+- Replace the pi-coding-agent runtime and session integration with the native harness built on pi-agent-core and pi-ai.
+
+### Tests
+
+- Add coverage for harness authentication, extensions, HTTP helpers, runner, sessions, and skills.
+
 ## [0.5.3] - 2026-06-30
 
 ### Added

package/README.md

@@ -16,8 +16,8 @@ mikan keeps the chat record, agent session, and execution runtime separate:
 ![mikan architecture](src/content/docs/assets/architecture.png)
 
 - **Chat / conversation data** is the platform-facing record: `log.jsonl`, attachments, and conversation files.
-- **Session orchestration** turns platform events into agent runs, handles top-level/thread scopes, and persists pi-coding-agent structured context under `sessions/*.jsonl`.
-- **pi-coding-agent harness** runs the model loop and calls mikan tools.
+- **Session orchestration** turns platform events into agent runs, handles top-level/thread scopes, and persists structured context under `sessions/*.jsonl`.
+- **mikan agent harness** (`src/harness/`, built on pi-agent-core and pi-ai) runs the model loop, session persistence, compaction, and calls mikan tools.
 - **Sandbox runtime** is where tool commands execute: host, Docker container/image, Firecracker, or Cloudflare bridge.
 - **Vault** provides runtime credentials as env vars and mounted secret files.
 

package/dist/adapter.d.ts

@@ -1,2 +1,2 @@
-export type { MessagingBot, ConversationContext, ConversationEvent, MessagingEventHandler, ChatAdapter, ConversationMessage, ConversationResponder, ChatToolResult, ConversationKind, MessagingInfo, PlatformName, RunningSession, } from "./types.js";
+export type { MessagingBot, ConversationContext, ConversationEvent, MessagingEventHandler, ChatAdapter, ConversationMessage, ConversationResponder, ChatToolResult, ConversationKind, MessagingInfo, PlatformName, PlatformNotifier, RunningSession, } from "./types.js";
 //# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,cAAc,GACf,MAAM,YAAY,CAAC"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,mBAAmB,EACnB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,cAAc,GACf,MAAM,YAAY,CAAC"}

package/dist/adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"","sourcesContent":["export type {\n  MessagingBot,\n  ConversationContext,\n  ConversationEvent,\n  MessagingEventHandler,\n  ChatAdapter,\n  ConversationMessage,\n  ConversationResponder,\n  ChatToolResult,\n  ConversationKind,\n  MessagingInfo,\n  PlatformName,\n  RunningSession,\n} from \"./types.js\";\n"]}
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"","sourcesContent":["export type {\n  MessagingBot,\n  ConversationContext,\n  ConversationEvent,\n  MessagingEventHandler,\n  ChatAdapter,\n  ConversationMessage,\n  ConversationResponder,\n  ChatToolResult,\n  ConversationKind,\n  MessagingInfo,\n  PlatformName,\n  PlatformNotifier,\n  RunningSession,\n} from \"./types.js\";\n"]}

package/dist/agent.d.ts

@@ -1,5 +1,6 @@
 import { type ImageContent } from "@earendil-works/pi-ai";
 import type { ConversationMessage } from "./adapter.js";
+import type { PlatformNotifier } from "./types.js";
 import type { SessionViewTokenStoreLike } from "./commands/types.js";
 import type { DockerContainerManager } from "./provisioner.js";
 import { type RuntimePathContext, type SandboxConfig } from "./sandbox/index.js";
@@ -8,6 +9,14 @@ import { type ResolvedSessionScope } from "./sessions/store.js";
 export type { PiAgentWrapper } from "./types.js";
 import type { PiAgentWrapper } from "./types.js";
 export declare function resolveTriggerAttribution(message: Pick<ConversationMessage, "id" | "text" | "userName">): string | undefined;
+/**
+ * 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 declare function buildTurnInstructions(isEventTrigger: boolean, triggerAttribution: string | undefined, platformName: string): string;
 export declare function getUnresolvedSandboxPathContext(sandboxConfig: SandboxConfig, hostWorkspaceRoot: string): RuntimePathContext;
 export declare function buildPromptPayload(message: ConversationMessage, workspacePath: string, pathContext?: RuntimePathContext): {
     userMessage: string;
@@ -24,7 +33,7 @@ export declare function appendTriggerAttribution(text: string, triggerAttributio
 export declare function createRunner(sandboxConfig: SandboxConfig, sessionKey: string, conversationId: string, conversationDir: string, workspaceDir: string, sessionScope: ResolvedSessionScope, vaultManager?: VaultManager, provisioner?: DockerContainerManager, sessionView?: {
     tokenStore: SessionViewTokenStoreLike;
     portalBaseUrl?: string;
-}): Promise<PiAgentWrapper>;
+}, platformNotifier?: PlatformNotifier): Promise<PiAgentWrapper>;
 export declare function translateRuntimePathToHost(runtimePath: string, pathContext: RuntimePathContext): string;
 export declare function translateAttachPathToHost(filePath: string, pathContext: RuntimePathContext): string;
 //# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,YAAY,EAAc,MAAM,uBAAuB,CAAC;AAkBhF,OAAO,KAAK,EACV,mBAAmB,EAKpB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAKrE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,qBAAqB,CAAC;AAO7B,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAyIjD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC,GAC7D,MAAM,GAAG,SAAS,CAOpB;AA+LD,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,aAAa,EAC5B,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,CAMpB;AA+SD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,mBAAmB,EAC5B,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,kBAAkB,GAC/B;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,YAAY,EAAE,CAAC;CAClC,CAaA;AA+BD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,MAAM,GAAG,SAAS,EACtC,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAYR;AA+qBD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,oBAAoB,EAClC,YAAY,CAAC,EAAE,YAAY,EAC3B,WAAW,CAAC,EAAE,sBAAsB,EACpC,WAAW,CAAC,EAAE;IACZ,UAAU,EAAE,yBAAyB,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GACA,OAAO,CAAC,cAAc,CAAC,CA0NzB;AAED,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,kBAAkB,GAC9B,MAAM,CAER;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,kBAAkB,GAC9B,MAAM,CAKR"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,YAAY,EAAc,MAAM,uBAAuB,CAAC;AAkBhF,OAAO,KAAK,EACV,mBAAmB,EAKpB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAiC,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAMrE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,qBAAqB,CAAC;AAQ7B,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAyIjD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,IAAI,GAAG,MAAM,GAAG,UAAU,CAAC,GAC7D,MAAM,GAAG,SAAS,CAOpB;AA6KD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,OAAO,EACvB,kBAAkB,EAAE,MAAM,GAAG,SAAS,EACtC,YAAY,EAAE,MAAM,GACnB,MAAM,CAkBR;AAED,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,aAAa,EAC5B,iBAAiB,EAAE,MAAM,GACxB,kBAAkB,CAMpB;AAwUD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,mBAAmB,EAC5B,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,kBAAkB,GAC/B;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,YAAY,EAAE,CAAC;CAClC,CAaA;AA+BD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,MAAM,GAAG,SAAS,EACtC,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CAYR;AAmsBD;;;;;;GAMG;AACH,wBAAsB,YAAY,CAChC,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,oBAAoB,EAClC,YAAY,CAAC,EAAE,YAAY,EAC3B,WAAW,CAAC,EAAE,sBAAsB,EACpC,WAAW,CAAC,EAAE;IACZ,UAAU,EAAE,yBAAyB,CAAC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,EACD,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,cAAc,CAAC,CAyNzB;AAED,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,kBAAkB,GAC9B,MAAM,CAER;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,kBAAkB,GAC9B,MAAM,CAKR"}

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");
@@ -358,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 {
@@ -705,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 });
@@ -725,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,
@@ -748,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,
@@ -1015,6 +1057,16 @@ function attachSessionEventHandlers(params) {
             });
             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");
+        }
     });
 }
 function extractToolResultText(result) {
@@ -1045,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);
@@ -1069,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();
@@ -1115,9 +1168,8 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 executionResolver,
                 resolveExecutorForRun,
                 getPathContext,
-                sessionManager,
                 session,
-                agent,
+                extensionSkills,
                 setEventContext,
                 setSandboxContext,
                 setUploadFunction,
@@ -1146,7 +1198,13 @@ 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;