@geminixiang/mama 0.1.10 → 0.2.0-beta.1

package/dist/agent.js

@@ -1,15 +1,19 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { getModel } from "@mariozechner/pi-ai";
-import { AgentSession, AuthStorage, convertToLlm, createExtensionRuntime, formatSkillsForPrompt, loadSkillsFromDir, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
-import { existsSync, mkdirSync, readFileSync } from "fs";
+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, 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 = {
     jpg: "image/jpeg",
     jpeg: "image/jpeg",
@@ -20,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();
@@ -35,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) {
@@ -53,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)) {
@@ -74,20 +78,20 @@ 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, currentUserId, memory, sandboxConfig, platform, skills) {
+    const conversationPath = `${workspacePath}/${conversationId}`;
+    const isContainer = sandboxConfig.type === "container" || sandboxConfig.type === "image";
     const isFirecracker = sandboxConfig.type === "firecracker";
-    // Format channel mappings
+    // Format platform conversation mappings
     const channelMappings = platform.channels.length > 0
         ? platform.channels.map((c) => `${c.id}\t#${c.name}`).join("\n")
         : "(no channels loaded)";
@@ -95,8 +99,8 @@ 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 = isContainer
+        ? `You are running inside a container (Docker runtime, Alpine Linux).
 - Bash working directory: / (use cd or absolute paths)
 - Install tools with: apk add <package>
 - Your changes persist across sessions`
@@ -132,18 +136,18 @@ ${envDescription}
 ${workspacePath}/
 ├── MEMORY.md                    # Global memory (all channels)
 ├── 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
@@ -170,19 +174,21 @@ 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}", "channelId": "${conversationId}", "userId": "<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}", "channelId": "${conversationId}", "userId": "<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}", "channelId": "${conversationId}", "userId": "<requester userId>", "text": "Check inbox and summarize", "schedule": "0 9 * * 1-5", "timezone": "${Intl.DateTimeFormat().resolvedOptions().timeZone}"}
 \`\`\`
 
+Set \`userId\` to the platform userId of whoever asked for the event (look it up in the user mappings above). When the event fires, tool execution will route to the sandbox vault selection for that user so the right credentials are available. In shared container mode, all events use the container's single shared vault.
+
 ### Cron Format
 \`minute hour day-of-month month day-of-week\`
 - \`0 9 * * *\` = daily at 9:00
@@ -197,10 +203,19 @@ All \`at\` timestamps must include offset (e.g., \`+01:00\`). Periodic events us
 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.
 
 ### Creating Events
+Prefer the \`event\` tool. It automatically writes to the correct events directory and fills the current \`platform\`, \`channelId\`, and requester \`userId\`.
+Do not use \`bash\` or \`write\` to hand-create JSON files in \`/events\` unless the user explicitly asks for manual file editing.
+
+Current conversation defaults:
+- \`platform\`: \`${platform.name}\`
+- \`channelId\`: \`${conversationId}\`
+- \`userId\`: \`${currentUserId ?? "unknown"}\`
+
+Manual file creation is fallback only:
 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}", "channelId": "${conversationId}", "userId": "<requester userId>", "text": "Dentist tomorrow", "at": "2025-12-14T09:00:00+01:00"}
 EOF
 \`\`\`
 Or check if file exists first before creating.
@@ -229,7 +244,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
@@ -247,7 +262,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
@@ -328,50 +343,106 @@ function formatToolArgsForSlack(_toolName, args) {
 // Agent runner
 // ============================================================================
 /**
- * Create a new AgentRunner for a channel.
+ * Create a new AgentRunner for a conversation.
  * Sets up the session and subscribes to events once.
  *
- * Runner caching is handled by the caller (channelStates in main.ts).
+ * Runner caching is handled by the caller (conversationStates in main.ts).
  * This is a stateless factory function.
  */
-export async function createRunner(sandboxConfig, sessionKey, channelId, channelDir, workspaceDir) {
-    const agentConfig = loadAgentConfig(workspaceDir);
+export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, vaultManager, bindingStore, provisioner, stateDir) {
+    const agentConfig = loadAgentConfig(stateDir ?? 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 &&
+        (vaultManager.isEnabled() ||
+            !!bindingStore ||
+            sandboxConfig.type === "image" ||
+            sandboxConfig.type === "container")
+        ? 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}`, "");
+    // Compute workspace path from the current executor. This may change per run.
+    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);
-    // Create session manager and settings manager
-    // Per-session context file: {channelDir}/sessions/{rootTs}/context.jsonl
-    const rootTs = sessionKey.includes(":") ? sessionKey.split(":").pop() : sessionKey;
-    const sessionDir = join(channelDir, "sessions", rootTs);
-    mkdirSync(sessionDir, { recursive: true });
-    const contextFile = join(sessionDir, "context.jsonl");
-    const sessionManager = SessionManager.open(contextFile, channelDir);
-    const settingsManager = createMamaSettingsManager(join(channelDir, ".."));
+    const systemPrompt = buildSystemPrompt(workspacePath, conversationId, undefined, memory, sandboxConfig, emptyPlatform, skills);
+    // Create session manager and settings manager.
+    // Top-level 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 sessionFile;
+    if (isThread) {
+        const threadFile = getThreadSessionFile(conversationDir, sessionKey);
+        const existing = tryResolveThreadSession(threadFile);
+        if (existing) {
+            sessionFile = existing;
+            sessionManager = openManagedSession(sessionFile, sessionDir, conversationDir);
+        }
+        else {
+            const conversationSource = resolveChannelSessionFile(conversationDir);
+            if (conversationSource) {
+                try {
+                    sessionFile = forkThreadSessionFile(conversationSource, threadFile, conversationDir);
+                    sessionManager = openManagedSession(sessionFile, sessionDir, conversationDir);
+                }
+                catch {
+                    sessionFile = createManagedSessionFileAtPath(threadFile, conversationDir);
+                    sessionManager = openManagedSession(sessionFile, sessionDir, conversationDir);
+                }
+            }
+            else {
+                sessionFile = createManagedSessionFileAtPath(threadFile, conversationDir);
+                sessionManager = openManagedSession(sessionFile, sessionDir, conversationDir);
+            }
+        }
+    }
+    else {
+        // Top-level conversation session: resolve the current session file.
+        sessionFile = resolveManagedSessionFile(sessionDir, conversationDir);
+        sessionManager = openManagedSession(sessionFile, sessionDir, conversationDir);
+    }
+    const sessionUuid = extractSessionUuid(sessionFile);
+    // Used for Slack thread filtering — for non-Slack platforms this is effectively a no-op
+    const rootTs = extractSessionSuffix(sessionKey);
+    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: {
@@ -391,27 +462,37 @@ 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 session file`);
+    }
+    // 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 {
+        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((e) => e.path).join(", ")}`);
+    }
+    catch (error) {
+        log.logWarning(`[${conversationId}] Failed to load resources`, String(error));
     }
-    const resourceLoader = {
-        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
-        getSkills: () => ({ skills: [], diagnostics: [] }),
-        getPrompts: () => ({ prompts: [], diagnostics: [] }),
-        getThemes: () => ({ themes: [], diagnostics: [] }),
-        getAgentsFiles: () => ({ agentsFiles: [] }),
-        getSystemPrompt: () => systemPrompt,
-        getAppendSystemPrompt: () => [],
-        extendResources: () => { },
-        reload: async () => { },
-    };
     const baseToolsOverride = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
     // Create AgentSession wrapper
     const session = new AgentSession({
         agent,
         sessionManager,
         settingsManager,
-        cwd: process.cwd(),
+        cwd: workspaceDir,
         modelRegistry,
         resourceLoader,
         baseToolsOverride,
@@ -429,6 +510,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             cacheWrite: 0,
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
         },
+        llmCallCount: 0,
         stopReason: "stop",
         errorMessage: undefined,
     };
@@ -438,6 +520,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.conversationId, session_id: logCtx.sessionId };
         if (event.type === "tool_execution_start") {
             const agentEvent = event;
             const args = agentEvent.args;
@@ -447,6 +530,10 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 args: agentEvent.args,
                 startTime: Date.now(),
             });
+            addLifecycleBreadcrumb("agent.tool.started", {
+                tool: agentEvent.toolName,
+                ...baseAttrs,
+            });
             log.logToolStart(logCtx, agentEvent.toolName, label, agentEvent.args);
             // Tool labels are omitted from the main message to reduce Slack noise.
             // Tool execution details are still posted to the thread (see tool_execution_end).
@@ -457,6 +544,26 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             const pending = pendingTools.get(agentEvent.toolCallId);
             pendingTools.delete(agentEvent.toolCallId);
             const durationMs = pending ? Date.now() - pending.startTime : 0;
+            Sentry.metrics.count("agent.tool.calls", 1, {
+                attributes: metricAttributes({
+                    tool: agentEvent.toolName,
+                    error: String(agentEvent.isError),
+                    ...baseAttrs,
+                }),
+            });
+            Sentry.metrics.distribution("agent.tool.duration", durationMs, {
+                unit: "millisecond",
+                attributes: metricAttributes({
+                    tool: agentEvent.toolName,
+                    ...baseAttrs,
+                }),
+            });
+            addLifecycleBreadcrumb("agent.tool.completed", {
+                tool: agentEvent.toolName,
+                error: agentEvent.isError,
+                duration_ms: durationMs,
+                ...baseAttrs,
+            });
             if (agentEvent.isError) {
                 log.logToolError(logCtx, agentEvent.toolName, durationMs, resultStr);
             }
@@ -489,6 +596,13 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         else if (event.type === "message_start") {
             const agentEvent = event;
             if (agentEvent.message.role === "assistant") {
+                runState.llmCallCount += 1;
+                addLifecycleBreadcrumb("agent.llm.call.started", {
+                    call_index: runState.llmCallCount,
+                    provider: model.provider,
+                    model: agentConfig.model,
+                    ...baseAttrs,
+                });
                 log.logResponseStart(logCtx);
             }
         }
@@ -512,6 +626,44 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                     runState.totalUsage.cost.cacheRead += assistantMsg.usage.cost.cacheRead;
                     runState.totalUsage.cost.cacheWrite += assistantMsg.usage.cost.cacheWrite;
                     runState.totalUsage.cost.total += assistantMsg.usage.cost.total;
+                    // Per-turn LLM metrics
+                    const llmAttributes = metricAttributes({
+                        provider: model.provider,
+                        model: agentConfig.model,
+                        ...baseAttrs,
+                        stop_reason: assistantMsg.stopReason,
+                        error: Boolean(assistantMsg.errorMessage),
+                    });
+                    Sentry.metrics.count("agent.llm.calls", 1, { attributes: llmAttributes });
+                    Sentry.metrics.distribution("agent.llm.tokens_in", assistantMsg.usage.input, {
+                        attributes: llmAttributes,
+                    });
+                    Sentry.metrics.distribution("agent.llm.tokens_out", assistantMsg.usage.output, {
+                        attributes: llmAttributes,
+                    });
+                    if (assistantMsg.usage.cacheRead > 0) {
+                        Sentry.metrics.distribution("agent.llm.cache_read", assistantMsg.usage.cacheRead, {
+                            attributes: llmAttributes,
+                        });
+                    }
+                    if (assistantMsg.usage.cacheWrite > 0) {
+                        Sentry.metrics.distribution("agent.llm.cache_write", assistantMsg.usage.cacheWrite, {
+                            attributes: llmAttributes,
+                        });
+                    }
+                    Sentry.metrics.distribution("agent.llm.cost_per_turn", assistantMsg.usage.cost.total, {
+                        attributes: llmAttributes,
+                    });
+                    addLifecycleBreadcrumb("agent.llm.call.completed", {
+                        call_index: runState.llmCallCount,
+                        provider: model.provider,
+                        model: agentConfig.model,
+                        stop_reason: assistantMsg.stopReason,
+                        error: Boolean(assistantMsg.errorMessage),
+                        input_tokens: assistantMsg.usage.input,
+                        output_tokens: assistantMsg.usage.output,
+                        cost_total_usd: assistantMsg.usage.cost.total,
+                    });
                 }
                 const content = agentEvent.message.content;
                 const thinkingParts = [];
@@ -578,41 +730,65 @@ 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 sessionConversationId = message.sessionKey.split(":")[0];
+            // Ensure the conversation directory exists
+            await mkdir(conversationDir, { recursive: true });
+            // Refresh vault config and clear executor cache so credential changes
+            // (env file updates, vault.json edits, token rotations) take effect.
+            // Then set the active actor BEFORE building system prompt, so workspacePath
+            // reflects the actor's sandbox type.
+            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)
             // Thread filter ensures only messages from this session's thread are synced
-            const syncedCount = await syncLogToSessionManager(sessionManager, channelDir, message.id, undefined, { rootTs, threadTs: message.threadTs });
+            const threadFilter = message.sessionKey.includes(":")
+                ? { scope: "thread", rootTs, threadTs: message.threadTs }
+                : { scope: "top-level", rootTs };
+            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
+            // Reload messages from the session file.
+            // 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);
+            // Use the actual executor's sandbox config, not the initial config,
+            // to ensure accurate environment description for the model
+            const memory = await getMemory(conversationDir);
+            const skills = loadMamaSkills(conversationDir, workspacePath);
+            const actualSandboxConfig = executor.getSandboxConfig();
+            const systemPrompt = buildSystemPrompt(workspacePath, conversationId, message.userId, memory, actualSandboxConfig, platform, skills);
+            session.agent.state.systemPrompt = systemPrompt;
             // 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);
             });
+            setEventContext({
+                platform: platform.name,
+                conversationId,
+                userId: message.userId,
+            });
             // Reset per-run state
             runState.responseCtx = responseCtx;
             runState.logCtx = {
-                channelId: sessionChannel,
+                conversationId: sessionConversationId,
                 userName: message.userName,
-                channelName: undefined,
+                conversationName: undefined,
+                sessionId: sessionUuid,
             };
             runState.pendingTools.clear();
             runState.totalUsage = {
@@ -622,6 +798,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 cacheWrite: 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             };
+            runState.llmCallCount = 0;
             runState.stopReason = "stop";
             runState.errorMessage = undefined;
             // Create queue for this run
@@ -672,7 +849,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)) {
@@ -701,7 +878,15 @@ 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: sessionConversationId,
+                session_id: sessionUuid,
+                attachment_count: message.attachments?.length ?? 0,
+                image_attachment_count: imageAttachments.length,
+            });
             await session.prompt(userMessage, imageAttachments.length > 0 ? { images: imageAttachments } : undefined);
             // Wait for queued messages
             await queueChain;
@@ -767,6 +952,35 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                         lastAssistantMessage.usage.cacheWrite
                     : 0;
                 const contextWindow = model.contextWindow || 200000;
+                // Run-level Sentry metrics
+                const { totalUsage } = runState;
+                const runMetricAttributes = metricAttributes({
+                    provider: model.provider,
+                    model: agentConfig.model,
+                    channel_id: sessionConversationId,
+                    session_id: sessionUuid,
+                    stop_reason: runState.stopReason,
+                    llm_calls: runState.llmCallCount,
+                });
+                Sentry.metrics.distribution("agent.run.tokens_in", totalUsage.input, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.tokens_out", totalUsage.output, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.cache_read", totalUsage.cacheRead, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.cache_write", totalUsage.cacheWrite, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.cost", totalUsage.cost.total, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.gauge("agent.context.utilization", contextTokens / contextWindow, {
+                    unit: "ratio",
+                    attributes: runMetricAttributes,
+                });
                 const summary = log.logUsageSummary(runState.logCtx, runState.totalUsage, contextTokens, contextWindow);
                 // Split long summaries to avoid msg_too_long
                 const summaryParts = splitForSlack(summary);
@@ -802,14 +1016,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;