mindforge-cc 8.2.0 → 9.0.0

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

@@ -1,82 +0,0 @@
-/**
- * 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

@@ -1,94 +0,0 @@
-/**
- * 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

@@ -1,106 +0,0 @@
-/**
- * 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

@@ -1,71 +0,0 @@
-/**
- * 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

@@ -1,39 +0,0 @@
-/**
- * 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

@@ -1,181 +0,0 @@
-/**
- * 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

@@ -1,100 +0,0 @@
-/**
- * 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();