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

package/dist/agent.js

@@ -11,7 +11,7 @@ import { ActorExecutionResolver } from "./execution-resolver.js";
 import * as log from "./log.js";
 import { createExecutor } from "./sandbox.js";
 import { addLifecycleBreadcrumb, metricAttributes } from "./sentry.js";
-import { createManagedSessionFileAtPath, extractSessionSuffix, extractSessionUuid, forkThreadSessionFile, getChannelSessionDir, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, resolveManagedSessionFile, tryResolveThreadSession, } from "./session-store.js";
+import { extractSessionSuffix, extractSessionUuid, openManagedSession, } from "./session-store.js";
 import { createMamaTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
 const IMAGE_MIME_TYPES = {
@@ -24,6 +24,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)
@@ -123,8 +130,11 @@ function buildSystemPrompt(workspacePath, conversationId, conversationKind, curr
 ## 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.
 
 ${platform.formattingGuide}
 
@@ -144,7 +154,11 @@ ${workspacePath}/
 ├── 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
     └── skills/                  # Conversation-specific tools
@@ -204,7 +218,7 @@ You can schedule events that wake you up at specific times or when external thin
 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 and Credential Routing
-Set \`platform\` to the target bot platform (\`${platform.name}\` for this conversation). When only one platform is running, omitting \`platform\` is allowed for backward compatibility, but include it by default to avoid ambiguity.
+Set \`platform\` to the target bot platform (\`${platform.name}\` for this conversation). Include it explicitly to avoid ambiguity.
 
 Set \`userId\` to the platform userId of whoever asked for the event. When the event fires, tool execution routes using that user's vault selection in per-user modes. In \`container:<name>\`, events use the container's single shared vault.
 
@@ -251,7 +265,7 @@ ${memory}
 
 ## System Configuration Log
 Maintain ${workspacePath}/SYSTEM.md to log all environment modifications:
-- Installed packages (apk add, npm install, pip install)
+- Installed packages (apt install, npm install, uv pip install)
 - Environment variables set
 - Config files modified (~/.gitconfig, cron jobs, etc.)
 - Skill dependencies installed
@@ -261,7 +275,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" : ""}
+Use \`log.jsonl\` for quick grep-style history. Use \`${conversationPath}/sessions/\` when you need structured turns, tool outputs, or branch lineage.
+${isContainer ? "Install jq: apt-get install jq" : ""}
 ${isFirecracker ? "Install jq: apt-get install jq" : ""}
 
 \`\`\`bash
@@ -273,6 +288,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
@@ -290,6 +309,12 @@ function truncate(text, maxLen) {
         return text;
     return `${text.substring(0, maxLen - 3)}...`;
 }
+// Tools whose output is interesting in the structured session log but too noisy
+// to surface as a per-tool diagnostic to the user.
+const QUIET_TOOLS = new Set(["read", "write", "edit"]);
+// 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;
@@ -311,33 +336,6 @@ function extractToolResultText(result) {
     }
     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");
-}
 // ============================================================================
 // Agent runner
 // ============================================================================
@@ -348,7 +346,7 @@ function formatToolArgsForSlack(_toolName, args) {
  * Runner caching is handled by the caller (channelStates in main.ts).
  * This is a stateless factory function.
  */
-export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, vaultManager, bindingStore, provisioner) {
+export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, bindingStore, provisioner) {
     const agentConfig = loadAgentConfig(workspaceDir);
     // Initialize logger with settings from config
     log.initLogger({
@@ -363,6 +361,8 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             sandboxConfig.type === "image")
         ? new ActorExecutionResolver(sandboxConfig, vaultManager, bindingStore, provisioner)
         : 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);
@@ -391,52 +391,24 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
     const memory = await getMemory(conversationDir);
     const skills = loadMamaSkills(conversationDir, workspacePath);
     const emptyPlatform = {
-        name: "slack",
+        name: "chat",
         formattingGuide: "",
         channels: [],
         users: [],
     };
     const systemPrompt = buildSystemPrompt(workspacePath, conversationId, "shared", undefined, memory, sandboxConfig, emptyPlatform, skills);
-    // Create session manager and settings manager
-    // Conversation sessions use {conversationDir}/sessions/current.
-    // Thread sessions use fixed files: {conversationDir}/sessions/{threadTs}.jsonl
-    const sessionDir = getChannelSessionDir(conversationDir);
+    // 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(":");
-    let sessionManager;
-    let contextFile;
-    if (isThread) {
-        const threadFile = getThreadSessionFile(conversationDir, sessionKey);
-        const existing = tryResolveThreadSession(threadFile);
-        if (existing) {
-            contextFile = existing;
-            sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
-        }
-        else {
-            const conversationSource = resolveChannelSessionFile(conversationDir);
-            if (conversationSource) {
-                try {
-                    contextFile = forkThreadSessionFile(conversationSource, threadFile, conversationDir);
-                    sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
-                }
-                catch {
-                    contextFile = createManagedSessionFileAtPath(threadFile, conversationDir);
-                    sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
-                }
-            }
-            else {
-                contextFile = createManagedSessionFileAtPath(threadFile, conversationDir);
-                sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
-            }
-        }
-    }
-    else {
-        // Direct/shared session: normal resolve
-        contextFile = resolveManagedSessionFile(sessionDir, conversationDir);
-        sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
+    const rootTs = extractSessionSuffix(sessionKey);
+    const { sessionDir, contextFile, threadRootMessage } = sessionScope;
+    const sessionManager = openManagedSession(contextFile, sessionDir, conversationDir);
+    const threadSessionName = buildThreadSessionName(threadRootMessage);
+    if (isThread && threadSessionName && sessionManager.getSessionName() !== threadSessionName) {
+        sessionManager.appendSessionInfo(threadSessionName);
     }
     const sessionUuid = extractSessionUuid(contextFile);
-    // Used for Slack thread filtering — for non-Slack platforms this is effectively a no-op
-    const rootTs = extractSessionSuffix(sessionKey);
     const settingsManager = createMamaSettingsManager(join(conversationDir, ".."));
     // Create AuthStorage and ModelRegistry
     // Auth stored outside workspace so agent can't access it
@@ -534,8 +506,6 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 ...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).
         }
         else if (event.type === "tool_execution_end") {
             const agentEvent = event;
@@ -569,24 +539,16 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             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\`\`\``;
-            // 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 (!QUIET_TOOLS.has(agentEvent.toolName)) {
+                const toolResult = {
+                    toolName: agentEvent.toolName,
+                    label: pending?.args ? pending.args.label : undefined,
+                    args: pending?.args,
+                    result: truncate(resultStr, TOOL_RESULT_DIAGNOSTIC_CAP),
+                    isError: agentEvent.isError,
+                    durationMs,
+                };
+                queue.enqueue(() => responseCtx.respondToolResult(toolResult), "tool result diagnostic");
             }
             if (agentEvent.isError) {
                 queue.enqueue(() => responseCtx.respond(`_Error: ${truncate(resultStr, 200)}_`), "tool error");
@@ -678,16 +640,12 @@ 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");
                 }
             }
         }
@@ -710,23 +668,6 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             queue.enqueue(() => responseCtx.respond(`_Retrying (${retryEvent.attempt}/${retryEvent.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++;
-        }
-        return parts;
-    };
     return {
         async run(message, responseCtx, platform) {
             // Extract conversationId from sessionKey (format: "conversationId:rootTs" or just "conversationId")
@@ -769,6 +710,11 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 conversationId,
                 conversationKind: message.conversationKind,
                 userId: message.userId,
+                sessionKey: message.sessionKey,
+                // For Slack scheduled events, preserve thread targeting only when the
+                // request was created inside an existing thread. Top-level reminders
+                // should come back as top-level messages.
+                threadTs: message.threadTs,
             });
             // Set up file upload function
             setUploadFunction(async (filePath, title) => {
@@ -806,11 +752,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                             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);
-                                }
+                                await responseCtx.respondDiagnostic(`Error: ${errMsg}`, { style: "error" });
                             }
                             catch {
                                 // Ignore
@@ -818,12 +760,6 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                         }
                     });
                 },
-                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`);
@@ -887,11 +823,9 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             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);
-                    }
+                    await responseCtx.respondDiagnostic(`Error: ${runState.errorMessage}`, {
+                        style: "error",
+                    });
                 }
                 catch (err) {
                     const errMsg = err instanceof Error ? err.message : String(err);
@@ -919,10 +853,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 }
                 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);
+                        await responseCtx.replaceResponse(finalText);
                     }
                     catch (err) {
                         const errMsg = err instanceof Error ? err.message : String(err);
@@ -975,12 +906,10 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                     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");
+                if (platform.diagnostics?.showUsageSummary === true) {
+                    runState.queue.enqueue(() => responseCtx.respondDiagnostic(summary, { style: "muted" }), "usage summary");
+                    await queueChain;
                 }
-                await queueChain;
             }
             // Clear run state
             runState.responseCtx = null;