@mariozechner/pi-mom 0.18.1 → 0.18.3

package/dist/agent.js

@@ -1,12 +1,14 @@
 import { Agent, ProviderTransport } from "@mariozechner/pi-agent-core";
 import { getModel } from "@mariozechner/pi-ai";
+import { AgentSession, messageTransformer } from "@mariozechner/pi-coding-agent";
 import { existsSync, readFileSync } from "fs";
 import { mkdir, writeFile } from "fs/promises";
 import { join } from "path";
+import { MomSessionManager, MomSettingsManager } from "./context.js";
 import * as log from "./log.js";
 import { createExecutor } from "./sandbox.js";
 import { createMomTools, setUploadFunction } from "./tools/index.js";
-// Hardcoded model for now
+// Hardcoded model for now - TODO: make configurable (issue #63)
 const model = getModel("anthropic", "claude-sonnet-4-5");
 /**
  * Convert Date.now() to Slack timestamp format (seconds.microseconds)
@@ -17,16 +19,14 @@ let tsCounter = 0;
 function toSlackTs() {
     const now = Date.now();
     if (now === lastTsMs) {
-        // Same millisecond - increment counter for sub-ms ordering
         tsCounter++;
     }
     else {
-        // New millisecond - reset counter
         lastTsMs = now;
         tsCounter = 0;
     }
     const seconds = Math.floor(now / 1000);
-    const micros = (now % 1000) * 1000 + tsCounter; // ms to micros + counter
+    const micros = (now % 1000) * 1000 + tsCounter;
     return `${seconds}.${micros.toString().padStart(6, "0")}`;
 }
 function getAnthropicApiKey() {
@@ -36,77 +36,6 @@ function getAnthropicApiKey() {
     }
     return key;
 }
-function getRecentMessages(channelDir, turnCount) {
-    const logPath = join(channelDir, "log.jsonl");
-    if (!existsSync(logPath)) {
-        return "(no message history yet)";
-    }
-    const content = readFileSync(logPath, "utf-8");
-    const lines = content.trim().split("\n").filter(Boolean);
-    if (lines.length === 0) {
-        return "(no message history yet)";
-    }
-    // Parse all messages and sort by Slack timestamp
-    // (attachment downloads can cause out-of-order logging)
-    const messages = [];
-    for (const line of lines) {
-        try {
-            messages.push(JSON.parse(line));
-        }
-        catch { }
-    }
-    messages.sort((a, b) => {
-        const tsA = parseFloat(a.ts || "0");
-        const tsB = parseFloat(b.ts || "0");
-        return tsA - tsB;
-    });
-    // Group into "turns" - a turn is either:
-    // - A single user message (isBot: false)
-    // - A sequence of consecutive bot messages (isBot: true) coalesced into one turn
-    // We walk backwards to get the last N turns
-    const turns = [];
-    let currentTurn = [];
-    let lastWasBot = null;
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const msg = messages[i];
-        const isBot = msg.isBot === true;
-        if (lastWasBot === null) {
-            // First message
-            currentTurn.unshift(msg);
-            lastWasBot = isBot;
-        }
-        else if (isBot && lastWasBot) {
-            // Consecutive bot messages - same turn
-            currentTurn.unshift(msg);
-        }
-        else {
-            // Transition - save current turn and start new one
-            turns.unshift(currentTurn);
-            currentTurn = [msg];
-            lastWasBot = isBot;
-            // Stop if we have enough turns
-            if (turns.length >= turnCount) {
-                break;
-            }
-        }
-    }
-    // Don't forget the last turn we were building
-    if (currentTurn.length > 0 && turns.length < turnCount) {
-        turns.unshift(currentTurn);
-    }
-    // Flatten turns back to messages and format as TSV
-    const formatted = [];
-    for (const turn of turns) {
-        for (const msg of turn) {
-            const date = (msg.date || "").substring(0, 19);
-            const user = msg.userName || msg.user || "";
-            const text = msg.text || "";
-            const attachments = (msg.attachments || []).map((a) => a.local).join(",");
-            formatted.push(`${date}\t${user}\t${text}\t${attachments}`);
-        }
-    }
-    return formatted.join("\n");
-}
 function getMemory(channelDir) {
     const parts = [];
     // Read workspace-level memory (shared across all channels)
@@ -155,13 +84,12 @@ function buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, chan
         : `You are running directly on the host machine.
 - Bash working directory: ${process.cwd()}
 - Be careful with system modifications`;
-    const currentDate = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
-    const currentDateTime = new Date().toISOString(); // Full ISO 8601
     return `You are mom, a Slack bot assistant. Be concise. No emojis.
 
 ## Context
-- Date: ${currentDate} (${currentDateTime})
-- You receive the last 50 conversation turns. If you need older context, search log.jsonl.
+- 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).
 
 ## Slack Formatting (mrkdwn, NOT Markdown)
 Bold: *text*, Italic: _text_, Code: \`code\`, Block: \`\`\`code\`\`\`, Links: <url|text>
@@ -183,7 +111,7 @@ ${workspacePath}/
 ├── skills/                      # Global CLI tools you create
 └── ${channelId}/                # This channel
     ├── MEMORY.md                # Channel-specific memory
-    ├── log.jsonl                # Full message history
+    ├── log.jsonl                # Message history (no tool results)
     ├── attachments/             # User-shared files
     ├── scratch/                 # Your working directory
     └── skills/                  # Channel-specific tools
@@ -212,36 +140,26 @@ Maintain ${workspacePath}/SYSTEM.md to log all environment modifications:
 
 Update this file whenever you modify the environment. On fresh container, read it first to restore your setup.
 
-## Log Queries (CRITICAL: limit output to avoid context overflow)
+## Log Queries (for older history)
 Format: \`{"date":"...","ts":"...","user":"...","userName":"...","text":"...","isBot":false}\`
-The log contains user messages AND your tool calls/results. Filter appropriately.
+The log contains user messages and your final responses (not tool calls/results).
 ${isDocker ? "Install jq: apk add jq" : ""}
 
-**Conversation only (excludes tool calls/results) - use for summaries:**
 \`\`\`bash
-# Recent conversation (no [Tool] or [Tool Result] lines)
-grep -v '"text":"\\[Tool' log.jsonl | tail -30 | jq -c '{date: .date[0:19], user: (.userName // .user), text}'
+# Recent messages
+tail -30 log.jsonl | jq -c '{date: .date[0:19], user: (.userName // .user), text}'
 
-# Yesterday's conversation
-grep '"date":"2025-11-26' log.jsonl | grep -v '"text":"\\[Tool' | jq -c '{date: .date[0:19], user: (.userName // .user), text}'
+# Search for specific topic
+grep -i "topic" log.jsonl | jq -c '{date: .date[0:19], user: (.userName // .user), text}'
 
-# Specific user's messages
-grep '"userName":"mario"' log.jsonl | grep -v '"text":"\\[Tool' | tail -20 | jq -c '{date: .date[0:19], text}'
-\`\`\`
-
-**Full details (includes tool calls) - use when you need technical context:**
-\`\`\`bash
-# Raw recent entries
-tail -20 log.jsonl | jq -c '{date: .date[0:19], user: (.userName // .user), text}'
-
-# Count all messages
-wc -l log.jsonl
+# Messages from specific user
+grep '"userName":"mario"' log.jsonl | tail -20 | jq -c '{date: .date[0:19], text}'
 \`\`\`
 
 ## Tools
 - bash: Run shell commands (primary tool). Install packages as needed.
 - read: Read files
-- write: Create/overwrite files  
+- write: Create/overwrite files
 - edit: Surgical file edits
 - attach: Share files to Slack
 
@@ -254,11 +172,9 @@ function truncate(text, maxLen) {
     return text.substring(0, maxLen - 3) + "...";
 }
 function extractToolResultText(result) {
-    // If it's already a string, return it
     if (typeof result === "string") {
         return result;
     }
-    // If it's an object with content array (tool result format)
     if (result &&
         typeof result === "object" &&
         "content" in result &&
@@ -274,16 +190,13 @@ function extractToolResultText(result) {
             return textParts.join("\n");
         }
     }
-    // Fallback to JSON
     return JSON.stringify(result);
 }
 function formatToolArgsForSlack(_toolName, args) {
     const lines = [];
     for (const [key, value] of Object.entries(args)) {
-        // Skip the label - it's already shown
         if (key === "label")
             continue;
-        // For read tool, format path with offset/limit
         if (key === "path" && typeof value === "string") {
             const offset = args.offset;
             const limit = args.limit;
@@ -295,10 +208,8 @@ function formatToolArgsForSlack(_toolName, args) {
             }
             continue;
         }
-        // Skip offset/limit since we already handled them
         if (key === "offset" || key === "limit")
             continue;
-        // For other values, format them
         if (typeof value === "string") {
             lines.push(value);
         }
@@ -308,259 +219,298 @@ function formatToolArgsForSlack(_toolName, args) {
     }
     return lines.join("\n");
 }
-export function createAgentRunner(sandboxConfig) {
-    let agent = null;
+// Cache runners per channel
+const channelRunners = new Map();
+/**
+ * Get or create an AgentRunner for a channel.
+ * Runners are cached - one per channel, persistent across messages.
+ */
+export function getOrCreateRunner(sandboxConfig, channelId, channelDir) {
+    const existing = channelRunners.get(channelId);
+    if (existing)
+        return existing;
+    const runner = createRunner(sandboxConfig, channelId, channelDir);
+    channelRunners.set(channelId, runner);
+    return runner;
+}
+/**
+ * Create a new AgentRunner for a channel.
+ * Sets up the session and subscribes to events once.
+ */
+function createRunner(sandboxConfig, channelId, channelDir) {
     const executor = createExecutor(sandboxConfig);
+    const workspacePath = executor.getWorkspacePath(channelDir.replace(`/${channelId}`, ""));
+    // Create tools
+    const tools = createMomTools(executor);
+    // Initial system prompt (will be updated each run with fresh memory/channels/users)
+    const memory = getMemory(channelDir);
+    const systemPrompt = buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, [], []);
+    // Create session manager and settings manager
+    // Pass model info so new sessions get a header written immediately
+    const sessionManager = new MomSessionManager(channelDir, {
+        provider: model.provider,
+        id: model.id,
+        thinkingLevel: "off",
+    });
+    const settingsManager = new MomSettingsManager(join(channelDir, ".."));
+    // Create agent
+    const agent = new Agent({
+        initialState: {
+            systemPrompt,
+            model,
+            thinkingLevel: "off",
+            tools,
+        },
+        messageTransformer,
+        transport: new ProviderTransport({
+            getApiKey: async () => getAnthropicApiKey(),
+        }),
+    });
+    // Load existing messages
+    const loadedSession = sessionManager.loadSession();
+    if (loadedSession.messages.length > 0) {
+        agent.replaceMessages(loadedSession.messages);
+        log.logInfo(`[${channelId}] Loaded ${loadedSession.messages.length} messages from context.jsonl`);
+    }
+    // Create AgentSession wrapper
+    const session = new AgentSession({
+        agent,
+        sessionManager: sessionManager,
+        settingsManager: settingsManager,
+    });
+    // Mutable per-run state - event handler references this
+    const runState = {
+        ctx: 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 },
+        },
+        stopReason: "stop",
+    };
+    // Subscribe to events ONCE
+    session.subscribe(async (event) => {
+        // Skip if no active run
+        if (!runState.ctx || !runState.logCtx || !runState.queue)
+            return;
+        const { ctx, logCtx, queue, pendingTools } = runState;
+        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,
+                startTime: Date.now(),
+            });
+            log.logToolStart(logCtx, agentEvent.toolName, label, agentEvent.args);
+            queue.enqueue(() => ctx.respond(`_→ ${label}_`, false), "tool label");
+        }
+        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);
+            const durationMs = pending ? Date.now() - pending.startTime : 0;
+            if (agentEvent.isError) {
+                log.logToolError(logCtx, agentEvent.toolName, durationMs, resultStr);
+            }
+            else {
+                log.logToolSuccess(logCtx, agentEvent.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```";
+            queue.enqueueMessage(threadMessage, "thread", "tool result thread", false);
+            if (agentEvent.isError) {
+                queue.enqueue(() => ctx.respond(`_Error: ${truncate(resultStr, 200)}_`, false), "tool error");
+            }
+        }
+        else if (event.type === "message_start") {
+            const agentEvent = event;
+            if (agentEvent.message.role === "assistant") {
+                log.logResponseStart(logCtx);
+            }
+        }
+        else if (event.type === "message_end") {
+            const agentEvent = event;
+            if (agentEvent.message.role === "assistant") {
+                const assistantMsg = agentEvent.message;
+                if (assistantMsg.stopReason) {
+                    runState.stopReason = assistantMsg.stopReason;
+                }
+                if (assistantMsg.usage) {
+                    runState.totalUsage.input += assistantMsg.usage.input;
+                    runState.totalUsage.output += assistantMsg.usage.output;
+                    runState.totalUsage.cacheRead += assistantMsg.usage.cacheRead;
+                    runState.totalUsage.cacheWrite += assistantMsg.usage.cacheWrite;
+                    runState.totalUsage.cost.input += assistantMsg.usage.cost.input;
+                    runState.totalUsage.cost.output += assistantMsg.usage.cost.output;
+                    runState.totalUsage.cost.cacheRead += assistantMsg.usage.cost.cacheRead;
+                    runState.totalUsage.cost.cacheWrite += assistantMsg.usage.cost.cacheWrite;
+                    runState.totalUsage.cost.total += assistantMsg.usage.cost.total;
+                }
+                const content = agentEvent.message.content;
+                const thinkingParts = [];
+                const textParts = [];
+                for (const part of content) {
+                    if (part.type === "thinking") {
+                        thinkingParts.push(part.thinking);
+                    }
+                    else if (part.type === "text") {
+                        textParts.push(part.text);
+                    }
+                }
+                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);
+                }
+                if (text.trim()) {
+                    log.logResponse(logCtx, text);
+                    queue.enqueueMessage(text, "main", "response main");
+                    queue.enqueueMessage(text, "thread", "response thread", false);
+                }
+            }
+        }
+        else if (event.type === "auto_compaction_start") {
+            log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
+            queue.enqueue(() => ctx.respond("_Compacting context..._", false), "compaction start");
+        }
+        else if (event.type === "auto_compaction_end") {
+            const compEvent = event;
+            if (compEvent.result) {
+                log.logInfo(`Auto-compaction complete: ${compEvent.result.tokensBefore} tokens compacted`);
+            }
+            else if (compEvent.aborted) {
+                log.logInfo("Auto-compaction aborted");
+            }
+        }
+        else if (event.type === "auto_retry_start") {
+            const retryEvent = event;
+            log.logWarning(`Retrying (${retryEvent.attempt}/${retryEvent.maxAttempts})`, retryEvent.errorMessage);
+            queue.enqueue(() => ctx.respond(`_Retrying (${retryEvent.attempt}/${retryEvent.maxAttempts})..._`, false), "retry");
+        }
+    });
+    // Slack message limit
+    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++;
+        }
+        return parts;
+    };
     return {
-        async run(ctx, channelDir, store) {
+        async run(ctx, _store, _pendingMessages) {
             // Ensure channel directory exists
             await mkdir(channelDir, { recursive: true });
-            const channelId = ctx.message.channel;
-            const workspacePath = executor.getWorkspacePath(channelDir.replace(`/${channelId}`, ""));
-            const recentMessages = getRecentMessages(channelDir, 50);
+            // Reload messages from context.jsonl
+            // This picks up any messages synced from log.jsonl before this run
+            const reloadedSession = sessionManager.loadSession();
+            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 and channel/user info
             const memory = getMemory(channelDir);
             const systemPrompt = buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, ctx.channels, ctx.users);
-            // Debug: log context sizes
-            log.logInfo(`Context sizes - system: ${systemPrompt.length} chars, messages: ${recentMessages.length} chars, memory: ${memory.length} chars`);
-            log.logInfo(`Channels: ${ctx.channels.length}, Users: ${ctx.users.length}`);
-            // Set up file upload function for the attach tool
-            // For Docker, we need to translate paths back to host
+            session.agent.setSystemPrompt(systemPrompt);
+            // Set up file upload function
             setUploadFunction(async (filePath, title) => {
                 const hostPath = translateToHostPath(filePath, channelDir, workspacePath, channelId);
                 await ctx.uploadFile(hostPath, title);
             });
-            // Create tools with executor
-            const tools = createMomTools(executor);
-            // Create ephemeral agent
-            agent = new Agent({
-                initialState: {
-                    systemPrompt,
-                    model,
-                    thinkingLevel: "off",
-                    tools,
-                },
-                transport: new ProviderTransport({
-                    getApiKey: async () => getAnthropicApiKey(),
-                }),
-            });
-            // Create logging context
-            const logCtx = {
+            // Reset per-run state
+            runState.ctx = ctx;
+            runState.logCtx = {
                 channelId: ctx.message.channel,
                 userName: ctx.message.userName,
                 channelName: ctx.channelName,
             };
-            // Track pending tool calls to pair args with results and timing
-            const pendingTools = new Map();
-            // Track usage across all assistant messages in this run
-            const totalUsage = {
+            runState.pendingTools.clear();
+            runState.totalUsage = {
                 input: 0,
                 output: 0,
                 cacheRead: 0,
                 cacheWrite: 0,
-                cost: {
-                    input: 0,
-                    output: 0,
-                    cacheRead: 0,
-                    cacheWrite: 0,
-                    total: 0,
-                },
-            };
-            // Track stop reason
-            let stopReason = "stop";
-            // Slack message limit is 40,000 characters - split into multiple messages if needed
-            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++;
-                }
-                return parts;
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             };
-            // Promise queue to ensure ctx.respond/respondInThread calls execute in order
-            // Handles errors gracefully by posting to thread instead of crashing
-            const queue = {
-                chain: Promise.resolve(),
+            runState.stopReason = "stop";
+            // Create queue for this run
+            let queueChain = Promise.resolve();
+            runState.queue = {
                 enqueue(fn, errorContext) {
-                    this.chain = this.chain.then(async () => {
+                    queueChain = queueChain.then(async () => {
                         try {
                             await fn();
                         }
                         catch (err) {
                             const errMsg = err instanceof Error ? err.message : String(err);
                             log.logWarning(`Slack API error (${errorContext})`, errMsg);
-                            // Try to post error to thread, but don't crash if that fails too
                             try {
                                 await ctx.respondInThread(`_Error: ${errMsg}_`);
                             }
                             catch {
-                                // Ignore - we tried our best
+                                // Ignore
                             }
                         }
                     });
                 },
-                // Enqueue a message that may need splitting
-                enqueueMessage(text, target, errorContext, log = true) {
+                enqueueMessage(text, target, errorContext, doLog = true) {
                     const parts = splitForSlack(text);
                     for (const part of parts) {
-                        this.enqueue(() => (target === "main" ? ctx.respond(part, log) : ctx.respondInThread(part)), errorContext);
+                        this.enqueue(() => (target === "main" ? ctx.respond(part, doLog) : ctx.respondInThread(part)), errorContext);
                     }
                 },
-                flush() {
-                    return this.chain;
-                },
             };
-            // Subscribe to events
-            agent.subscribe(async (event) => {
-                switch (event.type) {
-                    case "tool_execution_start": {
-                        const args = event.args;
-                        const label = args.label || event.toolName;
-                        // Store args to pair with result later
-                        pendingTools.set(event.toolCallId, {
-                            toolName: event.toolName,
-                            args: event.args,
-                            startTime: Date.now(),
-                        });
-                        // Log to console
-                        log.logToolStart(logCtx, event.toolName, label, event.args);
-                        // Log to jsonl
-                        await store.logMessage(ctx.message.channel, {
-                            date: new Date().toISOString(),
-                            ts: toSlackTs(),
-                            user: "bot",
-                            text: `[Tool] ${event.toolName}: ${JSON.stringify(event.args)}`,
-                            attachments: [],
-                            isBot: true,
-                        });
-                        // Show label in main message only
-                        queue.enqueue(() => ctx.respond(`_→ ${label}_`, false), "tool label");
-                        break;
-                    }
-                    case "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;
-                        // Log to console
-                        if (event.isError) {
-                            log.logToolError(logCtx, event.toolName, durationMs, resultStr);
-                        }
-                        else {
-                            log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
-                        }
-                        // Log to jsonl
-                        await store.logMessage(ctx.message.channel, {
-                            date: new Date().toISOString(),
-                            ts: toSlackTs(),
-                            user: "bot",
-                            text: `[Tool Result] ${event.toolName}: ${event.isError ? "ERROR: " : ""}${resultStr}`,
-                            attachments: [],
-                            isBot: true,
-                        });
-                        // Post args + result together in thread
-                        const label = pending?.args ? pending.args.label : undefined;
-                        const argsFormatted = pending
-                            ? formatToolArgsForSlack(event.toolName, pending.args)
-                            : "(args not found)";
-                        const duration = (durationMs / 1000).toFixed(1);
-                        let threadMessage = `*${event.isError ? "✗" : "✓"} ${event.toolName}*`;
-                        if (label) {
-                            threadMessage += `: ${label}`;
-                        }
-                        threadMessage += ` (${duration}s)\n`;
-                        if (argsFormatted) {
-                            threadMessage += "```\n" + argsFormatted + "\n```\n";
-                        }
-                        threadMessage += "*Result:*\n```\n" + resultStr + "\n```";
-                        queue.enqueueMessage(threadMessage, "thread", "tool result thread", false);
-                        // Show brief error in main message if failed
-                        if (event.isError) {
-                            queue.enqueue(() => ctx.respond(`_Error: ${truncate(resultStr, 200)}_`, false), "tool error");
-                        }
-                        break;
-                    }
-                    case "message_update": {
-                        // No longer stream to console - just track that we're streaming
-                        break;
-                    }
-                    case "message_start":
-                        if (event.message.role === "assistant") {
-                            log.logResponseStart(logCtx);
-                        }
-                        break;
-                    case "message_end":
-                        if (event.message.role === "assistant") {
-                            const assistantMsg = event.message; // AssistantMessage type
-                            // Track stop reason
-                            if (assistantMsg.stopReason) {
-                                stopReason = assistantMsg.stopReason;
-                            }
-                            // Accumulate usage
-                            if (assistantMsg.usage) {
-                                totalUsage.input += assistantMsg.usage.input;
-                                totalUsage.output += assistantMsg.usage.output;
-                                totalUsage.cacheRead += assistantMsg.usage.cacheRead;
-                                totalUsage.cacheWrite += assistantMsg.usage.cacheWrite;
-                                totalUsage.cost.input += assistantMsg.usage.cost.input;
-                                totalUsage.cost.output += assistantMsg.usage.cost.output;
-                                totalUsage.cost.cacheRead += assistantMsg.usage.cost.cacheRead;
-                                totalUsage.cost.cacheWrite += assistantMsg.usage.cost.cacheWrite;
-                                totalUsage.cost.total += assistantMsg.usage.cost.total;
-                            }
-                            // Extract thinking and text from assistant message
-                            const content = event.message.content;
-                            const thinkingParts = [];
-                            const textParts = [];
-                            for (const part of content) {
-                                if (part.type === "thinking") {
-                                    thinkingParts.push(part.thinking);
-                                }
-                                else if (part.type === "text") {
-                                    textParts.push(part.text);
-                                }
-                            }
-                            const text = textParts.join("\n");
-                            // Post thinking to main message and thread
-                            for (const thinking of thinkingParts) {
-                                log.logThinking(logCtx, thinking);
-                                queue.enqueueMessage(`_${thinking}_`, "main", "thinking main");
-                                queue.enqueueMessage(`_${thinking}_`, "thread", "thinking thread", false);
-                            }
-                            // Post text to main message and thread
-                            if (text.trim()) {
-                                log.logResponse(logCtx, text);
-                                queue.enqueueMessage(text, "main", "response main");
-                                queue.enqueueMessage(text, "thread", "response thread", false);
-                            }
-                        }
-                        break;
-                }
-            });
-            // Run the agent with user's message
-            // Prepend recent messages to the user prompt (not system prompt) for better caching
-            // The current message is already the last entry in recentMessages
-            const userPrompt = `Conversation history (last 50 turns). Respond to the last message.\n` +
-                `Format: date TAB user TAB text TAB attachments\n\n` +
-                recentMessages;
-            // Debug: write full context to file
-            const toolDefs = tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters }));
-            const debugPrompt = `=== SYSTEM PROMPT (${systemPrompt.length} chars) ===\n\n${systemPrompt}\n\n` +
-                `=== TOOL DEFINITIONS (${JSON.stringify(toolDefs).length} chars) ===\n\n${JSON.stringify(toolDefs, null, 2)}\n\n` +
-                `=== USER PROMPT (${userPrompt.length} chars) ===\n\n${userPrompt}`;
-            await writeFile(join(channelDir, "last_prompt.txt"), debugPrompt, "utf-8");
-            await agent.prompt(userPrompt);
-            // Wait for all queued respond calls to complete
-            await queue.flush();
-            // Get final assistant message text from agent state and replace main message
-            const messages = agent.state.messages;
+            // Log context info
+            log.logInfo(`Context sizes - system: ${systemPrompt.length} chars, memory: ${memory.length} chars`);
+            log.logInfo(`Channels: ${ctx.channels.length}, Users: ${ctx.users.length}`);
+            // Build user message with username prefix
+            // Format: "[username]: message" so LLM knows who's talking
+            let userMessage = `[${ctx.message.userName || "unknown"}]: ${ctx.message.text}`;
+            // Add attachment paths if any
+            if (ctx.message.attachments && ctx.message.attachments.length > 0) {
+                const attachmentPaths = ctx.message.attachments.map((a) => a.local).join("\n");
+                userMessage += `\n\nAttachments:\n${attachmentPaths}`;
+            }
+            // Debug: write context to last_prompt.jsonl
+            const debugContext = {
+                systemPrompt,
+                messages: session.messages,
+                newUserMessage: userMessage,
+            };
+            await writeFile(join(channelDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
+            await session.prompt(userMessage);
+            // Wait for queued messages
+            await queueChain;
+            // 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")
@@ -568,7 +518,6 @@ export function createAgentRunner(sandboxConfig) {
                 .join("\n") || "";
             if (finalText.trim()) {
                 try {
-                    // For the main message, truncate if too long (full text is in thread)
                     const mainText = finalText.length > SLACK_MAX_LENGTH
                         ? finalText.substring(0, SLACK_MAX_LENGTH - 50) + "\n\n_(see thread for full response)_"
                         : finalText;
@@ -579,16 +528,33 @@ export function createAgentRunner(sandboxConfig) {
                     log.logWarning("Failed to replace message with final text", errMsg);
                 }
             }
-            // Log usage summary if there was any usage
-            if (totalUsage.cost.total > 0) {
-                const summary = log.logUsageSummary(logCtx, totalUsage);
-                queue.enqueue(() => ctx.respondInThread(summary), "usage summary");
-                await queue.flush();
+            // 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;
+                const summary = log.logUsageSummary(runState.logCtx, runState.totalUsage, contextTokens, contextWindow);
+                runState.queue.enqueue(() => ctx.respondInThread(summary), "usage summary");
+                await queueChain;
             }
-            return { stopReason };
+            // Clear run state
+            runState.ctx = null;
+            runState.logCtx = null;
+            runState.queue = null;
+            return { stopReason: runState.stopReason };
         },
         abort() {
-            agent?.abort();
+            session.abort();
         },
     };
 }
@@ -597,17 +563,14 @@ export function createAgentRunner(sandboxConfig) {
  */
 function translateToHostPath(containerPath, channelDir, workspacePath, channelId) {
     if (workspacePath === "/workspace") {
-        // Docker mode - translate /workspace/channelId/... to host path
         const prefix = `/workspace/${channelId}/`;
         if (containerPath.startsWith(prefix)) {
             return join(channelDir, containerPath.slice(prefix.length));
         }
-        // Maybe it's just /workspace/...
         if (containerPath.startsWith("/workspace/")) {
             return join(channelDir, "..", containerPath.slice("/workspace/".length));
         }
     }
-    // Host mode or already a host path
     return containerPath;
 }
 //# sourceMappingURL=agent.js.map