mindforge-cc 6.3.0 → 6.4.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [6.4.0] - 2026-04-08
+
+### Added (v6.4.0: Context Entropy Guard - CEG)
+
+- **Context Entropy Guard (CEG)**:
+  - Implemented `context-entropy-guard.js` for active noise suppression and context pruning.
+  - Added semantic compression to `HandoverManager`, automatically summarizing stagnant reasoning loops into digests.
+  - Hardened Nexus Bundles against "Reasoning Entropy" (similarity-based token bloat).
+
+---
+
 ## [6.3.0] - 2026-04-08
 
 ### Added (v6.3.0: Intelligence-Drift Coupling - IDC)

package/bin/engine/context-entropy-guard.js

@@ -0,0 +1,94 @@
+/**
+ * MindForge v6.4.0 — Context Entropy Guard (CEG)
+ * Component: Context Entropy Guard (Pillar XI)
+ * 
+ * Actively manages context density by suppressing reasoning noise 
+ * and compressing repetitive semantic loops before handoff.
+ */
+'use strict';
+
+class ContextEntropyGuard {
+  constructor() {
+    this.SIMILARITY_SUPPRESSION_THRESHOLD = 0.85; // Suppress thoughts > 85% similar
+    this.STAGNATION_LIMIT = 3; // Max repetitive cycles before compression
+  }
+
+  /**
+   * Prunes and compresses a reasoning trace to manage context entropy.
+   * @param {Array} trace - Array of reasoning trace events.
+   * @returns {Array} - Guarded reasoning trace.
+   */
+  compress(trace) {
+    if (!trace || trace.length === 0) return [];
+
+    const result = [];
+    const history = [];
+    let loopBuffer = [];
+
+    for (const event of trace) {
+      if (event.event !== 'reasoning_trace') {
+        result.push(event);
+        continue;
+      }
+
+      const similarity = this._calculateMaxSimilarity(event.thought, history);
+      
+      if (similarity > this.SIMILARITY_SUPPRESSION_THRESHOLD) {
+        // High similarity: Buffer for potential compression
+        loopBuffer.push(event);
+        if (loopBuffer.length >= this.STAGNATION_LIMIT) {
+          // Trigger automatic compression/digest
+          const digest = {
+            event: 'reasoning_digest',
+            summary: `Compressed reasoning loop (${loopBuffer.length} stagnant steps).`,
+            final_conclusion: event.thought,
+            timestamp: new Date().toISOString()
+          };
+          // Replace buffered noise with a single digest
+          result.push(digest);
+          loopBuffer = []; 
+        }
+        continue;
+      }
+
+      // If we had a short buffer that didn't reach stagnation limit, push them back
+      if (loopBuffer.length > 0) {
+        result.push(...loopBuffer);
+        loopBuffer = [];
+      }
+
+      result.push(event);
+      history.push(event.thought);
+      if (history.length > 10) history.shift(); // Keep history window sliding
+    }
+
+    // Final flush for items remaining in buffer
+    if (loopBuffer.length > 0) {
+      result.push(...loopBuffer);
+    }
+
+    return result;
+  }
+
+  /**
+   * Internal Similarity Heuristic (Jaccard)
+   */
+  _calculateMaxSimilarity(thought, history) {
+    if (history.length === 0) return 0;
+    
+    const getTokens = (str) => new Set(str.toLowerCase().split(/\s+/).filter(t => t.length > 3));
+    const currentTokens = getTokens(thought);
+    
+    let max = 0;
+    for (const prev of history) {
+      const prevTokens = getTokens(prev);
+      const intersection = new Set([...currentTokens].filter(x => prevTokens.has(x)));
+      const union = new Set([...currentTokens, ...prevTokens]);
+      const sim = union.size === 0 ? 0 : intersection.size / union.size;
+      if (sim > max) max = sim;
+    }
+    return max;
+  }
+}
+
+module.exports = new ContextEntropyGuard();

package/bin/engine/handover-manager.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const ceg = require('./context-entropy-guard');
 
 class HandoverManager {
   constructor(config = {}) {
@@ -34,7 +35,8 @@ class HandoverManager {
         last_events: state.recentEvents,
         memory_shards: state.memoryShards || []
       },
-      reasoning_snapshot: state.reasoningTrace,
+      // v6.4.0: Context Entropy Guard applied for active noise suppression
+      reasoning_snapshot: (Array.isArray(state.reasoningTrace)) ? ceg.compress(state.reasoningTrace) : state.reasoningTrace,
       steering_requirements: state.blocks || []
     };
 

package/bin/engine/test-ceg.js

@@ -0,0 +1,59 @@
+/**
+ * MindForge v6.4.0 — CEG Verification Test
+ * 
+ * Simulates a "noisy" reasoning trace with repetitive thoughts 
+ * and verifies that the ContextEntropyGuard (CEG) correctly 
+ * suppresses noise and compresses the history.
+ */
+'use strict';
+
+const ceg = require('./context-entropy-guard');
+
+async function runTest() {
+  console.log('🧪 Starting CEG Verification Test...');
+
+  const trace = [
+    { event: 'reasoning_trace', thought: 'I should analyze the target directory structure.', is_stagnant: false },
+    { event: 'reasoning_trace', thought: 'Analyzing the directory layout now.', is_stagnant: false },
+    // Repetitive noise (to be suppressed)
+    { event: 'reasoning_trace', thought: 'Analyzing the directory layout now.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Analyzing the directory layout now.', is_stagnant: true },
+    // New thought
+    { event: 'reasoning_trace', thought: 'Found a potential vulnerability in the config file.', is_stagnant: false },
+    // Loop (to be compressed)
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true },
+    { event: 'reasoning_trace', thought: 'Checking config permissions.', is_stagnant: true }
+  ];
+
+  console.log(`\nInput Trace Length: ${trace.length}`);
+
+  const compressed = ceg.compress(trace);
+  console.log(`Compressed Trace Length: ${compressed.length}`);
+
+  console.log('\n--- Final Trace Preview ---');
+  compressed.forEach((e, idx) => {
+    if (e.event === 'reasoning_digest') {
+      console.log(`[${idx}] DIGEST: ${e.summary} | Last Conclusion: ${e.final_conclusion}`);
+    } else {
+      console.log(`[${idx}] THOUGHT: ${e.thought}`);
+    }
+  });
+
+  // Validations
+  const hasDigest = compressed.some(e => e.event === 'reasoning_digest');
+  const totalReduction = trace.length - compressed.length;
+
+  if (hasDigest && totalReduction >= 2) {
+    console.log('\n✅ SUCCESS: CEG successfully suppressed noise and compressed the reasoning loop.');
+  } else {
+    console.error('\n❌ FAILURE: CEG failed to compress the history significantly.');
+    process.exit(1);
+  }
+}
+
+runTest().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "mindforge-cc",
-  "version": "6.3.0",
-
+  "version": "6.4.0",
   "description": "MindForge — Sovereign Agentic Intelligence Framework. (CADIA v6.2 & PQAS Enabled)",
   "bin": {
     "mindforge-cc": "bin/install.js"
@@ -54,4 +53,4 @@
   "dependencies": {
     "express": "^4.19.2"
   }
-}
+}