mindforge-cc 5.1.0 → 5.2.0

package/bin/memory/federated-sync.js

@@ -9,6 +9,8 @@ const path  = require('node:path');
 const Store = require('./knowledge-store');
 const EISClient = require('./eis-client');
 const crypto = require('node:crypto');
+const EmbeddingEngine = require('./embedding-engine');
+const adsEngine = require('../review/ads-engine');
 
 class FederatedSync {
   constructor(config = {}) {
@@ -92,16 +94,94 @@ class FederatedSync {
     for (const remote of remoteEntries) {
       const local = existingById.get(remote.id);
       
-      // Conflict Resolution: Remote Wins if timestamp is newer
-      if (!local || new Date(remote.timestamp) > new Date(local.timestamp)) {
+      if (!local) {
         fs.appendFileSync(globalPath, JSON.stringify(remote) + '\n');
         mergedCount++;
+        continue;
       }
+
+      // Pillar I (v5.2.0): Hybrid Semantic synthesis
+      let similarity = 0;
+      try {
+        similarity = EmbeddingEngine.cosineSimilarity(
+          EmbeddingEngine.computeTfIdfVector(EmbeddingEngine.tokenize(local.content), {}, 1),
+          EmbeddingEngine.computeTfIdfVector(EmbeddingEngine.tokenize(remote.content), {}, 1)
+        );
+      } catch (err) {
+        console.error(`[FIM-ERR] Semantic analysis failed for ${local.id}. Falling back to LWW.`, err);
+        // Fallback to basic LWW (Last-Write-Wins)
+        if (new Date(remote.timestamp) > new Date(local.timestamp)) {
+          this.writeToGlobalKB(remote, globalPath);
+        }
+        continue;
+      }
+
+      this.triggerHybridSynthesis(local, remote, similarity, globalPath);
+      mergedCount++;
     }
     
     return mergedCount;
   }
 
+  /**
+   * Hybrid Synthesis Logic (Pillar I v5.2.0)
+   */
+  async triggerHybridSynthesis(local, remote, similarity, globalPath) {
+    console.log(`[FIM-SYNC] Analyzing semantic overlap for ${local.id} (Similarity: ${similarity.toFixed(4)})`);
+
+    // 1. LWW (Similarity > 0.9) - Near identical
+    if (similarity > 0.9) {
+      if (new Date(remote.timestamp) > new Date(local.timestamp)) {
+        this.writeToGlobalKB(remote, globalPath);
+        console.log(`  └─ [LWW] Auto-resolved via timestamp.`);
+      }
+      return;
+    }
+
+    // 2. Autonomous Merge (0.75 - 0.9) - Semantic Overlap
+    if (similarity > 0.75) {
+      console.log(`  └─ [ADS] Triggering Autonomous Knowledge Synthesis...`);
+      const merged = await this.triggerADSMerging(local, remote);
+      this.writeToGlobalKB(merged, globalPath);
+      return;
+    }
+
+    // 3. Human Stewardship (0.6 - 0.75) - Probable Disagreement
+    if (similarity > 0.6) {
+      console.log(`  └─ [DHH] High disagreement. Triggering Nexus Handover...`);
+      this.localStore.markConflict(local.id, remote);
+      return;
+    }
+
+    // 4. Collision Isolation (< 0.6) - Topic Mismatch
+    console.log(`  └─ [ISO] Semantic collision (Topic mismatch). Isolating entries.`);
+    this.writeToGlobalKB({ ...remote, id: `${remote.id}_collision_${Date.now()}` }, globalPath);
+  }
+
+  async triggerADSMerging(local, remote) {
+    const result = await adsEngine.runADSSynthesis({
+      phaseNum: 'SYNC',
+      goal: `Synthesize a unified knowledge entry for topic: ${local.topic || local.id}`,
+      context: `Local Entry: ${local.content}\n\nRemote Entry: ${remote.content}`,
+      sessionId: 'fim-sync-v5.2.0'
+    });
+
+    // Extract the final plan/content from ADS result
+    const mergedContent = fs.readFileSync(path.join(process.cwd(), '.planning', 'PLAN.md'), 'utf8');
+    
+    return {
+      ...remote,
+      content: mergedContent,
+      confidence: 1.0,
+      synthesis_id: result.ads_id,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  writeToGlobalKB(entry, globalPath) {
+    fs.appendFileSync(globalPath, JSON.stringify(entry) + '\n');
+  }
+
   isRecentlySynced(id) {
     // Simple check against local sync-history log
     if (!fs.existsSync(this.syncHistoryPath)) return false;

package/docs/INTELLIGENCE-MESH.md

@@ -15,7 +15,11 @@ The V5 mesh is built on three core pillars residing in `bin/memory/`:
 ### B. Federated Sync (`federated-sync.js`)
 - **Role**: High-performance synchronization engine between local stores and the organizational mesh.
 - **Delta Sync**: Tracks the `last_sync` timestamp to only pull new organizational insights, significantly reducing latency and compute costs.
-- **Conflict Resolution**: Uses **LWW (Last-Write-Wins)** logic with cryptographic version checks to handle concurrent updates from different agents.
+- **Conflict Resolution**: Uses **Hybrid Semantic Synthesis** (Pillar I v5.2.0). 
+  - **Similarity > 0.9**: Near-identical; auto-resolve via **Last-Write-Wins (LWW)**.
+  - **0.75 - 0.9**: Semantic Overlap; triggers **Autonomous ADS Merging**.
+  - **0.6 - 0.75**: Conflict; triggers **Nexus Handover (DHH)** for human steering.
+  - **< 0.6**: Topic Collision; isolates entries into unique IDs to prevent data loss.
 
 ### C. Knowledge Graph Bridge (`knowledge-graph.js`)
 - **Role**: Unified memory interface that resolves both local project nodes and remote federated nodes.
@@ -32,4 +36,4 @@ The V5 mesh is built on three core pillars residing in `bin/memory/`:
 - **Elimination of Redundancy**: Multi-thousand-token research chains are executed once and shared universally across the mesh.
 
 ---
-*Status: V5 "Beast" Mode Implemented & Verified (2026-03-28)*
+*Status: V5.2.0 Semantic Consensus Implemented & Verified (2026-03-28)*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindforge-cc",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "MindForge - Enterprise Agentic Framework for Claude Code and Antigravity",
   "bin": {
     "mindforge-cc": "bin/install.js"