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

package/dist/agent.js

@@ -1,16 +1,18 @@
-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 { Agent } from "@earendil-works/pi-agent-core";
+import { getModel } from "@earendil-works/pi-ai";
+import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, formatSkillsForPrompt, getAgentDir, loadSkillsFromDir, ModelRegistry, SettingsManager, } from "@earendil-works/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 { join, posix } from "path";
+import { loadAgentConfigForConversation } from "./config.js";
+import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
-import { createExecutor } from "./sandbox.js";
+import { createExecutor, } from "./sandbox.js";
+import { createMountedRuntimePathContext } from "./sandbox/path-context.js";
 import { addLifecycleBreadcrumb, metricAttributes } from "./sentry.js";
-import { createManagedSessionFileAtPath, extractSessionSuffix, extractSessionUuid, forkThreadSessionFile, getSessionDir, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, resolveManagedSessionFile, tryResolveThreadSession, } from "./session-store.js";
+import { extractSessionUuid, openManagedSession, } from "./session-store.js";
+import { shouldSurfaceToolDiagnostic } from "./tool-diagnostics.js";
 import { createMamaTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
 const IMAGE_MIME_TYPES = {
@@ -23,10 +25,17 @@ const IMAGE_MIME_TYPES = {
 function getImageMimeType(filename) {
     return IMAGE_MIME_TYPES[filename.toLowerCase().split(".").pop() || ""];
 }
-async function getMemory(channelDir) {
+function buildThreadSessionName(message) {
+    const text = message?.text?.trim();
+    if (!text)
+        return undefined;
+    const userLabel = message?.userName || message?.user || "unknown";
+    return `[${userLabel}]: ${text}`;
+}
+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 +47,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 +65,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,19 +86,87 @@ 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";
-    const isFirecracker = sandboxConfig.type === "firecracker";
+function buildRuntimePaths(runtimeWorkspaceRoot, conversationId) {
+    const workspaceRoot = runtimeWorkspaceRoot.replace(/\/+$/, "") || "/";
+    const conversationPath = posix.join(workspaceRoot, conversationId);
+    return {
+        workspaceRoot,
+        conversationPath,
+        scratchPath: posix.join(conversationPath, "scratch"),
+    };
+}
+function buildEnvDescription(sandboxType, workspaceRoot) {
+    switch (sandboxType) {
+        case "image":
+            return `You are running inside a managed per-user container.
+- Runtime workspace root: ${workspaceRoot}
+- Bash commands start in: ${workspaceRoot}
+- Install tools with the image's package manager
+- Your changes persist for this user's container until it is recreated`;
+        case "container":
+            return `You are running inside a shared container.
+- Runtime workspace root: ${workspaceRoot}
+- Bash commands start in: ${workspaceRoot}
+- Install tools with the container's package manager
+- Your changes persist across sessions`;
+        case "firecracker":
+            return `You are running inside a Firecracker microVM.
+- Runtime workspace root: ${workspaceRoot}
+- Use cd or absolute paths; project files are under ${workspaceRoot}
+- Install tools with: apt-get install <package> (Debian-based)
+- Your changes persist across sessions`;
+        case "cloudflare":
+            return `You are running through a Cloudflare Sandbox bridge.
+- Runtime workspace root: ${workspaceRoot}
+- Bash commands start in: ${workspaceRoot}
+- Your commands run in a remote container managed by Cloudflare
+- Important: the remote filesystem is not automatically synced back to the host workspace`;
+        default:
+            return `You are running directly on the host machine.
+- Runtime workspace root: ${workspaceRoot}
+- Bash commands start in: ${process.cwd()}
+- Be careful with system modifications`;
+    }
+}
+export function buildEventFilesystemInstructions(sandboxType, workspaceRoot) {
+    if (sandboxType === "host" || sandboxType === "container" || sandboxType === "image") {
+        return `Events live in the host-side mama control plane and are mounted at \`${workspaceRoot}/events/\` in this runtime.
+
+Prefer the \`event\` tool over manually writing JSON files; it fills \`platform\`, \`conversationId\`, \`conversationKind\`, and \`userId\` for the current conversation automatically.
+
+### Creating Events Manually
+Only do this when you need to create events from a script. Use unique filenames to avoid overwriting existing events. Include a timestamp or random suffix:
+\`\`\`bash
+cat > ${workspaceRoot}/events/dentist-reminder-$(date +%s).json << 'EOF'
+{"type": "one-shot", "platform": "<platform>", "conversationId": "<conversationId>", "conversationKind": "<direct|shared>", "userId": "<requester userId>", "text": "Dentist tomorrow", "at": "2025-12-14T09:00:00+01:00"}
+EOF
+\`\`\`
+
+### Managing Events
+- List: \`ls ${workspaceRoot}/events/\`
+- View: \`cat ${workspaceRoot}/events/foo.json\`
+- Delete/cancel: \`rm ${workspaceRoot}/events/foo.json\``;
+    }
+    return `Events live in the host-side mama control plane, not necessarily in this runtime filesystem.
+
+Use the \`event\` tool to create events. It writes to the correct host-side events directory and fills \`platform\`, \`conversationId\`, \`conversationKind\`, and \`userId\` for the current conversation automatically.
+
+Do not create event files with bash in \`${workspaceRoot}/events/\` from this sandbox unless you have explicitly verified that path is mounted back to the host-side mama events directory.`;
+}
+function buildSystemPrompt(workspacePath, conversationId, conversationKind, currentUserId, memory, sandboxConfig, platform, skills, isSyntheticEvent = false) {
+    const { workspaceRoot, conversationPath, scratchPath } = buildRuntimePaths(workspacePath, conversationId);
+    const sandboxType = sandboxConfig.type;
+    const isContainerLike = sandboxType === "container" || sandboxType === "image";
+    const isFirecracker = sandboxType === "firecracker";
     // Format channel mappings
     const channelMappings = platform.channels.length > 0
         ? platform.channels.map((c) => `${c.id}\t#${c.name}`).join("\n")
@@ -98,27 +175,29 @@ 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).
-- Bash working directory: / (use cd or absolute paths)
-- Install tools with: apk add <package>
-- Your changes persist across sessions`
-        : 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.
-- Bash working directory: ${process.cwd()}
-- Be careful with system modifications`;
+    const envDescription = buildEnvDescription(sandboxType, workspaceRoot);
+    const eventFilesystemInstructions = buildEventFilesystemInstructions(sandboxType, workspaceRoot);
+    const syntheticEventInstructions = isSyntheticEvent
+        ? `
+## Synthetic Event 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.
+`
+        : "";
     return `You are mama, a ${platform.name} bot assistant. Be concise. No emojis.
 
 ## Context
 - For current date/time, use: date
 - You have access to previous conversation context including tool results from prior turns.
-- For older history beyond your context, search log.jsonl (contains user messages and your final responses, but not tool results).
-- User messages include a \`[in-thread:TS]\` marker when sent from within a Slack thread (TS is the root message timestamp). Without this marker, the message is a top-level channel message.
-
+- For older human-readable history beyond your context, search \`log.jsonl\` (contains user messages and your final responses, but not tool results).
+- Structured session history with tool results lives in \`${conversationPath}/sessions/\`.
+- The active top-level session is selected by \`${conversationPath}/sessions/current\`, which points to a timestamped \`.jsonl\` file in the same directory.
+- Scoped/thread sessions use fixed files at \`${conversationPath}/sessions/<scope_id>.jsonl\` (for example \`${conversationPath}/sessions/1777386320.800769.jsonl\`).
+- 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.
+${syntheticEventInstructions}
 ${platform.formattingGuide}
 
 ## Platform IDs
@@ -130,23 +209,29 @@ When mentioning users, use <@username> format (e.g., <@mario>).
 
 ## Environment
 ${envDescription}
+- Default place for clones, downloads, and experiments: ${scratchPath}
+- Do not use host-only paths unless you are running in host mode and verified they exist.
 
 ## Workspace Layout
-${workspacePath}/
-├── MEMORY.md                    # Global memory (all channels)
+${workspaceRoot}/
+├── MEMORY.md                    # Global memory (all conversations)
 ├── skills/                      # Global CLI tools you create
-└── ${channelId}/                # This channel
-    ├── MEMORY.md                # Channel-specific memory
-    ├── log.jsonl                # Message history (no tool results)
+└── ${conversationId}/           # This conversation
+    ├── MEMORY.md                # Conversation-specific memory
+    ├── log.jsonl                # Human-readable message history (no tool results)
+    ├── sessions/                # Structured session history used for context reconstruction
+    │   ├── current              # Active top-level session pointer
+    │   ├── <timestamp>_<id>.jsonl  # Top-level session files
+    │   └── <scope_id>.jsonl        # Scoped thread/reply session files
     ├── attachments/             # User-shared files
-    ├── scratch/                 # Your working directory
-    └── skills/                  # Channel-specific tools
+    ├── scratch/                 # Working directory for clones/downloads/experiments: ${scratchPath}
+    └── 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 \`${workspaceRoot}/skills/<name>/\` (global) or \`${conversationPath}/skills/<name>/\` (conversation-specific).
 Each skill directory needs a \`SKILL.md\` with YAML frontmatter:
 
 \`\`\`markdown
@@ -167,23 +252,24 @@ Scripts are in: {baseDir}/
 ${skills.length > 0 ? formatSkillsForPrompt(skills) : "(no skills installed yet)"}
 
 ## Events
-You can schedule events that wake you up at specific times or when external things happen. Events are JSON files in \`${workspacePath}/events/\`.
+You can schedule events that wake you up at specific times or when external things happen.
+${eventFilesystemInstructions}
 
 ### Event Types
 
 **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,22 +282,12 @@ 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
-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.
+### Platform and Credential Routing
+Set \`platform\` to the target bot platform (\`${platform.name}\` for this conversation). Include it explicitly to avoid ambiguity.
 
-### 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"}
-EOF
-\`\`\`
-Or check if file exists first before creating.
+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.
 
-### Managing Events
-- List: \`ls ${workspacePath}/events/\`
-- View: \`cat ${workspacePath}/events/foo.json\`
-- Delete/cancel: \`rm ${workspacePath}/events/foo.json\`
+When scheduling an event, write \`text\` as a self-contained task for your future self. Include the minimum necessary context, tone, and constraints in the text itself because events do not inherit normal conversation history. Good: \`Please remind the user that break time is over and it is time to return to class. Keep it brief, in Traditional Chinese, and do not ask follow-up questions.\` Bad: \`back to class\`.
 
 ### When Events Trigger
 You receive a message like:
@@ -231,16 +307,16 @@ 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
+- Global (${workspaceRoot}/MEMORY.md): skills, preferences, project info
+- Conversation (${conversationPath}/MEMORY.md): conversation-specific decisions, ongoing work
 Update when you learn something important or when asked to remember something.
 
 ### Current Memory
 ${memory}
 
 ## System Configuration Log
-Maintain ${workspacePath}/SYSTEM.md to log all environment modifications:
-- Installed packages (apk add, npm install, pip install)
+Maintain ${workspaceRoot}/SYSTEM.md to log all environment modifications:
+- Installed packages (apt install, npm install, uv pip install)
 - Environment variables set
 - Config files modified (~/.gitconfig, cron jobs, etc.)
 - Skill dependencies installed
@@ -250,8 +326,8 @@ 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" : ""}
-${isFirecracker ? "Install jq: apt-get install jq" : ""}
+Use \`log.jsonl\` for quick grep-style history. Use \`${conversationPath}/sessions/\` when you need structured turns, tool outputs, or branch lineage.
+${isContainerLike || isFirecracker ? "Install jq: apt-get install jq" : ""}
 
 \`\`\`bash
 # Recent messages
@@ -262,6 +338,10 @@ grep -i "topic" log.jsonl | jq -c '{date: .date[0:19], user: (.userName // .user
 
 # Messages from specific user
 grep '"userName":"mario"' log.jsonl | tail -20 | jq -c '{date: .date[0:19], text}'
+
+# Inspect top-level session pointer and available session files
+cat sessions/current
+ls -1 sessions/
 \`\`\`
 
 ## Tools
@@ -279,162 +359,80 @@ function truncate(text, maxLen) {
         return text;
     return `${text.substring(0, maxLen - 3)}...`;
 }
-function extractToolResultText(result) {
-    if (typeof result === "string") {
-        return result;
+export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot) {
+    if (sandboxConfig.type === "image") {
+        return createMountedRuntimePathContext(hostWorkspaceRoot, "/workspace");
     }
-    if (result &&
-        typeof result === "object" &&
-        "content" in result &&
-        Array.isArray(result.content)) {
-        const content = result.content;
-        const textParts = [];
-        for (const part of content) {
-            if (part.type === "text" && part.text) {
-                textParts.push(part.text);
-            }
-        }
-        if (textParts.length > 0) {
-            return textParts.join("\n");
-        }
-    }
-    return JSON.stringify(result);
-}
-function formatToolArgsForSlack(_toolName, args) {
-    const lines = [];
-    for (const [key, value] of Object.entries(args)) {
-        if (key === "label")
-            continue;
-        if (key === "path" && typeof value === "string") {
-            const offset = args.offset;
-            const limit = args.limit;
-            if (offset !== undefined && limit !== undefined) {
-                lines.push(`${value}:${offset}-${offset + limit}`);
-            }
-            else {
-                lines.push(value);
-            }
-            continue;
-        }
-        if (key === "offset" || key === "limit")
-            continue;
-        if (typeof value === "string") {
-            lines.push(value);
-        }
-        else {
-            lines.push(JSON.stringify(value));
-        }
-    }
-    return lines.join("\n");
+    return createExecutor(sandboxConfig).getPathContext(hostWorkspaceRoot);
 }
-// ============================================================================
-// Agent runner
-// ============================================================================
-/**
- * Create a new AgentRunner for a channel.
- * Sets up the session and subscribes to events once.
- *
- * 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) {
-    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}`, ""));
-    // Create tools (per-runner, with per-runner upload function setter)
-    const { tools, setUploadFunction } = createMamaTools(executor);
-    // 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 emptyPlatform = {
-        name: "slack",
-        formattingGuide: "",
-        channels: [],
-        users: [],
+function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
+    const executionResolver = vaultManager &&
+        sandboxConfig.type !== "host" &&
+        (vaultManager.isEnabled() ||
+            sandboxConfig.type === "container" ||
+            sandboxConfig.type === "image" ||
+            sandboxConfig.type === "cloudflare" ||
+            sandboxConfig.type === "firecracker")
+        ? new ActorExecutionResolver(sandboxConfig, vaultManager, provisioner, workspaceDir)
+        : 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.
+    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();
+        },
+        getPathContext(hostWorkspaceRoot) {
+            return activeExecutor.getPathContext(hostWorkspaceRoot);
+        },
     };
-    const systemPrompt = buildSystemPrompt(workspacePath, channelId, 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);
-    const isThread = sessionKey.includes(":");
-    let sessionManager;
-    let contextFile;
-    if (isThread) {
-        const threadFile = getThreadSessionFile(channelDir, sessionKey);
-        const existing = tryResolveThreadSession(threadFile);
-        if (existing) {
-            contextFile = existing;
-            sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
-        }
-        else {
-            const channelSource = resolveChannelSessionFile(channelDir);
-            if (channelSource) {
-                try {
-                    contextFile = forkThreadSessionFile(channelSource, threadFile, channelDir);
-                    sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
-                }
-                catch {
-                    contextFile = createManagedSessionFileAtPath(threadFile, channelDir);
-                    sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
-                }
-            }
-            else {
-                contextFile = createManagedSessionFileAtPath(threadFile, channelDir);
-                sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
-            }
-        }
-    }
-    else {
-        // Channel/DM session: normal resolve
-        contextFile = resolveManagedSessionFile(sessionDir, channelDir);
-        sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
-    }
-    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, ".."));
-    // Create AuthStorage and ModelRegistry
-    // Auth stored outside workspace so agent can't access it
+    return {
+        executionResolver,
+        executor,
+        getPathContext: () => executor.getPathContext(hostWorkspacePath),
+        async resolveExecutorForRun(context) {
+            if (!executionResolver)
+                return;
+            activeExecutor = await executionResolver.resolve(context);
+        },
+    };
+}
+async function createConfiguredAgentSession(params) {
+    const { conversationId, workspaceDir, runtimeWorkspaceRoot, systemPrompt, model, thinkingLevel, tools, sessionManager, settingsManager, } = params;
     const authStorage = AuthStorage.create(join(homedir(), ".pi", "mama", "auth.json"));
-    const modelRegistry = new ModelRegistry(authStorage);
-    // Create agent
+    const modelRegistry = ModelRegistry.create(authStorage);
     const agent = new Agent({
         initialState: {
             systemPrompt,
             model,
-            thinkingLevel: agentConfig.thinkingLevel ?? "off",
+            thinkingLevel,
             tools,
         },
         convertToLlm,
         getApiKey: async () => {
             const key = await modelRegistry.getApiKeyForProvider(model.provider);
-            if (!key)
+            if (!key) {
                 throw new Error(`No API key for provider "${model.provider}". Set the appropriate environment variable or configure via auth.json`);
+            }
             return key;
         },
     });
-    // 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}] Reloaded ${loadedSession.messages.length} messages from session context`);
     }
-    // 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,124 +440,355 @@ 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((extension) => extension.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
     const session = new AgentSession({
         agent,
         sessionManager,
         settingsManager,
-        cwd: workspaceDir,
+        cwd: runtimeWorkspaceRoot,
         modelRegistry,
         resourceLoader,
         baseToolsOverride,
     });
-    // Mutable per-run state - event handler references this
-    const runState = {
+    return { agent, session };
+}
+function createEmptyUsageTotals() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function createRunState() {
+    return {
         responseCtx: null,
         logCtx: null,
         queue: null,
         pendingTools: new Map(),
-        totalUsage: {
-            input: 0,
-            output: 0,
-            cacheRead: 0,
-            cacheWrite: 0,
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-        },
+        totalUsage: createEmptyUsageTotals(),
         llmCallCount: 0,
         stopReason: "stop",
         errorMessage: undefined,
     };
-    // Subscribe to events ONCE
+}
+function resetRunState(runState, responseCtx, sessionConversation, userName, sessionUuid) {
+    runState.responseCtx = responseCtx;
+    runState.logCtx = {
+        conversationId: sessionConversation,
+        userName,
+        conversationName: undefined,
+        sessionId: sessionUuid,
+    };
+    runState.pendingTools.clear();
+    runState.totalUsage = createEmptyUsageTotals();
+    runState.llmCallCount = 0;
+    runState.stopReason = "stop";
+    runState.errorMessage = undefined;
+}
+function createRunQueue(responseCtx) {
+    let queueChain = Promise.resolve();
+    return {
+        queue: {
+            enqueue(fn, errorContext) {
+                queueChain = queueChain.then(async () => {
+                    try {
+                        await fn();
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        log.logWarning(`API error (${errorContext})`, errMsg);
+                        try {
+                            await responseCtx.respondDiagnostic(`Error: ${errMsg}`, { style: "error" });
+                        }
+                        catch {
+                            // Ignore
+                        }
+                    }
+                });
+            },
+        },
+        wait: () => queueChain,
+    };
+}
+function padTwoDigits(n) {
+    return n.toString().padStart(2, "0");
+}
+function formatTimestampedUserMessage(message) {
+    const now = new Date();
+    const offset = -now.getTimezoneOffset();
+    const offsetSign = offset >= 0 ? "+" : "-";
+    const offsetHours = padTwoDigits(Math.floor(Math.abs(offset) / 60));
+    const offsetMins = padTwoDigits(Math.abs(offset) % 60);
+    const timestamp = `${now.getFullYear()}-${padTwoDigits(now.getMonth() + 1)}-${padTwoDigits(now.getDate())} ` +
+        `${padTwoDigits(now.getHours())}:${padTwoDigits(now.getMinutes())}:${padTwoDigits(now.getSeconds())}` +
+        `${offsetSign}${offsetHours}:${offsetMins}`;
+    const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
+    return `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
+}
+function collectMessageAttachments(message, workspacePath) {
+    const imageAttachments = [];
+    const nonImagePaths = [];
+    for (const attachment of message.attachments || []) {
+        const fullPath = `${workspacePath}/${attachment.localPath}`;
+        const mimeType = getImageMimeType(attachment.localPath);
+        if (mimeType && existsSync(fullPath)) {
+            try {
+                imageAttachments.push({
+                    type: "image",
+                    mimeType,
+                    data: readFileSync(fullPath).toString("base64"),
+                });
+            }
+            catch {
+                nonImagePaths.push(fullPath);
+            }
+        }
+        else {
+            nonImagePaths.push(fullPath);
+        }
+    }
+    return { imageAttachments, nonImagePaths };
+}
+function buildPromptPayload(message, workspacePath) {
+    let userMessage = formatTimestampedUserMessage(message);
+    const { imageAttachments, nonImagePaths } = collectMessageAttachments(message, workspacePath);
+    if (nonImagePaths.length > 0) {
+        userMessage += `\n\n<slack_attachments>\n${nonImagePaths.join("\n")}\n</slack_attachments>`;
+    }
+    return { userMessage, imageAttachments };
+}
+async function writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachmentCount) {
+    const debugContext = {
+        systemPrompt,
+        messages: session.messages,
+        newUserMessage: userMessage,
+        imageAttachmentCount,
+    };
+    await writeFile(join(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
+}
+function getFinalAssistantText(session) {
+    const lastAssistant = session.messages.filter((message) => message.role === "assistant").pop();
+    return (lastAssistant?.content
+        .filter((content) => content.type === "text")
+        .map((content) => content.text)
+        .join("\n") || "");
+}
+async function finalizeRunResponse(responseCtx, session, runState) {
+    if (runState.stopReason === "error" && runState.errorMessage) {
+        try {
+            await responseCtx.replaceResponse("_Sorry, something went wrong_");
+            await responseCtx.respondDiagnostic(`Error: ${runState.errorMessage}`, {
+                style: "error",
+            });
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log.logWarning("Failed to post error message", errMsg);
+        }
+        return;
+    }
+    const finalText = getFinalAssistantText(session);
+    if (finalText.trim() === "[SILENT]" || finalText.trim().startsWith("[SILENT]")) {
+        try {
+            await responseCtx.deleteResponse();
+            log.logInfo("Silent response - deleted message and thread");
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log.logWarning("Failed to delete message for silent response", errMsg);
+        }
+        return;
+    }
+    if (!finalText.trim())
+        return;
+    try {
+        await responseCtx.replaceResponse(finalText);
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log.logWarning("Failed to replace message with final text", errMsg);
+    }
+}
+async function reportUsageSummary(ctx) {
+    const { session, runState, responseCtx, platform, model, agentConfig, sessionConversation, sessionUuid, waitForQueue, } = ctx;
+    if (runState.totalUsage.cost.total <= 0)
+        return;
+    const lastAssistantMessage = session.messages
+        .slice()
+        .toReversed()
+        .find((message) => message.role === "assistant" && message.stopReason !== "aborted");
+    const contextTokens = lastAssistantMessage
+        ? lastAssistantMessage.usage.input +
+            lastAssistantMessage.usage.output +
+            lastAssistantMessage.usage.cacheRead +
+            lastAssistantMessage.usage.cacheWrite
+        : 0;
+    const contextWindow = model.contextWindow || 200000;
+    const { totalUsage } = runState;
+    const runMetricAttributes = metricAttributes({
+        provider: model.provider,
+        model: agentConfig.model,
+        channel_id: sessionConversation,
+        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);
+    if (platform.diagnostics?.showUsageSummary === true) {
+        runState.queue.enqueue(() => responseCtx.respondDiagnostic(summary, { style: "muted" }), "usage summary");
+        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`);
+    }
+}
+async function prepareRunContext(params) {
+    const { message, responseCtx, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, sessionManager, session, agent, setEventContext, setUploadFunction, } = params;
+    let pathContext = params.pathContext;
+    const sessionConversation = message.sessionKey.split(":")[0];
+    await mkdir(join(conversationDir, "scratch"), { recursive: true });
+    if (executionResolver) {
+        await resolveExecutorForRun({
+            platform: platform.name,
+            userId: message.userId,
+            conversationId,
+        });
+        pathContext = getPathContext();
+    }
+    reloadSessionMessages(sessionManager, conversationId, agent);
+    const memory = await getMemory(conversationDir);
+    const skills = loadMamaSkills(conversationDir, pathContext.runtimeWorkspaceRoot);
+    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, conversationId, message.conversationKind, message.userId, memory, executor.getSandboxConfig(), platform, skills, message.id.startsWith("event:"));
+    session.agent.state.systemPrompt = systemPrompt;
+    setEventContext({
+        platform: platform.name,
+        conversationId,
+        conversationKind: message.conversationKind,
+        userId: message.userId,
+    });
+    setUploadFunction(async (filePath, title) => {
+        const hostPath = translateRuntimePathToHost(filePath, pathContext);
+        await responseCtx.uploadFile(hostPath, title);
+    });
+    resetRunState(runState, responseCtx, sessionConversation, message.userName, sessionUuid);
+    const runQueue = createRunQueue(responseCtx);
+    runState.queue = runQueue.queue;
+    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);
+    await writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachments.length);
+    return {
+        sessionConversation,
+        runQueue,
+        userMessage,
+        imageAttachments,
+        pathContext,
+    };
+}
+function attachSessionEventHandlers(params) {
+    const { session, runState, model, agentConfig } = params;
     session.subscribe(async (event) => {
-        // Skip if no active run
         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;
-            const label = args.label || agentEvent.toolName;
-            pendingTools.set(agentEvent.toolCallId, {
-                toolName: agentEvent.toolName,
-                args: agentEvent.args,
+            const args = (event.args ?? {});
+            const label = args.label || event.toolName;
+            pendingTools.set(event.toolCallId, {
+                toolName: event.toolName,
+                args: event.args,
                 startTime: Date.now(),
             });
             addLifecycleBreadcrumb("agent.tool.started", {
-                tool: agentEvent.toolName,
+                tool: event.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).
+            log.logToolStart(logCtx, event.toolName, label, event.args);
+            return;
         }
-        else if (event.type === "tool_execution_end") {
-            const agentEvent = event;
-            const resultStr = extractToolResultText(agentEvent.result);
-            const pending = pendingTools.get(agentEvent.toolCallId);
-            pendingTools.delete(agentEvent.toolCallId);
+        if (event.type === "tool_execution_end") {
+            const resultStr = extractToolResultText(event.result);
+            const pending = pendingTools.get(event.toolCallId);
+            pendingTools.delete(event.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),
+                    tool: event.toolName,
+                    error: String(event.isError),
                     ...baseAttrs,
                 }),
             });
             Sentry.metrics.distribution("agent.tool.duration", durationMs, {
                 unit: "millisecond",
                 attributes: metricAttributes({
-                    tool: agentEvent.toolName,
+                    tool: event.toolName,
                     ...baseAttrs,
                 }),
             });
             addLifecycleBreadcrumb("agent.tool.completed", {
-                tool: agentEvent.toolName,
-                error: agentEvent.isError,
+                tool: event.toolName,
+                error: event.isError,
                 duration_ms: durationMs,
                 ...baseAttrs,
             });
-            if (agentEvent.isError) {
-                log.logToolError(logCtx, agentEvent.toolName, durationMs, resultStr);
+            if (event.isError) {
+                log.logToolError(logCtx, event.toolName, durationMs, resultStr);
             }
             else {
-                log.logToolSuccess(logCtx, agentEvent.toolName, durationMs, resultStr);
+                log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
             }
-            // Post args + result to thread
-            const label = pending?.args ? pending.args.label : undefined;
-            const argsFormatted = pending
-                ? formatToolArgsForSlack(agentEvent.toolName, pending.args)
-                : "(args not found)";
-            const duration = (durationMs / 1000).toFixed(1);
-            let threadMessage = `*${agentEvent.isError ? "✗" : "✓"} ${agentEvent.toolName}*`;
-            if (label)
-                threadMessage += `: ${label}`;
-            threadMessage += ` (${duration}s)\n`;
-            if (argsFormatted)
-                threadMessage += `\`\`\`\n${argsFormatted}\n\`\`\`\n`;
-            threadMessage += `*Result:*\n\`\`\`\n${resultStr}\n\`\`\``;
-            // Only post thread details for tools with meaningful output (bash, attach).
-            // Skip read/write/edit to reduce Slack noise — their results are in the log.
-            const quietTools = new Set(["read", "write", "edit"]);
-            if (!quietTools.has(agentEvent.toolName)) {
-                queue.enqueueMessage(threadMessage, "thread", "tool result thread", false);
+            if (shouldSurfaceToolDiagnostic(event.toolName)) {
+                const toolResult = {
+                    toolName: event.toolName,
+                    label: pending?.args ? pending.args.label : undefined,
+                    args: pending?.args,
+                    result: truncate(resultStr, TOOL_RESULT_DIAGNOSTIC_CAP),
+                    isError: event.isError,
+                    durationMs,
+                };
+                queue.enqueue(() => responseCtx.respondToolResult(toolResult), "tool result diagnostic");
             }
-            if (agentEvent.isError) {
+            if (event.isError) {
                 queue.enqueue(() => responseCtx.respond(`_Error: ${truncate(resultStr, 200)}_`), "tool error");
             }
+            return;
         }
-        else if (event.type === "message_start") {
-            const agentEvent = event;
-            if (agentEvent.message.role === "assistant") {
+        if (event.type === "message_start") {
+            if (event.message.role === "assistant") {
                 runState.llmCallCount += 1;
                 addLifecycleBreadcrumb("agent.llm.call.started", {
                     call_index: runState.llmCallCount,
@@ -569,11 +798,11 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 });
                 log.logResponseStart(logCtx);
             }
+            return;
         }
-        else if (event.type === "message_end") {
-            const agentEvent = event;
-            if (agentEvent.message.role === "assistant") {
-                const assistantMsg = agentEvent.message;
+        if (event.type === "message_end") {
+            if (event.message.role === "assistant") {
+                const assistantMsg = event.message;
                 if (assistantMsg.stopReason) {
                     runState.stopReason = assistantMsg.stopReason;
                 }
@@ -590,7 +819,6 @@ 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,
@@ -629,10 +857,9 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                         cost_total_usd: assistantMsg.usage.cost.total,
                     });
                 }
-                const content = agentEvent.message.content;
                 const thinkingParts = [];
                 const textParts = [];
-                for (const part of content) {
+                for (const part of assistantMsg.content) {
                     if (part.type === "thinking") {
                         thinkingParts.push(part.thinking);
                     }
@@ -643,296 +870,168 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 const text = textParts.join("\n");
                 for (const thinking of thinkingParts) {
                     log.logThinking(logCtx, thinking);
-                    queue.enqueueMessage(`_${thinking}_`, "main", "thinking main");
-                    queue.enqueueMessage(`_${thinking}_`, "thread", "thinking thread", false);
+                    queue.enqueue(() => responseCtx.respond(`_${thinking}_`), "thinking main");
+                    queue.enqueue(() => responseCtx.respondDiagnostic(`_${thinking}_`), "thinking diagnostic");
                 }
                 if (text.trim()) {
                     log.logResponse(logCtx, text);
-                    queue.enqueueMessage(text, "main", "response main");
-                    // Only overflow to thread for texts that will be truncated in main
-                    if (text.length > SLACK_MAX_LENGTH) {
-                        queue.enqueueMessage(text, "thread", "response thread", false);
-                    }
+                    queue.enqueue(() => responseCtx.respond(text), "response main");
                 }
             }
+            return;
         }
-        else if (event.type === "compaction_start") {
+        if (event.type === "compaction_start") {
             log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
             queue.enqueue(() => responseCtx.respond("_Compacting context..._"), "compaction start");
+            return;
         }
-        else if (event.type === "compaction_end") {
-            const compEvent = event;
-            if (compEvent.result) {
-                log.logInfo(`Auto-compaction complete: ${compEvent.result.tokensBefore} tokens compacted`);
+        if (event.type === "compaction_end") {
+            if (event.result) {
+                log.logInfo(`Auto-compaction complete: ${event.result.tokensBefore} tokens compacted`);
             }
-            else if (compEvent.aborted) {
+            else if (event.aborted) {
                 log.logInfo("Auto-compaction aborted");
             }
+            return;
         }
-        else if (event.type === "auto_retry_start") {
-            const retryEvent = event;
-            log.logWarning(`Retrying (${retryEvent.attempt}/${retryEvent.maxAttempts})`, retryEvent.errorMessage);
-            queue.enqueue(() => responseCtx.respond(`_Retrying (${retryEvent.attempt}/${retryEvent.maxAttempts})..._`), "retry");
+        if (event.type === "auto_retry_start") {
+            log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
+            queue.enqueue(() => responseCtx.respond(`_Retrying (${event.attempt}/${event.maxAttempts})..._`), "retry");
         }
     });
-    // Message limit constant
-    const SLACK_MAX_LENGTH = 40000;
-    const splitForSlack = (text) => {
-        if (text.length <= SLACK_MAX_LENGTH)
-            return [text];
-        const parts = [];
-        let remaining = text;
-        let partNum = 1;
-        while (remaining.length > 0) {
-            const chunk = remaining.substring(0, SLACK_MAX_LENGTH - 50);
-            remaining = remaining.substring(SLACK_MAX_LENGTH - 50);
-            const suffix = remaining.length > 0 ? `\n_(continued ${partNum}...)_` : "";
-            parts.push(chunk + suffix);
-            partNum++;
+}
+// Cap raw tool output before handing it to adapters. Bash output can be MB; without
+// this each adapter's splitter would fan it out into many sequential platform posts.
+const TOOL_RESULT_DIAGNOSTIC_CAP = 8000;
+function extractToolResultText(result) {
+    if (typeof result === "string") {
+        return result;
+    }
+    if (result &&
+        typeof result === "object" &&
+        "content" in result &&
+        Array.isArray(result.content)) {
+        const content = result.content;
+        const textParts = [];
+        for (const part of content) {
+            if (part.type === "text" && part.text) {
+                textParts.push(part.text);
+            }
         }
-        return parts;
+        if (textParts.length > 0) {
+            return textParts.join("\n");
+        }
+    }
+    return JSON.stringify(result);
+}
+// ============================================================================
+// Agent runner
+// ============================================================================
+/**
+ * Create a new AgentRunner for a channel.
+ * Sets up the session and subscribes to events once.
+ *
+ * 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) {
+    const agentConfig = loadAgentConfigForConversation(conversationDir);
+    // Initialize logger with settings from config
+    log.initLogger({
+        logFormat: agentConfig.logFormat,
+        logLevel: agentConfig.logLevel,
+    });
+    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 } = 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(conversationDir);
+    const skills = loadMamaSkills(conversationDir, pathContext.runtimeWorkspaceRoot);
+    const emptyPlatform = {
+        name: "chat",
+        formattingGuide: "",
+        channels: [],
+        users: [],
     };
+    const systemPrompt = buildSystemPrompt(pathContext.runtimeWorkspaceRoot, conversationId, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills);
+    // Create session manager and settings manager. Top-level/private sessions
+    // use the conversation's current pointer; scoped sessions use fixed files.
+    // Platform-specific branch/fork behavior is resolved before runner creation.
+    const isThread = sessionKey.includes(":");
+    const { sessionDir, contextFile, threadRootMessage } = sessionScope;
+    const sessionManager = openManagedSession(contextFile, sessionDir, pathContext.runtimeWorkspaceRoot);
+    const threadSessionName = buildThreadSessionName(threadRootMessage);
+    if (isThread && threadSessionName && sessionManager.getSessionName() !== threadSessionName) {
+        sessionManager.appendSessionInfo(threadSessionName);
+    }
+    const sessionUuid = extractSessionUuid(contextFile);
+    const settingsManager = SettingsManager.inMemory();
+    const { agent, session } = await createConfiguredAgentSession({
+        conversationId,
+        workspaceDir,
+        runtimeWorkspaceRoot: pathContext.runtimeWorkspaceRoot,
+        systemPrompt,
+        model,
+        thinkingLevel: agentConfig.thinkingLevel,
+        tools,
+        sessionManager,
+        settingsManager,
+    });
+    // Mutable per-run state - event handler references this
+    const runState = createRunState();
+    attachSessionEventHandlers({ session, runState, model, agentConfig });
     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 });
-            // 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 threadFilter = message.sessionKey.includes(":")
-                ? { scope: "thread", rootTs, threadTs: message.threadTs }
-                : { scope: "top-level", rootTs };
-            const syncedCount = await syncLogToSessionManager(sessionManager, channelDir, message.id, undefined, threadFilter);
-            if (syncedCount > 0) {
-                log.logInfo(`[${channelId}] 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`);
-            }
-            // 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);
-            // Set up file upload function
-            setUploadFunction(async (filePath, title) => {
-                const hostPath = translateToHostPath(filePath, channelDir, workspacePath, channelId);
-                await responseCtx.uploadFile(hostPath, title);
+            const prepared = await prepareRunContext({
+                message,
+                responseCtx,
+                platform,
+                conversationId,
+                conversationDir,
+                sessionUuid,
+                runState,
+                executor,
+                executionResolver,
+                resolveExecutorForRun,
+                getPathContext,
+                sessionManager,
+                session,
+                agent,
+                setEventContext,
+                setUploadFunction,
+                pathContext,
             });
-            // Reset per-run state
-            runState.responseCtx = responseCtx;
-            runState.logCtx = {
-                channelId: sessionChannel,
-                userName: message.userName,
-                channelName: undefined,
-                sessionId: sessionUuid,
-            };
-            runState.pendingTools.clear();
-            runState.totalUsage = {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                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
-            let queueChain = Promise.resolve();
-            runState.queue = {
-                enqueue(fn, errorContext) {
-                    queueChain = queueChain.then(async () => {
-                        try {
-                            await fn();
-                        }
-                        catch (err) {
-                            const errMsg = err instanceof Error ? err.message : String(err);
-                            log.logWarning(`API error (${errorContext})`, errMsg);
-                            try {
-                                // Split long error messages to avoid msg_too_long
-                                const errParts = splitForSlack(`_Error: ${errMsg}_`);
-                                for (const part of errParts) {
-                                    await responseCtx.respondInThread(part);
-                                }
-                            }
-                            catch {
-                                // Ignore
-                            }
-                        }
-                    });
-                },
-                enqueueMessage(text, target, errorContext, _doLog = true) {
-                    const parts = splitForSlack(text);
-                    for (const part of parts) {
-                        this.enqueue(() => target === "main" ? responseCtx.respond(part) : responseCtx.respondInThread(part), errorContext);
-                    }
-                },
-            };
-            // Log context info
-            log.logInfo(`Context sizes - system: ${systemPrompt.length} chars, memory: ${memory.length} chars`);
-            log.logInfo(`Channels: ${platform.channels.length}, Users: ${platform.users.length}`);
-            // Build user message with timestamp and username prefix
-            // Format: "[YYYY-MM-DD HH:MM:SS+HH:MM] [username]: message" so LLM knows when and who
-            const now = new Date();
-            const pad = (n) => n.toString().padStart(2, "0");
-            const offset = -now.getTimezoneOffset();
-            const offsetSign = offset >= 0 ? "+" : "-";
-            const offsetHours = pad(Math.floor(Math.abs(offset) / 60));
-            const offsetMins = pad(Math.abs(offset) % 60);
-            const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}${offsetSign}${offsetHours}:${offsetMins}`;
-            const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
-            let userMessage = `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
-            const imageAttachments = [];
-            const nonImagePaths = [];
-            for (const a of message.attachments || []) {
-                // a.localPath is the path relative to the workspace (same as old a.local)
-                const fullPath = `${workspacePath}/${a.localPath}`;
-                const mimeType = getImageMimeType(a.localPath);
-                if (mimeType && existsSync(fullPath)) {
-                    try {
-                        imageAttachments.push({
-                            type: "image",
-                            mimeType,
-                            data: readFileSync(fullPath).toString("base64"),
-                        });
-                    }
-                    catch {
-                        nonImagePaths.push(fullPath);
-                    }
-                }
-                else {
-                    nonImagePaths.push(fullPath);
-                }
-            }
-            if (nonImagePaths.length > 0) {
-                userMessage += `\n\n<slack_attachments>\n${nonImagePaths.join("\n")}\n</slack_attachments>`;
-            }
-            // Debug: write context to last_prompt.jsonl
-            const debugContext = {
-                systemPrompt,
-                messages: session.messages,
-                newUserMessage: userMessage,
-                imageAttachmentCount: imageAttachments.length,
-            };
-            await writeFile(join(channelDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
+            pathContext = prepared.pathContext;
             addLifecycleBreadcrumb("agent.prompt.sent", {
                 provider: model.provider,
                 model: agentConfig.model,
-                channel_id: sessionChannel,
+                channel_id: prepared.sessionConversation,
                 session_id: sessionUuid,
                 attachment_count: message.attachments?.length ?? 0,
-                image_attachment_count: imageAttachments.length,
+                image_attachment_count: prepared.imageAttachments.length,
             });
-            await session.prompt(userMessage, imageAttachments.length > 0 ? { images: imageAttachments } : undefined);
+            await session.prompt(prepared.userMessage, prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : undefined);
             // Wait for queued messages
-            await queueChain;
-            // Handle error case - update main message and post error to thread
-            if (runState.stopReason === "error" && runState.errorMessage) {
-                try {
-                    await responseCtx.replaceResponse("_Sorry, something went wrong_");
-                    // Split long error messages to avoid msg_too_long
-                    const errorParts = splitForSlack(`_Error: ${runState.errorMessage}_`);
-                    for (const part of errorParts) {
-                        await responseCtx.respondInThread(part);
-                    }
-                }
-                catch (err) {
-                    const errMsg = err instanceof Error ? err.message : String(err);
-                    log.logWarning("Failed to post error message", errMsg);
-                }
-            }
-            else {
-                // Final message update
-                const messages = session.messages;
-                const lastAssistant = messages.filter((m) => m.role === "assistant").pop();
-                const finalText = lastAssistant?.content
-                    .filter((c) => c.type === "text")
-                    .map((c) => c.text)
-                    .join("\n") || "";
-                // Check for [SILENT] marker - delete message and thread instead of posting
-                if (finalText.trim() === "[SILENT]" || finalText.trim().startsWith("[SILENT]")) {
-                    try {
-                        await responseCtx.deleteResponse();
-                        log.logInfo("Silent response - deleted message and thread");
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log.logWarning("Failed to delete message for silent response", errMsg);
-                    }
-                }
-                else if (finalText.trim()) {
-                    try {
-                        const mainText = finalText.length > SLACK_MAX_LENGTH
-                            ? `${finalText.substring(0, SLACK_MAX_LENGTH - 50)}\n\n_(see thread for full response)_`
-                            : finalText;
-                        await responseCtx.replaceResponse(mainText);
-                    }
-                    catch (err) {
-                        const errMsg = err instanceof Error ? err.message : String(err);
-                        log.logWarning("Failed to replace message with final text", errMsg);
-                    }
-                }
-            }
-            // Log usage summary with context info
-            if (runState.totalUsage.cost.total > 0) {
-                // Get last non-aborted assistant message for context calculation
-                const messages = session.messages;
-                const lastAssistantMessage = messages
-                    .slice()
-                    .reverse()
-                    .find((m) => m.role === "assistant" && m.stopReason !== "aborted");
-                const contextTokens = lastAssistantMessage
-                    ? lastAssistantMessage.usage.input +
-                        lastAssistantMessage.usage.output +
-                        lastAssistantMessage.usage.cacheRead +
-                        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: sessionChannel,
-                    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);
-                for (const part of summaryParts) {
-                    runState.queue.enqueue(() => responseCtx.respondInThread(part, { style: "muted" }), "usage summary");
-                }
-                await queueChain;
-            }
+            await prepared.runQueue.wait();
+            await finalizeRunResponse(responseCtx, session, runState);
+            await reportUsageSummary({
+                session,
+                runState,
+                responseCtx,
+                platform,
+                model,
+                agentConfig,
+                sessionConversation: prepared.sessionConversation,
+                sessionUuid,
+                waitForQueue: () => prepared.runQueue.wait(),
+            });
             // Clear run state
             runState.responseCtx = null;
             runState.logCtx = null;
@@ -957,19 +1056,10 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         },
     };
 }
-/**
- * Translate container path back to host path for file operations
- */
-function translateToHostPath(containerPath, channelDir, workspacePath, channelId) {
-    if (workspacePath === "/workspace") {
-        const prefix = `/workspace/${channelId}/`;
-        if (containerPath.startsWith(prefix)) {
-            return join(channelDir, containerPath.slice(prefix.length));
-        }
-        if (containerPath.startsWith("/workspace/")) {
-            return join(channelDir, "..", containerPath.slice("/workspace/".length));
-        }
-    }
-    return containerPath;
+export function translateRuntimePathToHost(runtimePath, pathContext) {
+    return pathContext.runtimeToHostPath?.(runtimePath) ?? runtimePath;
+}
+export function buildInitialPathContextForTest(sandboxConfig, hostWorkspaceRoot) {
+    return getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot);
 }
 //# sourceMappingURL=agent.js.map