@memberjunction/ai-agents 5.40.1 → 5.41.0

package/dist/memory-manager-agent.js

@@ -8,6 +8,7 @@ var MemoryManagerAgent_1;
 import { BaseAgent } from './base-agent.js';
 import { RegisterClass, CleanAndParseJSON } from '@memberjunction/global';
 import { RunView, RunQuery, LogError, LogStatus } from '@memberjunction/core';
+import { InjectableNoteStatusSQLList } from '@memberjunction/core-entities';
 import { AIPromptRunner } from '@memberjunction/ai-prompts';
 import { AIPromptParams } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
@@ -27,6 +28,10 @@ const EXTRACTION_CONFIG = {
  * Configuration for note consolidation.
  * Consolidation finds clusters of similar notes and synthesizes them into single comprehensive notes.
  */
+const HARDENING_CONFIG = {
+    maxNotesPerRun: 200, // Batch cap per MM run — remaining provisional notes picked up next cycle
+    dedupeSimilarity: 0.85, // Similarity threshold for the dedupe check against hardened notes
+};
 const CONSOLIDATION_CONFIG = {
     /**
      * How often to run consolidation:
@@ -117,6 +122,8 @@ const DETERMINISTIC_PROMPT_PARAMS = { temperature: 0 };
  * passes the visited check (e.g., extremely deep legitimate chains from a bug).
  */
 const MAX_SOURCE_RESOLUTION_DEPTH = 10;
+/** Fields fetched for a SourceRunScope projection. */
+const SOURCE_RUN_SCOPE_FIELDS = ['AgentID', 'CompanyID', 'UserID', 'PrimaryScopeEntityID', 'PrimaryScopeRecordID', 'SecondaryScopes'];
 /**
  * Memory Manager Agent - automatically extracts notes and examples from conversations.
  * This agent runs on a schedule (every 15 minutes) and analyzes high-quality conversations
@@ -209,13 +216,19 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * For first run, returns null to process all history (limited by MaxRows).
      */
     async GetLastRunTime(agentId, contextUser) {
+        // Read-only: we only need StartedAt, so use a 'simple' projection with a narrow Fields
+        // list. Loading this as 'entity_object' would build a full MJAIAgentRunEntityExtended,
+        // whose InnerLoad fires a secondary "MJ: AI Agent Run Steps" RunView (LoadRelatedData) —
+        // a round-trip the redundancy telemetry flagged as a duplicate. A simple projection
+        // skips that sub-query entirely.
         const rv = new RunView();
         const result = await rv.RunView({
             EntityName: 'MJ: AI Agent Runs',
             ExtraFilter: `AgentID='${agentId}' AND Status='Completed'`,
             OrderBy: 'StartedAt DESC',
             MaxRows: 1,
-            ResultType: 'entity_object'
+            Fields: ['StartedAt'],
+            ResultType: 'simple'
         }, contextUser);
         if (result.Success && result.Results && result.Results.length > 0) {
             // Ensure we return a proper Date object
@@ -225,6 +238,25 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         // First run - return null to process all history (with MaxRows limit)
         return null;
     }
+    /**
+     * Load a source agent run's scope fields (read-only) for scope inheritance, memoized in
+     * the supplied per-cycle cache. Uses a 'simple' projection so it does not trigger the
+     * agent-run entity's LoadRelatedData steps sub-query.
+     */
+    async loadSourceRunScope(sourceAgentRunId, runCache, contextUser) {
+        if (!runCache.has(sourceAgentRunId)) {
+            const rv = new RunView();
+            const runResult = await rv.RunView({
+                EntityName: 'MJ: AI Agent Runs',
+                ExtraFilter: `ID='${sourceAgentRunId}'`,
+                MaxRows: 1,
+                Fields: [...SOURCE_RUN_SCOPE_FIELDS],
+                ResultType: 'simple'
+            }, contextUser);
+            runCache.set(sourceAgentRunId, runResult.Success && runResult.Results?.length > 0 ? runResult.Results[0] : null);
+        }
+        return runCache.get(sourceAgentRunId) || null;
+    }
     /**
      * Load agents that have note or example injection enabled.
      * Only extract notes/examples for agents that actually use these features.
@@ -319,6 +351,12 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
     /**
      * Load agent runs with high-usage artifacts since last run.
      * Links through: ArtifactUse -> ArtifactVersion -> ConversationDetailArtifact -> ConversationDetail -> Conversation -> AIAgentRun
+     *
+     * The caller only consumes the row count (`.length`) of the returned set, so this reads a
+     * 'simple' ID-only projection rather than full entity objects. Loading these as
+     * 'entity_object' would build up to 50 MJAIAgentRunEntityExtended instances, each firing a
+     * secondary "MJ: AI Agent Run Steps" RunView via InnerLoad/LoadRelatedData — exactly the
+     * redundant round-trips the telemetry flagged. The simple projection skips all of them.
      */
     async LoadHighValueAgentRuns(since, contextUser) {
         const rv = new RunView();
@@ -350,7 +388,8 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             ExtraFilter: filter,
             OrderBy: '__mj_CreatedAt DESC',
             MaxRows: 50, // Limit to most recent 50 high-value runs
-            ResultType: 'entity_object'
+            Fields: ['ID'],
+            ResultType: 'simple'
         }, contextUser);
         return result.Success ? (result.Results || []) : [];
     }
@@ -848,8 +887,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         let merged = 0;
         let failed = 0;
         const md = this.ProviderToUse;
-        const rv = new RunView();
-        // Cache source agent runs to avoid repeated lookups
+        // Cache source agent runs (scope fields only) to avoid repeated lookups
         const runCache = new Map();
         // Get the "AI" note type ID for AI-generated notes
         const aiNoteTypeId = AIEngine.Instance.AgenteNoteTypeIDByName('AI');
@@ -867,16 +905,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 // Load source agent run for scope inheritance (if available)
                 let sourceRun = null;
                 if (extracted.sourceAgentRunId) {
-                    if (!runCache.has(extracted.sourceAgentRunId)) {
-                        const runResult = await rv.RunView({
-                            EntityName: 'MJ: AI Agent Runs',
-                            ExtraFilter: `ID='${extracted.sourceAgentRunId}'`,
-                            MaxRows: 1,
-                            ResultType: 'entity_object'
-                        }, contextUser);
-                        runCache.set(extracted.sourceAgentRunId, runResult.Success && runResult.Results?.length > 0 ? runResult.Results[0] : null);
-                    }
-                    sourceRun = runCache.get(extracted.sourceAgentRunId) || null;
+                    sourceRun = await this.loadSourceRunScope(extracted.sourceAgentRunId, runCache, contextUser);
                 }
                 // Check if we should merge with existing (revoke all targets, create one replacement)
                 let createNewNote = !extracted.mergeWithExistingIds?.length;
@@ -1202,7 +1231,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * Returns both a boolean and the reason it fired so the observability layer can
      * record the trigger type on the parent consolidation run step.
      */
-    async shouldRunConsolidation(agentId, contextUser, forceMaintenance) {
+    async shouldRunConsolidation(agentId, contextUser, forceMaintenance, lastRun) {
         if (forceMaintenance)
             return { shouldRun: true, triggerType: 'forced' };
         const freq = CONSOLIDATION_CONFIG.frequency;
@@ -1211,7 +1240,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         if (freq === 'every-run')
             return { shouldRun: true, triggerType: 'every-run' };
         if (freq === 'hourly' || freq === 'daily') {
-            return this.shouldRunConsolidationByTimeWindow(agentId, contextUser, freq === 'hourly' ? 1 : 24);
+            return this.shouldRunConsolidationByTimeWindow(contextUser, freq === 'hourly' ? 1 : 24, lastRun);
         }
         if (typeof freq === 'number') {
             return this.shouldRunConsolidationByRunCount(agentId, contextUser, freq);
@@ -1224,8 +1253,11 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * when the event-driven new-note threshold has been crossed. Falls back to
      * triggerType='not-triggered' when neither condition fires.
      */
-    async shouldRunConsolidationByTimeWindow(agentId, contextUser, thresholdHours) {
-        const lastRun = await this.GetLastRunTime(agentId, contextUser);
+    async shouldRunConsolidationByTimeWindow(contextUser, thresholdHours, lastRun) {
+        // `lastRun` is the same value computed once at the top of the maintenance cycle
+        // (executeAgentInternal). Threading it through here removes a second identical
+        // `MJ: AI Agent Runs` RunView (AgentID + Status='Completed', OrderBy StartedAt DESC)
+        // that the redundancy telemetry flagged as a duplicate round-trip.
         if (!lastRun)
             return { shouldRun: true, triggerType: 'time' };
         const hoursSinceLast = (Date.now() - lastRun.getTime()) / (1000 * 60 * 60);
@@ -1420,8 +1452,57 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         return originals;
     }
-    /** Load a batch of notes by ID with the fields needed for source resolution. */
+    /**
+     * Load a batch of notes by ID with the fields needed for source resolution.
+     *
+     * AIEngineBase caches `MJ: AI Agent Notes` unfiltered as full entity objects
+     * (`AIEngine.Instance.AgentNotes`), so source-chain ancestors — which are pre-existing
+     * notes, never ones created earlier in this same cycle — are already in memory. We serve
+     * those from the cache and only issue a RunView for IDs the cache doesn't have, instead of
+     * a DB round-trip per BFS depth level. This resolves the redundancy telemetry's
+     * "Entity Already in Engine" warning for AIEngineBase while preserving exact behavior
+     * (the projection shape and field set are unchanged).
+     */
     async loadResolvedNotes(noteIds, contextUser) {
+        const cachedById = new Map();
+        for (const note of AIEngine.Instance.AgentNotes) {
+            if (note.ID)
+                cachedById.set(note.ID.toLowerCase(), note);
+        }
+        const resolved = [];
+        const missingIds = [];
+        for (const id of noteIds) {
+            const cached = cachedById.get(id.toLowerCase());
+            if (cached) {
+                resolved.push(this.projectResolvedNote(cached));
+            }
+            else {
+                missingIds.push(id);
+            }
+        }
+        if (missingIds.length > 0) {
+            resolved.push(...await this.loadResolvedNotesFromDatabase(missingIds, contextUser));
+        }
+        return resolved;
+    }
+    /** Project a cached note entity into the read-only shape used by source resolution. */
+    projectResolvedNote(note) {
+        return {
+            ID: note.ID,
+            ConsolidationCount: note.ConsolidationCount,
+            DerivedFromNoteIDs: note.DerivedFromNoteIDs,
+            Note: note.Note,
+            Type: note.Type,
+            AccessCount: note.AccessCount,
+            ImportanceScore: note.ImportanceScore,
+            AgentID: note.AgentID,
+            UserID: note.UserID,
+            CompanyID: note.CompanyID,
+            __mj_CreatedAt: note.__mj_CreatedAt
+        };
+    }
+    /** RunView fallback for note IDs not present in the AIEngine cache. */
+    async loadResolvedNotesFromDatabase(noteIds, contextUser) {
         const resolvedFields = [
             'ID', 'ConsolidationCount', 'DerivedFromNoteIDs', 'Note', 'Type',
             'AccessCount', 'ImportanceScore', 'AgentID', 'UserID', 'CompanyID', '__mj_CreatedAt'
@@ -2133,22 +2214,27 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
     }
     async loadExpiredItems(contextUser, nowISO) {
         const rv = new RunView();
-        const [notesResult, examplesResult] = await Promise.all([
-            rv.RunView({
+        const [notesResult, examplesResult] = await rv.RunViews([
+            {
                 EntityName: 'MJ: AI Agent Notes',
-                ExtraFilter: `Status = 'Active' AND ExpiresAt IS NOT NULL AND ExpiresAt < '${nowISO}'`,
+                // Includes Provisional so the TTL safety net on in-flight agent writes is
+                // actually enforced — a provisional note the hardening pass never reaches
+                // must still expire.
+                ExtraFilter: `Status IN (${InjectableNoteStatusSQLList()}) AND ExpiresAt IS NOT NULL AND ExpiresAt < '${nowISO}'`,
                 Fields: ['ID', 'ExpiresAt', 'ProtectionTier'],
                 MaxRows: 200,
-            }, contextUser),
-            rv.RunView({
+            },
+            {
                 EntityName: 'MJ: AI Agent Examples',
                 ExtraFilter: `Status = 'Active' AND ExpiresAt IS NOT NULL AND ExpiresAt < '${nowISO}'`,
                 Fields: ['ID', 'ExpiresAt'],
                 MaxRows: 200,
-            }, contextUser)
-        ]);
+            }
+        ], contextUser);
         return [
-            notesResult.Success && notesResult.Results ? notesResult.Results : [],
+            notesResult.Success && notesResult.Results
+                ? notesResult.Results.filter((r) => 'ProtectionTier' in r)
+                : [],
             examplesResult.Success && examplesResult.Results ? examplesResult.Results : []
         ];
     }
@@ -2194,24 +2280,32 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * Fetch notes and examples in parallel — they're independent.
      */
     async loadDecayCandidates(contextUser) {
+        // Batch into one RunViews round-trip — see loadExpiredItems for the rationale on why
+        // two parallel RunView calls are flagged sequential by the redundancy telemetry. The
+        // two projections differ, so the batch is typed with their union and narrowed by
+        // position (notes carry ProtectionTier, examples carry SuccessScore).
         const rv = new RunView();
-        const [activeNotesResult, activeExamplesResult] = await Promise.all([
-            rv.RunView({
+        const [activeNotesResult, activeExamplesResult] = await rv.RunViews([
+            {
                 EntityName: 'MJ: AI Agent Notes',
                 ExtraFilter: `IsAutoGenerated = 1 AND Status = 'Active'`,
                 Fields: ['ID', 'ImportanceScore', 'ProtectionTier', 'LastAccessedAt', '__mj_CreatedAt', 'AccessCount', 'AgentID'],
                 MaxRows: 1000,
-            }, contextUser),
-            rv.RunView({
+            },
+            {
                 EntityName: 'MJ: AI Agent Examples',
                 ExtraFilter: `IsAutoGenerated = 1 AND Status = 'Active' AND SuccessScore < 50`,
                 Fields: ['ID', 'SuccessScore', 'LastAccessedAt', '__mj_CreatedAt', 'AccessCount', 'AgentID'],
                 MaxRows: 500,
-            }, contextUser)
-        ]);
+            }
+        ], contextUser);
         return [
-            activeNotesResult.Success && activeNotesResult.Results ? activeNotesResult.Results : [],
-            activeExamplesResult.Success && activeExamplesResult.Results ? activeExamplesResult.Results : []
+            activeNotesResult.Success && activeNotesResult.Results
+                ? activeNotesResult.Results.filter((r) => 'ProtectionTier' in r)
+                : [],
+            activeExamplesResult.Success && activeExamplesResult.Results
+                ? activeExamplesResult.Results.filter((r) => 'SuccessScore' in r)
+                : []
         ];
     }
     /**
@@ -2282,6 +2376,110 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         if (await exampleToArchive.Save())
             result.examplesArchived++;
     }
+    /**
+     * Hardening pass over in-flight agent-written notes (Status='Provisional',
+     * AuthorType='Agent'). Runs UNCONDITIONALLY at the start of every MM cycle —
+     * before the consolidation-gated maintenance phases — so that:
+     *   1. provisional notes never languish waiting for a consolidation trigger, and
+     *   2. notes hardened here participate in importance scoring, consolidation,
+     *      contradiction detection, and decay in the SAME cycle via the existing
+     *      machinery (no duplicated reconciliation logic in this pass).
+     *
+     * Per note: dedupe against hardened (Active) notes using the same LLM dedupe
+     * prompt as extraction — duplicates are Archived with ConsolidatedIntoNoteID
+     * lineage; survivors are hardened (Status='Active', ExpiresAt=NULL so the
+     * standard decay machinery owns their lifetime).
+     */
+    async runHardeningPhase(contextUser) {
+        const counters = { hardened: 0, deduped: 0, failed: 0 };
+        const step = await this.CreateRunStep('Decision', 'Harden Provisional Notes', {
+            maxNotesPerRun: HARDENING_CONFIG.maxNotesPerRun
+        });
+        try {
+            const rv = new RunView();
+            const result = await rv.RunView({
+                EntityName: 'MJ: AI Agent Notes',
+                ExtraFilter: `Status = 'Provisional' AND AuthorType = 'Agent'`,
+                OrderBy: '__mj_CreatedAt ASC',
+                MaxRows: HARDENING_CONFIG.maxNotesPerRun,
+                ResultType: 'entity_object'
+            }, contextUser);
+            if (!result.Success) {
+                await this.FinalizeRunStep(step, false, counters, undefined, `Failed to load provisional notes: ${result.ErrorMessage}`);
+                return counters;
+            }
+            const provisionalNotes = result.Results || [];
+            if (provisionalNotes.length === 0) {
+                await this.FinalizeRunStep(step, true, { ...counters, provisionalCount: 0 });
+                return counters;
+            }
+            const runner = new AIPromptRunner();
+            const dedupePrompt = AIEngine.Instance.Prompts.find(p => p.Name === 'Memory Manager - Deduplicate Note' && p.Category === 'MJ: System');
+            for (const note of provisionalNotes) {
+                const outcome = await this.hardenSingleNote(note, dedupePrompt, runner, contextUser);
+                counters[outcome]++;
+            }
+            if (this._verbose) {
+                LogStatus(`Memory Manager: Hardening pass — ${counters.hardened} hardened, ${counters.deduped} deduped, ${counters.failed} failed of ${provisionalNotes.length} provisional notes`);
+            }
+            await this.FinalizeRunStep(step, counters.failed === 0, { ...counters, provisionalCount: provisionalNotes.length });
+        }
+        catch (error) {
+            LogError('Memory Manager: Hardening pass failed, continuing with run:', error);
+            await this.FinalizeRunStep(step, false, counters, undefined, error instanceof Error ? error.message : String(error));
+        }
+        return counters;
+    }
+    /**
+     * Harden one provisional note: archive it as a duplicate when the LLM dedupe
+     * decision says an equivalent hardened note exists, otherwise promote it to
+     * Active with decay-managed lifetime.
+     */
+    async hardenSingleNote(note, dedupePrompt, runner, contextUser) {
+        try {
+            // Compare against HARDENED notes only — other provisional notes are themselves
+            // unvetted, and same-run duplicates were already handled at write time.
+            const similar = (await AIEngine.Instance.FindSimilarAgentNotes(note.Note || '', note.AgentID || undefined, note.UserID || undefined, note.CompanyID || undefined, 10, HARDENING_CONFIG.dedupeSimilarity)).filter(m => m.note.ID !== note.ID && m.note.Status === 'Active');
+            if (similar.length > 0 && dedupePrompt) {
+                const candidate = {
+                    type: note.Type,
+                    content: note.Note || '',
+                    confidence: 100,
+                    agentId: note.AgentID || undefined,
+                    userId: note.UserID || undefined,
+                    companyId: note.CompanyID || undefined,
+                };
+                const decision = await this.runDedupePromptForCandidate(runner, dedupePrompt, candidate, similar, contextUser);
+                if (!decision.shouldAdd) {
+                    const target = similar[0].note;
+                    note.Status = 'Archived';
+                    note.ConsolidatedIntoNoteID = target.ID;
+                    note.Comments = `${note.Comments || ''} [Hardening: duplicate of ${target.ID} — ${decision.reason}]`.trim();
+                    if (!await note.Save()) {
+                        LogError(`Memory Manager: Failed to archive duplicate provisional note ${note.ID}: ${note.LatestResult?.CompleteMessage || 'unknown error'}`);
+                        return 'failed';
+                    }
+                    target.AccessCount = (target.AccessCount || 0) + 1;
+                    target.LastAccessedAt = new Date();
+                    if (!await target.Save()) {
+                        LogError(`Memory Manager: Failed to bump dedupe target ${target.ID}: ${target.LatestResult?.CompleteMessage || 'unknown error'}`);
+                    }
+                    return 'deduped';
+                }
+            }
+            note.Status = 'Active';
+            note.ExpiresAt = null;
+            if (!await note.Save()) {
+                LogError(`Memory Manager: Failed to harden provisional note ${note.ID}: ${note.LatestResult?.CompleteMessage || 'unknown error'}`);
+                return 'failed';
+            }
+            return 'hardened';
+        }
+        catch (error) {
+            LogError(`Memory Manager: Exception hardening note ${note.ID}:`, error);
+            return 'failed';
+        }
+    }
     /**
      * Run all 5 maintenance phases in order: importance scoring, consolidation,
      * contradiction detection, stale-reference pruning, and decay-based archival.
@@ -2483,24 +2681,14 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         let skipped = 0;
         let failed = 0;
         const md = this.ProviderToUse;
-        const rv = new RunView();
-        // Cache source agent runs to avoid repeated lookups
+        // Cache source agent runs (scope fields only) 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)) {
-                        const runResult = await rv.RunView({
-                            EntityName: 'MJ: AI Agent Runs',
-                            ExtraFilter: `ID='${extracted.sourceAgentRunId}'`,
-                            MaxRows: 1,
-                            ResultType: 'entity_object'
-                        }, contextUser);
-                        runCache.set(extracted.sourceAgentRunId, runResult.Success && runResult.Results?.length > 0 ? runResult.Results[0] : null);
-                    }
-                    sourceRun = runCache.get(extracted.sourceAgentRunId) || null;
+                    sourceRun = await this.loadSourceRunScope(extracted.sourceAgentRunId, runCache, contextUser);
                 }
                 const example = await md.GetEntityObject('MJ: AI Agent Examples', contextUser);
                 // AgentID must come from source run - LLM doesn't know real agent IDs
@@ -2579,9 +2767,12 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             this._stepCounter = 0;
             this._contextUser = params.contextUser || null;
             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);
+            // Phase 1: the last-run-time and the memory-enabled agent set are independent — load in
+            // parallel (avoids two back-to-back sequential RunViews flagged by the parallelization telemetry).
+            const [lastRunTime, agentsUsingMemory] = await Promise.all([
+                this.GetLastRunTime(params.agent.ID, params.contextUser),
+                this.LoadAgentsUsingMemory(params.contextUser)
+            ]);
             if (this._verbose) {
                 const sinceMessage = lastRunTime ? `since ${lastRunTime.toISOString()}` : 'all history';
                 LogStatus(`Memory Manager: Processing ${sinceMessage}`);
@@ -2595,13 +2786,21 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 };
                 return { finalStep, stepCount: 1 };
             }
-            // Step 1: Load conversations with new activity (includes rating data)
+            // Phase 2: conversations-with-new-activity and high-value agent runs both depend only on
+            // (lastRunTime, agentsUsingMemory) — never on each other — so load them in parallel, each
+            // recorded in its own run step.
             const step1 = await this.CreateRunStep('Decision', 'Load Conversations With New Activity', {
                 since: lastRunTime?.toISOString() || null,
                 agentCount: agentsUsingMemory.length,
                 agentIds: agentsUsingMemory.map(a => a.ID)
             });
-            const conversations = await this.LoadConversationsWithNewActivity(lastRunTime, agentsUsingMemory, params.contextUser);
+            const step2 = await this.CreateRunStep('Decision', 'Load High-Value Agent Runs', {
+                since: lastRunTime?.toISOString() || null
+            });
+            const [conversations, agentRuns] = await Promise.all([
+                this.LoadConversationsWithNewActivity(lastRunTime, agentsUsingMemory, params.contextUser),
+                this.LoadHighValueAgentRuns(lastRunTime, params.contextUser)
+            ]);
             const totalMessages = conversations.reduce((sum, c) => sum + c.messages.length, 0);
             await this.FinalizeRunStep(step1, true, {
                 conversationCount: conversations.length,
@@ -2610,18 +2809,11 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 negativeCount: conversations.filter(c => c.hasNegativeRating).length,
                 unratedCount: conversations.filter(c => c.isUnrated).length
             });
-            if (this._verbose) {
-                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
-            });
-            const agentRuns = await this.LoadHighValueAgentRuns(lastRunTime, params.contextUser);
             await this.FinalizeRunStep(step2, true, {
                 runCount: agentRuns.length
             });
             if (this._verbose) {
+                LogStatus(`Memory Manager: Found ${conversations.length} conversations with new activity`);
                 LogStatus(`Memory Manager: Found ${agentRuns.length} high-value agent runs`);
             }
             const hasNewData = conversations.length > 0 || agentRuns.length > 0;
@@ -2691,8 +2883,15 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 if (this._verbose)
                     LogStatus(`Memory Manager: Created ${notesCreated} notes and ${examplesCreated} examples`);
             }
+            // Harden agent-written provisional notes FIRST and unconditionally — survivors
+            // become Active and participate in this same cycle's maintenance phases
+            // (importance, consolidation, contradiction, decay) when those fire.
+            const hardening = await this.runHardeningPhase(params.contextUser);
+            const hardeningSummary = hardening.hardened + hardening.deduped + hardening.failed > 0
+                ? ` Hardened ${hardening.hardened} provisional notes (${hardening.deduped} deduped, ${hardening.failed} failed).`
+                : '';
             const forceMaintenance = params.data?.forceMaintenance === true;
-            const triggerDecision = await this.shouldRunConsolidation(params.agent.ID, params.contextUser, forceMaintenance);
+            const triggerDecision = await this.shouldRunConsolidation(params.agent.ID, params.contextUser, forceMaintenance, lastRunTime);
             const maintenance = triggerDecision.shouldRun
                 ? await this.runMaintenancePhases(params.contextUser, forceMaintenance, triggerDecision.triggerType)
                 : { consolidatedCount: 0, consolidationArchived: 0, contradictionsFound: 0, contradictionsResolved: 0, contradictionsFlagged: 0, staleNotesArchived: 0, decayNotesArchived: 0, decayExamplesArchived: 0, importanceScored: 0, tierPromotions: 0 };
@@ -2700,7 +2899,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             const finalStep = {
                 terminate: true,
                 step: 'Success',
-                message: `Processed ${conversations.length} conversations (${totalMessages} messages) and ${agentRuns.length} agent runs. Created ${notesCreated} notes and ${examplesCreated} examples.${maintenanceSummary}`,
+                message: `Processed ${conversations.length} conversations (${totalMessages} messages) and ${agentRuns.length} agent runs. Created ${notesCreated} notes and ${examplesCreated} examples.${hardeningSummary}${maintenanceSummary}`,
                 newPayload: {
                     notesCreated,
                     examplesCreated,