n8n-nodes-tembory 1.0.31 → 1.0.33

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,74 +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 preReservationFromRecentMessages = (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(pr[eé][-\s]?reservad[oa]|pre[-\s]?reservad[oa]|reservation_id|RES-[A-Z0-9-]+)\b/i.test(text)
-            && !/\b(confirmad[oa]|confirmation_id|CONF-[A-Z0-9-]+)\b/i.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 recentPreReservation = reservations.length ? null : preReservationFromRecentMessages(recentMessages);
-    const hasPreReservation = reservations.length > 0 || Boolean(recentPreReservation);
-    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 || ''))) || (recentPreReservation && !lastConfirmation));
     const blockedWithoutContext = [];
-    if (!hasAvailability)
-        blockedWithoutContext.push('agenda_pre_reservar_horario');
-    if (!hasPreReservation)
-        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,
@@ -482,20 +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: hasPreReservation,
-            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) : (recentPreReservation && includeResults !== false ? recentPreReservation.text : null),
-            latest_pre_reservation_source: lastReservation ? 'tool_history' : (recentPreReservation ? recentPreReservation.source : 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,
@@ -510,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,
@@ -586,6 +578,7 @@ const deriveEntityTimeline = (profileFacts = {}, graph = [], recentMessages = []
 };
 const RECENT_MESSAGE_MARKER = '__tembory_recent_message_v1__';
 const TOOL_HISTORY_MARKER = '__tembory_tool_history_v1__';
+const TOOL_LEDGER_MARKER = '__tembory_tool_ledger_v1__';
 const encodeRecentMessage = (recent, threadId) => `${RECENT_MESSAGE_MARKER}${safeStringify({
     role: recent.role || 'user',
     content: recent.content || '',
@@ -604,6 +597,21 @@ const encodeToolCall = (tool, threadId) => `${TOOL_HISTORY_MARKER}${safeStringif
     source: tool.source || 'n8n',
     thread_id: threadId,
 })}`;
+const encodeToolLedger = (tools = [], threadId) => `${TOOL_LEDGER_MARKER}${safeStringify({
+    thread_id: threadId,
+    generated_at: nowIso(),
+    tools: sortToolHistory(tools || []).map((tool, index) => ({
+        id: tool.id || tool.callId || tool.call_id || '',
+        turn_id: tool.turnId || tool.turn_id || '',
+        sequence: tool.sequence || index + 1,
+        name: tool.name || tool.tool || tool.toolName || '',
+        input: tool.input || '',
+        ok: tool.ok !== false,
+        result: tool.result || '',
+        at: tool.at || nowIso(),
+        source: tool.source || 'n8n',
+    })),
+})}`;
 const parseRecentMessageMarker = (text) => {
     if (!text || typeof text !== 'string' || !text.startsWith(RECENT_MESSAGE_MARKER))
         return null;
@@ -644,6 +652,30 @@ const parseToolHistoryMarker = (text) => {
         return null;
     }
 };
+const parseToolLedgerMarker = (text) => {
+    if (!text || typeof text !== 'string' || !text.startsWith(TOOL_LEDGER_MARKER))
+        return [];
+    try {
+        const parsed = JSON.parse(text.slice(TOOL_LEDGER_MARKER.length));
+        const tools = Array.isArray(parsed?.tools) ? parsed.tools : [];
+        return tools
+            .filter((tool) => tool && tool.name)
+            .map((tool, index) => ({
+            id: tool.id || tool.call_id || tool.callId || '',
+            turnId: tool.turn_id || tool.turnId || '',
+            sequence: tool.sequence || index + 1,
+            name: String(tool.name),
+            input: tool.input === undefined ? '' : String(tool.input),
+            ok: tool.ok !== false,
+            result: truncate(tool.result || '', 1000),
+            at: tool.at || parsed.generated_at || nowIso(),
+            source: tool.source || 'tool_ledger_marker',
+        }));
+    }
+    catch {
+        return [];
+    }
+};
 const recentMessageFromMemory = (item) => {
     const meta = metadataOf(item);
     const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
@@ -686,7 +718,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 || '',
@@ -699,26 +731,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;
@@ -738,6 +750,9 @@ const toolHistoryFromMemory = (item) => {
 const explicitToolHistoryItemsFromMemory = (item) => {
     const meta = metadataOf(item);
     const content = meta.content || item.memory || item.text || item.value || item.content || item.data;
+    const ledger = parseToolLedgerMarker(content);
+    if (ledger.length)
+        return ledger;
     const marked = parseToolHistoryMarker(content);
     if (marked)
         return [marked];
@@ -1268,17 +1283,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 || '')))
@@ -1336,8 +1352,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);
@@ -1345,31 +1361,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;
@@ -1377,47 +1384,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 || '')));
@@ -1426,20 +1415,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())
@@ -1447,41 +1430,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 = {} }) => {
@@ -1506,11 +1462,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,
@@ -1523,41 +1479,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',
@@ -1608,7 +1548,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: {
@@ -1654,7 +1599,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,
@@ -1669,11 +1613,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(),
     };
@@ -1684,13 +1627,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 {};
@@ -1720,9 +1663,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 = {};
@@ -1741,8 +1682,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)) {
@@ -1786,7 +1728,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'),
@@ -1795,19 +1737,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),
     };
@@ -1815,12 +1759,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({
@@ -1829,7 +1767,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,
@@ -2047,8 +1987,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({
@@ -2184,9 +2124,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({
@@ -2915,6 +2855,13 @@ class Mem0Memory {
                         thread_id: threadId,
                     }, ids));
                 }
+                clientMemories.push(await createClientVectorMemory(connectedEmbedding, encodeToolLedger(toolHistoryForTurn, threadId), {
+                    kind: 'tool_ledger',
+                    thread_id: threadId,
+                    project: project || undefined,
+                    source: 'n8n_connected_embedding',
+                    generated_at: nowIso(),
+                }, ids));
             }
             await saveClientVectorMemories(this, clientMemories, ids);
             if (adv.includeRecentMessages !== false && recentForMem0.length) {
@@ -2968,6 +2915,23 @@ class Mem0Memory {
                         tool: tool.name,
                     });
                 }
+                await safePersistLegacyMemory(this, {
+                    messages: [{ role: 'system', content: encodeToolLedger(toolHistoryForTurn, threadId) }],
+                    infer: false,
+                    user_id: body.user_id,
+                    agent_id: body.agent_id,
+                    run_id: body.run_id,
+                    metadata: {
+                        kind: 'tool_ledger',
+                        thread_id: threadId,
+                        project: project || undefined,
+                        source: 'tembory_transcript',
+                        generated_at: nowIso(),
+                    },
+                }, {
+                    kind: 'tool_ledger',
+                    user_id: body.user_id,
+                });
             }
             return;
         }
@@ -3015,6 +2979,20 @@ class Mem0Memory {
                     },
                 });
             }
+            await GenericFunctions_1.mem0ApiRequest.call(this, 'POST', '/v1/memories/', {
+                messages: [{ role: 'system', content: encodeToolLedger(toolHistoryForTurn, threadId) }],
+                infer: false,
+                user_id: body.user_id,
+                agent_id: body.agent_id,
+                run_id: body.run_id,
+                metadata: {
+                    kind: 'tool_ledger',
+                    thread_id: threadId,
+                    project: project || undefined,
+                    source: 'tembory_transcript',
+                    generated_at: nowIso(),
+                },
+            });
         }
         if (adv.persistToolFactsToMem0 && toolCalls.length) {
             const facts = toolCalls.map((tool) => `Tool ${tool.name} input=${tool.input}${tool.result ? ` result=${tool.result}` : ''}`).join('\n');
@@ -3712,8 +3690,6 @@ exports.__private = {
     explicitToolHistoryItemsFromMemory,
     toolHistoryFromMemory,
     cleanAssistantTranscriptText,
-    availabilityFromRecentMessages,
-    preReservationFromRecentMessages,
     buildActionDirective,
     recentMessageFromMemory,
     previousUserFallbackFromWorkingMemory,
@@ -3724,8 +3700,10 @@ exports.__private = {
     applyToolHistoryWindow,
     dedupeRecentMessages,
     parseToolHistoryMarker,
+    parseToolLedgerMarker,
     parseRecentMessageMarker,
     encodeToolCall,
+    encodeToolLedger,
     encodeRecentMessage,
     userKeyFrom,
     applyOperationalPreset,