mindforge-cc 3.0.0 → 5.0.0

package/bin/autonomous/auto-runner.js

@@ -11,18 +11,34 @@ const stuckMonitor = require('./stuck-monitor');
 const steeringManager = require('./steer');
 const progressStream = require('./progress-stream');
 const headlessAdapter = require('./headless');
+const ContextRefactorer = require('./context-refactorer');
 const KnowledgeCapture = require('../memory/knowledge-capture');
 const TemporalHub = require('../engine/temporal-hub');
 const crypto = require('crypto');
 
+// MindForge v5 Core Modules
+const PolicyEngine = require('../governance/policy-engine');
+const RBACManager  = require('../governance/rbac-manager');
+const ZTAIManager  = require('../governance/ztai-manager');
+const HandoverManager = require('../engine/handover-manager');
+
 class AutoRunner {
   constructor(options = {}) {
     this.phase = options.phase;
     this.isHeadless = options.headless || false;
-    this.auditPath = path.join(process.cwd(), '.planning/AUDIT.jsonl');
-    this.statePath = path.join(process.cwd(), '.planning/auto-state.json');
+    this.auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+    this.statePath = path.join(process.cwd(), '.planning', 'auto-state.json');
     this.monitor = new stuckMonitor(this.auditPath);
     this.isPaused = false;
+    this.handoverManager = new HandoverManager();
+
+    // v5 Governance Initialization
+    this.policyEngine = new PolicyEngine();
+    this.rbacManager  = new RBACManager();
+
+    // v5 PAR Initialization
+    this.refactorer = new ContextRefactorer();
+    this.c2cThreshold = 0.65;
   }
 
   async run() {
@@ -38,10 +54,33 @@ class AutoRunner {
     // 2. Main Wave Loop
     while (await this.hasNextWave()) {
       if (this.isPaused) break;
+      
+      // Pillar 2 (APO): Pre-execution Policy Check
+      const permit = await this.evaluateWavePolicy();
+      if (!permit) {
+        console.error('🛑 POLICY VIOLATION: Execution aborted by Agentic Policy Orchestrator.');
+        this.writeAudit({ event: 'auto_mode_denied', reason: 'Policy violation detected' });
+        break;
+      }
+
+      // Pillar 3 (PAR): Confidence-to-Cost Arbitrage
+      const isReliable = await this.checkArbitrage();
+      if (!isReliable) {
+        console.warn('⚠️ PAR ARBITRAGE: Confidence-to-Cost ratio below threshold. Escalating to human.');
+        this.writeAudit({ event: 'auto_mode_escalated', reason: 'Low C2C ratio' });
+        break;
+      }
+
+      // Pillar 3 (PAR): Context Density Refactoring
+      await this.checkContextDensity();
+
+      // Pillar 7 (DHH): Check for Human Steering
+      await this.checkHumanSteering(isReliable);
+
       await this.executeWave();
     }
 
-    this.complete();
+    await this.complete();
   }
 
   runPreFlight() {
@@ -65,11 +104,20 @@ class AutoRunner {
     this.writeAudit({ event: 'auto_mode_paused', timestamp: new Date().toISOString() });
   }
 
-  complete() {
+  async complete() {
     console.log('✅ Phase complete!');
     const report = progressStream.generateReport(this.auditPath, this.phase);
     fs.writeFileSync(path.join(process.cwd(), `.planning/phases/${this.phase}/AUTONOMOUS-REPORT.md`), report);
     
+    // v5 Pillar 1: Federated Intelligence Mesh (FIM)
+    try {
+      const { runSync } = require('../memory/federated-sync');
+      console.log('🔄 Finalizing organizational intelligence sync...');
+      await runSync();
+    } catch (err) {
+      console.warn('⚠️ Federated Sync failed at phase end:', err.message);
+    }
+    
     // Auto-capture knowledge from completed phase (ADRs, findings)
     try {
       const captured = KnowledgeCapture.captureFromPhaseCompletion(this.phase);
@@ -125,6 +173,108 @@ class AutoRunner {
     Object.assign(state, update);
     fs.writeFileSync(this.statePath, JSON.stringify(state, null, 2));
   }
+
+  /**
+   * Evaluates the policy for the next wave's intent. (v5 APO - HARDENED)
+   */
+  async evaluateWavePolicy() {
+    // [HARDEN] Dynamically derive intent from ZTAI identity and phase context
+    const manager = new ZTAIManager();
+    const identity = await manager.getIdentity();
+    
+    const intent = {
+      did: identity.did,
+      action: 'process_phase_wave',
+      resource: `projects/${process.env.MF_PROJECT_ID || 'MF-ALPHA'}/phases/${this.phase}/*`,
+      tier: identity.tier || 1,
+      metadata: {
+        engine: 'Nimbus-S4',
+        mode: 'autonomous',
+        wave_timestamp: new Date().toISOString()
+      }
+    };
+
+    const result = this.policyEngine.evaluate(intent);
+    
+    if (result.verdict === 'DENY') {
+      console.warn(`[APO-DENY] Intent rejected: ${result.reason} [ReqID: ${result.requestId}]`);
+      return false;
+    }
+
+    console.log(`[APO-PERMIT] Intent approved: ${result.reason} [ReqID: ${result.requestId}]`);
+    return true;
+  }
+
+  /**
+   * Predictive Agentic Reliability (PAR) - C2C Arbitrage
+   */
+  async checkArbitrage() {
+    // Simulated C2C calculation based on recent wave success rate
+    const events = this.getRecentAuditEvents(10);
+    const successCount = events.filter(e => e.status === 'success' || e.event === 'task_completed').length;
+    
+    // Confidence = SuccessRate * 0.8 + 0.2
+    const confidence = (successCount / Math.max(events.length, 1)) * 0.8 + 0.2;
+    const estimatedCost = 0.5; // Placeholder for token cost estimation
+    
+    const c2c = confidence / estimatedCost;
+    console.log(`[PAR-C2C] Confidence: ${confidence.toFixed(2)}, Cost: ${estimatedCost.toFixed(2)}, Ratio: ${c2c.toFixed(2)}`);
+    
+    return c2c >= this.c2cThreshold;
+  }
+
+  /**
+   * Predictive Agentic Reliability (PAR) - Context Refactoring
+   */
+  async checkContextDensity() {
+    const events = this.getRecentAuditEvents(20);
+    const analysis = this.refactorer.analyzeDensity(events);
+    
+    if (analysis.shouldRefactor) {
+      console.log(`[PAR-REFACTOR] Context density low (${analysis.density}). Triggering proactive refactor.`);
+      const refactorEvent = this.refactorer.generateRefactorPlan(events, this.phase);
+      this.writeAudit(refactorEvent);
+      
+      // In a real implementation, this would trigger a system_handoff summarization
+      // For now, we log it to the audit stream for the agent to action
+    }
+  }
+
+  async checkHumanSteering(isReliable) {
+    if (!isReliable) {
+      console.log('[DHH-AUTO] Low reliability detected. Packaging Nexus State Bundle for human review...');
+      const events = this.getRecentAuditEvents(20);
+      const bundlePath = this.handoverManager.createNexusBundle({
+        phase: this.phase,
+        wave: 'active',
+        recentEvents: events,
+        reasoningTrace: 'Reasoning isolated in SRE.'
+      });
+      
+      this.writeAudit({ 
+        event: 'human_handover_requested', 
+        bundle: bundlePath, 
+        timestamp: new Date().toISOString() 
+      });
+    }
+
+    // Check for mid-wave steering instructions if available
+    const steerPath = path.join(process.cwd(), '.planning', 'STEER.json');
+    if (fs.existsSync(steerPath)) {
+      const instructions = fs.readFileSync(steerPath, 'utf8').trim().split('\n');
+      if (instructions.length > 0) {
+        console.log(`[DHH-STEER] Processing ${instructions.length} injected human instructions...`);
+        // Real implementation would inject these into the agent's task list
+        fs.unlinkSync(steerPath); // Clear handled instructions
+      }
+    }
+  }
+
+  getRecentAuditEvents(count) {
+    if (!fs.existsSync(this.auditPath)) return [];
+    const lines = fs.readFileSync(this.auditPath, 'utf8').trim().split('\n');
+    return lines.slice(-count).map(l => JSON.parse(l));
+  }
 }
 
 module.exports = AutoRunner;

package/bin/autonomous/context-refactorer.js

@@ -0,0 +1,64 @@
+/**
+ * MindForge — Context Refactorer Engine (v5.0.0-PAR)
+ * Monitors context density and triggers proactive summarization/refactoring.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class ContextRefactorer {
+  constructor(options = {}) {
+    this.threshold = options.threshold || 0.3; // Min density before refactor
+    this.windowSize = options.windowSize || 20;
+    this.history = [];
+  }
+
+  /**
+   * Analyze the current context density.
+   * Density = (Implementation Events) / (Total Events)
+   */
+  analyzeDensity(events) {
+    this.history = events.slice(-this.windowSize);
+    
+    if (this.history.length < 5) return { density: 1.0, shouldRefactor: false };
+
+    const implementationEvents = this.history.filter(h => 
+      h.tool === 'run_command' || 
+      h.tool === 'replace_file_content' || 
+      h.tool === 'multi_replace_file_content' ||
+      h.event === 'task_completed'
+    );
+
+    const totalEvents = this.history.length;
+    const density = implementationEvents.length / totalEvents;
+
+    return {
+      density: parseFloat(density.toFixed(2)),
+      shouldRefactor: density < this.threshold
+    };
+  }
+
+  /**
+   * Generates a "Context Refactor" recommendation.
+   */
+  generateRefactorPlan(events, phase) {
+    const reasoningChain = events
+      .filter(e => e.event === 'reasoning_trace')
+      .map(e => `- ${e.thought}`)
+      .join('\n');
+
+    return {
+      event: 'context_refactor_triggered',
+      phase,
+      message: 'Context density low. Initiating proactive refactoring.',
+      action: 'SUMMARIZE_AND_RESET',
+      payload: {
+        summary_prompt: `The current reasoning chain has become dense (${this.threshold}). Summarize the progress for Phase ${phase} and reset the active context window.`,
+        trace_sample: reasoningChain.slice(-500) // Last few thoughts for context
+      }
+    };
+  }
+}
+
+module.exports = ContextRefactorer;

package/bin/autonomous/steer.js

@@ -64,8 +64,26 @@ function injectSteering(planContent, guidanceItems) {
   });
 }
 
+/**
+ * Add human steering to the unified queue (v5 Pillar VII).
+ */
+function pushHumanSteering(instruction, bundleId = 'none') {
+  const STEER_PATH = path.join(process.cwd(), '.planning', 'STEER.json');
+  const item = {
+    id: `human-${Date.now()}`,
+    timestamp: new Date().toISOString(),
+    bundle_id: bundleId,
+    type: 'HUMAN_OVERRIDE',
+    instruction,
+    priority: 'CRITICAL'
+  };
+  fs.appendFileSync(STEER_PATH, JSON.stringify(item) + '\n');
+  return item.id;
+}
+
 module.exports = {
   pushGuidance,
   popGuidance,
-  injectSteering
+  injectSteering,
+  pushHumanSteering
 };

package/bin/autonomous/stuck-monitor.js

@@ -26,9 +26,52 @@ class StuckMonitor {
     // Check S02: Command Loop (Identical failing commands)
     if (this.detectS02(event)) return { pattern: 'S02', message: 'Stuck in command loop: identical failing commands.' };
 
+    // Check S03: Semantic Mirroring (Reasoning Loop)
+    if (this.detectS03(event)) return { pattern: 'S03', message: 'Stuck in reasoning loop: semantic mirroring detected.' };
+
+    // Check S04: Infinite Decomposition (Planning Paradox)
+    if (this.detectS04(event)) return { pattern: 'S04', message: 'Stuck in planning paradox: infinite decomposition detected.' };
+
     return null;
   }
 
+  detectS03(event) {
+    if (event.event !== 'reasoning_trace') return false;
+
+    // Compare with the last 5 thoughts in history
+    const reflections = this.history.filter(h => h.event === 'reasoning_trace');
+    if (reflections.length < 3) return false;
+
+    const currentThought = event.thought;
+    const previousThoughts = reflections.slice(-4, -1);
+
+    const isMirroring = previousThoughts.some(p => 
+      this.isContentSimilar(p.thought, currentThought)
+    );
+
+    return isMirroring;
+  }
+
+  detectS04(event) {
+    if (event.event !== 'reasoning_trace') return false;
+
+    const decompositions = this.history.filter(h => 
+      h.event === 'reasoning_trace' && 
+      (h.thought?.toLowerCase().includes('break down') || h.thought?.toLowerCase().includes('sub-task'))
+    );
+
+    // If more than 4 consecutive decompositions without a command or edit
+    const lastActionIndex = this.history.findLastIndex(h => 
+      h.tool === 'run_command' || h.tool === 'replace_file_content' || h.tool === 'multi_replace_file_content'
+    );
+
+    const recentDecomps = decompositions.filter(d => 
+      this.history.indexOf(d) > lastActionIndex
+    );
+
+    return recentDecomps.length >= 4;
+  }
+
   detectS01(event) {
     if (event.tool !== 'multi_replace_file_content') return false;
 

package/bin/engine/feedback-loop.js

@@ -0,0 +1,71 @@
+/**
+ * MindForge — WaveFeedbackLoop (Pillar VI: Proactive Equilibrium)
+ * Monitors divergence during wave execution and triggers self-healing.
+ */
+
+class WaveFeedbackLoop {
+  constructor(config = {}) {
+    this.failureThreshold = config.failureThreshold || 0.20; // 20% failure rate
+    this.divergenceWeight = config.divergenceWeight || 1.5; // Bias for rapid divergence
+    this.waveState = {
+      completed: 0,
+      failed: 0,
+      skipped: 0,
+      total: 0,
+    };
+  }
+
+  /**
+   * Updates the feedback loop with a task result.
+   */
+  update(result) {
+    this.waveState.total++;
+    if (result.status === 'completed') {
+      this.waveState.completed++;
+    } else if (result.status === 'failed') {
+      this.waveState.failed++;
+    } else {
+      this.waveState.skipped++;
+    }
+  }
+
+  /**
+   * 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/bin/engine/handover-manager.js

@@ -0,0 +1,69 @@
+/**
+ * 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');
+
+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 || []
+      },
+      reasoning_snapshot: 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/bin/engine/nexus-tracer.js

@@ -0,0 +1,215 @@
+/**
+ * MindForge Nexus — Core Tracer Engine (v4.1.0-alpha.nexus)
+ *
+ * Handles Agentic Reasoning Tracing (ART) spans and OpenTelemetry-compatible 
+ * trace context propagation across the agentic mesh.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const ztai = require('../governance/ztai-manager');
+const SREManager = require('./sre-manager');
+
+class NexusTracer {
+  constructor(config = {}) {
+    this.projectId = config.projectId || 'mindforge-nexus';
+    this.auditPath = config.auditPath || path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+    this.currentTraceId = null;
+    this.activeSpans = new Map();
+    this.did = config.did || null; // Active Agent DID
+    this.enableZtai = config.enableZtai !== false;
+    this.sreManager = new SREManager();
+
+    // v5 Pillar IV: Agentic SBOM
+    this.sbom = {
+      manifest_version: '1.0.0',
+      models: new Set(),
+      skills: new Set(),
+      startTime: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Initialize or resume a trace.
+   */
+  startTrace(traceId = null) {
+    this.currentTraceId = traceId || `tr_${crypto.randomBytes(8).toString('hex')}`;
+    return this.currentTraceId;
+  }
+
+  /**
+   * Start a new ART span.
+   */
+  startSpan(name, attributes = {}, parentSpanId = null) {
+    const spanId = `sp_${crypto.randomBytes(6).toString('hex')}`;
+    const startTime = new Date().toISOString();
+
+    const span = {
+      id: spanId,
+      trace_id: this.currentTraceId,
+      parent_id: parentSpanId || null,
+      name,
+      status: 'active',
+      start_time: startTime,
+      attributes: {
+        ...attributes,
+        service: 'mindforge-nexus',
+      }
+    };
+
+    this.activeSpans.set(spanId, span);
+
+    // Track model and skill in SBOM if provided in attributes
+    if (attributes.model_id) this.sbom.models.add(attributes.model_id);
+    if (attributes.skill) this.sbom.skills.add(attributes.skill);
+
+    // v5 Pillar VI: Enclave Check
+    if (attributes.is_confidential && !attributes.enclave_id) {
+      try {
+        span.attributes.enclave_id = this.sreManager.initializeEnclave({ 
+          tier: attributes.tier || 1, 
+          did: this.did 
+        });
+      } catch (err) {
+        console.warn(`[NexusTracer] Failed to initialize SRE for confidential span: ${err.message}`);
+      }
+    }
+
+    // Record span start in AUDIT.jsonl
+    this._recordEvent('span_started', { 
+      span_id: spanId, 
+      parent_span_id: parentSpanId,
+      span_name: name,
+      ...attributes,
+      enclave_id: span.attributes.enclave_id
+    });
+
+    return spanId;
+  }
+
+  /**
+   * End an active span.
+   */
+  endSpan(spanId, status = 'success', metadata = {}) {
+    const span = this.activeSpans.get(spanId);
+    if (!span) return;
+
+    span.status = status;
+    span.end_time = new Date().toISOString();
+    
+    // v5 Pillar VI: Enclave Termination
+    if (span.attributes.enclave_id) {
+      this.sreManager.terminateEnclave(span.attributes.enclave_id);
+    }
+
+    this._recordEvent('span_completed', {
+      span_id: spanId,
+      status,
+      ...metadata
+    });
+
+    this.activeSpans.delete(spanId);
+  }
+
+  /**
+   * Record a Reasoning Trace event (ART granularity).
+   */
+  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);
+    }
+
+    this._recordEvent('reasoning_trace', {
+      span_id: spanId,
+      agent,
+      thought: sanitizedThought,
+      resolution
+    });
+  }
+
+  /**
+   * Internal AUDIT writer.
+   */
+  _recordEvent(event, data) {
+    const entry = {
+      id: crypto.randomUUID(),
+      timestamp: new Date().toISOString(),
+      event,
+      trace_id: this.currentTraceId,
+      ...data
+    };
+
+    // ZTAI Signing Logic
+    if (this.enableZtai && this.did) {
+      try {
+        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);
+      } catch (err) {
+        console.warn(`[NexusTracer] ZTAI signing failed: ${err.message}`);
+      }
+    }
+
+    try {
+      if (!fs.existsSync(path.dirname(this.auditPath))) {
+        fs.mkdirSync(path.dirname(this.auditPath), { recursive: true });
+      }
+      fs.appendFileSync(this.auditPath, JSON.stringify(entry) + '\n');
+    } catch (err) {
+      console.error(`[NexusTracer] Failed to write audit entry: ${err.message}`);
+    }
+  }
+
+  /**
+   * Records a FinOps budget decision (Pillar V).
+   */
+  recordFinOps(spanId, decision) {
+    this._recordEvent('finops_decision', {
+      span_id: spanId,
+      ...decision
+    });
+  }
+
+  /**
+   * Records a Self-Healing trigger event (Pillar VI).
+   */
+  recordSelfHeal(spanId, report) {
+    this._recordEvent('self_heal_trigger', {
+      span_id: spanId,
+      ...report
+    });
+  }
+
+  /**
+   * Finalize and export the Agentic SBOM (Pillar IV).
+   */
+  exportSBOM(outputPath = null) {
+    const finalPath = outputPath || path.join(process.cwd(), '.planning', 'MANIFEST.sbom.json');
+    const manifest = {
+      ...this.sbom,
+      models: Array.from(this.sbom.models),
+      skills: Array.from(this.sbom.skills),
+      endTime: new Date().toISOString()
+    };
+
+    try {
+      if (!fs.existsSync(path.dirname(finalPath))) {
+        fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+      }
+      fs.writeFileSync(finalPath, JSON.stringify(manifest, null, 2));
+      
+      this._recordEvent('sbom_exported', { path: finalPath });
+      return finalPath;
+    } catch (err) {
+      console.error(`[NexusTracer] Failed to export SBOM: ${err.message}`);
+      return null;
+    }
+  }
+}
+
+module.exports = NexusTracer;