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

package/dist/agent.js

@@ -1,17 +1,18 @@
-import { Agent } from "@mariozechner/pi-agent-core";
-import { getModel } from "@mariozechner/pi-ai";
-import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, formatSkillsForPrompt, getAgentDir, 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, getChannelSessionDir, 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 = {
@@ -24,6 +25,13 @@ const IMAGE_MIME_TYPES = {
 function getImageMimeType(filename) {
     return IMAGE_MIME_TYPES[filename.toLowerCase().split(".").pop() || ""];
 }
+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 conversations)
@@ -87,11 +95,79 @@ function loadMamaSkills(conversationDir, workspacePath) {
     }
     return Array.from(skillMap.values());
 }
-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 platform conversation mappings
+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")
         : "(no channels loaded)";
@@ -99,27 +175,29 @@ function buildSystemPrompt(workspacePath, conversationId, currentUserId, memory,
     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 = 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`
-        : 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
@@ -131,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
 └── ${conversationId}/           # This conversation
     ├── MEMORY.md                # Conversation-specific memory
-    ├── log.jsonl                # Message history (no tool results)
+    ├── 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
+    ├── 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 \`${conversationPath}/skills/<name>/\` (conversation-specific).
+Store in \`${workspaceRoot}/skills/<name>/\` (global) or \`${conversationPath}/skills/<name>/\` (conversation-specific).
 Each skill directory needs a \`SKILL.md\` with YAML frontmatter:
 
 \`\`\`markdown
@@ -168,27 +252,26 @@ 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": "${conversationId}", "userId": "<requester userId>", "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": "${conversationId}", "userId": "<requester userId>", "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": "${conversationId}", "userId": "<requester userId>", "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}"}
 \`\`\`
 
-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
@@ -199,31 +282,12 @@ Set \`userId\` to the platform userId of whoever asked for the event (look it up
 ### 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.
-
-### 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.
+### Platform and Credential Routing
+Set \`platform\` to the target bot platform (\`${platform.name}\` for this conversation). Include it explicitly to avoid ambiguity.
 
-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": "${conversationId}", "userId": "<requester userId>", "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:
@@ -243,7 +307,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
+- 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.
 
@@ -251,8 +315,8 @@ Update when you learn something important or when asked to remember something.
 ${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
@@ -262,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).
-${isContainer ? "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
@@ -274,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
@@ -291,78 +359,24 @@ 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 conversation.
- * Sets up the session and subscribes to events once.
- *
- * Runner caching is handled by the caller (conversationStates in main.ts).
- * This is a stateless factory function.
- */
-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,
-    });
+function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, hostWorkspacePath) {
     const executionResolver = vaultManager &&
+        sandboxConfig.type !== "host" &&
         (vaultManager.isEnabled() ||
-            !!bindingStore ||
+            sandboxConfig.type === "container" ||
             sandboxConfig.type === "image" ||
-            sandboxConfig.type === "container")
-        ? new ActorExecutionResolver(sandboxConfig, vaultManager, bindingStore, provisioner)
+            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);
@@ -376,98 +390,46 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         getSandboxConfig() {
             return activeExecutor.getSandboxConfig();
         },
+        getPathContext(hostWorkspaceRoot) {
+            return activeExecutor.getPathContext(hostWorkspaceRoot);
+        },
     };
-    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, 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, workspacePath);
-    const emptyPlatform = {
-        name: "slack",
-        formattingGuide: "",
-        channels: [],
-        users: [],
+    return {
+        executionResolver,
+        executor,
+        getPathContext: () => executor.getPathContext(hostWorkspacePath),
+        async resolveExecutorForRun(context) {
+            if (!executionResolver)
+                return;
+            activeExecutor = await executionResolver.resolve(context);
+        },
     };
-    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
+}
+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 = ModelRegistry.create(authStorage);
-    // Create agent
     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.state.messages = loadedSession.messages;
-        log.logInfo(`[${conversationId}] Loaded ${loadedSession.messages.length} messages from session file`);
+        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(),
@@ -481,121 +443,352 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 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(", ")}`);
+        log.logInfo(`[${conversationId}] Loaded ${extResult.extensions.length} extension(s): ${extResult.extensions.map((extension) => extension.path).join(", ")}`);
     }
     catch (error) {
         log.logWarning(`[${conversationId}] Failed to load resources`, String(error));
     }
     const 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.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,
@@ -605,11 +798,11 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 });
                 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;
                 }
@@ -626,7 +819,6 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                     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,
@@ -665,10 +857,9 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                         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);
                     }
@@ -679,316 +870,168 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 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);
+            }
+        }
+        if (textParts.length > 0) {
+            return textParts.join("\n");
         }
-        return parts;
+    }
+    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 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 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(`[${conversationId}] Synced ${syncedCount} messages from log.jsonl`);
-            }
-            // Reload messages from the session file.
-            // This picks up any messages synced above.
-            const reloadedSession = sessionManager.buildSessionContext();
-            if (reloadedSession.messages.length > 0) {
-                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
-            // 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, conversationDir, workspacePath, conversationId);
-                await responseCtx.uploadFile(hostPath, title);
-            });
-            setEventContext({
-                platform: platform.name,
+            const prepared = await prepareRunContext({
+                message,
+                responseCtx,
+                platform,
                 conversationId,
-                userId: message.userId,
+                conversationDir,
+                sessionUuid,
+                runState,
+                executor,
+                executionResolver,
+                resolveExecutorForRun,
+                getPathContext,
+                sessionManager,
+                session,
+                agent,
+                setEventContext,
+                setUploadFunction,
+                pathContext,
             });
-            // Reset per-run state
-            runState.responseCtx = responseCtx;
-            runState.logCtx = {
-                conversationId: sessionConversationId,
-                userName: message.userName,
-                conversationName: 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
-                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(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
+            pathContext = prepared.pathContext;
             addLifecycleBreadcrumb("agent.prompt.sent", {
                 provider: model.provider,
                 model: agentConfig.model,
-                channel_id: sessionConversationId,
+                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: 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);
-                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;
@@ -1013,19 +1056,10 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         },
     };
 }
-/**
- * Translate container path back to host path for file operations
- */
-function translateToHostPath(containerPath, conversationDir, workspacePath, conversationId) {
-    if (workspacePath === "/workspace") {
-        const prefix = `/workspace/${conversationId}/`;
-        if (containerPath.startsWith(prefix)) {
-            return join(conversationDir, containerPath.slice(prefix.length));
-        }
-        if (containerPath.startsWith("/workspace/")) {
-            return join(conversationDir, "..", 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