n8n-nodes-tembory 1.1.26 → 1.1.28

package/dist/nodes/Tembory/TemboryMemory.node.js

@@ -153,38 +153,39 @@ const currentInputJsonFromContext = (ctx, itemIndex = 0) => {
         return {};
     }
 };
-const resolveCurrentTurnQuery = (ctx, itemIndex = 0, inputValues = {}, queryParam = '') => {
+const resolveCurrentTurnQueryWithSource = (ctx, itemIndex = 0, inputValues = {}, queryParam = '') => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
     const inputJson = currentInputJsonFromContext(ctx, itemIndex);
     const candidates = [
-        queryParam,
-        inputValues.query,
-        inputValues.input,
-        inputValues.chatInput,
-        inputValues.text,
-        inputValues.question,
-        inputValues.message,
-        inputJson.query,
-        inputJson.lastUserMessage,
-        inputJson.chatInput,
-        inputJson.input,
-        inputJson.text,
-        inputJson.message,
-        (_a = inputJson.body) === null || _a === void 0 ? void 0 : _a.consolidated_text,
-        (_b = inputJson.body) === null || _b === void 0 ? void 0 : _b.chatInput,
-        (_c = inputJson.body) === null || _c === void 0 ? void 0 : _c.message,
-        (_d = inputJson.body) === null || _d === void 0 ? void 0 : _d.text,
-        (_e = inputJson.body) === null || _e === void 0 ? void 0 : _e.input,
-        (_h = (_g = (_f = inputJson.body) === null || _f === void 0 ? void 0 : _f.messages) === null || _g === void 0 ? void 0 : _g[0]) === null || _h === void 0 ? void 0 : _h.text,
-        (_k = (_j = inputJson.body) === null || _j === void 0 ? void 0 : _j.messages) === null || _k === void 0 ? void 0 : _k[0],
+        ['query_param', queryParam],
+        ['input_values.query', inputValues.query],
+        ['input_values.input', inputValues.input],
+        ['input_values.chatInput', inputValues.chatInput],
+        ['input_values.text', inputValues.text],
+        ['input_values.question', inputValues.question],
+        ['input_values.message', inputValues.message],
+        ['input_json.query', inputJson.query],
+        ['input_json.lastUserMessage', inputJson.lastUserMessage],
+        ['input_json.chatInput', inputJson.chatInput],
+        ['input_json.input', inputJson.input],
+        ['input_json.text', inputJson.text],
+        ['input_json.message', inputJson.message],
+        ['input_json.body.consolidated_text', (_a = inputJson.body) === null || _a === void 0 ? void 0 : _a.consolidated_text],
+        ['input_json.body.chatInput', (_b = inputJson.body) === null || _b === void 0 ? void 0 : _b.chatInput],
+        ['input_json.body.message', (_c = inputJson.body) === null || _c === void 0 ? void 0 : _c.message],
+        ['input_json.body.text', (_d = inputJson.body) === null || _d === void 0 ? void 0 : _d.text],
+        ['input_json.body.input', (_e = inputJson.body) === null || _e === void 0 ? void 0 : _e.input],
+        ['input_json.body.messages.0.text', (_h = (_g = (_f = inputJson.body) === null || _f === void 0 ? void 0 : _f.messages) === null || _g === void 0 ? void 0 : _g[0]) === null || _h === void 0 ? void 0 : _h.text],
+        ['input_json.body.messages.0', (_k = (_j = inputJson.body) === null || _j === void 0 ? void 0 : _j.messages) === null || _k === void 0 ? void 0 : _k[0]],
     ];
-    for (const candidate of candidates) {
+    for (const [source, candidate] of candidates) {
         const query = asSearchQuery(candidate).trim();
         if (query)
-            return stripThreadTestPrefix(query);
+            return { query: stripThreadTestPrefix(query), source };
     }
-    return '';
+    return { query: '', source: 'missing' };
 };
+const resolveCurrentTurnQuery = (ctx, itemIndex = 0, inputValues = {}, queryParam = '') => resolveCurrentTurnQueryWithSource(ctx, itemIndex, inputValues, queryParam).query;
 const memoryText = (memory) => {
     if (!memory)
         return '';
@@ -1205,16 +1206,18 @@ const getMemoryStore = (ctx) => {
         data.tembory.activeSummary = data.tembory.activeSummary || {};
         data.tembory.connectedModelSummaryCache = data.tembory.connectedModelSummaryCache || {};
         data.tembory.captureState = data.tembory.captureState || {};
+        data.tembory.memoryDedupe = data.tembory.memoryDedupe || {};
         return data.tembory;
     }
     catch {
-        global.__temboryMemory = global.__temboryMemory || { toolHistory: {}, recentMessages: {}, profileFacts: {}, workingMemory: {}, decisionState: {}, memoryCompression: {}, activeSummary: {}, connectedModelSummaryCache: {}, captureState: {} };
+        global.__temboryMemory = global.__temboryMemory || { toolHistory: {}, recentMessages: {}, profileFacts: {}, workingMemory: {}, decisionState: {}, memoryCompression: {}, activeSummary: {}, connectedModelSummaryCache: {}, captureState: {}, memoryDedupe: {} };
         global.__temboryMemory.workingMemory = global.__temboryMemory.workingMemory || {};
         global.__temboryMemory.decisionState = global.__temboryMemory.decisionState || {};
         global.__temboryMemory.memoryCompression = global.__temboryMemory.memoryCompression || {};
         global.__temboryMemory.activeSummary = global.__temboryMemory.activeSummary || {};
         global.__temboryMemory.connectedModelSummaryCache = global.__temboryMemory.connectedModelSummaryCache || {};
         global.__temboryMemory.captureState = global.__temboryMemory.captureState || {};
+        global.__temboryMemory.memoryDedupe = global.__temboryMemory.memoryDedupe || {};
         return global.__temboryMemory;
     }
 };
@@ -1268,6 +1271,8 @@ const mergeRemoteThreadState = (store, key, state) => {
         store.memoryCompression[key] = state.memoryCompression;
     if (state.captureState && typeof state.captureState === 'object')
         store.captureState[key] = { ...(store.captureState[key] || {}), ...state.captureState };
+    if (state.memoryDedupe && typeof state.memoryDedupe === 'object')
+        store.memoryDedupe[key] = mergeMemoryDedupeState(store.memoryDedupe[key], state.memoryDedupe);
     if (typeof state.activeSummary === 'string' && state.activeSummary)
         store.activeSummary[key] = state.activeSummary;
 };
@@ -1632,6 +1637,195 @@ const normalizeIntentText = (value = '') => String(value || '')
     .toLowerCase()
     .normalize('NFD')
     .replace(/[\u0300-\u036f]/g, '');
+const MEMORY_DEDUPE_MAX_KEYS = 600;
+const LEDGER_MEMORY_KINDS = new Set(['conversation_ledger', 'tool_ledger', 'turn_archive']);
+const normalizeDedupeText = (value = '') => normalizeIntentText(value).replace(/\s+/g, ' ').trim();
+const memoryBodyText = (body = {}) => {
+    const messages = Array.isArray(body.messages) ? body.messages : [];
+    if (messages.length)
+        return messages.map((message) => message.content || message.text || message.message || '').filter(Boolean).join('\n');
+    return body.memory || body.text || body.value || body.content || '';
+};
+const parseTurnArchiveText = (text = '') => {
+    const raw = String(text || '');
+    const start = raw.indexOf('{');
+    if (start < 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw.slice(start));
+        return parsed && parsed.marker === 'tembory_turn_archive_v1' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const compactToolForDedupe = (tool = {}, index = 0) => ({
+    id: tool.id || tool.callId || tool.call_id || undefined,
+    sequence: tool.sequence || index + 1,
+    name: tool.name || tool.tool || tool.toolName || '',
+    input: canonicalToolInput(tool.input || tool.toolInput || tool.args || ''),
+    ok: tool.ok !== false && tool.status !== 'failed',
+    result: String(tool.result || tool.output || ''),
+});
+const canonicalMemoryPayloadForDedupe = (kind = 'memory', body = {}, diagnostics = {}) => {
+    const meta = body.metadata || {};
+    const text = memoryBodyText(body);
+    if (kind === 'recent_message') {
+        const marker = parseRecentMessageMarker(text);
+        return stableStringify({
+            role: meta.role || marker?.role || 'user',
+            content: normalizeDedupeText(meta.content || marker?.content || text),
+        });
+    }
+    if (kind === 'tool_history') {
+        const marker = parseToolHistoryMarker(text);
+        const tool = marker || {
+            id: meta.id,
+            turnId: meta.turn_id || meta.turnId,
+            sequence: meta.sequence,
+            name: meta.name || diagnostics.tool,
+            input: meta.input,
+            ok: meta.ok,
+            result: meta.result,
+        };
+        return stableStringify(compactToolForDedupe(tool));
+    }
+    if (kind === 'tool_ledger') {
+        return stableStringify(dedupeToolHistory(parseToolLedgerMarker(text)).map(compactToolForDedupe));
+    }
+    if (kind === 'conversation_ledger') {
+        const messages = parseConversationLedgerMarker(text);
+        return stableStringify((messages || []).map((message) => ({
+            role: message.role || 'user',
+            content: normalizeDedupeText(message.content || ''),
+        })));
+    }
+    if (kind === 'turn_archive') {
+        const archive = parseTurnArchiveText(text);
+        if (archive) {
+            return stableStringify({
+                conversation: (archive.conversation || []).map((message) => ({
+                    role: message.role || 'user',
+                    content: normalizeDedupeText(message.content || ''),
+                })),
+                tools: (archive.tools || []).map(compactToolForDedupe),
+            });
+        }
+    }
+    return normalizeDedupeText(String(text || '')
+        .replace(/"generated_at"\s*:\s*"[^"]+"/g, '"generated_at":"<ts>"')
+        .replace(/"timestamp"\s*:\s*"[^"]+"/g, '"timestamp":"<ts>"'));
+};
+const inferMemoryKindFromText = (text = '') => {
+    const raw = String(text || '');
+    if (parseRecentMessageMarker(raw))
+        return 'recent_message';
+    if (parseToolHistoryMarker(raw))
+        return 'tool_history';
+    if (parseToolLedgerMarker(raw).length)
+        return 'tool_ledger';
+    if (parseConversationLedgerMarker(raw).length)
+        return 'conversation_ledger';
+    if (parseTurnArchiveText(raw))
+        return 'turn_archive';
+    return '';
+};
+const buildMemoryDedupeCandidate = (body = {}, diagnostics = {}) => {
+    const meta = body.metadata || {};
+    const text = memoryBodyText(body);
+    const kind = String(meta.kind || diagnostics.kind || inferMemoryKindFromText(text) || 'memory');
+    const thread = String(meta.thread_id || diagnostics.thread_id || body.thread_id || '');
+    const project = String(meta.project || diagnostics.project || body.project || '');
+    const slot = [kind, thread, project].filter(Boolean).join(':') || kind;
+    const canonical = canonicalMemoryPayloadForDedupe(kind, body, diagnostics);
+    const key = `${slot}:${stableHash(canonical)}`;
+    return cleanContextValue({
+        key,
+        slot,
+        kind,
+        content_hash: stableHash(canonical),
+        strategy: LEDGER_MEMORY_KINDS.has(kind) ? 'latest-ledger-per-content' : 'exact-canonical-content',
+    });
+};
+const mergeMemoryDedupeState = (current = {}, incoming = {}) => {
+    const merged = {
+        seen: { ...((current || {}).seen || {}), ...((incoming || {}).seen || {}) },
+        latestBySlot: { ...((current || {}).latestBySlot || {}), ...((incoming || {}).latestBySlot || {}) },
+        lastSummary: (incoming || {}).lastSummary || (current || {}).lastSummary || undefined,
+        updatedAt: (incoming || {}).updatedAt || (current || {}).updatedAt || undefined,
+    };
+    const entries = Object.entries(merged.seen);
+    if (entries.length > MEMORY_DEDUPE_MAX_KEYS) {
+        entries
+            .sort((a, b) => String(a[1] || '').localeCompare(String(b[1] || '')))
+            .slice(0, entries.length - MEMORY_DEDUPE_MAX_KEYS)
+            .forEach(([key]) => delete merged.seen[key]);
+    }
+    return cleanContextValue(merged);
+};
+const ensureMemoryDedupeState = (store, key) => {
+    store.memoryDedupe = store.memoryDedupe || {};
+    store.memoryDedupe[key] = mergeMemoryDedupeState(store.memoryDedupe[key] || {}, {});
+    store.memoryDedupe[key].seen = store.memoryDedupe[key].seen || {};
+    store.memoryDedupe[key].latestBySlot = store.memoryDedupe[key].latestBySlot || {};
+    return store.memoryDedupe[key];
+};
+const createDedupeSummary = () => ({
+    enabled: true,
+    write: { candidates: 0, persisted: 0, skipped: 0, byKind: {} },
+    load: {},
+});
+const recordDedupeWriteSummary = (summary, candidate, decision) => {
+    if (!summary || !candidate)
+        return;
+    summary.write.candidates += 1;
+    summary.write[decision.persist ? 'persisted' : 'skipped'] += 1;
+    summary.write.byKind[candidate.kind] = summary.write.byKind[candidate.kind] || { candidates: 0, persisted: 0, skipped: 0 };
+    summary.write.byKind[candidate.kind].candidates += 1;
+    summary.write.byKind[candidate.kind][decision.persist ? 'persisted' : 'skipped'] += 1;
+};
+const evaluateMemoryDedupeWrite = (state, candidate, at = nowIso()) => {
+    if (!candidate || !candidate.key)
+        return { persist: true, reason: 'no_dedupe_key' };
+    state.seen = state.seen || {};
+    state.latestBySlot = state.latestBySlot || {};
+    if (state.seen[candidate.key])
+        return { persist: false, reason: 'duplicate_memory_key' };
+    state.seen[candidate.key] = at;
+    state.latestBySlot[candidate.slot] = candidate.key;
+    state.updatedAt = at;
+    return { persist: true, reason: 'new_memory_key' };
+};
+const dedupeMemoryItemsForLoad = (items = []) => {
+    const list = Array.isArray(items) ? items : [];
+    const seen = new Set();
+    const seenSlots = new Set();
+    const out = [];
+    for (const item of [...list].reverse()) {
+        const candidate = buildMemoryDedupeCandidate({ messages: [{ role: 'system', content: memoryText(item) }], metadata: metadataOf(item) }, {});
+        const slotKey = LEDGER_MEMORY_KINDS.has(candidate.kind) ? candidate.slot : candidate.key;
+        const key = LEDGER_MEMORY_KINDS.has(candidate.kind) ? slotKey : candidate.key;
+        if (LEDGER_MEMORY_KINDS.has(candidate.kind)) {
+            if (seenSlots.has(slotKey))
+                continue;
+            seenSlots.add(slotKey);
+        }
+        else if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        out.push(item);
+    }
+    out.reverse();
+    return {
+        items: out,
+        summary: cleanContextValue({
+            input: list.length,
+            kept: out.length,
+            removed: Math.max(0, list.length - out.length),
+        }),
+    };
+};
 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);
@@ -2287,6 +2481,7 @@ const compactSaveAuditForAgent = (capture = {}) => cleanContextValue({
         tool_history_after_save: capture.last_save_tool_history_after_save,
         thread_state_saved: capture.last_save_thread_state_saved,
         backend_memory_persistence: capture.last_save_backend_memory_persistence,
+        dedupe: capture.last_save_dedupe_summary,
     },
 });
 const compactEntityTimelineForAgent = (timeline = [], maxItems = 8) => pruneByLimit(timeline || [], maxItems).map((item) => cleanContextValue({
@@ -2431,8 +2626,8 @@ const compactToolAuditForSideChannel = (tool = {}) => cleanContextValue({
     status: tool.status || (tool.ok === false ? 'failed' : 'ok'),
     at: tool.at || tool.timestamp,
     timestamp: tool.timestamp || tool.at,
-    input: truncate(String(tool.input || tool.tool_args || tool.normalized_args || ''), 500) || undefined,
-    output: compactToolResult(tool.result !== undefined ? tool.result : tool.output !== undefined ? tool.output : tool.observation, 1200),
+    input: truncate(String(tool.input || tool.tool_args || tool.normalized_args || ''), 300) || undefined,
+    output: compactToolResult(tool.result !== undefined ? tool.result : tool.output !== undefined ? tool.output : tool.observation, 800),
 });
 const compactMessageForSideChannel = (message = {}) => {
     const type = messageTypeOf(message) || String(message.role || 'message').toLowerCase();
@@ -2456,7 +2651,7 @@ const normalizeConversationRoleForSideChannel = (role = '') => {
         return 'tool';
     return normalized || 'message';
 };
-const compactConversationTimelineForSideChannel = (conversation = {}, maxItems = 12) => {
+const compactConversationTimelineForSideChannel = (conversation = {}, maxItems = 4, includeFull = false) => {
     const chronological = Array.isArray(conversation.conversation_history_chronological)
         ? conversation.conversation_history_chronological
         : [];
@@ -2472,13 +2667,12 @@ const compactConversationTimelineForSideChannel = (conversation = {}, maxItems =
             at,
             chars: content.length,
             preview,
-            content: preview,
-            message: {
+            message: includeFull ? {
                 role,
                 at,
                 content: role === 'system' ? '[system context hidden]' : truncate(content, 2000),
                 truncated: content.length > 2000,
-            },
+            } : undefined,
         });
     });
 };
@@ -2508,11 +2702,11 @@ const compactMemoryEventPayload = (payload = {}) => {
         compact.toolNames = compact.toolCalls
             .map((tool) => (tool && (tool.name || tool.tool_name || tool.tool)) || '')
             .filter(Boolean)
-            .slice(0, 20);
+            .slice(0, 12);
         compact.toolEvents = compact.toolCalls
             .map((tool) => compactToolAuditForSideChannel(tool || {}))
             .filter((tool) => tool && Object.keys(tool).length)
-            .slice(0, 20);
+            .slice(0, 8);
         delete compact.toolCalls;
     }
     for (const key of ['input', 'output', 'values', 'chatHistory', 'context', 'contextText', 'diagnostics']) {
@@ -2522,6 +2716,49 @@ const compactMemoryEventPayload = (payload = {}) => {
     }
     return compact;
 };
+const compactLastSaveForSideChannel = (lastSave = {}) => cleanContextValue({
+    saved: lastSave.saved,
+    status: lastSave.status,
+    at: lastSave.at,
+    inputChars: lastSave.input_chars,
+    outputChars: lastSave.output_chars,
+    toolCallsCaptured: lastSave.tool_calls_captured,
+    toolNames: lastSave.tool_names,
+    conversationMessagesAfterSave: lastSave.conversation_messages_after_save,
+    toolHistoryAfterSave: lastSave.tool_history_after_save,
+    threadStateSaved: lastSave.thread_state_saved,
+    backendPersistence: lastSave.backend_memory_persistence,
+});
+const compactDedupeForSideChannel = (dedupe = {}) => {
+    const load = dedupe.load || {};
+    const removedOnLoad = Object.values(load).reduce((sum, item) => sum + Number((item || {}).removed || 0), 0);
+    const write = dedupe.lastSave?.write || dedupe.write || {};
+    return cleanContextValue({
+        enabled: dedupe.enabled,
+        removedOnLoad,
+        skippedWrites: Number(write.skipped || 0),
+        persistedWrites: Number(write.persisted || 0),
+        candidates: Number(write.candidates || 0),
+    });
+};
+const loadedSectionsForSideChannel = (parsed = {}, memoryAudit = {}) => cleanContextValue({
+    conversation: Boolean(parsed.conversation),
+    summary: Boolean(parsed.summary),
+    activeSummary: Boolean(parsed.activeSummary),
+    connectedModelSummary: Boolean(parsed.connectedModelSummary),
+    workingMemory: Boolean(parsed.workingMemory),
+    decisionState: Boolean(parsed.decisionState),
+    memoryCompression: Boolean(parsed.memoryCompression),
+    operationalState: Boolean(parsed.operationalState),
+    actionLedger: Array.isArray(parsed.actionLedger),
+    turnBrief: Boolean(parsed.turnBrief || parsed.turn_brief),
+    memoryAudit: Boolean(memoryAudit && Object.keys(memoryAudit).length),
+    entityTimeline: Array.isArray(parsed.entityTimeline),
+    vectorMemories: Array.isArray(parsed.vectorMemories),
+    graph: Array.isArray(parsed.graph),
+    recentHighlights: Array.isArray(parsed.recentHighlights),
+    contextHealth: Boolean(parsed.contextHealth),
+});
 const summarizeMemoryMessagesForSideChannel = (messages = []) => {
     const list = Array.isArray(messages) ? messages : [];
     const summary = { messages: list.length };
@@ -2538,20 +2775,45 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
         const toolItems = Array.isArray(tools.items) ? tools.items : [];
         const memoryAudit = parsed.memoryAudit || parsed.memory_audit || {};
         const summaryText = parsed.summary?.slm || parsed.summary || parsed.connectedModelSummary || parsed.activeSummary || '';
+        const chronological = Array.isArray(conversation.conversation_history_chronological)
+            ? conversation.conversation_history_chronological
+            : [];
+        const allUserMessages = Array.isArray(conversation.all_user_messages_chronological)
+            ? conversation.all_user_messages_chronological
+            : chronological.filter((message) => normalizeConversationRoleForSideChannel(message.role || message.type) === 'user');
+        const lastUser = [...chronological].reverse().find((message) => normalizeConversationRoleForSideChannel(message.role || message.type) === 'user');
+        const lastAgent = [...chronological].reverse().find((message) => normalizeConversationRoleForSideChannel(message.role || message.type) === 'agent');
+        const includeDebug = Boolean(parsed.options?.includeDiagnostics || parsed.diagnostics?.includeDiagnostics || parsed.diagnostics?.include_diagnostics);
+        const lastSave = compactLastSaveForSideChannel(memoryAudit.last_save || parsed.state?.last_save || {});
+        const fullDedupeSummary = parsed.dedupeSummary || parsed.diagnostics?.dedupeSummary || undefined;
+        const loadedSections = loadedSectionsForSideChannel(parsed, memoryAudit);
         summary.userId = parsed.userId;
         summary.project = parsed.project || undefined;
         summary.retrievalMode = parsed.retrievalMode;
         summary.payloadFormat = parsed.payloadFormat;
-        summary.options = cleanContextValue(parsed.options || {});
         summary.intent = parsed.observations?.inferred_intent?.label || parsed.workingMemory?.last_user_intent || parsed.decisionState?.current_intent || undefined;
         const parsedTurnBrief = parsed.turnBrief || parsed.turn_brief || undefined;
+        summary.currentTurn = parsed.currentTurn || parsed.current_turn || parsed.diagnostics?.currentTurn || undefined;
         summary.currentUserMessage = conversation.current_user_message ? truncate(conversation.current_user_message, 180) : undefined;
-        summary.recentMessages = Array.isArray(conversation.conversation_history_chronological) ? conversation.conversation_history_chronological.length : undefined;
-        summary.conversationTimeline = compactConversationTimelineForSideChannel(conversation, 12);
+        summary.recentMessages = chronological.length || undefined;
+        summary.conversation = cleanContextValue({
+            messages: chronological.length,
+            userMessages: allUserMessages.length,
+            currentUserMessage: summary.currentUserMessage,
+            lastUser: lastUser ? {
+                at: lastUser.at || lastUser.timestamp || lastUser.created_at || lastUser.createdAt,
+                preview: truncate(String(lastUser.content || lastUser.text || lastUser.message || ''), 240),
+            } : undefined,
+            lastAgent: lastAgent ? {
+                at: lastAgent.at || lastAgent.timestamp || lastAgent.created_at || lastAgent.createdAt,
+                preview: truncate(String(lastAgent.content || lastAgent.text || lastAgent.message || ''), 240),
+            } : undefined,
+        });
+        summary.conversationTimeline = compactConversationTimelineForSideChannel(conversation, 4);
         summary.toolCount = toolItems.length || tools.count || parsed.operationalState?.tool_counts?.total || undefined;
-        summary.toolNames = toolItems.map((tool) => tool.name || tool.tool_name).filter(Boolean).slice(0, 20);
+        summary.toolNames = toolItems.map((tool) => tool.name || tool.tool_name).filter(Boolean).slice(0, 12);
         summary.toolEvents = toolItems
-            .slice(-6)
+            .slice(-3)
             .map((tool) => compactToolAuditForSideChannel(tool || {}))
             .filter((tool) => tool && Object.keys(tool).length);
         summary.lastTool = tools.last_successful_tool
@@ -2571,8 +2833,8 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
             })
             : parsedTurnBrief;
         summary.counts = cleanContextValue({
-            conversationMessages: Array.isArray(conversation.conversation_history_chronological) ? conversation.conversation_history_chronological.length : undefined,
-            userMessages: Array.isArray(conversation.all_user_messages_chronological) ? conversation.all_user_messages_chronological.length : undefined,
+            conversationMessages: chronological.length || undefined,
+            userMessages: allUserMessages.length || undefined,
             toolHistory: toolItems.length,
             actionLedger: Array.isArray(parsed.actionLedger) ? parsed.actionLedger.length : undefined,
             entityTimeline: Array.isArray(parsed.entityTimeline) ? parsed.entityTimeline.length : undefined,
@@ -2580,25 +2842,8 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
             graph: Array.isArray(parsed.graph) ? parsed.graph.length : undefined,
             recentHighlights: Array.isArray(parsed.recentHighlights) ? parsed.recentHighlights.length : undefined,
         });
-        summary.lastSave = memoryAudit.last_save || parsed.state?.last_save || undefined;
-        summary.loadedSections = cleanContextValue({
-            conversation: Boolean(parsed.conversation),
-            summary: Boolean(parsed.summary),
-            activeSummary: Boolean(parsed.activeSummary),
-            connectedModelSummary: Boolean(parsed.connectedModelSummary),
-            workingMemory: Boolean(parsed.workingMemory),
-            decisionState: Boolean(parsed.decisionState),
-            memoryCompression: Boolean(parsed.memoryCompression),
-            operationalState: Boolean(parsed.operationalState),
-            actionLedger: Array.isArray(parsed.actionLedger),
-            turnBrief: Boolean(parsed.turnBrief || parsed.turn_brief),
-            memoryAudit: Boolean(memoryAudit && Object.keys(memoryAudit).length),
-            entityTimeline: Array.isArray(parsed.entityTimeline),
-            vectorMemories: Array.isArray(parsed.vectorMemories),
-            graph: Array.isArray(parsed.graph),
-            recentHighlights: Array.isArray(parsed.recentHighlights),
-            contextHealth: Boolean(parsed.contextHealth),
-        });
+        summary.lastSave = Object.keys(lastSave).length ? lastSave : undefined;
+        summary.dedupe = fullDedupeSummary ? compactDedupeForSideChannel(fullDedupeSummary) : undefined;
         summary.workingMemory = cleanContextValue({
             currentGoal: parsed.workingMemory?.current_goal,
             currentGoalReason: parsed.workingMemory?.current_goal_reason,
@@ -2619,8 +2864,14 @@ const summarizeMemoryMessagesForSideChannel = (messages = []) => {
             doNotRepeatTools: parsed.decisionState?.do_not_repeat_tools,
         });
         summary.quality = parsed.contextHealth?.quality_score || parsed.contextQualityScore || undefined;
-        summary.contextSize = parsed.diagnostics?.contextSize || undefined;
-        summary.summaryChars = typeof summaryText === 'string' ? summaryText.length : safeStringify(summaryText).length;
+        summary.debug = includeDebug ? cleanContextValue({
+            options: parsed.options,
+            loadedSections,
+            contextSize: parsed.diagnostics?.contextSize,
+            summaryChars: typeof summaryText === 'string' ? summaryText.length : safeStringify(summaryText).length,
+            dedupeSummary: fullDedupeSummary,
+            conversationTimelineFull: compactConversationTimelineForSideChannel(conversation, 12, true),
+        }) : undefined;
         return Object.fromEntries(Object.entries(summary).filter(([, value]) => value !== undefined));
     }
     catch {
@@ -2837,6 +3088,7 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
                 current_user_request: focus.current_user_request,
                 instruction: focus.instruction,
             }),
+            currentTurn: diagnostics?.currentTurn,
             action_directive: directive ? cleanContextValue({
                 required_tool: directive.required_tool,
                 next_expected_action: directive.next_expected_action,
@@ -2856,6 +3108,7 @@ const buildContextMessages = ({ payloadFormat, query, userId, profileFacts, work
             profile: sectionValue('profile_facts'),
             tools: compactToolLedger,
             memoryAudit,
+            dedupeSummary: diagnostics?.dedupeSummary,
         });
         const renderCompactSection = (section) => {
             if (section.value === null || section.value === undefined)
@@ -3375,6 +3628,58 @@ class TemboryMemory {
         const output = cleanAssistantTranscriptText(rawOutput);
         const toolCalls = extractToolCalls(outputValues);
         const saveAt = nowIso();
+        const dedupeState = ensureMemoryDedupeState(store, key);
+        const dedupeSummary = createDedupeSummary();
+        const persistLegacyMemory = async (legacyBody, diagnostics = {}) => {
+            const candidate = buildMemoryDedupeCandidate(legacyBody, diagnostics);
+            const decision = evaluateMemoryDedupeWrite(dedupeState, candidate, saveAt);
+            recordDedupeWriteSummary(dedupeSummary, candidate, decision);
+            if (!decision.persist)
+                return { skipped: true, reason: decision.reason, dedupeKey: candidate.key };
+            const bodyWithDedupe = {
+                ...legacyBody,
+                metadata: cleanContextValue({
+                    ...(legacyBody.metadata || {}),
+                    memory_dedupe_key: candidate.key,
+                    memory_dedupe_slot: candidate.slot,
+                    memory_dedupe_strategy: candidate.strategy,
+                }),
+            };
+            return await safePersistLegacyMemory(this, bodyWithDedupe, {
+                ...diagnostics,
+                memory_dedupe_key: candidate.key,
+                memory_dedupe_slot: candidate.slot,
+            });
+        };
+        const finalizeDedupeSummary = async () => {
+            dedupeState.lastSummary = dedupeSummary;
+            dedupeState.updatedAt = nowIso();
+            store.memoryDedupe[key] = mergeMemoryDedupeState(store.memoryDedupe[key], dedupeState);
+            store.captureState[key] = cleanContextValue({
+                ...(store.captureState[key] || {}),
+                last_save_dedupe_summary: dedupeSummary,
+            });
+            const finalThreadStateSaved = await saveThreadState(this, key, threadId, project, {
+                kind: 'tembory.thread_state.v1',
+                threadId,
+                project: project || undefined,
+                updatedAt: nowIso(),
+                recentMessages: recentForTurn,
+                toolHistory: toolHistoryForTurn,
+                profileFacts: store.profileFacts[key] || {},
+                workingMemory: workingMemoryForTurn,
+                decisionState: decisionStateForTurn,
+                memoryCompression: compressionForTurn,
+                operationalState: operationalStateForTurn,
+                captureState: store.captureState[key],
+                memoryDedupe: store.memoryDedupe[key],
+                activeSummary: store.activeSummary[key] || '',
+            });
+            store.captureState[key] = cleanContextValue({
+                ...(store.captureState[key] || {}),
+                last_save_thread_state_saved: (store.captureState[key] || {}).last_save_thread_state_saved || finalThreadStateSaved,
+            });
+        };
         store.captureState[key] = {
             last_save_status: 'started',
             last_save_saved: false,
@@ -3388,6 +3693,7 @@ class TemboryMemory {
             last_save_tool_calls_captured: toolCalls.length,
             last_save_tool_names: toolCalls.map((tool) => tool.name).filter(Boolean).slice(0, 20),
             last_save_capture_sources: Array.from(new Set(toolCalls.map((tool) => tool.source).filter(Boolean))),
+            last_save_dedupe_summary: dedupeSummary,
         };
         const recentForTembory = [];
         const profileFromTurn = extractProfileFactsFromText(input, 'user_message', nowIso());
@@ -3488,6 +3794,7 @@ class TemboryMemory {
                 : adv.useVectorMemory === false
                     ? 'thread_state_only'
                     : 'enabled',
+            last_save_dedupe_summary: dedupeSummary,
         });
         const threadStateSaved = await saveThreadState(this, key, threadId, project, {
             kind: 'tembory.thread_state.v1',
@@ -3502,6 +3809,7 @@ class TemboryMemory {
             memoryCompression: compressionForTurn,
             operationalState: operationalStateForTurn,
             captureState: nextCaptureState,
+            memoryDedupe: dedupeState,
             activeSummary: store.activeSummary[key] || '',
         });
         store.captureState[key] = cleanContextValue({
@@ -3513,10 +3821,14 @@ class TemboryMemory {
             globalData.__dataChanged = true;
         }
         catch { }
-        if (adv.persistBackendMemories === false)
+        if (adv.persistBackendMemories === false) {
+            await finalizeDedupeSummary();
             return;
-        if (adv.useVectorMemory === false)
+        }
+        if (adv.useVectorMemory === false) {
+            await finalizeDedupeSummary();
             return;
+        }
         const connectedEmbedding = await getConnectedEmbedding(this, itemIndex);
         if (connectedEmbedding) {
             const ids = { user_id: body.user_id, agent_id: body.agent_id, run_id: body.run_id };
@@ -3529,21 +3841,32 @@ class TemboryMemory {
                 memoryCompression: compressionForTurn,
                 operationalState: operationalStateForTurn,
             });
-            await saveClientVectorMemories(this, [
-                await createClientVectorMemory(connectedEmbedding, archiveText, {
-                    kind: 'turn_archive',
-                    thread_id: threadId,
-                    project: project || undefined,
-                    source: 'n8n_connected_embedding',
-                    generated_at: nowIso(),
-                    message_count: recentForTurn.length,
-                    tool_count: toolHistoryForTurn.length,
-                    latest_tool: toolHistoryForTurn.at(-1)?.name || null,
-                }, ids),
-            ], ids);
+            const archiveMetadata = {
+                kind: 'turn_archive',
+                thread_id: threadId,
+                project: project || undefined,
+                source: 'n8n_connected_embedding',
+                generated_at: nowIso(),
+                message_count: recentForTurn.length,
+                tool_count: toolHistoryForTurn.length,
+                latest_tool: toolHistoryForTurn.at(-1)?.name || null,
+            };
+            const archiveCandidate = buildMemoryDedupeCandidate({ messages: [{ role: 'system', content: archiveText }], metadata: archiveMetadata }, { kind: 'turn_archive', user_id: body.user_id });
+            const archiveDecision = evaluateMemoryDedupeWrite(dedupeState, archiveCandidate, saveAt);
+            recordDedupeWriteSummary(dedupeSummary, archiveCandidate, archiveDecision);
+            if (archiveDecision.persist) {
+                await saveClientVectorMemories(this, [
+                    await createClientVectorMemory(connectedEmbedding, archiveText, {
+                        ...archiveMetadata,
+                        memory_dedupe_key: archiveCandidate.key,
+                        memory_dedupe_slot: archiveCandidate.slot,
+                        memory_dedupe_strategy: archiveCandidate.strategy,
+                    }, ids),
+                ], ids);
+            }
             if (adv.includeRecentMessages !== false && recentForTembory.length) {
                 for (const recent of recentForTembory) {
-                    await safePersistLegacyMemory(this, {
+                    await persistLegacyMemory({
                         messages: [{ role: 'system', content: encodeRecentMessage(recent, threadId) }],
                         infer: false,
                         user_id: body.user_id,
@@ -3561,9 +3884,10 @@ class TemboryMemory {
                     }, {
                         kind: 'recent_message',
                         user_id: body.user_id,
+                        thread_id: threadId,
                     });
                 }
-                await safePersistLegacyMemory(this, {
+                await persistLegacyMemory({
                     messages: [{ role: 'system', content: encodeConversationLedger(recentForTurn, threadId) }],
                     infer: false,
                     user_id: body.user_id,
@@ -3579,11 +3903,12 @@ class TemboryMemory {
                 }, {
                     kind: 'conversation_ledger',
                     user_id: body.user_id,
+                    thread_id: threadId,
                 });
             }
             if (adv.includeToolHistory !== false && toolCalls.length) {
                 for (const tool of toolCalls) {
-                    await safePersistLegacyMemory(this, {
+                    await persistLegacyMemory({
                         messages: [{ role: 'system', content: encodeToolCall(tool, threadId) }],
                         infer: false,
                         user_id: body.user_id,
@@ -3607,9 +3932,10 @@ class TemboryMemory {
                         kind: 'tool_history',
                         user_id: body.user_id,
                         tool: tool.name,
+                        thread_id: threadId,
                     });
                 }
-                await safePersistLegacyMemory(this, {
+                await persistLegacyMemory({
                     messages: [{ role: 'system', content: encodeToolLedger(toolHistoryForTurn, threadId) }],
                     infer: false,
                     user_id: body.user_id,
@@ -3625,18 +3951,21 @@ class TemboryMemory {
                 }, {
                     kind: 'tool_ledger',
                     user_id: body.user_id,
+                    thread_id: threadId,
                 });
             }
+            await finalizeDedupeSummary();
             return;
         }
         if (messages.length)
-            await safePersistLegacyMemory(this, body, {
+            await persistLegacyMemory(body, {
                 kind: 'conversation_messages',
                 user_id: body.user_id,
+                thread_id: threadId,
             });
         if (adv.includeRecentMessages !== false && recentForTembory.length) {
             for (const recent of recentForTembory) {
-                await safePersistLegacyMemory(this, {
+                await persistLegacyMemory({
                     messages: [{ role: 'system', content: encodeRecentMessage(recent, threadId) }],
                     infer: false,
                     user_id: body.user_id,
@@ -3653,9 +3982,10 @@ class TemboryMemory {
                 }, {
                     kind: 'recent_message',
                     user_id: body.user_id,
+                    thread_id: threadId,
                 });
             }
-            await safePersistLegacyMemory(this, {
+            await persistLegacyMemory({
                 messages: [{ role: 'system', content: encodeConversationLedger(recentForTurn, threadId) }],
                 infer: false,
                 user_id: body.user_id,
@@ -3671,11 +4001,12 @@ class TemboryMemory {
             }, {
                 kind: 'conversation_ledger',
                 user_id: body.user_id,
+                thread_id: threadId,
             });
         }
         if (adv.includeToolHistory !== false && !adv.persistToolFactsToTembory && toolCalls.length) {
             for (const tool of toolCalls) {
-                await safePersistLegacyMemory(this, {
+                await persistLegacyMemory({
                     messages: [{ role: 'system', content: encodeToolCall(tool, threadId) }],
                     infer: false,
                     user_id: body.user_id,
@@ -3699,9 +4030,10 @@ class TemboryMemory {
                     kind: 'tool_history',
                     user_id: body.user_id,
                     tool: tool.name,
+                    thread_id: threadId,
                 });
             }
-            await safePersistLegacyMemory(this, {
+            await persistLegacyMemory({
                 messages: [{ role: 'system', content: encodeToolLedger(toolHistoryForTurn, threadId) }],
                 infer: false,
                 user_id: body.user_id,
@@ -3717,11 +4049,12 @@ class TemboryMemory {
             }, {
                 kind: 'tool_ledger',
                 user_id: body.user_id,
+                thread_id: threadId,
             });
         }
         if (adv.persistToolFactsToTembory && toolCalls.length) {
             const facts = toolCalls.map((tool) => `Tool ${tool.name} input=${tool.input}${tool.result ? ` result=${tool.result}` : ''}`).join('\n');
-            await safePersistLegacyMemory(this, {
+            await persistLegacyMemory({
                 messages: [{ role: 'system', content: `Tool facts (read-only):\n${truncate(facts, 2000)}` }],
                 infer: false,
                 user_id: body.user_id,
@@ -3729,9 +4062,10 @@ class TemboryMemory {
             }, {
                 kind: 'tool_facts',
                 user_id: body.user_id,
+                thread_id: threadId,
             });
             for (const tool of toolCalls) {
-                await safePersistLegacyMemory(this, {
+                await persistLegacyMemory({
                     messages: [{ role: 'system', content: encodeToolCall(tool, threadId) }],
                     infer: false,
                     user_id: body.user_id,
@@ -3754,9 +4088,29 @@ class TemboryMemory {
                     kind: 'tool_history',
                     user_id: body.user_id,
                     tool: tool.name,
+                    thread_id: threadId,
                 });
             }
+            await persistLegacyMemory({
+                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,
+                thread_id: threadId,
+            });
         }
+        await finalizeDedupeSummary();
     }
     async loadMemoryVariablesForItem(itemIndex, inputValues = {}) {
         var _a, _b, _c, _d, _e, _f, _g;
@@ -3773,7 +4127,8 @@ class TemboryMemory {
         const store = getMemoryStore(this);
         const key = userKeyFrom(threadId, adv, project);
         const queryParam = this.getNodeParameter('query', itemIndex, '');
-        const query = resolveCurrentTurnQuery(this, itemIndex, inputValues, queryParam);
+        const currentTurn = resolveCurrentTurnQueryWithSource(this, itemIndex, inputValues, queryParam);
+        const query = currentTurn.query;
         const remoteThreadState = await loadThreadState(this, key, threadId, project);
         mergeRemoteThreadState(store, key, remoteThreadState);
         let connectedLanguageModel;
@@ -3802,12 +4157,18 @@ class TemboryMemory {
                 retrievalMode,
                 requestedRetrievalMode,
                 hasQuery: String(query || '').trim().length > 0,
+                querySource: currentTurn.source,
                 connectedAi,
             });
         }
         catch { }
         let payload;
         let vectorMemories = [];
+        const loadDedupeSummary = {
+            enabled: true,
+            load: {},
+            lastSave: store.memoryDedupe[key]?.lastSummary,
+        };
         if (vectorMemoryEnabled && (retrievalMode === 'semantic' || retrievalMode === 'semanticV2' || retrievalMode === 'hybrid')) {
             const body = { query: String(query || '') };
             // IDs
@@ -4068,6 +4429,12 @@ class TemboryMemory {
                 connectedAi.errors.push(`persistedContext.load: ${error.message || String(error)}`);
             }
         }
+        const vectorDedupe = dedupeMemoryItemsForLoad(vectorMemories);
+        vectorMemories = vectorDedupe.items;
+        loadDedupeSummary.load.vectorMemories = vectorDedupe.summary;
+        const persistedDedupe = dedupeMemoryItemsForLoad(persistedMemoryItems);
+        persistedMemoryItems = persistedDedupe.items;
+        loadDedupeSummary.load.persistedMemories = persistedDedupe.summary;
         if (adv.includeRecentMessages !== false) {
             persistedRecentMessages = persistedMemoryItems
                 .flatMap(recentMessagesFromMemory)
@@ -4082,7 +4449,13 @@ class TemboryMemory {
                 .sort((a, b) => new Date(a.at || 0).getTime() - new Date(b.at || 0).getTime());
         }
         const storedRecentMessages = adv.includeRecentMessages === false ? [] : (store.recentMessages[key] || []).concat(persistedRecentMessages, vectorRecentMessages);
-        const allRecentMessages = dedupeRecentMessages(appendCurrentUserMessage(storedRecentMessages, query));
+        const appendedRecentMessages = appendCurrentUserMessage(storedRecentMessages, query);
+        const allRecentMessages = dedupeRecentMessages(appendedRecentMessages);
+        loadDedupeSummary.load.recentMessages = cleanContextValue({
+            input: appendedRecentMessages.length,
+            kept: allRecentMessages.length,
+            removed: Math.max(0, appendedRecentMessages.length - allRecentMessages.length),
+        });
         const recentMessages = pruneConversationMessagesPreserveAnchors(allRecentMessages, Math.max(Number(adv.recentMessagesLastN || 8), 8));
         const toolHistoryFromRecentMessages = [];
         if (adv.includeToolHistory !== false) {
@@ -4091,7 +4464,13 @@ class TemboryMemory {
         }
         const toolHistoryFromVectorMarkers = adv.includeToolHistory === false ? [] : vectorMemories.flatMap(explicitToolHistoryItemsFromMemory);
         const toolHistoryFromVectorMemories = adv.includeToolHistory === false || adv.includeToolHistorySemanticFallback !== true ? [] : vectorMemories.flatMap(toolHistoryItemsFromMemory);
-        const toolHistory = adv.includeToolHistory === false ? [] : applyToolHistoryWindow((store.toolHistory[key] || []).concat(persistedToolHistory, toolHistoryFromRecentMessages, toolHistoryFromVectorMarkers, toolHistoryFromVectorMemories), adv.toolHistoryTTLSeconds, adv.toolHistoryLastN || 15);
+        const combinedToolHistory = (store.toolHistory[key] || []).concat(persistedToolHistory, toolHistoryFromRecentMessages, toolHistoryFromVectorMarkers, toolHistoryFromVectorMemories);
+        const toolHistory = adv.includeToolHistory === false ? [] : applyToolHistoryWindow(combinedToolHistory, adv.toolHistoryTTLSeconds, adv.toolHistoryLastN || 15);
+        loadDedupeSummary.load.toolHistory = cleanContextValue({
+            input: adv.includeToolHistory === false ? 0 : combinedToolHistory.length,
+            kept: toolHistory.length,
+            removed: Math.max(0, (adv.includeToolHistory === false ? 0 : combinedToolHistory.length) - toolHistory.length),
+        });
         const highlights = adv.includeRecentHighlights === false ? [] : getRecentHighlights(recentMessages, toolHistory, adv.recentHighlightsMaxItems || 6);
         const profileFacts = adv.includeProfileFacts === false ? {} : mergeProfileFacts(store.profileFacts[key], profileFactsFromMessages(allRecentMessages), profileFactsFromMemories(vectorMemories));
         if (adv.includeProfileFacts !== false && Object.keys(profileFacts).length) {
@@ -4221,6 +4600,8 @@ class TemboryMemory {
             },
             connectedAi,
             activeSummary: summaryDiagnostics,
+            dedupeSummary: cleanContextValue(loadDedupeSummary),
+            currentTurn,
         };
         const contextHealth = deriveContextHealth({
             userId: key,
@@ -4292,6 +4673,7 @@ class TemboryMemory {
             userId: key,
             project: project || undefined,
             query,
+            currentTurn,
             retrievalMode,
             requestedRetrievalMode: requestedRetrievalMode === retrievalMode ? undefined : requestedRetrievalMode,
             payloadFormat,
@@ -4360,6 +4742,7 @@ class TemboryMemory {
                 })),
             },
             diagnostics,
+            dedupeSummary: diagnostics.dedupeSummary,
         };
         return {
             response: {
@@ -4476,6 +4859,7 @@ exports.__private = {
     flattenAdvancedGroups,
     asSearchQuery,
     currentInputJsonFromContext,
+    resolveCurrentTurnQueryWithSource,
     resolveCurrentTurnQuery,
     safePersistLegacyMemory,
     stripThreadTestPrefix,
@@ -4493,6 +4877,10 @@ exports.__private = {
     deriveOperationalState,
     deriveActionLedger,
     deriveEntityTimeline,
+    buildMemoryDedupeCandidate,
+    dedupeMemoryItemsForLoad,
+    mergeMemoryDedupeState,
+    evaluateMemoryDedupeWrite,
     scoreOf,
     scoreMetaOf,
     extractProfileFactsFromText,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-tembory",
-  "version": "1.1.26",
+  "version": "1.1.28",
   "description": "Tembory node for n8n AI Agents with operational memory, tool history and decision state",
   "license": "MIT",
   "homepage": "https://tembory.com",