@memberjunction/ai-agents 6.2.0-edge.0 → 6.2.0-edge.2

package/dist/memory-manager-agent.js

@@ -6,13 +6,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var MemoryManagerAgent_1;
 import { BaseAgent } from './base-agent.js';
-import { RegisterClass, CleanAndParseJSON } from '@memberjunction/global';
+import { RegisterClass, CleanAndParseJSON, IsPlainObject } from '@memberjunction/global';
 import { RunView, RunQuery, LogError, LogStatus, LogStatusEx } from '@memberjunction/core';
 import { IsInjectableNoteStatus } from '@memberjunction/core-entities';
 import { AIPromptRunner } from '@memberjunction/ai-prompts';
-import { AIPromptParams } from '@memberjunction/ai-core-plus';
+import { AIPromptParams, DescribeAnsweringModel } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
 import { UUIDsEqual } from '@memberjunction/global';
+import { AgentDecisionService } from './AgentDecisionService.js';
+import { BuildMemoryNoteQuestions, BuildMemoryNoteState, JudgeMemoryNotes, MemoryNotePromptQuestionCap, ChunkMemoryNotes, GroupMemoryNotesByConversation, MEMORY_NOTE_MIN_PROBABILITY } from './memory-note-gate.js';
 /**
  * Configuration for extraction limits to ensure sparsity
  */
@@ -131,7 +133,7 @@ const SOURCE_RUN_SCOPE_FIELDS = ['AgentID', 'CompanyID', 'UserID', 'PrimaryScope
  * 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 = MemoryManagerAgent_1 = class MemoryManagerAgent extends BaseAgent {
+let MemoryManagerAgent = class MemoryManagerAgent extends BaseAgent {
     constructor() {
         super(...arguments);
         /** Verbose logging flag from params.verbose */
@@ -142,6 +144,21 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         this._stepCounter = 0;
         /** Context user for step operations */
         this._contextUser = null;
+        /** Flag to enable typed decision gate instead of self-confidence threshold */
+        this._enableDecisionGate = false;
+    }
+    static { MemoryManagerAgent_1 = this; }
+    /**
+     * Whether the typed decision gate is enabled for filtering extracted memory notes.
+     * When false (default), uses the self-reported confidence filter (confidence >= 80).
+     * The gate also needs the master switch: the run's agent-type prompt params must set
+     * `decisionsEnabled: true` ({@link DecisionsEnabled}), or the confidence filter is used.
+     */
+    get EnableDecisionGate() {
+        return this._enableDecisionGate;
+    }
+    set EnableDecisionGate(value) {
+        this._enableDecisionGate = value;
     }
     /** Check if a string is a valid UUID format. Filters out LLM-generated placeholders like "user-uuid-here". */
     static isValidUUID(id) {
@@ -152,8 +169,9 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
     /**
      * Create an agent run step record for observability.
      * Returns null if agentRunID is not set (defensive check).
+     * Protected so a test can stand in for the database.
      */
-    async CreateRunStep(stepType, stepName, inputData, targetId) {
+    async createRunStep(stepType, stepName, inputData, targetId) {
         if (!this._agentRunID || !this._contextUser) {
             return null;
         }
@@ -188,7 +206,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
     /**
      * Finalize an agent run step with success/failure status and output data.
      */
-    async FinalizeRunStep(step, success, outputData, targetLogId, errorMessage) {
+    async finalizeRunStep(step, success, outputData, targetLogId, errorMessage) {
         if (!step) {
             return;
         }
@@ -217,7 +235,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * 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) {
+    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) —
@@ -263,7 +281,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * Load agents that have note or example injection enabled.
      * Only extract notes/examples for agents that actually use these features.
      */
-    async LoadAgentsUsingMemory(contextUser) {
+    async loadAgentsUsingMemory(contextUser) {
         const allAgents = AIEngine.Instance.Agents;
         const filteredAgents = allAgents.filter(a => a.Status === 'Active' && (a.InjectNotes || a.InjectExamples));
         // Debug logging only in verbose mode
@@ -290,7 +308,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * 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) {
+    async loadConversationsWithNewActivity(since, agentsUsingMemory, contextUser) {
         if (agentsUsingMemory.length === 0) {
             LogStatus('Memory Manager: No agents have memory injection enabled - skipping');
             return [];
@@ -362,7 +380,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * 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) {
+    async loadHighValueAgentRuns(since, contextUser) {
         const rv = new RunView();
         // Use subquery to find agent runs with high-usage artifacts
         const sinceFilter = since ? `AND au.__mj_CreatedAt >= '${since.toISOString()}'` : '';
@@ -415,7 +433,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * matching the high-value loader's lightweight projection. The confidence gate (≥80) downstream
      * discards transient/low-signal failures that carry no generalizable lesson.
      */
-    async LoadInstructiveFailedAgentRuns(since, contextUser) {
+    async loadInstructiveFailedAgentRuns(since, contextUser) {
         const rv = new RunView();
         const sinceFilter = since ? ` AND __mj_CreatedAt >= '${since.toISOString()}'` : '';
         const filter = `((Status IN ('Failed', 'Cancelled') AND ErrorMessage IS NOT NULL) OR (Success = 0 AND Status NOT IN ('Running', 'Paused')))${sinceFilter}`;
@@ -434,7 +452,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * 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) {
+    async extractNotesFromConversations(conversations, contextUser) {
         if (conversations.length === 0) {
             return [];
         }
@@ -468,7 +486,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 companyId: n.CompanyID
             }))
         };
-        return this.executeNoteExtraction(promptData, existingNotes, contextUser);
+        return this.executeNoteExtraction(promptData, existingNotes, contextUser, true);
     }
     /**
      * Mine corrective ("avoid this") memory from failed/cancelled agent runs. Each failed run
@@ -477,7 +495,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * to the corrective note types (Issue/Context only, never Constraint/Preference/Example) and
      * tagged 'Ephemeral' so a one-off transient failure decays unless reinforced by recurrence.
      */
-    async ExtractNotesFromFailedRuns(failedRuns, contextUser) {
+    async extractNotesFromFailedRuns(failedRuns, contextUser) {
         if (failedRuns.length === 0) {
             return [];
         }
@@ -508,7 +526,9 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 companyId: n.CompanyID
             }))
         };
-        const extracted = await this.executeNoteExtraction(promptData, existingNotes, contextUser);
+        // The decision gate was measured on conversation notes only; a corrective lesson from a failed run
+        // is not the durable user fact its question asks about, so these keep the self-reported rule.
+        const extracted = await this.executeNoteExtraction(promptData, existingNotes, contextUser, false);
         return this.markCorrectiveNotes(extracted);
     }
     /**
@@ -546,7 +566,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      *
      * Each step is its own private helper so the pipeline can be read top-to-bottom.
      */
-    async executeNoteExtraction(promptData, existingNotes, contextUser) {
+    async executeNoteExtraction(promptData, existingNotes, contextUser, decisionGateApplies) {
         // Step 1: run the extraction prompt and parse out the raw notes
         const rawNotes = await this.runNoteExtractionPrompt(promptData, existingNotes.length, contextUser);
         if (!rawNotes)
@@ -559,11 +579,11 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 LogStatus(`Memory Manager: Raw note: [${note.type}] "${note.content}" (confidence: ${note.confidence})${note.mergeWithExistingIds?.length ? ` mergeWith: ${note.mergeWithExistingIds.join(', ')}` : ''}`);
             }
         }
-        // Step 3: filter by confidence and content length
-        const candidateNotes = this.filterByConfidenceAndLength(rawNotes);
+        // Step 3: filter by decision gate or confidence/content length
+        const candidateNotes = await this.filterCandidateNotes(rawNotes, promptData.conversationThreads, contextUser, decisionGateApplies);
         if (candidateNotes.length === 0) {
             if (this._verbose)
-                LogStatus('Memory Manager: No candidates passed confidence/length thresholds');
+                LogStatus('Memory Manager: No candidates passed gating thresholds');
             return [];
         }
         // Step 4: apply per-message and per-conversation sparsity caps
@@ -592,7 +612,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             return null;
         const conversationThreads = promptData.conversationThreads;
         this.logExtractionPromptContext(prompt, conversationThreads);
-        const step = await this.CreateRunStep('Prompt', 'Extract Notes from Conversations', {
+        const step = await this.createRunStep('Prompt', 'Extract Notes from Conversations', {
             conversationCount: conversationThreads.length,
             messageCount: conversationThreads.reduce((sum, t) => sum + t.messages.length, 0),
             existingNoteCount
@@ -605,7 +625,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         params.attemptJSONRepair = true;
         params.additionalParameters = DETERMINISTIC_PROMPT_PARAMS;
         const result = await runner.ExecutePrompt(params);
-        await this.FinalizeRunStep(step, result.success, {
+        await this.finalizeRunStep(step, result.success, {
             success: result.success,
             rawNoteCount: result.result && typeof result.result !== 'string' ? (result.result.notes?.length || 0) : 0
         }, result.promptRun?.ID, result.errorMessage || undefined);
@@ -689,6 +709,134 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         return filtered;
     }
+    /**
+     * Filters candidate notes using either the typed decision gate (if enabled, with the master switch
+     * on, and the notes are ones it was measured on) or the traditional self-reported confidence and
+     * length filters. Protected so a test can run the gate the way extraction does.
+     *
+     * @param decisionGateApplies Whether these notes may be gated: conversation notes only.
+     */
+    async filterCandidateNotes(notes, conversationThreads, contextUser, decisionGateApplies) {
+        if (!this._enableDecisionGate || !this.DecisionsEnabled(this._runPromptParams) || !decisionGateApplies) {
+            return this.filterByConfidenceAndLength(notes);
+        }
+        return this.filterWithDecisionGate(notes, conversationThreads, contextUser);
+    }
+    /**
+     * Evaluates candidate notes through the typed decision gate, one conversation at a time: each note
+     * is judged against the conversation it came from, as the gate was measured and calibrated, in
+     * batches no larger than the prompt models' declared MaxQuestionsPerCall. A note whose conversation
+     * can't be told keeps the self-reported rule. The kept notes keep their original order.
+     */
+    async filterWithDecisionGate(notes, conversationThreads, contextUser) {
+        const lengthFiltered = notes.filter(n => n.content && n.content.length >= EXTRACTION_CONFIG.minContentLength);
+        if (lengthFiltered.length === 0) {
+            if (this._verbose)
+                LogStatus('Memory Manager: No candidates passed content length check before decision gate');
+            return [];
+        }
+        const cap = MemoryNotePromptQuestionCap(AIEngine.Instance, 'Default Decision');
+        const grouping = GroupMemoryNotesByConversation(lengthFiltered, conversationThreads.map(t => ({
+            ConversationId: t.conversationId,
+            Turns: t.messages.map(m => ({ role: m.role, text: m.message }))
+        })));
+        const kept = new Set(this.filterByConfidenceAndLength(grouping.Unattributed));
+        if (grouping.Unattributed.length > 0) {
+            LogStatus(`Memory Manager: ${grouping.Unattributed.length} note(s) name no conversation of this batch, so they keep the confidence filter`);
+        }
+        for (const conversation of grouping.Batches) {
+            for (const batch of ChunkMemoryNotes(conversation.Notes, cap)) {
+                const batchPassed = await this.judgeDecisionBatch(batch, conversation.ConversationId, conversation.Excerpt, contextUser, cap);
+                batchPassed.forEach(note => kept.add(note));
+            }
+        }
+        return lengthFiltered.filter(note => kept.has(note));
+    }
+    /**
+     * Runs a decision prompt call for a single batch of candidate notes from one conversation, falling
+     * back to the confidence filter if the decision call fails. The call's step joins the agent run's
+     * steps, and carries the call's prompt run, so the run's cost and token totals count it.
+     */
+    async judgeDecisionBatch(batch, conversationId, excerpt, contextUser, modelCap) {
+        const questions = BuildMemoryNoteQuestions(batch);
+        const state = BuildMemoryNoteState(batch, excerpt);
+        const step = await this.createRunStep('Decision', 'Judge Extracted Notes', {
+            conversationId,
+            noteCount: batch.length,
+            modelCap
+        });
+        if (step) {
+            this.AgentRun?.Steps.push(step);
+        }
+        const decisionService = this._agentDecisionService ?? new AgentDecisionService();
+        const result = await decisionService.Ask({
+            ContextUser: contextUser,
+            PromptName: 'Default Decision',
+            State: state,
+            Questions: questions,
+            AgentID: this.AgentRun?.AgentID ?? undefined,
+            CancellationToken: this._cancellationToken
+        });
+        await this.recordDecisionStep(step, result);
+        if (!result.success) {
+            LogStatus(`Memory Manager: Decision call failed (${result.errorMessage ?? 'unknown error'}), falling back to confidence filter for batch`);
+            return this.filterByConfidenceAndLength(batch);
+        }
+        const answeredBy = { ModelName: result.modelInfo?.modelName, ResolvedModel: result.DecisionResult?.ResolvedModel };
+        return this.evaluateDecisionVerdict(batch, result.Answers, answeredBy);
+    }
+    /**
+     * Puts the decision's prompt run on its step, which is how the agent run counts the call's cost
+     * and tokens, and marks the step complete.
+     */
+    async recordDecisionStep(step, result) {
+        if (!step)
+            return;
+        this.attachDecisionPromptRun(step, result);
+        await this.finalizeRunStep(step, result.success, { answers: result.Answers, model: result.modelInfo?.modelName, resolvedModel: result.DecisionResult?.ResolvedModel }, result.promptRun?.ID, result.errorMessage);
+    }
+    /** The answering models already logged as having no memory-note calibration, so each is logged once per process. */
+    static { this._uncalibratedGateModelsLogged = new Set(); }
+    /**
+     * Logs, once per model, that the decision gate fell back to the confidence filter because the
+     * model that answered has no memory-note calibration. That happens on a failover, when a decision
+     * model is added or renamed, or when a vendor model moves to another version (Jev's `APIName`).
+     */
+    static logUncalibratedGateModel(answeredBy) {
+        const described = DescribeAnsweringModel(answeredBy);
+        if (MemoryManagerAgent_1._uncalibratedGateModelsLogged.has(described)) {
+            return;
+        }
+        MemoryManagerAgent_1._uncalibratedGateModelsLogged.add(described);
+        LogStatus(`Memory Manager: ${described} has no memory-note calibration (MEMORY_NOTE_DECISION_CALIBRATION), so the decision gate falls back to the confidence filter for its batches`);
+    }
+    /**
+     * Applies calibrated probabilities to judge which candidate notes to keep. A note the calibrated
+     * model gave no usable answer for keeps the self-reported rule, as a failed call's batch does.
+     */
+    evaluateDecisionVerdict(batch, answers, answeredBy) {
+        const verdict = JudgeMemoryNotes(answers, batch, answeredBy, MEMORY_NOTE_MIN_PROBABILITY);
+        // Only a calibrated model replaces the self-reported confidence: one that answered without a
+        // calibration (a failover, or a calibrated model at another version) has not been shown to
+        // beat it, so the batch falls back to it.
+        if (!verdict.Calibrated) {
+            MemoryManagerAgent_1.logUncalibratedGateModel(answeredBy);
+            return this.filterByConfidenceAndLength(batch);
+        }
+        if (this._verbose) {
+            LogStatus(`Memory Manager: Decision gate evaluated ${batch.length} notes (calibrated: ${verdict.Calibrated}): kept ${verdict.KeptNotes.length}`);
+            for (const judged of verdict.JudgedNotes) {
+                LogStatus(`Memory Manager: Note [${judged.Note.type}] "${judged.Note.content.slice(0, 50)}..." -> kept: ${judged.Kept} (prob: ${judged.CalibratedProbability ?? judged.RawProbability ?? 'none'}), reason: ${judged.Reason}`);
+            }
+        }
+        const unanswered = verdict.JudgedNotes.filter(j => j.CalibratedProbability === undefined).map(j => j.Note);
+        if (unanswered.length === 0) {
+            return verdict.KeptNotes;
+        }
+        LogStatus(`Memory Manager: ${DescribeAnsweringModel(answeredBy)} gave no usable answer for ${unanswered.length} of ${batch.length} note(s), which keep the confidence filter`);
+        const kept = new Set([...verdict.KeptNotes, ...this.filterByConfidenceAndLength(unanswered)]);
+        return batch.filter(note => kept.has(note));
+    }
     /**
      * Enforce per-message and per-conversation note caps from EXTRACTION_CONFIG.
      * Drops any candidates that would exceed either cap.
@@ -731,7 +879,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * replacing). Creates and finalizes its own observability run step.
      */
     async deduplicateCandidates(candidates, existingNotes, contextUser) {
-        const step = await this.CreateRunStep('Decision', 'Deduplicate Note Candidates', {
+        const step = await this.createRunStep('Decision', 'Deduplicate Note Candidates', {
             candidateCount: candidates.length,
             existingNoteCount: existingNotes.length
         });
@@ -750,7 +898,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 approved.push(candidate);
             }
         }
-        await this.FinalizeRunStep(step, true, {
+        await this.finalizeRunStep(step, true, {
             approvedCount: approved.length,
             rejectedCount: stats.rejectedCount,
             llmCallCount: stats.llmCallCount
@@ -855,7 +1003,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * Extract examples from conversation details with high ratings.
      * Uses LLM-based deduplication to avoid adding redundant examples.
      */
-    async ExtractExamples(conversationDetails, contextUser) {
+    async extractExamples(conversationDetails, contextUser) {
         if (conversationDetails.length === 0) {
             return [];
         }
@@ -874,7 +1022,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             return [];
         }
         // Step 5: Execute AI extraction
-        const step5 = await this.CreateRunStep('Prompt', 'Extract Examples from Conversations', {
+        const step5 = await this.createRunStep('Prompt', 'Extract Examples from Conversations', {
             qaPairCount: qaPairs.length
         }, extractPrompt.ID);
         const runner = new AIPromptRunner();
@@ -886,7 +1034,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         extractParams.additionalParameters = { temperature: 0 };
         const extractResult = await runner.ExecutePrompt(extractParams);
         if (!extractResult.success || !extractResult.result) {
-            await this.FinalizeRunStep(step5, false, {
+            await this.finalizeRunStep(step5, false, {
                 success: false
             }, extractResult.promptRun?.ID, extractResult.errorMessage || undefined);
             LogError('Failed to extract examples:', extractResult.errorMessage);
@@ -909,7 +1057,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         const candidateExamples = (parsedResult.examples || [])
             .filter(e => e.successScore >= 70 && e.confidence >= 70);
         // Finalize Step 5 after extraction parsing
-        await this.FinalizeRunStep(step5, true, {
+        await this.finalizeRunStep(step5, true, {
             rawExampleCount: parsedResult.examples?.length || 0,
             candidateCount: candidateExamples.length
         }, extractResult.promptRun?.ID);
@@ -917,7 +1065,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             return [];
         }
         // Step 6: Deduplicate example candidates (summary step)
-        const step6 = await this.CreateRunStep('Decision', 'Deduplicate Example Candidates', {
+        const step6 = await this.createRunStep('Decision', 'Deduplicate Example Candidates', {
             candidateCount: candidateExamples.length
         });
         const approvedExamples = [];
@@ -967,7 +1115,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             }
         }
         // Finalize Step 6 after deduplication loop
-        await this.FinalizeRunStep(step6, true, {
+        await this.finalizeRunStep(step6, true, {
             approvedCount: approvedExamples.length,
             rejectedCount: exampleDedupeRejectedCount,
             llmCallCount: exampleDedupeLlmCallCount
@@ -978,9 +1126,9 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * Create note records from extracted data.
      * Inherits scope from source agent run and applies scopeLevel to determine scope specificity.
      */
-    async CreateNoteRecords(extractedNotes, contextUser) {
+    async createNoteRecords(extractedNotes, contextUser) {
         // Step 7: Create Note Records
-        const step7 = await this.CreateRunStep('Decision', 'Create Note Records', {
+        const step7 = await this.createRunStep('Decision', 'Create Note Records', {
             noteCount: extractedNotes.length
         });
         let created = 0;
@@ -993,7 +1141,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         const aiNoteTypeId = AIEngine.Instance.AgenteNoteTypeIDByName('AI');
         if (!aiNoteTypeId) {
             LogError('Memory Manager: Could not find "AI" note type - cannot create notes');
-            await this.FinalizeRunStep(step7, false, {
+            await this.finalizeRunStep(step7, false, {
                 created: 0,
                 merged: 0,
                 failed: extractedNotes.length
@@ -1108,7 +1256,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             }
         }
         // Finalize Step 7
-        await this.FinalizeRunStep(step7, failed === 0 || created > 0 || merged > 0, {
+        await this.finalizeRunStep(step7, failed === 0 || created > 0 || merged > 0, {
             created,
             merged,
             failed
@@ -1865,7 +2013,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      */
     async processConsolidationCluster(cluster, consolidatePrompt, aiNoteTypeId, runner, md, contextUser) {
         const maxGeneration = Math.max(...cluster.map(n => n.ConsolidationCount || 0));
-        const clusterStep = await this.CreateRunStep('Prompt', 'Process Consolidation Cluster', {
+        const clusterStep = await this.createRunStep('Prompt', 'Process Consolidation Cluster', {
             clusterSize: cluster.length,
             noteIds: cluster.map(n => n.ID),
             maxGeneration
@@ -1918,7 +2066,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         finally {
             // Treat skip (shouldConsolidate: false) as a successful completion rather than a
             // failure — the phase intentionally chose not to consolidate this cluster.
-            await this.FinalizeRunStep(clusterStep, outcome.consolidated === 1 || stepOutput.shouldConsolidate === false, stepOutput);
+            await this.finalizeRunStep(clusterStep, outcome.consolidated === 1 || stepOutput.shouldConsolidate === false, stepOutput);
         }
     }
     /**
@@ -2523,7 +2671,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      */
     async runHardeningPhase(contextUser) {
         const counters = { hardened: 0, deduped: 0, failed: 0 };
-        const step = await this.CreateRunStep('Decision', 'Harden Provisional Notes', {
+        const step = await this.createRunStep('Decision', 'Harden Provisional Notes', {
             maxNotesPerRun: HARDENING_CONFIG.maxNotesPerRun
         });
         try {
@@ -2541,7 +2689,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                 .sort((a, b) => new Date(a.__mj_CreatedAt).getTime() - new Date(b.__mj_CreatedAt).getTime())
                 .slice(0, HARDENING_CONFIG.maxNotesPerRun);
             if (provisionalNotes.length === 0) {
-                await this.FinalizeRunStep(step, true, { ...counters, provisionalCount: 0 });
+                await this.finalizeRunStep(step, true, { ...counters, provisionalCount: 0 });
                 return counters;
             }
             const runner = new AIPromptRunner();
@@ -2553,11 +2701,11 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             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 });
+            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));
+            await this.finalizeRunStep(step, false, counters, undefined, error instanceof Error ? error.message : String(error));
         }
         return counters;
     }
@@ -2634,7 +2782,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         return r;
     }
     async runImportancePhase(r, contextUser) {
-        const importanceStep = await this.CreateRunStep('Decision', 'Compute Importance Scores', {
+        const importanceStep = await this.createRunStep('Decision', 'Compute Importance Scores', {
             activeNoteCount: AIEngine.Instance.AgentNotes.filter(n => n.Status === 'Active').length
         });
         try {
@@ -2643,7 +2791,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             r.tierPromotions = scoringResult.tierPromotions;
             if (this._verbose)
                 LogStatus(`Memory Manager: Scored ${r.importanceScored} notes, ${r.tierPromotions} tier promotions`);
-            await this.FinalizeRunStep(importanceStep, true, {
+            await this.finalizeRunStep(importanceStep, true, {
                 notesScored: r.importanceScored,
                 tierPromotions: r.tierPromotions,
                 scoreDistribution: scoringResult.scoreDistribution
@@ -2651,12 +2799,12 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         catch (error) {
             LogError('Memory Manager: Importance scoring failed, continuing with other phases:', error);
-            await this.FinalizeRunStep(importanceStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
+            await this.finalizeRunStep(importanceStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
         }
     }
     async runConsolidationPhase(r, contextUser, triggerType) {
         const consolidatedNoteIds = new Set();
-        const consolidationStep = await this.CreateRunStep('Decision', 'Consolidate Related Notes', {
+        const consolidationStep = await this.createRunStep('Decision', 'Consolidate Related Notes', {
             frequency: CONSOLIDATION_CONFIG.frequency,
             triggerType,
             activeNoteCount: AIEngine.Instance.AgentNotes.filter(n => n.Status === 'Active' && n.IsAutoGenerated).length
@@ -2671,7 +2819,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             if (r.consolidatedCount > 0 && this._verbose) {
                 LogStatus(`Memory Manager: Consolidated ${r.consolidatedCount} clusters, archived ${r.consolidationArchived} source notes`);
             }
-            await this.FinalizeRunStep(consolidationStep, true, {
+            await this.finalizeRunStep(consolidationStep, true, {
                 consolidatedClusterCount: r.consolidatedCount,
                 sourceNotesArchived: r.consolidationArchived,
                 newConsolidatedNoteIds: Array.from(consolidatedNoteIds)
@@ -2679,7 +2827,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         catch (error) {
             LogError('Memory Manager: Consolidation failed, continuing with other phases:', error);
-            await this.FinalizeRunStep(consolidationStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
+            await this.finalizeRunStep(consolidationStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
         }
         // Emit the phase-level verification run step (spec Task 8c). Runs whether or not
         // any clusters were consolidated so "no items" runs still produce a visible step.
@@ -2688,14 +2836,14 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
     }
     /** Aggregate per-cluster verification results into a single phase-level run step. */
     async emitVerificationRunStep(verifications) {
-        const verificationStep = await this.CreateRunStep('Validation', 'Verify Consolidation Output', {
+        const verificationStep = await this.createRunStep('Validation', 'Verify Consolidation Output', {
             clustersVerified: verifications.length
         });
         const verificationsFlagged = verifications.filter(v => !v.passed).length;
         const verificationsPassed = verifications.filter(v => v.passed).length;
         const entitiesChecked = verifications.reduce((sum, v) => sum + v.entitiesChecked, 0);
         const entitiesMissing = verifications.flatMap(v => v.entitiesMissing);
-        await this.FinalizeRunStep(verificationStep, true, {
+        await this.finalizeRunStep(verificationStep, true, {
             clustersVerified: verifications.length,
             entitiesChecked,
             entitiesMissing,
@@ -2704,7 +2852,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         });
     }
     async runContradictionPhase(r, contextUser, consolidatedNoteIds) {
-        const contradictionStep = await this.CreateRunStep('Decision', 'Detect Note Contradictions', {
+        const contradictionStep = await this.createRunStep('Decision', 'Detect Note Contradictions', {
             consolidatedNoteIdsCount: consolidatedNoteIds.size
         });
         try {
@@ -2715,7 +2863,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             if (r.contradictionsFound > 0 && this._verbose) {
                 LogStatus(`Memory Manager: Found ${r.contradictionsFound} contradictions — resolved ${r.contradictionsResolved}, flagged ${r.contradictionsFlagged}`);
             }
-            await this.FinalizeRunStep(contradictionStep, true, {
+            await this.finalizeRunStep(contradictionStep, true, {
                 pairsAnalyzed: contradictionResult.pairsAnalyzed,
                 contradictionsFound: r.contradictionsFound,
                 contradictionsResolved: r.contradictionsResolved,
@@ -2725,7 +2873,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         catch (error) {
             LogError('Memory Manager: Contradiction detection failed, continuing with other phases:', error);
-            await this.FinalizeRunStep(contradictionStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
+            await this.finalizeRunStep(contradictionStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
         }
     }
     /**
@@ -2733,8 +2881,8 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * doesn't block the other.
      */
     async runPruneAndDecayPhases(r, contextUser) {
-        const pruneStep = await this.CreateRunStep('Decision', 'Prune Stale References', {});
-        const decayStep = await this.CreateRunStep('Decision', 'Decay-Based Archival', {});
+        const pruneStep = await this.createRunStep('Decision', 'Prune Stale References', {});
+        const decayStep = await this.createRunStep('Decision', 'Decay-Based Archival', {});
         await Promise.allSettled([
             this.runPrunePhase(r, contextUser, pruneStep),
             this.runDecayPhase(r, contextUser, decayStep),
@@ -2747,7 +2895,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             if (r.staleNotesArchived > 0 && this._verbose) {
                 LogStatus(`Memory Manager: Pruned ${r.staleNotesArchived} orphaned notes`);
             }
-            await this.FinalizeRunStep(pruneStep, true, {
+            await this.finalizeRunStep(pruneStep, true, {
                 notesArchived: r.staleNotesArchived,
                 orphanedAgents: pruneResult.orphanedAgents,
                 orphanedUsers: pruneResult.orphanedUsers,
@@ -2757,7 +2905,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         catch (error) {
             LogError('Memory Manager: Stale reference pruning failed:', error);
-            await this.FinalizeRunStep(pruneStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
+            await this.finalizeRunStep(pruneStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
         }
     }
     async runDecayPhase(r, contextUser, decayStep) {
@@ -2769,7 +2917,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             if (totalDecayArchived > 0 && this._verbose) {
                 LogStatus(`Memory Manager: Decay archival — ${decayResult.notesArchived} notes, ${decayResult.examplesArchived} examples, ${decayResult.notesExpired} expired notes, ${decayResult.examplesExpired} expired examples`);
             }
-            await this.FinalizeRunStep(decayStep, true, {
+            await this.finalizeRunStep(decayStep, true, {
                 notesArchived: decayResult.notesArchived,
                 examplesArchived: decayResult.examplesArchived,
                 notesExpired: decayResult.notesExpired,
@@ -2781,7 +2929,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         }
         catch (error) {
             LogError('Memory Manager: Decay-based archival failed:', error);
-            await this.FinalizeRunStep(decayStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
+            await this.finalizeRunStep(decayStep, false, undefined, undefined, error instanceof Error ? error.message : String(error));
         }
     }
     /** Build a human-readable summary string from maintenance phase results. */
@@ -2803,9 +2951,9 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
      * Create example records from extracted data.
      * Inherits scope from source agent run and applies scopeLevel to determine scope specificity.
      */
-    async CreateExampleRecords(extractedExamples, contextUser) {
+    async createExampleRecords(extractedExamples, contextUser) {
         // Step 8: Create Example Records
-        const step8 = await this.CreateRunStep('Decision', 'Create Example Records', {
+        const step8 = await this.createRunStep('Decision', 'Create Example Records', {
             exampleCount: extractedExamples.length
         });
         let created = 0;
@@ -2879,13 +3027,23 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             }
         }
         // Finalize Step 8
-        await this.FinalizeRunStep(step8, failed === 0 || created > 0, {
+        await this.finalizeRunStep(step8, failed === 0 || created > 0, {
             created,
             skipped,
             failed
         });
         return created;
     }
+    /**
+     * The run's merged agent-type prompt params: the agent type's defaults, then the Memory Manager
+     * agent's own `AgentTypePromptParams`, then the run's `data.__agentTypePromptParams`. This agent
+     * renders no Loop prompt, so it merges them itself, once per run.
+     */
+    runPromptParams(params) {
+        const agentType = AIEngine.Instance.AgentTypes.find(at => UUIDsEqual(at.ID, params.agent.TypeID));
+        const override = params.data?.__agentTypePromptParams;
+        return this.buildAgentTypePromptParams(agentType, params.agent, IsPlainObject(override) ? override : undefined);
+    }
     /**
      * Main execution method called by scheduler
      */
@@ -2893,6 +3051,11 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
         try {
             // Use verbose flag from agent execution params or data payload (UI passes it via data)
             this._verbose = params.verbose || params.data?.verbose || false;
+            if (typeof params.data?.enableDecisionGate === 'boolean') {
+                this._enableDecisionGate = params.data.enableDecisionGate;
+            }
+            this._runPromptParams = this.runPromptParams(params);
+            this._cancellationToken = params.cancellationToken;
             // Initialize observability state for this run
             this._agentRunID = this.AgentRun?.ID || null;
             this._stepCounter = 0;
@@ -2903,8 +3066,8 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             // 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)
+                this.getLastRunTime(params.agent.ID, params.contextUser),
+                this.loadAgentsUsingMemory(params.contextUser)
             ]);
             if (this._verbose) {
                 const sinceMessage = lastRunTime ? `since ${lastRunTime.toISOString()}` : 'all history';
@@ -2922,34 +3085,34 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             // 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', {
+            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 step2 = await this.CreateRunStep('Decision', 'Load High-Value Agent Runs', {
+            const step2 = await this.createRunStep('Decision', 'Load High-Value Agent Runs', {
                 since: lastRunTime?.toISOString() || null
             });
-            const step3 = await this.CreateRunStep('Decision', 'Load Instructive Failed Agent Runs', {
+            const step3 = await this.createRunStep('Decision', 'Load Instructive Failed Agent Runs', {
                 since: lastRunTime?.toISOString() || null
             });
             const [conversations, agentRuns, failedRuns] = await Promise.all([
-                this.LoadConversationsWithNewActivity(lastRunTime, agentsUsingMemory, params.contextUser),
-                this.LoadHighValueAgentRuns(lastRunTime, params.contextUser),
-                this.LoadInstructiveFailedAgentRuns(lastRunTime, params.contextUser)
+                this.loadConversationsWithNewActivity(lastRunTime, agentsUsingMemory, params.contextUser),
+                this.loadHighValueAgentRuns(lastRunTime, params.contextUser),
+                this.loadInstructiveFailedAgentRuns(lastRunTime, params.contextUser)
             ]);
             const totalMessages = conversations.reduce((sum, c) => sum + c.messages.length, 0);
-            await this.FinalizeRunStep(step1, true, {
+            await this.finalizeRunStep(step1, true, {
                 conversationCount: conversations.length,
                 totalMessages,
                 positiveCount: conversations.filter(c => c.hasPositiveRating).length,
                 negativeCount: conversations.filter(c => c.hasNegativeRating).length,
                 unratedCount: conversations.filter(c => c.isUnrated).length
             });
-            await this.FinalizeRunStep(step2, true, {
+            await this.finalizeRunStep(step2, true, {
                 runCount: agentRuns.length
             });
-            await this.FinalizeRunStep(step3, true, {
+            await this.finalizeRunStep(step3, true, {
                 runCount: failedRuns.length
             });
             if (this._verbose) {
@@ -2968,12 +3131,12 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
             let notesCreated = 0;
             let examplesCreated = 0;
             if (hasNewData) {
-                const extractedNotes = await this.ExtractNotesFromConversations(conversations, params.contextUser);
+                const extractedNotes = await this.extractNotesFromConversations(conversations, params.contextUser);
                 if (this._verbose) {
                     LogStatus(`Memory Manager: Extracted ${extractedNotes.length} potential notes`);
                 }
                 // Mine corrective notes from failed runs (Issue/Context only, Ephemeral tier).
-                const correctiveNotes = await this.ExtractNotesFromFailedRuns(failedRuns, params.contextUser);
+                const correctiveNotes = await this.extractNotesFromFailedRuns(failedRuns, params.contextUser);
                 if (this._verbose) {
                     LogStatus(`Memory Manager: Extracted ${correctiveNotes.length} corrective notes from failed runs`);
                 }
@@ -2987,7 +3150,7 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                     Message: msg.message,
                     __mj_CreatedAt: msg.createdAt
                 })));
-                const extractedExamples = await this.ExtractExamples(conversationDetails, params.contextUser);
+                const extractedExamples = await this.extractExamples(conversationDetails, params.contextUser);
                 if (this._verbose) {
                     LogStatus(`Memory Manager: Extracted ${extractedExamples.length} potential examples`);
                 }
@@ -3024,8 +3187,8 @@ let MemoryManagerAgent = MemoryManagerAgent_1 = class MemoryManagerAgent extends
                         example.agentId = '';
                     }
                 }
-                notesCreated = await this.CreateNoteRecords([...extractedNotes, ...correctiveNotes], params.contextUser);
-                examplesCreated = await this.CreateExampleRecords(extractedExamples, params.contextUser);
+                notesCreated = await this.createNoteRecords([...extractedNotes, ...correctiveNotes], params.contextUser);
+                examplesCreated = await this.createExampleRecords(extractedExamples, params.contextUser);
                 if (this._verbose)
                     LogStatus(`Memory Manager: Created ${notesCreated} notes and ${examplesCreated} examples`);
             }