agent-world 0.13.0 → 0.15.0

package/dist/core/events/memory-manager.js

@@ -20,6 +20,27 @@
  * - storage (runtime)
  *
  * Changes:
+ * - 2026-03-13: Phase 1 — weak fallback no-commit: `pickFallbackTitle` returns '' instead of 'Chat Session' so low-signal LLM results keep the chat in 'New Chat' state.
+ * - 2026-03-13: Phase 2 — bounded context window: `buildTitlePromptMessages` collects up to TITLE_CONTEXT_WINDOW_TURNS*2 recent user+assistant messages for richer prompt context.
+ * - 2026-03-13: Improved title-gen prompt: explicit @mention semantics, no-verbatim-copy rule, noun-phrase Title Case format constraint.
+ * - 2026-03-13: Title-generation LLM calls now strip world `reasoning_effort` so background title requests omit provider reasoning params by default.
+ * - 2026-03-06: Required explicit chat scope in memory-save/continuation/assistant-response paths; removed `world.currentChatId` fallback from agent event routing.
+ * - 2026-03-06: Normalized shell continuation parse/validation/policy failures through explicit canonical shell failure reasons and updated continuation comments to reflect bounded-preview tool persistence.
+ * - 2026-03-06: Collapsed shell continuation result-mode selection to one bounded-preview mode and normalized persisted shell tool failures through the canonical shell-result formatter.
+ * - 2026-02-28: Added canonical `message.publish` logs for assistant publish events in direct and continuation response paths.
+ * - 2026-02-27: Passed explicit chat scope to continuation system events (`publishEvent`) to prevent fallback routing to `world.currentChatId` during chat switches.
+ * - 2026-02-27: Suppress repeated identical `load_skill` tool calls within the same continuation run once a prior same-run load succeeded.
+ * - 2026-02-27: Added per-chat/agent continuation run lock in `continueLLMAfterToolExecution` to skip concurrent duplicate continuation runs while tools are pending/executing (prevents duplicate HITL approval prompts).
+ * - 2026-03-01: Expanded script-like shell command detection to treat path-based interpreter executables (for example `.venv/bin/python`) as script hosts so continuation prefers smart shell result mode after skill-driven script calls.
+ * - 2026-03-01: Generalized script-host detection for smart shell continuation mode to include additional interpreter families (`bash`, `node`, `deno`, `bun`, `ruby`, `perl`, `php`, `pwsh`) and `env <interpreter> script` invocation patterns.
+ * - 2026-03-01: Updated duplicate `shell_cmd` matching to ignore `output_format`/`output_detail` differences and redact those fields from continuation tool telemetry payloads.
+ * - 2026-02-26: Replaced `resumePendingToolCallsForChat` console traces with categorized structured logger events (`chat.restore.resume.tools`) for env-controlled restore diagnostics.
+ * - 2026-02-24: Commented out hardcoded Infinite-Etude handoff safeguard to respect separation of concerns (logic moved to agent prompt).
+ * - 2026-02-25: Added detailed resume tracing in `resumePendingToolCallsForChat` (start/skip/execute/error/continue) for cross-layer restore diagnostics.
+ * - 2026-02-25: Added duplicate messageId guard in `saveIncomingMessageToMemory` so chat-restore replay can re-emit pending user messages without duplicating persisted agent memory.
+ * - 2026-02-25: Added `resumePendingToolCallsForChat` to restore unresolved persisted tool calls (e.g. `load_skill`) on chat load/switch and continue the LLM loop.
+ * - 2026-02-21: Shell tool continuation context now requests minimal LLM result mode (`status`/`exit_code`) and passes agent name for assistant-stream shell SSE attribution.
+ * - 2026-02-20: Added Infinite-Etude handoff safeguard to enforce Pedagogue -> Engraver final mention when missing.
  * - 2026-02-16: Added plain-text tool-intent fallback parser in continuation to synthesize executable `tool_calls` when providers return `Calling tool: ...` text.
  * - 2026-02-16: Max tool-hop guardrail now emits UI/tool errors and injects transient LLM context, then continues loop instead of returning.
  * - 2026-02-16: Removed plain-text tool-intent reminder/retry path; continuation now relies only on tool-call loop + hop guardrail.
@@ -47,6 +68,8 @@ import { createCategoryLogger } from '../logger.js';
 import { beginWorldActivity } from '../activity-tracker.js';
 import { createStorageWithWrappers } from '../storage/storage-factory.js';
 import { generateAgentResponse } from '../llm-manager.js';
+import { formatShellToolErrorEnvelopeContent, } from '../shell-cmd-tool.js';
+import { createTextToolPreview, getToolEventPreviewPayload, parseToolExecutionEnvelopeContent, serializeToolExecutionEnvelope, stringifyToolExecutionResult, } from '../tool-execution-envelope.js';
 import { isMessageProcessingCanceledError, throwIfMessageProcessingStopped } from '../message-processing-control.js';
 import { shouldAutoMention, addAutoMention, hasAnyMentionAtBeginning, removeSelfMentions } from './mention-logic.js';
 import { publishMessageWithId, publishSSE, publishEvent, publishToolEvent, isStreamingEnabled } from './publishers.js';
@@ -56,8 +79,10 @@ const loggerAgent = createCategoryLogger('agent');
 const loggerTurnLimit = createCategoryLogger('turnlimit');
 const loggerChatTitle = createCategoryLogger('chattitle');
 const loggerAutoMention = createCategoryLogger('automention');
-const TITLE_PROMPT_MAX_TURNS = 24;
+const loggerRestoreResumeTools = createCategoryLogger('chat.restore.resume.tools');
+const loggerMessagePublish = createCategoryLogger('message.publish');
 const TITLE_PROMPT_MAX_CHARS_PER_TURN = 240;
+const TITLE_CONTEXT_WINDOW_TURNS = 3;
 // Storage wrapper instance - initialized lazily
 let storageWrappers = null;
 async function getStorageWrappers() {
@@ -66,6 +91,103 @@ async function getStorageWrappers() {
     }
     return storageWrappers;
 }
+const activeContinuationRuns = new Map();
+const continuationRunLoadedSkills = new Map();
+const continuationRunShellCommandResults = new Map();
+function normalizeContinuationChatId(chatId) {
+    if (chatId === undefined || chatId === null) {
+        return '__null__';
+    }
+    const normalized = String(chatId).trim();
+    return normalized || '__null__';
+}
+function getContinuationScopeKey(worldId, agentId, chatId) {
+    return `${worldId}::${agentId}::${normalizeContinuationChatId(chatId)}`;
+}
+function enterContinuationScope(scopeKey, runId) {
+    const activeRun = activeContinuationRuns.get(scopeKey);
+    if (!activeRun) {
+        activeContinuationRuns.set(scopeKey, { runId, depth: 1 });
+        return true;
+    }
+    if (activeRun.runId !== runId) {
+        return false;
+    }
+    activeRun.depth += 1;
+    return true;
+}
+function leaveContinuationScope(scopeKey, runId) {
+    const activeRun = activeContinuationRuns.get(scopeKey);
+    if (!activeRun || activeRun.runId !== runId) {
+        return;
+    }
+    activeRun.depth -= 1;
+    if (activeRun.depth <= 0) {
+        activeContinuationRuns.delete(scopeKey);
+    }
+}
+function isContinuationRunActive(runId) {
+    for (const activeRun of activeContinuationRuns.values()) {
+        if (activeRun.runId === runId) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLoadedSkillsForContinuationRun(runId) {
+    const existing = continuationRunLoadedSkills.get(runId);
+    if (existing) {
+        return existing;
+    }
+    const created = new Set();
+    continuationRunLoadedSkills.set(runId, created);
+    return created;
+}
+function getShellCommandResultsForContinuationRun(runId) {
+    const existing = continuationRunShellCommandResults.get(runId);
+    if (existing) {
+        return existing;
+    }
+    const created = new Map();
+    continuationRunShellCommandResults.set(runId, created);
+    return created;
+}
+function normalizeShellCommandParameterList(parameters) {
+    if (!Array.isArray(parameters)) {
+        return [];
+    }
+    return parameters.map((parameter) => String(parameter));
+}
+function buildShellCommandSignature(toolArgs, trustedWorkingDirectory) {
+    const command = String(toolArgs?.command || '').trim();
+    const parameters = normalizeShellCommandParameterList(toolArgs?.parameters);
+    const requestedDirectory = typeof toolArgs?.directory === 'string' && toolArgs.directory.trim()
+        ? toolArgs.directory.trim()
+        : trustedWorkingDirectory;
+    return JSON.stringify({
+        command,
+        parameters,
+        directory: requestedDirectory,
+    });
+}
+function sanitizeToolArgsForEventPayload(toolName, toolArgs) {
+    if (toolName !== 'shell_cmd' || !toolArgs || typeof toolArgs !== 'object') {
+        return toolArgs;
+    }
+    const sanitized = { ...toolArgs };
+    delete sanitized.output_format;
+    delete sanitized.output_detail;
+    return sanitized;
+}
+function cleanupContinuationRunState(runId) {
+    if (isContinuationRunActive(runId)) {
+        return;
+    }
+    continuationRunLoadedSkills.delete(runId);
+    continuationRunShellCommandResults.delete(runId);
+}
+// Fallback title candidates longer than this are likely full sentences/commands, not titles.
+const FALLBACK_TITLE_MAX_CHARS = 60;
 const GENERIC_TITLES = new Set([
     'chat',
     'new chat',
@@ -74,7 +196,9 @@ const GENERIC_TITLES = new Set([
     'title',
     'assistant chat',
     'user chat',
-    'chat title'
+    'chat title',
+    'chat session',
+    'session'
 ]);
 function normalizeTitlePromptText(content) {
     return content
@@ -88,34 +212,62 @@ function clipTitlePromptText(content) {
     }
     return `${content.substring(0, TITLE_PROMPT_MAX_CHARS_PER_TURN - 3)}...`;
 }
-function buildTitlePromptMessages(messages) {
-    const dedupKeys = new Set();
-    const filtered = [];
-    for (const message of messages) {
-        if (message.role !== 'user' && message.role !== 'assistant') {
-            continue;
-        }
-        if (typeof message.content !== 'string') {
+function selectTitleSourceUserMessage(messages, content) {
+    const contentCandidate = normalizeTitlePromptText(content || '');
+    if (contentCandidate) {
+        return clipTitlePromptText(contentCandidate);
+    }
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (!message || message.role !== 'user' || typeof message.content !== 'string') {
             continue;
         }
         const normalized = normalizeTitlePromptText(message.content);
         if (!normalized) {
             continue;
         }
-        const clipped = clipTitlePromptText(normalized);
-        const dedupKey = message.messageId
-            ? `id:${message.messageId}`
-            : `${message.role}:${clipped.toLowerCase()}`;
-        if (dedupKeys.has(dedupKey)) {
+        return clipTitlePromptText(normalized);
+    }
+    return '';
+}
+function buildTitlePromptMessages(messages, content) {
+    // Collect up to TITLE_CONTEXT_WINDOW_TURNS * 2 most recent eligible messages (user + assistant only).
+    const maxMessages = TITLE_CONTEXT_WINDOW_TURNS * 2;
+    const window = [];
+    for (let i = messages.length - 1; i >= 0 && window.length < maxMessages; i -= 1) {
+        const message = messages[i];
+        if (!message)
             continue;
-        }
-        dedupKeys.add(dedupKey);
-        filtered.push({
-            role: message.role,
-            content: clipped
+        const role = String(message.role || '').toLowerCase();
+        if (role !== 'user' && role !== 'assistant')
+            continue;
+        if (typeof message.content !== 'string')
+            continue;
+        const normalized = normalizeTitlePromptText(message.content);
+        if (!normalized)
+            continue;
+        window.unshift({
+            role: role,
+            content: clipTitlePromptText(normalized)
         });
     }
-    return filtered.slice(-TITLE_PROMPT_MAX_TURNS);
+    // Apply explicit content override to the last user slot (or append if none found).
+    const overrideText = normalizeTitlePromptText(content || '');
+    if (overrideText) {
+        const clipped = clipTitlePromptText(overrideText);
+        let replaced = false;
+        for (let i = window.length - 1; i >= 0; i -= 1) {
+            if (window[i].role === 'user') {
+                window[i] = { role: 'user', content: clipped };
+                replaced = true;
+                break;
+            }
+        }
+        if (!replaced) {
+            window.push({ role: 'user', content: clipped });
+        }
+    }
+    return window;
 }
 function sanitizeGeneratedTitle(rawTitle) {
     const firstLine = String(rawTitle || '').split(/\r?\n/).find((line) => line.trim()) || '';
@@ -125,13 +277,26 @@ function sanitizeGeneratedTitle(rawTitle) {
         .replace(/^[-*]\s+/, '')
         .replace(/^\d+[.)]\s+/, '')
         .replace(/^title\s*[:\-]\s*/i, '')
-        .replace(/^["'`]+|["'`]+$/g, '')
+        .replace(/\\"/g, '') // strip \" sequences before quote removal
+        .replace(/"/g, '') // strip all remaining double quotes
+        .replace(/^['`]+|['`]+$/g, '') // strip leading/trailing single quotes and backticks
         .replace(/[\r\n\*`_]+/g, ' ')
         .replace(/\s+/g, ' ')
         .trim();
     title = title.replace(/[.!?]+$/g, '').trim();
     return title;
 }
+function removeEnvVariableFromText(variablesText, key) {
+    const targetKey = String(key || '').trim();
+    if (!targetKey) {
+        return String(variablesText || '');
+    }
+    return String(variablesText || '')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith(`${targetKey}=`))
+        .join('\n');
+}
 function isLowQualityTitle(title) {
     if (!title)
         return true;
@@ -146,18 +311,20 @@ function isLowQualityTitle(title) {
 }
 function pickFallbackTitle(content, promptMessages) {
     const contentCandidate = sanitizeGeneratedTitle(content);
-    if (!isLowQualityTitle(contentCandidate)) {
+    if (!isLowQualityTitle(contentCandidate) && contentCandidate.length <= FALLBACK_TITLE_MAX_CHARS) {
         return contentCandidate;
     }
     for (const message of promptMessages) {
         if (message.role !== 'user')
             continue;
         const candidate = sanitizeGeneratedTitle(message.content);
-        if (!isLowQualityTitle(candidate)) {
+        if (!isLowQualityTitle(candidate) && candidate.length <= FALLBACK_TITLE_MAX_CHARS) {
             return candidate;
         }
     }
-    return 'Chat Session';
+    // No quality title found — return empty string so the caller retains 'New Chat'
+    // and the chat remains eligible for a future auto-title attempt.
+    return '';
 }
 function isTitleGenerationCanceledError(error) {
     if (!error)
@@ -196,6 +363,406 @@ function parseToolCallArguments(rawArguments) {
     }
     return {};
 }
+function getLoadSkillIdFromToolArgs(toolArgs) {
+    const skillId = typeof toolArgs?.skill_id === 'string' ? toolArgs.skill_id.trim() : '';
+    return skillId || null;
+}
+function getLoadSkillIdFromRawToolArguments(rawArguments) {
+    const parsed = parseToolCallArguments(rawArguments);
+    return getLoadSkillIdFromToolArgs(parsed);
+}
+function isSuccessfulLoadSkillResult(toolResult) {
+    const envelope = parseToolExecutionEnvelopeContent(toolResult);
+    const normalized = envelope
+        ? stringifyToolExecutionResult(envelope.result)
+        : String(toolResult || '');
+    return /<skill_context\b/i.test(normalized) && !/<error>/i.test(normalized);
+}
+function formatToolErrorContent(options) {
+    if (options.toolName === 'shell_cmd') {
+        return formatShellToolErrorEnvelopeContent({
+            command: options.toolArgs?.command,
+            parameters: options.toolArgs?.parameters,
+            error: options.error,
+            failureReason: options.failureReason,
+            toolCallId: options.toolCallId,
+        });
+    }
+    const message = `Error executing tool: ${options.error instanceof Error ? options.error.message : String(options.error)}`;
+    if (options.toolName === 'load_skill') {
+        return serializeToolExecutionEnvelope({
+            __type: 'tool_execution_envelope',
+            version: 1,
+            tool: 'load_skill',
+            tool_call_id: options.toolCallId,
+            status: 'failed',
+            preview: createTextToolPreview(message),
+            result: message,
+        });
+    }
+    return message;
+}
+function resolveShellContinuationLlmResultMode(options) {
+    if (options.toolName !== 'shell_cmd') {
+        return 'verbose';
+    }
+    return 'minimal';
+}
+function getLatestUnresolvedToolCallForChat(agent, chatId) {
+    const chatMessages = agent.memory.filter((message) => message.chatId === chatId);
+    if (!chatMessages.length) {
+        return null;
+    }
+    const completedToolCallIds = new Set();
+    for (const message of chatMessages) {
+        if (message.role === 'tool' && typeof message.tool_call_id === 'string' && message.tool_call_id.trim()) {
+            completedToolCallIds.add(message.tool_call_id.trim());
+        }
+    }
+    for (let index = chatMessages.length - 1; index >= 0; index--) {
+        const message = chatMessages[index];
+        if (message.role !== 'assistant' || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
+            continue;
+        }
+        for (const toolCall of message.tool_calls) {
+            const toolCallId = String(toolCall?.id || '').trim();
+            const toolName = String(toolCall?.function?.name || '').trim();
+            if (!toolCallId || !toolName) {
+                continue;
+            }
+            if (completedToolCallIds.has(toolCallId)) {
+                continue;
+            }
+            return {
+                assistantMessage: message,
+                toolCall: {
+                    id: toolCallId,
+                    function: {
+                        name: toolName,
+                        arguments: toolCall?.function?.arguments,
+                    },
+                },
+            };
+        }
+    }
+    return null;
+}
+export async function resumePendingToolCallsForChat(world, chatId, targetAssistantMessageId) {
+    if (!chatId) {
+        return 0;
+    }
+    const resumeStartedAt = Date.now();
+    loggerRestoreResumeTools.debug('Resume pending tool calls started', {
+        worldId: world.id,
+        chatId,
+        targetAssistantMessageId: targetAssistantMessageId || null,
+    });
+    const { getMCPToolsForWorld } = await import('../mcp-server-registry.js');
+    const mcpTools = await getMCPToolsForWorld(world.id);
+    const storage = await getStorageWrappers();
+    let resumedCount = 0;
+    for (const agent of world.agents.values()) {
+        const pending = getLatestUnresolvedToolCallForChat(agent, chatId);
+        if (!pending) {
+            loggerRestoreResumeTools.debug('Resume pending tool calls skipped agent with no pending tool call', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+            });
+            continue;
+        }
+        if (targetAssistantMessageId
+            && pending.assistantMessage.messageId
+            && pending.assistantMessage.messageId !== targetAssistantMessageId) {
+            loggerRestoreResumeTools.debug('Resume pending tool calls skipped assistant target mismatch', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                pendingAssistantMessageId: pending.assistantMessage.messageId || null,
+                targetAssistantMessageId,
+            });
+            continue;
+        }
+        const { assistantMessage, toolCall } = pending;
+        loggerRestoreResumeTools.debug('Resume pending tool calls found pending tool call', {
+            worldId: world.id,
+            chatId,
+            agentId: agent.id,
+            toolName: toolCall.function.name,
+            toolCallId: toolCall.id,
+            assistantMessageId: assistantMessage.messageId || null,
+        });
+        let toolArgs = {};
+        try {
+            toolArgs = parseToolCallArguments(toolCall.function.arguments);
+        }
+        catch (parseError) {
+            loggerRestoreResumeTools.warn('Resume pending tool calls failed to parse tool arguments', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+            });
+            const errorContent = toolCall.function.name === 'shell_cmd' || toolCall.function.name === 'load_skill'
+                ? formatToolErrorContent({
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    toolArgs,
+                    error: `Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+                    failureReason: 'validation_error',
+                })
+                : `Error executing tool: Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`;
+            const toolErrorMessage = {
+                role: 'tool',
+                content: errorContent,
+                tool_call_id: toolCall.id,
+                sender: agent.id,
+                createdAt: new Date(),
+                chatId,
+                messageId: generateId(),
+                replyToMessageId: assistantMessage.messageId,
+                agentId: agent.id,
+            };
+            agent.memory.push(toolErrorMessage);
+            if (assistantMessage.toolCallStatus) {
+                assistantMessage.toolCallStatus[toolCall.id] = { complete: true, result: errorContent };
+            }
+            await storage.saveAgent(world.id, agent);
+            await continueLLMAfterToolExecution(world, agent, chatId);
+            loggerRestoreResumeTools.debug('Resume pending tool calls continued after parse error', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                toolCallId: toolCall.id,
+            });
+            resumedCount += 1;
+            continue;
+        }
+        const toolDef = mcpTools[toolCall.function.name];
+        if (!toolDef) {
+            loggerRestoreResumeTools.warn('Resume pending tool calls tool definition missing', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+            });
+            const errorContent = toolCall.function.name === 'shell_cmd' || toolCall.function.name === 'load_skill'
+                ? formatToolErrorContent({
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    toolArgs,
+                    error: `Tool not found: ${toolCall.function.name}`,
+                    failureReason: 'execution_error',
+                })
+                : `Error executing tool: Tool not found: ${toolCall.function.name}`;
+            const toolErrorMessage = {
+                role: 'tool',
+                content: errorContent,
+                tool_call_id: toolCall.id,
+                sender: agent.id,
+                createdAt: new Date(),
+                chatId,
+                messageId: generateId(),
+                replyToMessageId: assistantMessage.messageId,
+                agentId: agent.id,
+            };
+            agent.memory.push(toolErrorMessage);
+            if (assistantMessage.toolCallStatus) {
+                assistantMessage.toolCallStatus[toolCall.id] = { complete: true, result: errorContent };
+            }
+            publishToolEvent(world, {
+                agentName: agent.id,
+                type: 'tool-error',
+                messageId: toolCall.id,
+                chatId,
+                toolExecution: {
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    input: toolArgs,
+                    error: `Tool not found: ${toolCall.function.name}`,
+                },
+            });
+            await storage.saveAgent(world.id, agent);
+            await continueLLMAfterToolExecution(world, agent, chatId);
+            loggerRestoreResumeTools.debug('Resume pending tool calls continued after missing tool definition', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                toolCallId: toolCall.id,
+            });
+            resumedCount += 1;
+            continue;
+        }
+        loggerRestoreResumeTools.debug('Resume pending tool calls executing tool', {
+            worldId: world.id,
+            chatId,
+            agentId: agent.id,
+            toolName: toolCall.function.name,
+            toolCallId: toolCall.id,
+        });
+        let seededLoadSkillIdForContinuation = null;
+        publishToolEvent(world, {
+            agentName: agent.id,
+            type: 'tool-start',
+            messageId: toolCall.id,
+            chatId,
+            toolExecution: {
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+                input: toolArgs,
+            },
+        });
+        try {
+            const trustedWorkingDirectory = String(getEnvValueFromText(world.variables, 'working_directory') || getDefaultWorkingDirectory()).trim() || getDefaultWorkingDirectory();
+            const toolContext = {
+                world,
+                messages: agent.memory,
+                toolCallId: toolCall.id,
+                chatId,
+                workingDirectory: trustedWorkingDirectory,
+                agentName: agent.id,
+                llmResultMode: resolveShellContinuationLlmResultMode({
+                    toolName: toolCall.function.name,
+                }),
+                persistToolEnvelope: toolCall.function.name === 'shell_cmd' || toolCall.function.name === 'load_skill',
+            };
+            const toolResult = await toolDef.execute(toolArgs, undefined, undefined, toolContext);
+            const serializedToolResult = typeof toolResult === 'string'
+                ? toolResult
+                : JSON.stringify(toolResult) ?? String(toolResult);
+            if (toolCall.function.name === 'load_skill') {
+                const requestedSkillId = getLoadSkillIdFromToolArgs(toolArgs);
+                if (requestedSkillId && isSuccessfulLoadSkillResult(serializedToolResult)) {
+                    seededLoadSkillIdForContinuation = requestedSkillId;
+                }
+            }
+            const toolResultMessage = {
+                role: 'tool',
+                content: serializedToolResult,
+                tool_call_id: toolCall.id,
+                sender: agent.id,
+                createdAt: new Date(),
+                chatId,
+                messageId: generateId(),
+                replyToMessageId: assistantMessage.messageId,
+                agentId: agent.id,
+            };
+            agent.memory.push(toolResultMessage);
+            if (assistantMessage.toolCallStatus) {
+                assistantMessage.toolCallStatus[toolCall.id] = {
+                    complete: true,
+                    result: serializedToolResult,
+                };
+            }
+            const toolEnvelope = parseToolExecutionEnvelopeContent(serializedToolResult);
+            const toolEventPreview = getToolEventPreviewPayload(serializedToolResult);
+            const toolEventResult = toolEnvelope ? toolEnvelope.result : toolResult;
+            publishToolEvent(world, {
+                agentName: agent.id,
+                type: 'tool-result',
+                messageId: toolCall.id,
+                chatId,
+                toolExecution: {
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    input: toolArgs,
+                    ...(toolEventPreview !== undefined ? { preview: toolEventPreview } : {}),
+                    result: toolEventResult,
+                    resultType: Array.isArray(toolEventResult)
+                        ? 'array'
+                        : toolEventResult === null
+                            ? 'null'
+                            : typeof toolEventResult === 'string'
+                                ? 'string'
+                                : 'object',
+                    resultSize: serializedToolResult.length,
+                },
+            });
+            loggerRestoreResumeTools.debug('Resume pending tool calls tool execution result persisted', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+                resultSize: serializedToolResult.length,
+            });
+        }
+        catch (toolError) {
+            loggerRestoreResumeTools.warn('Resume pending tool calls tool execution failed', {
+                worldId: world.id,
+                chatId,
+                agentId: agent.id,
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+                error: toolError instanceof Error ? toolError.message : String(toolError),
+            });
+            const errorContent = formatToolErrorContent({
+                toolName: toolCall.function.name,
+                toolCallId: toolCall.id,
+                toolArgs,
+                error: toolError,
+            });
+            const toolErrorMessage = {
+                role: 'tool',
+                content: errorContent,
+                tool_call_id: toolCall.id,
+                sender: agent.id,
+                createdAt: new Date(),
+                chatId,
+                messageId: generateId(),
+                replyToMessageId: assistantMessage.messageId,
+                agentId: agent.id,
+            };
+            agent.memory.push(toolErrorMessage);
+            if (assistantMessage.toolCallStatus) {
+                assistantMessage.toolCallStatus[toolCall.id] = {
+                    complete: true,
+                    result: errorContent,
+                };
+            }
+            publishToolEvent(world, {
+                agentName: agent.id,
+                type: 'tool-error',
+                messageId: toolCall.id,
+                chatId,
+                toolExecution: {
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    input: toolArgs,
+                    error: toolError instanceof Error ? toolError.message : String(toolError),
+                },
+            });
+        }
+        await storage.saveAgent(world.id, agent);
+        loggerRestoreResumeTools.debug('Resume pending tool calls saved agent state', {
+            worldId: world.id,
+            chatId,
+            agentId: agent.id,
+            toolCallId: toolCall.id,
+        });
+        await continueLLMAfterToolExecution(world, agent, chatId, {
+            ...(seededLoadSkillIdForContinuation ? { preloadedSkillIds: [seededLoadSkillIdForContinuation] } : {}),
+        });
+        loggerRestoreResumeTools.debug('Resume pending tool calls continued LLM after tool execution', {
+            worldId: world.id,
+            chatId,
+            agentId: agent.id,
+            toolCallId: toolCall.id,
+            ...(seededLoadSkillIdForContinuation ? { seededLoadSkillIdForContinuation } : {}),
+        });
+        resumedCount += 1;
+    }
+    loggerRestoreResumeTools.debug('Resume pending tool calls completed', {
+        worldId: world.id,
+        chatId,
+        resumedCount,
+        elapsedMs: Date.now() - resumeStartedAt,
+    });
+    return resumedCount;
+}
 function decodeControlTokens(value) {
     return value.replace(/<ctrl(\d+)>/gi, (_match, codeRaw) => {
         const code = Number(codeRaw);
@@ -341,15 +908,29 @@ export async function saveIncomingMessageToMemory(world, agent, messageEvent) {
         }
         // Derive chatId from the message event for concurrency-safe processing
         // This ensures messages stay bound to their originating session
-        const targetChatId = messageEvent.chatId ?? world.currentChatId ?? null;
+        const targetChatId = typeof messageEvent.chatId === 'string' ? messageEvent.chatId.trim() : '';
         if (!targetChatId) {
-            loggerMemory.warn('Saving message without chatId', {
+            loggerMemory.error('Saving message without explicit chatId', {
+                worldId: world.id,
                 agentId: agent.id,
                 messageId: messageEvent.messageId
             });
+            return;
         }
         // Parse message content to detect enhanced format (e.g., tool results)
         const { message: parsedMessage } = parseMessageContent(messageEvent.content, 'user');
+        if (messageEvent.messageId && targetChatId) {
+            const duplicate = agent.memory.some((message) => message.chatId === targetChatId && message.messageId === messageEvent.messageId);
+            if (duplicate) {
+                loggerMemory.debug('Skipping duplicate incoming message memory save', {
+                    worldId: world.id,
+                    agentId: agent.id,
+                    chatId: targetChatId,
+                    messageId: messageEvent.messageId,
+                });
+                return;
+            }
+        }
         const userMessage = {
             ...parsedMessage,
             sender: messageEvent.sender,
@@ -382,7 +963,37 @@ export async function saveIncomingMessageToMemory(world, agent, messageEvent) {
  * Used for auto-execution flow where tools are executed automatically
  */
 export async function continueLLMAfterToolExecution(world, agent, chatId, options) {
-    const completeActivity = beginWorldActivity(world, `agent:${agent.id}`, chatId ?? undefined);
+    const continuationChatId = typeof chatId === 'string' ? chatId.trim() : '';
+    if (!continuationChatId) {
+        throw new Error(`continueLLMAfterToolExecution: explicit chatId is required for agent ${agent.id}`);
+    }
+    const targetChatId = continuationChatId;
+    const continuationRunId = String(options?.continuationRunId || '').trim() || generateId();
+    const continuationScopeKey = getContinuationScopeKey(world.id, agent.id, continuationChatId);
+    const enteredScope = enterContinuationScope(continuationScopeKey, continuationRunId);
+    if (!enteredScope) {
+        loggerAgent.debug('Skipping duplicate continuation run while another run is active', {
+            worldId: world.id,
+            agentId: agent.id,
+            chatId: continuationChatId,
+        });
+        logToolBridge('CONTINUE SKIP_INFLIGHT', {
+            worldId: world.id,
+            agentId: agent.id,
+            chatId: continuationChatId,
+            responseType: 'skipped',
+        });
+        return;
+    }
+    const completeActivity = beginWorldActivity(world, `agent:${agent.id}`, targetChatId);
+    const loadedSkillsForRun = getLoadedSkillsForContinuationRun(continuationRunId);
+    const shellCommandResultsForRun = getShellCommandResultsForContinuationRun(continuationRunId);
+    for (const preloadedSkillId of options?.preloadedSkillIds || []) {
+        const normalizedSkillId = String(preloadedSkillId || '').trim();
+        if (normalizedSkillId) {
+            loadedSkillsForRun.add(normalizedSkillId);
+        }
+    }
     try {
         let hopCount = options?.hopCount ?? 0;
         const maxToolHops = 50;
@@ -390,25 +1001,25 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
         const maxEmptyTextRetries = 2;
         const emptyToolCallRetryCount = options?.emptyToolCallRetryCount ?? 0;
         const maxEmptyToolCallRetries = 2;
-        let transientGuardrailError;
+        let transientGuardrailError = options?.transientContinuationInstruction;
         if (hopCount > maxToolHops) {
             const guardrailErrorMessage = `[Error] Tool continuation exceeded ${maxToolHops} hops. Guardrail triggered; reporting error and continuing.`;
             const guardrailToolCallId = generateId();
             loggerAgent.error('Tool continuation hop limit reached; reporting error and continuing loop', {
                 agentId: agent.id,
-                chatId: chatId ?? world.currentChatId ?? null,
+                chatId: targetChatId,
                 hopCount,
                 maxToolHops,
             });
             publishEvent(world, 'system', {
                 message: guardrailErrorMessage,
                 type: 'error',
-            });
+            }, targetChatId);
             publishToolEvent(world, {
                 agentName: agent.id,
                 type: 'tool-error',
                 messageId: guardrailToolCallId,
-                chatId: chatId ?? world.currentChatId ?? null,
+                chatId: targetChatId,
                 toolExecution: {
                     toolName: '__tool_continuation_guardrail__',
                     toolCallId: guardrailToolCallId,
@@ -418,7 +1029,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             logToolBridge('CONTINUE HOP_GUARDRAIL', {
                 worldId: world.id,
                 agentId: agent.id,
-                chatId: chatId ?? world.currentChatId ?? null,
+                chatId: targetChatId,
                 hopCount,
                 maxToolHops,
                 guardrailToolCallId,
@@ -428,14 +1039,11 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             hopCount = 0;
         }
         throwIfMessageProcessingStopped(options?.abortSignal);
-        // Use explicit chatId when provided, fallback to world.currentChatId.
-        const targetChatId = chatId !== undefined ? chatId : world.currentChatId;
         // Filter memory to current chat only
         const currentChatMessages = agent.memory.filter(m => m.chatId === targetChatId);
         loggerAgent.debug('Continuing LLM execution with tool result in memory', {
             agentId: agent.id,
             targetChatId,
-            worldCurrentChatId: world.currentChatId,
             totalMemoryLength: agent.memory.length,
             currentChatLength: currentChatMessages.length,
             lastFewMessages: currentChatMessages.slice(-5).map(m => ({
@@ -446,7 +1054,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             }))
         });
         // Tool execution already happened before this function was called
-        // The tool result is already in memory with the actual stdout/stderr
+        // The canonical tool result is already in memory with bounded preview fields for shell output
         // Now prepare messages for LLM - loads fresh data from storage
         // Prepare messages with system prompt and complete conversation history
         const messages = await prepareMessagesForLLM(world.id, agent, targetChatId ?? null);
@@ -485,6 +1093,8 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
         }
         catch (error) {
             loggerAgent.error('Failed to save agent after LLM call increment', {
+                worldId: world.id,
+                chatId: targetChatId,
                 agentId: agent.id,
                 error: error instanceof Error ? error.message : error
             });
@@ -603,7 +1213,15 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                     ? firstInvalidToolCall.function.arguments
                     : '{}';
                 const malformedToolErrorContent = rawToolName
-                    ? `Error executing tool: Invalid tool call payload for '${rawToolName}'`
+                    ? rawToolName === 'shell_cmd' || rawToolName === 'load_skill'
+                        ? formatToolErrorContent({
+                            toolName: rawToolName,
+                            toolCallId,
+                            toolArgs: {},
+                            error: `Invalid tool call payload for '${rawToolName}'`,
+                            failureReason: 'validation_error',
+                        })
+                        : `Error executing tool: Invalid tool call payload for '${rawToolName}'`
                     : 'Error executing tool: Invalid tool call payload - empty or missing tool name';
                 loggerAgent.warn('Continuation returned tool_calls without executable tool; reporting tool error back to LLM context', {
                     agentId: agent.id,
@@ -689,7 +1307,10 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                 }
                 catch (error) {
                     loggerMemory.error('Failed to save malformed continuation tool error context', {
+                        worldId: world.id,
+                        chatId: targetChatId,
                         agentId: agent.id,
+                        toolCallId,
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
@@ -699,12 +1320,40 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                         ...options,
                         hopCount: hopCount + 1,
                         emptyToolCallRetryCount: emptyToolCallRetryCount + 1,
+                        continuationRunId,
                     });
                     return;
                 }
                 publishEvent(world, 'system', {
                     message: '[Warning] Agent repeatedly returned invalid tool calls after tool execution. Please refine the prompt.',
                     type: 'warning',
+                }, targetChatId);
+                return;
+            }
+            let requestedLoadSkillId = null;
+            if (toolCall.function.name === 'load_skill') {
+                try {
+                    requestedLoadSkillId = getLoadSkillIdFromRawToolArguments(toolCall.function.arguments);
+                }
+                catch {
+                    requestedLoadSkillId = null;
+                }
+            }
+            if (requestedLoadSkillId && loadedSkillsForRun.has(requestedLoadSkillId)) {
+                loggerAgent.debug('Suppressing duplicate load_skill call in continuation run', {
+                    worldId: world.id,
+                    agentId: agent.id,
+                    chatId: targetChatId,
+                    continuationRunId,
+                    skillId: requestedLoadSkillId,
+                    toolCallId: toolCall.id,
+                });
+                throwIfMessageProcessingStopped(options?.abortSignal);
+                await continueLLMAfterToolExecution(world, agent, targetChatId, {
+                    ...options,
+                    hopCount: hopCount + 1,
+                    continuationRunId,
+                    transientContinuationInstruction: `System notice: Suppressed duplicate load_skill("${requestedLoadSkillId}") in this run because the skill was already loaded. Continue the task using the existing skill context without calling load_skill again for this skill.`,
                 });
                 return;
             }
@@ -729,7 +1378,10 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             }
             catch (error) {
                 loggerMemory.error('Failed to save assistant tool_call message during continuation', {
+                    worldId: world.id,
+                    chatId: targetChatId,
                     agentId: agent.id,
+                    toolCallId: toolCall.id,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
@@ -751,7 +1403,15 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             if (!toolDef) {
                 const missingToolResult = {
                     role: 'tool',
-                    content: `Error executing tool: Tool not found: ${toolCall.function.name}`,
+                    content: toolCall.function.name === 'shell_cmd' || toolCall.function.name === 'load_skill'
+                        ? formatToolErrorContent({
+                            toolName: toolCall.function.name,
+                            toolCallId: toolCall.id,
+                            toolArgs: {},
+                            error: `Tool not found: ${toolCall.function.name}`,
+                            failureReason: 'execution_error',
+                        })
+                        : `Error executing tool: Tool not found: ${toolCall.function.name}`,
                     tool_call_id: toolCall.id,
                     sender: agent.id,
                     createdAt: new Date(),
@@ -783,17 +1443,27 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                 await continueLLMAfterToolExecution(world, agent, targetChatId, {
                     ...options,
                     hopCount: hopCount + 1,
+                    continuationRunId,
                 });
                 return;
             }
             let toolArgs = {};
             try {
                 toolArgs = parseToolCallArguments(toolCall.function.arguments);
+                requestedLoadSkillId = requestedLoadSkillId || getLoadSkillIdFromToolArgs(toolArgs);
             }
             catch (parseError) {
                 const parseErrorResult = {
                     role: 'tool',
-                    content: `Error executing tool: Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+                    content: toolCall.function.name === 'shell_cmd' || toolCall.function.name === 'load_skill'
+                        ? formatToolErrorContent({
+                            toolName: toolCall.function.name,
+                            toolCallId: toolCall.id,
+                            toolArgs,
+                            error: `Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+                            failureReason: 'validation_error',
+                        })
+                        : `Error executing tool: Invalid JSON in tool arguments: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
                     tool_call_id: toolCall.id,
                     sender: agent.id,
                     createdAt: new Date(),
@@ -825,9 +1495,77 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                 await continueLLMAfterToolExecution(world, agent, targetChatId, {
                     ...options,
                     hopCount: hopCount + 1,
+                    continuationRunId,
                 });
                 return;
             }
+            let shellCommandSignature = null;
+            const sanitizedToolArgsForEventPayload = sanitizeToolArgsForEventPayload(toolCall.function.name, toolArgs);
+            if (toolCall.function.name === 'shell_cmd') {
+                shellCommandSignature = buildShellCommandSignature(toolArgs, trustedWorkingDirectory);
+                const reusedShellCommandResult = shellCommandResultsForRun.get(shellCommandSignature);
+                if (reusedShellCommandResult !== undefined) {
+                    loggerAgent.debug('Suppressing duplicate shell_cmd call in continuation run', {
+                        worldId: world.id,
+                        agentId: agent.id,
+                        chatId: targetChatId,
+                        continuationRunId,
+                        toolCallId: toolCall.id,
+                    });
+                    const reusedToolResultMessage = {
+                        role: 'tool',
+                        content: reusedShellCommandResult,
+                        tool_call_id: toolCall.id,
+                        sender: agent.id,
+                        createdAt: new Date(),
+                        chatId: targetChatId,
+                        messageId: generateId(),
+                        replyToMessageId: messageId,
+                        agentId: agent.id,
+                    };
+                    agent.memory.push(reusedToolResultMessage);
+                    if (assistantToolCallMessage.toolCallStatus) {
+                        assistantToolCallMessage.toolCallStatus[toolCall.id] = {
+                            complete: true,
+                            result: reusedShellCommandResult,
+                        };
+                    }
+                    const reusedToolEnvelope = parseToolExecutionEnvelopeContent(reusedShellCommandResult);
+                    const reusedToolEventPreview = getToolEventPreviewPayload(reusedShellCommandResult);
+                    const reusedToolEventResult = reusedToolEnvelope ? reusedToolEnvelope.result : reusedShellCommandResult;
+                    publishToolEvent(world, {
+                        agentName: agent.id,
+                        type: 'tool-result',
+                        messageId: toolCall.id,
+                        chatId: targetChatId,
+                        toolExecution: {
+                            toolName: toolCall.function.name,
+                            toolCallId: toolCall.id,
+                            input: sanitizedToolArgsForEventPayload,
+                            ...(reusedToolEventPreview !== undefined ? { preview: reusedToolEventPreview } : {}),
+                            result: reusedToolEventResult,
+                            resultType: Array.isArray(reusedToolEventResult)
+                                ? 'array'
+                                : reusedToolEventResult === null
+                                    ? 'null'
+                                    : typeof reusedToolEventResult === 'string'
+                                        ? 'string'
+                                        : 'object',
+                            resultSize: reusedShellCommandResult.length,
+                            metadata: { reusedFromContinuationRun: true },
+                        },
+                    });
+                    const storage = await getStorageWrappers();
+                    await storage.saveAgent(world.id, agent);
+                    await continueLLMAfterToolExecution(world, agent, targetChatId, {
+                        ...options,
+                        hopCount: hopCount + 1,
+                        continuationRunId,
+                        transientContinuationInstruction: 'System notice: Suppressed duplicate shell_cmd call in this continuation run and reused its previous result. Continue from the existing command output without rerunning the same command.',
+                    });
+                    return;
+                }
+            }
             publishToolEvent(world, {
                 agentName: agent.id,
                 type: 'tool-start',
@@ -836,7 +1574,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                 toolExecution: {
                     toolName: toolCall.function.name,
                     toolCallId: toolCall.id,
-                    input: toolArgs,
+                    input: sanitizedToolArgsForEventPayload,
                     metadata: {
                         isStreaming: isStreamingEnabled(),
                     },
@@ -850,11 +1588,24 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                     chatId: targetChatId,
                     abortSignal: options?.abortSignal,
                     workingDirectory: trustedWorkingDirectory,
+                    agentName: agent.id,
+                    llmResultMode: resolveShellContinuationLlmResultMode({
+                        toolName: toolCall.function.name,
+                    }),
+                    persistToolEnvelope: toolCall.function.name === 'shell_cmd' || toolCall.function.name === 'load_skill',
                 };
                 const toolResult = await toolDef.execute(toolArgs, undefined, undefined, toolContext);
                 const serializedToolResult = typeof toolResult === 'string'
                     ? toolResult
                     : JSON.stringify(toolResult) ?? String(toolResult);
+                if (toolCall.function.name === 'load_skill'
+                    && requestedLoadSkillId
+                    && isSuccessfulLoadSkillResult(serializedToolResult)) {
+                    loadedSkillsForRun.add(requestedLoadSkillId);
+                }
+                if (toolCall.function.name === 'shell_cmd' && shellCommandSignature) {
+                    shellCommandResultsForRun.set(shellCommandSignature, serializedToolResult);
+                }
                 const toolResultMessage = {
                     role: 'tool',
                     content: serializedToolResult,
@@ -873,6 +1624,9 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                         result: serializedToolResult,
                     };
                 }
+                const toolEnvelope = parseToolExecutionEnvelopeContent(serializedToolResult);
+                const toolEventPreview = getToolEventPreviewPayload(serializedToolResult);
+                const toolEventResult = toolEnvelope ? toolEnvelope.result : toolResult;
                 publishToolEvent(world, {
                     agentName: agent.id,
                     type: 'tool-result',
@@ -881,21 +1635,27 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                     toolExecution: {
                         toolName: toolCall.function.name,
                         toolCallId: toolCall.id,
-                        input: toolArgs,
-                        result: serializedToolResult.slice(0, 4000),
-                        resultType: typeof toolResult === 'string'
-                            ? 'string'
-                            : Array.isArray(toolResult)
-                                ? 'array'
-                                : toolResult === null
-                                    ? 'null'
+                        input: sanitizedToolArgsForEventPayload,
+                        ...(toolEventPreview !== undefined ? { preview: toolEventPreview } : {}),
+                        result: toolEventResult,
+                        resultType: Array.isArray(toolEventResult)
+                            ? 'array'
+                            : toolEventResult === null
+                                ? 'null'
+                                : typeof toolEventResult === 'string'
+                                    ? 'string'
                                     : 'object',
                         resultSize: serializedToolResult.length,
                     },
                 });
             }
             catch (toolError) {
-                const errorContent = `Error executing tool: ${toolError instanceof Error ? toolError.message : String(toolError)}`;
+                const errorContent = formatToolErrorContent({
+                    toolName: toolCall.function.name,
+                    toolCallId: toolCall.id,
+                    toolArgs,
+                    error: toolError,
+                });
                 const toolErrorMessage = {
                     role: 'tool',
                     content: errorContent,
@@ -922,7 +1682,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                     toolExecution: {
                         toolName: toolCall.function.name,
                         toolCallId: toolCall.id,
-                        input: toolArgs,
+                        input: sanitizedToolArgsForEventPayload,
                         error: toolError instanceof Error ? toolError.message : String(toolError),
                     },
                 });
@@ -933,7 +1693,10 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             }
             catch (error) {
                 loggerMemory.error('Failed to save continuation tool result to memory', {
+                    worldId: world.id,
+                    chatId: targetChatId,
                     agentId: agent.id,
+                    toolCallId: toolCall.id,
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
@@ -941,6 +1704,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
             await continueLLMAfterToolExecution(world, agent, targetChatId, {
                 ...options,
                 hopCount: hopCount + 1,
+                continuationRunId,
             });
             return;
         }
@@ -964,6 +1728,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                 await continueLLMAfterToolExecution(world, agent, targetChatId, {
                     ...options,
                     emptyTextRetryCount: emptyTextRetryCount + 1,
+                    continuationRunId,
                 });
                 return;
             }
@@ -981,7 +1746,7 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
                 publishEvent(world, 'system', {
                     message: '[Warning] Agent returned empty follow-up after tool execution. Please retry or refine the prompt.',
                     type: 'warning'
-                });
+                }, targetChatId);
                 logToolBridge('CONTINUE EMPTY_TEXT_STOP', {
                     worldId: world.id,
                     agentId: agent.id,
@@ -1015,12 +1780,24 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
         }
         catch (error) {
             loggerMemory.error('Failed to save agent response after tool execution', {
+                worldId: world.id,
+                chatId: targetChatId,
                 agentId: agent.id,
+                messageId,
                 error: error instanceof Error ? error.message : String(error)
             });
         }
         // Publish the response message using the same messageId from streaming
         publishMessageWithId(world, sanitizedResponse, agent.id, messageId, targetChatId, undefined);
+        loggerMessagePublish.debug('Published assistant response message', {
+            worldId: world.id,
+            chatId: targetChatId,
+            agentId: agent.id,
+            messageId,
+            turnId: messageId,
+            responseLength: sanitizedResponse.length,
+            source: 'continuation',
+        });
         loggerAgent.debug('Agent response published after tool execution', {
             agentId: agent.id,
             messageId,
@@ -1031,46 +1808,61 @@ export async function continueLLMAfterToolExecution(world, agent, chatId, option
         if (isMessageProcessingCanceledError(error) || options?.abortSignal?.aborted) {
             loggerAgent.info('Skipped continuation after stop request', {
                 agentId: agent.id,
-                chatId: chatId ?? world.currentChatId ?? null,
+                chatId: targetChatId,
                 error: error instanceof Error ? error.message : String(error)
             });
             logToolBridge('CONTINUE CANCELED', {
                 worldId: world.id,
                 agentId: agent.id,
-                chatId: chatId ?? world.currentChatId ?? null,
+                chatId: targetChatId,
                 error: error instanceof Error ? error.message : String(error),
             });
             return;
         }
         loggerAgent.error('Failed to continue LLM after tool execution', {
+            worldId: world.id,
+            chatId: targetChatId,
             agentId: agent.id,
             error: error instanceof Error ? error.message : error
         });
         publishEvent(world, 'system', {
             message: `[Error] ${error.message}`,
             type: 'error'
-        });
+        }, targetChatId);
         logToolBridge('CONTINUE ERROR', {
             worldId: world.id,
             agentId: agent.id,
-            chatId: chatId ?? world.currentChatId ?? null,
+            chatId: targetChatId,
             error: error instanceof Error ? error.message : String(error),
         });
     }
     finally {
+        leaveContinuationScope(continuationScopeKey, continuationRunId);
+        cleanupContinuationRunState(continuationRunId);
         completeActivity();
     }
 }
 /**
  * Handle text response from LLM (extracted for clarity)
- * @param chatId - Explicit chat ID for concurrency-safe processing. If not provided, uses messageEvent.chatId or world.currentChatId.
+ * @param chatId - Explicit chat ID for concurrency-safe processing. When omitted, `messageEvent.chatId` is used.
  */
 export async function handleTextResponse(world, agent, responseText, messageId, messageEvent, chatId) {
-    // Derive target chatId: explicit parameter > message event > world.currentChatId
-    const targetChatId = chatId !== undefined ? chatId : (messageEvent.chatId ?? world.currentChatId ?? null);
+    const explicitChatId = typeof chatId === 'string' ? chatId.trim() : '';
+    const messageChatId = typeof messageEvent.chatId === 'string' ? messageEvent.chatId.trim() : '';
+    const targetChatId = explicitChatId || messageChatId;
+    if (!targetChatId) {
+        throw new Error(`handleTextResponse: explicit chatId is required for agent ${agent.id}`);
+    }
     const sanitizedResponse = removeSelfMentions(responseText, agent.id);
+    // const needsInfiniteEtudePedagogueHandoff =
+    //   world.id === 'infinite-etude' &&
+    //   agent.id === 'madame-pedagogue' &&
+    //   !/^\s*@monsieur-engraver\b/im.test(sanitizedResponse);
+    // const responseWithRequiredHandoff = needsInfiniteEtudePedagogueHandoff
+    //   ? `${sanitizedResponse.trimEnd()}\n\n@monsieur-engraver please render this.`
+    //   : sanitizedResponse;
     // Apply auto-mention logic if needed
-    let finalResponse = sanitizedResponse;
+    let finalResponse = sanitizedResponse; // responseWithRequiredHandoff;
     if (agent.autoReply !== false && shouldAutoMention(sanitizedResponse, messageEvent.sender, agent.id)) {
         finalResponse = addAutoMention(sanitizedResponse, messageEvent.sender);
         loggerAutoMention.debug('Auto-mention applied', {
@@ -1108,12 +1900,25 @@ export async function handleTextResponse(world, agent, responseText, messageId,
     }
     catch (error) {
         loggerMemory.error('Failed to save agent response', {
+            worldId: world.id,
+            chatId: targetChatId,
             agentId: agent.id,
+            messageId,
             error: error instanceof Error ? error.message : String(error)
         });
     }
     // Publish the response message using the same messageId from streaming
     publishMessageWithId(world, finalResponse, agent.id, messageId, targetChatId, messageEvent.messageId);
+    loggerMessagePublish.debug('Published assistant response message', {
+        worldId: world.id,
+        chatId: targetChatId,
+        agentId: agent.id,
+        messageId,
+        turnId: messageId,
+        replyToMessageId: messageEvent.messageId,
+        responseLength: finalResponse.length,
+        source: 'direct',
+    });
     loggerAgent.debug('Agent response published', {
         agentId: agent.id,
         messageId,
@@ -1156,10 +1961,7 @@ export async function generateChatTitleFromMessages(world, content, targetChatId
         const storage = await getStorageWrappers();
         // Load messages for the target chat only, not all messages.
         messages = targetChatId ? await storage.getMemory(world.id, targetChatId) : [];
-        if (content) {
-            messages.push({ role: 'user', content });
-        }
-        promptMessages = buildTitlePromptMessages(messages);
+        promptMessages = buildTitlePromptMessages(messages, content);
         loggerChatTitle.debug('Calling LLM for title generation', {
             messageCount: messages.length,
             promptMessageCount: promptMessages.length,
@@ -1170,19 +1972,22 @@ export async function generateChatTitleFromMessages(world, content, targetChatId
         const tempAgent = {
             provider: world.chatLLMProvider || firstAgent?.provider || 'openai',
             model: world.chatLLMModel || firstAgent?.model || 'gpt-4',
-            systemPrompt: 'You are a helpful assistant that turns conversations into concise titles.',
+            systemPrompt: 'You are a concise title generator. Given a conversation snippet, output a short noun-phrase title (3–6 words, Title Case). Rules: output the title only — no explanation, no punctuation at the end; never copy the user message verbatim; if the user message begins with @agentname, that is an agent mention — base the title on the topic or task after it, not on the mention itself.',
             maxTokens: 20,
         };
         const userPrompt = {
             role: 'user',
-            content: `Below is a conversation between a user and an assistant. Generate a short, punchy title (3–6 words) that captures its main topic.
-
-${promptMessages.map(msg => `-${msg.role}: ${msg.content}`).join('\n')}
-      `
+            content: `Generate a short title (3–6 words, Title Case) for this conversation.\nRules:\n- Do NOT copy the user message word-for-word.\n- An @name prefix (e.g. "@gemini") is an agent mention — base the title on the topic or task, not the mention.\n- Output the title only.\n\n${promptMessages.map(msg => `-${msg.role}: ${msg.content}`).join('\n')}`
+        };
+        const titleGenerationWorld = {
+            ...world,
+            // Force reasoning_effort=none so thinking models (e.g. Gemini 2.5 Flash)
+            // don't exhaust the maxOutputTokens budget on thinking before outputting text.
+            variables: removeEnvVariableFromText(world.variables, 'reasoning_effort') + '\nreasoning_effort=none',
         };
-        const { response: titleResponse } = await generateAgentResponse(world, tempAgent, [userPrompt], undefined, true, targetChatId); // skipTools = true for title generation
-        // Title generation should return plain text when skipTools=true; keep a guard for safety.
-        title = typeof titleResponse === 'string' ? titleResponse : '';
+        const { response: titleResponse } = await generateAgentResponse(titleGenerationWorld, tempAgent, [userPrompt], undefined, true, targetChatId); // skipTools = true for title generation
+        // LLMResponse is an object {type, content?} — extract the text content.
+        title = titleResponse?.type === 'text' ? (titleResponse?.content ?? '') : '';
         loggerChatTitle.debug('LLM generated title', { rawTitle: title });
     }
     catch (error) {