mindforge-cc 5.6.0 → 6.0.0-alpha

package/MINDFORGE.md

@@ -1,12 +1,12 @@
-# MINDFORGE.md — Parameter Registry (v5.1.0-beast)
+# MINDFORGE.md — Parameter Registry (v6.2.0-alpha)
 
 ## 1. IDENTITY & VERSIONING
 
 [NAME]    = MindForge
-[VERSION] = 5.1.0
-[STABLE]  = true
+[VERSION] = 6.2.0-alpha
+[STABLE]  = false
 [MODE]    = "Zero-Trust Agentic Hub"
-[REQUIRED_CORE_VERSION] = 5.1.0
+[REQUIRED_CORE_VERSION] = 6.2.0
 
 ## 2. INTELLIGENCE TOGGLES (V4 UPDATES)
 
@@ -21,8 +21,11 @@
 [RAG_2_AUTO_SHADOW] = true
 [ENABLE_ART_TRACING] = true
 [ENABLE_ZTAI] = true
-[ZTAI_KEY_TYPE] = "Ed25519"
+[ZTAI_KEY_TYPE] = "Dilithium-5"
 [NEXUS_TRACE_RETENTION_DAYS] = 30
+[CADIA_CORE] = true
+[PQAS_ENFORCED] = true
+[PROACTIVE_HOMING] = true
 
 ---
 

package/README.md

@@ -1,7 +1,38 @@
-# MindForge v5.1.0 — The Beast AdditionFramework (v5.1.0)
+# MindForge v6.2.0 Alpha — Sovereign Intelligence (PQAS & Homing)
 
-MindForge turns AI coding agents into production-grade engineering partners with governance, multi-cloud resilience, and a non-bypassable Sovereign Reason Enclave.
-Release published: v5.1.0-PRO.
+MindForge v6.2.0 Alpha achieves the **Sovereign Intelligence** final stage, introducing post-quantum safe identities and proactive agentic homing through **Post-Quantum Agentic Security (PQAS)** and **Proactive Semantic Homing**.
+
+## What's new in v6.2 Alpha (Sovereign Intelligence)
+
+MindForge V6.2 Alpha completes the "Sovereign" pillars, hardening the mesh against future threats and eliminating reactive latency.
+
+- **Pillar XI: Post-Quantum Agentic Security (PQAS)**: Lattice-based (Dilithium-5) signatures and ZK-Proof bypasses for Tier 4 agent identities.
+- **Pillar XII: Proactive Semantic Homing**: Autonomous "Intent Hunting" where agents proactively claim tasks and peer-heal logic drift (>80) in the mesh.
+- **Edge-Case Biometrics**: Hardware-locked governance requiring manual `APPROVED_BY_EXECUTIVE` steering for catastrophic-risk operations (>95 Blast Radius).
+- **Quantum-Safe Key Provider**: Integrated lattice cryptography in the `ZTAIManager` for verifiable, future-proof identity.
+- **Mesh Self-Healer**: Real-time collaborative reasoning recovery for drifting autonomous nodes.
+
+## What's new in v6.0 Alpha (CADIA Optimizer)
+
+MindForge V6.0 Alpha introduces the **Neural Blast Radius Optimizer**, transforming how the framework evaluates architectural risk in real-time.
+
+- **CADIA Engine (Pillar II Upgrade)**: Dynamic risk scoring (0-100) based on file influence, session history, and goal alignment.
+- **Session Entropy Guardrails**: Prevents "Rogue Wave" mass-corruption by increasing risk scores logarithmically as an agent touches more files.
+- **Goal-Path Alignment**: Cross-references every intent against the "Current Phase" in `STATE.md`, flagging anomalous files outside the active mission.
+- **Tier 3 Reasoning Proof Bypass**: Senior agents can override high-risk blocks (score > 80) by providing a cryptographically signed "Reasoning Proof."
+- **Enterprise RISK-AUDIT**: Persistent, high-fidelity compliance logging of every policy decision to `.planning/RISK-AUDIT.jsonl`.
+
+## What's new in v5.10 (Nexus Steering & AgRevOps)
+
+MindForge V5.10 completes the "Hyper-Enterprise" evolution, transforming the dashboard into a high-fidelity control center for temporal debugging and financial governance.
+
+- **Interactive Temporal Steering (Pillar VII)**: The 'Time-Travel' slider allows real-time navigation of historical snapshots. Inspect reasoning traces at any point in space-time and inject 'Hindsight Steering Vectors' to correct agentic drift.
+- **AgRevOps ROI Engine (Pillar VIII)**: Automated calculation of economic value ($100/hr dev saving vs token costs). Tracks cumulative savings and net agentic ROI for the entire swarm.
+- **Velocity Forecaster**: Statistical ETA prediction for milestones based on live task completion velocity.
+- **Governance Debt Monitor**: Security Health Score tracking that flags policy bypasses and critical findings in the audit trail.
+- **Nexus Dashboard v2.0**: Major UI upgrade with dedicated Temporal and RevOps tabs, featuring real-time gauges and reasoning inspectors.
+
+## What's new in v5.9 (Beast Mode Hardening)
 
 ## Installation & Setup
 
@@ -36,17 +67,22 @@ npx mindforge-cc@latest --claude --local
 AI coding agents degrade over long sessions. Context fills up. Quality drops.
 Decisions get forgotten. MindForge fixes that with:
 
-- **Multi-Cloud Arbitrage (v5.0)** — Dynamic routing and provider hedging with low-latency arbitrage.
-- **Sovereign Reason Enclave (v5.0)** — TEE-simulated reasoning isolation and sanitization for confidential workloads.
+- **Sovereign Reason Enclave (v5.8)** — TEE-simulated reasoning isolation with Zero-Knowledge (ZK) Audit Trails.
+- **Multi-Cloud Arbitrage (v5.7)** — Dynamic routing across Vertex AI, Bedrock, and Azure with intelligence-first task affinity.
+- **Sentinel Execution (v5.6)** — JIT Binary Runtime Attestation and Zero-Trust Skill Enforcement.
+- **Interactive Temporal Steering (v5.10)** — Full history scrubbing, hindsight state repair, and real-time temporal slider navigation.
+- **AgRevOps Hub (v5.10)** — Dynamic ROI tracking ($100/hr mapping), Milestone Velocity forecasting, and Governance Debt monitoring.
+- **Sovereign Reason Enclave (v5.8)** — TEE-simulated reasoning isolation with Zero-Knowledge (ZK) Audit Trails.
+- **Multi-Cloud Arbitrage (v5.7)** — Dynamic routing across Vertex AI, Bedrock, and Azure with intelligence-first task affinity.
+- **Sentinel Execution (v5.6)** — JIT Binary Runtime Attestation and Zero-Trust Skill Enforcement.
 - **Human-Agent Handover (v5.0)** — Nexus State Bundles and mid-wave steering injection.
-- **Autonomous FinOps (v4.3)** — Dynamic **C2C** (Confidence-to-Cost) routing and Agentic ROI tracking.
+- **Autonomous FinOps (v4.3)** — Dynamic **C2C** (Confidence-to-Cost) routing.
 - **Proactive Equilibrium (v4.3)** — Real-time **Wave Divergence** monitoring and autonomous state recovery.
 - **MindForge Nexus (v4.1)** — High-fidelity **ART** (Agentic Reasoning Tracing).
 - **Zero-Trust Identity (v4.2)** — DID-signed non-repudiable audit logs with HSM/Enclave support.
 - **Global Intelligence Mesh (v4.2)** — Cross-repo knowledge sharing and Ghost Pattern Detection.
 - **Context Sharding (v3)** — relevance-dense memory management (40% token savings)
 - **Adversarial Synthesis (v3)** — zero-drift logic through red/blue model debate
-- **Temporal Vision (v3)** — full history scrubbing and hindsight state repair
 - **RAG 2.0 (v3)** — automatic semantic shadowing for background pattern retrieval
 - **Role personas** — specialised agent modes for each task type
 - **Specialized Identities** — custom `/agents/` workspace with enriched `IDENTITY.md` protocols
@@ -292,6 +328,30 @@ See `.mindforge/production/token-optimiser.md`.
 
 ---
 
+## What's new in v5.8 (Sovereign Reason Enclaves)
+
+MindForge V5.8 implements the sixth pillar of the Hyper-Enterprise roadmap: **Sovereign Reason Enclaves with ZK-Audit**.
+
+- **ZK-Proof Compliance Certificates**: Simulated zero-knowledge proofs (signed by System DID) for SRE sessions, proving policy adherence without exposing thoughts.
+- **Privacy-Preserving Auditing**: `NexusTracer` replaces raw reasoning with verifiable certificates in the global audit log.
+- **Enclave Verification**: Cryptographic verification of enclave sessions via `verifyZKProof`.
+
+## What's new in v5.7 (Multi-Cloud Arbitrage)
+
+MindForge V5.7 implements the fifth pillar of the Hyper-Enterprise roadmap: **Multi-Cloud Arbitrage with Task-to-Model Affinity**.
+
+- **Task Affinity Matrices**: Persistent tracking of model success rates by task taxonomy (e.g., Anthropic for refactoring, Google for research).
+- **Intelligence-First Routing**: Scoring weighted 50% on success probability, ensuring the best model for the job.
+- **Feedback Integration**: Automated performance updates via the implementation feedback loop.
+
+## What's new in v5.6 (Sentinel Execution)
+
+MindForge V5.6 completes the "Hyper-Enterprise" roadmap with two critical security and reliability pillars.
+
+- **Binary Runtime Attestation (ZTS)**: Cryptographically sign skills using HSM-secured identities. The `SkillValidator` now performs JIT verification, blocking tampered or unauthorized skills from loading.
+- **Reasoning Entropy Monitoring (PAR)**: The `NexusTracer` now calculates **RES (Reasoning Entropy Scoring)**. If an agent falls into a semantic loop or circular reasoning, the system proactively generates a **Steering Vector** to break the loop and recover the execution wave.
+- **Sentinel Hardening**: Enhanced `NexusTracer` with SRE-aware audit integrity and Merkle-root cumulative hash chains.
+
 ## What's new in v4.3 (Enterprise Mesh & Equilibrium)
 
 MindForge V4.3 matures the framework for enterprise mission-critical environments.

package/RELEASENOTES.md

@@ -1,4 +1,57 @@
-# MindForge v5.4.0 — Beast Mode Hardening
+# MindForge v6.0.0-alpha — AgRevOps ROI Engine (Enterprise Value)
+
+## Top Summary
+
+The v6.0.0-alpha release introduces the final pillar of the MindForge Enterprise architecture: AgRevOps (Agentic Revenue Operations). This engine provides real-time ROI attribution for autonomous waves, enabling enterprises to quantify the business value of every agentic reasoning cycle.
+
+## Highlights (v6.0.0-alpha)
+
+- **AgRevOps ROI Engine**: Real-time value attribution for autonomous task execution.
+- **ROI Telemetry**: New `roi-telemetry.jsonl` stream for tracking cost efficiency vs. outcome quality.
+- **Nexus Steering Sync**: Final synchronization of the `NexusTracer` and `NexusSteering` protocols into the core execution loop.
+- **Protocol Automation**: Automated activation of `_extended` mindforge skills via the Neural Orchestrator.
+
+---
+
+# MindForge v5.9.0 — Beast Mode Hardening (Nexus Unification)
+
+## Top Summary
+
+The v5.9.0 release elevates the MindForge Enterprise architecture to "Beast Mode" by unifying the tracing infrastructure into a single, high-fidelity asynchronous ART protocol and hardening the governance and arbitrage pillars with advanced cryptographic and resilience patterns.
+
+## Highlights (v5.9.0)
+
+- **Unified NexusTracer Singleton**: Migration of all tracing and reasoning capture to `bin/engine/nexus-tracer.js`. Standardized as a singleton with mandatory `async` methods to support ZTAI cryptographic signing.
+- **Merkle-Style Audit Integrity**: Hardened SRE and ZTAI logs with Merkle-root cumulative hash chains, ensuring every audit entry is cryptographically linked to the entire session history.
+- **MCA Circuit Breakers**: Stateful provider blacklisting in `CloudBroker` that automatically disables failing models for 10 minutes after 3 consecutive errors.
+- **Intelligence Metrics Decay**: Historical performance data now favors recent trends via a 0.95 decay factor, ensuring routing adaptivity.
+- **Async Test Suite**: 100% restoration of the core test suite (Nexus, SRE, RES) for the new asynchronous execution model.
+
+---
+
+# MindForge v5.8.0 — Sovereign Reason Enclaves (ZK-Audit)
+## Top Summary
+The v5.8.0 release implements the sixth pillar of the Hyper-Enterprise roadmap: Sovereign Reason Enclaves with Zero-Knowledge (ZK) Audit Trails. This enables agents to provide cryptographic proof of policy adherence for confidential reasoning without exposing proprietary content to global logs.
+
+## Highlights
+- **ZK-Proof Compliance Certificates**: Simulated zero-knowledge proofs (DID-signed) for SRE sessions.
+- **Privacy-Preserving Auditing**: `NexusTracer` replaces raw thought traces with verifiable certificates for isolated tasks.
+- **Enclave Verification**: New `verifyZKProof` utility for non-custodial audit integrity checks.
+
+---
+
+# MindForge v5.7.0 — Multi-Cloud Arbitrage (Affinity Routing)
+## Top Summary
+The v5.7.0 release implements the fifth pillar of the Hyper-Enterprise roadmap: Multi-Cloud Arbitrage with Task-to-Model Affinity Routing. Routing is now intelligence-first, mapping task taxonomies to providers with the highest historical success rates.
+
+## Highlights
+- **Task-to-Model Affinity Matrices**: Persistent tracking of success probability per model and task type (refactor, test, audit, etc.).
+- **Intelligence-First Routing**: `CloudBroker` weights routing scoring by success probability (50% weight) alongside cost (30%) and latency (20%).
+- **Feedback Loop Integration**: Automated updates to performance metrics via `WaveFeedbackLoop` completions.
+
+---
+
+# MindForge v5.6.0 — Sentinel Execution
 ## Top Summary
 The v5.4.0 release elevates the "Hyper-Enterprise" features to maximum robustness ("Beast Mode"), implementing critical safety systems, automated blast-radius protection for sensitive files, and advanced failure telemetry.
 

package/SECURITY.md

@@ -2,3 +2,41 @@
 
 Please see `docs/security/SECURITY.md` for the full security policy,
 reporting process, and supported versions.
+
+
+# 1. Publish v6.0.0-alpha
+git checkout v6.0.0-alpha
+npm publish --tag alpha --cache /tmp/npm-cache
+
+# 2. Publish v6.1.0-alpha
+git checkout v6.1.0-alpha
+npm publish --tag alpha --cache /tmp/npm-cache
+
+# 3. Publish v6.2.0-alpha (Final)
+git checkout feature/mindforge-docs
+npm publish --tag alpha --cache /tmp/npm-cache
+
+# 1. Re-login (this will prompt for 2FA in the browser or CLI)
+npm login
+
+# 2. Then try publishing again
+npm publish --tag alpha --cache /tmp/npm-cache
+
+git checkout v6.0.0-alpha
+npm publish --tag alpha --cache /tmp/npm-cache --otp=YOUR_CODE
+
+
+# Replace YOUR_TOKEN with the npm_... token you just generated
+export NPM_TOKEN=YOUR_TOKEN
+
+# 1. Publish v6.0.0-alpha
+git checkout v6.0.0-alpha
+npm publish --tag alpha --cache /tmp/npm-cache --//registry.npmjs.org/:_authToken=$NPM_TOKEN
+
+# 2. Publish v6.1.0-alpha
+git checkout v6.1.0-alpha
+npm publish --tag alpha --cache /tmp/npm-cache --//registry.npmjs.org/:_authToken=$NPM_TOKEN
+
+# 3. Publish v6.2.0-alpha (Final)
+git checkout feature/mindforge-docs
+npm publish --tag alpha --cache /tmp/npm-cache --//registry.npmjs.org/:_authToken=$NPM_TOKEN

package/bin/autonomous/auto-runner.js

@@ -14,6 +14,8 @@ const headlessAdapter = require('./headless');
 const ContextRefactorer = require('./context-refactorer');
 const KnowledgeCapture = require('../memory/knowledge-capture');
 const TemporalHub = require('../engine/temporal-hub');
+const IntentHarvester = require('./intent-harvester');
+const MeshSelfHealer = require('./mesh-self-healer');
 const crypto = require('crypto');
 
 // MindForge v5 Core Modules
@@ -161,6 +163,18 @@ class AutoRunner {
 
   handleStuck(result) {
     console.error(`🛑 STUCK PATTERN DETECTED: ${result.pattern} - ${result.message}`);
+    
+    // v7: Mesh Self-Healing (Pillar XII)
+    if (result.driftScore > 80) {
+      console.log(`[HOMING-REPAIR] Stuck pattern with high drift detected. Invoking Mesh Self-Healer...`);
+      const repairPlan = MeshSelfHealer.homeIn(result.did || 'auto-runner', result.driftScore);
+      if (repairPlan) {
+        this.writeAudit({ event: 'mesh_healing_active', plan: repairPlan });
+        // In a real system, this would modify the execution DAG to include the repair wave
+        return; 
+      }
+    }
+
     this.writeAudit({ event: 'auto_mode_escalated', reason: result.message });
     process.exit(10);
   }

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();