@geminixiang/mama 0.2.0-beta.0 → 0.2.0-beta.2

package/dist/agent.js

@@ -1,16 +1,17 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { getModel } from "@mariozechner/pi-ai";
-import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, formatSkillsForPrompt, loadSkillsFromDir, ModelRegistry, } from "@mariozechner/pi-coding-agent";
+import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, formatSkillsForPrompt, getAgentDir, loadSkillsFromDir, ModelRegistry, } from "@mariozechner/pi-coding-agent";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
 import { loadAgentConfig } from "./config.js";
 import { createMamaSettingsManager, syncLogToSessionManager } from "./context.js";
+import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
 import { createExecutor } from "./sandbox.js";
 import { addLifecycleBreadcrumb, metricAttributes } from "./sentry.js";
-import { createManagedSessionFileAtPath, extractSessionSuffix, extractSessionUuid, forkThreadSessionFile, getSessionDir, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, resolveManagedSessionFile, tryResolveThreadSession, } from "./session-store.js";
+import { createManagedSessionFileAtPath, extractSessionSuffix, extractSessionUuid, forkThreadSessionFile, getChannelSessionDir, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, resolveManagedSessionFile, tryResolveThreadSession, } from "./session-store.js";
 import { createMamaTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
 const IMAGE_MIME_TYPES = {
@@ -23,10 +24,10 @@ const IMAGE_MIME_TYPES = {
 function getImageMimeType(filename) {
     return IMAGE_MIME_TYPES[filename.toLowerCase().split(".").pop() || ""];
 }
-async function getMemory(channelDir) {
+async function getMemory(conversationDir) {
     const parts = [];
-    // Read workspace-level memory (shared across all channels)
-    const workspaceMemoryPath = join(channelDir, "..", "MEMORY.md");
+    // Read workspace-level memory (shared across all conversations)
+    const workspaceMemoryPath = join(conversationDir, "..", "MEMORY.md");
     if (existsSync(workspaceMemoryPath)) {
         try {
             const content = (await readFile(workspaceMemoryPath, "utf-8")).trim();
@@ -38,17 +39,17 @@ async function getMemory(channelDir) {
             log.logWarning("Failed to read workspace memory", `${workspaceMemoryPath}: ${error}`);
         }
     }
-    // Read channel-specific memory
-    const channelMemoryPath = join(channelDir, "MEMORY.md");
-    if (existsSync(channelMemoryPath)) {
+    // Read conversation-specific memory
+    const conversationMemoryPath = join(conversationDir, "MEMORY.md");
+    if (existsSync(conversationMemoryPath)) {
         try {
-            const content = (await readFile(channelMemoryPath, "utf-8")).trim();
+            const content = (await readFile(conversationMemoryPath, "utf-8")).trim();
             if (content) {
-                parts.push(`### Channel-Specific Memory\n${content}`);
+                parts.push(`### Conversation-Specific Memory\n${content}`);
             }
         }
         catch (error) {
-            log.logWarning("Failed to read channel memory", `${channelMemoryPath}: ${error}`);
+            log.logWarning("Failed to read conversation memory", `${conversationMemoryPath}: ${error}`);
         }
     }
     if (parts.length === 0) {
@@ -56,12 +57,12 @@ async function getMemory(channelDir) {
     }
     return parts.join("\n\n");
 }
-function loadMamaSkills(channelDir, workspacePath) {
+function loadMamaSkills(conversationDir, workspacePath) {
     const skillMap = new Map();
-    // channelDir is the host path (e.g., /Users/.../data/C0A34FL8PMH)
+    // 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(channelDir, "..");
+    const hostWorkspacePath = join(conversationDir, "..");
     // Helper to translate host paths to container paths
     const translatePath = (hostPath) => {
         if (hostPath.startsWith(hostWorkspacePath)) {
@@ -77,18 +78,19 @@ function loadMamaSkills(channelDir, workspacePath) {
         skill.baseDir = translatePath(skill.baseDir);
         skillMap.set(skill.name, skill);
     }
-    // Load channel-specific skills (override workspace skills on collision)
-    const channelSkillsDir = join(channelDir, "skills");
-    for (const skill of loadSkillsFromDir({ dir: channelSkillsDir, source: "channel" }).skills) {
+    // Load conversation-specific skills (override workspace skills on collision)
+    const conversationSkillsDir = join(conversationDir, "skills");
+    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);
     }
     return Array.from(skillMap.values());
 }
-function buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, platform, skills) {
-    const channelPath = `${workspacePath}/${channelId}`;
-    const isDocker = sandboxConfig.type === "docker";
+function buildSystemPrompt(workspacePath, conversationId, conversationKind, currentUserId, memory, sandboxConfig, platform, skills) {
+    const conversationPath = `${workspacePath}/${conversationId}`;
+    const isContainer = sandboxConfig.type === "container" || sandboxConfig.type === "image";
+    const isImageSandbox = sandboxConfig.type === "image";
     const isFirecracker = sandboxConfig.type === "firecracker";
     // Format channel mappings
     const channelMappings = platform.channels.length > 0
@@ -98,17 +100,22 @@ function buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, plat
     const userMappings = platform.users.length > 0
         ? platform.users.map((u) => `${u.id}\t@${u.userName}\t${u.displayName}`).join("\n")
         : "(no users loaded)";
-    const envDescription = isDocker
-        ? `You are running inside a Docker container (Alpine Linux).
+    const envDescription = isImageSandbox
+        ? `You are running inside a managed per-user container.
 - Bash working directory: / (use cd or absolute paths)
-- Install tools with: apk add <package>
+- Install tools with the image's package manager
+- Your changes persist for this user's container until it is recreated`
+        : isContainer
+            ? `You are running inside a shared container.
+- Bash working directory: / (use cd or absolute paths)
+- Install tools with the container's package manager
 - Your changes persist across sessions`
-        : isFirecracker
-            ? `You are running inside a Firecracker microVM.
+            : isFirecracker
+                ? `You are running inside a Firecracker microVM.
 - Bash working directory: / (use cd or absolute paths)
 - Install tools with: apt-get install <package> (Debian-based)
 - Your changes persist across sessions`
-            : `You are running directly on the host machine.
+                : `You are running directly on the host machine.
 - Bash working directory: ${process.cwd()}
 - Be careful with system modifications`;
     return `You are mama, a ${platform.name} bot assistant. Be concise. No emojis.
@@ -133,20 +140,20 @@ ${envDescription}
 
 ## Workspace Layout
 ${workspacePath}/
-├── MEMORY.md                    # Global memory (all channels)
+├── MEMORY.md                    # Global memory (all conversations)
 ├── skills/                      # Global CLI tools you create
-└── ${channelId}/                # This channel
-    ├── MEMORY.md                # Channel-specific memory
+└── ${conversationId}/           # This conversation
+    ├── MEMORY.md                # Conversation-specific memory
     ├── log.jsonl                # Message history (no tool results)
     ├── attachments/             # User-shared files
     ├── scratch/                 # Your working directory
-    └── skills/                  # Channel-specific tools
+    └── skills/                  # Conversation-specific tools
 
 ## Skills (Custom CLI Tools)
 You can create reusable CLI tools for recurring tasks (email, APIs, data processing, etc.).
 
 ### Creating Skills
-Store in \`${workspacePath}/skills/<name>/\` (global) or \`${channelPath}/skills/<name>/\` (channel-specific).
+Store in \`${workspacePath}/skills/<name>/\` (global) or \`${conversationPath}/skills/<name>/\` (conversation-specific).
 Each skill directory needs a \`SKILL.md\` with YAML frontmatter:
 
 \`\`\`markdown
@@ -173,17 +180,17 @@ You can schedule events that wake you up at specific times or when external thin
 
 **Immediate** - Triggers as soon as harness sees the file. Use in scripts/webhooks to signal external events.
 \`\`\`json
-{"type": "immediate", "platform": "${platform.name}", "channelId": "${channelId}", "text": "New GitHub issue opened"}
+{"type": "immediate", "platform": "${platform.name}", "conversationId": "${conversationId}", "conversationKind": "${conversationKind}", "userId": "${currentUserId ?? "<requester userId>"}", "text": "New GitHub issue opened"}
 \`\`\`
 
 **One-shot** - Triggers once at a specific time. Use for reminders.
 \`\`\`json
-{"type": "one-shot", "platform": "${platform.name}", "channelId": "${channelId}", "text": "Remind Mario about dentist", "at": "2025-12-15T09:00:00+01:00"}
+{"type": "one-shot", "platform": "${platform.name}", "conversationId": "${conversationId}", "conversationKind": "${conversationKind}", "userId": "${currentUserId ?? "<requester userId>"}", "text": "Remind Mario about dentist", "at": "2025-12-15T09:00:00+01:00"}
 \`\`\`
 
 **Periodic** - Triggers on a cron schedule. Use for recurring tasks.
 \`\`\`json
-{"type": "periodic", "platform": "${platform.name}", "channelId": "${channelId}", "text": "Check inbox and summarize", "schedule": "0 9 * * 1-5", "timezone": "${Intl.DateTimeFormat().resolvedOptions().timeZone}"}
+{"type": "periodic", "platform": "${platform.name}", "conversationId": "${conversationId}", "conversationKind": "${conversationKind}", "userId": "${currentUserId ?? "<requester userId>"}", "text": "Check inbox and summarize", "schedule": "0 9 * * 1-5", "timezone": "${Intl.DateTimeFormat().resolvedOptions().timeZone}"}
 \`\`\`
 
 ### Cron Format
@@ -196,14 +203,18 @@ You can schedule events that wake you up at specific times or when external thin
 ### Timezones
 All \`at\` timestamps must include offset (e.g., \`+01:00\`). Periodic events use IANA timezone names. The harness runs in ${Intl.DateTimeFormat().resolvedOptions().timeZone}. When users mention times without timezone, assume ${Intl.DateTimeFormat().resolvedOptions().timeZone}.
 
-### Platform Routing
+### Platform and Credential Routing
 Set \`platform\` to the target bot platform (\`${platform.name}\` for this conversation). When only one platform is running, omitting \`platform\` is allowed for backward compatibility, but include it by default to avoid ambiguity.
 
+Set \`userId\` to the platform userId of whoever asked for the event. When the event fires, tool execution routes using that user's vault selection in per-user modes. In \`container:<name>\`, events use the container's single shared vault.
+
+Prefer the \`event\` tool over manually writing JSON files; it fills \`platform\`, \`conversationId\`, \`conversationKind\`, and \`userId\` for the current conversation automatically.
+
 ### Creating Events
 Use unique filenames to avoid overwriting existing events. Include a timestamp or random suffix:
 \`\`\`bash
 cat > ${workspacePath}/events/dentist-reminder-$(date +%s).json << 'EOF'
-{"type": "one-shot", "platform": "${platform.name}", "channelId": "${channelId}", "text": "Dentist tomorrow", "at": "2025-12-14T09:00:00+01:00"}
+{"type": "one-shot", "platform": "${platform.name}", "conversationId": "${conversationId}", "conversationKind": "${conversationKind}", "userId": "${currentUserId ?? "<requester userId>"}", "text": "Dentist tomorrow", "at": "2025-12-14T09:00:00+01:00"}
 EOF
 \`\`\`
 Or check if file exists first before creating.
@@ -232,7 +243,7 @@ Maximum 5 events can be queued. Don't create excessive immediate or periodic eve
 ## Memory
 Write to MEMORY.md files to persist context across conversations.
 - Global (${workspacePath}/MEMORY.md): skills, preferences, project info
-- Channel (${channelPath}/MEMORY.md): channel-specific decisions, ongoing work
+- Conversation (${conversationPath}/MEMORY.md): conversation-specific decisions, ongoing work
 Update when you learn something important or when asked to remember something.
 
 ### Current Memory
@@ -250,7 +261,7 @@ Update this file whenever you modify the environment. On fresh container, read i
 ## Log Queries (for older history)
 Format: \`{"date":"...","ts":"...","user":"...","userName":"...","text":"...","isBot":false}\`
 The log contains user messages and your final responses (not tool calls/results).
-${isDocker ? "Install jq: apk add jq" : ""}
+${isContainer ? "Install jq: apk add jq" : ""}
 ${isFirecracker ? "Install jq: apt-get install jq" : ""}
 
 \`\`\`bash
@@ -337,77 +348,100 @@ function formatToolArgsForSlack(_toolName, args) {
  * Runner caching is handled by the caller (channelStates in main.ts).
  * This is a stateless factory function.
  */
-export async function createRunner(sandboxConfig, sessionKey, channelId, channelDir, workspaceDir) {
+export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, vaultManager, bindingStore, provisioner) {
     const agentConfig = loadAgentConfig(workspaceDir);
     // Initialize logger with settings from config
     log.initLogger({
         logFormat: agentConfig.logFormat,
         logLevel: agentConfig.logLevel,
     });
-    const executor = createExecutor(sandboxConfig);
-    const workspacePath = executor.getWorkspacePath(channelDir.replace(`/${channelId}`, ""));
+    const executionResolver = vaultManager &&
+        sandboxConfig.type !== "host" &&
+        (vaultManager.isEnabled() ||
+            !!bindingStore ||
+            sandboxConfig.type === "container" ||
+            sandboxConfig.type === "image")
+        ? new ActorExecutionResolver(sandboxConfig, vaultManager, bindingStore, provisioner)
+        : undefined;
+    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();
+        },
+    };
+    const workspaceBase = conversationDir.replace(`/${conversationId}`, "");
+    const getWorkspacePath = () => executor.getWorkspacePath(workspaceBase);
+    let workspacePath = getWorkspacePath();
     // Create tools (per-runner, with per-runner upload function setter)
-    const { tools, setUploadFunction } = createMamaTools(executor);
+    const { tools, setUploadFunction, setEventContext } = createMamaTools(executor, workspaceDir);
     // Resolve model from config
     // Use 'as any' cast because agentConfig.provider/model are plain strings,
     // while getModel() has constrained generic types for known providers.
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const model = getModel(agentConfig.provider, agentConfig.model);
     // Initial system prompt (will be updated each run with fresh memory/channels/users/skills)
-    const memory = await getMemory(channelDir);
-    const skills = loadMamaSkills(channelDir, workspacePath);
+    const memory = await getMemory(conversationDir);
+    const skills = loadMamaSkills(conversationDir, workspacePath);
     const emptyPlatform = {
         name: "slack",
         formattingGuide: "",
         channels: [],
         users: [],
     };
-    const systemPrompt = buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, emptyPlatform, skills);
+    const systemPrompt = buildSystemPrompt(workspacePath, conversationId, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills);
     // Create session manager and settings manager
-    // Channel sessions use {channelDir}/sessions/current.
-    // Thread sessions use fixed files: {channelDir}/sessions/{threadTs}.jsonl
-    const sessionDir = getSessionDir(channelDir, sessionKey);
+    // Conversation sessions use {conversationDir}/sessions/current.
+    // Thread sessions use fixed files: {conversationDir}/sessions/{threadTs}.jsonl
+    const sessionDir = getChannelSessionDir(conversationDir);
     const isThread = sessionKey.includes(":");
     let sessionManager;
     let contextFile;
     if (isThread) {
-        const threadFile = getThreadSessionFile(channelDir, sessionKey);
+        const threadFile = getThreadSessionFile(conversationDir, sessionKey);
         const existing = tryResolveThreadSession(threadFile);
         if (existing) {
             contextFile = existing;
-            sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+            sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
         }
         else {
-            const channelSource = resolveChannelSessionFile(channelDir);
-            if (channelSource) {
+            const conversationSource = resolveChannelSessionFile(conversationDir);
+            if (conversationSource) {
                 try {
-                    contextFile = forkThreadSessionFile(channelSource, threadFile, channelDir);
-                    sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+                    contextFile = forkThreadSessionFile(conversationSource, threadFile, conversationDir);
+                    sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
                 }
                 catch {
-                    contextFile = createManagedSessionFileAtPath(threadFile, channelDir);
-                    sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+                    contextFile = createManagedSessionFileAtPath(threadFile, conversationDir);
+                    sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
                 }
             }
             else {
-                contextFile = createManagedSessionFileAtPath(threadFile, channelDir);
-                sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+                contextFile = createManagedSessionFileAtPath(threadFile, conversationDir);
+                sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
             }
         }
     }
     else {
-        // Channel/DM session: normal resolve
-        contextFile = resolveManagedSessionFile(sessionDir, channelDir);
-        sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+        // Direct/shared session: normal resolve
+        contextFile = resolveManagedSessionFile(sessionDir, conversationDir);
+        sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
     }
     const sessionUuid = extractSessionUuid(contextFile);
     // Used for Slack thread filtering — for non-Slack platforms this is effectively a no-op
     const rootTs = extractSessionSuffix(sessionKey);
-    const settingsManager = createMamaSettingsManager(join(channelDir, ".."));
+    const settingsManager = createMamaSettingsManager(join(conversationDir, ".."));
     // Create AuthStorage and ModelRegistry
     // Auth stored outside workspace so agent can't access it
     const authStorage = AuthStorage.create(join(homedir(), ".pi", "mama", "auth.json"));
-    const modelRegistry = new ModelRegistry(authStorage);
+    const modelRegistry = ModelRegistry.create(authStorage);
     // Create agent
     const agent = new Agent({
         initialState: {
@@ -427,14 +461,15 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
     // Load existing messages
     const loadedSession = sessionManager.buildSessionContext();
     if (loadedSession.messages.length > 0) {
-        agent.replaceMessages(loadedSession.messages);
-        log.logInfo(`[${channelId}] Loaded ${loadedSession.messages.length} messages from context.jsonl`);
+        agent.state.messages = loadedSession.messages;
+        log.logInfo(`[${conversationId}] Loaded ${loadedSession.messages.length} messages from context.jsonl`);
     }
     // Load extensions, skills, prompts, themes via DefaultResourceLoader
     // This reads ~/.pi/agent/settings.json (packages, extensions enable/disable)
     // and discovers resources from standard locations + npm/git packages.
     const resourceLoader = new DefaultResourceLoader({
         cwd: workspaceDir,
+        agentDir: getAgentDir(),
         systemPrompt,
     });
     try {
@@ -442,13 +477,13 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         const extResult = resourceLoader.getExtensions();
         if (extResult.errors.length > 0) {
             for (const err of extResult.errors) {
-                log.logWarning(`[${channelId}] Extension load error: ${err.path}`, err.error);
+                log.logWarning(`[${conversationId}] Extension load error: ${err.path}`, err.error);
             }
         }
-        log.logInfo(`[${channelId}] Loaded ${extResult.extensions.length} extension(s): ${extResult.extensions.map((e) => e.path).join(", ")}`);
+        log.logInfo(`[${conversationId}] Loaded ${extResult.extensions.length} extension(s): ${extResult.extensions.map((e) => e.path).join(", ")}`);
     }
     catch (error) {
-        log.logWarning(`[${channelId}] Failed to load resources`, String(error));
+        log.logWarning(`[${conversationId}] Failed to load resources`, String(error));
     }
     const baseToolsOverride = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
     // Create AgentSession wrapper
@@ -484,7 +519,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         if (!runState.responseCtx || !runState.logCtx || !runState.queue)
             return;
         const { responseCtx, logCtx, queue, pendingTools } = runState;
-        const baseAttrs = { channel_id: logCtx.channelId, session_id: logCtx.sessionId };
+        const baseAttrs = { channel_id: logCtx.conversationId, session_id: logCtx.sessionId };
         if (event.type === "tool_execution_start") {
             const agentEvent = event;
             const args = agentEvent.args;
@@ -694,10 +729,18 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
     };
     return {
         async run(message, responseCtx, platform) {
-            // Extract channelId from sessionKey (format: "channelId:rootTs" or just "channelId")
-            const sessionChannel = message.sessionKey.split(":")[0];
-            // Ensure channel directory exists
-            await mkdir(channelDir, { recursive: true });
+            // Extract conversationId from sessionKey (format: "conversationId:rootTs" or just "conversationId")
+            const sessionConversation = message.sessionKey.split(":")[0];
+            // Ensure conversation directory exists
+            await mkdir(conversationDir, { recursive: true });
+            if (executionResolver) {
+                executionResolver.refresh();
+                activeExecutor = await executionResolver.resolve({
+                    platform: platform.name,
+                    userId: message.userId,
+                });
+                workspacePath = getWorkspacePath();
+            }
             // Sync messages from log.jsonl that arrived while we were offline or busy
             // Exclude the current message (it will be added via prompt())
             // Default sync range is 10 days (handled by syncLogToSessionManager)
@@ -705,33 +748,39 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             const threadFilter = message.sessionKey.includes(":")
                 ? { scope: "thread", rootTs, threadTs: message.threadTs }
                 : { scope: "top-level", rootTs };
-            const syncedCount = await syncLogToSessionManager(sessionManager, channelDir, message.id, undefined, threadFilter);
+            const syncedCount = await syncLogToSessionManager(sessionManager, conversationDir, message.id, undefined, threadFilter);
             if (syncedCount > 0) {
-                log.logInfo(`[${channelId}] Synced ${syncedCount} messages from log.jsonl`);
+                log.logInfo(`[${conversationId}] Synced ${syncedCount} messages from log.jsonl`);
             }
             // Reload messages from context.jsonl
             // This picks up any messages synced above
             const reloadedSession = sessionManager.buildSessionContext();
             if (reloadedSession.messages.length > 0) {
-                agent.replaceMessages(reloadedSession.messages);
-                log.logInfo(`[${channelId}] Reloaded ${reloadedSession.messages.length} messages from context`);
+                agent.state.messages = reloadedSession.messages;
+                log.logInfo(`[${conversationId}] Reloaded ${reloadedSession.messages.length} messages from context`);
             }
             // Update system prompt with fresh memory, channel/user info, and skills
-            const memory = await getMemory(channelDir);
-            const skills = loadMamaSkills(channelDir, workspacePath);
-            const systemPrompt = buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, platform, skills);
-            session.agent.setSystemPrompt(systemPrompt);
+            const memory = await getMemory(conversationDir);
+            const skills = loadMamaSkills(conversationDir, workspacePath);
+            const systemPrompt = buildSystemPrompt(workspacePath, conversationId, message.conversationKind, message.userId, memory, executor.getSandboxConfig(), platform, skills);
+            session.agent.state.systemPrompt = systemPrompt;
+            setEventContext({
+                platform: platform.name,
+                conversationId,
+                conversationKind: message.conversationKind,
+                userId: message.userId,
+            });
             // Set up file upload function
             setUploadFunction(async (filePath, title) => {
-                const hostPath = translateToHostPath(filePath, channelDir, workspacePath, channelId);
+                const hostPath = translateToHostPath(filePath, conversationDir, workspacePath, conversationId);
                 await responseCtx.uploadFile(hostPath, title);
             });
             // Reset per-run state
             runState.responseCtx = responseCtx;
             runState.logCtx = {
-                channelId: sessionChannel,
+                conversationId: sessionConversation,
                 userName: message.userName,
-                channelName: undefined,
+                conversationName: undefined,
                 sessionId: sessionUuid,
             };
             runState.pendingTools.clear();
@@ -793,7 +842,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             const imageAttachments = [];
             const nonImagePaths = [];
             for (const a of message.attachments || []) {
-                // a.localPath is the path relative to the workspace (same as old a.local)
+                // a.localPath is the path relative to the workspace.
                 const fullPath = `${workspacePath}/${a.localPath}`;
                 const mimeType = getImageMimeType(a.localPath);
                 if (mimeType && existsSync(fullPath)) {
@@ -822,11 +871,11 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 newUserMessage: userMessage,
                 imageAttachmentCount: imageAttachments.length,
             };
-            await writeFile(join(channelDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
+            await writeFile(join(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
             addLifecycleBreadcrumb("agent.prompt.sent", {
                 provider: model.provider,
                 model: agentConfig.model,
-                channel_id: sessionChannel,
+                channel_id: sessionConversation,
                 session_id: sessionUuid,
                 attachment_count: message.attachments?.length ?? 0,
                 image_attachment_count: imageAttachments.length,
@@ -901,7 +950,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 const runMetricAttributes = metricAttributes({
                     provider: model.provider,
                     model: agentConfig.model,
-                    channel_id: sessionChannel,
+                    channel_id: sessionConversation,
                     session_id: sessionUuid,
                     stop_reason: runState.stopReason,
                     llm_calls: runState.llmCallCount,
@@ -960,14 +1009,14 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
 /**
  * Translate container path back to host path for file operations
  */
-function translateToHostPath(containerPath, channelDir, workspacePath, channelId) {
+function translateToHostPath(containerPath, conversationDir, workspacePath, conversationId) {
     if (workspacePath === "/workspace") {
-        const prefix = `/workspace/${channelId}/`;
+        const prefix = `/workspace/${conversationId}/`;
         if (containerPath.startsWith(prefix)) {
-            return join(channelDir, containerPath.slice(prefix.length));
+            return join(conversationDir, containerPath.slice(prefix.length));
         }
         if (containerPath.startsWith("/workspace/")) {
-            return join(channelDir, "..", containerPath.slice("/workspace/".length));
+            return join(conversationDir, "..", containerPath.slice("/workspace/".length));
         }
     }
     return containerPath;