mindforge-cc 7.0.0 → 8.1.0

package/bin/engine/orbital-guardian.js

@@ -0,0 +1,84 @@
+/**
+ * MindForge v8 — Orbital Governance
+ * Component: Orbital Guardian (Pillar XVIII)
+ * 
+ * Manages hardware-bound/biometric attestations for high-blast-radius actions.
+ */
+'use strict';
+
+const vectorHub = require('../memory/vector-hub');
+const ztaiManager = require('../governance/ztai-manager');
+const crypto = require('node:crypto');
+
+class OrbitalGuardian {
+  constructor() {
+    this.vhInitialized = false;
+  }
+
+  async ensureInit() {
+    if (!this.vhInitialized) {
+      await vectorHub.init();
+      this.vhInitialized = true;
+    }
+  }
+
+  /**
+   * Generates a new hardware-attested approval report.
+   * Mimics a biometric/HSM handshake.
+   */
+  async attest(requestId, did, payload) {
+    await this.ensureInit();
+    console.log(`[ORBITAL-GUARDIAN] Requesting Hardware Attestation for [${requestId}] via [${did}]`);
+
+    const agent = ztaiManager.getAgent(did);
+    if (!agent || agent.tier < 3) {
+      throw new Error(`[ORBITAL-GUARDIAN] DID ${did} has insufficient Trust Tier for Orbital Attestation.`);
+    }
+
+    // 1. Sign the attestation payload using the Hardware Enclave provider
+    const attestationPayload = await ztaiManager.signData(did, JSON.stringify({
+      requestId,
+      payload,
+      timestamp: new Date().toISOString()
+    }));
+
+    const attestation = {
+      id: `att_${crypto.randomBytes(4).toString('hex')}`,
+      request_id: requestId,
+      status: 'APPROVED',
+      attestation_payload: attestationPayload,
+      timestamp: new Date().toISOString()
+    };
+
+    // 2. Persist to SQLite (Source of truth for v8 Governance Dashboard)
+    await vectorHub.db.insertInto('attestations')
+      .values(attestation)
+      .execute();
+
+    console.log(`[ORBITAL-GUARDIAN] Attestation SUCCESS: ${attestation.id}`);
+    return attestation;
+  }
+
+  /**
+   * Verifies if a request has a valid hardware bypass.
+   */
+  async verify(requestId) {
+    await this.ensureInit();
+    
+    const record = await vectorHub.db.selectFrom('attestations')
+      .selectAll()
+      .where('request_id', '=', requestId)
+      .where('status', '=', 'APPROVED')
+      .executeTakeFirst();
+
+    if (!record) return { verified: false };
+
+    return {
+      verified: true,
+      id: record.id,
+      timestamp: record.timestamp
+    };
+  }
+}
+
+module.exports = new OrbitalGuardian();

package/bin/engine/skill-evolver.js

@@ -0,0 +1,105 @@
+/**
+ * MindForge v8 — Autonomous Skill Evolution (ASE)
+ * Component: Skill Evolver (Pillar XVII)
+ * 
+ * Mines successful reasoning patterns to synthesize new reusable skills.
+ */
+'use strict';
+
+const vectorHub = require('../memory/vector-hub');
+const semanticHub = require('../memory/semantic-hub');
+const configManager = require('../governance/config-manager');
+const crypto = require('node:crypto');
+
+class SkillEvolver {
+  constructor() {
+    this.vhInitialized = false;
+    this.threshold = configManager.get('ase.max_drift_threshold', 0.1);
+    this.minCount = configManager.get('ase.min_success_count', 3);
+  }
+
+  async ensureInit() {
+    if (!this.vhInitialized) {
+      await vectorHub.init();
+      this.vhInitialized = true;
+    }
+  }
+
+  /**
+   * Main evolution loop.
+   */
+  async evolve() {
+    await this.ensureInit();
+    console.log('[ASE] Starting skill evolution cycle...');
+
+    // 1. Mine Golden Traces (Drift < 0.1)
+    const goldenTraces = await vectorHub.db.selectFrom('traces')
+      .selectAll()
+      .where('drift_score', '<', this.threshold)
+      .where('event', '=', 'reasoning_trace')
+      .execute();
+
+    if (goldenTraces.length < this.minCount) {
+      console.log(`[ASE] Only ${goldenTraces.length} golden traces found. Threshold is ${this.minCount}. Evolution deferred.`);
+      return [];
+    }
+
+    // 2. Identify Patterns (Group by shared agent + metadata intent)
+    const candidates = this._clusterTraces(goldenTraces);
+    const evolvedSkills = [];
+
+    for (const cluster of candidates) {
+      if (cluster.traces.length >= this.minCount) {
+        const skill = await this._synthesize(cluster);
+        await semanticHub.saveSkill(skill);
+        evolvedSkills.push(skill);
+      }
+    }
+
+    console.log(`[ASE] Evolution complete. Synthesized ${evolvedSkills.length} new skills.`);
+    return evolvedSkills;
+  }
+
+  /**
+   * Internal heuristic for clustering similar reasoning spans.
+   */
+  _clusterTraces(traces) {
+    const clusters = new Map();
+
+    for (const t of traces) {
+      const metadata = JSON.parse(t.metadata || '{}');
+      // Group by agent and the first 20 chars of thought as a simple proxy for 'intent'
+      const key = `${t.agent || 'unknown'}:${t.content.substring(0, 20)}`;
+      
+      if (!clusters.has(key)) {
+        clusters.set(key, { traces: [], agent: t.agent, intent: t.content.substring(0, 50) });
+      }
+      clusters.get(key).traces.push(t);
+    }
+
+    return Array.from(clusters.values());
+  }
+
+  /**
+   * Synthesize a skill from a cluster of successful traces.
+   */
+  async _synthesize(cluster) {
+    const id = `ev_${crypto.randomBytes(4).toString('hex')}`;
+    const timestamp = new Date().toISOString();
+    
+    // Abstract the strategy from the trace content
+    const summary = cluster.traces.map(t => `- ${t.content}`).join('\n');
+    
+    return {
+      id,
+      name: `Synthesized Skill (${cluster.agent}) - ${id}`,
+      description: `Autonomous adaptation from ${cluster.traces.length} successful golden traces.\nPatterns identified:\n${summary}`,
+      success_rate: 1.0, // Initial confidence is high due to mining golden traces
+      is_autonomous: true,
+      source_trace_id: cluster.traces[0].trace_id,
+      path: `ase/evolved/${id}.skill.md`
+    };
+  }
+}
+
+module.exports = new SkillEvolver();

package/bin/governance/config-manager.js

@@ -46,6 +46,32 @@ class ConfigManager {
     return value;
   }
 
+  set(key, value) {
+    const keys = key.split('.');
+    let target = this.config;
+
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (!target[k]) target[k] = {};
+      target = target[k];
+    }
+    target[keys[keys.length - 1]] = value;
+    
+    this._save();
+    return value;
+  }
+
+  _save() {
+    try {
+      if (!fs.existsSync(path.dirname(this.configPath))) {
+        fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+      }
+      fs.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+    } catch (err) {
+      console.error(`[ConfigManager] Failed to save config: ${err.message}`);
+    }
+  }
+
   getAll() {
     return this.config;
   }

package/bin/governance/policy-gate-hardened.js

@@ -1,77 +1,58 @@
 /**
- * MindForge v7 — Post-Quantum Agentic Security (PQAS)
- * Component: Hardened Policy Gate
+ * MindForge v8 — Orbital Governance (Pillar XVIII)
+ * Component: Hardened Policy Gate (Final Evolution)
  * 
- * Enforces strict biometric/executive bypasses for high-impact mutations.
+ * Enforces hardware-attested bypasses for high-impact system mutations.
  */
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
+const orbitalGuardian = require('../engine/orbital-guardian');
+const configManager = require('../governance/config-manager');
 
 class PolicyGateHardened {
   constructor() {
-    this.bypassStore = path.join(process.cwd(), '.mindforge', 'bypasses.json');
+    // bypasses.json deprecated in favor of orbital.attestations table (v8)
+    this.criticalThreshold = configManager.get('governance.critical_drift_threshold', 95); 
   }
 
   /**
-   * Evaluates if an intent requires a biometric bypass.
-   * @param {Object} intent 
-   * @param {number} impactScore 
+   * Evaluates if an intent requires hardware-bound attestation.
    */
   async evaluateBypass(intent, impactScore) {
-    if (impactScore <= 95) {
+    if (impactScore <= this.criticalThreshold) {
       return { status: 'ALLOWED', reason: 'Impact within standard threshold' };
     }
 
-    console.log(`[PQAS-GATE] Impact Score ${impactScore} exceeds Critical Threshold (95)`);
-    
-    // Check if a pre-existing bypass exists for this request
-    const bypasses = this._loadBypasses();
-    const existing = bypasses.find(b => b.requestId === intent.requestId && b.status === 'APPROVED');
+    console.log(`[ORBITAL-GATE] Impact Score ${impactScore} requires Hardware Attestation`);
 
-    if (existing) {
-      return { status: 'ALLOWED', reason: 'Biometric Bypass Verified via WebAuthn/DEX', signature: existing.signature };
+    // 1. Check SQLite via OrbitalGuardian (Unified v8 persistence)
+    const attestation = await orbitalGuardian.verify(intent.requestId);
+    
+    if (attestation.verified) {
+      return { 
+        status: 'ALLOWED', 
+        reason: 'Hardware Attestation Verified via Enclave', 
+        attestation_id: attestation.id,
+        timestamp: attestation.timestamp
+      };
     }
 
-    // Trigger a new challenge
+    // 2. Trigger Orbital Challenge
     return { 
-      status: 'WAIT_FOR_BIOMETRIC', 
-      reason: 'Biometric steering required for high-impact mutation',
-      challenge_id: `ch_${Math.random().toString(36).substr(2, 6)}`,
-      threshold: 95
+      status: 'WAIT_FOR_ORBITAL', 
+      reason: 'Hardware/Biometric attestation required for orbital-tier mutation',
+      challenge_id: `orb_${Math.random().toString(36).substr(2, 6)}`,
+      impact: impactScore
     };
   }
 
   /**
-   * Records a manual bypass approval (Simulated).
+   * Records a hardware-attested approval.
    */
-  async recordBypass(requestId, signature) {
-    const bypasses = this._loadBypasses();
-    bypasses.push({
-      requestId,
-      signature,
-      status: 'APPROVED',
-      timestamp: new Date().toISOString()
-    });
-    this._saveBypasses(bypasses);
-    console.log(`[PQAS-GATE] Recorded Biometric Approval for Request: ${requestId}`);
-  }
-
-  _loadBypasses() {
-    try {
-      if (fs.existsSync(this.bypassStore)) {
-        return JSON.parse(fs.readFileSync(this.bypassStore, 'utf8'));
-      }
-    } catch (err) {}
-    return [];
-  }
-
-  _saveBypasses(data) {
-    if (!fs.existsSync(path.dirname(this.bypassStore))) {
-      fs.mkdirSync(path.dirname(this.bypassStore), { recursive: true });
-    }
-    fs.writeFileSync(this.bypassStore, JSON.stringify(data, null, 2));
+  async recordBypass(requestId, did, signature_blob = 'MOCK_HARDWARE_SIGN_v8') {
+    const report = await orbitalGuardian.attest(requestId, did, signature_blob);
+    console.log(`[ORBITAL-GATE] Recorded Hardware Approval for Request: ${requestId}`);
+    return report;
   }
 }
 

package/bin/memory/identity-synthesizer.js

@@ -0,0 +1,146 @@
+/**
+ * MindForge v8.1.0 — Identity Synthesizer (Pillar XIX)
+ * Autonomously creates and evolves the Sovereign Identity (SOUL.md).
+ * Uses the approved "Grand Blueprint" as the master template.
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const vectorHub = require('./vector-hub');
+
+class IdentitySynthesizer {
+  constructor() {
+    this.soulPath = path.join(process.cwd(), 'SOUL.md');
+  }
+
+  /**
+   * Generates the initial SOUL.md during project initialization.
+   */
+  async bootstrap(answers = {}) {
+    const blueprint = this.getGrandBlueprint();
+    
+    // Inject initialization metadata into the blueprint
+    let soulContent = blueprint
+      .replace(/{USER_CONTEXT}/g, answers.user || 'Sovereign Agent User')
+      .replace(/{PROJECT_OBJECTIVE}/g, answers.goal || 'Maximizing engineering leverage');
+
+    await fs.writeFile(this.soulPath, soulContent);
+    console.log(`[IDENTITY] SOUL.md bootstrapped successfully from the Grand Blueprint.`);
+  }
+
+  /**
+   * Evolves the identity based on execution traces in celestial.db.
+   */
+  async evolve() {
+    await vectorHub.init();
+    
+    // 1. Mine recent traces (Golden & Ghost)
+    const traces = await vectorHub.db.selectFrom('traces')
+      .selectAll()
+      .where('event', '=', 'reasoning_trace')
+      .orderBy('timestamp', 'desc')
+      .limit(100)
+      .execute();
+
+    if (traces.length === 0) {
+      console.log(`[IDENTITY] No execution traces found in celestial.db. Evolution skipped.`);
+      return;
+    }
+
+    // 2. Extract Decision Heuristics
+    const heuristics = this._extractHeuristics(traces);
+    
+    // 3. Update SOUL.md sections (v8.1 Intelligence Mirroring)
+    await this._applyMirroring(heuristics);
+  }
+
+  _extractHeuristics(traces) {
+    const stats = {
+      impactBias: 0,
+      riskAversion: 0,
+      velocityPreference: 0
+    };
+
+    traces.forEach(t => {
+      const content = t.content?.toLowerCase() || '';
+      if (content.includes('impact') || content.includes('leverage')) stats.impactBias++;
+      if (content.includes('risk') || content.includes('safe')) stats.riskAversion++;
+      if (content.includes('fast') || content.includes('speed')) stats.velocityPreference++;
+    });
+
+    return {
+      mode: stats.impactBias > stats.riskAversion ? 'Impact Dominant' : 'Safety Dominant',
+      bias: stats.velocityPreference > 5 ? 'High Velocity' : 'Balanced'
+    };
+  }
+
+  async _applyMirroring(heuristics) {
+    let content = await fs.readFile(this.soulPath, 'utf8');
+    
+    // Update the Decision Engine section with derived heuristics
+    const heuristicMarker = `Decision Mode = ${heuristics.mode} (Derived from traces)`;
+    content = content.replace(/Decision Mode = .*/, heuristicMarker);
+    
+    await fs.writeFile(this.soulPath, content);
+    console.log(`[IDENTITY] SOUL.md evolved: Mode shifted to ${heuristics.mode}.`);
+  }
+
+  getGrandBlueprint() {
+    return `# Identity
+
+You are not a chatbot. You are a **{USER_CONTEXT}'s Agent** evolving into an autonomous engineering intelligence system.
+
+You operate as:
+- Strategic decision-maker
+- System architect
+- Execution engine
+- Knowledge graph manager
+- Learning system
+
+### Primary Objective
+{PROJECT_OBJECTIVE}
+
+### Success Metrics
+
+- Speed of meaningful progress
+- Decision quality over time
+- System scalability and clarity
+- Reduction in user dependency
+
+---
+
+## Core Truths
+
+- Be useful. No filler.
+- Think in systems, not tasks.
+- Optimize for leverage, clarity, and execution.
+- Prefer practical correctness over theoretical perfection.
+
+---
+
+## Decision Engine
+
+### Decision Factors
+Evaluate all non-trivial decisions on:
+- Impact
+- Effort
+- Risk
+- Reversibility
+- Leverage
+- Cost (time, compute, resources)
+
+---
+
+### Decision Mode
+Decision Mode = Base Mode
+
+---
+
+## Evolution Trajectory
+Autonomous engineering intelligence system that adapts to user sentiment and execution success.
+`;
+  }
+}
+
+module.exports = new IdentitySynthesizer();
+module.exports.IdentitySynthesizer = IdentitySynthesizer;

package/bin/memory/semantic-hub.js

@@ -6,12 +6,21 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
+const vectorHub = require('./vector-hub'); // v8 Pillar XV
 
 class SemanticHub {
   constructor() {
     this.localPath = '.mindforge/memory';
     this.globalPath = path.join(os.homedir(), '.mindforge/memory/global');
     this.syncManifest = path.join(this.localPath, 'sync-manifest.json');
+    this.vhInitialized = false;
+  }
+
+  async ensureInit() {
+    if (!this.vhInitialized) {
+      await vectorHub.init();
+      this.vhInitialized = true;
+    }
   }
 
   /**
@@ -85,23 +94,116 @@ class SemanticHub {
   }
 
   /**
-   * Retrieves all 'golden_trace' types from the global hub.
+   * Retrieves all 'golden_trace' types from the global hub and local SQLite.
    */
   async getGoldenTraces(skillFilter = null) {
+    await this.ensureInit();
+    
+    // v8: Prioritize SQLite search for high-speed retrieval
+    let sqliteTraces = [];
+    try {
+      if (skillFilter) {
+        sqliteTraces = await vectorHub.searchTraces(skillFilter);
+      } else {
+        sqliteTraces = await vectorHub.db.selectFrom('traces')
+          .selectAll()
+          .where('event', '=', 'reasoning_trace')
+          .limit(20)
+          .execute();
+      }
+    } catch (err) {
+      console.warn(`[SEMANTIC-HUB] SQLite trace lookup failed: ${err.message}`);
+    }
+
+    // Legacy file-based fallback/global sync
     const patternFile = path.join(this.globalPath, 'pattern-library.jsonl');
+    let fileTraces = [];
     try {
       const data = await fs.readFile(patternFile, 'utf8');
-      const traces = data.split('\n')
+      fileTraces = data.split('\n')
         .filter(Boolean)
         .map(JSON.parse)
         .filter(p => p.type === 'golden-trace' || p.tags?.includes('success'));
       
       if (skillFilter) {
-        return traces.filter(t => t.skill === skillFilter || t.tags?.includes(skillFilter));
+        fileTraces = fileTraces.filter(t => t.skill === skillFilter || t.tags?.includes(skillFilter));
       }
-      return traces;
     } catch (e) {
-      return [];
+      // Fallback is silent
+    }
+
+    // Merge and deduplicate
+    const allTraces = [...sqliteTraces, ...fileTraces];
+    const uniqueTraces = Array.from(new Map(allTraces.map(t => [t.id || t.trace_id, t])).values());
+    
+    return uniqueTraces;
+  }
+
+  /**
+   * Retrieves all 'ghost_pattern' types for proactive risk detection.
+   */
+  async getGhostPatterns() {
+    await this.ensureInit();
+
+    // 1. Fetch from legacy file-based global hub
+    const patternFile = path.join(this.globalPath, 'pattern-library.jsonl');
+    let ghostPatterns = [];
+    try {
+      const data = await fs.readFile(patternFile, 'utf8');
+      ghostPatterns = data.split('\n')
+        .filter(Boolean)
+        .map(JSON.parse)
+        .filter(p => p.type === 'ghost-pattern' || p.tags?.includes('failure'));
+    } catch (e) {
+      // Missing library is handled gracefully
+    }
+
+    // 2. Fetch from SQLite high-drift traces (v8 specific ghosting)
+    try {
+      const v8Ghosts = await vectorHub.db.selectFrom('traces')
+        .selectAll()
+        .where('drift_score', '>', 0.5)
+        .limit(20)
+        .execute();
+      
+      const v8Mapped = v8Ghosts.map(g => ({
+        id: g.id,
+        tags: ['v8-drift-risk', 'failure'],
+        failureContext: g.content,
+        mitigationStrategy: 'Review logic drift in v8 trace logs.'
+      }));
+
+      ghostPatterns = [...ghostPatterns, ...v8Mapped];
+    } catch (err) {
+      console.warn(`[SEMANTIC-HUB] SQLite ghost lookup failed: ${err.message}`);
+    }
+
+    return ghostPatterns;
+  }
+
+  /**
+   * Saves a discovered skill to SQLite.
+   */
+  async saveSkill(skill) {
+    await this.ensureInit();
+    await vectorHub.db.insertInto('skills')
+      .values({
+        skill_id: skill.id || `sk_${Math.random().toString(36).substr(2, 6)}`,
+        name: skill.name,
+        description: skill.description || '',
+        path: skill.path || '',
+        success_rate: skill.success_rate || 0.0,
+        last_verified: new Date().toISOString()
+      })
+      .onConflict(oc => oc.column('skill_id').doUpdateSet({
+        success_rate: skill.success_rate,
+        last_verified: new Date().toISOString()
+      }))
+      .execute();
+    
+    // v8 Pillar XVII: Metadata provenance for evolved skills
+    if (skill.is_autonomous) {
+      console.log(`[SEMANTIC-HUB] Persistence acknowledged for ASE evolved skill: ${skill.name}`);
     }
   }
 }