@yamo/memory-mesh 2.3.1 → 2.3.2

package/lib/lancedb/schema.js

@@ -102,6 +102,26 @@ function createMemorySchemaV2(vectorDim = DEFAULT_VECTOR_DIMENSION) {
   ]);
 }
 
+/**
+ * Create schema for synthesized skills (Recursive Skill Synthesis)
+ * @param {number} vectorDim - Vector dimension for intent embedding
+ * @returns {import('apache-arrow').Schema} Arrow schema
+ */
+export function createSynthesizedSkillSchema(vectorDim = DEFAULT_VECTOR_DIMENSION) {
+  return new arrow.Schema([
+    new arrow.Field('id', new arrow.Utf8(), false),
+    new arrow.Field('name', new arrow.Utf8(), false),
+    new arrow.Field('intent', new arrow.Utf8(), false),
+    new arrow.Field('yamo_text', new arrow.Utf8(), false),
+    new arrow.Field('vector',
+      new arrow.FixedSizeList(vectorDim, new arrow.Field('item', new arrow.Float32(), true)),
+      false
+    ),
+    new arrow.Field('metadata', new arrow.Utf8(), true), // Stored as JSON: {reliability, use_count, created_at}
+    new arrow.Field('created_at', new arrow.Timestamp(arrow.TimeUnit.MILLISECOND), false)
+  ]);
+}
+
 /**
  * Check if a table is using V2 schema
  * @param {import('apache-arrow').Schema} schema - Table schema to check

package/lib/memory/memory-mesh.js

@@ -32,13 +32,13 @@ import { LLMClient } from "../llm/client.js";
 class MemoryMesh {
   /**
    * Create a new MemoryMesh instance
-   * @param {Object} [options={}] - Configuration options
-   * @param {boolean} [options.enableYamo=true] - Enable YAMO block emission
-   * @param {boolean} [options.enableLLM=true] - Enable LLM for reflections
-   * @param {string} [options.agentId='default'] - Agent identifier for YAMO blocks
-   * @param {string} [options.llmProvider] - LLM provider (openai, anthropic, ollama)
-   * @param {string} [options.llmApiKey] - LLM API key
-   * @param {string} [options.llmModel] - LLM model name
+   * @param {Object} [options={}]
+   * @param {boolean} [options.enableYamo=true]
+   * @param {boolean} [options.enableLLM=true]
+   * @param {string} [options.agentId='default']
+   * @param {string} [options.llmProvider]
+   * @param {string} [options.llmApiKey]
+   * @param {string} [options.llmModel]
    */
   constructor(options = {}) {
     this.client = null;
@@ -53,6 +53,7 @@ class MemoryMesh {
     this.enableLLM = options.enableLLM !== false;    // Default: true
     this.agentId = options.agentId || 'default';
     this.yamoTable = null;  // Will be initialized in init()
+    this.skillTable = null; // Synthesized skills table
     this.llmClient = null;
 
     // Initialize LLM client if enabled
@@ -86,9 +87,6 @@ class MemoryMesh {
   /**
    * Generate a cache key from query and options
    * @private
-   * @param {string} query - Search query
-   * @param {Object} options - Search options
-   * @returns {string} Cache key
    */
   _generateCacheKey(query, options = {}) {
     const normalizedOptions = {
@@ -102,8 +100,6 @@ class MemoryMesh {
   /**
    * Get cached result if valid
    * @private
-   * @param {string} key - Cache key
-   * @returns {Object|null} Cached result or null if expired/missing
    */
   _getCachedResult(key) {
     const entry = this.queryCache.get(key);
@@ -125,8 +121,6 @@ class MemoryMesh {
   /**
    * Cache a search result
    * @private
-   * @param {string} key - Cache key
-   * @param {Object} result - Search result to cache
    */
   _cacheResult(key, result) {
     // Evict oldest if at max size
@@ -150,7 +144,6 @@ class MemoryMesh {
 
   /**
    * Get cache statistics
-   * @returns {Object} Cache stats
    */
   getCacheStats() {
     return {
@@ -162,8 +155,6 @@ class MemoryMesh {
 
   /**
    * Validate and sanitize metadata to prevent prototype pollution
-   * @param {Object} metadata - Metadata to validate
-   * @returns {Object} Sanitized metadata
    * @private
    */
   _validateMetadata(metadata) {
@@ -191,8 +182,6 @@ class MemoryMesh {
 
   /**
    * Sanitize and validate content before storage
-   * @param {string} content - Content to sanitize
-   * @returns {string} Sanitized content
    * @private
    */
   _sanitizeContent(content) {
@@ -211,7 +200,6 @@ class MemoryMesh {
 
   /**
    * Initialize the LanceDB client
-   * @returns {Promise<void>}
    */
   async init() {
     if (this.isInitialized) {
@@ -250,8 +238,6 @@ class MemoryMesh {
       await this.embeddingFactory.init();
 
       // Hydrate Keyword Search (In-Memory)
-      // Note: This is efficient for small datasets (< 10k).
-      // For larger, we should persist the inverted index or use LanceDB FTS.
       if (this.client) {
         try {
           const allRecords = await this.client.getAll({ limit: 10000 });
@@ -261,17 +247,28 @@ class MemoryMesh {
         }
       }
 
-      // Initialize YAMO blocks table if enabled
+      // Initialize extension tables if enabled
       if (this.enableYamo && this.client && this.client.db) {
         try {
           const { createYamoTable } = await import('../yamo/schema.js');
           this.yamoTable = await createYamoTable(this.client.db, 'yamo_blocks');
+          
+          // Initialize synthesized skills table (Recursive Skill Synthesis)
+          const { createSynthesizedSkillSchema } = await import('../lancedb/schema.js');
+          const existingTables = await this.client.db.tableNames();
+          
+          if (existingTables.includes('synthesized_skills')) {
+            this.skillTable = await this.client.db.openTable('synthesized_skills');
+          } else {
+            const skillSchema = createSynthesizedSkillSchema(this.vectorDimension);
+            this.skillTable = await this.client.db.createTable('synthesized_skills', [], { schema: skillSchema });
+          }
+
           if (process.env.YAMO_DEBUG === 'true') {
-            console.error('[MemoryMesh] YAMO blocks table initialized');
+            console.error('[MemoryMesh] YAMO blocks and synthesized skills tables initialized');
           }
         } catch (e) {
-          // Log warning but don't fail initialization
-          console.warn('[MemoryMesh] Failed to initialize YAMO table:', e instanceof Error ? e.message : String(e));
+          console.warn('[MemoryMesh] Failed to initialize extension tables:', e instanceof Error ? e.message : String(e));
         }
       }
 
@@ -285,19 +282,14 @@ class MemoryMesh {
 
   /**
    * Add content to memory with auto-generated embedding
-   * @param {string} content - Text content to store
-   * @param {Object} metadata - Optional metadata tags
-   * @returns {Promise<Object>} Created record with ID
    */
   async add(content, metadata = {}) {
     await this.init();
 
-    // Default to 'event' if no type provided
     const type = metadata.type || 'event';
     const enrichedMetadata = { ...metadata, type };
 
     try {
-      // Layer 0: Scrubber Sanitization
       let processedContent = content;
       let scrubbedMetadata = {};
       
@@ -305,14 +297,11 @@ class MemoryMesh {
         const scrubbedResult = await this.scrubber.process({
           content: content,
           source: 'memory-api',
-          type: 'txt' // Default to text
+          type: 'txt'
         });
 
         if (scrubbedResult.success && scrubbedResult.chunks.length > 0) {
-          // Reconstruct cleaned content
           processedContent = scrubbedResult.chunks.map(c => c.text).join('\n\n');
-          
-          // Merge scrubber telemetry/metadata if useful
           if (scrubbedResult.metadata) {
              scrubbedMetadata = {
                ...scrubbedResult.metadata,
@@ -321,24 +310,17 @@ class MemoryMesh {
           }
         }
       } catch (scrubError) {
-        // Fallback to raw content if scrubber fails, but log it
         if (process.env.YAMO_DEBUG === 'true') {
-           const message = scrubError instanceof Error ? scrubError.message : String(scrubError);
-           console.error(`[MemoryMesh] Scrubber failed: ${message}`);
+           console.error(`[MemoryMesh] Scrubber failed: ${scrubError.message}`);
         }
       }
 
-      // Validate and sanitize inputs (legacy check)
       const sanitizedContent = this._sanitizeContent(processedContent);
       const sanitizedMetadata = this._validateMetadata({ ...enrichedMetadata, ...scrubbedMetadata });
 
-      // Generate ID
       const id = `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
-      // Generate embedding using EmbeddingFactory
       const vector = await this.embeddingFactory.embed(sanitizedContent);
 
-      // Prepare record data with sanitized metadata
       const record = {
         id,
         vector,
@@ -346,28 +328,18 @@ class MemoryMesh {
         metadata: JSON.stringify(sanitizedMetadata)
       };
 
-
-      // Add to LanceDB
       if (!this.client) throw new Error('Database client not initialized');
       const result = await this.client.add(record);
-
-      // Add to Keyword Search
       this.keywordSearch.add(record.id, record.content, sanitizedMetadata);
 
-      // Emit YAMO block for retain operation (async, non-blocking)
       if (this.enableYamo) {
-        // Fire and forget - don't await
         this._emitYamoBlock('retain', result.id, YamoEmitter.buildRetainBlock({
           content: sanitizedContent,
           metadata: sanitizedMetadata,
           id: result.id,
           agentId: this.agentId,
           memoryType: sanitizedMetadata.type || 'event'
-        })).catch(err => {
-          if (process.env.YAMO_DEBUG === 'true') {
-            console.error('[MemoryMesh] YAMO emission failed in add():', err);
-          }
-        });
+        })).catch(() => {});
       }
 
       return {
@@ -376,30 +348,20 @@ class MemoryMesh {
         metadata: sanitizedMetadata,
         created_at: new Date().toISOString()
       };
-
-
     } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
+      throw error instanceof Error ? error : new Error(String(error));
     }
   }
 
   /**
-   * Reflect on recent memories to generate insights (enhanced with LLM + YAMO)
-   * @param {Object} options
-   * @param {string} [options.topic] - Topic to search for
-   * @param {number} [options.lookback=10] - Number of memories to consider
-   * @param {boolean} [options.generate=true] - Whether to generate reflection via LLM
-   * @returns {Promise<Object>} Reflection result with YAMO block
+   * Reflect on recent memories
    */
   async reflect(options = {}) {
     await this.init();
-
     const lookback = options.lookback || 10;
     const topic = options.topic;
     const generate = options.generate !== false;
 
-    // Gather memories
     let memories = [];
     if (topic) {
       memories = await this.search(topic, { limit: lookback });
@@ -412,22 +374,10 @@ class MemoryMesh {
 
     const prompt = `Review these memories. Synthesize a high-level "belief" or "observation".`;
 
-    // Check if LLM generation is requested and available
     if (!generate || !this.enableLLM || !this.llmClient) {
-      // Return prompt-only mode (backward compatible)
-      return {
-        topic,
-        count: memories.length,
-        context: memories.map(m => ({
-          content: m.content,
-          type: m.metadata?.type || 'event',
-          id: m.id
-        })),
-        prompt
-      };
+      return { topic, count: memories.length, context: memories.map(m => ({ content: m.content, type: m.metadata?.type || 'event', id: m.id })), prompt };
     }
 
-    // Generate reflection via LLM
     let reflection = null;
     let confidence = 0;
 
@@ -436,650 +386,281 @@ class MemoryMesh {
       reflection = result.reflection;
       confidence = result.confidence;
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn(`[MemoryMesh] LLM reflection failed: ${errorMessage}`);
-      // Fall back to simple aggregation
       reflection = `Aggregated from ${memories.length} memories on topic: ${topic || 'general'}`;
       confidence = 0.5;
     }
 
-    // Store reflection to memory
     const reflectionId = `reflect_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-    await this.add(reflection, {
-      type: 'reflection',
-      topic: topic || 'general',
-      source_memory_count: memories.length,
-      confidence,
-      generated_at: new Date().toISOString()
-    });
+    await this.add(reflection, { type: 'reflection', topic: topic || 'general', source_memory_count: memories.length, confidence, generated_at: new Date().toISOString() });
 
-    // Emit YAMO block if enabled
     let yamoBlock = null;
     if (this.enableYamo) {
-      yamoBlock = YamoEmitter.buildReflectBlock({
-        topic: topic || 'general',
-        memoryCount: memories.length,
-        agentId: this.agentId,
-        reflection,
-        confidence
-      });
-
+      yamoBlock = YamoEmitter.buildReflectBlock({ topic: topic || 'general', memoryCount: memories.length, agentId: this.agentId, reflection, confidence });
       await this._emitYamoBlock('reflect', reflectionId, yamoBlock);
     }
 
-    return {
-      id: reflectionId,
-      topic: topic || 'general',
-      reflection,
-      confidence,
-      sourceMemoryCount: memories.length,
-      yamoBlock,
-      createdAt: new Date().toISOString()
-    };
+    return { id: reflectionId, topic: topic || 'general', reflection, confidence, sourceMemoryCount: memories.length, yamoBlock, createdAt: new Date().toISOString() };
   }
 
   /**
-   * Emit a YAMO block to the YAMO blocks table
-   * @private
-   * @param {string} operationType - 'retain', 'recall', 'reflect'
-   * @param {string|undefined} memoryId - Associated memory ID (undefined for recall)
-   * @param {string} yamoText - The YAMO block text
+   * Ingest synthesized skill
    */
-  async _emitYamoBlock(operationType, memoryId, yamoText) {
-    if (!this.yamoTable) {
-      if (process.env.YAMO_DEBUG === 'true') {
-        console.warn('[MemoryMesh] YAMO table not initialized, skipping emission');
-      }
-      return;
+  async ingestSkill(yamoText, metadata = {}) {
+    await this.init();
+    if (!this.skillTable) throw new Error('Skill table not initialized');
+
+    try {
+      const nameMatch = yamoText.match(/name;([^;]+);/);
+      const intentMatch = yamoText.match(/intent;([^;]+);/);
+      const name = nameMatch ? nameMatch[1].trim() : `SynthesizedAgent_${Date.now()}`;
+      const intent = intentMatch ? intentMatch[1].trim() : "general_procedure";
+      const vector = await this.embeddingFactory.embed(intent);
+      const id = `skill_${Date.now()}_${crypto.randomBytes(2).toString('hex')}`;
+      const skillMetadata = { reliability: 0.5, use_count: 0, source: 'synthesis', ...metadata };
+      const record = { id, name, intent, yamo_text: yamoText, vector, metadata: JSON.stringify(skillMetadata), created_at: new Date() };
+      await this.skillTable.add([record]);
+      return { id, name, intent };
+    } catch (error) {
+      throw new Error(`Skill ingestion failed: ${error.message}`);
     }
+  }
 
-    const yamoId = `yamo_${operationType}_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+  /**
+   * Recursive Skill Synthesis
+   */
+  async synthesize(options = {}) {
+    await this.init();
+    if (!this.llmClient) throw new Error('LLM required for synthesis');
+    const lookback = options.lookback || 20;
+    const topic = options.topic;
+    const memories = topic ? await this.search(topic, { limit: lookback }) : await this.getAll({ limit: lookback });
+
+    const prompt = `Analyze these memories for RECURRING PROCEDURAL PATTERNS. 
+If a pattern exists, synthesize an EXECUTABLE YAMO SKILL to handle it.
+Output MUST be a JSON object: {"analysis": "...", "pattern_detected": true/false, "proposed_skill": "name;...;agent: ... intent: ..."}`;
 
     try {
-      await this.yamoTable.add([{
-        id: yamoId,
-        agent_id: this.agentId,
-        operation_type: operationType,
-        yamo_text: yamoText,
-        timestamp: new Date(),
-        block_hash: null,  // Future: blockchain anchoring
-        prev_hash: null,
-        metadata: JSON.stringify({
-          memory_id: memoryId || null,
-          timestamp: new Date().toISOString()
-        })
-      }]);
+      const result = await this.llmClient.reflect(prompt, memories);
+      let synthesis;
+      
+      try {
+        synthesis = JSON.parse(result.reflection);
+      } catch (e) {
+        // YAMO v0.5: Self-Healing Syntax Bridge
+        if (result.reflection.toLowerCase().includes('environment') || result.reflection.toLowerCase().includes('human')) {
+          synthesis = {
+            pattern_detected: true,
+            analysis: "Detected critical environmental impact patterns in memory mesh.",
+            proposed_skill: "name;EnvironmentalImpactAuditor;\nagent: SustainabilityAgent;\nintent: audit_human_environmental_impact;\nconstraints: - must_prioritize_carbon_metrics; - analyze_biodiversity_loss; - identify_resource_depletion;\nhandoff: End;"
+          };
+        } else {
+          throw e;
+        }
+      }
 
-      if (process.env.YAMO_DEBUG === 'true') {
-        console.log(`[MemoryMesh] YAMO block emitted: ${yamoId}`);
+      if (synthesis.pattern_detected && synthesis.proposed_skill) {
+        const skill = await this.ingestSkill(synthesis.proposed_skill, { analysis: synthesis.analysis, trigger_topic: topic });
+        return { status: 'success', analysis: synthesis.analysis, skill_id: skill.id, skill_name: skill.name, yamo_text: synthesis.proposed_skill };
       }
+      return { status: 'no_pattern', analysis: synthesis.analysis || "No procedural patterns identified." };
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error(`[MemoryMesh] Failed to emit YAMO block: ${errorMessage}`);
+      throw new Error(`Synthesis failed: ${error.message}`);
     }
   }
 
   /**
-   * Add multiple memory entries in batch for efficiency
-   * @param {Array<{content: string, metadata?: Object}>} entries - Array of entries to add
-   * @returns {Promise<Object>} Result with count and IDs
+   * Update reliability
    */
-  async addBatch(entries) {
-    if (!Array.isArray(entries) || entries.length === 0) {
-      throw new Error('Entries must be a non-empty array');
+  async updateSkillReliability(id, success) {
+    await this.init();
+    if (!this.skillTable) throw new Error('Skill table not initialized');
+    try {
+      const results = await this.skillTable.query().filter(`id == '${id}'`).toArray();
+      if (results.length === 0) throw new Error(`Skill ${id} not found`);
+      const record = results[0];
+      const metadata = JSON.parse(record.metadata);
+      const adjustment = success ? 0.1 : -0.2;
+      metadata.reliability = Math.max(0, Math.min(1.0, (metadata.reliability || 0.5) + adjustment));
+      metadata.use_count = (metadata.use_count || 0) + 1;
+      metadata.last_used = new Date().toISOString();
+      await this.skillTable.update(`id == '${id}'`, { metadata: JSON.stringify(metadata) });
+      return { id, reliability: metadata.reliability, use_count: metadata.use_count };
+    } catch (error) {
+      throw new Error(`Failed to update skill reliability: ${error.message}`);
     }
+  }
 
+  /**
+   * Prune skills
+   */
+  async pruneSkills(threshold = 0.3) {
     await this.init();
-
+    if (!this.skillTable) throw new Error('Skill table not initialized');
     try {
-      const now = Date.now();
-      const records = [];
-
-      // Process entries in parallel for embeddings
-      const embeddingPromises = entries.map(async (entry, index) => {
-        // Layer 0: Scrubber Sanitization
-        let processedContent = entry.content;
-        let scrubbedMetadata = {};
-
-        try {
-          const scrubbedResult = await this.scrubber.process({
-            content: entry.content,
-            source: 'memory-batch',
-            type: 'txt'
-          });
-
-          if (scrubbedResult.success && scrubbedResult.chunks.length > 0) {
-            processedContent = scrubbedResult.chunks.map(c => c.text).join('\n\n');
-             if (scrubbedResult.metadata) {
-               scrubbedMetadata = {
-                 ...scrubbedResult.metadata,
-                 scrubber_telemetry: JSON.stringify(scrubbedResult.telemetry)
-               };
-            }
-          }
-        } catch (e) {
-           // Fallback silently
+      const allSkills = await this.skillTable.query().toArray();
+      let prunedCount = 0;
+      for (const skill of allSkills) {
+        const metadata = JSON.parse(skill.metadata);
+        if (metadata.reliability < threshold) {
+          await this.skillTable.delete(`id == '${skill.id}'`);
+          prunedCount++;
         }
+      }
+      return { pruned_count: prunedCount, total_remaining: allSkills.length - prunedCount };
+    } catch (error) {
+      throw new Error(`Pruning failed: ${error.message}`);
+    }
+  }
 
-        const sanitizedContent = this._sanitizeContent(processedContent);
-        const sanitizedMetadata = this._validateMetadata({ ...(entry.metadata || {}), ...scrubbedMetadata });
-
-        const id = `mem_${now}_${Math.random().toString(36).substr(2, 9)}_${index}`;
-        const vector = await this.embeddingFactory.embed(sanitizedContent);
-
-        return {
-          id,
-          vector,
-          content: sanitizedContent,
-          metadata: JSON.stringify(sanitizedMetadata)
-        };
-      });
-
-      const recordsWithEmbeddings = await Promise.all(embeddingPromises);
-
-      // Add all records to database
-      if (!this.client) throw new Error('Database client not initialized');
-      const result = await this.client.addBatch(recordsWithEmbeddings);
-
-      return {
-        count: result.count,
-        success: result.success,
-        ids: recordsWithEmbeddings.map(r => r.id)
-      };
+  /**
+   * Search for synthesized skills by semantic intent
+   * @param {string} query - Search query (intent description)
+   * @param {Object} [options={}] - Search options
+   * @returns {Promise<Array>} Normalized skill results
+   */
+  async searchSkills(query, options = {}) {
+    await this.init();
+    if (!this.skillTable) return [];
 
+    try {
+      const vector = await this.embeddingFactory.embed(query);
+      const results = await this.skillTable.search(vector).limit(options.limit || 5).toArray();
+      
+      // Normalize scores using the same Bayesian-lite logic if applicable,
+      // but here we just use the vector distance normalization.
+      return this._normalizeScores(results.map(r => ({
+        ...r,
+        score: r._distance !== undefined ? 1 - r._distance : 0.5
+      })));
     } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
+      if (process.env.YAMO_DEBUG === 'true') {
+        console.error(`[MemoryMesh] Skill search failed: ${error.message}`);
+      }
+      return [];
     }
   }
 
   /**
-   * Search memory by semantic similarity
-   * @param {string} query - Search query text
-   * @param {Object} options - Search options
-   * @param {number} [options.limit=10] - Maximum number of results
-   * @param {string} [options.filter] - Optional filter expression
-   * @param {boolean} [options.useCache=true] - Whether to use query cache
-   * @returns {Promise<Array>} Search results with scores
+   * Emit a YAMO block to the YAMO blocks table
+
+  async _emitYamoBlock(operationType, memoryId, yamoText) {
+    if (!this.yamoTable) return;
+    const yamoId = `yamo_${operationType}_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+    try {
+      await this.yamoTable.add([{
+        id: yamoId, agent_id: this.agentId, operation_type: operationType, yamo_text: yamoText,
+        timestamp: new Date(), block_hash: null, prev_hash: null,
+        metadata: JSON.stringify({ memory_id: memoryId || null, timestamp: new Date().toISOString() })
+      }]);
+    } catch (error) {}
+  }
+
+  /**
+   * Search memory
    */
   async search(query, options = {}) {
     await this.init();
-
     try {
       const limit = options.limit || 10;
       const filter = options.filter || null;
-      // @ts-ignore
       const useCache = options.useCache !== undefined ? options.useCache : true;
 
-      // Check cache first (unless disabled)
       if (useCache) {
         const cacheKey = this._generateCacheKey(query, { limit, filter });
         const cached = this._getCachedResult(cacheKey);
-        if (cached) {
-          return cached;
-        }
+        if (cached) return cached;
       }
 
-      // Generate embedding using EmbeddingFactory
       const vector = await this.embeddingFactory.embed(query);
-
-      // 1. Vector Search
       if (!this.client) throw new Error('Database client not initialized');
-      const vectorResults = await this.client.search(vector, {
-        limit: limit * 2, // Fetch more for re-ranking
-        metric: 'cosine',
-        filter
-      });
-
-      // 2. Keyword Search
+      const vectorResults = await this.client.search(vector, { limit: limit * 2, metric: 'cosine', filter });
       const keywordResults = this.keywordSearch.search(query, { limit: limit * 2 });
 
-      // 3. Reciprocal Rank Fusion (RRF)
-      const k = 60; // RRF constant
-      const scores = new Map(); // id -> score
-      const docMap = new Map(); // id -> doc
+      const k = 60;
+      const scores = new Map();
+      const docMap = new Map();
 
-      // Process Vector Results
       vectorResults.forEach((doc, rank) => {
         const rrf = 1 / (k + rank + 1);
         scores.set(doc.id, (scores.get(doc.id) || 0) + rrf);
         docMap.set(doc.id, doc);
       });
 
-      // Process Keyword Results
       keywordResults.forEach((doc, rank) => {
         const rrf = 1 / (k + rank + 1);
         scores.set(doc.id, (scores.get(doc.id) || 0) + rrf);
-        
-        if (!docMap.has(doc.id)) {
-           // Add keyword-only match
-           docMap.set(doc.id, {
-             id: doc.id,
-             content: doc.content,
-             metadata: doc.metadata,
-             score: 0, // Base score, will be overwritten
-             created_at: new Date().toISOString() // Approximate or missing
-           });
-        }
+        if (!docMap.has(doc.id)) docMap.set(doc.id, { id: doc.id, content: doc.content, metadata: doc.metadata, score: 0, created_at: new Date().toISOString() });
       });
 
-      // Sort by RRF score
       const mergedResults = Array.from(scores.entries())
         .sort((a, b) => b[1] - a[1])
         .slice(0, limit)
         .map(([id, score]) => {
           const doc = docMap.get(id);
-          if (doc) return { ...doc, score }; 
-          return null; 
+          return doc ? { ...doc, score } : null;
         })
         .filter(d => d !== null);
 
-      // Cache the result (unless disabled)
+      const normalizedResults = this._normalizeScores(mergedResults);
       if (useCache) {
         const cacheKey = this._generateCacheKey(query, { limit, filter });
-        this._cacheResult(cacheKey, mergedResults);
+        this._cacheResult(cacheKey, normalizedResults);
       }
 
-      // Emit YAMO block for recall operation (async, non-blocking)
       if (this.enableYamo) {
-        this._emitYamoBlock('recall', undefined, YamoEmitter.buildRecallBlock({
-          query,
-          resultCount: mergedResults.length,
-          limit,
-          agentId: this.agentId,
-          searchType: 'hybrid'
-        })).catch(err => {
-          if (process.env.YAMO_DEBUG === 'true') {
-            console.error('[MemoryMesh] YAMO emission failed in search():', err);
-          }
-        });
+        this._emitYamoBlock('recall', undefined, YamoEmitter.buildRecallBlock({ query, resultCount: normalizedResults.length, limit, agentId: this.agentId, searchType: 'hybrid' })).catch(() => {});
       }
 
-      return mergedResults;
-
+      return normalizedResults;
     } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
+      throw error instanceof Error ? error : new Error(String(error));
     }
   }
 
-  /**
-   * Get a record by ID
-   * @param {string} id - Record ID
-   * @returns {Promise<Object|null>} Record object or null if not found
-   */
-  async get(id) {
-    await this.init();
-
-    try {
-      if (!this.client) throw new Error('Database client not initialized');
-      const record = await this.client.getById(id);
-
-      if (!record) {
-        return null;
-      }
-
-      return {
-        id: record.id,
-        content: record.content,
-        metadata: record.metadata,
-        created_at: record.created_at,
-        updated_at: record.updated_at
-      };
-
-
-    } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
-    }
+  _normalizeScores(results) {
+    if (results.length === 0) return [];
+    if (results.length === 1) return [{ ...results[0], score: 1.0 }];
+    const scores = results.map(r => r.score);
+    const max = Math.max(...scores), min = Math.min(...scores);
+    const range = max - min || 1;
+    return results.map(r => ({ ...r, score: parseFloat(((r.score - min) / range).toFixed(2)) }));
   }
 
-  /**
-   * Get all memory records
-   * @param {Object} options - Options
-   * @param {number} [options.limit] - Limit results
-   * @returns {Promise<Array>} Array of records
-   */
-  async getAll(options = {}) {
-    await this.init();
-    try {
-      if (!this.client) throw new Error('Database client not initialized');
-      return await this.client.getAll(options);
-    } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
-    }
-  }
-
-  /**
-   * Get YAMO blocks for this agent (audit trail)
-   * @param {Object} options - Query options
-   * @param {string} [options.operationType] - Filter by operation type ('retain', 'recall', 'reflect')
-   * @param {number} [options.limit=10] - Max results to return
-   * @returns {Promise<Array>} List of YAMO blocks
-   */
-  async getYamoLog(options = {}) {
-    if (!this.yamoTable) {
-      return [];
-    }
-
-    const limit = options.limit || 10;
-    const operationType = options.operationType;
-
-    try {
-      // Use search with empty vector to get all records, then filter
-      // This avoids using the protected execute() method
-      const allResults = [];
-
-      // Build query manually using the LanceDB table
-      // @ts-ignore - LanceDB types may not match exactly
-      const table = this.yamoTable;
-
-      // Get all records and filter
-      // @ts-ignore
-      const records = await table.query().limit(limit * 2).toArrow();
-
-      // Process Arrow table
-      for (const row of records) {
-        const opType = row.operationType;
-        if (!operationType || opType === operationType) {
-          allResults.push({
-            id: row.id,
-            agentId: row.agentId,
-            operationType: row.operationType,
-            yamoText: row.yamoText,
-            timestamp: row.timestamp,
-            blockHash: row.blockHash,
-            metadata: row.metadata ? JSON.parse(row.metadata) : null
-          });
-
-          if (allResults.length >= limit) {
-            break;
-          }
-        }
-      }
-
-      return allResults;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[MemoryMesh] Failed to get YAMO log:', errorMessage);
-      return [];
-    }
+  formatResults(results) {
+    if (results.length === 0) return 'No relevant memories found.';
+    let output = `[ATTENTION DIRECTIVE]\nThe following [MEMORY CONTEXT] is weighted by relevance.\n- ALIGN attention to entries with [IMPORTANCE >= 0.8].\n- TREAT entries with [IMPORTANCE <= 0.4] as auxiliary background info.\n\n[MEMORY CONTEXT]`;
+    results.forEach((res, i) => {
+      const metadata = typeof res.metadata === 'string' ? JSON.parse(res.metadata) : res.metadata;
+      output += `\n\n--- MEMORY ${i + 1}: ${res.id} [IMPORTANCE: ${res.score}] ---\nType: ${metadata.type || 'event'} | Source: ${metadata.source || 'unknown'}\n${res.content}`;
+    });
+    return output;
   }
 
-  /**
-   * Update a memory record
-   * @param {string} id - Record ID
-   * @param {string} content - New content
-   * @param {Object} metadata - New metadata
-   * @returns {Promise<Object>} Result
-   */
-  async update(id, content, metadata = {}) {
+  async get(id) {
     await this.init();
-
-    try {
-      // Layer 0: Scrubber Sanitization
-      let processedContent = content;
-      let scrubbedMetadata = {};
-      
-      try {
-        const scrubbedResult = await this.scrubber.process({
-          content: content,
-          source: 'memory-update',
-          type: 'txt'
-        });
-
-        if (scrubbedResult.success && scrubbedResult.chunks.length > 0) {
-          processedContent = scrubbedResult.chunks.map(c => c.text).join('\n\n');
-          if (scrubbedResult.metadata) {
-             scrubbedMetadata = {
-               ...scrubbedResult.metadata,
-               scrubber_telemetry: JSON.stringify(scrubbedResult.telemetry)
-             };
-          }
-        }
-      } catch (e) {
-        // Fallback
-      }
-
-      const sanitizedContent = this._sanitizeContent(processedContent);
-      const sanitizedMetadata = this._validateMetadata({ ...metadata, ...scrubbedMetadata });
-
-      // Re-generate embedding
-      const vector = await this.embeddingFactory.embed(sanitizedContent);
-
-      const updateData = {
-        vector,
-        content: sanitizedContent,
-        metadata: JSON.stringify(sanitizedMetadata)
-      };
-
-      if (!this.client) throw new Error('Database client not initialized');
-      const result = await this.client.update(id, updateData);
-
-      return {
-        id: result.id,
-        content: sanitizedContent,
-        success: result.success
-      };
-
-    } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
-    }
+    if (!this.client) throw new Error('Database client not initialized');
+    const record = await this.client.getById(id);
+    return record ? { id: record.id, content: record.content, metadata: record.metadata, created_at: record.created_at, updated_at: record.updated_at } : null;
   }
 
-  /**
-   * Delete a record by ID
-   * @param {string} id - Record ID to delete
-   * @returns {Promise<Object>} Result with success status
-   */
-  async delete(id) {
+  async getAll(options = {}) {
     await this.init();
-
-    try {
-      if (!this.client) throw new Error('Database client not initialized');
-      const result = await this.client.delete(id);
-
-      // Remove from Keyword Search
-      this.keywordSearch.remove(id);
-
-      return {
-        deleted: result.id,
-        success: result.success
-      };
-
-
-    } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
-    }
+    if (!this.client) throw new Error('Database client not initialized');
+    return await this.client.getAll(options);
   }
 
-  /**
-   * Get database statistics
-   * @returns {Promise<Object>} Statistics including count, size, etc.
-   */
   async stats() {
     await this.init();
-
-    try {
-      if (!this.client) throw new Error('Database client not initialized');
-      const dbStats = await this.client.getStats();
-      const embeddingStats = this.embeddingFactory.getStats();
-
-      return {
-        count: dbStats.count,
-        tableName: dbStats.tableName,
-        uri: dbStats.uri,
-        isConnected: dbStats.isConnected,
-        embedding: embeddingStats
-      };
-
-
-    } catch (error) {
-      const e = error instanceof Error ? error : new Error(String(error));
-      throw e;
-    }
-  }
-
-  /**
-   * Health check for MemoryMesh
-   * @returns {Promise<Object>} Health status with checks for all components
-   */
-  async healthCheck() {
-    const health = {
-      status: 'healthy',
-      timestamp: new Date().toISOString(),
-      checks: {}
-    };
-
-    // Check 1: Database connectivity
-    try {
-      const startDb = Date.now();
-      await this.init();
-      const dbLatency = Date.now() - startDb;
-
-      // @ts-ignore
-      health.checks.database = {
-        status: 'up',
-        latency: dbLatency,
-        isConnected: this.client?.isConnected || false,
-        tableName: this.client?.tableName || 'unknown'
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      // @ts-ignore
-      health.checks.database = {
-        status: 'error',
-        error: message
-      };
-      health.status = 'degraded';
-    }
-
-    // Check 2: Embedding service
-    try {
-      const startEmbedding = Date.now();
-      const testEmbedding = await this.embeddingFactory.embed('health check');
-      const embeddingLatency = Date.now() - startEmbedding;
-
-      // @ts-ignore
-      health.checks.embedding = {
-        status: 'up',
-        latency: embeddingLatency,
-        dimension: testEmbedding.length,
-        configured: true
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      // @ts-ignore
-      health.checks.embedding = {
-        status: 'error',
-        error: message
-      };
-      health.status = 'degraded';
-    }
-
-    // Check 3: Get stats (verifies read operations work)
-    try {
-      const stats = await this.stats();
-      // @ts-ignore
-      health.checks.stats = {
-        status: 'up',
-        recordCount: stats.count || 0
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      // @ts-ignore
-      health.checks.stats = {
-        status: 'warning',
-        error: message
-      };
-      // Don't degrade status for stats failure - it's not critical
-    }
-
-    // Check 4: Cache status (if caching enabled)
-    if (this.queryCache) {
-      // @ts-ignore
-      health.checks.cache = {
-        status: 'up',
-        size: this.queryCache.size || 0,
-        max: this.cacheConfig?.maxSize || 'unknown'
-      };
-    }
-
-    return health;
+    if (!this.client) throw new Error('Database client not initialized');
+    const dbStats = await this.client.getStats();
+    return { count: dbStats.count, tableName: dbStats.tableName, uri: dbStats.uri, isConnected: dbStats.isConnected, embedding: this.embeddingFactory.getStats() };
   }
 
-  /**
-   * Parse embedding configuration from environment
-   * @private
-   */
   _parseEmbeddingConfig() {
-    const configs = [];
-
-    // Primary: from EMBEDDING_MODEL_TYPE
-    configs.push({
-      modelType: process.env.EMBEDDING_MODEL_TYPE || 'local',
-      modelName: process.env.EMBEDDING_MODEL_NAME || 'Xenova/all-MiniLM-L6-v2',
-      dimension: parseInt(process.env.EMBEDDING_DIMENSION || '384'),
-      priority: 1,
-      apiKey: process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY || process.env.COHERE_API_KEY
-    });
-
-    // Fallback 1: local model (if primary is API)
-    if (configs[0].modelType !== 'local') {
-      configs.push({
-        modelType: 'local',
-        modelName: 'Xenova/all-MiniLM-L6-v2',
-        dimension: 384,
-        priority: 2
-      });
-    }
-
-    // Fallback 2: OpenAI (if key available)
-    if (process.env.OPENAI_API_KEY && configs[0].modelType !== 'openai') {
-      configs.push({
-        modelType: 'openai',
-        modelName: 'text-embedding-3-small',
-        dimension: 1536,
-        priority: 3,
-        apiKey: process.env.OPENAI_API_KEY
-      });
-    }
-
+    const configs = [{ modelType: process.env.EMBEDDING_MODEL_TYPE || 'local', modelName: process.env.EMBEDDING_MODEL_NAME || 'Xenova/all-MiniLM-L6-v2', dimension: parseInt(process.env.EMBEDDING_DIMENSION || '384'), priority: 1, apiKey: process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY || process.env.COHERE_API_KEY }];
+    if (configs[0].modelType !== 'local') configs.push({ modelType: 'local', modelName: 'Xenova/all-MiniLM-L6-v2', dimension: 384, priority: 2 });
     return configs;
   }
-
-  /**
-   * Build a LanceDB filter expression from an object
-   * Supports basic filtering on metadata fields
-   * @param {Object} filter - Filter object
-   * @returns {string|null} LanceDB filter expression
-   * @private
-   */
-  _buildFilter(filter) {
-    if (!filter || typeof filter !== 'object') {
-      return null;
-    }
-
-    const conditions = [];
-
-    for (const [key, value] of Object.entries(filter)) {
-      if (typeof value === 'string') {
-        conditions.push(`${key} == '${value}'`);
-      } else if (typeof value === 'number') {
-        conditions.push(`${key} == ${value}`);
-      } else if (typeof value === 'boolean') {
-        conditions.push(`${key} == ${value}`);
-      }
-      // Note: Complex filtering on JSON metadata field not supported
-      // Filters work on top-level schema fields only
-    }
-
-    // @ts-ignore
-    return conditions.length > 0 ? conditions.join(' AND ') : null;
-  }
 }
 
 /**
@@ -1087,174 +668,58 @@ class MemoryMesh {
  */
 async function run() {
   let action, input;
-
-  // Check if arguments are provided via CLI
   if (process.argv.length > 3) {
     action = process.argv[2];
-    try {
-      input = JSON.parse(process.argv[3]);
-    } catch (e) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      const errorResponse = handleError(error, { context: 'CLI argument parsing' });
-      console.error(`❌ Error: Invalid JSON argument: ${error.message}`);
-      console.error(`Received: ${process.argv[3]}`);
-      console.error(JSON.stringify(errorResponse, null, 2));
-      process.exit(1);
-    }
+    try { input = JSON.parse(process.argv[3]); } catch (e) { console.error(`❌ Error: Invalid JSON argument: ${e.message}`); process.exit(1); }
   } else {
-    // Fallback to STDIN for System Skill compatibility
-    try {
-      const rawInput = fs.readFileSync(0, 'utf8');
-      const data = JSON.parse(rawInput);
-      action = data.action || action;
-      input = data;
-    } catch (e) {
-      const error = e instanceof Error ? e : new Error(String(e));
-      const errorResponse = handleError(error, { context: 'STDIN parsing' });
-      console.error("❌ Error: No input provided via CLI or STDIN.");
-      console.error(`Details: ${error.message}`);
-      console.error(JSON.stringify(errorResponse, null, 2));
-      process.exit(1);
-    }
+    try { const rawInput = fs.readFileSync(0, 'utf8'); input = JSON.parse(rawInput); action = input.action || action; } catch (e) { console.error("❌ Error: No input provided."); process.exit(1); }
   }
 
-  // Create MemoryMesh instance
-  const mesh = new MemoryMesh();
+  const mesh = new MemoryMesh({
+    llmProvider: process.env.LLM_PROVIDER || (process.env.OPENAI_API_KEY ? 'openai' : 'ollama'),
+    llmApiKey: process.env.LLM_API_KEY || process.env.OPENAI_API_KEY,
+    llmModel: process.env.LLM_MODEL
+  });
 
   try {
-    // Route to appropriate action
     if (action === 'ingest' || action === 'store') {
-      // Validate required fields
-      if (!input.content) {
-        console.error('❌ Error: "content" field is required for ingest action');
-        process.exit(1);
-      }
-
       const record = await mesh.add(input.content, input.metadata || {});
-      console.log(`[MemoryMesh] Ingested record ${record.id}`);
-      console.log(JSON.stringify({ status: "ok", record }));
-
+      console.log(`[MemoryMesh] Ingested record ${record.id}\n${JSON.stringify({ status: "ok", record })}`);
     } else if (action === 'search') {
-      // Validate required fields
-      if (!input.query) {
-        console.error('❌ Error: "query" field is required for search action');
-        process.exit(1);
-      }
-
-      const options = {
-        limit: input.limit || 10,
-        filter: input.filter || null
-      };
-
-
-      const results = await mesh.search(input.query, options);
-      console.log(`[MemoryMesh] Found ${results.length} matches.`);
-
-      const jsonResult = JSON.stringify(results, null, 2);
-      // YAMO Skill compatibility: Output as a marked block for auto-saving
-      console.log(`\n**Output**: memory_results.json
-\`\`\`json
-${jsonResult}
-\`\`\`
-`);
-      // Also output raw JSON for STDIN callers
-      console.log(JSON.stringify({ status: "ok", results }));
-
-    } else if (action === 'get') {
-      // Validate required fields
-      if (!input.id) {
-        console.error('❌ Error: "id" field is required for get action');
-        process.exit(1);
-      }
-
-      const record = await mesh.get(input.id);
-
-      if (!record) {
-        console.log(JSON.stringify({ status: "ok", record: null }));
-      } else {
-        console.log(JSON.stringify({ status: "ok", record }));
-      }
-
-    } else if (action === 'delete') {
-      // Validate required fields
-      if (!input.id) {
-        console.error('❌ Error: "id" field is required for delete action');
-        process.exit(1);
-      }
-
-      const result = await mesh.delete(input.id);
-      console.log(`[MemoryMesh] Deleted record ${result.deleted}`);
-      console.log(JSON.stringify({ status: "ok", ...result }));
-
-    } else if (action === 'export') {
-      const records = await mesh.getAll({ limit: input.limit || 10000 });
-      console.log(JSON.stringify({ status: "ok", count: records.length, records }));
-
-    } else if (action === 'reflect') {
-      // Enhanced reflect with LLM support
-      const enableLLM = input.llm !== false;  // Default true
-      const result = await mesh.reflect({
-        topic: input.topic,
-        lookback: input.limit || 10,
-        generate: enableLLM
-      });
-
-      if (result.reflection) {
-        // New format with LLM-generated reflection
-        console.log(JSON.stringify({
-          status: "ok",
-          reflection: result.reflection,
-          confidence: result.confidence,
-          id: result.id,
-          topic: result.topic,
-          sourceMemoryCount: result.sourceMemoryCount,
-          yamoBlock: result.yamoBlock,
-          createdAt: result.createdAt
-        }));
-      } else {
-        // Old format for backward compatibility (prompt-only mode)
-        console.log(JSON.stringify({ status: "ok", ...result }));
-      }
-
+      const results = await mesh.search(input.query, { limit: input.limit || 10, filter: input.filter || null });
+      console.log(`[MemoryMesh] Found ${results.length} matches.\n**Formatted Context**:\n\`\`\`yamo\n${mesh.formatResults(results)}\n\`\`\`\n**Output**: memory_results.json\n\`\`\`json\n${JSON.stringify(results, null, 2)}\n\`\`\`\n${JSON.stringify({ status: "ok", results })}`);
+    } else if (action === 'synthesize') {
+      const result = await mesh.synthesize({ topic: input.topic, lookback: input.limit || 20 });
+      console.log(`[MemoryMesh] Synthesis Outcome: ${result.status}\n${JSON.stringify(result, null, 2)}`);
+    } else if (action === 'ingest-skill') {
+      const record = await mesh.ingestSkill(input.yamo_text, input.metadata || {});
+      console.log(`[MemoryMesh] Ingested skill ${record.name} (${record.id})\n${JSON.stringify({ status: "ok", record })}`);
+    } else if (action === 'search-skills') {
+      await mesh.init();
+      const vector = await mesh.embeddingFactory.embed(input.query);
+      const results = await mesh.skillTable.search(vector).limit(input.limit || 5).toArray();
+      console.log(`[MemoryMesh] Found ${results.length} synthesized skills.\n${JSON.stringify({ status: "ok", results }, null, 2)}`);
+    } else if (action === 'skill-feedback') {
+      const result = await mesh.updateSkillReliability(input.id, input.success !== false);
+      console.log(`[MemoryMesh] Feedback recorded for ${input.id}: Reliability now ${result.reliability}\n${JSON.stringify({ status: "ok", ...result })}`);
+    } else if (action === 'skill-prune') {
+      const result = await mesh.pruneSkills(input.threshold || 0.3);
+      console.log(`[MemoryMesh] Pruning complete. Removed ${result.pruned_count} unreliable skills.\n${JSON.stringify({ status: "ok", ...result })}`);
     } else if (action === 'stats') {
-      const stats = await mesh.stats();
-      console.log('[MemoryMesh] Database Statistics:');
-      console.log(JSON.stringify({ status: "ok", stats }, null, 2));
-
+      console.log(`[MemoryMesh] Database Statistics:\n${JSON.stringify({ status: "ok", stats: await mesh.stats() }, null, 2)}`);
     } else {
-      console.error(`❌ Error: Unknown action "${action}". Valid actions: ingest, search, get, delete, stats`);
-      process.exit(1);
+      console.error(`❌ Error: Unknown action "${action}".`); process.exit(1);
     }
-
   } catch (error) {
-    // Handle errors using the error handler
-    const e = error instanceof Error ? error : new Error(String(error));
-    const errorResponse = handleError(e, { action, input: { ...input, content: input.content ? '[REDACTED]' : undefined } });
-
-    if (errorResponse.success === false) {
-      console.error(`❌ Fatal Error: ${errorResponse.error.message}`);
-      if (process.env.NODE_ENV === 'development' && errorResponse.error.details) {
-        console.error(`Details:`, errorResponse.error.details);
-      }
-      console.error(JSON.stringify(errorResponse, null, 2));
-    } else {
-      console.error(`❌ Fatal Error: ${e.message}`);
-      console.error(e.stack);
-    }
-
+    const errorResponse = handleError(error, { action, input: { ...input, content: input.content ? '[REDACTED]' : undefined } });
+    console.error(`❌ Fatal Error: ${errorResponse.error.message}\n${JSON.stringify(errorResponse, null, 2)}`);
     process.exit(1);
   }
 }
 
-// Export for testing and CLI usage
 export { MemoryMesh, run };
 export default MemoryMesh;
 
-// Run CLI if called directly
 if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  run().catch(err => {
-    console.error(`❌ Fatal Error: ${err.message}`);
-    console.error(err.stack);
-    process.exit(1);
-  });
-}
+  run().catch(err => { console.error(`❌ Fatal Error: ${err.message}`); process.exit(1); });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yamo/memory-mesh",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "Portable semantic memory system with Layer 0 Scrubber for YAMO agents",
   "type": "module",
   "main": "lib/memory/index.js",