mindforge-cc 8.1.0 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/dashboard/temporal-api.js

@@ -0,0 +1,82 @@
+/**
+ * MindForge v3 — Temporal Dashboard API
+ * REST endpoints for time-travel debugging and state exploration.
+ */
+'use strict';
+
+const express = require('express');
+const router = express.Router();
+const TemporalHub = require('../engine/temporal-hub');
+const HindsightInjector = require('../hindsight-injector');
+
+/**
+ * GET /api/temporal/history
+ * Returns the full timeline of state snapshots.
+ */
+router.get('/history', (req, res) => {
+  try {
+    const history = TemporalHub.getHistory();
+    res.json(history);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to retrieve temporal history', detail: err.message });
+  }
+});
+
+/**
+ * GET /api/temporal/snapshot/:auditId/:file
+ * Returns the content of a specific file at a specific point in time.
+ */
+router.get('/snapshot/:auditId/:file', (req, res) => {
+  try {
+    const { auditId, file } = req.params;
+    const content = TemporalHub.getSnapshotFile(auditId, file);
+    
+    if (content === null) {
+      return res.status(404).json({ error: `File ${file} not found in snapshot ${auditId}` });
+    }
+    
+    res.send(content);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to retrieve snapshot file', detail: err.message });
+  }
+});
+
+/**
+ * GET /api/temporal/snapshot/:auditId/meta
+ * Returns metadata for a specific snapshot.
+ */
+router.get('/snapshot/:auditId/meta', (req, res) => {
+  try {
+    const snapshots = TemporalHub.getHistory();
+    const snap = snapshots.find(s => s.id === req.params.auditId);
+    if (!snap) return res.status(404).json({ error: 'Snapshot not found' });
+    res.json(snap);
+  } catch (err) {
+    res.status(500).json({ error: 'Failed to retrieve snapshot metadata' });
+  }
+});
+
+/**
+ * POST /api/temporal/inject
+ * Triggers a state rollback and hindsight injection.
+ */
+router.post('/inject', async (req, res) => {
+  try {
+    const { auditId, fixDescription } = req.body;
+    
+    if (!auditId || !fixDescription) {
+      return res.status(400).json({ error: 'auditId and fixDescription are required' });
+    }
+
+    const result = await HindsightInjector.inject(auditId, fixDescription);
+    if (result.success) {
+      res.json(result);
+    } else {
+      res.status(500).json(result);
+    }
+  } catch (err) {
+    res.status(500).json({ error: 'Hindsight injection failed', detail: err.message });
+  }
+});
+
+module.exports = router;

package/.mindforge/mirrors/mirror-sre-776a1cf9/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/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/feedback-loop.js

@@ -0,0 +1,106 @@
+/**
+ * MindForge — WaveFeedbackLoop (Pillar VI: Proactive Equilibrium)
+ * Monitors divergence during wave execution and triggers self-healing.
+ */
+const fs = require('fs');
+const path = require('path');
+
+class WaveFeedbackLoop {
+  constructor(config = {}) {
+    this.failureThreshold = config.failureThreshold || 0.20; // 20% failure rate
+    this.divergenceWeight = config.divergenceWeight || 1.5; // Bias for rapid divergence
+    this.statsPath = config.statsPath || path.join(__dirname, '..', 'models', 'performance-stats.json');
+    this.waveState = {
+      completed: 0,
+      failed: 0,
+      skipped: 0,
+      total: 0,
+    };
+  }
+
+  /**
+   * Updates the feedback loop with a task result and records performance stats.
+   */
+  update(result) {
+    this.waveState.total++;
+    const provider = result.providerId || 'unknown';
+    const taskType = result.taskType || 'default';
+
+    if (result.status === 'completed') {
+      this.waveState.completed++;
+      this.recordPerformance(provider, taskType, true);
+    } else if (result.status === 'failed') {
+      this.waveState.failed++;
+      this.recordPerformance(provider, taskType, false);
+    } else {
+      this.waveState.skipped++;
+    }
+  }
+
+  /**
+   * Records performance metrics to persistent storage.
+   */
+  recordPerformance(provider, taskType, isSuccess) {
+    if (provider === 'unknown') return;
+
+    try {
+      let stats = {};
+      if (fs.existsSync(this.statsPath)) {
+        stats = JSON.parse(fs.readFileSync(this.statsPath, 'utf8'));
+      }
+
+      if (!stats[provider]) stats[provider] = {};
+      if (!stats[provider][taskType]) stats[provider][taskType] = { success: 0, failure: 0 };
+
+      if (isSuccess) {
+        stats[provider][taskType].success++;
+      } else {
+        stats[provider][taskType].failure++;
+      }
+
+      fs.writeFileSync(this.statsPath, JSON.stringify(stats, null, 2));
+    } catch (e) {
+      console.warn(`[MCA-WARN] Failed to record performance stats: ${e.message}`);
+    }
+  }
+
+  /**
+   * Calculates the current divergence rate.
+   * @returns {number} - 0.0 to 1.0 divergence rate.
+   */
+  calculateDivergence() {
+    if (this.waveState.total === 0) return 0;
+    const failureRate = this.waveState.failed / this.waveState.total;
+    const skippedRate = this.waveState.skipped / this.waveState.total;
+    
+    // Divergence includes failures and unexpected skips
+    return (failureRate + (skippedRate * 0.5));
+  }
+
+  /**
+   * Determines if the wave is "Diverging" and needs autonomous recovery.
+   * @returns {Object} - Result (shouldPause, reason)
+   */
+  shouldTriggerHindsight() {
+    const divergence = this.calculateDivergence();
+    const minSample = 5; // Start checking after 5 tasks to avoid noise
+
+    if (this.waveState.total < minSample) return { shouldPause: false };
+
+    if (divergence >= this.failureThreshold) {
+      return {
+        shouldPause: true,
+        divergence: divergence.toFixed(2),
+        reason: `Wave Divergence reached critical threshold (${(divergence * 100).toFixed(0)}%). Triggering Temporal Hindsight for RCA and repair.`,
+      };
+    }
+
+    return { shouldPause: false };
+  }
+
+  reset() {
+    this.waveState = { completed: 0, failed: 0, skipped: 0, total: 0 };
+  }
+}
+
+module.exports = WaveFeedbackLoop;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/handover-manager.js

@@ -0,0 +1,71 @@
+/**
+ * MindForge — HandoverManager (Pillar VII: Dynamic Human-Agent Handover)
+ * Packages Nexus State Bundles for bidirectional steering and human escalation.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const ceg = require('./context-entropy-guard');
+
+class HandoverManager {
+  constructor(config = {}) {
+    this.handoffPath = path.join(process.cwd(), '.planning', 'handoffs');
+  }
+
+  /**
+   * Packages a Nexus State Bundle for human review.
+   * @param {Object} state - Current execution state (audit, memory, goals)
+   * @returns {string} - Path to the state bundle.
+   */
+  createNexusBundle(state) {
+    if (!fs.existsSync(this.handoffPath)) {
+      fs.mkdirSync(this.handoffPath, { recursive: true });
+    }
+
+    const bundleId = `bundle_${crypto.randomBytes(6).toString('hex')}`;
+    const bundle = {
+      id: bundleId,
+      timestamp: new Date().toISOString(),
+      version: '5.0.0-nexus',
+      context: {
+        phase: state.phase,
+        wave: state.wave,
+        last_events: state.recentEvents,
+        memory_shards: state.memoryShards || []
+      },
+      // 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 || []
+    };
+
+    const bundlePath = path.join(this.handoffPath, `${bundleId}.json`);
+    fs.writeFileSync(bundlePath, JSON.stringify(bundle, null, 2));
+
+    console.log(`[DHH-BUNDLE] Nexus State Bundle packaged: ${bundlePath}`);
+    return bundlePath;
+  }
+
+  /**
+   * Injects human steering into the agentic flow.
+   * @param {string} bundleId - The bundle being steered.
+   * @param {Object} steeringRequest - Human instructions/overrides.
+   */
+  injectSteering(bundleId, steeringRequest) {
+    const steerPath = path.join(process.cwd(), '.planning', 'STEER.json');
+    const instruction = {
+      id: crypto.randomUUID(),
+      timestamp: new Date().toISOString(),
+      bundle_id: bundleId,
+      type: 'HUMAN_OVERRIDE',
+      instruction: steeringRequest.instruction,
+      priority: 'CRITICAL'
+    };
+
+    fs.appendFileSync(steerPath, JSON.stringify(instruction) + '\n');
+    console.log(`[DHH-STEER] Human instruction injected into autonomous stream [Ref: ${bundleId}]`);
+  }
+}
+
+module.exports = HandoverManager;

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/intelligence-interlock.js

@@ -0,0 +1,39 @@
+/**
+ * MindForge v6.3.0 — Intelligence-Drift Coupling (IDC)
+ * Component: Intelligence Interlock
+ * 
+ * New architectural bridge that listens for critical logic-drift signals 
+ * and triggers proactive model upgrades in the steering engine.
+ */
+'use strict';
+
+const driftDetector = require('./logic-drift-detector');
+const routerSteering = require('../revops/router-steering-v2');
+
+class IntelligenceInterlock {
+  constructor() {
+    this.UPGRADE_THRESHOLD = 0.50; // v6.3.0 Threshold (Recalibrated for IDC readiness)
+  }
+
+  /**
+   * Evaluates if a model upgrade is required based on reasoning drift.
+   * @param {string} spanId 
+   * @param {string} thought 
+   */
+  evaluate(spanId, thought) {
+    const analysis = driftDetector.analyze(spanId, thought);
+    
+    if (analysis.drift_score > this.UPGRADE_THRESHOLD) {
+      console.log(`[IDC] Critical Drift Detected (${analysis.drift_score}). Recommending intelligence upgrade for Span ${spanId}.`);
+      return {
+        action: 'UPGRADE_MIR',
+        new_mir: 99, // Force maximum intelligence (Tier 1+)
+        reason: analysis.markers
+      };
+    }
+
+    return { action: 'CONTINUE', drift: analysis.drift_score };
+  }
+}
+
+module.exports = new IntelligenceInterlock();

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/learning-manager.js

@@ -0,0 +1,181 @@
+/**
+ * MindForge Learning Manager — v1.0.0
+ * Part of the Sovereign Intelligence Engine (v8.1.1)
+ * Manages the lifecycle of AGENTS_LEARNING.md and its integration with the distributed mesh.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+class LearningManager {
+  constructor(options = {}) {
+    this.rootDir = options.rootDir || process.cwd();
+    this.templateDir = options.templateDir || path.join(__dirname, '../../docs/templates/Project');
+    this.learningFile = path.join(this.rootDir, 'AGENTS_LEARNING.md');
+  }
+
+  /**
+   * Initialize a new learning file from the template.
+   */
+  async init(projectInfo = {}) {
+    if (fs.existsSync(this.learningFile)) {
+      throw new Error(`Learning file already exists at ${this.learningFile}`);
+    }
+
+    const templatePath = path.join(this.templateDir, 'AGENTS_LEARNING.md');
+    if (!fs.existsSync(templatePath)) {
+      throw new Error(`Template not found at ${templatePath}`);
+    }
+
+    let content = fs.readFileSync(templatePath, 'utf8');
+
+    // Basic hydration
+    content = content
+      .replace(/\[Project Name\]/g, projectInfo.name || path.basename(this.rootDir))
+      .replace(/\[Project Type\]/g, projectInfo.type || 'Fullstack')
+      .replace(/\[Tech Stack\]/g, projectInfo.techStack || 'Node.js, ESM')
+      .replace(/\[Short description of the system\]/g, projectInfo.description || 'Distributed agentic ecosystem.')
+      .replace(/\[Date\]/g, new Date().toISOString().split('T')[0])
+      .replace(/0x\[Identity\]/g, projectInfo.systemDid || '0xenterprise');
+
+    fs.writeFileSync(this.learningFile, content, 'utf8');
+    return this.learningFile;
+  }
+
+  /**
+   * Append a new Learning Entry to the Evolution Log.
+   */
+  async record(entry) {
+    if (!fs.existsSync(this.learningFile)) {
+      throw new Error(`Learning file not found at ${this.learningFile}. Run 'mindforge learning init' first.`);
+    }
+
+    const timestamp = new Date().toISOString();
+    const formattedEntry = `
+### [Learning Entry - ${timestamp}]
+
+**Context:**
+${entry.context || 'Autonomous execution wave'}
+
+**Mistake:**
+${entry.mistake || 'None (Best Practice Discovery)'}
+
+**Root Cause:**
+${entry.rootCause || 'N/A'}
+
+**Fix:**
+${entry.fix || 'N/A'}
+
+**Prevention Rule:**
+${entry.preventionRule || 'No specific rule defined.'}
+
+**Category:**
+- ${entry.category || 'General Learning'}
+
+---
+**Document Status:** Updated
+**Root Identity:** \`${entry.did || 'did:mindforge:enclave:0xenterprise'}\`
+**Last Verified:** ${timestamp.split('T')[0]}
+`;
+
+    fs.appendFileSync(this.learningFile, formattedEntry, 'utf8');
+    return true;
+  }
+
+  /**
+   * Read and summarize the top-level learnings (Best Practices & Anti-Patterns).
+   */
+  async getStatus() {
+    if (!fs.existsSync(this.learningFile)) {
+      return { initialized: false };
+    }
+
+    const content = fs.readFileSync(this.learningFile, 'utf8');
+    const entryMatches = content.match(/### \[Learning Entry -/g) || [];
+    
+    return {
+      initialized: true,
+      entryCount: entryMatches.length,
+      path: this.learningFile
+    };
+  }
+
+  /**
+   * Extract context-specific learnings to prevent repeating mistakes.
+   * In a future version, this will use embeddings/semantic search.
+   * v1.0.0 uses keyword matching on task description.
+   */
+  async summarizeRelevantLearnings(currentTask = '') {
+    if (!fs.existsSync(this.learningFile)) return 'N/A (Learning memory not initialized)';
+
+    const content = fs.readFileSync(this.learningFile, 'utf8');
+    
+    // Extract sections
+    const bestPractices = this._extractSection(content, '4. Best Practices');
+    const antiPatterns = this._extractSection(content, '5. Anti-Patterns');
+    const mistakes = this._extractSection(content, '1. Mistakes Observed');
+
+    let summary = '### 🧠 AGENTIC LEARNING CONTEXT\n';
+    
+    if (bestPractices) summary += `\n**Verified Best Practices:**\n${bestPractices}\n`;
+    if (antiPatterns) summary += `\n**Anti-Patterns to Avoid:**\n${antiPatterns}\n`;
+    
+    if (mistakes && currentTask) {
+      // Very simple keyword matching for relevance
+      const relevantMistakes = mistakes.split('\n')
+        .filter(m => {
+          const words = currentTask.toLowerCase().split(/\s+/);
+          return words.some(w => w.length > 3 && m.toLowerCase().includes(w));
+        })
+        .join('\n');
+      
+      if (relevantMistakes) {
+        summary += `\n**Potentially Relevant Past Mistakes:**\n${relevantMistakes}\n`;
+      }
+    }
+
+    return summary;
+  }
+
+  _extractSection(content, sectionName) {
+    const startIdx = content.indexOf(`## ${sectionName}`);
+    if (startIdx === -1) return null;
+    
+    const nextSectionIdx = content.indexOf('---', startIdx + 1);
+    const endIdx = nextSectionIdx !== -1 ? nextSectionIdx : content.length;
+    
+    return content.substring(startIdx, endIdx).trim();
+  }
+}
+
+module.exports = LearningManager;
+
+// CLI Support for internal testing
+if (require.main === module) {
+  (async () => {
+    const manager = new LearningManager();
+    const args = process.argv.slice(2);
+    const cmd = args[0];
+
+    try {
+      if (cmd === 'init') {
+        const path = await manager.init();
+        console.log(`✅ Initialized learning at ${path}`);
+      } else if (cmd === 'record') {
+        // Simple interactive mock
+        await manager.record({
+          context: 'CLI Manual Test',
+          category: 'Architecture'
+        });
+        console.log('✅ Recorded manual learning entry.');
+      } else {
+        const status = await manager.getStatus();
+        console.log('📊 Learning System Status:', status);
+      }
+    } catch (err) {
+      console.error(`❌ Error: ${err.message}`);
+    }
+  })();
+}

package/.mindforge/mirrors/mirror-sre-776a1cf9/bin/engine/logic-drift-detector.js

@@ -0,0 +1,100 @@
+/**
+ * MindForge v6.1.0-alpha — Neural Drift Remediation (NDR)
+ * Component: Logic Drift Detector (Pillar X)
+ * 
+ * Analyzes reasoning traces for "Semantic Decay" (repeated failure patterns, 
+ * hallucination-like markers, or mission drift).
+ */
+'use strict';
+
+const configManager = require('../governance/config-manager');
+
+class LogicDriftDetector {
+  constructor() {
+    this.sessionDriftHistory = new Map(); // spanId -> [scores]
+    this.DRIFT_THRESHOLD = configManager.get('governance.drift_threshold', 0.75);
+    this.CRITICAL_DRIFT_THRESHOLD = configManager.get('governance.critical_drift_threshold', 0.50);
+  }
+
+  /**
+   * Analyzes a specific thought for logic drift.
+   * @param {string} spanId 
+   * @param {string} thought 
+   */
+  analyze(spanId, thought) {
+    const semanticDensity = this._calculateSemanticDensity(thought);
+    const patternScore = this._detectRepetitivePatterns(spanId, thought);
+    const contradictionScore = this._checkHeuristicContradictions(thought);
+
+    // v6.1 Weights: Aggressive on contradictions and patterns
+    const driftScore = (semanticDensity * 0.1) + (patternScore * 0.5) + (contradictionScore * 0.4);
+
+    if (!this.sessionDriftHistory.has(spanId)) {
+      this.sessionDriftHistory.set(spanId, []);
+    }
+    this.sessionDriftHistory.get(spanId).push(driftScore);
+
+    return {
+      span_id: spanId,
+      drift_score: parseFloat(driftScore.toFixed(4)),
+      status: driftScore > this.DRIFT_THRESHOLD ? 'DRIFT_DETECTED' : 'STABLE',
+      markers: {
+        density: semanticDensity,
+        pattern: patternScore,
+        contradiction: contradictionScore
+      }
+    };
+  }
+
+  /**
+   * Internal Heuristic: Detects low semantic density (rambling).
+   */
+  _calculateSemanticDensity(thought) {
+    const words = thought.split(/\s+/).length;
+    // Strip punctuation for keyword matching
+    const keywords = thought.toLowerCase().replace(/[^\w\s]/g, '').match(/\b(\w{5,})\b/g) || [];
+    const uniqueKeywords = new Set(keywords).size;
+    
+    if (words === 0) return 0;
+    const ratio = uniqueKeywords / words;
+    // v6.1 Hardening: High sensitivity to rambling
+    return ratio < 0.25 ? 0.95 : 0.05; 
+  }
+
+  /**
+   * Internal Heuristic: Detects circular reasoning across a span window 
+   * and within the thought itself.
+   */
+  _detectRepetitivePatterns(spanId, currentThought) {
+    const history = this.sessionDriftHistory.get(spanId) || [];
+    
+    // Internal Repetition Check (Strip punctuation)
+    const normalized = currentThought.toLowerCase().replace(/[^\w\s]/g, '');
+    const words = normalized.split(/\s+/).filter(w => w.length > 3);
+    const wordCounts = {};
+    words.forEach(w => wordCounts[w] = (wordCounts[w] || 0) + 1);
+    
+    const maxRep = Math.max(0, ...Object.values(wordCounts));
+    const internalRepFactor = maxRep > 3 ? 0.9 : 0.1; // v6.1: Higher penalty
+
+    if (history.length < 2) return internalRepFactor;
+
+    // Window trending check
+    const recentScores = history.slice(-3);
+    const isTrendingUp = recentScores.length >= 2 && recentScores[recentScores.length-1] > recentScores[0];
+
+    return Math.max(internalRepFactor, isTrendingUp ? 0.7 : 0.1);
+  }
+
+  /**
+   * Internal Heuristic: Detects logic contradiction keywords.
+   */
+  _checkHeuristicContradictions(thought) {
+    const t = thought.toLowerCase();
+    const markers = ['nevertheless', 'however, i will instead', 'contradicting', 'error in reasoning', 'failed to', 'restart checking'];
+    const hits = markers.filter(m => t.includes(m)).length;
+    return Math.min(1.0, hits * 0.35); // v6.1: Higher impact per marker
+  }
+}
+
+module.exports = new LogicDriftDetector();