@mxf-dev/core 1.0.0 → 2.0.0

package/src/services/McpToolDocumentationService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/MemoryCompressor.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 
@@ -56,9 +56,20 @@ export interface CompressionResult {
   originalLength: number;
   compressedLength: number;
   compressionRatio: number;
-  method: 'semantic' | 'extractive' | 'abstractive';
+  method: CompressionMethod;
 }
 
+/**
+ * How a memory's content was compressed.
+ *
+ * Only 'extractive' exists: leading sentences are kept and the remainder is discarded.
+ * The union previously also offered 'semantic' and 'abstractive', neither of which was
+ * ever implemented — 'semantic' was reported for what was, in fact, the same extractive
+ * slicing. Listing methods the service cannot perform invites callers to trust compressed
+ * memories more than they should.
+ */
+export type CompressionMethod = 'extractive';
+
 /**
  * Consolidation options
  */
@@ -257,18 +268,14 @@ export class MemoryCompressor {
     const originalLength = content.length;
     const targetRatio = this.compressionRatios[level];
 
-    let compressedContent: string;
-    let method: 'semantic' | 'extractive' | 'abstractive';
-
-    if (this.contextCompressor && level !== CompressionLevel.Light) {
-      // Use semantic compression for moderate/heavy compression
-      compressedContent = await this.semanticCompress(content, targetRatio);
-      method = 'semantic';
-    } else {
-      // Use extractive compression for light compression
-      compressedContent = this.extractiveCompress(content, targetRatio);
-      method = 'extractive';
-    }
+    // Every compression this service performs is extractive: it keeps leading sentences
+    // and discards the rest. The previous 'semantic' branch called a semanticCompress()
+    // that never touched the contextCompressor it checked for, and did exactly the same
+    // sentence-slicing as the extractive path — it differed only in the label it reported.
+    // Callers deciding how much to trust a compressed memory were reading that label, so
+    // it now says what actually happened.
+    const compressedContent = this.extractiveCompress(content, targetRatio);
+    const method: CompressionMethod = 'extractive';
 
     const compressedLength = compressedContent.length;
     const actualRatio = compressedLength / originalLength;
@@ -283,25 +290,6 @@ export class MemoryCompressor {
     };
   }
 
-  private async semanticCompress(content: string, targetRatio: number): Promise<string> {
-    // Use ContextCompressionEngine for semantic compression
-    const targetLength = Math.ceil(content.length * targetRatio);
-
-    // Simple summarization approach
-    const words = content.split(/\s+/);
-    const targetWords = Math.ceil(words.length * targetRatio);
-
-    if (words.length <= targetWords) {
-      return content;
-    }
-
-    // Extract key sentences (simple extractive approach)
-    const sentences = content.split(/[.!?]+/).filter(s => s.trim());
-    const targetSentences = Math.max(1, Math.ceil(sentences.length * targetRatio));
-
-    return sentences.slice(0, targetSentences).join('. ') + '.';
-  }
-
   private extractiveCompress(content: string, targetRatio: number): string {
     // Simple extractive compression: keep first N% of content
     const targetLength = Math.ceil(content.length * targetRatio);

package/src/services/MemoryService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 
@@ -30,6 +30,8 @@
  */
 
 import { Observable, of } from 'rxjs';
+import { IMemoryPersistence } from '../interfaces/IMemoryPersistence.js';
+import { MxfMeilisearchService } from './MxfMeilisearchService.js';
 import { v4 as uuidv4 } from 'uuid';
 
 import { 
@@ -160,7 +162,7 @@ export interface IEnhancedChannelMemory extends IChannelMemory {
 interface MemoryServiceConfig {
     enablePersistence?: boolean;
     cacheSize?: number;
-    persistenceService?: any; // Optional persistence service (server-only)
+    persistenceService?: IMemoryPersistence; // Optional persistence service (server-only, injected at boot)
 }
 
 /**
@@ -191,7 +193,7 @@ export class MemoryService {
     private config: MemoryServiceConfig;
 
     // Optional persistence service (server-only)
-    private persistenceService?: any;
+    private persistenceService?: IMemoryPersistence;
 
     // Validator
     private validator = createMemoryValidator('MemoryService');
@@ -612,9 +614,10 @@ export class MemoryService {
         }
 
         // If persistence service is available, try loading from MongoDB
-        if (this.persistenceService) {
+        const persistence = this.persistenceService;
+        if (persistence) {
             return new Observable<IEnhancedAgentMemory>(observer => {
-                this.persistenceService.getAgentMemory(agentId).subscribe({
+                persistence.getAgentMemory(agentId).subscribe({
                     next: (loadedMemory: any) => {
                         // Enhance the loaded memory with cognitive memory structure
                         const enhancedMemory: IEnhancedAgentMemory = {
@@ -1628,50 +1631,63 @@ export class MemoryService {
 
         const semanticSearchStart = Date.now();
 
-        // Phase A: Semantic search to get candidates
-        // This would typically integrate with MxfMeilisearchService
-        // For now, we search cognitive memory as a fallback
+        // Phase A: semantic search over the real memory index.
+        //
+        // Meilisearch is the only retrieval path agents actually use, so utility scoring
+        // has to sit on top of it to influence anything. (This previously searched an
+        // in-process cognitiveMemory Map with keyword counting, which nothing populated
+        // in production — so the whole two-phase retrieval could never return a result.)
+        const meilisearch = MxfMeilisearchService.getInstance();
+        const maxCandidates = options.maxCandidates ?? 20;
+        const similarityThreshold = options.similarityThreshold ?? 0.3;
+
+        const filters: string[] = [];
+        if (options.agentId) {
+            filters.push(`agentId = "${options.agentId}"`);
+        }
+        if (options.channelId) {
+            filters.push(`channelId = "${options.channelId}"`);
+        }
+
+        const searchResult = await meilisearch.searchConversations({
+            query: options.query,
+            filter: filters.length > 0 ? filters.join(' AND ') : undefined,
+            limit: maxCandidates,
+            hybridRatio: options.hybridRatio ?? 0.7
+        });
+
+        const semanticSearchTimeMs = Date.now() - semanticSearchStart;
+
         const candidates: MemoryCandidate[] = [];
 
-        // Search cognitive memory entries matching the query
-        const allCognitiveEntries = Array.from(this.cognitiveMemory.values());
-        for (const entry of allCognitiveEntries) {
-            // Filter by agent/channel if specified
-            if (options.agentId && entry.agentId !== options.agentId) continue;
-            if (options.channelId && entry.channelId !== options.channelId) continue;
-
-            // Simple text similarity for cognitive memory (in production, use Meilisearch)
-            const contentStr = JSON.stringify(entry.content).toLowerCase();
-            const queryWords = options.query.toLowerCase().split(/\s+/);
-            const matchCount = queryWords.filter(word => contentStr.includes(word)).length;
-            const similarity = matchCount / Math.max(queryWords.length, 1);
-
-            // Apply similarity threshold
-            const threshold = options.similarityThreshold ?? 0.3;
-            if (similarity >= threshold) {
-                // Get Q-value from manager or use default
-                const qValue = qValueManager.getQValue(entry.id);
-
-                candidates.push({
-                    memoryId: entry.id,
-                    similarity,
-                    qValue,
-                    content: entry.content,
-                    metadata: {
-                        memoryType: entry.memoryType,
-                        labels: entry.labels,
-                        createdAt: entry.createdAt
-                    }
-                });
+        for (const hit of searchResult.hits) {
+            // Meilisearch ranking scores are already normalised to 0..1.
+            const similarity = hit._rankingScore;
+            if (similarity < similarityThreshold) {
+                continue;
             }
+
+            candidates.push({
+                memoryId: hit.id,
+                similarity,
+                qValue: qValueManager.getQValue(hit.id),
+                content: hit.content,
+                metadata: {
+                    memoryType: hit.role,
+                    createdAt: new Date(hit.timestamp)
+                }
+            });
         }
 
-        const semanticSearchTimeMs = Date.now() - semanticSearchStart;
+        // Load Q-values learned in previous runs before scoring, otherwise every memory
+        // this process has not seen yet would score at the default and ranking would
+        // silently ignore everything the system has learned.
+        await this.hydrateQValues(candidates.map(c => c.memoryId));
+        for (const candidate of candidates) {
+            candidate.qValue = qValueManager.getQValue(candidate.memoryId);
+        }
 
-        // Limit candidates for Phase B
-        const maxCandidates = options.maxCandidates ?? 20;
-        candidates.sort((a, b) => b.similarity - a.similarity);
-        const topCandidates = candidates.slice(0, maxCandidates);
+        const topCandidates = candidates;
 
         // Phase B: Utility scoring
         const utilityScoringStart = Date.now();
@@ -1735,28 +1751,50 @@ export class MemoryService {
     }
 
     /**
-     * Update Q-value for a specific memory
-     * Used by QValueManager persistence callback
+     * Persist the utility subdocument for a memory.
+     *
+     * Registered as QValueManager's persistence callback at server boot, so this runs
+     * on every Q-value change and on dirty-cache eviction. It must throw on failure:
+     * swallowing the error here is what previously made the whole learning system look
+     * like it worked while retaining nothing across a restart.
      */
     public async updateMemoryUtility(memoryId: string, utilityUpdate: Partial<MemoryUtilitySubdocument>): Promise<void> {
-        // Find the memory in cognitive memory cache
-        const cognitiveEntry = this.cognitiveMemory.get(memoryId);
-        if (cognitiveEntry) {
-            // Update in-memory cache (cognitive memory doesn't have utility subdoc by default)
-            // For cognitive memory, we just rely on QValueManager's cache
+        if (!this.persistenceService) {
+            throw new Error(
+                `[MemoryService] Cannot persist utility for memory ${memoryId}: no persistence service is configured. ` +
+                `MULS requires the server to inject a persistence service at boot.`
+            );
+        }
+
+        await this.persistenceService.updateAgentMemoryUtility(memoryId, utilityUpdate);
+    }
+
+    /**
+     * Load stored Q-values for a batch of memories into the QValueManager cache.
+     *
+     * Called before utility scoring so that ranking uses values learned in previous
+     * runs rather than the default for every memory the current process has not seen.
+     * Memories with no stored utility keep the configured default.
+     */
+    public async hydrateQValues(memoryIds: string[]): Promise<void> {
+        if (!this.persistenceService || memoryIds.length === 0) {
             return;
         }
 
-        // For persistent memory, delegate to persistence service
-        if (this.persistenceService) {
-            try {
-                // Update agent memory with utility subdocument
-                // This is a partial update to just the utility field
-                await this.persistenceService.updateAgentMemoryUtility?.(memoryId, utilityUpdate);
-            } catch (error) {
-                this.logger.warn(`[MemoryService] Failed to update utility for memory ${memoryId}: ${error}`);
-            }
+        const qValueManager = QValueManager.getInstance();
+        const uncached = memoryIds.filter(id => !qValueManager.isCached(id));
+        if (uncached.length === 0) {
+            return;
         }
+
+        const utilities = await this.persistenceService.getAgentMemoryUtilities(uncached);
+        for (const [memoryId, utility] of utilities) {
+            qValueManager.setQValueInCache(memoryId, utility.qValue);
+        }
+
+        this.logger.debug(
+            `[MemoryService] Hydrated ${utilities.size}/${uncached.length} Q-values from persistence`
+        );
     }
 
     /**

package/src/services/MxfMLService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 
@@ -862,28 +862,35 @@ export class MxfMLService {
      * @returns true if model was loaded successfully, false if not found
      */
     public async loadModel(modelId: string): Promise<boolean> {
-        const tfRef = this.getTf();
+        this.getTf();
         const entry = this.getModelEntry(modelId);
 
-        const backend = getStorageBackend();
-        let source: string;
-
         try {
-            if (backend === ModelStorageBackend.MONGODB_GRIDFS) {
-                const handler = new GridFSIOHandler(modelId);
-                entry.model = await tfRef.loadLayersModel(handler);
-                source = `gridfs://${modelId}`;
-            } else {
-                const modelDir = path.join(getModelStoragePath(), modelId);
-                const modelJsonPath = path.join(modelDir, 'model.json');
-                if (!fs.existsSync(modelJsonPath)) {
-                    this.logger.debug(`[MxfMLService] Model file not found: ${modelJsonPath}`);
-                    return false;
-                }
-                entry.model = await tfRef.loadLayersModel(`file://${modelDir}/model.json`);
-                source = `file://${modelDir}`;
+            const { loaded, source } = await this.loadModelFromBackend(modelId);
+
+            // Not found in storage (expected on first run before models are trained).
+            if (!loaded) {
+                return false;
             }
 
+            // Preserve compilation across the reload. tf.loadLayersModel() returns a
+            // model without an optimizer unless the saved artifacts carry a
+            // trainingConfig — and the GridFS backend never stores one, so the loaded
+            // model comes back uncompiled. buildSequentialModel() has already created a
+            // compiled model with this exact architecture, so copy the saved weights
+            // into it and keep its compilation. Replacing it outright would leave the
+            // model un-trainable, and the next scheduled retrain would throw
+            // "The model needs to be compiled before being used."
+            // When no model was pre-built (a standalone load for inference only),
+            // adopt the loaded model as-is.
+            if (entry.model) {
+                const builtModel = entry.model as any;
+                const loadedModel = loaded as any;
+                builtModel.setWeights(loadedModel.getWeights());
+                loadedModel.dispose();
+            } else {
+                entry.model = loaded;
+            }
             entry.status = ModelStatus.TRAINED;
 
             this.logger.info(`[MxfMLService] Model loaded: ${modelId} ← ${source}`);
@@ -923,6 +930,43 @@ export class MxfMLService {
         }
     }
 
+    /**
+     * Load a model's topology and weights from the configured storage backend.
+     *
+     * Returns the reconstructed tf.LayersModel and a human-readable source string,
+     * or { loaded: null } when the filesystem backend has no saved model yet.
+     *
+     * Note: tf.loadLayersModel() returns a model WITHOUT an optimizer unless the
+     * saved artifacts carry a trainingConfig. The GridFS handler does not persist
+     * one, so loaded models come back uncompiled — loadModel() compensates by
+     * keeping the already-built compiled model and copying these weights into it.
+     *
+     * @param modelId - ID of the model to load
+     * @returns The loaded model (or null if not found) and its source descriptor
+     */
+    private async loadModelFromBackend(
+        modelId: string
+    ): Promise<{ loaded: unknown | null; source: string }> {
+        const tfRef = this.getTf();
+        const backend = getStorageBackend();
+
+        if (backend === ModelStorageBackend.MONGODB_GRIDFS) {
+            const handler = new GridFSIOHandler(modelId);
+            return { loaded: await tfRef.loadLayersModel(handler), source: `gridfs://${modelId}` };
+        }
+
+        const modelDir = path.join(getModelStoragePath(), modelId);
+        const modelJsonPath = path.join(modelDir, 'model.json');
+        if (!fs.existsSync(modelJsonPath)) {
+            this.logger.debug(`[MxfMLService] Model file not found: ${modelJsonPath}`);
+            return { loaded: null, source: `file://${modelDir}` };
+        }
+        return {
+            loaded: await tfRef.loadLayersModel(`file://${modelDir}/model.json`),
+            source: `file://${modelDir}`,
+        };
+    }
+
     // ─── Memory Management ──────────────────────────────────────────────────────
 
     /**

package/src/services/MxfMeilisearchService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/MxfMessageAggregator.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/PatternLearningService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/PerformanceOptimizationService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/PredictiveAnalyticsService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 
@@ -67,7 +67,13 @@ export enum ModelType {
     GRADIENT_BOOSTING = 'gradient_boosting',
     NEURAL_NETWORK = 'neural_network',
     ISOLATION_FOREST = 'isolation_forest',
-    LSTM = 'lstm'
+    LSTM = 'lstm',
+    /**
+     * A rule-based heuristic, not a trained model. Exists so a heuristic result can say
+     * what it is: without it, heuristic predictions were reported to callers as
+     * GRADIENT_BOOSTING, alongside a hardcoded accuracy figure.
+     */
+    HEURISTIC = 'heuristic'
 }
 
 /**
@@ -188,14 +194,24 @@ export interface RiskScore {
  */
 export interface ModelMetadata {
     modelId: string;
+    /**
+     * Which predictor this describes ('error_prediction', 'anomaly_detection',
+     * 'pattern_forecast'). Identity has to be separate from `type`, because `type` now
+     * changes with training state — a predictor is a HEURISTIC until it is actually
+     * trained — so callers can no longer identify a predictor by its algorithm label.
+     */
+    name: string;
     type: ModelType;
     version: string;
-    trainedAt: number;
+    /** Null until the predictor has actually been trained. */
+    trainedAt: number | null;
+    /** Null for heuristics — they have no measured validation accuracy. */
     accuracy: number | null;
     features: string[];
     hyperparameters: Record<string, any>;
     trainingDataSize: number;
-    validationMetrics: Record<string, number>;
+    /** Null until a real validation run has produced metrics. */
+    validationMetrics: Record<string, number> | null;
 }
 
 /** TF.js model ID for the error prediction Dense classifier */
@@ -234,8 +250,6 @@ export class PredictiveAnalyticsService extends EventEmitter {
     // Otherwise falls back to the heuristic distance-based isolation score.
     private tfAnomalyAutoencoderReady: boolean = false;
 
-    // Models (simplified in-memory implementation)
-    private readonly models = new Map<string, any>();
     private readonly modelMetadata = new Map<string, ModelMetadata>();
     
     // Training data
@@ -601,7 +615,9 @@ export class PredictiveAnalyticsService extends EventEmitter {
             },
             features,
             model: {
-                type: usedTfModel ? ModelType.NEURAL_NETWORK : ModelType.GRADIENT_BOOSTING,
+                // Say which it actually was. A heuristic reported as GRADIENT_BOOSTING is
+                // how an unvalidated rule of thumb ends up being trusted as a trained model.
+                type: usedTfModel ? ModelType.NEURAL_NETWORK : ModelType.HEURISTIC,
                 version: modelMeta?.version || '1.0',
                 accuracy: modelMeta?.accuracy ?? null
             }
@@ -1662,37 +1678,36 @@ export class PredictiveAnalyticsService extends EventEmitter {
     /**
      * Initialize models
      */
+    /**
+     * Register metadata for the predictors this service exposes.
+     *
+     * Until a model is actually trained (see trainErrorPredictionModel and friends), every
+     * predictor here is a rule-based heuristic and is described as one. Nothing is
+     * reported as trained, and no accuracy is claimed.
+     *
+     * This previously registered three constant functions — `predict: () => ({score: 0.5,
+     * confidence: 0.7})` labelled GRADIENT_BOOSTING, and `sequence[last] * 1.1` labelled
+     * LSTM — together with a hardcoded accuracy of 0.75, a training-set size of 1000, and
+     * invented precision/recall figures, all of which were served to callers through the
+     * predictive_* tools and the REST layer. The predict functions were dead (nothing ever
+     * read this.models), but the fabricated metadata was not: it was read on every
+     * prediction. Both are gone.
+     */
     private initializeModels(): void {
-        // Initialize simplified models
-        // In production, would load actual trained models
-        
-        this.models.set('error_prediction', {
-            type: ModelType.GRADIENT_BOOSTING,
-            predict: (features: number[]) => ({ score: 0.5, confidence: 0.7 })
-        });
-        
-        this.models.set('anomaly_detection', {
-            type: ModelType.ISOLATION_FOREST,
-            predict: (features: number[]) => ({ score: 0.5 })
-        });
-        
-        this.models.set('pattern_forecast', {
-            type: ModelType.LSTM,
-            predict: (sequence: number[]) => sequence[sequence.length - 1] * 1.1
-        });
-        
-        // Set metadata
-        for (const [name, model] of this.models) {
+        const heuristicPredictors = ['error_prediction', 'anomaly_detection', 'pattern_forecast'];
+
+        for (const name of heuristicPredictors) {
             this.modelMetadata.set(name, {
                 modelId: uuidv4(),
-                type: model.type,
+                name,
+                type: ModelType.HEURISTIC,
                 version: '1.0.0',
-                trainedAt: Date.now(),
-                accuracy: 0.75,
+                trainedAt: null,
+                accuracy: null, // heuristics have no measured validation accuracy
                 features: [],
                 hyperparameters: {},
-                trainingDataSize: 1000,
-                validationMetrics: { accuracy: 0.75, precision: 0.8, recall: 0.7 }
+                trainingDataSize: 0,
+                validationMetrics: null
             });
         }
     }
@@ -1792,9 +1807,14 @@ export class PredictiveAnalyticsService extends EventEmitter {
                 // Update internal metadata with real training metrics
                 const modelMeta = this.modelMetadata.get('error_prediction');
                 if (modelMeta) {
+                    // Backed by a trained classifier now, not the heuristic.
+                    modelMeta.type = ModelType.NEURAL_NETWORK;
                     modelMeta.trainedAt = Date.now();
                     modelMeta.trainingDataSize = features.length;
-                    modelMeta.accuracy = metrics.accuracy ?? metrics.valAccuracy ?? 0.75;
+                    // If training reported no accuracy, we do not know the accuracy. Say so.
+                    // This previously fell back to 0.75 — an invented figure indistinguishable
+                    // from a measured one.
+                    modelMeta.accuracy = metrics.accuracy ?? metrics.valAccuracy ?? null;
                     modelMeta.validationMetrics = {
                         accuracy: metrics.accuracy ?? 0,
                         val_accuracy: metrics.valAccuracy ?? 0,
@@ -1916,6 +1936,9 @@ export class PredictiveAnalyticsService extends EventEmitter {
                 // Update internal metadata with real training metrics
                 const modelMeta = this.modelMetadata.get('anomaly_detection');
                 if (modelMeta) {
+                    // A real autoencoder is now backing this predictor, so it stops being a
+                    // heuristic and says so.
+                    modelMeta.type = ModelType.NEURAL_NETWORK;
                     modelMeta.trainedAt = Date.now();
                     modelMeta.trainingDataSize = features.length;
                     // For autoencoders, accuracy is not directly applicable —

package/src/services/ProactiveValidationService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/PromptArgumentInferenceService.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 

package/src/services/QValueManager.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  *
  * @author Brad Anderson <BradA1878@pm.me>
- * @repository https://github.com/mxf-dev/mxf
+ * @repository https://github.com/BradA1878/model-exchange-framework
  * @documentation https://mxf-dev.github.io/mxf/
  */
 
@@ -169,6 +169,16 @@ export class QValueManager {
         return result;
     }
 
+    /**
+     * Whether a Q-value for this memory is already in the cache.
+     *
+     * Used by MemoryService.hydrateQValues so a retrieval only reads persistence for
+     * memories this process has not scored yet.
+     */
+    public isCached(memoryId: string): boolean {
+        return this.qValueCache.has(memoryId);
+    }
+
     /**
      * Set Q-value in cache (typically called when loading from persistence)
      */