iranti 0.2.51 → 0.3.2

package/dist/src/lib/autoRemember.js

@@ -17,6 +17,8 @@ exports.autoRememberAssistantFacts = autoRememberAssistantFacts;
 exports.rememberAssistantResponseFacts = rememberAssistantResponseFacts;
 exports.parseBackfillChatTranscript = parseBackfillChatTranscript;
 exports.backfillChatHistory = backfillChatHistory;
+const staffEventRegistry_1 = require("./staffEventRegistry");
+const semanticFactTags_1 = require("./semanticFactTags");
 exports.USER_PROMPT_AUTO_REMEMBER_SOURCE = 'UserPromptAutoRemember';
 const PERSONAL_MEMORY_KEYS = new Set([
     'name',
@@ -69,8 +71,380 @@ function buildTextFact(key, value, scope = 'personal') {
         key: cleanKey,
         value: { text: cleanValue },
         summary: `${cleanKey.replace(/_/g, ' ')} is ${cleanValue}`,
+        durableClass: cleanKey.startsWith('favorite_') ? 'preference' : 'profile',
     };
 }
+function dedupeStrings(values) {
+    const seen = new Set();
+    const deduped = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed)
+            continue;
+        const normalized = trimmed.toLowerCase();
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        deduped.push(trimmed);
+    }
+    return deduped;
+}
+function dedupeObjects(values) {
+    const seen = new Set();
+    const deduped = [];
+    for (const value of values) {
+        const identity = JSON.stringify(value);
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        deduped.push(value);
+    }
+    return deduped;
+}
+function normalizeListItems(raw) {
+    return raw
+        .split(/(?:,|;|\band\b)/i)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function trimSummary(text, max = 220) {
+    const normalized = text.trim();
+    if (normalized.length <= max)
+        return normalized;
+    return `${normalized.slice(0, max - 3).trimEnd()}...`;
+}
+function readStringArray(value, preferredKey) {
+    if (Array.isArray(value)) {
+        return value.map((item) => String(item ?? '').trim()).filter(Boolean);
+    }
+    if (typeof value !== 'object' || value === null)
+        return [];
+    const record = value;
+    const direct = record[preferredKey];
+    if (Array.isArray(direct)) {
+        return direct.map((item) => String(item ?? '').trim()).filter(Boolean);
+    }
+    if (Array.isArray(record.items)) {
+        return record.items.map((item) => String(item ?? '').trim()).filter(Boolean);
+    }
+    return [];
+}
+function readFileChangeItems(value) {
+    if (typeof value !== 'object' || value === null)
+        return [];
+    const record = value;
+    const items = Array.isArray(record.items) ? record.items : [];
+    return items.filter((item) => typeof item === 'object' && item !== null);
+}
+function readActionItems(value) {
+    if (typeof value !== 'object' || value === null)
+        return [];
+    const record = value;
+    const items = Array.isArray(record.items) ? record.items : [];
+    return items.filter((item) => typeof item === 'object' && item !== null);
+}
+function mergeFactValue(key, existing, incoming) {
+    if (key === 'open_risks') {
+        return { items: dedupeStrings([...readStringArray(existing, 'items'), ...readStringArray(incoming, 'items')]) };
+    }
+    if (key === 'important_artifacts') {
+        return { items: dedupeStrings([...readStringArray(existing, 'items'), ...readStringArray(incoming, 'items'), ...readStringArray(existing, 'files'), ...readStringArray(incoming, 'files')]) };
+    }
+    if (key === 'failed_paths' || key === 'alternative_routes') {
+        return { items: dedupeStrings([...readStringArray(existing, 'items'), ...readStringArray(incoming, 'items')]) };
+    }
+    if (key === 'recent_file_changes') {
+        return { items: dedupeObjects([...readFileChangeItems(existing), ...readFileChangeItems(incoming)]) };
+    }
+    if (key === 'recent_actions') {
+        return { items: dedupeObjects([...readActionItems(existing), ...readActionItems(incoming)]) };
+    }
+    return incoming;
+}
+function summarizeMergedFact(key, value, fallback) {
+    if (key === 'open_risks') {
+        const items = readStringArray(value, 'items');
+        return items.length > 0 ? trimSummary(`open risks include ${items.join('; ')}`) : fallback;
+    }
+    if (key === 'important_artifacts') {
+        const items = readStringArray(value, 'items');
+        return items.length > 0 ? trimSummary(`important artifacts include ${items.join('; ')}`) : fallback;
+    }
+    if (key === 'failed_paths') {
+        const items = readStringArray(value, 'items');
+        return items.length > 0 ? trimSummary(`failed paths include ${items.join('; ')}`) : fallback;
+    }
+    if (key === 'alternative_routes') {
+        const items = readStringArray(value, 'items');
+        return items.length > 0 ? trimSummary(`alternative routes include ${items.join('; ')}`) : fallback;
+    }
+    if (key === 'recent_file_changes') {
+        const items = readFileChangeItems(value).map((item) => {
+            const action = String(item.action ?? 'updated').trim();
+            const path = String(item.path ?? '').trim();
+            const toPath = String(item.toPath ?? '').trim();
+            const purpose = String(item.purpose ?? '').trim();
+            if (!path)
+                return '';
+            if (toPath)
+                return `${action} ${path} -> ${toPath}${purpose ? ` (${purpose})` : ''}`;
+            return `${action} ${path}${purpose ? ` (${purpose})` : ''}`;
+        }).filter(Boolean);
+        return items.length > 0 ? trimSummary(`recent file changes include ${items.join('; ')}`) : fallback;
+    }
+    if (key === 'recent_actions') {
+        const items = readActionItems(value).map((item) => {
+            const kind = String(item.kind ?? 'action').trim();
+            const summary = String(item.summary ?? '').trim();
+            const status = String(item.status ?? '').trim();
+            if (!summary)
+                return '';
+            return status ? `[${status}] ${kind}: ${summary}` : `${kind}: ${summary}`;
+        }).filter(Boolean);
+        return items.length > 0 ? trimSummary(`recent actions include ${items.join('; ')}`) : fallback;
+    }
+    return fallback;
+}
+function buildFactProperties(fact, phase) {
+    const mergeStrategy = ['open_risks', 'important_artifacts', 'recent_file_changes', 'recent_actions', 'failed_paths', 'alternative_routes'].includes(fact.key)
+        ? 'append_dedupe'
+        : 'replace';
+    return {
+        memoryScope: fact.scope,
+        capturePhase: phase,
+        durableClass: fact.durableClass,
+        canonicalKey: fact.key,
+        mergeStrategy,
+        ...(0, semanticFactTags_1.buildSemanticFactTags)({
+            memoryScope: fact.scope,
+            durableClass: fact.durableClass,
+            mergeStrategy,
+        }),
+    };
+}
+function extractProjectOperationalFacts(text) {
+    const facts = [];
+    const decisionMatch = text.match(/^we decided(?: that)? (.+)$/i);
+    if (decisionMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'decision',
+            value: { text: decisionMatch[1].trim() },
+            summary: `decision is ${decisionMatch[1].trim()}`,
+            durableClass: 'decision',
+        });
+    }
+    const nextStepMatch = text.match(/^(?:the )?next step is (.+)$/i);
+    if (nextStepMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'next_step',
+            value: { instruction: nextStepMatch[1].trim() },
+            summary: `next step is ${nextStepMatch[1].trim()}`,
+            durableClass: 'next_step',
+        });
+    }
+    const currentStepMatch = text.match(/^(?:the )?current step is (.+)$/i);
+    if (currentStepMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'current_step',
+            value: { text: currentStepMatch[1].trim() },
+            summary: `current step is ${currentStepMatch[1].trim()}`,
+            durableClass: 'current_step',
+        });
+    }
+    const blockerMatch = text.match(/^(?:the )?blocker is (.+)$/i);
+    if (blockerMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'blocker',
+            value: { text: blockerMatch[1].trim() },
+            summary: `blocker is ${blockerMatch[1].trim()}`,
+            durableClass: 'blocker',
+        });
+    }
+    const ownerMatch = text.match(/^(?:the )?current owner is (.+)$/i);
+    if (ownerMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'current_owner',
+            value: { text: ownerMatch[1].trim() },
+            summary: `current owner is ${ownerMatch[1].trim()}`,
+            durableClass: 'owner',
+        });
+    }
+    const openRisksMatch = text.match(/^(?:the )?(?:open risks?|risks?) (?:are|include) (.+)$/i);
+    if (openRisksMatch) {
+        const items = dedupeStrings(normalizeListItems(openRisksMatch[1]));
+        if (items.length > 0) {
+            facts.push({
+                scope: 'project',
+                key: 'open_risks',
+                value: { items },
+                summary: trimSummary(`open risks include ${items.join('; ')}`),
+                durableClass: 'open_risks',
+            });
+        }
+    }
+    const artifactsMatch = text.match(/^(?:important )?artifacts? (?:are|include) (.+)$/i);
+    if (artifactsMatch) {
+        const items = dedupeStrings(normalizeListItems(artifactsMatch[1]));
+        if (items.length > 0) {
+            facts.push({
+                scope: 'project',
+                key: 'important_artifacts',
+                value: { items },
+                summary: trimSummary(`important artifacts include ${items.join('; ')}`),
+                durableClass: 'artifact',
+            });
+        }
+    }
+    const failedPathMatch = text.match(/^(?:the )?failed path (?:is|was) (.+)$/i);
+    if (failedPathMatch) {
+        const items = dedupeStrings(normalizeListItems(failedPathMatch[1]));
+        if (items.length > 0) {
+            facts.push({
+                scope: 'project',
+                key: 'failed_paths',
+                value: { items },
+                summary: trimSummary(`failed paths include ${items.join('; ')}`),
+                durableClass: 'failed_path',
+            });
+        }
+    }
+    const alternativeRouteMatch = text.match(/^(?:the )?alternative route (?:is|was) (.+)$/i);
+    if (alternativeRouteMatch) {
+        const items = dedupeStrings(normalizeListItems(alternativeRouteMatch[1]));
+        if (items.length > 0) {
+            facts.push({
+                scope: 'project',
+                key: 'alternative_routes',
+                value: { items },
+                summary: trimSummary(`alternative routes include ${items.join('; ')}`),
+                durableClass: 'alternative_route',
+            });
+        }
+    }
+    const createdFileMatch = text.match(/^file created (\S+)(?: for (.+))?$/i);
+    if (createdFileMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'recent_file_changes',
+            value: { items: [{ action: 'created', path: createdFileMatch[1].trim(), purpose: createdFileMatch[2]?.trim() || undefined }] },
+            summary: trimSummary(`recent file changes include created ${createdFileMatch[1].trim()}${createdFileMatch[2]?.trim() ? ` (${createdFileMatch[2].trim()})` : ''}`),
+            durableClass: 'file_change',
+        });
+    }
+    const movedFileMatch = text.match(/^file moved (\S+) to (\S+)(?: for (.+))?$/i);
+    if (movedFileMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'recent_file_changes',
+            value: { items: [{ action: 'moved', path: movedFileMatch[1].trim(), toPath: movedFileMatch[2].trim(), purpose: movedFileMatch[3]?.trim() || undefined }] },
+            summary: trimSummary(`recent file changes include moved ${movedFileMatch[1].trim()} to ${movedFileMatch[2].trim()}${movedFileMatch[3]?.trim() ? ` (${movedFileMatch[3].trim()})` : ''}`),
+            durableClass: 'file_change',
+        });
+    }
+    const renamedFileMatch = text.match(/^file renamed (\S+) to (\S+)(?: for (.+))?$/i);
+    if (renamedFileMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'recent_file_changes',
+            value: { items: [{ action: 'renamed', path: renamedFileMatch[1].trim(), toPath: renamedFileMatch[2].trim(), purpose: renamedFileMatch[3]?.trim() || undefined }] },
+            summary: trimSummary(`recent file changes include renamed ${renamedFileMatch[1].trim()} to ${renamedFileMatch[2].trim()}${renamedFileMatch[3]?.trim() ? ` (${renamedFileMatch[3].trim()})` : ''}`),
+            durableClass: 'file_change',
+        });
+    }
+    const deletedFileMatch = text.match(/^file deleted (\S+)(?: because (.+))?$/i);
+    if (deletedFileMatch) {
+        facts.push({
+            scope: 'project',
+            key: 'recent_file_changes',
+            value: { items: [{ action: 'deleted', path: deletedFileMatch[1].trim(), purpose: deletedFileMatch[2]?.trim() || undefined }] },
+            summary: trimSummary(`recent file changes include deleted ${deletedFileMatch[1].trim()}${deletedFileMatch[2]?.trim() ? ` (${deletedFileMatch[2].trim()})` : ''}`),
+            durableClass: 'file_change',
+        });
+    }
+    const commandRanMatch = text.match(/^command ran (.+)$/i);
+    if (commandRanMatch) {
+        const target = commandRanMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'command', summary: `ran ${target}`, status: 'completed', target }] },
+            summary: trimSummary(`recent actions include [completed] command: ran ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    const commandFailedMatch = text.match(/^command failed (.+)$/i);
+    if (commandFailedMatch) {
+        const target = commandFailedMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'command', summary: `failed ${target}`, status: 'failed', target }] },
+            summary: trimSummary(`recent actions include [failed] command: failed ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    const testPassedMatch = text.match(/^test passed (.+)$/i);
+    if (testPassedMatch) {
+        const target = testPassedMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'test', summary: `passed ${target}`, status: 'passed', target }] },
+            summary: trimSummary(`recent actions include [passed] test: passed ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    const testFailedMatch = text.match(/^test failed (.+)$/i);
+    if (testFailedMatch) {
+        const target = testFailedMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'test', summary: `failed ${target}`, status: 'failed', target }] },
+            summary: trimSummary(`recent actions include [failed] test: failed ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    const validationPassedMatch = text.match(/^validation passed (.+)$/i);
+    if (validationPassedMatch) {
+        const target = validationPassedMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'validation', summary: `passed ${target}`, status: 'passed', target }] },
+            summary: trimSummary(`recent actions include [passed] validation: passed ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    const validationFailedMatch = text.match(/^validation failed (.+)$/i);
+    if (validationFailedMatch) {
+        const target = validationFailedMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'validation', summary: `failed ${target}`, status: 'failed', target }] },
+            summary: trimSummary(`recent actions include [failed] validation: failed ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    const searchRanMatch = text.match(/^search ran (.+)$/i);
+    if (searchRanMatch) {
+        const target = searchRanMatch[1].trim();
+        facts.push({
+            scope: 'project',
+            key: 'recent_actions',
+            value: { items: [{ kind: 'search', summary: `ran ${target}`, status: 'completed', target }] },
+            summary: trimSummary(`recent actions include [completed] search: ran ${target}`),
+            durableClass: 'action_log',
+        });
+    }
+    return facts;
+}
 function isAutoRememberEnabled() {
     const raw = process.env.IRANTI_AUTO_REMEMBER?.trim().toLowerCase();
     return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
@@ -144,7 +518,7 @@ function classifyMemoryScope(message) {
     const normalized = normalizePrompt(message).toLowerCase();
     if (!normalized)
         return null;
-    if (/\b(next step|blocker|decision|current owner)\b/.test(normalized)) {
+    if (/\b(next step|current step|blocker|decision|current owner|open risks?|artifacts?|failed path|alternative route|file (?:created|moved|renamed|deleted))\b/.test(normalized)) {
         return 'project';
     }
     if (/\b(my|me|i)\b/.test(normalized)) {
@@ -222,6 +596,30 @@ function detectMandatoryRecall(message) {
             reason: 'project_owner_recall',
         };
     }
+    if (/\b(?:what|remind me)(?:[^.?!]*)\bcurrent step\b/i.test(normalized)) {
+        return {
+            required: true,
+            scope: 'project',
+            key: 'current_step',
+            reason: 'project_current_step_recall',
+        };
+    }
+    if (/\b(?:what|which|remind me)(?:[^.?!]*)\bopen risks?\b/i.test(normalized)) {
+        return {
+            required: true,
+            scope: 'project',
+            key: 'open_risks',
+            reason: 'project_open_risks_recall',
+        };
+    }
+    if (/\b(?:what|which|remind me)(?:[^.?!]*)\b(?:important )?artifacts?\b/i.test(normalized)) {
+        return {
+            required: true,
+            scope: 'project',
+            key: 'important_artifacts',
+            reason: 'project_artifacts_recall',
+        };
+    }
     return { required: false, scope: null };
 }
 function extractExplicitPromptMemory(prompt) {
@@ -256,33 +654,7 @@ function extractExplicitPromptMemory(prompt) {
     if (preferenceMatch) {
         facts.push(buildTextFact('likes', preferenceMatch[1]));
     }
-    const decisionMatch = stripped.match(/^we decided(?: that)? (.+)$/i);
-    if (decisionMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'decision',
-            value: { text: decisionMatch[1].trim() },
-            summary: `decision is ${decisionMatch[1].trim()}`,
-        });
-    }
-    const nextStepMatch = stripped.match(/^(?:the )?next step is (.+)$/i);
-    if (nextStepMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'next_step',
-            value: { instruction: nextStepMatch[1].trim() },
-            summary: `next step is ${nextStepMatch[1].trim()}`,
-        });
-    }
-    const blockerMatch = stripped.match(/^(?:the )?blocker is (.+)$/i);
-    if (blockerMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'blocker',
-            value: { text: blockerMatch[1].trim() },
-            summary: `blocker is ${blockerMatch[1].trim()}`,
-        });
-    }
+    facts.push(...extractProjectOperationalFacts(stripped));
     const deduped = new Map();
     for (const fact of facts) {
         if (!fact.key || fact.summary.length > 220)
@@ -308,42 +680,7 @@ function extractExplicitAssistantMemory(response) {
     })) {
         facts.push(buildTextFact(yourFieldMatch[1], yourFieldMatch[2]));
     }
-    const decisionMatch = lower.match(/^we decided(?: that)? (.+)$/i);
-    if (decisionMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'decision',
-            value: { text: decisionMatch[1].trim() },
-            summary: `decision is ${decisionMatch[1].trim()}`,
-        });
-    }
-    const nextStepMatch = lower.match(/^(?:the )?next step is (.+)$/i);
-    if (nextStepMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'next_step',
-            value: { instruction: nextStepMatch[1].trim() },
-            summary: `next step is ${nextStepMatch[1].trim()}`,
-        });
-    }
-    const blockerMatch = lower.match(/^(?:the )?blocker is (.+)$/i);
-    if (blockerMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'blocker',
-            value: { text: blockerMatch[1].trim() },
-            summary: `blocker is ${blockerMatch[1].trim()}`,
-        });
-    }
-    const ownerMatch = lower.match(/^(?:the )?current owner is (.+)$/i);
-    if (ownerMatch) {
-        facts.push({
-            scope: 'project',
-            key: 'current_owner',
-            value: { text: ownerMatch[1].trim() },
-            summary: `current owner is ${ownerMatch[1].trim()}`,
-        });
-    }
+    facts.push(...extractProjectOperationalFacts(lower));
     const deduped = new Map();
     for (const fact of facts) {
         if (!fact.key || fact.summary.length > 220)
@@ -361,7 +698,7 @@ function comparableValue(value) {
     }
 }
 async function persistExtractedFacts(params) {
-    const { iranti, facts, agent, source, phase, confidence, entity, projectEntity, personalEntity, } = params;
+    const { iranti, facts, agent, source, phase, confidence, entity, projectEntity, personalEntity, ledgerContext, } = params;
     const skipped = [];
     let written = 0;
     const writtenEntities = new Set();
@@ -374,7 +711,9 @@ async function persistExtractedFacts(params) {
             continue;
         }
         const existing = await iranti.query(targetEntity, fact.key).catch(() => ({ found: false }));
-        if (existing.found && comparableValue(existing.value) === comparableValue(fact.value)) {
+        const mergedValue = existing.found ? mergeFactValue(fact.key, existing.value, fact.value) : fact.value;
+        const mergedSummary = summarizeMergedFact(fact.key, mergedValue, fact.summary);
+        if (existing.found && comparableValue(existing.value) === comparableValue(mergedValue)) {
             skipped.push({ key: fact.key, reason: 'unchanged' });
             continue;
         }
@@ -384,12 +723,32 @@ async function persistExtractedFacts(params) {
         await iranti.write({
             entity: targetEntity,
             key: fact.key,
-            value: fact.value,
-            summary: fact.summary,
+            value: mergedValue,
+            summary: mergedSummary,
             confidence,
             source: writeSource,
             agent,
+            properties: buildFactProperties(fact, phase),
         });
+        if (phase === 'assistant_response') {
+            (0, staffEventRegistry_1.getStaffEventEmitter)().emit({
+                staffComponent: 'Attendant',
+                actionType: 'summary_written',
+                agentId: agent,
+                source: ledgerContext?.source?.trim() || source,
+                entityType: targetEntity.split('/', 2)[0],
+                entityId: targetEntity.split('/', 2)[1],
+                key: fact.key,
+                reason: 'strict_assistant_summary_persisted',
+                level: 'audit',
+                metadata: {
+                    memoryScope: fact.scope,
+                    durableClass: fact.durableClass,
+                    capturePhase: phase,
+                    ...(ledgerContext?.host ? { host: ledgerContext.host } : {}),
+                },
+            });
+        }
         written += 1;
         writtenEntities.add(targetEntity);
     }
@@ -402,7 +761,7 @@ async function persistExtractedFacts(params) {
     };
 }
 async function autoRememberPromptFacts(params) {
-    const { iranti, prompt, agent, source, entity, projectEntity, personalEntity, confidence = 96, } = params;
+    const { iranti, prompt, agent, source, entity, projectEntity, personalEntity, confidence = 96, ledgerContext, } = params;
     if (!isAutoRememberEnabled()) {
         return {
             enabled: false,
@@ -422,10 +781,11 @@ async function autoRememberPromptFacts(params) {
         entity,
         projectEntity,
         personalEntity,
+        ledgerContext,
     });
 }
 async function autoRememberAssistantFacts(params) {
-    const { iranti, response, agent, source, entity, projectEntity, personalEntity, confidence = 90, } = params;
+    const { iranti, response, agent, source, entity, projectEntity, personalEntity, confidence = 90, ledgerContext, } = params;
     if (!isAutoRememberEnabled()) {
         return {
             enabled: false,
@@ -445,10 +805,11 @@ async function autoRememberAssistantFacts(params) {
         entity,
         projectEntity,
         personalEntity,
+        ledgerContext,
     });
 }
 async function rememberAssistantResponseFacts(params) {
-    const { iranti, response, agent, source, entity, projectEntity, personalEntity, confidence = 90, } = params;
+    const { iranti, response, agent, source, entity, projectEntity, personalEntity, confidence = 90, ledgerContext, } = params;
     return persistExtractedFacts({
         iranti,
         facts: extractExplicitAssistantMemory(response),
@@ -459,6 +820,7 @@ async function rememberAssistantResponseFacts(params) {
         entity,
         projectEntity,
         personalEntity,
+        ledgerContext,
     });
 }
 function parseBackfillChatTranscript(content) {