mindforge-cc 8.2.0 → 9.0.0

package/bin/memory/vector-hub.js

@@ -1,24 +1,25 @@
 const Database = require('better-sqlite3');
 const { Kysely, SqliteDialect, sql } = require('kysely');
+const crypto = require('crypto');
 const path = require('path');
 const fs = require('fs');
 
 /**
- * MindForge v8 VectorHub
- * Unified Persistence Layer for Trace, Remediation, and Skill data.
+ * MindForge v9 VectorHub
+ * Unified Persistence Layer — traces, remediations, skills, knowledge, and graph edges.
  */
 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;
   }
 
@@ -51,13 +52,6 @@ class VectorHub {
       .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')
@@ -101,12 +95,61 @@ class VectorHub {
       .addColumn('value', 'text')
       .execute();
 
-    // Enable Full-Text Search for traces (FTS5)
+    // v9 Pillar XXVI: Unified Knowledge table (migrated from JSONL stores)
+    await this.db.schema
+      .createTable('knowledge')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('type', 'text', (col) => col.notNull())
+      .addColumn('content', 'text', (col) => col.notNull())
+      .addColumn('tags', 'text')
+      .addColumn('source', 'text')
+      .addColumn('confidence', 'real', (col) => col.defaultTo(1.0))
+      .addColumn('created_at', 'text', (col) => col.notNull())
+      .addColumn('updated_at', 'text')
+      .addColumn('metadata', 'text')
+      .execute();
+
+    // v9 Pillar XXVI: Graph edges table (migrated from knowledge-graph JSONL)
+    await this.db.schema
+      .createTable('graph_edges')
+      .ifNotExists()
+      .addColumn('id', 'text', (col) => col.primaryKey())
+      .addColumn('source_id', 'text', (col) => col.notNull())
+      .addColumn('target_id', 'text', (col) => col.notNull())
+      .addColumn('edge_type', 'text', (col) => col.notNull())
+      .addColumn('weight', 'real', (col) => col.defaultTo(1.0))
+      .addColumn('created_at', 'text', (col) => col.notNull())
+      .execute();
+
+    // v9 Pillar XXVII: Migration tracking table
+    await this.db.schema
+      .createTable('_migrations')
+      .ifNotExists()
+      .addColumn('id', 'integer', (col) => col.primaryKey())
+      .addColumn('name', 'text', (col) => col.notNull())
+      .addColumn('applied_at', 'text', (col) => col.notNull())
+      .execute();
+
+    // Enable Full-Text Search (FTS5) for traces and knowledge
     await sql`
-      CREATE VIRTUAL TABLE IF NOT EXISTS traces_search 
+      CREATE VIRTUAL TABLE IF NOT EXISTS traces_search
       USING fts5(trace_id, content, agent, tokenize='porter');
     `.execute(this.db);
 
+    await sql`
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_search
+      USING fts5(id, content, tags, tokenize='porter');
+    `.execute(this.db);
+
+    // v9: Secondary indexes for common query patterns
+    await sql`CREATE INDEX IF NOT EXISTS idx_traces_trace_id ON traces(trace_id)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_traces_timestamp ON traces(timestamp)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_knowledge_type ON knowledge(type)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_graph_edges_source ON graph_edges(source_id)`.execute(this.db);
+    await sql`CREATE INDEX IF NOT EXISTS idx_graph_edges_target ON graph_edges(target_id)`.execute(this.db);
+    await sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_migrations_name ON _migrations(name)`.execute(this.db);
+
     this.initialized = true;
     console.log(`[VectorHub] Initialized SQLite persistence at ${this.dbPath}`);
   }
@@ -120,7 +163,7 @@ class VectorHub {
    */
   async recordTrace(data) {
     const entry = {
-      id: data.id || Math.random().toString(36).substr(2, 9),
+      id: data.id || crypto.randomBytes(8).toString('hex'),
       trace_id: data.trace_id,
       span_id: data.span_id || null,
       event: data.event,
@@ -143,6 +186,7 @@ class VectorHub {
     
     // Update FTS5 index if content exists
     if (entry.content) {
+      await sql`DELETE FROM traces_search WHERE trace_id = ${entry.trace_id}`.execute(this.db);
       await sql`INSERT INTO traces_search (trace_id, content, agent) VALUES (${entry.trace_id}, ${entry.content}, ${entry.agent})`
         .execute(this.db);
     }
@@ -153,9 +197,10 @@ class VectorHub {
   /**
    * Semantic search for previous traces.
    */
-  async searchTraces(query) {
+  async searchTraces(rawQuery) {
+    const query = '"' + rawQuery.replace(/"/g, '""') + '"';
     const results = await sql`
-        SELECT t.*, ts.rank 
+        SELECT t.*, ts.rank
         FROM traces t
         JOIN traces_search ts ON t.trace_id = ts.trace_id
         WHERE traces_search MATCH ${query}
@@ -164,6 +209,93 @@ class VectorHub {
       `.execute(this.db);
     return results.rows;
   }
+  // ── v9 Pillar XXVI: Unified Knowledge API ─────────────────────────────────
+
+  async saveKnowledge(entry) {
+    const now = new Date().toISOString();
+    const record = {
+      id: entry.id || `k_${crypto.randomBytes(8).toString('hex')}`,
+      type: entry.type || 'insight',
+      content: entry.content,
+      tags: Array.isArray(entry.tags) ? entry.tags.join(',') : (entry.tags || ''),
+      source: entry.source || 'unknown',
+      confidence: entry.confidence ?? 1.0,
+      created_at: entry.created_at || now,
+      updated_at: now,
+      metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
+    };
+
+    await this.db.insertInto('knowledge')
+      .values(record)
+      .onConflict(oc => oc.column('id').doUpdateSet({
+        content: record.content,
+        tags: record.tags,
+        confidence: record.confidence,
+        updated_at: record.updated_at,
+        metadata: record.metadata,
+      }))
+      .execute();
+
+    await sql`DELETE FROM knowledge_search WHERE id = ${record.id}`.execute(this.db);
+    await sql`INSERT INTO knowledge_search (id, content, tags) VALUES (${record.id}, ${record.content}, ${record.tags})`
+      .execute(this.db);
+
+    return record.id;
+  }
+
+  async searchKnowledge(rawQuery, limit = 10) {
+    const query = '"' + rawQuery.replace(/"/g, '""') + '"';
+    const results = await sql`
+      SELECT k.*, ks.rank
+      FROM knowledge k
+      JOIN knowledge_search ks ON k.id = ks.id
+      WHERE knowledge_search MATCH ${query}
+      ORDER BY ks.rank
+      LIMIT ${limit}
+    `.execute(this.db);
+    return results.rows;
+  }
+
+  async saveEdge(edge) {
+    const record = {
+      id: edge.id || `e_${crypto.randomBytes(8).toString('hex')}`,
+      source_id: edge.source_id,
+      target_id: edge.target_id,
+      edge_type: edge.edge_type,
+      weight: edge.weight ?? 1.0,
+      created_at: edge.created_at || new Date().toISOString(),
+    };
+
+    await this.db.insertInto('graph_edges')
+      .values(record)
+      .onConflict(oc => oc.column('id').doNothing())
+      .execute();
+
+    return record.id;
+  }
+
+  async getEdges(nodeId) {
+    const results = await this.db.selectFrom('graph_edges')
+      .selectAll()
+      .where((eb) => eb.or([
+        eb('source_id', '=', nodeId),
+        eb('target_id', '=', nodeId),
+      ]))
+      .execute();
+    return results;
+  }
+
+  // ── v9 Pillar XXVII: Migration tracking ──────────────────────────────────
+
+  async getAppliedMigrations() {
+    const rows = await this.db.selectFrom('_migrations').selectAll().execute();
+    return rows.map(r => r.name);
+  }
+
+  async recordMigration(name) {
+    await sql`INSERT OR IGNORE INTO _migrations (name, applied_at) VALUES (${name}, ${new Date().toISOString()})`
+      .execute(this.db);
+  }
 }
 
 module.exports = new VectorHub();

package/bin/migrations/migrate.js

@@ -44,6 +44,7 @@ async function runMigrations(fromVersion, toVersion) {
     require('./0.1.0-to-0.5.0'),
     require('./0.5.0-to-0.6.0'),
     require('./0.6.0-to-1.0.0'),
+    require('./v9-unified-memory'),
   ];
 
   // A migration should run if its DESTINATION VERSION falls within the range:

package/bin/migrations/v9-unified-memory.js

@@ -0,0 +1,98 @@
+/**
+ * MindForge v9 Migration — Unified Memory Architecture (Pillar XXVI)
+ * Migrates knowledge-store JSONL and knowledge-graph JSONL into celestial.db.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const vectorHub = require('../memory/vector-hub');
+
+const fromVersion = '8.2.1';
+const toVersion = '9.0.0';
+const description = 'Unified Memory: migrate JSONL knowledge stores into SQLite';
+
+async function run() {
+  await vectorHub.init();
+
+  const applied = await vectorHub.getAppliedMigrations();
+  if (applied.includes('v9-unified-memory')) {
+    console.log('[v9-MIGRATION] Already applied — skipping.');
+    return;
+  }
+
+  let knowledgeMigrated = 0;
+  let edgesMigrated = 0;
+  let skippedLines = 0;
+
+  await vectorHub.db.transaction().execute(async (trx) => {
+    // 1. Migrate knowledge-base.jsonl → knowledge table
+    const kbPaths = [
+      path.join(process.cwd(), '.mindforge', 'memory', 'knowledge-base.jsonl'),
+      path.join(process.cwd(), '.mindforge', 'memory', 'global-knowledge-base.jsonl'),
+    ];
+
+    for (const kbPath of kbPaths) {
+      if (!fs.existsSync(kbPath)) continue;
+      const lines = fs.readFileSync(kbPath, 'utf8').split('\n').filter(Boolean);
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.status === 'deleted') continue;
+          await vectorHub.saveKnowledge({
+            id: entry.id,
+            type: entry.type || 'insight',
+            content: entry.content || entry.insight || '',
+            tags: entry.tags || [],
+            source: entry.source || (kbPath.includes('global') ? 'global' : 'project'),
+            confidence: entry.confidence ?? 1.0,
+            created_at: entry.timestamp || entry.created_at,
+            metadata: entry,
+          });
+          knowledgeMigrated++;
+        } catch (e) {
+          skippedLines++;
+        }
+      }
+    }
+
+    // 2. Migrate knowledge-graph edges → graph_edges table
+    const graphPath = path.join(process.cwd(), '.mindforge', 'memory', 'graph-edges.jsonl');
+    if (fs.existsSync(graphPath)) {
+      const lines = fs.readFileSync(graphPath, 'utf8').split('\n').filter(Boolean);
+
+      for (const line of lines) {
+        try {
+          const edge = JSON.parse(line);
+          await vectorHub.saveEdge({
+            id: edge.id || edge.edge_id,
+            source_id: edge.source_id || edge.from,
+            target_id: edge.target_id || edge.to,
+            edge_type: edge.edge_type || edge.type || 'RELATED_TO',
+            weight: edge.weight ?? 1.0,
+            created_at: edge.timestamp || edge.created_at,
+          });
+          edgesMigrated++;
+        } catch (e) {
+          skippedLines++;
+        }
+      }
+    }
+  });
+
+  // 3. Record migration completion (outside transaction — it committed successfully)
+  await vectorHub.recordMigration('v9-unified-memory');
+
+  console.log(`[v9-MIGRATION] Knowledge entries migrated: ${knowledgeMigrated}`);
+  console.log(`[v9-MIGRATION] Graph edges migrated: ${edgesMigrated}`);
+  if (skippedLines > 0) {
+    console.warn(`[v9-MIGRATION] WARNING: ${skippedLines} malformed lines skipped`);
+  }
+}
+
+if (require.main === module) {
+  run().then(() => process.exit(0)).catch(err => { console.error(err); process.exit(1); });
+}
+
+module.exports = { fromVersion, toVersion, description, run };

package/bin/models/cloud-broker.js

@@ -118,12 +118,13 @@ class CloudBroker {
   /**
    * Retrieves provider-specific model mapping.
    */
+  // v9: Provider model mappings aligned to Claude 4.x family
   mapToProviderModel(provider, modelGroup) {
     const mappings = {
-      'anthropic': { 'sonnet': 'claude-3-5-sonnet', 'opus': 'claude-3-opus', 'haiku': 'claude-3-haiku' },
-      'google': { 'sonnet': 'gemini-1.5-pro', 'haiku': 'gemini-1.5-flash' },
-      'aws': { 'sonnet': 'anthropic.claude-3-5-sonnet-v2:0', 'haiku': 'anthropic.claude-3-haiku-v1:0' },
-      'azure': { 'sonnet': 'gpt-4o', 'haiku': 'gpt-35-turbo' }
+      'anthropic': { 'sonnet': 'claude-sonnet-4-6', 'opus': 'claude-opus-4-7', 'haiku': 'claude-haiku-4-5' },
+      'google': { 'sonnet': 'gemini-2.5-pro', 'haiku': 'gemini-2.5-flash' },
+      'aws': { 'sonnet': 'anthropic.claude-sonnet-4-6-v1:0', 'haiku': 'anthropic.claude-haiku-4-5-v1:0' },
+      'azure': { 'sonnet': 'claude-sonnet-4-6', 'haiku': 'claude-haiku-4-5' }
     };
 
     return mappings[provider]?.[modelGroup] || mappings[provider]?.['sonnet'];
@@ -151,9 +152,9 @@ class CloudBroker {
   startChaosMode() {
     console.log('[ENTERPRISE-RESILIENCE] CloudBroker Chaos Mode ACTIVE. Simulating jitter and provider dropouts...');
     setInterval(() => {
-      const providers = Object.keys(this.latencyMap);
+      const providers = Object.keys(this.state);
       const randomProvider = providers[Math.floor(Math.random() * providers.length)];
-      this.latencyMap[randomProvider] = Math.random() > 0.7 ? 5000 : 100; // Spike latency
+      this.state[randomProvider].latency = Math.random() > 0.7 ? 5000 : 100;
     }, 10000);
   }
 }

package/bin/models/model-broker.js

@@ -114,14 +114,15 @@ class ModelBroker {
   }
 
   estimateCost(modelId, input, output) {
-    // Mock cost estimation logic per 1M tokens
+    // v9: Pricing aligned to Claude 4.x family (per 1M tokens)
     const rates = {
-      'claude-3-opus': { in: 15, out: 75 },
-      'claude-3-5-sonnet': { in: 3, out: 15 },
-      'claude-3-haiku': { in: 0.25, out: 1.25 },
+      'claude-opus-4-7':   { in: 15, out: 75 },
+      'claude-sonnet-4-6': { in: 3, out: 15 },
+      'claude-haiku-4-5':  { in: 0.80, out: 4.0 },
+      'gemini-2.5-pro':    { in: 1.25, out: 10 },
     };
 
-    const rate = rates[modelId] || rates['claude-3-5-sonnet'];
+    const rate = rates[modelId] || rates['claude-sonnet-4-6'];
     return (input / 1_000_000) * rate.in + (output / 1_000_000) * rate.out;
   }
 }

package/bin/models/model-client.js

@@ -10,10 +10,11 @@ const AnthropicProvider = require('./anthropic-provider');
 const OpenAIProvider = require('./openai-provider');
 const GeminiProvider = require('./gemini-provider');
 
+// v9: Fallback chains aligned to Claude 4.x family
 const FALLBACK_CHAINS = {
-  'claude-3-opus-20240229': ['gpt-4o', 'claude-3-5-sonnet-20240620'],
-  'gpt-4o': ['claude-3-5-sonnet-20240620'],
-  'gemini-1.5-pro': ['claude-3-5-sonnet-20240620'],
+  'claude-opus-4-7': ['claude-sonnet-4-6', 'gemini-2.5-pro'],
+  'claude-sonnet-4-6': ['claude-haiku-4-5', 'gemini-2.5-pro'],
+  'gemini-2.5-pro': ['claude-sonnet-4-6'],
 };
 
 class ModelClient {
@@ -70,24 +71,27 @@ class ModelClient {
         return result;
 
       } catch (err) {
-        process.stderr.write(`[model-client] ${currentModel} failed: ${err.message}\n`);
+        const safeMsg = (err.message || '').replace(/sk-[a-zA-Z0-9_-]+/g, 'sk-***').replace(/key-[a-zA-Z0-9_-]+/g, 'key-***');
+        process.stderr.write(`[model-client] ${currentModel} failed: ${safeMsg}\n`);
         if (attempts.indexOf(currentModel) === attempts.length - 1) {
-          throw err;
+          const safeErr = new Error(safeMsg);
+          safeErr.code = err.code;
+          throw safeErr;
         }
       }
     }
   }
 
   static _getProvider(modelId) {
-    if (modelId.includes('claude')) {
+    if (modelId.startsWith('claude') || modelId.startsWith('anthropic.claude')) {
       if (!process.env.ANTHROPIC_API_KEY) return null;
       return new AnthropicProvider(process.env.ANTHROPIC_API_KEY);
     }
-    if (modelId.includes('gpt')) {
+    if (modelId.startsWith('gpt') || modelId.startsWith('o1') || modelId.startsWith('o3')) {
       if (!process.env.OPENAI_API_KEY) return null;
       return new OpenAIProvider(process.env.OPENAI_API_KEY);
     }
-    if (modelId.includes('gemini')) {
+    if (modelId.startsWith('gemini')) {
       if (!process.env.GOOGLE_API_KEY) return null;
       return new GeminiProvider(process.env.GOOGLE_API_KEY);
     }

package/bin/models/model-router.js

@@ -7,18 +7,18 @@
 const fs = require('fs');
 const path = require('path');
 
-// Default model assignments
+// v9: Model topology aligned to Claude 4.x family (2026-04)
 const DEFAULTS = {
-  PLANNER_MODEL:          'claude-4-5-opus-preview',
-  EXECUTOR_MODEL:         'claude-3-5-sonnet-20240620',
-  REVIEWER_MODEL:         'gpt-4o',
-  SECURITY_MODEL:         'claude-3-opus-20240229',
-  RESEARCH_MODEL:         'gemini-1.5-pro',
-  QA_MODEL:               'claude-3-5-sonnet-20240620',
-  DEBUG_MODEL:            'claude-3-opus-20240229',
-  QUICK_MODEL:            'claude-3-5-haiku-20241022',
-  CROSS_REVIEW_SECONDARY: 'gpt-4o',
-  CROSS_REVIEW_TERTIARY:  'gemini-1.5-pro',
+  PLANNER_MODEL:          'claude-opus-4-7',
+  EXECUTOR_MODEL:         'claude-sonnet-4-6',
+  REVIEWER_MODEL:         'claude-sonnet-4-6',
+  SECURITY_MODEL:         'claude-opus-4-7',
+  RESEARCH_MODEL:         'gemini-2.5-pro',
+  QA_MODEL:               'claude-sonnet-4-6',
+  DEBUG_MODEL:            'claude-opus-4-7',
+  QUICK_MODEL:            'claude-haiku-4-5',
+  CROSS_REVIEW_SECONDARY: 'claude-sonnet-4-6',
+  CROSS_REVIEW_TERTIARY:  'gemini-2.5-pro',
 };
 
 // Persona to setting key mapping

package/docs/Context/Master-Context.md

@@ -10,7 +10,7 @@
 **Tagline:** Enterprise Agentic Framework — the best agentic framework
 **Repository:** `github.com/mindforge-dev/mindforge` (conceptual)
 **npm package:** `npx mindforge-cc@latest`
-**Current version:** v8.2.0 (Autonomous SRE Era)
+**Current version:** v9.0.0 (Bedrock Meridian Era)
 **Runtimes supported:** Claude Code (`.claude/`) and Antigravity (`.agent/`)
 **License:** MIT
 
@@ -309,6 +309,23 @@ Built the framework's self-healing and production reliability layer:
 
 ---
 
+### — Bedrock Meridian (`feat/mindforge-bedrock-meridian` → v9.0.0)
+
+**Branch:** `feat/mindforge-bedrock-meridian`
+**Pillars:** XXIV, XXV, XXVI, XXVII, XXVIII
+
+Grounded the framework on modern model topologies, unified persistence, and verified execution chains:
+
+- **Pillar XXIV: Grounded Wave Execution** — The AutoRunner now parses `HANDOFF.json` wave groups and dispatches tasks with full audit trail persistence. Resume from `auto-state.json` restores completed task state, eliminating re-execution of already-verified waves.
+- **Pillar XXV: Model Topology Modernization (Claude 4.x)** — All model references updated to current-generation identifiers (`claude-sonnet-4-6`, `claude-opus-4-7`, `claude-haiku-4-5`). Provider routing switched from substring matching to prefix matching to prevent false-positive model resolution.
+- **Pillar XXVI: Unified Memory Architecture (SQLite consolidation)** — All knowledge and graph data consolidated into a single SQLite database with FTS5 search indexes, replacing the previous multi-file JSONL approach for queryable persistence.
+- **Pillar XXVII: Schema Migration Engine** — Automated migration pipeline for `.planning/` schema evolution. Supports forward-only migrations with backup-and-restore safety, dry-run mode, and CI integration.
+- **Pillar XXVIII: Integration Test Chain (27 assertions)** — End-to-end verification suite covering the full autonomous loop: init → plan → execute → verify → ship. 27 discrete assertions validate state transitions, audit entries, and artifact integrity across the complete lifecycle.
+
+**Key ADRs:** ADR-024 (Grounded Wave Execution), ADR-025 (Model Topology Currency), ADR-026 (Unified SQLite Persistence)
+
+---
+
 ## CURRENT SYSTEM ARCHITECTURE
 
 ```
@@ -711,4 +728,4 @@ All prompt files are in `/mnt/user-data/outputs/`:
 
 ---
 
-*State file generated at completion. MindForge v8.2.0 — 36 commands · 10 skills · 34 personas · 23 ADRs · 16 test suites.*
+*State file generated at completion. MindForge v9.0.0 — 36 commands · 10 skills · 34 personas · 23 ADRs · 17 test suites.*