@memberjunction/ai-agents 3.4.0 → 4.1.0

package/dist/memory-manager-agent.js

@@ -1,40 +1,53 @@
-"use strict";
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryManagerAgent = void 0;
-const base_agent_1 = require("./base-agent");
-const global_1 = require("@memberjunction/global");
-const core_1 = require("@memberjunction/core");
-const ai_prompts_1 = require("@memberjunction/ai-prompts");
-const ai_core_plus_1 = require("@memberjunction/ai-core-plus");
-const aiengine_1 = require("@memberjunction/aiengine");
+import { BaseAgent } from './base-agent.js';
+import { RegisterClass } from '@memberjunction/global';
+import { Metadata, RunView, RunQuery, LogError, LogStatus } from '@memberjunction/core';
+import { AIPromptRunner } from '@memberjunction/ai-prompts';
+import { AIPromptParams } from '@memberjunction/ai-core-plus';
+import { AIEngine } from '@memberjunction/aiengine';
+/**
+ * Configuration for extraction limits to ensure sparsity
+ */
 const EXTRACTION_CONFIG = {
-    maxNotesPerRun: 1000,
-    maxNotesPerConversation: 1000,
-    maxNotesPerMessage: 1000,
-    minConfidenceThreshold: 80,
-    minContentLength: 10,
-    cooldownHours: 24
+    maxNotesPerRun: 1000, // Max new notes per agent run
+    maxNotesPerConversation: 1000, // Max notes from a single conversation
+    maxNotesPerMessage: 1000, // Max notes from a single message
+    minConfidenceThreshold: 80, // Minimum confidence to extract a note
+    minContentLength: 10, // Minimum note content length (lowered from 20 to allow short names)
+    cooldownHours: 24 // Don't re-extract from same conversation within 24h
 };
-let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent {
+/**
+ * Memory Manager Agent - automatically extracts notes and examples from conversations.
+ * This agent runs on a schedule (every 15 minutes) and analyzes high-quality conversations
+ * and agent runs to extract learnings and example interactions.
+ */
+let MemoryManagerAgent = class MemoryManagerAgent extends BaseAgent {
     constructor() {
         super(...arguments);
+        /** Verbose logging flag from params.verbose */
         this._verbose = false;
+        /** Agent run ID for creating run steps */
         this._agentRunID = null;
+        /** Step counter for sequential step numbering */
         this._stepCounter = 0;
+        /** Context user for step operations */
         this._contextUser = null;
     }
+    /**
+     * Create an agent run step record for observability.
+     * Returns null if agentRunID is not set (defensive check).
+     */
     async CreateRunStep(stepType, stepName, inputData, targetId) {
         if (!this._agentRunID || !this._contextUser) {
             return null;
         }
         try {
-            const md = new core_1.Metadata();
+            const md = new Metadata();
             const step = await md.GetEntityObject('MJ: AI Agent Run Steps', this._contextUser);
             step.AgentRunID = this._agentRunID;
             step.StepNumber = ++this._stepCounter;
@@ -52,15 +65,18 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 return step;
             }
             else {
-                (0, core_1.LogError)(`Memory Manager: Failed to create run step: ${JSON.stringify(step.LatestResult)}`);
+                LogError(`Memory Manager: Failed to create run step: ${JSON.stringify(step.LatestResult)}`);
                 return null;
             }
         }
         catch (error) {
-            (0, core_1.LogError)('Memory Manager: Exception creating run step:', error);
+            LogError('Memory Manager: Exception creating run step:', error);
             return null;
         }
     }
+    /**
+     * Finalize an agent run step with success/failure status and output data.
+     */
     async FinalizeRunStep(step, success, outputData, targetLogId, errorMessage) {
         if (!step) {
             return;
@@ -79,15 +95,19 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 step.OutputData = JSON.stringify(outputData);
             }
             if (!await step.Save()) {
-                (0, core_1.LogError)(`Memory Manager: Failed to finalize run step: ${JSON.stringify(step.LatestResult)}`);
+                LogError(`Memory Manager: Failed to finalize run step: ${JSON.stringify(step.LatestResult)}`);
             }
         }
         catch (error) {
-            (0, core_1.LogError)('Memory Manager: Exception finalizing run step:', error);
+            LogError('Memory Manager: Exception finalizing run step:', error);
         }
     }
+    /**
+     * Get the last run timestamp for this agent to determine what to process.
+     * For first run, returns null to process all history (limited by MaxRows).
+     */
     async GetLastRunTime(agentId, contextUser) {
-        const rv = new core_1.RunView();
+        const rv = new RunView();
         const result = await rv.RunView({
             EntityName: 'MJ: AI Agent Runs',
             ExtraFilter: `AgentID='${agentId}' AND Status='Completed'`,
@@ -96,38 +116,52 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             ResultType: 'entity_object'
         }, contextUser);
         if (result.Success && result.Results && result.Results.length > 0) {
+            // Ensure we return a proper Date object
             const startedAt = result.Results[0].StartedAt;
             return startedAt instanceof Date ? startedAt : new Date(startedAt);
         }
+        // First run - return null to process all history (with MaxRows limit)
         return null;
     }
+    /**
+     * Load agents that have note or example injection enabled.
+     * Only extract notes/examples for agents that actually use these features.
+     */
     async LoadAgentsUsingMemory(contextUser) {
-        const allAgents = aiengine_1.AIEngine.Instance.Agents;
+        const allAgents = AIEngine.Instance.Agents;
         const filteredAgents = allAgents.filter(a => a.Status === 'Active' && (a.InjectNotes || a.InjectExamples));
+        // Debug logging only in verbose mode
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: AIEngine has ${allAgents.length} total agents cached`);
+            LogStatus(`Memory Manager: AIEngine has ${allAgents.length} total agents cached`);
             if (filteredAgents.length > 0) {
                 const agentNames = filteredAgents.map(a => `${a.Name} (InjectNotes=${a.InjectNotes}, InjectExamples=${a.InjectExamples})`).join(', ');
-                (0, core_1.LogStatus)(`Memory Manager: Agents with memory enabled: ${agentNames}`);
+                LogStatus(`Memory Manager: Agents with memory enabled: ${agentNames}`);
             }
             const sage = allAgents.find(a => a.Name === 'Sage');
             if (sage) {
-                (0, core_1.LogStatus)(`Memory Manager: Sage agent - ID=${sage.ID}, InjectNotes=${sage.InjectNotes}, InjectExamples=${sage.InjectExamples}, Status=${sage.Status}`);
+                LogStatus(`Memory Manager: Sage agent - ID=${sage.ID}, InjectNotes=${sage.InjectNotes}, InjectExamples=${sage.InjectExamples}, Status=${sage.Status}`);
             }
         }
+        // Warning: Always log if Sage is missing
         const sage = allAgents.find(a => a.Name === 'Sage');
         if (!sage) {
-            (0, core_1.LogStatus)(`Memory Manager: WARNING - Sage agent not found in AIEngine cache!`);
+            LogStatus(`Memory Manager: WARNING - Sage agent not found in AIEngine cache!`);
         }
         return filteredAgents;
     }
+    /**
+     * Load conversations with new activity since last run, including rating data.
+     * Uses a single optimized RunQuery that replaces 4 separate database queries.
+     * Returns conversations with their details, ratings, and agent run IDs for scope inheritance.
+     */
     async LoadConversationsWithNewActivity(since, agentsUsingMemory, contextUser) {
         if (agentsUsingMemory.length === 0) {
-            (0, core_1.LogStatus)('Memory Manager: No agents have memory injection enabled - skipping');
+            LogStatus('Memory Manager: No agents have memory injection enabled - skipping');
             return [];
         }
         const agentIds = agentsUsingMemory.map(a => `'${a.ID}'`).join(',');
-        const rq = new core_1.RunQuery();
+        // Use RunQuery to fetch all data in a single optimized query
+        const rq = new RunQuery();
         const result = await rq.RunQuery({
             QueryName: 'GetConversationsForMemoryManager',
             CategoryPath: '/MJ/AI/Agents/',
@@ -135,14 +169,16 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 since: since?.toISOString() || null,
                 agentIds: agentIds
             },
-            MaxRows: 1000
+            MaxRows: 1000 // Limit to 1000 conversations per run
         }, contextUser);
         if (!result.Success || !result.Results || result.Results.length === 0) {
-            (0, core_1.LogStatus)('Memory Manager: No conversations with new activity found');
+            LogStatus('Memory Manager: No conversations with new activity found');
             return [];
         }
+        // Parse the query results into ConversationWithRatings objects
         const conversations = [];
         for (const row of result.Results) {
+            // Parse the MessagesJSON from the query result
             let messages = [];
             if (row.MessagesJSON) {
                 try {
@@ -157,7 +193,7 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                     }));
                 }
                 catch (e) {
-                    (0, core_1.LogError)(`Memory Manager: Failed to parse MessagesJSON for conversation ${row.ConversationID}:`, e);
+                    LogError(`Memory Manager: Failed to parse MessagesJSON for conversation ${row.ConversationID}:`, e);
                     continue;
                 }
             }
@@ -173,12 +209,17 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         }
         const totalMessages = conversations.reduce((sum, c) => sum + c.messages.length, 0);
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: Loaded ${conversations.length} conversations with ${totalMessages} total messages (positive: ${conversations.filter(c => c.hasPositiveRating).length}, negative: ${conversations.filter(c => c.hasNegativeRating).length}, unrated: ${conversations.filter(c => c.isUnrated).length})`);
+            LogStatus(`Memory Manager: Loaded ${conversations.length} conversations with ${totalMessages} total messages (positive: ${conversations.filter(c => c.hasPositiveRating).length}, negative: ${conversations.filter(c => c.hasNegativeRating).length}, unrated: ${conversations.filter(c => c.isUnrated).length})`);
         }
         return conversations;
     }
+    /**
+     * Load agent runs with high-usage artifacts since last run.
+     * Links through: ArtifactUse -> ArtifactVersion -> ConversationDetailArtifact -> ConversationDetail -> Conversation -> AIAgentRun
+     */
     async LoadHighValueAgentRuns(since, contextUser) {
-        const rv = new core_1.RunView();
+        const rv = new RunView();
+        // Use subquery to find agent runs with high-usage artifacts
         const sinceFilter = since ? `AND au.__mj_CreatedAt >= '${since.toISOString()}'` : '';
         const filter = `
             ID IN (
@@ -205,21 +246,27 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             EntityName: 'MJ: AI Agent Runs',
             ExtraFilter: filter,
             OrderBy: '__mj_CreatedAt DESC',
-            MaxRows: 50,
+            MaxRows: 50, // Limit to most recent 50 high-value runs
             ResultType: 'entity_object'
         }, contextUser);
         return result.Success ? (result.Results || []) : [];
     }
+    /**
+     * Extract notes from conversations with rating data using AI analysis.
+     * This is the primary method that handles rated, unrated, positive, and negative feedback.
+     * Uses LLM-based deduplication and applies sparsity controls.
+     */
     async ExtractNotesFromConversations(conversations, contextUser) {
         if (conversations.length === 0) {
             return [];
         }
-        const allNotes = aiengine_1.AIEngine.Instance.AgentNotes;
+        const allNotes = AIEngine.Instance.AgentNotes;
         const existingNotes = allNotes.filter(n => n.Status === 'Active');
+        // Prepare conversation threads with rating data and user context
         const conversationThreads = conversations.map(conv => ({
             conversationId: conv.conversationId,
-            userId: conv.userId,
-            agentRunId: conv.agentRunId,
+            userId: conv.userId, // User who owns the conversation - for scoping
+            agentRunId: conv.agentRunId, // Linked agent run - for scope inheritance
             hasPositiveRating: conv.hasPositiveRating,
             hasNegativeRating: conv.hasNegativeRating,
             isUnrated: conv.isUnrated,
@@ -245,88 +292,100 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         };
         return this.executeNoteExtraction(promptData, existingNotes, contextUser);
     }
+    /**
+     * Common extraction logic for note extraction.
+     * Applies sparsity controls and deduplication.
+     */
     async executeNoteExtraction(promptData, existingNotes, contextUser) {
         const conversationThreads = promptData.conversationThreads;
-        const prompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Extract Notes' && p.Category === 'MJ: System');
+        // Find extraction prompt
+        const prompt = AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Extract Notes' && p.Category === 'MJ: System');
         if (!prompt) {
-            (0, core_1.LogError)('Memory Manager note extraction prompt not found');
+            LogError('Memory Manager note extraction prompt not found');
             if (this._verbose) {
-                (0, core_1.LogStatus)(`Memory Manager: Available prompts in MJ: System category: ${aiengine_1.AIEngine.Instance.Prompts.filter(p => p.Category === 'MJ: System').map(p => p.Name).join(', ')}`);
+                LogStatus(`Memory Manager: Available prompts in MJ: System category: ${AIEngine.Instance.Prompts.filter(p => p.Category === 'MJ: System').map(p => p.Name).join(', ')}`);
             }
             return [];
         }
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: Found extraction prompt "${prompt.Name}" (ID: ${prompt.ID})`);
-            (0, core_1.LogStatus)(`Memory Manager: Sending ${conversationThreads.length} conversation threads with ${conversationThreads.reduce((sum, t) => sum + t.messages.length, 0)} total messages for note extraction`);
+            LogStatus(`Memory Manager: Found extraction prompt "${prompt.Name}" (ID: ${prompt.ID})`);
+            LogStatus(`Memory Manager: Sending ${conversationThreads.length} conversation threads with ${conversationThreads.reduce((sum, t) => sum + t.messages.length, 0)} total messages for note extraction`);
             if (conversationThreads.length > 0) {
                 const firstThread = conversationThreads[0];
-                (0, core_1.LogStatus)(`Memory Manager: Sample thread (conv ${firstThread.conversationId}): ${firstThread.messages.map(m => `[${m.role}] ${m.message?.substring(0, 80)}...`).join(' | ')}`);
+                LogStatus(`Memory Manager: Sample thread (conv ${firstThread.conversationId}): ${firstThread.messages.map(m => `[${m.role}] ${m.message?.substring(0, 80)}...`).join(' | ')}`);
             }
         }
+        // Step 3: Execute AI extraction
         const step3 = await this.CreateRunStep('Prompt', 'Extract Notes from Conversations', {
             conversationCount: conversationThreads.length,
             messageCount: conversationThreads.reduce((sum, t) => sum + t.messages.length, 0),
             existingNoteCount: existingNotes.length
         }, prompt.ID);
-        const runner = new ai_prompts_1.AIPromptRunner();
-        const params = new ai_core_plus_1.AIPromptParams();
+        const runner = new AIPromptRunner();
+        const params = new AIPromptParams();
         params.prompt = prompt;
         params.data = promptData;
         params.contextUser = contextUser;
         const result = await runner.ExecutePrompt(params);
+        // Finalize Step 3 after extraction
         await this.FinalizeRunStep(step3, result.success, {
             success: result.success,
             rawNoteCount: result.result && typeof result.result !== 'string' ? (result.result.notes?.length || 0) : 0
         }, result.promptRun?.ID, result.errorMessage || undefined);
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: Extraction prompt result - success: ${result.success}, hasResult: ${!!result.result}`);
+            LogStatus(`Memory Manager: Extraction prompt result - success: ${result.success}, hasResult: ${!!result.result}`);
             if (result.errorMessage) {
-                (0, core_1.LogStatus)(`Memory Manager: Extraction error: ${result.errorMessage}`);
+                LogStatus(`Memory Manager: Extraction error: ${result.errorMessage}`);
             }
             if (result.result) {
-                (0, core_1.LogStatus)(`Memory Manager: Raw extraction result: ${JSON.stringify(result.result)}`);
+                LogStatus(`Memory Manager: Raw extraction result: ${JSON.stringify(result.result)}`);
             }
         }
         if (!result.success || !result.result) {
-            (0, core_1.LogError)('Failed to extract notes:', result.errorMessage);
+            LogError('Failed to extract notes:', result.errorMessage);
             return [];
         }
+        // Parse result if it's a string (AI sometimes returns JSON as string)
         let parsedResult;
         if (typeof result.result === 'string') {
             try {
                 parsedResult = JSON.parse(result.result);
                 if (this._verbose) {
-                    (0, core_1.LogStatus)(`Memory Manager: Parsed string result into object with ${parsedResult.notes?.length || 0} notes`);
+                    LogStatus(`Memory Manager: Parsed string result into object with ${parsedResult.notes?.length || 0} notes`);
                 }
             }
             catch (e) {
-                (0, core_1.LogError)('Failed to parse extraction result as JSON:', e);
+                LogError('Failed to parse extraction result as JSON:', e);
                 return [];
             }
         }
         else {
             parsedResult = result.result;
         }
+        // Log raw notes before filtering (for debugging)
         if (this._verbose && parsedResult.notes) {
-            (0, core_1.LogStatus)(`Memory Manager: LLM returned ${parsedResult.notes.length} raw notes before filtering`);
+            LogStatus(`Memory Manager: LLM returned ${parsedResult.notes.length} raw notes before filtering`);
             for (const note of parsedResult.notes) {
-                (0, core_1.LogStatus)(`Memory Manager: Raw note: [${note.type}] "${note.content}" (confidence: ${note.confidence})`);
+                LogStatus(`Memory Manager: Raw note: [${note.type}] "${note.content}" (confidence: ${note.confidence})`);
             }
         }
+        // Filter by confidence threshold (use EXTRACTION_CONFIG)
         const candidateNotes = (parsedResult.notes || []).filter(n => n.confidence >= EXTRACTION_CONFIG.minConfidenceThreshold &&
             n.content && n.content.length >= EXTRACTION_CONFIG.minContentLength);
         if (candidateNotes.length === 0) {
             if (this._verbose) {
-                (0, core_1.LogStatus)('Memory Manager: No candidates passed confidence/length thresholds');
+                LogStatus('Memory Manager: No candidates passed confidence/length thresholds');
             }
             return [];
         }
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: ${candidateNotes.length} candidates passed confidence threshold (>=${EXTRACTION_CONFIG.minConfidenceThreshold})`);
+            LogStatus(`Memory Manager: ${candidateNotes.length} candidates passed confidence threshold (>=${EXTRACTION_CONFIG.minConfidenceThreshold})`);
+            // Log each extracted note for debugging
             for (const note of candidateNotes) {
-                (0, core_1.LogStatus)(`Memory Manager: Extracted note: [${note.type}] "${note.content}" (confidence: ${note.confidence})`);
+                LogStatus(`Memory Manager: Extracted note: [${note.type}] "${note.content}" (confidence: ${note.confidence})`);
             }
         }
+        // Apply sparsity: limit notes per message AND per conversation
         const notesByMessage = new Map();
         const noteCountByConversation = new Map();
         for (const note of candidateNotes) {
@@ -334,14 +393,15 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             const convId = note.sourceConversationId || 'unknown';
             const existingForMsg = notesByMessage.get(msgId) || [];
             const convCount = noteCountByConversation.get(convId) || 0;
+            // Check both per-message and per-conversation limits
             if (existingForMsg.length >= EXTRACTION_CONFIG.maxNotesPerMessage) {
                 if (this._verbose) {
-                    (0, core_1.LogStatus)(`Memory Manager: Skipping note (max ${EXTRACTION_CONFIG.maxNotesPerMessage} per message reached)`);
+                    LogStatus(`Memory Manager: Skipping note (max ${EXTRACTION_CONFIG.maxNotesPerMessage} per message reached)`);
                 }
             }
             else if (convCount >= EXTRACTION_CONFIG.maxNotesPerConversation) {
                 if (this._verbose) {
-                    (0, core_1.LogStatus)(`Memory Manager: Skipping note (max ${EXTRACTION_CONFIG.maxNotesPerConversation} per conversation reached)`);
+                    LogStatus(`Memory Manager: Skipping note (max ${EXTRACTION_CONFIG.maxNotesPerConversation} per conversation reached)`);
                 }
             }
             else {
@@ -352,8 +412,9 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         }
         const sparseCandidates = Array.from(notesByMessage.values()).flat();
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: ${sparseCandidates.length} candidates after sparsity filter`);
+            LogStatus(`Memory Manager: ${sparseCandidates.length} candidates after sparsity filter`);
         }
+        // Step 4: Apply deduplication (summary step)
         const step4 = await this.CreateRunStep('Decision', 'Deduplicate Note Candidates', {
             candidateCount: sparseCandidates.length,
             existingNoteCount: existingNotes.length
@@ -361,26 +422,33 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         const approvedNotes = [];
         let dedupeRejectedCount = 0;
         let dedupeLlmCallCount = 0;
-        const dedupePrompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Deduplicate Note' && p.Category === 'MJ: System');
+        // Find deduplication prompt
+        const dedupePrompt = AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Deduplicate Note' && p.Category === 'MJ: System');
         for (const candidate of sparseCandidates) {
+            // Check global max notes per run
             if (approvedNotes.length >= EXTRACTION_CONFIG.maxNotesPerRun) {
                 if (this._verbose) {
-                    (0, core_1.LogStatus)(`Memory Manager: Stopping - max notes per run (${EXTRACTION_CONFIG.maxNotesPerRun}) reached`);
+                    LogStatus(`Memory Manager: Stopping - max notes per run (${EXTRACTION_CONFIG.maxNotesPerRun}) reached`);
                 }
                 break;
             }
+            // Step 1: Check for exact content match FIRST (case-insensitive, trimmed)
             const normalizedContent = candidate.content.toLowerCase().trim();
             const exactMatch = existingNotes.find(n => n.Note && n.Note.toLowerCase().trim() === normalizedContent);
             if (exactMatch) {
                 dedupeRejectedCount++;
                 if (this._verbose) {
-                    (0, core_1.LogStatus)(`Memory Manager: Skipping exact duplicate: "${candidate.content.substring(0, 50)}..."`);
+                    LogStatus(`Memory Manager: Skipping exact duplicate: "${candidate.content.substring(0, 50)}..."`);
                 }
                 continue;
             }
-            const similarNotes = await aiengine_1.AIEngine.Instance.FindSimilarAgentNotes(candidate.content, candidate.agentId, candidate.userId, candidate.companyId, 10, 0.85);
+            // Step 2: Find similar existing notes using semantic search with tighter threshold
+            const similarNotes = await AIEngine.Instance.FindSimilarAgentNotes(candidate.content, candidate.agentId, candidate.userId, candidate.companyId, 10, // Top 10 similar (increased from 5)
+            0.85 // 85% similarity threshold (increased from 70%)
+            );
+            // Step 3: If deduplication prompt exists and similar notes found, ask LLM
             if (dedupePrompt && similarNotes.length > 0) {
-                const dedupeParams = new ai_core_plus_1.AIPromptParams();
+                const dedupeParams = new AIPromptParams();
                 dedupeParams.prompt = dedupePrompt;
                 dedupeParams.data = {
                     candidateNote: candidate,
@@ -399,31 +467,35 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 if (dedupeResult.success && dedupeResult.result && dedupeResult.result.shouldAdd) {
                     approvedNotes.push(candidate);
                     if (this._verbose) {
-                        (0, core_1.LogStatus)(`Memory Manager: Approved note - ${dedupeResult.result.reason}`);
+                        LogStatus(`Memory Manager: Approved note - ${dedupeResult.result.reason}`);
                     }
                 }
                 else {
                     dedupeRejectedCount++;
                     if (this._verbose) {
-                        (0, core_1.LogStatus)(`Memory Manager: Skipped duplicate note - ${dedupeResult.result?.reason || 'too similar to existing notes'}`);
+                        LogStatus(`Memory Manager: Skipped duplicate note - ${dedupeResult.result?.reason || 'too similar to existing notes'}`);
                     }
                 }
             }
             else {
+                // No similar notes found or no deduplication prompt, add the note
                 approvedNotes.push(candidate);
                 if (this._verbose) {
-                    (0, core_1.LogStatus)(`Memory Manager: Approved note (no similar notes found): "${candidate.content.substring(0, 50)}..."`);
+                    LogStatus(`Memory Manager: Approved note (no similar notes found): "${candidate.content.substring(0, 50)}..."`);
                 }
             }
         }
+        // Finalize Step 4 after deduplication loop
         await this.FinalizeRunStep(step4, true, {
             approvedCount: approvedNotes.length,
             rejectedCount: dedupeRejectedCount,
             llmCallCount: dedupeLlmCallCount
         });
         if (this._verbose) {
-            (0, core_1.LogStatus)(`Memory Manager: Final approved notes: ${approvedNotes.length}`);
+            LogStatus(`Memory Manager: Final approved notes: ${approvedNotes.length}`);
         }
+        // Enrich notes with userId and agentRunId from conversation context
+        // Build a map of conversationId -> context for quick lookup
         const conversationContext = new Map();
         for (const thread of conversationThreads) {
             conversationContext.set(thread.conversationId, {
@@ -431,13 +503,16 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 agentRunId: thread.agentRunId || null
             });
         }
+        // Enrich each note with conversation context
         for (const note of approvedNotes) {
             if (note.sourceConversationId) {
                 const ctx = conversationContext.get(note.sourceConversationId);
                 if (ctx) {
+                    // Set userId from conversation if not already set
                     if (!note.userId && ctx.userId) {
                         note.userId = ctx.userId;
                     }
+                    // Set sourceAgentRunId from conversation if not already set
                     if (!note.sourceAgentRunId && ctx.agentRunId) {
                         note.sourceAgentRunId = ctx.agentRunId;
                     }
@@ -446,10 +521,15 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         }
         return approvedNotes;
     }
+    /**
+     * Extract examples from conversation details with high ratings.
+     * Uses LLM-based deduplication to avoid adding redundant examples.
+     */
     async ExtractExamples(conversationDetails, contextUser) {
         if (conversationDetails.length === 0) {
             return [];
         }
+        // Prepare Q&A pairs from conversation details
         const qaPairs = conversationDetails.map(detail => ({
             id: detail.ID,
             conversationId: detail.ConversationID,
@@ -457,16 +537,18 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             message: detail.Message,
             createdAt: detail.__mj_CreatedAt
         }));
-        const extractPrompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Extract Examples' && p.Category === 'MJ: System');
+        // Find extraction prompt
+        const extractPrompt = AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Extract Examples' && p.Category === 'MJ: System');
         if (!extractPrompt) {
-            (0, core_1.LogError)('Memory Manager example extraction prompt not found');
+            LogError('Memory Manager example extraction prompt not found');
             return [];
         }
+        // Step 5: Execute AI extraction
         const step5 = await this.CreateRunStep('Prompt', 'Extract Examples from Conversations', {
             qaPairCount: qaPairs.length
         }, extractPrompt.ID);
-        const runner = new ai_prompts_1.AIPromptRunner();
-        const extractParams = new ai_core_plus_1.AIPromptParams();
+        const runner = new AIPromptRunner();
+        const extractParams = new AIPromptParams();
         extractParams.prompt = extractPrompt;
         extractParams.data = { qaPairs };
         extractParams.contextUser = contextUser;
@@ -475,16 +557,17 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             await this.FinalizeRunStep(step5, false, {
                 success: false
             }, extractResult.promptRun?.ID, extractResult.errorMessage || undefined);
-            (0, core_1.LogError)('Failed to extract examples:', extractResult.errorMessage);
+            LogError('Failed to extract examples:', extractResult.errorMessage);
             return [];
         }
+        // Parse result if it's a string (AI sometimes returns JSON as string)
         let parsedResult;
         if (typeof extractResult.result === 'string') {
             try {
                 parsedResult = JSON.parse(extractResult.result);
             }
             catch (e) {
-                (0, core_1.LogError)('Failed to parse example extraction result as JSON:', e);
+                LogError('Failed to parse example extraction result as JSON:', e);
                 return [];
             }
         }
@@ -493,6 +576,7 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         }
         const candidateExamples = (parsedResult.examples || [])
             .filter(e => e.successScore >= 70 && e.confidence >= 70);
+        // Finalize Step 5 after extraction parsing
         await this.FinalizeRunStep(step5, true, {
             rawExampleCount: parsedResult.examples?.length || 0,
             candidateCount: candidateExamples.length
@@ -500,17 +584,23 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         if (candidateExamples.length === 0) {
             return [];
         }
+        // Step 6: Deduplicate example candidates (summary step)
         const step6 = await this.CreateRunStep('Decision', 'Deduplicate Example Candidates', {
             candidateCount: candidateExamples.length
         });
         const approvedExamples = [];
         let exampleDedupeRejectedCount = 0;
         let exampleDedupeLlmCallCount = 0;
+        // Process each candidate example with LLM-based deduplication
         for (const candidate of candidateExamples) {
-            const similarExamples = await aiengine_1.AIEngine.Instance.FindSimilarAgentExamples(candidate.exampleInput, candidate.agentId, candidate.userId, candidate.companyId, 5, 0.7);
-            const dedupePrompt = aiengine_1.AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Deduplicate Example' && p.Category === 'MJ: System');
+            // Find similar existing examples using semantic search
+            const similarExamples = await AIEngine.Instance.FindSimilarAgentExamples(candidate.exampleInput, candidate.agentId, candidate.userId, candidate.companyId, 5, // Top 5 similar
+            0.7 // 70% similarity threshold
+            );
+            // Ask LLM if this candidate adds value given existing similar examples
+            const dedupePrompt = AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Deduplicate Example' && p.Category === 'MJ: System');
             if (dedupePrompt && similarExamples.length > 0) {
-                const dedupeParams = new ai_core_plus_1.AIPromptParams();
+                const dedupeParams = new AIPromptParams();
                 dedupeParams.prompt = dedupePrompt;
                 dedupeParams.data = {
                     candidateExample: candidate,
@@ -527,20 +617,22 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 if (dedupeResult.success && dedupeResult.result && dedupeResult.result.shouldAdd) {
                     approvedExamples.push(candidate);
                     if (this._verbose) {
-                        (0, core_1.LogStatus)(`Memory Manager: Approved example - ${dedupeResult.result.reason}`);
+                        LogStatus(`Memory Manager: Approved example - ${dedupeResult.result.reason}`);
                     }
                 }
                 else {
                     exampleDedupeRejectedCount++;
                     if (this._verbose) {
-                        (0, core_1.LogStatus)(`Memory Manager: Skipped duplicate example - ${dedupeResult.result?.reason || 'too similar'}`);
+                        LogStatus(`Memory Manager: Skipped duplicate example - ${dedupeResult.result?.reason || 'too similar'}`);
                     }
                 }
             }
             else {
+                // No similar examples found, add it
                 approvedExamples.push(candidate);
             }
         }
+        // Finalize Step 6 after deduplication loop
         await this.FinalizeRunStep(step6, true, {
             approvedCount: approvedExamples.length,
             rejectedCount: exampleDedupeRejectedCount,
@@ -548,23 +640,33 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         });
         return approvedExamples;
     }
+    /**
+     * Check if a string is a valid UUID format.
+     */
     isValidUUID(str) {
         const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
         return uuidRegex.test(str);
     }
+    /**
+     * Create note records from extracted data.
+     * Inherits scope from source agent run and applies scopeLevel to determine scope specificity.
+     */
     async CreateNoteRecords(extractedNotes, contextUser) {
+        // Step 7: Create Note Records
         const step7 = await this.CreateRunStep('Decision', 'Create Note Records', {
             noteCount: extractedNotes.length
         });
         let created = 0;
         let merged = 0;
         let failed = 0;
-        const md = new core_1.Metadata();
-        const rv = new core_1.RunView();
+        const md = new Metadata();
+        const rv = new RunView();
+        // Cache source agent runs to avoid repeated lookups
         const runCache = new Map();
-        const aiNoteTypeId = aiengine_1.AIEngine.Instance.AgenteNoteTypeIDByName('AI');
+        // Get the "AI" note type ID for AI-generated notes
+        const aiNoteTypeId = AIEngine.Instance.AgenteNoteTypeIDByName('AI');
         if (!aiNoteTypeId) {
-            (0, core_1.LogError)('Memory Manager: Could not find "AI" note type - cannot create notes');
+            LogError('Memory Manager: Could not find "AI" note type - cannot create notes');
             await this.FinalizeRunStep(step7, false, {
                 created: 0,
                 merged: 0,
@@ -574,6 +676,7 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         }
         for (const extracted of extractedNotes) {
             try {
+                // Load source agent run for scope inheritance (if available)
                 let sourceRun = null;
                 if (extracted.sourceAgentRunId) {
                     if (!runCache.has(extracted.sourceAgentRunId)) {
@@ -587,9 +690,11 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                     }
                     sourceRun = runCache.get(extracted.sourceAgentRunId) || null;
                 }
+                // Check if we should merge with existing
                 if (extracted.mergeWithExistingId) {
                     const existingNote = await md.GetEntityObject('AI Agent Notes', contextUser);
                     if (await existingNote.Load(extracted.mergeWithExistingId)) {
+                        // Update existing note
                         existingNote.Note = extracted.content;
                         existingNote.Type = extracted.type;
                         existingNote.AgentNoteTypeID = aiNoteTypeId;
@@ -605,12 +710,15 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                     }
                 }
                 else {
+                    // Create new note
                     const note = await md.GetEntityObject('AI Agent Notes', contextUser);
+                    // Only use valid UUIDs, filter out placeholders like "user-uuid-here"
                     const isValidUUID = (id) => {
                         if (!id)
                             return false;
                         return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
                     };
+                    // Determine AgentID - prefer extracted, then inherit from source run
                     let agentId = isValidUUID(extracted.agentId) ? extracted.agentId : null;
                     if (!agentId && sourceRun?.AgentID) {
                         agentId = sourceRun.AgentID;
@@ -618,15 +726,17 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                     note.AgentID = agentId;
                     note.UserID = isValidUUID(extracted.userId) ? extracted.userId : null;
                     note.CompanyID = isValidUUID(extracted.companyId) ? extracted.companyId : null;
-                    note.AgentNoteTypeID = aiNoteTypeId;
-                    note.Type = extracted.type;
+                    note.AgentNoteTypeID = aiNoteTypeId; // "AI" type for AI-generated notes
+                    note.Type = extracted.type; // Category: Preference, Constraint, Context, Issue, Example
                     note.Note = extracted.content;
                     note.IsAutoGenerated = true;
-                    note.Status = 'Active';
-                    note.AccessCount = 1;
+                    note.Status = 'Active'; // Auto-approve high-confidence notes
+                    note.AccessCount = 1; // Required field
                     note.SourceConversationID = extracted.sourceConversationId || null;
+                    // Only use if it's a valid UUID (LLM now sees message IDs in the prompt)
                     note.SourceConversationDetailID = isValidUUID(extracted.sourceConversationDetailId) ? extracted.sourceConversationDetailId : null;
                     note.SourceAIAgentRunID = extracted.sourceAgentRunId || null;
+                    // Apply scope: Lean towards USER-specific memories by default
                     const scopeLevel = extracted.scopeLevel || 'contact';
                     if (scopeLevel === 'global') {
                         note.PrimaryScopeEntityID = null;
@@ -649,15 +759,16 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                     }
                     else {
                         failed++;
-                        (0, core_1.LogError)(`Memory Manager: Failed to save note - Validation errors: ${JSON.stringify(note.LatestResult)}`);
+                        LogError(`Memory Manager: Failed to save note - Validation errors: ${JSON.stringify(note.LatestResult)}`);
                     }
                 }
             }
             catch (error) {
                 failed++;
-                (0, core_1.LogError)('Memory Manager: Exception creating note:', error);
+                LogError('Memory Manager: Exception creating note:', error);
             }
         }
+        // Finalize Step 7
         await this.FinalizeRunStep(step7, failed === 0 || created > 0 || merged > 0, {
             created,
             merged,
@@ -665,18 +776,25 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         });
         return created + merged;
     }
+    /**
+     * Create example records from extracted data.
+     * Inherits scope from source agent run and applies scopeLevel to determine scope specificity.
+     */
     async CreateExampleRecords(extractedExamples, contextUser) {
+        // Step 8: Create Example Records
         const step8 = await this.CreateRunStep('Decision', 'Create Example Records', {
             exampleCount: extractedExamples.length
         });
         let created = 0;
         let skipped = 0;
         let failed = 0;
-        const md = new core_1.Metadata();
-        const rv = new core_1.RunView();
+        const md = new Metadata();
+        const rv = new RunView();
+        // Cache source agent runs to avoid repeated lookups
         const runCache = new Map();
         for (const extracted of extractedExamples) {
             try {
+                // Load source agent run for scope inheritance (if available)
                 let sourceRun = null;
                 if (extracted.sourceAgentRunId) {
                     if (!runCache.has(extracted.sourceAgentRunId)) {
@@ -691,10 +809,11 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                     sourceRun = runCache.get(extracted.sourceAgentRunId) || null;
                 }
                 const example = await md.GetEntityObject('MJ: AI Agent Examples', contextUser);
+                // AgentID must come from source run - LLM doesn't know real agent IDs
                 if (!sourceRun?.AgentID) {
                     skipped++;
                     if (this._verbose) {
-                        (0, core_1.LogStatus)(`Memory Manager: Skipping example - no source run to inherit AgentID from`);
+                        LogStatus(`Memory Manager: Skipping example - no source run to inherit AgentID from`);
                     }
                     continue;
                 }
@@ -706,23 +825,28 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 example.ExampleOutput = extracted.exampleOutput;
                 example.IsAutoGenerated = true;
                 example.SuccessScore = extracted.successScore;
-                example.Status = 'Active';
+                example.Status = 'Active'; // Auto-approve high-confidence examples
                 example.SourceConversationID = extracted.sourceConversationId || null;
+                // Only use if it's a valid UUID
                 example.SourceConversationDetailID = this.isValidUUID(extracted.sourceConversationDetailId) ? extracted.sourceConversationDetailId : null;
                 example.SourceAIAgentRunID = extracted.sourceAgentRunId || null;
+                // Apply scope from source agent run based on scopeLevel hint
                 if (sourceRun && sourceRun.PrimaryScopeEntityID) {
-                    const scopeLevel = extracted.scopeLevel || 'contact';
+                    const scopeLevel = extracted.scopeLevel || 'contact'; // Default to most specific
                     if (scopeLevel === 'global') {
+                        // Global example - no scope fields set
                         example.PrimaryScopeEntityID = null;
                         example.PrimaryScopeRecordID = null;
                         example.SecondaryScopes = null;
                     }
                     else if (scopeLevel === 'organization') {
+                        // Org-level example - primary scope only, no secondary
                         example.PrimaryScopeEntityID = sourceRun.PrimaryScopeEntityID;
                         example.PrimaryScopeRecordID = sourceRun.PrimaryScopeRecordID;
                         example.SecondaryScopes = null;
                     }
                     else {
+                        // Fully-scoped example (contact level) - inherit full scope
                         example.PrimaryScopeEntityID = sourceRun.PrimaryScopeEntityID;
                         example.PrimaryScopeRecordID = sourceRun.PrimaryScopeRecordID;
                         example.SecondaryScopes = sourceRun.SecondaryScopes;
@@ -733,14 +857,15 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 }
                 else {
                     failed++;
-                    (0, core_1.LogError)(`Memory Manager: Failed to save example - Validation errors: ${JSON.stringify(example.LatestResult)}`);
+                    LogError(`Memory Manager: Failed to save example - Validation errors: ${JSON.stringify(example.LatestResult)}`);
                 }
             }
             catch (error) {
                 failed++;
-                (0, core_1.LogError)('Memory Manager: Exception creating example:', error);
+                LogError('Memory Manager: Exception creating example:', error);
             }
         }
+        // Finalize Step 8
         await this.FinalizeRunStep(step8, failed === 0 || created > 0, {
             created,
             skipped,
@@ -748,19 +873,25 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         });
         return created;
     }
+    /**
+     * Main execution method called by scheduler
+     */
     async executeAgentInternal(params, config) {
         try {
+            // Use verbose flag from agent execution params
             this._verbose = params.verbose ?? false;
+            // Initialize observability state for this run
             this._agentRunID = this.AgentRun?.ID || null;
             this._stepCounter = 0;
             this._contextUser = params.contextUser || null;
-            (0, core_1.LogStatus)('Memory Manager: Starting analysis cycle');
+            LogStatus('Memory Manager: Starting analysis cycle');
             const lastRunTime = await this.GetLastRunTime(params.agent.ID, params.contextUser);
+            // Load agents that have memory injection enabled
             const agentsUsingMemory = await this.LoadAgentsUsingMemory(params.contextUser);
             if (this._verbose) {
                 const sinceMessage = lastRunTime ? `since ${lastRunTime.toISOString()}` : 'all history';
-                (0, core_1.LogStatus)(`Memory Manager: Processing ${sinceMessage}`);
-                (0, core_1.LogStatus)(`Memory Manager: Found ${agentsUsingMemory.length} agents with memory injection enabled`);
+                LogStatus(`Memory Manager: Processing ${sinceMessage}`);
+                LogStatus(`Memory Manager: Found ${agentsUsingMemory.length} agents with memory injection enabled`);
             }
             if (agentsUsingMemory.length === 0) {
                 const finalStep = {
@@ -770,6 +901,7 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 };
                 return { finalStep, stepCount: 1 };
             }
+            // Step 1: Load conversations with new activity (includes rating data)
             const step1 = await this.CreateRunStep('Decision', 'Load Conversations With New Activity', {
                 since: lastRunTime?.toISOString() || null,
                 agentCount: agentsUsingMemory.length,
@@ -785,8 +917,9 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 unratedCount: conversations.filter(c => c.isUnrated).length
             });
             if (this._verbose) {
-                (0, core_1.LogStatus)(`Memory Manager: Found ${conversations.length} conversations with new activity`);
+                LogStatus(`Memory Manager: Found ${conversations.length} conversations with new activity`);
             }
+            // Step 2: Load high-value agent runs
             const step2 = await this.CreateRunStep('Decision', 'Load High-Value Agent Runs', {
                 since: lastRunTime?.toISOString() || null
             });
@@ -795,11 +928,11 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 runCount: agentRuns.length
             });
             if (this._verbose) {
-                (0, core_1.LogStatus)(`Memory Manager: Found ${agentRuns.length} high-value agent runs`);
+                LogStatus(`Memory Manager: Found ${agentRuns.length} high-value agent runs`);
             }
             if (conversations.length === 0 && agentRuns.length === 0) {
                 if (this._verbose) {
-                    (0, core_1.LogStatus)('Memory Manager: No data to process');
+                    LogStatus('Memory Manager: No data to process');
                 }
                 const finalStep = {
                     terminate: true,
@@ -808,10 +941,13 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 };
                 return { finalStep, stepCount: 1 };
             }
+            // Extract notes from conversations (with rating context)
             const extractedNotes = await this.ExtractNotesFromConversations(conversations, params.contextUser);
             if (this._verbose) {
-                (0, core_1.LogStatus)(`Memory Manager: Extracted ${extractedNotes.length} potential notes`);
+                LogStatus(`Memory Manager: Extracted ${extractedNotes.length} potential notes`);
             }
+            // Extract examples from conversation details (legacy method for now)
+            // Convert conversations back to flat details for example extraction
             const conversationDetails = conversations.flatMap(conv => conv.messages.map(msg => ({
                 ID: msg.id,
                 ConversationID: conv.conversationId,
@@ -822,8 +958,10 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             })));
             const extractedExamples = await this.ExtractExamples(conversationDetails, params.contextUser);
             if (this._verbose) {
-                (0, core_1.LogStatus)(`Memory Manager: Extracted ${extractedExamples.length} potential examples`);
+                LogStatus(`Memory Manager: Extracted ${extractedExamples.length} potential examples`);
             }
+            // Enrich examples with userId and agentRunId from conversation context
+            // Build a map from conversationId to context (same as notes enrichment)
             const conversationContextForExamples = new Map();
             for (const conv of conversations) {
                 conversationContextForExamples.set(conv.conversationId, {
@@ -835,34 +973,40 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
                 if (example.sourceConversationId) {
                     const ctx = conversationContextForExamples.get(example.sourceConversationId);
                     if (ctx) {
+                        // Enrich userId if not set
                         if (!example.userId && ctx.userId) {
                             example.userId = ctx.userId;
                             if (this._verbose) {
-                                (0, core_1.LogStatus)(`Memory Manager: Enriched example with userId from conversation: ${ctx.userId}`);
+                                LogStatus(`Memory Manager: Enriched example with userId from conversation: ${ctx.userId}`);
                             }
                         }
+                        // Enrich agentRunId if not set
                         if (!example.sourceAgentRunId && ctx.agentRunId) {
                             example.sourceAgentRunId = ctx.agentRunId;
                             if (this._verbose) {
-                                (0, core_1.LogStatus)(`Memory Manager: Enriched example with agentRunId from conversation: ${ctx.agentRunId}`);
+                                LogStatus(`Memory Manager: Enriched example with agentRunId from conversation: ${ctx.agentRunId}`);
                             }
                         }
                     }
                 }
+                // Clear invalid agentId (LLM sometimes returns placeholder values like "agent-12345")
                 if (example.agentId && !this.isValidUUID(example.agentId)) {
                     if (this._verbose) {
-                        (0, core_1.LogStatus)(`Memory Manager: Clearing invalid agentId "${example.agentId}" from example`);
+                        LogStatus(`Memory Manager: Clearing invalid agentId "${example.agentId}" from example`);
                     }
                     example.agentId = '';
                 }
             }
+            // Create records
             const notesCreated = await this.CreateNoteRecords(extractedNotes, params.contextUser);
             const examplesCreated = await this.CreateExampleRecords(extractedExamples, params.contextUser);
-            (0, core_1.LogStatus)(`Memory Manager: Created ${notesCreated} notes and ${examplesCreated} examples`);
+            LogStatus(`Memory Manager: Created ${notesCreated} notes and ${examplesCreated} examples`);
+            // Refresh AIEngine memory cache if any new memories were created
+            // This ensures subsequent agent runs can find the new notes/examples via semantic search
             if (notesCreated > 0 || examplesCreated > 0) {
-                (0, core_1.LogStatus)(`Memory Manager: Refreshing AIEngine memory cache...`);
-                await aiengine_1.AIEngine.Instance.Config(true, params.contextUser);
-                (0, core_1.LogStatus)(`Memory Manager: Memory cache refreshed`);
+                LogStatus(`Memory Manager: Refreshing AIEngine memory cache...`);
+                await AIEngine.Instance.Config(true, params.contextUser);
+                LogStatus(`Memory Manager: Memory cache refreshed`);
             }
             const finalStep = {
                 terminate: true,
@@ -879,7 +1023,7 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
             return { finalStep, stepCount: 1 };
         }
         catch (error) {
-            (0, core_1.LogError)('Memory Manager execution failed:', error);
+            LogError('Memory Manager execution failed:', error);
             const finalStep = {
                 terminate: true,
                 step: 'Failed',
@@ -889,8 +1033,8 @@ let MemoryManagerAgent = class MemoryManagerAgent extends base_agent_1.BaseAgent
         }
     }
 };
-exports.MemoryManagerAgent = MemoryManagerAgent;
-exports.MemoryManagerAgent = MemoryManagerAgent = __decorate([
-    (0, global_1.RegisterClass)(base_agent_1.BaseAgent, 'MemoryManagerAgent')
+MemoryManagerAgent = __decorate([
+    RegisterClass(BaseAgent, 'MemoryManagerAgent')
 ], MemoryManagerAgent);
+export { MemoryManagerAgent };
 //# sourceMappingURL=memory-manager-agent.js.map