mindforge-cc 8.1.1 → 8.2.0

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/temporal-vision.test.js

@@ -0,0 +1,68 @@
+/**
+ * MindForge v3 — Temporal Vision Test Suite
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+const TemporalHub = require('../bin/engine/temporal-hub');
+const HindsightInjector = require('../bin/hindsight-injector');
+
+const TEST_PLAN_DIR = path.join(process.cwd(), '.planning');
+const HISTORY_DIR   = path.join(TEST_PLAN_DIR, 'history');
+
+// Mock setup
+if (!fs.existsSync(TEST_PLAN_DIR)) fs.mkdirSync(TEST_PLAN_DIR, { recursive: true });
+
+async function runTests() {
+  console.log('🧪 Starting Temporal Vision Verification...\n');
+
+  try {
+    // 1. Create a dummy file in .planning
+    const testFile = path.join(TEST_PLAN_DIR, 'TEMPORAL-TEST.md');
+    fs.writeFileSync(testFile, 'Initial State: $T_0$');
+    console.log('✅ Created test file in .planning');
+
+    // 2. Capture state
+    const auditId = 'test-audit-001';
+    const snapshotDir = TemporalHub.captureState(auditId, { task: 'Verification Test' });
+    assert(fs.existsSync(snapshotDir), 'Snapshot directory should exist');
+    assert(fs.existsSync(path.join(snapshotDir, 'TEMPORAL-TEST.md')), 'Snapshot file should exist');
+    console.log('✅ TemporalHub.captureState works');
+
+    // 3. Modify original file
+    fs.writeFileSync(testFile, 'Modified State: $T_1$');
+    console.log('✅ Modified original file');
+
+    // 4. Verify History
+    const history = TemporalHub.getHistory();
+    assert(history.length > 0, 'History should not be empty');
+    assert(history[0].id === auditId, 'Latest history ID should match');
+    console.log('✅ TemporalHub.getHistory works');
+
+    // 5. Rollback
+    const rollbackSuccess = TemporalHub.rollbackTo(auditId);
+    assert(rollbackSuccess === true, 'Rollback should return success');
+    const content = fs.readFileSync(testFile, 'utf8');
+    assert(content === 'Initial State: $T_0$', 'Rollback did not restore file content correctly');
+    console.log('✅ TemporalHub.rollbackTo works');
+
+    // 6. Hindsight Injection
+    const injectResult = await HindsightInjector.inject(auditId, 'Recovering from $T_1$ failure');
+    assert(injectResult.success === true, 'Hindsight injection should succeed');
+    assert(fs.existsSync(path.join(HISTORY_DIR, injectResult.event.id)), 'New snapshot for injection should exist');
+    console.log('✅ HindsightInjector.inject works');
+
+    // Cleanup
+    // fs.unlinkSync(testFile);
+    // Note: We leave history for manual inspection if needed, or implement cleanup test.
+
+    console.log('\n✨ ALL TEMPORAL TESTS PASSED ✨');
+  } catch (err) {
+    console.error('\n❌ TEST FAILED:', err.message);
+    process.exit(1);
+  }
+}
+
+runTests();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v7-pillar-integration.test.js

@@ -0,0 +1,73 @@
+/**
+ * MindForge v6.1.0-alpha — Pillar IX & X Integration Suite
+ * 
+ * Verifies the Sovereign Phase 1 ecosystem:
+ * 1. Autonomous Resource Harvesting (ARH) - Token Arbitrage
+ * 2. Neural Drift Remediation (NDR) - Self-Correction
+ */
+'use strict';
+
+const nexus = require('../bin/engine/nexus-tracer');
+const router = require('../bin/revops/router-steering-v2');
+const roi = require('../bin/revops/roi-engine');
+
+async function runIntegratedAudit() {
+  console.log('--- Starting MindForge v6.1 Integration Audit ---');
+
+  // [Pillar IX Test] - Complex Architecture Task
+  console.log('\n[TEST] Verifying Pillar IX (Arbitrage)...');
+  const span1 = await nexus.startSpan('v7_blueprint_execution', { tier: 3 });
+  const steer1 = await router.steer(span1, 'Design a post-quantum cryptographic enclave for agentic mesh');
+  
+  if (steer1.selected_model === 'claude-3-5-sonnet' || steer1.selected_model === 'gemini-1.5-pro') {
+    console.log(`✅ ARH correctly selected premium model (${steer1.selected_model}) for high-MIR task.`);
+  } else {
+    console.warn(`❌ ARH failed to select premium model for complex task. Selected: ${steer1.selected_model}`);
+  }
+
+  // [Pillar IX Test] - Common Test Task
+  const span2 = await nexus.startSpan('boilerplate_generation');
+  const steer2 = await router.steer(span2, 'Write a basic unit test for a counter in javascript');
+  if (steer2.selected_model.includes('llama') || steer2.selected_model.includes('flash')) {
+    console.log(`✅ ARH correctly leveraged arbitrage model (${steer2.selected_model}) for low-MIR task.`);
+    console.log(`💰 Estimated Savings: $${steer2.estimated_arbitrage_savings.toFixed(4)}`);
+  }
+
+  // [Pillar X Test] - Neural Drift Detection
+  console.log('\n[TEST] Verifying Pillar X (Drift Remediation)...');
+  const span3 = await nexus.startSpan('long_running_reasoning');
+  
+  console.log('Simulating stable reasoning...');
+  await nexus.recordReasoning(span3, 'mf-executor', 'Analyzing directory structure for security bypass possibilities.');
+  
+  console.log('Simulating reasoning drift (repetitive rambling)...');
+  await nexus.recordReasoning(span3, 'mf-executor', 'I will check. I will check. I will check again. Nevertheless I will check one more time. Contradicting previous logic, I will restart checking. However, I will instead check again.');
+  
+  // Checking audit for remediation events
+  const auditEntries = require('fs').readFileSync('.planning/AUDIT.jsonl', 'utf-8').split('\n').filter(Boolean).map(JSON.parse);
+  const remediation = auditEntries.find(e => e.event === 'drift_remediation_event' && e.span_id === span3);
+  
+  if (remediation) {
+    console.log(`✅ NDR correctly detected drift (Score: ${remediation.score}) and triggered: ${remediation.strategy}`);
+  } else {
+    console.warn('❌ NDR failed to record drift remediation event in audit log.');
+  }
+
+  // ROI Summary
+  console.log('\n[TEST] Verifying ROI Engine v6.1 Integration...');
+  const finalROI = roi.calculate({
+    costs: [{ cost: 0.12 }],
+    arbitrageSavings: steer1.estimated_arbitrage_savings + steer2.estimated_arbitrage_savings,
+    auditEntries: [{ event: 'task_completed', message: 'Architect Pillar IX' }]
+  });
+
+  console.log(`📈 Session Net Value: $${finalROI.net_value}`);
+  console.log(`🏛️ Arbitrage Savings Realized: $${finalROI.arbitrage_savings}`);
+
+  console.log('\n--- MindForge v6.1 Integration Audit Complete ---');
+}
+
+runIntegratedAudit().catch(err => {
+  console.error('Audit Suite Failed:', err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v7-proactive-homing.test.js

@@ -0,0 +1,53 @@
+/**
+ * MindForge v7 — Pillar XII (Proactive Semantic Homing) Verification
+ */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert');
+const intentHarvester = require('../bin/autonomous/intent-harvester');
+const meshSelfHealer = require('../bin/autonomous/mesh-self-healer');
+
+async function testProactiveHoming() {
+  console.log('--- Testing Proactive Semantic Homing (Pillar XII) ---');
+
+  // 1. Setup Mock Backlog
+  const planningDir = path.join(process.cwd(), '.planning');
+  if (!fs.existsSync(planningDir)) fs.mkdirSync(planningDir);
+  
+  const mockBacklog = [
+    { id: 'task_001', description: 'Optimization Refactor', status: 'unassigned', required_skills: ['Refactor Specialist'] }
+  ];
+  fs.writeFileSync(path.join(planningDir, 'BACKLOG.json'), JSON.stringify(mockBacklog, null, 2));
+
+  // 2. Test Intent Harvesting
+  console.log('Step 1: Testing Proactive Intent Harvesting...');
+  const tasks = await intentHarvester.idleScan();
+  assert.strictEqual(tasks.length, 1, 'Failed to harvest backlog tasks');
+
+  const agent = { did: 'did:mindforge:agent-1', skills: ['Refactor Specialist'] };
+  const claimedTask = await intentHarvester.intentGrab(agent, tasks);
+  
+  assert.notStrictEqual(claimedTask, null, 'Agent failed to claim high-affinity task');
+  assert.strictEqual(claimedTask.assigned_to, agent.did, 'Task assignment mismatch');
+  console.log('✅ Intent Harvesting successful.');
+
+  // 3. Test Mesh Self-Healing
+  console.log('\nStep 2: Testing Mesh Self-Healing (Drift Recovery)...');
+  const recovery = await meshSelfHealer.homeIn('did:mindforge:drifting-agent', 85);
+  
+  assert.strictEqual(recovery.type, 'collective_repair', 'Mesh self-healing failed to generate recovery vector');
+  assert.ok(recovery.consensus, 'Mesh recovery consensus missing');
+  console.log('✅ Mesh Self-Healing successful (Recovery vector generated).');
+
+  console.log('\n--- Proactive Homing Verification Complete ---');
+  
+  // Cleanup
+  fs.unlinkSync(path.join(planningDir, 'BACKLOG.json'));
+}
+
+testProactiveHoming().catch(err => {
+  console.error('❌ Proactive Homing Test Failed:', err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v7-sovereign-security.test.js

@@ -0,0 +1,64 @@
+/**
+ * MindForge v7 — Pillar XI (PQAS) Verification
+ */
+'use strict';
+
+const assert = require('node:assert');
+const quantumCrypto = require('../bin/governance/quantum-crypto');
+const policyEngine = require('../bin/governance/policy-engine');
+
+async function testPQAS() {
+  console.log('--- Testing Post-Quantum Agentic Security (Pillar XI) ---');
+
+  // 1. Test Lattice Key Generation & Signing
+  console.log('Step 1: Testing Dilithium-5 Signature Flow...');
+  const keyPair = await quantumCrypto.generateLatticeKeyPair();
+  const data = 'Sovereign mutation: update core/kernel';
+  const signature = await quantumCrypto.signPQ(data, keyPair.privateKey);
+  
+  const isValid = quantumCrypto.verifyPQ(data, signature, keyPair.publicKey);
+  assert.strictEqual(isValid, true, 'Lattice signature verification failed');
+  console.log('✅ Lattice signature verified.');
+
+  // 2. Test ZK-Proof Policy Bypass
+  console.log('\nStep 2: Testing ZK-Proof Policy Bypass...');
+  const PolicyEngine = require('../bin/governance/policy-engine');
+  const pe = new PolicyEngine();
+  
+  const intent = {
+    id: 'intent_v7_001',
+    tier: 3,
+    pq_proof: quantumCrypto.generateZKProof({ id: 'intent_v7_001' }, { verdict: 'ALLOW' })
+  };
+  
+  // Simulated high impact
+  // Mocking matches and policies for testing
+  pe.matches = () => true;
+  pe.loadPolicies = () => [{ id: 'test_policy', effect: 'PERMIT', max_impact: 80 }];
+  
+  const verdict = pe.evaluate(intent);
+  console.log(`✅ Policy Evaluation returned: ${verdict.verdict} (${verdict.reason})`);
+  assert.strictEqual(verdict.verdict, 'PERMIT', 'ZK-Proof bypass should result in PERMIT if verified');
+
+  // 3. Test Biometric Challenge (Risk > 95)
+  console.log('\nStep 3: Testing Biometric Challenge (Edge Case)...');
+  const ImpactAnalyzer = require('../bin/governance/impact-analyzer');
+  const originalAnalyze = ImpactAnalyzer.analyze;
+  ImpactAnalyzer.analyze = () => 98; // Force critical risk
+  
+  const highRiskIntent = { id: 'intent_v7_002', tier: 3, action: 'CRITICAL_MUTATION' };
+  const biometricVerdict = pe.evaluate(highRiskIntent);
+  
+  assert.strictEqual(biometricVerdict.status, 'WAIT_FOR_BIOMETRIC', 'Biometric challenge did not trigger for risk > 95');
+  console.log('✅ Biometric challenge successfully triggered for Risk=98.');
+  
+  // Restore mock
+  ImpactAnalyzer.analyze = originalAnalyze;
+
+  console.log('\n--- PQAS Verification Complete ---');
+}
+
+testPQAS().catch(err => {
+  console.error('❌ PQAS Test Failed:', err);
+  process.exit(1);
+});

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v8-mesh-sync.test.js

@@ -0,0 +1,76 @@
+/**
+ * MindForge v8 — Federated Mesh Synthesis (FMS) Verification Test
+ * Tests cross-project knowledge sharing and secure bundle import.
+ */
+const meshSyncer = require('../bin/engine/mesh-syncer');
+const vectorHub = require('../bin/memory/vector-hub');
+const ztaiManager = require('../bin/governance/ztai-manager');
+const configManager = require('../bin/governance/config-manager');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+async function runTest() {
+  console.log('[TEST] Starting v8 Federated Mesh Synthesis Verification...');
+
+  try {
+    await vectorHub.init();
+    
+    // 1. Provision Node Alpha Identity (Tier 3)
+    console.log('[TEST] Provisioning Node Alpha identity...');
+    const alphaDid = await ztaiManager.registerAgent('mf-analyzer', 3);
+    configManager.set('governance.active_did', alphaDid);
+    configManager.set('mesh.node_id', 'alpha-node');
+
+    // 2. Seed Alpha Reasoning Data
+    console.log('[TEST] Seeding Alpha reasoning data...');
+    const alphaTraceId = `tr_alpha_${Math.random().toString(36).substr(2, 5)}`;
+    await vectorHub.recordTrace({
+        id: `alpha_seeding_${Math.random().toString(36).substr(2, 5)}`,
+        trace_id: alphaTraceId,
+        event: 'reasoning_trace',
+        agent: 'mf-analyzer',
+        content: 'Alpha node optimization sequence.',
+        drift_score: 0.1
+    });
+
+    // 3. Export Bundle from Alpha
+    console.log('[TEST] Exporting bundle from Alpha...');
+    const bundlePath = path.join(process.cwd(), '.mindforge', 'alpha-bundle.mfb');
+    await meshSyncer.exportBundle(bundlePath);
+
+    // 4. Provision Node Beta Identity
+    console.log('[TEST] Provisioning Node Beta identity...');
+    const betaDid = await ztaiManager.registerAgent('mf-synthesizer', 3);
+    configManager.set('governance.active_did', betaDid);
+    configManager.set('mesh.node_id', 'beta-node');
+
+    // 5. Import Bundle into Beta
+    console.log('[TEST] Importing bundle into Beta...');
+    await meshSyncer.importBundle(bundlePath);
+
+    // 6. Verification of Cross-Node Intelligence
+    const results = await vectorHub.db.selectFrom('traces')
+        .selectAll()
+        .where('mesh_node_id', '=', 'alpha-node')
+        .execute();
+
+    if (results.length > 0) {
+        process.stdout.write('✅ MindForge v8 Federated Mesh Synthesis Passed.\n');
+        console.log(`[TEST] Successfully verified ${results.length} traces imported with Alpha provenance.`);
+    } else {
+        throw new Error('Federated knowledge import failed — no traces with alpha-node provenance found!');
+    }
+
+  } catch (err) {
+    console.error(`[TEST] ❌ Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    // Cleanup
+    try {
+        await fs.unlink(path.join(process.cwd(), '.mindforge', 'alpha-bundle.mfb'));
+    } catch(e) {}
+    process.exit(0);
+  }
+}
+
+runTest();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v8-orbital-governance.test.js

@@ -0,0 +1,74 @@
+/**
+ * MindForge v8 — Orbital Governance Verification Test (Pillar XVIII)
+ * Tests hardware-attested security gates for high-impact mutations.
+ */
+const policyGate = require('../bin/governance/policy-gate-hardened');
+const orbitalGuardian = require('../bin/engine/orbital-guardian');
+const ztaiManager = require('../bin/governance/ztai-manager');
+const vectorHub = require('../bin/memory/vector-hub');
+
+async function runTest() {
+  console.log('[TEST] Starting v8 Orbital Governance Verification...');
+
+  try {
+    await vectorHub.init();
+    
+    // 1. Register a Tier 3 "Orbital" Agent
+    console.log('[TEST] Registering Tier 3 Governor Agent...');
+    const governorDid = await ztaiManager.registerAgent('mf-governor', 3);
+    console.log(`[TEST] Governor DID: ${governorDid}`);
+
+    // 2. Simulate High-Impact Request (Impact 98)
+    const request = {
+        requestId: `req_destructive_${Math.random().toString(36).substr(2, 5)}`,
+        action: 'DELETE_PRODUCTION_INDEX',
+        impact: 98
+    };
+
+    console.log(`[TEST] Evaluating High-Impact Request: ${request.action} (Impact: ${request.impact})`);
+    let decision = await policyGate.evaluateBypass(request, request.impact);
+
+    // Should be blocked
+    if (decision.status === 'WAIT_FOR_ORBITAL') {
+        console.log('✅ Gate successfully BLOCKED high-impact action and requested Orbital Attestation.');
+    } else {
+        throw new Error(`Expected WAIT_FOR_ORBITAL, got ${decision.status}`);
+    }
+
+    // 3. Perform Orbital Attestation (Hardware Signing Handshake)
+    console.log('[TEST] Performing Hardware-Attested Bypass...');
+    await policyGate.recordBypass(request.requestId, governorDid, 'BIOMETRIC_TOUCH_ID_v8_SIGNED');
+
+    // 4. Re-evaluate Request
+    console.log('[TEST] Re-evaluating Request after Attestation...');
+    decision = await policyGate.evaluateBypass(request, request.impact);
+
+    if (decision.status === 'ALLOWED' && decision.attestation_id) {
+        console.log(`✅ Gate successfully ALLOWED action with Attestation ID: ${decision.attestation_id}`);
+    } else {
+        throw new Error(`Expected ALLOWED, got ${decision.status}`);
+    }
+
+    // 5. Verify SQL Persistence
+    console.log('[TEST] Verifying SQLite persistence of the attestation record...');
+    const records = await vectorHub.db.selectFrom('attestations')
+        .selectAll()
+        .where('request_id', '=', request.requestId)
+        .execute();
+
+    if (records.length === 1 && records[0].status === 'APPROVED') {
+        process.stdout.write('✅ SQLite Attestation Audit Trail Verified.\n');
+        console.log('✅ MindForge v8 Orbital Governance Passed.');
+    } else {
+        throw new Error('Attestation record not found or invalid in SQLite!');
+    }
+
+  } catch (err) {
+    console.error(`[TEST] ❌ Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    process.exit(0);
+  }
+}
+
+runTest();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v8-persistence.test.js

@@ -0,0 +1,86 @@
+/**
+ * MindForge v8 Persistence Verification Test
+ * Tests the Unified Persistence Layer (SQLite)
+ */
+const nexusTracer = require('../bin/engine/nexus-tracer');
+const remediationQueue = require('../bin/revops/remediation-queue');
+const semanticHub = require('../bin/memory/semantic-hub');
+const vectorHub = require('../bin/memory/vector-hub');
+
+async function runTest() {
+  const testId = Math.random().toString(36).substr(2, 6);
+  console.log(`[TEST] Starting v8 Persistence Verification (Test ID: ${testId})...`);
+
+  try {
+    // 1. Test NexusTracer -> VectorHub
+    console.log('[TEST] Recording reasoning trace...');
+    const traceId = nexusTracer.startTrace(`v8_trace_${testId}`);
+    const spanId = await nexusTracer.startSpan(`v8_span_${testId}`);
+    await nexusTracer.recordReasoning(spanId, 'mf-tester', `Celestial persistence test ${testId}.`, 'verified');
+    await nexusTracer.endSpan(spanId);
+
+    // 2. Test RemediationQueue -> VectorHub
+    console.log('[TEST] Enqueuing remediation...');
+    const remId = `rem_v8_${testId}`;
+    const remediation = await remediationQueue.enqueue({
+      remediation_id: remId,
+      span_id: spanId,
+      strategy: 'REASONING_RESTART'
+    });
+    console.log(`[TEST] Enqueued: ${remediation.remediation_id}`);
+    
+    await remediationQueue.updateStatus(remId, 'COMPLETED');
+    console.log('[TEST] Updated remediation status.');
+
+    // 3. Test SemanticHub -> VectorHub
+    console.log('[TEST] Saving skill...');
+    const skillId = `sk_v8_${testId}`;
+    await semanticHub.saveSkill({
+      id: skillId,
+      name: `Celestial Reasoning ${testId}`,
+      description: 'High-performance SQL-backed reasoning',
+      success_rate: 0.99
+    });
+
+    // 4. Verify SQLite contents
+    console.log('[TEST] Verifying SQLite contents...');
+    await vectorHub.init();
+    
+    const traces = await vectorHub.db.selectFrom('traces')
+      .selectAll()
+      .where('trace_id', '=', `v8_trace_${testId}`)
+      .execute();
+    console.log(`[TEST] Traces found: ${traces.length}`);
+
+    const rems = await vectorHub.db.selectFrom('remediations')
+      .selectAll()
+      .where('id', '=', remId)
+      .execute();
+    console.log(`[TEST] Remediations found: ${rems.length} (Status: ${rems[0]?.status})`);
+
+    const skills = await vectorHub.db.selectFrom('skills')
+      .selectAll()
+      .where('skill_id', '=', skillId)
+      .execute();
+    console.log(`[TEST] Skills found: ${skills.length} (Success Rate: ${skills[0]?.success_rate})`);
+
+    // 5. Semantic Search Test
+    console.log('[TEST] Testing semantic search (FTS5)...');
+    const results = await vectorHub.searchTraces(`persistence test ${testId}`);
+    console.log(`[TEST] FTS Search Results: ${results.length}`);
+
+    if (traces.length > 0 && rems.length > 0 && skills.length > 0 && results.length > 0) {
+      console.log('✅ MindForge v8 Persistence Verification Passed.');
+    } else {
+      console.error('❌ MindForge v8 Persistence Verification Failed.');
+    }
+
+  } catch (err) {
+    console.error(`[TEST] Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    process.exit(0);
+  }
+}
+
+runTest();

package/.mindforge/mirrors/mirror-sre-776a1cf9/tests/v8-skill-evolution.test.js

@@ -0,0 +1,74 @@
+/**
+ * MindForge v8 Autonomous Skill Evolution (ASE) Verification Test
+ * Tests the self-improvement loop: Trace Mining -> Synthesis -> Skill Persistence.
+ */
+const skillEvolver = require('../bin/engine/skill-evolver');
+const vectorHub = require('../bin/memory/vector-hub');
+const semanticHub = require('../bin/memory/semantic-hub');
+
+async function runTest() {
+  console.log('[TEST] Starting v8 Autonomous Skill Evolution Verification...');
+
+  try {
+    await vectorHub.init();
+    
+    // 1. Seed Golden Traces (Success Cluster)
+    console.log('[TEST] Seeding Golden Trace cluster...');
+    const clusterId = `cluster_${Math.random().toString(36).substr(2, 5)}`;
+    
+    for (let i = 1; i <= 3; i++) {
+        await vectorHub.recordTrace({
+            id: `ase_golden_${clusterId}_${i}`,
+            trace_id: `tr_ase_${clusterId}`,
+            event: 'reasoning_trace',
+            agent: 'mf-analyzer',
+            content: 'Optimizing the celestial mesh for high-frequency synchronization.',
+            drift_score: 0.05 // Well within ASE threshold
+        });
+    }
+
+    // 2. Seed Noise (Low confidence traces)
+    console.log('[TEST] Seeding noise traces...');
+    await vectorHub.recordTrace({
+        id: `ase_noise_${clusterId}`,
+        trace_id: `tr_ase_noise_${clusterId}`,
+        event: 'reasoning_trace',
+        agent: 'mf-analyzer',
+        content: 'Failing to sync... retry policy mismatch.',
+        drift_score: 0.85 // High drift
+    });
+
+    // 3. Run Evolution
+    console.log('[TEST] Triggering ASE Evolution...');
+    const evolved = await skillEvolver.evolve();
+
+    console.log(`[TEST] Synthesized ${evolved.length} skills.`);
+
+    // 4. Verification
+    if (evolved.length >= 1) {
+        const newSkill = evolved[0];
+        console.log(`[TEST] Verifying unique skill synthesis: ${newSkill.name}`);
+        
+        const skillsInDb = await vectorHub.db.selectFrom('skills')
+            .selectAll()
+            .where('skill_id', '=', newSkill.id)
+            .execute();
+        
+        if (skillsInDb.length > 0) {
+            console.log('✅ MindForge v8 Autonomous Skill Evolution Passed.');
+        } else {
+            console.error('❌ Skill was synthesized but not found in the Database!');
+        }
+    } else {
+        console.error('❌ ASE failed to synthesize a skill from the golden cluster.');
+    }
+
+  } catch (err) {
+    console.error(`[TEST] Error: ${err.message}`);
+    process.exit(1);
+  } finally {
+    process.exit(0);
+  }
+}
+
+runTest();