mindforge-cc 5.6.0 → 6.0.0-alpha

package/bin/engine/nexus-tracer.js

@@ -10,6 +10,8 @@ const path = require('path');
 const crypto = require('crypto');
 const ztai = require('../governance/ztai-manager');
 const SREManager = require('./sre-manager');
+const driftDetector = require('./logic-drift-detector'); // v6.1 Pillar X
+const remediationEngine = require('./remediation-engine'); // v6.1 Pillar X
 
 class NexusTracer {
   constructor(config = {}) {
@@ -21,9 +23,12 @@ class NexusTracer {
     this.enableZtai = config.enableZtai !== false;
     this.sreManager = new SREManager();
 
-    // v5 Pillar III: Reasoning Entropy Monitoring (RES)
-    this.RES_THRESHOLD = 0.8; // Similarity threshold for stagnation
-    this.entropyCache = new Map(); // spanId -> [thoughtHistories]
+    // v5/v6: Reasoning Entropy Monitoring (RES)
+    this.RES_THRESHOLD = 0.8; 
+    this.entropyCache = new Map(); 
+
+    // v6.1: Neural Drift Remediation (NDR)
+    this.DRIFT_SAMPLE_RATE = 1.0; 
 
     // v5 Pillar IV: Agentic SBOM
     this.sbom = {
@@ -45,7 +50,7 @@ class NexusTracer {
   /**
    * Start a new ART span.
    */
-  startSpan(name, attributes = {}, parentSpanId = null) {
+  async startSpan(name, attributes = {}, parentSpanId = null) {
     const spanId = `sp_${crypto.randomBytes(6).toString('hex')}`;
     const startTime = new Date().toISOString();
 
@@ -59,6 +64,8 @@ class NexusTracer {
       attributes: {
         ...attributes,
         service: 'mindforge-nexus',
+        host: require('os').hostname(),
+        pid: process.pid
       }
     };
 
@@ -81,7 +88,7 @@ class NexusTracer {
     }
 
     // Record span start in AUDIT.jsonl
-    this._recordEvent('span_started', { 
+    await this._recordEvent('span_started', { 
       span_id: spanId, 
       parent_span_id: parentSpanId,
       span_name: name,
@@ -95,7 +102,7 @@ class NexusTracer {
   /**
    * End an active span.
    */
-  endSpan(spanId, status = 'success', metadata = {}) {
+  async endSpan(spanId, status = 'success', metadata = {}) {
     const span = this.activeSpans.get(spanId);
     if (!span) return;
 
@@ -107,7 +114,7 @@ class NexusTracer {
       this.sreManager.terminateEnclave(span.attributes.enclave_id);
     }
 
-    this._recordEvent('span_completed', {
+    await this._recordEvent('span_completed', {
       span_id: spanId,
       status,
       ...metadata
@@ -119,25 +126,52 @@ class NexusTracer {
   /**
    * Record a Reasoning Trace event (ART granularity).
    */
-  recordReasoning(spanId, agent, thought, resolution = 'none') {
+  async recordReasoning(spanId, agent, thought, resolution = 'none') {
     const span = this.activeSpans.get(spanId);
     let sanitizedThought = thought;
 
     if (span && span.attributes.enclave_id) {
-      sanitizedThought = this.sreManager.sanitizeThoughtChain(thought, span.attributes.enclave_id);
+      const result = this.sreManager.sanitizeThoughtChain(thought, span.attributes.enclave_id);
+      
+      if (result.status === 'SRE-ISOLATED') {
+        // Log the ZK proof instead of the raw thought
+        await this._recordEvent('sre_proof_logged', {
+          span_id: spanId,
+          agent,
+          certificate: result,
+          resolution
+        });
+        return; // Skip standard reasoning trace for isolated content
+      }
+      sanitizedThought = result.content || thought;
+    }
+
+    // v6.1 Pillar X: Neural Drift Remediation (NDR)
+    const driftReport = driftDetector.analyze(spanId, sanitizedThought);
+    if (driftReport.status === 'DRIFT_DETECTED') {
+      const remediation = await remediationEngine.trigger(spanId, driftReport);
+      
+      await this._recordEvent('drift_remediation_event', {
+        span_id: spanId,
+        score: driftReport.drift_score,
+        strategy: remediation.strategy,
+        remediation_id: remediation.remediation_id,
+        markers: driftReport.markers
+      });
     }
 
     // v5 Pillar III: PES (Proactive Equilibrium Scoring)
     const entropy = this.calculateEntropy(spanId, sanitizedThought);
     const isStagnant = entropy > this.RES_THRESHOLD;
 
-    this._recordEvent('reasoning_trace', {
+    await this._recordEvent('reasoning_trace', {
       span_id: spanId,
       agent,
       thought: sanitizedThought,
       resolution,
       entropy: parseFloat(entropy.toFixed(4)),
-      is_stagnant: isStagnant
+      is_stagnant: isStagnant,
+      drift_score: driftReport.drift_score // Inclusion for consolidated audit
     });
 
     if (isStagnant) {
@@ -145,7 +179,7 @@ class NexusTracer {
       const stagnationCount = history.filter(h => h.entropy > this.RES_THRESHOLD).length;
 
       if (stagnationCount >= 3) {
-        this._recordEvent('vulnerability_detected', {
+        await this._recordEvent('vulnerability_detected', {
           span_id: spanId,
           type: 'REASONING_LOOP',
           severity: 'HIGH',
@@ -154,7 +188,7 @@ class NexusTracer {
         });
         
         // Signal proactive recovery
-        this.recordSelfHeal(spanId, {
+        await this.recordSelfHeal(spanId, {
           type: 'PROACTIVE_RCA',
           cause: 'REASONING_STAGNATION',
           suggestion: 'Entropy threshold exceeded. Switch reasoning strategy.'
@@ -200,7 +234,7 @@ class NexusTracer {
   /**
    * Internal AUDIT writer.
    */
-  _recordEvent(event, data) {
+  async _recordEvent(event, data) {
     const entry = {
       id: crypto.randomUUID(),
       timestamp: new Date().toISOString(),
@@ -215,7 +249,7 @@ class NexusTracer {
         entry.did = this.did;
         // Sign the stringified entry WITHOUT the signature field itself
         const payload = JSON.stringify(entry);
-        entry.signature = ztai.signData(this.did, payload);
+        entry.signature = await ztai.signData(this.did, payload);
       } catch (err) {
         console.warn(`[NexusTracer] ZTAI signing failed: ${err.message}`);
       }
@@ -234,8 +268,8 @@ class NexusTracer {
   /**
    * Records a FinOps budget decision (Pillar V).
    */
-  recordFinOps(spanId, decision) {
-    this._recordEvent('finops_decision', {
+  async recordFinOps(spanId, decision) {
+    await this._recordEvent('finops_decision', {
       span_id: spanId,
       ...decision
     });
@@ -244,8 +278,8 @@ class NexusTracer {
   /**
    * Records a Self-Healing trigger event (Pillar VI).
    */
-  recordSelfHeal(spanId, report) {
-    this._recordEvent('self_heal_trigger', {
+  async recordSelfHeal(spanId, report) {
+    await this._recordEvent('self_heal_trigger', {
       span_id: spanId,
       ...report
     });
@@ -254,7 +288,7 @@ class NexusTracer {
   /**
    * Finalize and export the Agentic SBOM (Pillar IV).
    */
-  exportSBOM(outputPath = null) {
+  async exportSBOM(outputPath = null) {
     const finalPath = outputPath || path.join(process.cwd(), '.planning', 'MANIFEST.sbom.json');
     const manifest = {
       ...this.sbom,
@@ -269,7 +303,7 @@ class NexusTracer {
       }
       fs.writeFileSync(finalPath, JSON.stringify(manifest, null, 2));
       
-      this._recordEvent('sbom_exported', { path: finalPath });
+      await this._recordEvent('sbom_exported', { path: finalPath });
       return finalPath;
     } catch (err) {
       console.error(`[NexusTracer] Failed to export SBOM: ${err.message}`);
@@ -278,4 +312,9 @@ class NexusTracer {
   }
 }
 
-module.exports = NexusTracer;
+// Global Singleton Instance for easy mesh-wide access
+const globalTracer = new NexusTracer();
+
+// Export both the class and the global instance
+module.exports = globalTracer;
+module.exports.NexusTracer = NexusTracer;

package/bin/engine/remediation-engine.js

@@ -0,0 +1,72 @@
+/**
+ * MindForge v6.1.0-alpha — Neural Drift Remediation (NDR)
+ * Component: Remediation Engine (Pillar X)
+ * 
+ * Triggers corrective actions when logic drift or reasoning 
+ * stagnation is detected.
+ */
+'use strict';
+
+const driftDetector = require('./logic-drift-detector');
+
+class RemediationEngine {
+  constructor() {
+    this.activeRemediations = new Set();
+  }
+
+  /**
+   * Triggers a specific remediation workflow.
+   * @param {string} spanId 
+   * @param {Object} report - From LogicDriftDetector
+   */
+  async trigger(spanId, report) {
+    const { drift_score, markers } = report;
+    let strategy = 'NOT_REQUIRED';
+
+    // Tiered Remediation Logic
+    if (drift_score > 0.9) strategy = 'REASONING_RESTART';
+    else if (drift_score > 0.8) strategy = 'GOLDEN_TRACE_INJECTION';
+    else if (drift_score > 0.75) strategy = 'CONTEXT_COMPRESSION';
+
+    if (strategy === 'NOT_REQUIRED') return { status: 'STABLE', strategy };
+
+    const action = {
+      span_id: spanId,
+      strategy,
+      remediation_id: `rem_${Math.random().toString(36).substr(2, 6)}`,
+      timestamp: new Date().toISOString(),
+      effectiveness_prediction: 0.85
+    };
+
+    console.log(`[Remediation] Triggered ${strategy} for ${spanId} (Drift: ${drift_score})`);
+    
+    this.activeRemediations.add(action);
+    
+    // Simulating specific remediation actions
+    this._executeStrategy(strategy, spanId);
+
+    return action;
+  }
+
+  /**
+   * Mock implementation of remediation strategies.
+   */
+  async _executeStrategy(strategy, spanId) {
+    switch(strategy) {
+      case 'REASONING_RESTART':
+        console.log(`[Remediation] Forcing reasoner reset for ${spanId}`);
+        // Logic to clear local thought window for span
+        break;
+      case 'GOLDEN_TRACE_INJECTION':
+        console.log(`[Remediation] Injecting successful trace heuristics into ${spanId}`);
+        // Logic to pull from Semantic Hub successful past traces
+        break;
+    }
+  }
+
+  getActiveRemediations() {
+    return Array.from(this.activeRemediations);
+  }
+}
+
+module.exports = new RemediationEngine();

package/bin/engine/sre-manager.js

@@ -6,6 +6,10 @@
 
 const crypto = require('crypto');
 
+// Simulated System DID for Enclave Proofs (Tier 3)
+const ENCLAVE_PRIVATE_KEY = 'tier3-enclave-secret-key-sim'; // In production, this would be a TEE-bound private key
+const SYSTEM_DID = 'did:mindforge:enclave:0xbeast';
+
 class SREManager {
   constructor() {
     this.activeEnclaves = new Map();
@@ -26,7 +30,8 @@ class SREManager {
       startedAt: new Date().toISOString(),
       principal: context.did,
       hasIP: true,
-      isolationLevel: 'Hardware-Enclave (Simulated)'
+      isolationLevel: 'Hardware-Enclave (Simulated)',
+      cumulativeHash: null // Root of the proof chain
     });
 
     console.log(`[SRE-INIT] Initialized Sovereign Reason Enclave: ${enclaveId} for ${context.did}`);
@@ -34,19 +39,68 @@ class SREManager {
   }
 
   /**
-   * Sanitizes a thought chain for global audit logging.
-   * Ensures that sensitive IP or "zero-visibility" thoughts are isolated.
+   * Sanitizes a thought chain and generates a ZK-Proof Compliance Certificate.
+   * Ensures that sensitive IP or "zero-visibility" thoughts are isolated while proving audit-eligibility.
    * @param {string} thoughtChain - The raw agentic thought chain.
-   * @returns {string} - Sanitized/Isolated thought chain.
+   * @param {string} enclaveId - The active enclave ID.
+   * @param {Object} policyResult - Whether the content passed internal policy checks.
+   * @returns {Object} - ZK-Proof compliance certificate.
    */
-  sanitizeThoughtChain(thoughtChain, enclaveId) {
-    if (!this.activeEnclaves.has(enclaveId)) return thoughtChain;
+  sanitizeThoughtChain(thoughtChain, enclaveId, policyResult = { passed: true }) {
+    if (!this.activeEnclaves.has(enclaveId)) {
+      return { status: 'PLAINTEXT', content: thoughtChain };
+    }
 
-    // Zero-Visibility Protocol: In SRE mode, the global audit log only receives a hash
-    // or a redacted summary. The full chain is kept in volatile enclave memory.
+    // v5 Pillar VI: Merkle-style Cumulative Hash Chain
+    const enclaveData = this.activeEnclaves.get(enclaveId);
+    const prevHash = enclaveData.cumulativeHash;
     const digest = crypto.createHash('sha256').update(thoughtChain).digest('hex');
     
-    return `[SRE-ISOLATED] Confidential reasoning executed in enclave ${enclaveId}. Verification Digest: ${digest}. Original trace is isolated from persistence.`;
+    // Generate a simulated ZK-Proof Compliance Certificate
+    const proofPayload = {
+      enclaveId: enclaveId,
+      digest: digest,
+      prevHash: prevHash, // Links the chain
+      policyPassed: policyResult.passed,
+      timestamp: new Date().toISOString(),
+      principal: enclaveData.principal
+    };
+
+    // Sign the proof with the Enclave Private Key
+    const signature = crypto.createHmac('sha256', ENCLAVE_PRIVATE_KEY)
+      .update(JSON.stringify(proofPayload))
+      .digest('hex');
+
+    // Update the cumulative hash for the next block
+    const proofHash = crypto.createHash('sha256').update(signature).digest('hex');
+    enclaveData.cumulativeHash = proofHash;
+
+    const certificate = {
+      status: 'SRE-ISOLATED',
+      proof: proofPayload,
+      signature: signature,
+      proofHash: proofHash,
+      verificationDid: SYSTEM_DID,
+      message: `[SRE-ZK-PROOF] Confidential reasoning (sha256:${digest.substring(0, 8)}...) verified by Enclave Auditor.`
+    };
+
+    return certificate;
+  }
+
+  /**
+   * Verifies an SRE Compliance Certificate without seeing the original content.
+   */
+  verifyZKProof(certificate) {
+    if (certificate.status !== 'SRE-ISOLATED') return false;
+
+    const expectedSignature = crypto.createHmac('sha256', ENCLAVE_PRIVATE_KEY)
+      .update(JSON.stringify(certificate.proof))
+      .digest('hex');
+
+    const isValid = (expectedSignature === certificate.signature);
+    const policyPassed = certificate.proof.policyPassed;
+
+    return isValid && policyPassed;
   }
 
   /**

package/bin/governance/impact-analyzer.js

@@ -1,9 +1,12 @@
 /**
- * MindForge v5.4.0 — Impact Analyzer (Hardened Edition)
+ * MindForge v6.0.0 — Context-Aware Dynamic Impact Analysis (CADIA)
  * Calculates the 'Blast Radius' score of a proposed intent.
  */
 'use strict';
 
+const fs = require('node:fs');
+const path = require('node:path');
+
 class ImpactAnalyzer {
   static CRITICAL_PATHS = [
     '.env',
@@ -27,18 +30,22 @@ class ImpactAnalyzer {
     'READ': 1,
     'WRITE': 5,
     'DELETE': 10,
-    'EXECUTE': 15, // Raised from 8
-    'GRANT': 20    // Raised from 15
+    'EXECUTE': 15,
+    'GRANT': 20
   };
 
+  // Cache for session-based entropy tracking
+  static sessionState = new Map();
+
   /**
-   * Scores an intent based on action type, target path sensitivity, and recursion depth.
+   * [CADIA] Scores an intent based on architectural influence, session entropy, and trust tiers.
    * Score Range: 0 - 100
    */
-  static analyze(intent) {
+  static analyze(intent, context = {}) {
     const { action, target, namespace } = intent;
-    
-    // 1. Critical Path Protection (Score 100)
+    const { sessionId = 'default', trustTier = 0, currentGoal = '' } = context;
+
+    // 1. Critical Path Protection (Hardened)
     const isCritical = this.CRITICAL_PATHS.some(cp => 
       (target && (target.endsWith(cp) || target.includes(`/${cp}`)))
     );
@@ -49,33 +56,86 @@ class ImpactAnalyzer {
 
     let score = this.ACTION_SCORES[action] || 5;
     
-    // 2. Sensitive Namespace Multiplier
+    // 2. [NEW] Architectural Influence Engine (x2.5 multiplier)
+    if (this.isArchitecturallySignificant(target)) {
+      score *= 2.5; 
+    }
+
+    // 3. Sensitive Namespace Multiplier (x4.0 multiplier)
     const isSensitive = this.SENSITIVE_NAMESPACES.some(ns => 
       (target && target.includes(ns)) || (namespace && namespace.includes(ns))
     );
 
     if (isSensitive) {
-      score *= 4; 
+      score *= 4.0; 
     }
 
-    // 3. Recursive Depth Penalty (Beast Mode)
+    // 4. [NEW] Session Entropy Tracker (+15 penalty)
+    const sessCount = (this.sessionState.get(sessionId) || 0) + 1;
+    this.sessionState.set(sessionId, sessCount);
+    
+    if (sessCount > 5) {
+      score += (sessCount - 5) * 15; 
+    }
+
+    // 5. [NEW] Goal-to-Path Alignment (+40 penalty)
+    if (currentGoal && !this.isGoalAligned(target, currentGoal)) {
+      score += 40; 
+    }
+
+    // 6. [NEW] ZTAI-Trust Scaling (Risk buffer)
+    const trustBuffer = trustTier * 10;
+    score = Math.max(0, score - trustBuffer);
+
+    // 7. Recursive Depth Scale
     if (target && target.split('/').length > 5) {
-      score *= 1.5; // Deeper actions are riskier (mass-scale silent mods)
+      score *= 1.25; 
     }
 
-    // Cap the score at 100
     return Math.min(Math.round(score), 100);
   }
 
+
+  /**
+   * Identifies files with high architectural side-effects.
+   */
+  static isArchitecturallySignificant(filePath) {
+    if (!filePath) return false;
+    const highWeightDirs = ['bin/governance', 'bin/engine', 'bin/models', '.mindforge/intelligence'];
+    const highWeightFiles = ['package.json', 'sdk/nexus-core.js', 'bin/mindforge-cli.js'];
+    
+    return highWeightDirs.some(d => filePath.includes(d)) || 
+           highWeightFiles.some(f => filePath.endsWith(f));
+  }
+
   /**
-   * Returns a risk tier based on the score.
+   * Checks if the target path semantically aligns with the current active goal/phase.
    */
+  static isGoalAligned(filePath, currentGoal) {
+    if (!currentGoal || !filePath) return true; // Default to neutral if no goal set
+    
+    // Simple heuristic: Does the goal mention the file or directory?
+    const normalizedGoal = currentGoal.toLowerCase();
+    const normalizedPath = filePath.toLowerCase();
+    
+    // Extract domain (e.g., 'auth', 'ui', 'api')
+    const domain = normalizedPath.split('/')[0];
+    
+    return normalizedGoal.includes(domain) || 
+           normalizedGoal.includes(path.basename(normalizedPath, path.extname(normalizedPath)));
+  }
+
   static getRiskTier(score) {
-    if (score < 20) return 'LOW';
+    if (score < 25) return 'LOW';
     if (score < 50) return 'MEDIUM';
-    if (score < 80) return 'HIGH';
+    if (score < 75) return 'HIGH';
     return 'CRITICAL';
   }
+
+  static resetSession(sessionId) {
+    this.sessionState.delete(sessionId);
+  }
 }
 
 module.exports = ImpactAnalyzer;
+