mindforge-cc 5.10.0 → 6.1.0-alpha

package/bin/autonomous/intent-harvester.js

@@ -0,0 +1,80 @@
+/**
+ * MindForge v7 — Proactive Semantic Homing (Pillar XII)
+ * Intent Harvester: Proactively scans and claims unassigned tasks.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+class IntentHarvester {
+  constructor() {
+    this.planningDir = path.join(process.cwd(), '.planning');
+    this.backlogPath = path.join(this.planningDir, 'BACKLOG.json');
+    this.handoffPath = path.join(this.planningDir, 'HANDOFF.json');
+  }
+
+  /**
+   * Scans for unassigned intent in the backlog and peer handoffs.
+   */
+  async idleScan() {
+    console.log('[HOMING-SCAN] Agents transitioning to "Proactive Hunter" mode. Scanning FIM for unassigned intent...');
+    
+    const tasks = [];
+    if (fs.existsSync(this.backlogPath)) {
+      const backlog = JSON.parse(fs.readFileSync(this.backlogPath, 'utf8'));
+      tasks.push(...backlog.filter(t => t.status === 'unassigned' || t.status === 'pending'));
+    }
+
+    if (fs.existsSync(this.handoffPath)) {
+      const handoff = JSON.parse(fs.readFileSync(this.handoffPath, 'utf8'));
+      tasks.push(...(handoff.open_intents || []));
+    }
+
+    return tasks;
+  }
+
+  /**
+   * Autonomous task claiming based on agent Skill-Score.
+   */
+  async intentGrab(agent, tasks) {
+    if (tasks.length === 0) return null;
+
+    console.log(`[HOMING-GRAB] Agent ${agent.did} evaluating ${tasks.length} unassigned intents...`);
+    
+    // Sort tasks by Skill-Match affinity
+    const prioritized = tasks.map(task => ({
+      task,
+      score: this.calculateAffinity(agent, task)
+    })).sort((a, b) => b.score - a.score);
+
+    const bestMatch = prioritized[0];
+    if (bestMatch.score > 70) {
+      console.log(`[HOMING-GRAB] High affinity detected (${bestMatch.score}). Agent ${agent.did} claiming: ${bestMatch.task.description}`);
+      return this.claimTask(agent, bestMatch.task);
+    }
+
+    return null;
+  }
+
+  calculateAffinity(agent, task) {
+    // Simulated skill-affinity calculation
+    const skills = agent.skills || [];
+    const taskReqs = task.required_skills || [];
+    
+    const matchCount = taskReqs.filter(s => skills.includes(s)).length;
+    return (matchCount / Math.max(taskReqs.length, 1)) * 100;
+  }
+
+  async claimTask(agent, task) {
+    task.assigned_to = agent.did;
+    task.status = 'active';
+    task.claimedAt = new Date().toISOString();
+    
+    // Update local state (in a real system this would be a atomic mesh update)
+    return task;
+  }
+}
+
+module.exports = new IntentHarvester();

package/bin/autonomous/mesh-self-healer.js

@@ -0,0 +1,67 @@
+/**
+ * MindForge v7 — Proactive Semantic Homing (Pillar XII)
+ * Mesh Self-Healer: Peer agents "home in" on drifting nodes to provide collaborative reasoning.
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+class MeshSelfHealer {
+  constructor() {
+    this.auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+  }
+
+  /**
+   * Peer agents "home in" on a node with high logic drift.
+   */
+  async homeIn(driftingAgentDid, driftScore) {
+    if (driftScore < 80) return null; // Only home in on major drift
+    
+    console.log(`[HOMING-HEAL] Global Mesh Alert: Agent ${driftingAgentDid} experiencing critical logic drift (${driftScore}). Peer agents redirecting...`);
+    
+    // Find nearby idle agents or specialists
+    const peers = this.findAvailablePeers(driftingAgentDid);
+    const healingNodes = [];
+
+    for (const peer of peers) {
+      console.log(`[HOMING-HEAL] Agent ${peer.did} homing in on ${driftingAgentDid} to provide collective reasoning support.`);
+      const supportTrace = await this.provideCollectiveReasoning(peer, driftingAgentDid);
+      healingNodes.push(supportTrace);
+    }
+
+    return this.reconcileReasoning(healingNodes);
+  }
+
+  findAvailablePeers(driftingAgentDid) {
+    // Simulated peer discovery
+    return [
+      { did: 'did:mindforge:peer-1-specialist', name: 'Refactor Specialist' },
+      { did: 'did:mindforge:peer-2-architect', name: 'Security Architect' }
+    ];
+  }
+
+  async provideCollectiveReasoning(peer, target) {
+    // Peer agent provides a second opinion/reasoning node
+    return {
+      provider: peer.did,
+      target: target,
+      reasoning: `Recommended steering for drift recovery based on Mesh-State: Re-syncing with Sovereign-Reason-Enclave.`,
+      confidence: 94
+    };
+  }
+
+  reconcileReasoning(nodes) {
+    // Merge peer reasoning nodes into a single corrective steering vector
+    const consensus = nodes[0].reasoning; // Mock consensus
+    console.log(`[HOMING-HEAL] Collective reasoning consensus acheived: 100% agreement on recovery vector.`);
+    
+    return {
+      type: 'collective_repair',
+      consensus,
+      source: 'Mesh-Self-Healing'
+    };
+  }
+}
+
+module.exports = new MeshSelfHealer();

package/bin/engine/logic-drift-detector.js

@@ -0,0 +1,97 @@
+/**
+ * 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';
+
+class LogicDriftDetector {
+  constructor() {
+    this.sessionDriftHistory = new Map(); // spanId -> [scores]
+    this.DRIFT_THRESHOLD = 0.75;
+  }
+
+  /**
+   * 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();

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 = {
@@ -141,6 +146,20 @@ class NexusTracer {
       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;
@@ -151,7 +170,8 @@ class NexusTracer {
       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) {

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/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;
+