mindforge-cc 7.0.0 → 8.0.0

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/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}`);
     }
   }
 }

package/bin/memory/vector-hub.js

@@ -0,0 +1,170 @@
+const Database = require('better-sqlite3');
+const { Kysely, SqliteDialect, sql } = require('kysely');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * MindForge v8 VectorHub
+ * Unified Persistence Layer for Trace, Remediation, and Skill data.
+ */
+class VectorHub {
+  constructor(dbPath = null) {
+    this.dbPath = dbPath || path.join(process.cwd(), '.mindforge', 'celestial.db');
+    this._ensureDir();
+    
+    const nativeDb = new Database(this.dbPath);
+    this.db = new Kysely({
+      dialect: new SqliteDialect({
+        database: nativeDb,
+      }),
+    });
+    
+    this.initialized = false;
+  }
+
+  _ensureDir() {
+    const dir = path.dirname(this.dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Initialize tables and FTS5 search.
+   */
+  async init() {
+    if (this.initialized) return;
+
+    // Traces Table
+    await this.db.schema
+      .createTable('traces')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('trace_id', 'text', (col) => col.notNull())
+      .addColumn('span_id', 'text')
+      .addColumn('event', 'text', (col) => col.notNull())
+      .addColumn('timestamp', 'text', (col) => col.notNull())
+      .addColumn('agent', 'text')
+      .addColumn('content', 'text')
+      .addColumn('metadata', 'text') // JSON blob
+      .addColumn('drift_score', 'real')
+      .addColumn('mesh_node_id', 'text') // v8 Pillar XVI
+      .execute();
+
+    // v8 Migration: ensure mesh_node_id exists on existing table
+    try {
+      await sql`ALTER TABLE traces ADD COLUMN mesh_node_id TEXT`.execute(this.db);
+    } catch (e) {
+      // Column might already exist, ignore error.
+    }
+
+    // Remediations Table
+    await this.db.schema
+      .createTable('remediations')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('trace_id', 'text', (col) => col.notNull())
+      .addColumn('strategy', 'text', (col) => col.notNull())
+      .addColumn('status', 'text', (col) => col.notNull())
+      .addColumn('timestamp', 'text', (col) => col.notNull())
+      .addColumn('outcome', 'text')
+      .execute();
+
+    // Skills Table
+    await this.db.schema
+      .createTable('skills')
+      .ifNotExists()
+      .addColumn('skill_id', 'text', (col) => col.primaryKey())
+      .addColumn('name', 'text', (col) => col.notNull())
+      .addColumn('description', 'text')
+      .addColumn('path', 'text')
+      .addColumn('success_rate', 'real', (col) => col.defaultTo(0.0))
+      .addColumn('last_verified', 'text')
+      .execute();
+
+    // Attestations Table (v8 Pillar XVIII)
+    await this.db.schema
+      .createTable('attestations')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('request_id', 'text', (col) => col.notNull())
+      .addColumn('status', 'text', (col) => col.notNull()) // APPROVED / REJECTED
+      .addColumn('attestation_payload', 'text') // Signed blob from hardware enclave
+      .addColumn('timestamp', 'text', (col) => col.notNull())
+      .execute();
+
+    // Config Table
+    await this.db.schema
+      .createTable('mesh_config')
+      .ifNotExists()
+      .addColumn('key', 'text', (col) => col.primaryKey())
+      .addColumn('value', 'text')
+      .execute();
+
+    // Enable Full-Text Search for traces (FTS5)
+    await sql`
+      CREATE VIRTUAL TABLE IF NOT EXISTS traces_search 
+      USING fts5(trace_id, content, agent, tokenize='porter');
+    `.execute(this.db);
+
+    this.initialized = true;
+    console.log(`[VectorHub] Initialized SQLite persistence at ${this.dbPath}`);
+  }
+
+  async close() {
+    await this.db.destroy();
+  }
+
+  /**
+   * Record a trace event.
+   */
+  async recordTrace(data) {
+    const entry = {
+      id: data.id || Math.random().toString(36).substr(2, 9),
+      trace_id: data.trace_id,
+      span_id: data.span_id || null,
+      event: data.event,
+      timestamp: data.timestamp || new Date().toISOString(),
+      agent: data.agent || null,
+      content: data.content || null,
+      metadata: data.metadata ? JSON.stringify(data.metadata) : null,
+      drift_score: data.drift_score || 0,
+      mesh_node_id: data.mesh_node_id || null
+    };
+
+    await this.db.insertInto('traces')
+      .values(entry)
+      .onConflict(oc => oc.column('id').doUpdateSet({
+        metadata: entry.metadata,
+        mesh_node_id: entry.mesh_node_id,
+        drift_score: entry.drift_score
+      }))
+      .execute();
+    
+    // Update FTS5 index if content exists
+    if (entry.content) {
+      await sql`INSERT INTO traces_search (trace_id, content, agent) VALUES (${entry.trace_id}, ${entry.content}, ${entry.agent})`
+        .execute(this.db);
+    }
+    
+    return entry.id;
+  }
+
+  /**
+   * Semantic search for previous traces.
+   */
+  async searchTraces(query) {
+    const results = await sql`
+        SELECT t.*, ts.rank 
+        FROM traces t
+        JOIN traces_search ts ON t.trace_id = ts.trace_id
+        WHERE traces_search MATCH ${query}
+        ORDER BY ts.rank
+        LIMIT 10
+      `.execute(this.db);
+    return results.rows;
+  }
+}
+
+module.exports = new VectorHub();
+module.exports.VectorHub = VectorHub;

package/bin/migrations/v8-sqlite-migration.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+const vectorHub = require('../memory/vector-hub');
+
+/**
+ * MindForge v8 SQLite Migration Script
+ * Migrates legacy .json and .jsonl state into VectorHub.
+ */
+async function runMigration() {
+  console.log('[MIGRATION] Starting MindForge v8 (Celestial) SQLite migration...');
+  
+  await vectorHub.init();
+
+  // 1. Migrate Remediation Queue
+  const remPath = path.join(process.cwd(), '.mindforge', 'remediation-queue.json');
+  if (fs.existsSync(remPath)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(remPath, 'utf8'));
+      console.log(`[MIGRATION] Migrating ${data.length} remediations...`);
+      for (const rem of data) {
+        await vectorHub.db.insertInto('remediations')
+          .values({
+            id: rem.remediation_id,
+            trace_id: rem.span_id, // Mapping span_id to trace_id for legacy compatibility
+            strategy: rem.strategy,
+            status: rem.status,
+            timestamp: rem.timestamp || new Date().toISOString(),
+            outcome: rem.status === 'SUCCESS' ? 'Legacy Success' : null
+          })
+          .onConflict(oc => oc.column('id').doNothing())
+          .execute();
+      }
+    } catch (err) {
+      console.warn(`[MIGRATION] Failed to migrate remediations: ${err.message}`);
+    }
+  }
+
+  // 2. Migrate Audit Traces (AUDIT.jsonl)
+  const auditPath = path.join(process.cwd(), '.planning', 'AUDIT.jsonl');
+  if (fs.existsSync(auditPath)) {
+    try {
+      const lines = fs.readFileSync(auditPath, 'utf8').split('\n').filter(Boolean);
+      console.log(`[MIGRATION] Migrating ${lines.length} audit trace lines...`);
+      
+      for (const line of lines) {
+        const entry = JSON.parse(line);
+        if (entry.event === 'reasoning_trace' || entry.event === 'drift_remediation_event') {
+          await vectorHub.recordTrace({
+            id: entry.id,
+            trace_id: entry.trace_id || 'legacy_trace',
+            span_id: entry.span_id || null,
+            event: entry.event,
+            timestamp: entry.timestamp,
+            agent: entry.agent || null,
+            content: entry.thought || entry.strategy || null,
+            metadata: entry,
+            drift_score: entry.drift_score || 0
+          });
+        }
+      }
+    } catch (err) {
+      console.warn(`[MIGRATION] Failed to migrate audit traces: ${err.message}`);
+    }
+  }
+
+  // 3. Set Mesh Node Identity
+  await vectorHub.db.insertInto('mesh_config')
+    .values({ key: 'mesh_node_id', value: `mindforge-node-${Math.random().toString(36).substr(2, 6)}` })
+    .onConflict(oc => oc.column('key').doNothing())
+    .execute();
+
+  await vectorHub.db.insertInto('mesh_config')
+    .values({ key: 'v8_migration_complete', value: new Date().toISOString() })
+    .onConflict(oc => oc.column('key').doNothing())
+    .execute();
+
+  console.log('[MIGRATION] MindForge v8 Migration Successful.');
+  await vectorHub.close();
+}
+
+if (require.main === module) {
+  runMigration().catch(console.error);
+}
+
+module.exports = runMigration;

package/bin/revops/remediation-queue.js

@@ -9,10 +9,18 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+const vectorHub = require('../memory/vector-hub');
+
 class RemediationQueue {
   constructor() {
-    this.queuePath = path.join(process.cwd(), '.mindforge', 'remediation-queue.json');
-    this.queue = this._loadQueue();
+    this.initialized = false;
+  }
+
+  async ensureInit() {
+    if (!this.initialized) {
+      await vectorHub.init();
+      this.initialized = true;
+    }
   }
 
   /**
@@ -34,49 +42,65 @@ class RemediationQueue {
    * Adds a new task to the remediation queue.
    */
   async enqueue(task) {
+    await this.ensureInit();
     const entry = {
       ...task,
       enqueued_at: new Date().toISOString(),
       status: 'PENDING'
     };
     
-    this.queue.push(entry);
-    this._persist();
+    await vectorHub.db.insertInto('remediations')
+      .values({
+        id: entry.remediation_id,
+        trace_id: entry.span_id || 'unknown',
+        strategy: entry.strategy,
+        status: entry.status,
+        timestamp: entry.enqueued_at
+      })
+      .execute();
+
     return entry;
   }
 
   /**
    * Updates the status of a specific remediation task.
    */
-  updateStatus(remediationId, status) {
-    const task = this.queue.find(t => t.remediation_id === remediationId);
-    if (task) {
-      task.status = status;
-      task.updated_at = new Date().toISOString();
-      this._persist();
-    }
+  async updateStatus(remediationId, status) {
+    await this.ensureInit();
+    await vectorHub.db.updateTable('remediations')
+      .set({ 
+        status, 
+        outcome: `Updated at ${new Date().toISOString()}` 
+      })
+      .where('id', '=', remediationId)
+      .execute();
   }
 
   /**
-   * Internal persistence helper.
+   * Legacy persistence removed in v8 (SQLite transition).
    */
   _persist() {
-    try {
-      if (!fs.existsSync(path.dirname(this.queuePath))) {
-        fs.mkdirSync(path.dirname(this.queuePath), { recursive: true });
-      }
-      fs.writeFileSync(this.queuePath, JSON.stringify(this.queue, null, 2));
-    } catch (err) {
-      console.error(`[RemediationQueue] Failed to persist queue: ${err.message}`);
-    }
+     // No-op for v8
+  }
+
+  _loadQueue() {
+     // No-op for v8
+     return [];
   }
 
-  getPending() {
-    return this.queue.filter(t => t.status === 'PENDING');
+  async getPending() {
+    await this.ensureInit();
+    return await vectorHub.db.selectFrom('remediations')
+      .selectAll()
+      .where('status', '=', 'PENDING')
+      .execute();
   }
 
-  getAll() {
-    return this.queue;
+  async getAll() {
+    await this.ensureInit();
+    return await vectorHub.db.selectFrom('remediations')
+      .selectAll()
+      .execute();
   }
 }