@geminixiang/mikan 1.0.0-beta.37 → 1.0.0-beta.39

package/dist/agent.js

@@ -2,19 +2,17 @@
  * Agent runner: prompt construction, path translation, run lifecycle, and createRunner.
  * Single module — do not split helpers that only this file uses.
  */
-import { officeDirName } from "./office-address.js";
 import { DEFAULT_EVENT_BUDGET, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, parseCommandInput, } from "./harness/index.js";
 import { runSubagent } from "./harness/subagent-runner.js";
 import { loadSubagentProfiles } from "./harness/subagent-profiles.js";
 import { mergeSubagentProgress, parseSubagentProgressSnapshot, renderSubagentDashboard, settleSubagentProgress, } from "./subagent-progress.js";
 import { createHash } from "crypto";
-import { existsSync, lstatSync, readdirSync } from "fs";
+import { existsSync, lstatSync } from "fs";
 import { chmod, mkdtemp, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { basename, isAbsolute, join, posix, relative, resolve, sep } from "path";
 import { resolveConversationSettings } from "./config.js";
 import { resolveWorkspaceProjection } from "./workspace-projection/index.js";
-import { effectiveStateDir } from "./cli/arg-grammar.js";
 import { packageSkillRuntimeDir, resolveConversationPackages } from "./packages/index.js";
 import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
@@ -191,12 +189,11 @@ function isRegularFile(path) {
         return false;
     }
 }
-function loadMikanSkills(address, conversationDir, workspacePath, projection) {
+function loadMikanSkills(office, workspacePath, projection) {
     const skillMap = new Map();
-    // conversationDir is the host path (e.g., /Users/.../data/C0A34FL8PMH)
-    // hostWorkspacePath is the parent directory on host
-    // workspacePath is the container path (e.g., /workspace)
-    const hostWorkspacePath = join(conversationDir, "..");
+    // workspacePath is the runtime-side root (e.g. /workspace); host paths under
+    // the workspace root translate onto it for prompt references.
+    const hostWorkspacePath = office.workspace.root;
     // Helper to translate host paths to container paths
     const translatePath = (hostPath) => {
         if (hostPath.startsWith(hostWorkspacePath)) {
@@ -214,11 +211,7 @@ function loadMikanSkills(address, conversationDir, workspacePath, projection) {
     // so the agent can read the files — including any scripts or templates the
     // skill ships alongside its SKILL.md, which inlining could never carry.
     const mounted = workspacePath !== hostWorkspacePath;
-    for (const { slug, dir } of resolveConversationPackages({
-        address,
-        stateDir: effectiveStateDir(),
-        conversationDir,
-    }).skillDirs) {
+    for (const { slug, dir } of resolveConversationPackages({ office }).skillDirs) {
         const runtimeDir = packageSkillRuntimeDir(slug);
         for (const skill of loadSkillsFromDir({ dir, source: `package:${slug}` }).skills) {
             // In host mode there is no mount, so the host path is already the path
@@ -242,58 +235,32 @@ function loadMikanSkills(address, conversationDir, workspacePath, projection) {
     }
     // Load conversation-specific skills (override workspace skills on collision).
     // Host prompt construction must never follow an agent-created symlink out of
-    // the conversation office.
+    // the conversation office, so this load rejects symlinks per entry — on
+    // exactly the paths it reads. Vendored node_modules and dot directories are
+    // never read and never disqualify anything.
     const conversationSkillsDir = projection.promptSources.conversationSkillsDir;
-    if (isSafePromptSkillTree(conversationSkillsDir, projection.promptSources.conversationDir)) {
-        for (const skill of loadSkillsFromDir({ dir: conversationSkillsDir, source: "channel" })
-            .skills) {
-            skill.filePath = translatePath(skill.filePath);
-            skill.baseDir = translatePath(skill.baseDir);
-            skillMap.set(skill.name, skill);
-        }
-    }
-    else if (existsSync(conversationSkillsDir)) {
-        log.logWarning("Ignoring unsafe conversation skill tree", conversationSkillsDir);
-    }
-    return Array.from(skillMap.values());
-}
-export function isSafePromptSkillTree(dir, conversationDir) {
-    if (!existsSync(dir))
-        return true;
-    if (dir !== conversationDir && !dir.startsWith(`${conversationDir}${sep}`))
-        return false;
-    const stack = [dir];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        let stats;
-        try {
-            stats = lstatSync(current);
-        }
-        catch {
-            return false;
-        }
-        if (stats.isSymbolicLink())
-            return false;
-        if (!stats.isDirectory())
+    const conversationSkills = loadSkillsFromDir({
+        dir: conversationSkillsDir,
+        source: "channel",
+        rejectSymlinks: true,
+    });
+    const skippedSkillLinks = [];
+    for (const diagnostic of conversationSkills.diagnostics) {
+        if (diagnostic.code !== "symlink")
             continue;
-        let entries;
-        try {
-            entries = readdirSync(current, { withFileTypes: true });
-        }
-        catch {
-            return false;
-        }
-        for (const entry of entries) {
-            if (entry.isSymbolicLink())
-                return false;
-            stack.push(join(current, entry.name));
-        }
+        log.logWarning("Skipping conversation skill entry (symlink)", diagnostic.path);
+        skippedSkillLinks.push(translatePath(diagnostic.path));
     }
-    return true;
+    for (const skill of conversationSkills.skills) {
+        skill.filePath = translatePath(skill.filePath);
+        skill.baseDir = translatePath(skill.baseDir);
+        skillMap.set(skill.name, skill);
+    }
+    return { skills: Array.from(skillMap.values()), skippedSkillLinks };
 }
-function buildRuntimePaths(runtimeWorkspaceRoot, address) {
+function buildRuntimePaths(runtimeWorkspaceRoot, office) {
     const workspaceRoot = runtimeWorkspaceRoot.replace(/\/+$/, "") || "/";
-    const conversationPath = posix.join(workspaceRoot, officeDirName(address));
+    const conversationPath = posix.join(workspaceRoot, office.key);
     return {
         workspaceRoot,
         conversationPath,
@@ -344,8 +311,8 @@ export function resolveTriggerAttribution(message) {
         return `@${message.userName}`;
     return undefined;
 }
-function buildSystemPrompt(workspacePath, address, conversationKind, currentUserId, memory, sandboxConfig, platform, skills, projection) {
-    const { workspaceRoot, conversationPath, scratchPath } = buildRuntimePaths(workspacePath, address);
+function buildSystemPrompt(workspacePath, office, conversationKind, currentUserId, memory, sandboxConfig, platform, skills, projection, skippedSkillLinks = []) {
+    const { workspaceRoot, conversationPath, scratchPath } = buildRuntimePaths(workspacePath, office);
     const sandboxType = sandboxConfig.type;
     const isContainerLike = sandboxType === "container" || sandboxType === "image";
     const isFirecracker = sandboxType === "firecracker";
@@ -403,7 +370,7 @@ Channels: ${channelMappings}
 
 Users: ${userMappings}
 
-When mentioning users, use <@username> format (e.g., <@mario>).
+When mentioning users, write <@userName> using the exact userName from the Users table above (e.g., <@mario>). Never invent handles from other platforms (GitHub, email); the platform adapter converts <@userName> to the platform's native mention form.
 
 ## Environment
 ${envDescription}
@@ -417,7 +384,7 @@ ${projection.layout === "conversation"
         : `${workspaceRoot}/
 ├── MEMORY.md                    # Global memory (all conversations)
 ├── skills/                      # Global CLI tools you create
-└── ${officeDirName(address)}/           # This conversation`}
+└── ${office.key}/           # This conversation`}
     ├── MEMORY.md                # Conversation-specific memory
     ├── log.jsonl                # Human-readable message history (no tool results)
     ├── sessions/                # Structured session history used for context reconstruction
@@ -450,7 +417,9 @@ Scripts are in: {baseDir}/
 \`name\` and \`description\` are required. Use \`{baseDir}\` as placeholder for the skill's directory path.
 
 ### Available Skills
-${skills.length > 0 ? formatSkillsForPrompt(skills) : "(no skills installed yet)"}
+${skills.length > 0 ? formatSkillsForPrompt(skills) : "(no skills installed yet)"}${skippedSkillLinks.length > 0
+        ? `\n\nNote: these skill entries were skipped because they are symlinks, which the host never follows when reading this conversation's skills: ${skippedSkillLinks.join(", ")}. Replace each with a real file or directory (for example \`cp -rL\`) to load it.`
+        : ""}
 
 ## Events
 Use the \`event\` tool to schedule immediate, one-shot, or periodic follow-ups. It writes to the host-side mikan control plane and fills routing fields for the current conversation automatically.
@@ -912,9 +881,9 @@ function buildThreadSessionName(message) {
     const userLabel = message?.userName || message?.user || "unknown";
     return `[${userLabel}]: ${text}`;
 }
-function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
+function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspace) {
     const executionResolver = vaultManager && sandboxConfig.type !== "host"
-        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath)
+        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspace)
         : undefined;
     // activeExecutor is replaced at the start of each run() call when executionResolver
     // is present, so the stable `executor` wrapper always delegates to the latest resolved value.
@@ -947,7 +916,7 @@ function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner,
     return {
         executionResolver,
         executor,
-        getPathContext: () => executor.getPathContext(hostWorkspacePath),
+        getPathContext: () => executor.getPathContext(workspace.root),
         async resolveExecutorForRun(context) {
             if (!executionResolver)
                 return;
@@ -962,10 +931,10 @@ function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner,
  * notify posts through the platform bots when main.ts provides a notifier.
  */
 function buildExtensionHostServices(params) {
-    const { workspaceDir, vaultManager, platformNotifier, platformReactor, platformUploader, platformBlockKit, runSubagentService, } = params;
-    const eventStore = HostEventStore.fromWorkspaceDir(workspaceDir);
+    const { workspace, vaultManager, platformNotifier, platformReactor, platformUploader, platformBlockKit, runSubagentService, } = params;
+    const eventStore = HostEventStore.fromWorkspaceDir(workspace.root);
     return {
-        stateDir: effectiveStateDir(),
+        stateDir: workspace.stateDir,
         scheduleStore: {
             write: async (filename, payload) => {
                 await eventStore.write(filename, payload);
@@ -988,7 +957,10 @@ function buildExtensionHostServices(params) {
     };
 }
 async function createConfiguredAgentSession(params) {
-    const { address, conversationId, conversationDir, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, platformUploader, platformBlockKit, } = params;
+    const { office, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, platformUploader, platformBlockKit, } = params;
+    const { address } = office;
+    const conversationId = address.conversationId;
+    const workspaceDir = office.workspace.root;
     // 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).
@@ -1004,11 +976,7 @@ async function createConfiguredAgentSession(params) {
     // contributed theirs. Both subagent entry points read this at call time, so
     // they always agree on which profiles are launchable.
     let runnableSubagentProfiles = loadedProfiles.profiles;
-    const resolvedPackages = resolveConversationPackages({
-        address,
-        stateDir: effectiveStateDir(),
-        conversationDir,
-    });
+    const resolvedPackages = resolveConversationPackages({ office });
     for (const error of resolvedPackages.errors) {
         log.logWarning(`Package unavailable: ${error.source}`, error.message);
     }
@@ -1017,7 +985,7 @@ async function createConfiguredAgentSession(params) {
         roots: resolvedPackages.extensionRoots,
         context: { address, conversationId, workspaceDir, model, thinkingLevel },
         services: buildExtensionHostServices({
-            workspaceDir,
+            workspace: office.workspace,
             vaultManager,
             platformNotifier,
             platformReactor,
@@ -1094,10 +1062,11 @@ function reloadSessionMessages(session, conversationId) {
     }
 }
 async function prepareRunContext(params) {
-    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, setReactFunction, bindPlatformToolPacks, } = params;
+    const { message, responder, platform, office, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, setImageUploadFunction, setReactFunction, bindPlatformToolPacks, } = params;
+    const conversationId = office.address.conversationId;
     let pathContext = params.pathContext;
     const sessionConversation = conversationIdOf(message.sessionKey);
-    await mkdir(join(conversationDir, "scratch"), { recursive: true });
+    await mkdir(join(office.dir, "scratch"), { recursive: true });
     if (executionResolver) {
         await resolveExecutorForRun({
             address: message.address,
@@ -1107,11 +1076,12 @@ async function prepareRunContext(params) {
         pathContext = getPathContext();
     }
     reloadSessionMessages(session, conversationId);
-    const projection = resolveWorkspaceProjection(join(conversationDir, ".."), message.address);
+    const projection = resolveWorkspaceProjection(office);
     const memory = await getMemory(projection);
-    const skills = mergeExtensionSkills(loadMikanSkills(message.address, conversationDir, pathContext.runtimeWorkspaceRoot, projection), params.extensionSkills ?? []);
+    const conversationSkillLoad = loadMikanSkills(office, pathContext.runtimeWorkspaceRoot, projection);
+    const skills = mergeExtensionSkills(conversationSkillLoad.skills, params.extensionSkills ?? []);
     const triggerAttribution = resolveTriggerAttribution(message);
-    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, message.address, message.conversationKind, message.userId, memory, executor.getSandboxConfig(), platform, skills, projection);
+    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, office, message.conversationKind, message.userId, memory, executor.getSandboxConfig(), platform, skills, projection, conversationSkillLoad.skippedSkillLinks);
     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
@@ -1133,6 +1103,11 @@ async function prepareRunContext(params) {
         const runtimePath = normalizeAttachRuntimePath(filePath, pathContext.runtimeWorkspaceRoot);
         await withStagedRuntimeFile(executor, runtimePath, (stagedPath) => responder.uploadFile(stagedPath, title));
     });
+    // generate_image writes its file host-side, so it uploads by host path —
+    // no staging through the sandbox, where the file may not be mounted.
+    setImageUploadFunction(async (hostPath, title) => {
+        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.
@@ -1526,26 +1501,32 @@ function attachSessionEventHandlers(params) {
  * This is a stateless factory function.
  */
 export async function createRunner(options) {
-    const { sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, resourceController, sessionView, platformNotifier, platformReactor, platformUploader, platformBlockKit, platformToolPackFactories, } = options;
-    const agentConfig = resolveConversationSettings({ address: options.address, conversationDir });
-    const workspaceBase = join(conversationDir, "..");
-    const projection = resolveWorkspaceProjection(workspaceBase, options.address);
+    const { sandboxConfig, sessionKey, office, sessionScope, vaultManager, provisioner, resourceController, sessionView, platformNotifier, platformReactor, platformUploader, platformBlockKit, platformToolPackFactories, } = options;
+    const conversationId = office.address.conversationId;
+    const conversationDir = office.dir;
+    const workspaceDir = office.workspace.root;
+    const agentConfig = resolveConversationSettings(office);
+    const projection = resolveWorkspaceProjection(office);
     assertSandboxSupportsWorkspacePolicy(sandboxConfig, projection.doorPolicy);
-    const { executionResolver, executor, getPathContext, resolveExecutorForRun } = createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, workspaceBase);
-    let pathContext = getUnresolvedSandboxPathContext(sandboxConfig, workspaceBase);
+    const { executionResolver, executor, getPathContext, resolveExecutorForRun } = createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, office.workspace);
+    let pathContext = getUnresolvedSandboxPathContext(sandboxConfig, workspaceDir);
     const modelRegistry = options.models ?? MikanModels.create();
     if (modelRegistry.getError()) {
         log.logWarning("models.json load error", modelRegistry.getError());
     }
     const model = modelRegistry.resolve(agentConfig.provider, agentConfig.model);
     // Create tools (per-runner, with per-runner upload function setter)
-    const { tools, setUploadFunction, setReactFunction, bindPlatformToolPacks, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, resourceController: resourceController ?? provisioner }, platformToolPackFactories ?? [], {
+    const { tools, setUploadFunction, setImageUploadFunction, setReactFunction, bindPlatformToolPacks, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, resourceController: resourceController ?? provisioner }, platformToolPackFactories ?? [], {
         model,
         getApiKey: () => modelRegistry.getApiKeyForProvider(model.provider),
+        // The conversation's own office dir: mounted into the sandbox, unlike
+        // the workspace base — generated images must land somewhere the agent
+        // (and a future run) can still reach.
+        outputDir: conversationDir,
     });
     // Initial system prompt (will be updated each run with fresh memory/channels/users/skills)
     const memory = await getMemory(projection);
-    const skills = loadMikanSkills(options.address, conversationDir, pathContext.runtimeWorkspaceRoot, projection);
+    const { skills, skippedSkillLinks } = loadMikanSkills(office, pathContext.runtimeWorkspaceRoot, projection);
     const emptyPlatform = {
         name: "chat",
         formattingGuide: "",
@@ -1553,7 +1534,7 @@ export async function createRunner(options) {
         users: [],
         trustModel: "membership",
     };
-    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, options.address, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills, projection);
+    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, office, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills, projection, skippedSkillLinks);
     // 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.
@@ -1567,10 +1548,7 @@ export async function createRunner(options) {
     const sessionUuid = extractSessionUuid(contextFile);
     const chatSessionManager = new ChatHistorySync();
     const { session, extensionSkills, extensionRegistry, disposeExtensions } = await createConfiguredAgentSession({
-        address: options.address,
-        conversationId,
-        conversationDir,
-        workspaceDir,
+        office,
         systemPrompt,
         model,
         thinkingLevel: agentConfig.thinkingLevel,
@@ -1600,8 +1578,7 @@ export async function createRunner(options) {
                 message,
                 responder,
                 platform,
-                conversationId,
-                conversationDir,
+                office,
                 sessionUuid,
                 runState,
                 executor,
@@ -1613,6 +1590,7 @@ export async function createRunner(options) {
                 setEventContext,
                 setSandboxContext,
                 setUploadFunction,
+                setImageUploadFunction,
                 setReactFunction,
                 bindPlatformToolPacks,
                 pathContext,
@@ -1724,8 +1702,7 @@ export async function createRunner(options) {
                 message,
                 responder,
                 platform,
-                conversationId,
-                conversationDir,
+                office,
                 sessionUuid,
                 runState,
                 executor,
@@ -1737,13 +1714,14 @@ export async function createRunner(options) {
                 setEventContext,
                 setSandboxContext,
                 setUploadFunction,
+                setImageUploadFunction,
                 setReactFunction,
                 bindPlatformToolPacks,
                 pathContext,
             });
             pathContext = prepared.pathContext;
             try {
-                const conversationMemoryPath = posix.join(prepared.pathContext.runtimeWorkspaceRoot, officeDirName(message.address), "MEMORY.md");
+                const conversationMemoryPath = posix.join(prepared.pathContext.runtimeWorkspaceRoot, office.key, "MEMORY.md");
                 const dreamTools = sessionDreamTools(session.agent.state.tools, conversationMemoryPath);
                 const outcome = await session.prompt(sessionDreamPrompt(conversationMemoryPath, dreamTools.map((tool) => tool.name)), {
                     origin: {