n8n-nodes-tembory 1.0.30 → 1.0.32

package/README.md

@@ -2,7 +2,13 @@
 
 Node de memoria operacional da Tembory para agentes de IA no n8n.
 
-Versao atual: `1.0.30`.
+Versao atual: `1.0.31`.
+
+## 1.0.31
+
+- Considera pre-reserva recente no transcript como estado operacional valido quando `tool_history` ainda nao foi recuperado no turno.
+- Evita chamar `agenda_pre_reservar_horario` novamente antes de confirmar quando a mensagem recente ja diz que houve pre-reserva.
+- Direciona confirmacoes como "pode confirmar" direto para `agenda_confirmar_agendamento` quando existe pre-reserva recente pendente.
 
 ## 1.0.30
 

package/dist/nodes/Mem0/Mem0Memory.node.js

@@ -295,7 +295,7 @@ const extractProfileFactsFromText = (text, source = 'message', at = nowIso()) =>
     const canExtractStrongProfileFacts = sourceName !== 'assistant_message';
     if (!content.trim())
         return facts;
-    if (/\[Used tools:|Calling\s+agenda_|"tool"\s*:|"args"\s*:|confirmation_id|reservation_id/i.test(content))
+    if (/\[Used tools:|Calling\s+[A-Za-z_][A-Za-z0-9_.:-]*|"tool"\s*:|"args"\s*:|confirmation_id|reservation_id/i.test(content))
         return facts;
     const email = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i.exec(content);
     if (email && canExtractStrongProfileFacts)
@@ -407,53 +407,63 @@ const safeParseToolPayload = (value) => {
 };
 const compactToolPayload = (value) => truncate(typeof value === 'string' ? value : safeStringify(value), 900);
 const maybeToolResult = (tool, includeResults = true) => includeResults === false ? undefined : compactToolPayload(safeParseToolPayload(tool === null || tool === void 0 ? void 0 : tool.result));
-const containsSelectedSlot = (text = '') => /\b(?:às|as|das|para)?\s*\d{1,2}(?::\d{2}|h\d{0,2})?\b/i.test(String(text || '')) || /\b\d{1,2}\/\d{1,2}(?:\/\d{2,4})?\b/.test(String(text || ''));
-const availabilityFromRecentMessages = (recentMessages = []) => {
-    const messages = Array.isArray(recentMessages) ? recentMessages : [];
-    const candidates = [...messages].reverse().filter((message) => {
-        const role = String(message.role || '').toLowerCase();
-        const text = String(message.content || message.text || message.memory || '');
-        if (role && role !== 'assistant' && role !== 'ai' && role !== 'system')
-            return false;
-        return /\b(?:tem|tenho|há|ha)\s+vagas?\b|\bop[cç][oõ]es?\s+dispon[ií]veis\b|\bavailable_slots\b/i.test(text)
-            && (/\b\d{1,2}\/\d{1,2}(?:\/\d{2,4})?\b/.test(text) || /\b\d{1,2}:\d{2}\b/.test(text));
-    });
-    const latest = candidates[0];
-    if (!latest)
-        return null;
-    return {
-        text: truncate(String(latest.content || latest.text || latest.memory || ''), 900),
-        at: latest.at || latest.created_at || latest.createdAt || nowIso(),
-        source: latest.source || 'recent_message',
-    };
+const isToolName = (value = '') => /^[A-Za-z_][A-Za-z0-9_.:-]{1,127}$/.test(String(value || ''));
+const pickRequiredToolFromAction = (text = '') => {
+    const next = String(text || '');
+    const protectedCall = /\bdo not call\s+([A-Za-z_][A-Za-z0-9_.:-]{1,127})\b[\s\S]*?\bcall\s+([A-Za-z_][A-Za-z0-9_.:-]{1,127})\b/i.exec(next);
+    if (protectedCall && isToolName(protectedCall[2]))
+        return protectedCall[2];
+    if (/\bdo not call\b/i.test(next))
+        return '';
+    const mustCall = /\bMUST\s+call\s+([A-Za-z_][A-Za-z0-9_.:-]{1,127})\b/i.exec(next);
+    if (mustCall && isToolName(mustCall[1]))
+        return mustCall[1];
+    const call = /\bcall\s+([A-Za-z_][A-Za-z0-9_.:-]{1,127})\b/i.exec(next);
+    if (call && isToolName(call[1]))
+        return call[1];
+    return '';
 };
 const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessages = [], includeResults = true) => {
     const tools = Array.isArray(toolHistory) ? toolHistory : [];
     const successfulTools = tools.filter((tool) => tool.ok !== false);
-    const byName = (name) => successfulTools.filter((tool) => tool.name === name);
-    const availability = byName('agenda_consultar_disponibilidade');
-    const recentAvailability = availability.length ? null : availabilityFromRecentMessages(recentMessages);
-    const hasAvailability = availability.length > 0 || Boolean(recentAvailability);
-    const reservations = byName('agenda_pre_reservar_horario');
-    const confirmations = byName('agenda_confirmar_agendamento');
+    const failedTools = tools.filter((tool) => tool.ok === false);
+    const toolCountsByName = {};
+    const latestByName = {};
+    const failedByName = {};
+    const recentSequence = [];
+    for (let index = 0; index < tools.length; index += 1) {
+        const tool = tools[index];
+        const name = String(tool.name || 'unknown_tool');
+        const compactInput = compactToolPayload(safeParseToolPayload(tool.input));
+        const compactResult = maybeToolResult(tool, includeResults);
+        const reason = truncate(String(tool.reason || tool.decision || tool.why || tool.source || 'recorded tool call'), 260);
+        toolCountsByName[name] = (toolCountsByName[name] || 0) + 1;
+        latestByName[name] = {
+            name,
+            ok: tool.ok !== false,
+            at: tool.at || null,
+            input: compactInput,
+            result: compactResult,
+            reason,
+            source: tool.source || 'unknown',
+        };
+        recentSequence.push(cleanContextValue({
+            sequence: tool.sequence || index + 1,
+            tool: name,
+            status: tool.ok === false ? 'failed' : 'ok',
+            at: tool.at || null,
+            reason,
+            input: compactInput,
+            output: compactResult,
+        }));
+        if (tool.ok === false)
+            failedByName[name] = (failedByName[name] || 0) + 1;
+    }
     const lastTool = tools[tools.length - 1] || null;
-    const lastReservation = reservations[reservations.length - 1] || null;
-    const lastConfirmation = confirmations[confirmations.length - 1] || null;
-    const hasPendingReservation = Boolean(lastReservation && (!lastConfirmation || String(lastReservation.at || '') > String(lastConfirmation.at || '')));
     const blockedWithoutContext = [];
-    if (!hasAvailability)
-        blockedWithoutContext.push('agenda_pre_reservar_horario');
-    if (!reservations.length)
-        blockedWithoutContext.push('agenda_confirmar_agendamento');
-    const guidance = [];
-    if (!hasAvailability)
-        guidance.push('No availability result is known for this session; consult availability before reserving or confirming.');
-    else if (hasPendingReservation)
-        guidance.push('A pre-reservation exists after the latest confirmation; confirmation can use the latest pre-reservation context.');
-    else if (lastConfirmation)
-        guidance.push('The latest reservation appears confirmed; do not confirm again unless the user explicitly asks to repeat or change it.');
-    else if (hasAvailability)
-        guidance.push('Availability is known; if the user chooses one listed slot, reserve without repeating availability.');
+    const guidance = [
+        'Use tool_state and action_ledger as the source of truth for prior tool calls, inputs, outputs, failures and decisions. Domain-specific tool policy must come from the agent prompt, not from memory.',
+    ];
     return {
         profile_complete: Boolean(profileFacts && profileFacts.name && profileFacts.company && profileFacts.email && profileFacts.phone),
         last_tool: lastTool ? { name: lastTool.name, ok: lastTool.ok, at: lastTool.at } : null,
@@ -461,19 +471,22 @@ const deriveOperationalState = (toolHistory = [], profileFacts = {}, recentMessa
             total: tools.length,
             ok: successfulTools.length,
             failed: tools.length - successfulTools.length,
-            agenda_consultar_disponibilidade: availability.length,
-            agenda_pre_reservar_horario: reservations.length,
-            agenda_confirmar_agendamento: confirmations.length,
+            by_name: toolCountsByName,
         },
-        agenda_state: {
-            has_availability: hasAvailability,
-            has_pre_reservation: reservations.length > 0,
-            has_confirmation: confirmations.length > 0,
-            has_pending_pre_reservation: hasPendingReservation,
-            latest_availability_result: availability.length ? maybeToolResult(availability[availability.length - 1], includeResults) : (recentAvailability && includeResults !== false ? recentAvailability.text : null),
-            latest_availability_source: availability.length ? 'tool_history' : (recentAvailability ? recentAvailability.source : null),
-            latest_pre_reservation_result: lastReservation ? maybeToolResult(lastReservation, includeResults) : null,
-            latest_confirmation_result: lastConfirmation ? maybeToolResult(lastConfirmation, includeResults) : null,
+        tool_state: {
+            total: tools.length,
+            ok: successfulTools.length,
+            failed: failedTools.length,
+            names: Object.keys(toolCountsByName),
+            counts_by_name: toolCountsByName,
+            failed_by_name: failedByName,
+            latest_by_name: latestByName,
+            recent_sequence: pruneByLimit(recentSequence, 20),
+            last_successful_tool: successfulTools.length ? {
+                name: successfulTools[successfulTools.length - 1].name,
+                at: successfulTools[successfulTools.length - 1].at || null,
+                result: maybeToolResult(successfulTools[successfulTools.length - 1], includeResults),
+            } : null,
         },
         blocked_without_context: Array.from(new Set(blockedWithoutContext)),
         guidance,
@@ -488,6 +501,7 @@ const deriveActionLedger = (toolHistory = [], maxItems = 20, includeResults = tr
         kind: 'tool_call',
         name: tool.name || 'unknown_tool',
         status: tool.ok === false ? 'failed' : 'ok',
+        reason: truncate(String(tool.reason || tool.decision || tool.why || tool.source || 'recorded tool call'), 260),
         input: compactToolPayload(safeParseToolPayload(tool.input)),
         result: maybeToolResult(tool, includeResults),
         at: tool.at || null,
@@ -664,7 +678,7 @@ const toolHistoryFromMemory = (item) => {
             source: 'semantic_fact',
         };
     }
-    const namedTool = meta.kind === 'tool_history' ? /(?:tool|ferramenta)\s+([A-Za-z0-9_.:-]*(?:agenda_[A-Za-z0-9_.:-]+)[A-Za-z0-9_.:-]*)/i.exec(String(content || '')) : null;
+    const namedTool = meta.kind === 'tool_history' ? /(?:tool|ferramenta)\s+([A-Za-z_][A-Za-z0-9_.:-]{1,127})/i.exec(String(content || '')) : null;
     if (namedTool) {
         return {
             id: meta.id || meta.call_id || meta.callId || '',
@@ -677,26 +691,6 @@ const toolHistoryFromMemory = (item) => {
             source: 'semantic_named_tool',
         };
     }
-    const text = meta.kind === 'tool_history' ? String(content || '').toLowerCase() : '';
-    const inferredAgendaTool = text.includes('confirm') && text.includes('agendamento')
-        ? 'agenda_confirmar_agendamento'
-        : text.includes('pré-reserva') || text.includes('pre-reserva') || text.includes('pre reserva') || text.includes('pré reserva')
-            ? 'agenda_pre_reservar_horario'
-            : (text.includes('horários disponíveis') || text.includes('horarios disponiveis') || text.includes('available') || text.includes('disponibilidade')) && text.includes('agenda')
-                ? 'agenda_consultar_disponibilidade'
-                : '';
-    if (inferredAgendaTool) {
-        return {
-            id: meta.id || meta.call_id || meta.callId || '',
-            turnId: meta.turn_id || meta.turnId || '',
-            name: inferredAgendaTool,
-            input: '',
-            ok: true,
-            result: truncate(content || '', 1000),
-            at: meta.at || item.created_at || item.createdAt || nowIso(),
-            source: 'semantic_inference',
-        };
-    }
     if (meta.kind !== 'tool_history')
         return null;
     const name = meta.name || meta.tool || meta.toolName;
@@ -1246,17 +1240,18 @@ const normalizeIntentText = (value = '') => String(value || '')
     .toLowerCase()
     .normalize('NFD')
     .replace(/[\u0300-\u036f]/g, '');
-const hasConfirmIntent = (value = '') => /\b(confirm\w*|confim\w*|cnfirm\w*|cofnirm\w*|ocnfi\w*|ocnfia\w*|fechar)\b/.test(normalizeIntentText(value));
+const hasCommitIntent = (value = '') => /\b(confirm\w*|confim\w*|cnfirm\w*|cofnirm\w*|ocnfi\w*|ocnfia\w*|fechar|aprovar|finalizar|prosseguir|continuar|sim)\b/.test(normalizeIntentText(value));
 const isConversationRecallQuery = (value = '') => {
     const text = normalizeIntentText(value);
     return /\b(minha|qual|quais|o que|oq|voce|vc|lembra|lembrar|sabe|diga|fala)\b.{0,80}\b(ultima|ultimas|msg|msgs|mensagem|mensagens|pergunta|perguntei|falei|disse)\b/.test(text)
         || /\b(o que|oq)\b.{0,30}\b(eu)\b.{0,30}\b(falei|disse|perguntei|mandei)\b/.test(text)
         || /\b(nao|nao)\b.{0,20}\b(lembra|sabe)\b.{0,60}\b(msg|msgs|mensagem|pergunta|falei|disse|perguntei)\b/.test(text);
 };
-const isAgendaStatusQuery = (value = '') => {
+const isOperationalStatusQuery = (value = '') => {
     const text = normalizeIntentText(value);
-    return /\b(ja|ainda|tinha|tenho|foi|esta|ta)\b.{0,60}\b(agend\w*|agned\w*|ganed\w*|marc\w*|reserv\w*|confirm\w*)\b/.test(text)
-        || /\b(agend\w*|agned\w*|ganed\w*|marc\w*|reserv\w*|confirm\w*)\b.{0,60}\b(ja|ainda|feito|feita|confirmado|confirmada)\b/.test(text);
+    return /\b(quais?|qual|lista|mostra|resume|status|estado|historico|hist[oó]rico|outputs?|retornos?|resultado|resultados?)\b.{0,80}\b(tools?|ferramentas?|apis?|a[cç][oõ]es?|chamadas?|executadas?|usadas?)\b/.test(text)
+        || /\b(tools?|ferramentas?|apis?|a[cç][oõ]es?|chamadas?|executadas?|usadas?)\b.{0,80}\b(quais?|qual|lista|mostra|resume|status|estado|historico|hist[oó]rico|outputs?|retornos?|resultado|resultados?)\b/.test(text)
+        || /\b(ja|ainda|tinha|tenho|foi|esta|ta)\b.{0,60}\b(feito|feita|executad\w*|chamad\w*|concluid\w*|confirm\w*|criad\w*|atualizad\w*|agend\w*|agned\w*|ganed\w*|marc\w*|reserv\w*)\b/.test(text);
 };
 const recentUserMessages = (recentMessages = []) => [...(recentMessages || [])]
     .filter((msg) => /^(user|human)$/i.test(String(msg.role || '')))
@@ -1314,8 +1309,8 @@ const buildConversationFrame = ({ query = '', recentMessages = [], workingMemory
 };
 const buildCurrentTurnFocus = ({ query = '', recentMessages = [], operationalState = {}, workingMemory = {} }) => {
     const recall = isConversationRecallQuery(query);
-    const agendaStatus = isAgendaStatusQuery(query);
-    if (!recall && !agendaStatus)
+    const operationalStatus = isOperationalStatusQuery(query);
+    if (!recall && !operationalStatus)
         return null;
     const previousUser = previousUserMessageForQuery(query, recentMessages);
     const firstUser = firstUserMessageFromConversation(recentMessages);
@@ -1323,31 +1318,22 @@ const buildCurrentTurnFocus = ({ query = '', recentMessages = [], operationalSta
         .filter((msg) => normalizeIntentText(msg.content).trim() !== normalizeIntentText(query).trim())
         .slice(0, 3)
         .map((msg) => ({ role: msg.role, content: truncate(msg.content, 500), at: msg.at }));
-    const agenda = (operationalState || {}).agenda_state || {};
+    const toolState = (operationalState || {}).tool_state || {};
     const previousUserMessage = previousUser ? truncate(previousUser.content, 500) : previousUserFallbackFromWorkingMemory(query, workingMemory);
     const focus = cleanContextValue({
         current_user_request: truncate(query, 500),
-        intent: recall ? 'conversation_recall' : 'agenda_status_question',
+        intent: recall ? 'conversation_recall' : 'tool_or_status_question',
         first_user_message: firstUser ? truncate(firstUser.content, 500) : null,
         previous_user_message: previousUserMessage,
         recent_user_messages: users,
-        agenda_status: agendaStatus ? {
-            reservation_status: agenda.has_confirmation && !agenda.has_pending_pre_reservation
-                ? 'confirmed'
-                : agenda.has_pending_pre_reservation
-                    ? 'pending_pre_reservation'
-                    : agenda.has_pre_reservation
-                        ? 'pre_reserved'
-                        : agenda.has_availability
-                            ? 'availability_known_not_scheduled'
-                            : 'none',
-            has_confirmation: Boolean(agenda.has_confirmation && !agenda.has_pending_pre_reservation),
-            has_pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
-            has_availability: Boolean(agenda.has_availability),
+        tool_status: operationalStatus ? {
+            executed_tools: toolState.names || [],
+            last_successful_tool: toolState.last_successful_tool || null,
+            failed_by_name: toolState.failed_by_name || {},
         } : undefined,
         instruction: recall
-            ? 'Answer the user meta-question from previous_user_message/recent_user_messages and the chronological transcript. Do not answer with agenda availability unless the user asks for availability.'
-            : 'Answer whether the appointment/reservation is already scheduled using agenda_status. Do not offer availability as the main answer unless there is no schedule/reservation state.',
+            ? 'Answer the user meta-question from previous_user_message/recent_user_messages and the chronological transcript. Do not call tools for recall-only questions.'
+            : 'Answer status questions from tool_state, tool_history and action_ledger. Do not call tools unless the agent prompt requires it.',
     });
     if (!previousUserMessage)
         focus.previous_user_message = null;
@@ -1355,47 +1341,29 @@ const buildCurrentTurnFocus = ({ query = '', recentMessages = [], operationalSta
 };
 const buildActionDirective = ({ workingMemory = {}, operationalState = {} }) => {
     const next = String((workingMemory || {}).next_expected_action || '');
-    const match = /\bagenda_(consultar_disponibilidade|pre_reservar_horario|confirmar_agendamento)\b/.exec(next);
-    if (!match || !/\bcall\b|\bMUST\b/i.test(next))
+    const tool = pickRequiredToolFromAction(next);
+    if (!tool || !/\bcall\b|\bMUST\b/i.test(next))
         return null;
-    const tool = match[0];
-    const agenda = (operationalState || {}).agenda_state || {};
+    const toolState = (operationalState || {}).tool_state || {};
+    const latestForTool = ((toolState.latest_by_name || {})[tool]) || null;
     return cleanContextValue({
         required_tool: tool,
         next_expected_action: next,
-        agenda_state: {
-            has_availability: Boolean(agenda.has_availability),
-            latest_availability_source: agenda.latest_availability_source,
-            has_pre_reservation: Boolean(agenda.has_pre_reservation),
-            has_pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
-            has_confirmation: Boolean(agenda.has_confirmation),
+        tool_state: {
+            last_tool: (operationalState || {}).last_tool || null,
+            required_tool_last_result: latestForTool,
+            counts_by_name: toolState.counts_by_name || {},
+            failed_by_name: toolState.failed_by_name || {},
         },
-        instruction: `You MUST call ${tool} now. Do not answer with "posso", "se quiser", "já posso" or ask for the same confirmation instead of calling the required tool. Only skip this tool if it is explicitly blocked in Tool guard.`,
+        instruction: `If the agent prompt requires this action, call ${tool} now using tool_state/action_ledger as evidence. Do not infer domain policy from memory; memory only provides prior conversation, decisions, inputs and outputs.`,
     });
 };
 const inferToolGuard = ({ query, recentMessages, toolHistory, vectorMemories }) => {
-    const text = normalizeIntentText(query);
-    const names = new Set((toolHistory || []).map((tool) => String(tool.name || '')));
-    const hasRecentContext = (recentMessages || []).some((msg) => /reserva|pré-reserva|pre-reserva|agend|confirm|hor[aá]rio|dispon/i.test(String(msg.content || '')));
-    const hasVectorContext = (vectorMemories || []).some((memory) => /reserva|pré-reserva|pre-reserva|agend|confirm|hor[aá]rio|dispon/i.test(memoryText(memory)));
-    const hasAvailabilityTool = names.has('agenda_consultar_disponibilidade');
-    const hasPreReservationTool = names.has('agenda_pre_reservar_horario');
-    const hasAnyContext = names.size > 0 || hasRecentContext || hasVectorContext;
-    const blocked = [];
-    const reasons = [];
-    if (!hasAnyContext) {
-        blocked.push('agenda_pre_reservar_horario', 'agenda_confirmar_agendamento');
-        reasons.push('no prior availability or pre-reservation context was found for this session');
-    }
-    if (hasConfirmIntent(text) && !hasPreReservationTool) {
-        blocked.push('agenda_confirmar_agendamento');
-        reasons.push('confirmation requested but no structured agenda_pre_reservar_horario tool result was found; assistant text or vector memories are not enough to confirm');
-    }
-    if ((/pre.?reserv|pre.?reserv|reservar/.test(text)) && !hasAvailabilityTool) {
-        blocked.push('agenda_pre_reservar_horario');
-        reasons.push('reservation requested but no structured agenda_consultar_disponibilidade tool result was found');
-    }
-    return { blockedTools: Array.from(new Set(blocked)), reasons };
+    return {
+        blockedTools: [],
+        reasons: [],
+        instruction: 'Memory does not block domain tools by hardcoded rules. The agent prompt decides which tool to call; use tool_state/tool_history/action_ledger to verify prior inputs, outputs and failures.',
+    };
 };
 const inferUserIntent = (query = '', recentMessages = []) => {
     const latestUser = [...(recentMessages || [])].reverse().find((msg) => /^(user|human)$/i.test(String(msg.role || '')));
@@ -1404,20 +1372,14 @@ const inferUserIntent = (query = '', recentMessages = []) => {
     const normalizedQuery = normalizeIntentText(query).trim();
     if (isConversationRecallQuery(query))
         return 'conversation_recall';
-    if (isAgendaStatusQuery(query))
-        return 'agenda_status_question';
+    if (isOperationalStatusQuery(query))
+        return 'operational_status_question';
     if (/^(ok|sim|pode|pode sim|isso|isso mesmo|confirmo|confirmar)$/.test(normalizedQuery))
         return 'affirm';
-    if (hasConfirmIntent(text))
-        return 'confirm';
-    if (containsSelectedSlot(text))
-        return 'select_slot';
-    if (/\b(pre.?reserv|pre.?reserv|reservar|segurar|marcar)\b/.test(text))
-        return 'pre_reserve';
-    if (/\b(disponibilidade|horarios?|agenda(?:r|mento)?|quando pode|tem vaga|quero agendar|gostaria de agendar|preciso agendar)\b/.test(text))
-        return 'check_availability';
-    if (/\b(cancel|desmarcar|remarcar|alterar|mudar)\b/.test(text))
-        return 'change_or_cancel';
+    if (hasCommitIntent(text))
+        return 'commit_or_continue';
+    if (/\b(buscar|busca|criar|cria|atualizar|atualiza|consultar|consulta|reservar|reserva|agendar|agenda|abrir|abre|cancelar|cancela|enviar|envia|gerar|gera|validar|valida|processar|processa|executar|executa)\b/.test(text))
+        return 'tool_action_candidate';
     if (/\b(meu nome|email|telefone|empresa|prefiro|preferencia)\b/.test(text))
         return 'profile_update';
     if (text.trim())
@@ -1425,41 +1387,14 @@ const inferUserIntent = (query = '', recentMessages = []) => {
     return 'unknown';
 };
 const deriveNextExpectedAction = (intent, operationalState = {}) => {
-    const agenda = operationalState.agenda_state || {};
-    if (intent === 'affirm') {
-        if (agenda.has_pending_pre_reservation)
-            return 'MUST call agenda_confirmar_agendamento now; do not ask the same confirmation question again';
-        if (agenda.has_availability)
-            return 'MUST call agenda_pre_reservar_horario now using the selected or latest discussed slot; do not ask again';
-        return 'call agenda_consultar_disponibilidade before reserving';
-    }
-    if (intent === 'confirm') {
-        if (agenda.has_pending_pre_reservation)
-            return 'MUST call agenda_confirmar_agendamento now using the latest pre-reservation context; do not ask again';
-        if (agenda.has_availability)
-            return 'MUST call agenda_pre_reservar_horario first using the selected or latest discussed slot; do not ask for permission again';
-        return 'do not call agenda_confirmar_agendamento; call agenda_consultar_disponibilidade first because no availability is known';
-    }
-    if (intent === 'select_slot') {
-        if (agenda.has_availability)
-            return 'MUST call agenda_pre_reservar_horario now using the selected slot; do not ask for confirmation before pre-reserving';
-        return 'call agenda_consultar_disponibilidade before pre-reserving';
-    }
-    if (intent === 'pre_reserve') {
-        if (agenda.has_availability)
-            return 'MUST call agenda_pre_reservar_horario now using one of the known available slots';
-        return 'call agenda_consultar_disponibilidade before pre-reserving';
-    }
-    if (intent === 'check_availability')
-        return agenda.has_availability ? 'reuse known availability unless the user asks to refresh' : 'call agenda_consultar_disponibilidade';
-    if (intent === 'change_or_cancel')
-        return 'inspect current reservation state before changing or cancelling';
+    if (['affirm', 'commit_or_continue', 'tool_action_candidate'].includes(intent))
+        return 'continue according to the agent prompt using conversation_frame, tool_state, tool_history and action_ledger; do not apply domain-specific memory rules';
     if (intent === 'profile_update')
         return 'save stable profile facts and continue the conversation';
     if (intent === 'conversation_recall')
-        return 'answer directly using recent_messages.previous_user_message; do not call agenda tools';
-    if (intent === 'agenda_status_question')
-        return 'answer whether there is a confirmed or pending reservation using operational_state; do not consult availability unless status is unknown';
+        return 'answer directly using previous_user_message and conversation_history_chronological; do not call tools for recall-only questions';
+    if (intent === 'operational_status_question')
+        return 'answer status questions from tool_state, tool_history and action_ledger; do not call tools unless the agent prompt requires it';
     return 'answer using retrieved context and avoid unnecessary tool calls';
 };
 const deriveWorkingMemory = ({ query = '', profileFacts = {}, recentMessages = [], toolHistory = [], operationalState = {}, previous = {} }) => {
@@ -1484,11 +1419,11 @@ const deriveWorkingMemory = ({ query = '', profileFacts = {}, recentMessages = [
     };
 };
 const deriveDecisionState = ({ query = '', toolHistory = [], operationalState = {}, workingMemory = {} }) => {
-    const agenda = operationalState.agenda_state || {};
     const decisions = [];
     const doNotRepeatTools = [];
     const intent = workingMemory.last_user_intent || inferUserIntent(query, []);
     const now = nowIso();
+    const toolState = operationalState.tool_state || {};
     const pushDecision = (id, decision, reason, appliesTo, extra = {}) => {
         decisions.push({
             id,
@@ -1501,41 +1436,25 @@ const deriveDecisionState = ({ query = '', toolHistory = [], operationalState =
             created_at: extra.created_at || now,
             valid_until: extra.valid_until || null,
             superseded_by: extra.superseded_by || null,
+            tool: extra.tool,
         });
     };
-    if (agenda.has_availability) {
-        doNotRepeatTools.push('agenda_consultar_disponibilidade');
-        pushDecision('agenda_availability_known', 'do not consult availability again unless the user asks to refresh', 'availability result already exists in tool_history', 'agenda_flow', { confidence: 0.9 });
-    }
-    if (agenda.has_pending_pre_reservation) {
-        doNotRepeatTools.push('agenda_pre_reservar_horario');
-        pushDecision('agenda_pre_reservation_pending', 'confirmation should use the latest pre-reservation context', 'a pre-reservation exists after the latest confirmation', 'agenda_flow', { confidence: 0.92 });
-    }
-    if (agenda.has_confirmation && !agenda.has_pending_pre_reservation) {
-        doNotRepeatTools.push('agenda_confirmar_agendamento');
-        pushDecision('agenda_confirmation_done', 'do not confirm again unless the user explicitly asks to repeat or change it', 'latest reservation appears confirmed', 'agenda_flow', { confidence: 0.9 });
-    }
-    const reservationStatus = agenda.has_confirmation && !agenda.has_pending_pre_reservation
-        ? 'confirmed'
-        : agenda.has_pending_pre_reservation
-            ? 'pending_pre_reservation'
-            : agenda.has_pre_reservation
-                ? 'pre_reserved'
-                : agenda.has_availability
-                    ? 'availability_known'
-                    : 'none';
+    for (const name of Object.keys(toolState.counts_by_name || {})) {
+        doNotRepeatTools.push(name);
+    }
+    if (toolState.last_successful_tool)
+        pushDecision('last_successful_tool_recorded', `latest successful tool is ${toolState.last_successful_tool.name}`, 'tool_state records successful tool execution', 'tool_orchestration', { confidence: 0.9, tool: toolState.last_successful_tool.name });
+    for (const [name, count] of Object.entries(toolState.failed_by_name || {}))
+        pushDecision(`tool_failed_${name}`, `${name} failed ${count} time(s); inspect tool output before retrying`, 'tool_state records failed tool execution', 'tool_orchestration', { confidence: 0.86, tool: name });
     return {
         active_decisions: decisions,
         do_not_repeat_tools: Array.from(new Set(doNotRepeatTools)),
         current_intent: intent,
-        agenda_decision_state: {
-            pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
-            active_reservation: Boolean(agenda.has_pre_reservation || agenda.has_confirmation),
-            confirmed_reservation: Boolean(agenda.has_confirmation && !agenda.has_pending_pre_reservation),
-            superseded_reservation: Boolean(agenda.has_confirmation && agenda.has_pending_pre_reservation),
-            reschedule_requested: intent === 'change_or_cancel' && Boolean(agenda.has_confirmation || agenda.has_pre_reservation),
-            cancel_requested: /\b(cancelar|cancele|desmarcar|remover)\b/i.test(String(query || '')),
-            reservation_status: reservationStatus,
+        tool_decision_state: {
+            executed_tools: Object.keys(toolState.counts_by_name || {}),
+            failed_tools: Object.keys(toolState.failed_by_name || {}),
+            last_successful_tool: toolState.last_successful_tool || null,
+            do_not_repeat_tools: Array.from(new Set(doNotRepeatTools)),
             evaluated_at: now,
         },
         conflict_policy: 'prefer active decisions with newer timestamps; ignore superseded or expired memories unless auditing',
@@ -1586,7 +1505,12 @@ const deriveMemoryCompression = ({ recentMessages = [], toolHistory = [], profil
         session_summary: {
             messages: lastMessages.length,
             tools: lastTools,
-            agenda_state: operationalState.agenda_state || {},
+            tool_state: (operationalState || {}).tool_state ? {
+                names: ((operationalState.tool_state || {}).names || []).slice(0, maxItems),
+                counts_by_name: (operationalState.tool_state || {}).counts_by_name || {},
+                failed_by_name: (operationalState.tool_state || {}).failed_by_name || {},
+                last_successful_tool: (operationalState.tool_state || {}).last_successful_tool || null,
+            } : {},
         },
         entity_summary: profile,
         workflow_summary: {
@@ -1632,7 +1556,6 @@ const deriveContextHealth = ({ userId = '', project = '', vectorMemories = [], r
             score += weights[key] || 0;
     }
     const missing = Object.entries(checks).filter(([, ok]) => !ok).map(([key]) => key);
-    const agenda = operationalState.agenda_state || {};
     return {
         kind: 'tembory.context_health.v1',
         namespace: userId || null,
@@ -1647,11 +1570,10 @@ const deriveContextHealth = ({ userId = '', project = '', vectorMemories = [], r
             tool_history: Array.isArray(toolHistory) ? toolHistory.length : 0,
             active_decisions: Array.isArray(decisionState.active_decisions) ? decisionState.active_decisions.length : 0,
         },
-        agenda_state: {
-            has_availability: Boolean(agenda.has_availability),
-            has_pre_reservation: Boolean(agenda.has_pre_reservation),
-            has_confirmation: Boolean(agenda.has_confirmation),
-            has_pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
+        tool_state: {
+            names: (((operationalState || {}).tool_state || {}).names || []).slice(0, 12),
+            last_successful_tool: (((operationalState || {}).tool_state || {}).last_successful_tool) || null,
+            failed_by_name: (((operationalState || {}).tool_state || {}).failed_by_name) || {},
         },
         generated_at: nowIso(),
     };
@@ -1662,13 +1584,13 @@ const contextMemoryText = (memory, max = 700) => {
     if (tools.length) {
         const names = tools.map((tool) => `${tool.name || 'tool'}:${tool.ok === false ? 'failed' : 'ok'}`).join(', ');
         const ids = tools.map((tool) => tool.result || tool.input || '').join(' ');
-        const idMatch = /(reservation_id|confirmation_id|id)["':\s]+([A-Za-z0-9_.:-]+)/i.exec(ids);
+        const idMatch = /([A-Za-z_][A-Za-z0-9_.:-]*id)["':\s]+([A-Za-z0-9_.:-]+)/i.exec(ids);
         return truncate(`[tool_events_extracted] ${names}${idMatch ? ` ${idMatch[1]}=${idMatch[2]}` : ''}. See Tool history for structured details.`, max);
     }
     return truncate(text, max);
 };
 const approxTokenCount = (text) => Math.ceil(String(text || '').length / 4);
-const importantJsonFields = ['reservation_id', 'confirmation_id', 'selected_from_message', 'status', 'next_step', 'available_slots', 'timezone', 'error'];
+const importantJsonFields = ['id', 'status', 'state', 'next_step', 'action', 'intent', 'tool', 'input', 'output', 'result', 'error', 'message', 'reason', 'customer_id', 'user_id', 'lead_id', 'ticket_id', 'charge_id'];
 const pickImportantFields = (value) => {
     if (value === null || value === undefined)
         return {};
@@ -1698,9 +1620,7 @@ const compactToolResult = (result, max = 360) => {
         return undefined;
     try {
         const parsed = JSON.parse(text);
-        const picked = pickImportantFields(parsed);
-        if (Object.keys(picked).length)
-            return truncate(safeStringify(picked), max);
+        return truncate(safeStringify(parsed), max);
     }
     catch { }
     const picked = {};
@@ -1719,8 +1639,9 @@ const compactToolHistoryForAgent = (toolHistory = [], maxItems = 6, includeResul
     name: tool.name,
     status: tool.ok === false ? 'failed' : 'ok',
     at: tool.at,
-    input: truncate(String(tool.input || ''), 180) || undefined,
-    result: includeResults ? compactToolResult(tool.result, 360) : undefined,
+    reason: truncate(String(tool.reason || tool.decision || tool.why || tool.source || 'recorded tool call'), 140),
+    input: truncate(String(tool.input || ''), 140) || undefined,
+    result: includeResults ? compactToolResult(tool.result, 240) : undefined,
 }));
 const cleanContextValue = (value) => {
     if (Array.isArray(value)) {
@@ -1764,7 +1685,7 @@ const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
         at: decision.at || decision.updated_at,
     })),
     do_not_repeat_tools: state.do_not_repeat_tools,
-    agenda_decision_state: state.agenda_decision_state,
+    tool_decision_state: state.tool_decision_state,
     latest_tool: state.latest_tool ? cleanContextValue({
         name: state.latest_tool.name,
         status: state.latest_tool.status || (state.latest_tool.ok === false ? 'failed' : 'ok'),
@@ -1773,19 +1694,21 @@ const compactDecisionStateForAgent = (state = {}) => cleanContextValue({
     conflict_policy: state.conflict_policy,
 });
 const compactOperationalStateForAgent = (state = {}) => {
-    const agenda = state.agenda_state || {};
+    const counts = state.tool_counts || {};
+    const toolState = state.tool_state || {};
     return {
         last_tool: state.last_tool || null,
-        tool_counts: state.tool_counts || {},
-        agenda_state: {
-            has_availability: Boolean(agenda.has_availability),
-            has_pre_reservation: Boolean(agenda.has_pre_reservation),
-            has_confirmation: Boolean(agenda.has_confirmation),
-            has_pending_pre_reservation: Boolean(agenda.has_pending_pre_reservation),
-            latest_availability: compactToolResult(agenda.latest_availability_result),
-            latest_pre_reservation: compactToolResult(agenda.latest_pre_reservation_result),
-            latest_confirmation: compactToolResult(agenda.latest_confirmation_result),
+        tool_counts: {
+            total: counts.total || 0,
+            ok: counts.ok || 0,
+            failed: counts.failed || 0,
         },
+        tool_state: (toolState.names || []).length ? {
+            names: toolState.names,
+            counts_by_name: toolState.counts_by_name || {},
+            failed_by_name: toolState.failed_by_name || {},
+            last_successful_tool: toolState.last_successful_tool || undefined,
+        } : undefined,
         blocked_without_context: state.blocked_without_context || [],
         guidance: (state.guidance || []).slice(0, 3),
     };
@@ -1793,12 +1716,6 @@ const compactOperationalStateForAgent = (state = {}) => {
 const compactMemoryCompressionForAgent = (compression = {}) => ({
     turn_summary: (compression.turn_summary || []).slice(-3),
     session_tools: (((compression.session_summary || {}).tools) || []).slice(-6),
-    agenda_state: ((compression.session_summary || {}).agenda_state) ? {
-        has_availability: Boolean(compression.session_summary.agenda_state.has_availability),
-        has_pre_reservation: Boolean(compression.session_summary.agenda_state.has_pre_reservation),
-        has_confirmation: Boolean(compression.session_summary.agenda_state.has_confirmation),
-        has_pending_pre_reservation: Boolean(compression.session_summary.agenda_state.has_pending_pre_reservation),
-    } : undefined,
     active_memory_count: ((compression.workflow_summary || {}).active_memory_count) || 0,
 });
 const compactActionLedgerForAgent = (ledger = [], maxItems = 6, includeResults = true) => pruneByLimit(ledger || [], maxItems).map((item) => cleanContextValue({
@@ -1807,7 +1724,9 @@ const compactActionLedgerForAgent = (ledger = [], maxItems = 6, includeResults =
     tool: item.tool || item.name,
     status: item.status,
     at: item.at,
-    result: includeResults ? compactToolResult(item.result, 260) : undefined,
+    reason: item.reason,
+    input: item.input,
+    result: includeResults ? compactToolResult(item.result, 180) : undefined,
 }));
 const compactEntityTimelineForAgent = (timeline = [], maxItems = 8) => pruneByLimit(timeline || [], maxItems).map((item) => cleanContextValue({
     entity: item.entity || item.source || item.name,
@@ -2025,8 +1944,8 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             section: 'context_header',
             title: 'Tembory context',
             value: compactForAgent || compactStateSections
-                ? 'Read-only memory. Conversation frame is authoritative for the full recent transcript, including first/current/previous client messages. Follow next_expected_action when present. Before calling downstream tools, verify required prior tool context in tool_history or operational_state. Do not repeat tools listed in do_not_repeat_tools.'
-                : 'Use this context as read-only memory. Prefer it over guessing. Do not mention internal section names to the user. The Conversation frame is authoritative for the full recent transcript, including first, current, previous, and recent client messages. Treat next_expected_action as an instruction, not as a suggestion. If it says to call a tool now, call that tool instead of asking the user the same question again. If the user asks to continue, chooses a slot, says ok/sim, reserve, confirm, update, cancel, or performs any downstream action that depends on a prior tool result, first verify the required prior result in tool_history, recent_messages, or vector memories. If the required prior result is absent, do not call the downstream tool; ask for the missing context or call the appropriate prerequisite tool.',
+                ? 'Read-only operational memory. Conversation frame is authoritative for user/assistant transcript. Tool history/action ledger are authoritative for tool calls, reasons, inputs, outputs, status and timestamps. The agent prompt owns domain policy and decides which tool to call.'
+                : 'Use this context as read-only operational memory. Do not mention internal section names to the user. Conversation frame is authoritative for the chronological user/assistant transcript. Tool history and action ledger are authoritative for what tools were called, why they were called, what input was sent, what output returned, whether they failed, and when they ran. Memory must not invent domain-specific tool rules; the agent prompt owns tool orchestration policy.',
         });
     }
     sections.push({
@@ -2162,9 +2081,9 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
         value: {
             blocked_tools: guard.blockedTools,
             reasons: guard.reasons,
-            instruction: guard.blockedTools.length
+            instruction: guard.instruction || (guard.blockedTools.length
                 ? `Do not call these tools now: ${guard.blockedTools.join(', ')}. Ask for the missing context or execute the prerequisite step first.`
-                : 'No downstream tool is blocked by missing memory prerequisites.',
+                : 'No downstream tool is blocked by missing memory prerequisites.'),
         },
     });
     sections.push({
@@ -3690,7 +3609,6 @@ exports.__private = {
     explicitToolHistoryItemsFromMemory,
     toolHistoryFromMemory,
     cleanAssistantTranscriptText,
-    availabilityFromRecentMessages,
     buildActionDirective,
     recentMessageFromMemory,
     previousUserFallbackFromWorkingMemory,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-tembory",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "Tembory node for n8n AI Agents with profile, tools, timeline, graph and semantic memory",
   "license": "MIT",
   "homepage": "https://tembory.com",
@@ -25,7 +25,8 @@
     "test": "node --test test/*.test.js",
     "smoke:n8n:multiturn": "node scripts/smoke-n8n-multiturn-tools.js",
     "simulate:agent-context": "node scripts/simulate-agent-context.js",
-    "prepublishOnly": "npm test"
+    "simulate:n8n-agent": "node scripts/simulate-n8n-agent-agenda.js",
+    "prepublishOnly": "npm test && npm run simulate:n8n-agent"
   },
   "files": [
     "dist",

package/scripts/simulate-agent-context.js

@@ -27,53 +27,49 @@ const core = require('../dist/nodes/Mem0/Mem0Memory.node.js').__private;
 
 const toolHistory = [
   {
-    id: 'tool_ry3twg',
-    name: 'agenda_consultar_disponibilidade',
-    input: '',
+    id: 'tool_crm_lookup',
+    name: 'crm_buscar_cliente',
+    input: '{"phone":"11999998888"}',
     ok: true,
     at: '2026-05-14T05:34:12.460Z',
-    source: 'used_tools_text',
-    result: '[{"args":{"tool":"agenda_consultar_disponibilidade","available_slots":"2026-05-12T09:00,2026-05-12T14:00,2026-05-13T10:30","timezone":"America/Sao_Paulo","next_step":"escolher_um_horario"}}]',
+    source: 'structured_tool_event',
+    reason: 'agent prompt requested CRM lookup by phone',
+    result: '{"customer_id":"CUS-TEMBORY-LAB-001","name":"Lucas","phone":"11999998888"}',
   },
   {
-    id: 'tool_mu9qd2',
-    name: 'agenda_pre_reservar_horario',
-    input: '',
+    id: 'tool_charge',
+    name: 'pagamento_criar_cobranca',
+    input: '{"customer_id":"CUS-TEMBORY-LAB-001","amount_cents":9700}',
     ok: true,
     at: '2026-05-14T05:34:34.017Z',
-    source: 'used_tools_text',
-    result: '[{"args":{"tool":"agenda_pre_reservar_horario","reservation_id":"RES-TEMBORY-LAB-001","selected_from_message":"dia 13","status":"pre_reserved","next_step":"confirmar_agendamento"}}]',
+    source: 'structured_tool_event',
+    reason: 'agent prompt requested payment creation',
+    result: '{"charge_id":"CHG-TEMBORY-LAB-001","customer_id":"CUS-TEMBORY-LAB-001","status":"created"}',
   },
 ];
 
 const vectorMemories = [
   {
-    memory: '[Used tools: Tool: agenda_pre_reservar_horario, Input: , Result: [{"args":{"tool":"agenda_pre_reservar_horario","reservation_id":"RES-TEMBORY-LAB-001","selected_from_message":"dia 13","status":"pre_reserved","next_step":"confirmar_agendamento"}}]] Calling agenda_pre_reservar_horario with input: {"id":"call_bfHlltcjI1vCagRkav0fj8Ha"}\nPré-reserva feita para o dia 13.\nSe quiser, posso confirmar agora.',
+    memory: '[Used tools: Tool: pagamento_criar_cobranca, Input: {"customer_id":"CUS-TEMBORY-LAB-001"}, Result: {"charge_id":"CHG-TEMBORY-LAB-001","status":"created"}] Cobrança criada para Lucas.',
     created_at: '2026-05-14T05:34:35.373020Z',
     temboryScore: { semanticScore: 0.71, recencyScore: 0.99, hybridScore: 0.81, source: 'semantic' },
   },
-  {
-    memory: '[Used tools: Tool: agenda_consultar_disponibilidade, Input: , Result: [{"args":{"tool":"agenda_consultar_disponibilidade","available_slots":"2026-05-12T09:00,2026-05-12T14:00,2026-05-13T10:30","timezone":"America/Sao_Paulo","next_step":"escolher_um_horario"}}]] Temos estes horários vagos:\n- 12/05 às 09:00\n- 12/05 às 14:00\n- 13/05 às 10:30',
-    created_at: '2026-05-14T05:34:14.717988Z',
-    temboryScore: { semanticScore: 0.7, recencyScore: 0.99, hybridScore: 0.8, source: 'semantic' },
-  },
-  { memory: 'Oi! Como posso ajudar?', created_at: '2026-05-14T05:33:47.194630Z' },
-  { memory: 'oi', created_at: '2026-05-14T05:33:47.194355Z' },
+  { memory: 'Lucas prefere atendimento financeiro por WhatsApp.', created_at: '2026-05-14T05:33:47.194630Z' },
 ];
 
 const operationalState = core.deriveOperationalState(toolHistory, {}, [], true);
 const workingMemory = {
-  current_goal: 'call agenda_confirmar_agendamento now; do not ask the same confirmation question again',
-  current_task: 'call agenda_confirmar_agendamento now; do not ask the same confirmation question again',
-  last_user_intent: 'affirm',
-  last_user_message: 'ok',
-  next_expected_action: 'call agenda_confirmar_agendamento now; do not ask the same confirmation question again',
+  current_goal: 'call suporte_abrir_ticket now using prior CRM/payment context',
+  current_task: 'call suporte_abrir_ticket now using prior CRM/payment context',
+  last_user_intent: 'tool_action_candidate',
+  last_user_message: 'abre um ticket com financeiro',
+  next_expected_action: 'call suporte_abrir_ticket now using prior CRM/payment context',
 };
-const decisionState = core.deriveDecisionState({ query: 'ok', toolHistory, operationalState, workingMemory });
+const decisionState = core.deriveDecisionState({ query: 'abre um ticket com financeiro', toolHistory, operationalState, workingMemory });
 const memoryCompression = core.deriveMemoryCompression({ toolHistory, operationalState, vectorMemories });
 const common = {
   payloadFormat: 'structured',
-  query: 'ok',
+  query: 'abre um ticket com financeiro',
   userId: 'd48292bd4c9f4eccb9120092e3acd073',
   profileFacts: {},
   workingMemory,
@@ -86,8 +82,8 @@ const common = {
   recentMessages: [],
   toolHistory,
   highlights: [
-    'tool agenda_consultar_disponibilidade: [{"args":{"available_slots":"2026-05-12T09:00,2026-05-12T14:00,2026-05-13T10:30"}}]',
-    'tool agenda_pre_reservar_horario: [{"args":{"reservation_id":"RES-TEMBORY-LAB-001","status":"pre_reserved"}}]',
+    'tool crm_buscar_cliente: {"customer_id":"CUS-TEMBORY-LAB-001"}',
+    'tool pagamento_criar_cobranca: {"charge_id":"CHG-TEMBORY-LAB-001"}',
   ],
   graph: [],
   diagnostics: {},
@@ -106,8 +102,8 @@ for (const [name, adv] of modes) {
     size: core.contextSizeOfMessages(messages),
     has_next_expected_action: /next_expected_action/.test(text),
     has_do_not_repeat_tools: /do_not_repeat_tools/.test(text),
-    has_reservation_id: /RES-TEMBORY-LAB-001/.test(text),
-    has_available_slots: /available_slots/.test(text),
-    has_duplicate_calling_text: /Calling agenda_pre_reservar_horario/.test(text),
+    has_customer_id: /CUS-TEMBORY-LAB-001/.test(text),
+    has_charge_id: /CHG-TEMBORY-LAB-001/.test(text),
+    has_duplicate_calling_text: /Calling\s+[A-Za-z_][A-Za-z0-9_.:-]*/.test(text),
   }, null, 2));
 }

package/scripts/simulate-n8n-agent-agenda.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('node:assert/strict');
+const Module = require('node:module');
+
+const originalLoad = Module._load;
+Module._load = function patchedLoad(request, parent, isMain) {
+  if (request === 'n8n-workflow') {
+    return {
+      NodeConnectionTypes: {
+        AiMemory: 'ai_memory',
+        AiLanguageModel: 'ai_languageModel',
+        AiEmbedding: 'ai_embedding',
+      },
+      NodeApiError: class NodeApiError extends Error {},
+    };
+  }
+  if (request === '@langchain/core/messages') {
+    return {
+      HumanMessage: class HumanMessage { constructor(content) { this.content = content; } _getType() { return 'human'; } },
+      AIMessage: class AIMessage { constructor(content) { this.content = content; } _getType() { return 'ai'; } },
+      SystemMessage: class SystemMessage { constructor(content) { this.content = content; } _getType() { return 'system'; } },
+    };
+  }
+  return originalLoad.call(this, request, parent, isMain);
+};
+
+const core = require('../dist/nodes/Mem0/Mem0Memory.node.js').__private;
+
+const BASE_TIME = Date.parse('2026-05-16T12:00:00.000Z');
+
+function at(index) {
+  return new Date(BASE_TIME + index * 1000).toISOString();
+}
+
+function parseContext(messages) {
+  return messages.map((message) => message.content || '').join('\n\n');
+}
+
+function requiredToolFromText(text) {
+  return /"required_tool":"([^"]+)"/.exec(text)?.[1] || null;
+}
+
+function previousUserMessageFromText(text) {
+  return /"previous_user_message":"((?:\\"|[^"])*)"/.exec(text)?.[1]?.replace(/\\"/g, '"') || '';
+}
+
+function normalizeText(value) {
+  return String(value || '').toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '');
+}
+
+function mockTool(name, userMessage) {
+  const outputs = {
+    crm_buscar_cliente: {
+      customer_id: 'CUS-TEMBORY-LAB-001',
+      name: 'Lucas',
+      phone: '11999998888',
+      lifecycle_stage: 'lead_qualified',
+    },
+    crm_atualizar_pipeline: {
+      customer_id: 'CUS-TEMBORY-LAB-001',
+      pipeline_id: 'PIPE-VENDAS-001',
+      stage: 'proposal',
+      updated_from_message: userMessage,
+    },
+    pagamento_criar_cobranca: {
+      charge_id: 'CHG-TEMBORY-LAB-001',
+      customer_id: 'CUS-TEMBORY-LAB-001',
+      amount_cents: 9700,
+      status: 'created',
+    },
+    suporte_abrir_ticket: {
+      ticket_id: 'TCK-TEMBORY-LAB-001',
+      customer_id: 'CUS-TEMBORY-LAB-001',
+      queue: 'financeiro',
+      status: 'opened',
+    },
+    api_enviar_webhook: {
+      webhook_id: 'WH-TEMBORY-LAB-001',
+      endpoint: 'https://example.test/hooks/customer',
+      status: 'delivered',
+    },
+  };
+  if (!outputs[name]) throw new Error(`Unknown mock tool: ${name}`);
+  return outputs[name];
+}
+
+function answerFor({ userMessage, toolCalls, state, contextText }) {
+  const normalized = normalizeText(userMessage);
+  if (/o que eu ja te disse|o que eu já te disse/.test(normalized)) {
+    const facts = core.renderProfileFacts(state.profileFacts);
+    return [
+      'Você me disse que:',
+      facts.name ? `- seu nome é ${facts.name}` : null,
+      facts.phone ? `- seu telefone é ${facts.phone}` : null,
+      facts.company ? `- sua empresa é ${facts.company}` : null,
+      Array.isArray(facts.interests) && facts.interests.length ? `- interesses: ${facts.interests.join(', ')}` : null,
+    ].filter(Boolean).join('\n');
+  }
+  if (/quais tools|tools foram|ferramentas foram|outputs/.test(normalized)) {
+    if (!state.toolHistory.length) return 'Nenhuma tool foi chamada ainda.';
+    return `Foram chamadas ${state.toolHistory.length} tools:\n` + state.toolHistory
+      .map((tool, index) => `${index + 1}. ${tool.name}: ${tool.result}`)
+      .join('\n');
+  }
+  if (/qual.*ultima mensagem antes/.test(normalized)) {
+    const previous = previousUserMessageFromText(contextText)
+      || core.previousUserFallbackFromWorkingMemory(userMessage, state.workingMemory);
+    return previous ? `Sua última mensagem antes desta foi: "${previous}".` : 'Não encontrei mensagem anterior.';
+  }
+  if (toolCalls.length) {
+    return `Tool executada: ${toolCalls.map((tool) => tool.name).join(', ')}.`;
+  }
+  return userMessage.includes('lucas') ? 'Prazer, Lucas! Como posso ajudar?' : 'Perfeito.';
+}
+
+function buildTurnContext({ state, userMessage, visibleToolHistory, turnIndex, requiredTool = null }) {
+  state.recentMessages.push({ role: 'user', content: userMessage, at: at(turnIndex * 2) });
+  state.profileFacts = core.mergeProfileFacts(
+    state.profileFacts,
+    core.extractProfileFactsFromText(userMessage, 'user_message', at(turnIndex * 2)),
+    core.mergeProfileFacts(...state.recentMessages
+      .filter((message) => /^(user|human)$/i.test(String(message.role || '')))
+      .map((message) => core.extractProfileFactsFromText(message.content, 'recent_user_message', message.at))),
+  );
+
+  const renderedProfile = core.renderProfileFacts(state.profileFacts);
+  const operationalState = core.deriveOperationalState(visibleToolHistory, renderedProfile, state.recentMessages, true);
+  const workingMemory = core.deriveWorkingMemory({
+    query: userMessage,
+    profileFacts: renderedProfile,
+    recentMessages: state.recentMessages,
+    toolHistory: visibleToolHistory,
+    operationalState,
+    previous: state.workingMemory,
+  });
+  if (requiredTool) {
+    workingMemory.current_task = `MUST call ${requiredTool} now because the agent prompt selected this tool`;
+    workingMemory.next_expected_action = `MUST call ${requiredTool} now because the agent prompt selected this tool`;
+    workingMemory.last_user_intent = 'tool_action_candidate';
+  }
+  const decisionState = core.deriveDecisionState({
+    query: userMessage,
+    toolHistory: visibleToolHistory,
+    operationalState,
+    workingMemory,
+  });
+  const adv = core.applyOperationalPreset({ operationPreset: 'productionBalanced' });
+  const contextMessages = core.buildContextMessages({
+    payloadFormat: 'structured',
+    query: userMessage,
+    userId: state.namespace,
+    profileFacts: renderedProfile,
+    workingMemory,
+    decisionState,
+    memoryCompression: core.deriveMemoryCompression({
+      recentMessages: state.recentMessages,
+      toolHistory: visibleToolHistory,
+      profileFacts: state.profileFacts,
+      operationalState,
+      vectorMemories: [],
+    }),
+    operationalState,
+    actionLedger: core.deriveActionLedger(visibleToolHistory, 20, true),
+    entityTimeline: core.deriveEntityTimeline(state.profileFacts, [], state.recentMessages, visibleToolHistory),
+    vectorMemories: [],
+    recentMessages: state.recentMessages,
+    toolHistory: visibleToolHistory,
+    highlights: [],
+    graph: [],
+    diagnostics: {},
+    adv,
+  });
+
+  state.workingMemory = workingMemory;
+  state.decisionState = decisionState;
+  state.operationalState = operationalState;
+
+  return { contextText: parseContext(contextMessages), workingMemory, operationalState };
+}
+
+function runScenario({ name, turns, expectedCounts, hideToolHistoryOnTurns = new Set() }) {
+  const state = {
+    namespace: `local-${name}`,
+    recentMessages: [],
+    toolHistory: [],
+    profileFacts: {},
+    workingMemory: {},
+    decisionState: {},
+    operationalState: {},
+  };
+  const trace = [];
+
+  for (let index = 0; index < turns.length; index += 1) {
+    const turn = turns[index];
+    const turnNumber = index + 1;
+    const visibleToolHistory = hideToolHistoryOnTurns.has(turnNumber) ? [] : state.toolHistory;
+    const { contextText, workingMemory, operationalState } = buildTurnContext({
+      state,
+      userMessage: turn.user,
+      visibleToolHistory,
+      turnIndex: index,
+      requiredTool: turn.tool,
+    });
+
+    assert.doesNotMatch(contextText, /\[Used tools:|Calling\s+[A-Za-z_][A-Za-z0-9_.:-]*/i, `${name} turn ${turnNumber}: raw tool audit leaked into context`);
+
+    const toolName = requiredToolFromText(contextText);
+    const toolCalls = [];
+    if (toolName) {
+      const result = mockTool(toolName, turn.user);
+      const extracted = core.extractToolCalls({
+        output: '',
+        __temboryToolCalls: [{
+          id: `${name}-turn-${turnNumber}-${toolName}`,
+          sequence: 1,
+          name: toolName,
+          input: JSON.stringify({ user_message: turn.user }),
+          result: JSON.stringify([{ args: { tool: toolName, ...result } }]),
+          ok: true,
+          at: at(index * 2 + 1),
+          source: 'local_n8n_agent_simulator',
+          reason: `agent_prompt_selected_${toolName}`,
+        }],
+      });
+      state.toolHistory = core.applyToolHistoryWindow(state.toolHistory.concat(extracted), 3600, 20);
+      toolCalls.push(...extracted);
+    }
+
+    const answer = core.cleanAssistantTranscriptText(answerFor({ userMessage: turn.user, toolCalls, state, contextText }));
+    state.recentMessages.push({ role: 'assistant', content: answer, at: at(index * 2 + 1) });
+    state.recentMessages = core.pruneConversationMessagesPreserveAnchors(state.recentMessages, 30);
+
+    trace.push({
+      turn: turnNumber,
+      user: turn.user,
+      requiredTool: toolName,
+      calledTools: toolCalls.map((tool) => tool.name),
+      toolState: operationalState.tool_state,
+      nextExpected: workingMemory.next_expected_action,
+      answer,
+    });
+  }
+
+  for (const [toolName, expectedCount] of Object.entries(expectedCounts)) {
+    assert.equal(state.toolHistory.filter((tool) => tool.name === toolName).length, expectedCount, `${name}: unexpected count for ${toolName}`);
+  }
+  assert.match(trace.at(-1).answer, /quais tools foram chamadas/i, `${name}: previous message recall failed`);
+
+  const finalOperational = core.deriveOperationalState(state.toolHistory, core.renderProfileFacts(state.profileFacts), state.recentMessages, true);
+  const health = core.deriveContextHealth({
+    userId: state.namespace,
+    project: 'local-agent-simulation',
+    vectorMemories: [{ memory: 'local simulation' }],
+    recentMessages: state.recentMessages,
+    toolHistory: state.toolHistory,
+    workingMemory: state.workingMemory,
+    decisionState: state.decisionState,
+    memoryCompression: core.deriveMemoryCompression({
+      recentMessages: state.recentMessages,
+      toolHistory: state.toolHistory,
+      profileFacts: state.profileFacts,
+      operationalState: finalOperational,
+      vectorMemories: [],
+    }),
+    operationalState: finalOperational,
+    diagnostics: { connectedAi: { languageModel: true, embedding: true, errors: [] } },
+  });
+
+  assert.ok(health.quality_score >= 970, `${name}: health score too low: ${health.quality_score}`);
+
+  return {
+    name,
+    ok: true,
+    toolHistory: state.toolHistory.map((tool) => tool.name),
+    profileFacts: core.renderProfileFacts(state.profileFacts),
+    qualityScore: health.quality_score,
+    status: health.status,
+    trace,
+  };
+}
+
+const results = [
+  runScenario({
+    name: 'generic-crm-payment-support-flow',
+    turns: [
+      { user: 'oi meu nome eh lucas' },
+      { user: 'meu telefone eh 11999998888' },
+      { user: 'minha empresa chama Elefai' },
+      { user: 'busca meu cadastro pelo telefone', tool: 'crm_buscar_cliente' },
+      { user: 'atualiza meu pipeline para proposta', tool: 'crm_atualizar_pipeline' },
+      { user: 'cria uma cobrança para mim', tool: 'pagamento_criar_cobranca' },
+      { user: 'abre um ticket com o financeiro', tool: 'suporte_abrir_ticket' },
+      { user: 'envia webhook para meu sistema', tool: 'api_enviar_webhook' },
+      { user: 'quais tools foram chamadas e quais outputs elas deram?' },
+      { user: 'qual foi minha ultima mensagem antes desta?' },
+    ],
+    expectedCounts: {
+      crm_buscar_cliente: 1,
+      crm_atualizar_pipeline: 1,
+      pagamento_criar_cobranca: 1,
+      suporte_abrir_ticket: 1,
+      api_enviar_webhook: 1,
+    },
+  }),
+  runScenario({
+    name: 'retrieval-gap-still-uses-agent-selected-tools',
+    hideToolHistoryOnTurns: new Set([5, 6]),
+    turns: [
+      { user: 'oi meu nome eh lucas' },
+      { user: 'busca meu cadastro pelo telefone', tool: 'crm_buscar_cliente' },
+      { user: 'quais tools foram chamadas?' },
+      { user: 'cria uma cobrança para mim', tool: 'pagamento_criar_cobranca' },
+      { user: 'abre ticket mesmo se o histórico estruturado não vier agora', tool: 'suporte_abrir_ticket' },
+      { user: 'quais tools foram chamadas e quais outputs elas deram?' },
+      { user: 'qual foi minha ultima mensagem antes desta?' },
+    ],
+    expectedCounts: {
+      crm_buscar_cliente: 1,
+      pagamento_criar_cobranca: 1,
+      suporte_abrir_ticket: 1,
+    },
+  }),
+];
+
+console.log(JSON.stringify({ ok: true, scenarios: results }, null, 2));

package/scripts/smoke-n8n-multiturn-tools.js

@@ -30,31 +30,31 @@ const core = require('../dist/nodes/Mem0/Mem0Memory.node.js').__private;
 
 const turns = [
   {
-    user: 'Quais horarios existem para uma reuniao esta semana?',
-    tools: [{ name: 'agenda_consultar_disponibilidade', input: { range: 'week' }, result: { slots: ['2026-05-15T14:00:00-03:00'] } }],
+    user: 'Busca meu cadastro no CRM pelo telefone',
+    tools: [{ name: 'crm_buscar_cliente', input: { phone: '11999998888' }, result: { customer_id: 'CUS-TEMBORY-001' } }],
   },
-  { user: 'Pode usar o horario das 14h', tools: [] },
+  { user: 'Pode usar esse cadastro', tools: [] },
   {
-    user: 'Faz a pre-reserva desse horario',
-    tools: [{ name: 'agenda_pre_reservar_horario', input: { slot: '2026-05-15T14:00:00-03:00' }, result: { reservation_id: 'RES-TEMBORY-001' } }],
+    user: 'Atualiza o pipeline para proposta',
+    tools: [{ name: 'crm_atualizar_pipeline', input: { customer_id: 'CUS-TEMBORY-001', stage: 'proposal' }, result: { pipeline_id: 'PIPE-TEMBORY-001', stage: 'proposal' } }],
   },
-  { user: 'Qual pre-reserva ficou pendente?', tools: [] },
+  { user: 'Qual atualização ficou registrada?', tools: [] },
   {
-    user: 'Pode confirmar',
-    tools: [{ name: 'agenda_confirmar_agendamento', input: { reservation_id: 'RES-TEMBORY-001' }, result: { confirmation_id: 'CONF-TEMBORY-001' } }],
+    user: 'Cria uma cobrança para esse cliente',
+    tools: [{ name: 'pagamento_criar_cobranca', input: { customer_id: 'CUS-TEMBORY-001' }, result: { charge_id: 'CHG-TEMBORY-001' } }],
   },
-  { user: 'Qual foi o codigo de confirmacao?', tools: [] },
+  { user: 'Qual foi o codigo da cobrança?', tools: [] },
   {
-    user: 'Atualiza disponibilidade para outro horario',
-    tools: [{ name: 'agenda_consultar_disponibilidade', input: { refresh: true }, result: { slots: ['2026-05-16T10:00:00-03:00'] } }],
+    user: 'Abre ticket para o financeiro',
+    tools: [{ name: 'suporte_abrir_ticket', input: { customer_id: 'CUS-TEMBORY-001', queue: 'financeiro' }, result: { ticket_id: 'TCK-TEMBORY-001' } }],
   },
   {
-    user: 'Pre-reserva o novo horario',
-    tools: [{ name: 'agenda_pre_reservar_horario', input: { slot: '2026-05-16T10:00:00-03:00' }, result: { reservation_id: 'RES-TEMBORY-002' } }],
+    user: 'Envia webhook para meu sistema',
+    tools: [{ name: 'api_enviar_webhook', input: { customer_id: 'CUS-TEMBORY-001' }, result: { webhook_id: 'WH-TEMBORY-001', status: 'delivered' } }],
   },
   {
-    user: 'Confirma o novo horario',
-    tools: [{ name: 'agenda_confirmar_agendamento', input: { reservation_id: 'RES-TEMBORY-002' }, result: { confirmation_id: 'CONF-TEMBORY-002' } }],
+    user: 'Atualiza o CRM com o webhook enviado',
+    tools: [{ name: 'crm_registrar_evento', input: { customer_id: 'CUS-TEMBORY-001', event: 'webhook_delivered' }, result: { event_id: 'EVT-TEMBORY-001' } }],
   },
   { user: 'Resume as tools usadas e o estado atual', tools: [] },
   { user: 'O que voce sabe sem chamar ferramenta?', tools: [] },
@@ -103,14 +103,14 @@ for (const [index, turn] of turns.entries()) {
     toolHistory,
     profileFacts: {},
     operationalState,
-    vectorMemories: [{ memory: 'CONF-TEMBORY-002 confirmado' }],
+    vectorMemories: [{ memory: 'EVT-TEMBORY-001 registrado' }],
   });
 }
 
 const health = core.deriveContextHealth({
   userId: namespace,
   project: 'smoke',
-  vectorMemories: [{ memory: 'CONF-TEMBORY-002 confirmado' }],
+  vectorMemories: [{ memory: 'EVT-TEMBORY-001 registrado' }],
   recentMessages,
   toolHistory,
   workingMemory,
@@ -122,9 +122,10 @@ const health = core.deriveContextHealth({
 
 assert.equal(recentMessages.length, 12);
 assert.equal(toolHistory.length, 6);
-assert.equal(operationalState.agenda_state.has_confirmation, true);
-assert.equal(decisionState.agenda_decision_state.confirmed_reservation, true);
-assert.ok(decisionState.do_not_repeat_tools.includes('agenda_confirmar_agendamento'));
+assert.equal(operationalState.tool_state.counts_by_name.crm_buscar_cliente, 1);
+assert.equal(operationalState.tool_state.counts_by_name.crm_registrar_evento, 1);
+assert.equal(decisionState.tool_decision_state.last_successful_tool.name, 'crm_registrar_evento');
+assert.ok(decisionState.do_not_repeat_tools.includes('crm_registrar_evento'));
 assert.ok(health.quality_score >= 970);
 
 console.log(JSON.stringify({
@@ -134,5 +135,5 @@ console.log(JSON.stringify({
   toolEvents: toolHistory.length,
   qualityScore: health.quality_score,
   status: health.status,
-  latestConfirmation: operationalState.agenda_state.latest_confirmation_result,
+  latestTool: operationalState.tool_state.last_successful_tool,
 }, null, 2));