ruvector 0.2.2 → 0.2.4

package/README.md

@@ -56,7 +56,7 @@ npx ruvector hooks init --pretrain --build-agents quality
 
 ### MCP Server Integration
 
-RuVector includes an MCP server for Claude Code with 30+ tools:
+RuVector includes an MCP server for Claude Code with 103 tools:
 
 ```bash
 # Add to Claude Code
@@ -72,6 +72,35 @@ claude mcp add ruvector -- npx ruvector mcp start
 - `hooks_security_scan` — Vulnerability detection
 - `hooks_rag_context` — Semantic context retrieval
 - `hooks_attention_info`, `hooks_gnn_info` — Neural capabilities
+- `brain_search`, `brain_share`, `brain_status` — Shared brain knowledge
+- `brain_agi_status`, `brain_sona_stats`, `brain_temporal`, `brain_explore` — AGI diagnostics
+- `brain_midstream`, `brain_flags` — Midstream platform + feature flags
+- `midstream_status`, `midstream_attractor`, `midstream_scheduler` — Streaming analysis
+- `midstream_benchmark`, `midstream_search`, `midstream_health` — Latency benchmarks + health
+
+### Brain AGI Commands
+
+Access all 8 AGI subsystems deployed at π.ruv.io:
+
+```bash
+npx ruvector brain agi status          # Combined AGI + midstream diagnostics
+npx ruvector brain agi sona            # SONA patterns, trajectories, ticks
+npx ruvector brain agi temporal        # Knowledge evolution velocity
+npx ruvector brain agi explore         # Meta-learning curiosity & regret
+npx ruvector brain agi midstream       # Scheduler, attractor, solver, strange-loop
+npx ruvector brain agi flags           # Feature flag state
+```
+
+### Midstream Commands
+
+Real-time streaming analysis platform:
+
+```bash
+npx ruvector midstream status          # Platform overview
+npx ruvector midstream attractor       # Lyapunov attractor analysis
+npx ruvector midstream scheduler       # Nanosecond scheduler metrics
+npx ruvector midstream benchmark       # Latency benchmark (p50/p90/p99)
+```
 
 ---
 

package/bin/cli.js

@@ -4106,7 +4106,7 @@ hooksCmd.command('suggest-context').description('Suggest relevant context').acti
   console.log(`RuVector Intelligence: ${stats.total_patterns} learned patterns, ${stats.total_errors} error fixes available. Use 'ruvector hooks route' for agent suggestions.`);
 });
 
-hooksCmd.command('remember').description('Store in memory').requiredOption('-t, --type <type>', 'Memory type').option('--silent', 'Suppress output').option('--semantic', 'Use ONNX semantic embeddings (slower, better quality)').argument('<content...>', 'Content').action(async (content, opts) => {
+hooksCmd.command('remember').description('Store in memory').option('-t, --type <type>', 'Memory type', 'general').option('--silent', 'Suppress output').option('--semantic', 'Use ONNX semantic embeddings (slower, better quality)').argument('<content...>', 'Content').action(async (content, opts) => {
   const intel = new Intelligence();
   let id;
   if (opts.semantic) {
@@ -7880,6 +7880,7 @@ brainCmd.command('search <query>')
   .option('--url <url>', 'Brain server URL')
   .option('--key <key>', 'Pi key')
   .option('--json', 'Output as JSON')
+  .option('--verbose', 'Show detailed scoring and metadata per result')
   .action(async (query, opts) => {
     const piBrain = await requirePiBrain();
     const config = getBrainConfig(opts);
@@ -7893,6 +7894,14 @@ brainCmd.command('search <query>')
         console.log(`  ${chalk.yellow(i + 1 + '.')} ${chalk.bold(r.title || r.id)}`);
         if (r.category) console.log(`     ${chalk.dim('Category:')} ${r.category}`);
         if (r.score) console.log(`     ${chalk.dim('Score:')} ${r.score.toFixed(3)}`);
+        if (opts.verbose) {
+          if (r.quality_score !== undefined) console.log(`     ${chalk.dim('Quality:')} ${typeof r.quality_score === 'number' ? r.quality_score.toFixed(3) : r.quality_score}`);
+          if (r.votes_up !== undefined || r.votes_down !== undefined) console.log(`     ${chalk.dim('Votes:')} ${r.votes_up || 0}↑ ${r.votes_down || 0}↓`);
+          if (r.witness_hash) console.log(`     ${chalk.dim('Witness:')} ${r.witness_hash.slice(0, 12)}...`);
+          if (r.contributor_id) console.log(`     ${chalk.dim('Contributor:')} ${r.contributor_id}`);
+          if (r.created_at) console.log(`     ${chalk.dim('Created:')} ${r.created_at}`);
+          if (r.tags && r.tags.length) console.log(`     ${chalk.dim('Tags:')} ${r.tags.join(', ')}`);
+        }
         console.log();
       });
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
@@ -8003,6 +8012,20 @@ brainCmd.command('status')
       Object.entries(status).forEach(([k, v]) => {
         console.log(`  ${chalk.bold(k + ':')} ${v}`);
       });
+      // AGI subsystem fields
+      if (status.sona_patterns !== undefined) {
+        console.log(chalk.bold('\n  AGI Subsystems'));
+        if (status.sona_patterns !== undefined) console.log(`  ${chalk.dim('SONA Patterns:')} ${status.sona_patterns}  ${chalk.dim('Trajectories:')} ${status.sona_trajectories || 0}`);
+        if (status.gwt_workspace_load !== undefined) console.log(`  ${chalk.dim('GWT Load:')} ${status.gwt_workspace_load}  ${chalk.dim('Avg Salience:')} ${status.gwt_avg_salience || 0}`);
+        if (status.knowledge_velocity !== undefined) console.log(`  ${chalk.dim('Temporal Velocity:')} ${status.knowledge_velocity}/hr  ${chalk.dim('Deltas:')} ${status.temporal_deltas || 0}`);
+        if (status.meta_avg_regret !== undefined) console.log(`  ${chalk.dim('Meta Regret:')} ${status.meta_avg_regret}  ${chalk.dim('Plateau:')} ${status.meta_plateau_status || 'unknown'}`);
+      }
+      if (status.midstream_scheduler_ticks !== undefined) {
+        console.log(chalk.bold('\n  Midstream'));
+        console.log(`  ${chalk.dim('Scheduler Ticks:')} ${status.midstream_scheduler_ticks}`);
+        console.log(`  ${chalk.dim('Attractor Categories:')} ${status.midstream_attractor_categories || 0}`);
+        console.log(`  ${chalk.dim('Strange-Loop:')} v${status.midstream_strange_loop_version || '?'}`);
+      }
       console.log();
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
   });
@@ -8173,6 +8196,299 @@ brainCmd.command('node <action> [args...]')
     } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
   });
 
+// ── Brain AGI Subcommands ── AGI subsystem diagnostics ──────────────────
+const agiCmd = brainCmd.command('agi').description('AGI subsystem diagnostics — SONA, GWT, temporal, meta-learning, midstream');
+
+async function fetchBrainEndpoint(config, endpoint) {
+  const url = (config.url || 'https://pi.ruv.io') + endpoint;
+  const headers = {};
+  if (config.key) headers['Authorization'] = `Bearer ${config.key}`;
+  const resp = await fetch(url, { headers });
+  if (!resp.ok) throw new Error(`${resp.status} ${resp.statusText}`);
+  return resp.json();
+}
+
+agiCmd.command('status')
+  .description('Combined AGI + midstream diagnostics from π.ruv.io')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const status = await fetchBrainEndpoint(config, '/v1/status');
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(status, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  π.ruv.io AGI Diagnostics\n'));
+      console.log(chalk.bold('  SONA'));
+      console.log(`    Patterns: ${status.sona_patterns || 0}  Trajectories: ${status.sona_trajectories || 0}`);
+      console.log(`    Background ticks: ${status.sona_background_ticks || 0}`);
+      console.log(chalk.bold('\n  GWT Attention'));
+      console.log(`    Workspace load: ${status.gwt_workspace_load || 0}`);
+      console.log(`    Avg salience: ${status.gwt_avg_salience || 0}`);
+      console.log(chalk.bold('\n  Temporal'));
+      console.log(`    Total deltas: ${status.temporal_deltas || 0}`);
+      console.log(`    Velocity: ${status.knowledge_velocity || 0}/hr`);
+      console.log(`    Trend: ${status.temporal_trend || 'unknown'}`);
+      console.log(chalk.bold('\n  Meta-Learning'));
+      console.log(`    Avg regret: ${status.meta_avg_regret || 0}`);
+      console.log(`    Plateau: ${status.meta_plateau_status || 'unknown'}`);
+      console.log(chalk.bold('\n  Midstream'));
+      console.log(`    Scheduler ticks: ${status.midstream_scheduler_ticks || 0}`);
+      console.log(`    Attractor categories: ${status.midstream_attractor_categories || 0}`);
+      console.log(`    Strange-loop: v${status.midstream_strange_loop_version || '?'}`);
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+agiCmd.command('sona')
+  .description('SONA learning engine — patterns, trajectories, background ticks')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/sona/stats');
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  SONA Learning Engine\n'));
+      Object.entries(data).forEach(([k, v]) => console.log(`  ${chalk.bold(k + ':')} ${v}`));
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+agiCmd.command('temporal')
+  .description('Temporal delta tracking — velocity, trend, total deltas')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/temporal');
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  Temporal Delta Tracking\n'));
+      Object.entries(data).forEach(([k, v]) => console.log(`  ${chalk.bold(k + ':')} ${v}`));
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+agiCmd.command('explore')
+  .description('Meta-learning exploration — curiosity, regret, plateau, Pareto')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/explore');
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  Meta-Learning Exploration\n'));
+      Object.entries(data).forEach(([k, v]) => console.log(`  ${chalk.bold(k + ':')} ${v}`));
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+agiCmd.command('midstream')
+  .description('Midstream platform — scheduler, attractor, solver, strange-loop')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/midstream');
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  Midstream Platform\n'));
+      Object.entries(data).forEach(([k, v]) => {
+        if (typeof v === 'object' && v !== null) {
+          console.log(`  ${chalk.bold(k + ':')}`);
+          Object.entries(v).forEach(([sk, sv]) => console.log(`    ${chalk.dim(sk + ':')} ${sv}`));
+        } else {
+          console.log(`  ${chalk.bold(k + ':')} ${v}`);
+        }
+      });
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+agiCmd.command('flags')
+  .description('Show feature flag state from backend')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const status = await fetchBrainEndpoint(config, '/v1/status');
+      const flags = {};
+      for (const [k, v] of Object.entries(status)) {
+        if (typeof v === 'boolean' || k.startsWith('rvf_') || k.endsWith('_enabled')) {
+          flags[k] = v;
+        }
+      }
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(flags, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  Feature Flags\n'));
+      Object.entries(flags).forEach(([k, v]) => {
+        const icon = v ? chalk.green('●') : chalk.red('○');
+        console.log(`  ${icon} ${chalk.bold(k)}: ${v}`);
+      });
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+// ============================================================================
+// Midstream Commands — Real-time streaming analysis platform
+// ============================================================================
+
+const midstreamCmd = program.command('midstream').description('Real-time streaming analysis — attractor, scheduler, benchmark');
+
+midstreamCmd.command('status')
+  .description('Midstream platform overview')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/midstream');
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  Midstream Platform Status\n'));
+      Object.entries(data).forEach(([k, v]) => {
+        if (typeof v === 'object' && v !== null) {
+          console.log(`  ${chalk.bold(k + ':')}`);
+          Object.entries(v).forEach(([sk, sv]) => console.log(`    ${chalk.dim(sk + ':')} ${sv}`));
+        } else {
+          console.log(`  ${chalk.bold(k + ':')} ${v}`);
+        }
+      });
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+midstreamCmd.command('attractor [category]')
+  .description('Lyapunov attractor analysis per category')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (category, opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/midstream');
+      const attractors = data.attractor_categories || data.attractors || {};
+      if (category) {
+        const entry = typeof attractors === 'object' ? attractors[category] : null;
+        if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(entry || { error: 'Category not found' }, null, 2)); return; }
+        if (!entry) { console.log(chalk.yellow(`  No attractor data for category: ${category}`)); return; }
+        console.log(chalk.bold.cyan(`\n  Attractor: ${category}\n`));
+        Object.entries(entry).forEach(([k, v]) => console.log(`  ${chalk.bold(k + ':')} ${v}`));
+      } else {
+        if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(attractors, null, 2)); return; }
+        console.log(chalk.bold.cyan('\n  Attractor Categories\n'));
+        if (typeof attractors === 'object' && Object.keys(attractors).length > 0) {
+          Object.entries(attractors).forEach(([cat, info]) => {
+            console.log(`  ${chalk.yellow(cat + ':')} ${typeof info === 'object' ? JSON.stringify(info) : info}`);
+          });
+        } else {
+          console.log(chalk.dim(`  ${typeof attractors === 'number' ? attractors + ' categories tracked' : 'No attractor data available'}`));
+        }
+      }
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+midstreamCmd.command('scheduler')
+  .description('Nanosecond scheduler performance metrics')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    try {
+      const data = await fetchBrainEndpoint(config, '/v1/midstream');
+      const sched = data.scheduler || { ticks: data.scheduler_ticks || 0 };
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(sched, null, 2)); return; }
+      console.log(chalk.bold.cyan('\n  Nanosecond Scheduler\n'));
+      if (typeof sched === 'object') {
+        Object.entries(sched).forEach(([k, v]) => console.log(`  ${chalk.bold(k + ':')} ${v}`));
+      } else {
+        console.log(`  ${chalk.bold('Ticks:')} ${sched}`);
+      }
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
+midstreamCmd.command('benchmark')
+  .description('Run latency benchmark against brain backend')
+  .option('--url <url>', 'Brain server URL')
+  .option('--key <key>', 'Pi key')
+  .option('-n, --concurrent <n>', 'Concurrent search requests', '20')
+  .option('--json', 'Output as JSON')
+  .action(async (opts) => {
+    const config = getBrainConfig(opts);
+    const baseUrl = config.url || 'https://pi.ruv.io';
+    const headers = {};
+    if (config.key) headers['Authorization'] = `Bearer ${config.key}`;
+    const concurrentN = Math.min(parseInt(opts.concurrent) || 20, 100);
+
+    async function timeRequest(url, label) {
+      const start = performance.now();
+      const resp = await fetch(url, { headers });
+      const elapsed = performance.now() - start;
+      return { label, status: resp.status, elapsed };
+    }
+
+    function percentile(sorted, p) {
+      const idx = Math.ceil(sorted.length * p / 100) - 1;
+      return sorted[Math.max(0, idx)];
+    }
+
+    try {
+      if (!opts.json && process.stdout.isTTY) console.log(chalk.bold.cyan('\n  Midstream Benchmark\n'));
+
+      // Sequential tests (3 each)
+      const endpoints = [
+        { path: '/v1/health', label: 'health' },
+        { path: '/v1/status', label: 'status' },
+        { path: '/v1/memories/search?q=test&limit=3', label: 'search' },
+        { path: '/v1/midstream', label: 'midstream' },
+      ];
+
+      const sequential = {};
+      for (const ep of endpoints) {
+        const times = [];
+        for (let i = 0; i < 3; i++) {
+          const r = await timeRequest(baseUrl + ep.path, ep.label);
+          times.push(r.elapsed);
+        }
+        sequential[ep.label] = { avg: times.reduce((a, b) => a + b, 0) / times.length, min: Math.min(...times), max: Math.max(...times) };
+      }
+
+      // Concurrent search test
+      const concurrentTimes = [];
+      const promises = [];
+      for (let i = 0; i < concurrentN; i++) {
+        promises.push(timeRequest(baseUrl + '/v1/memories/search?q=test&limit=3', 'concurrent'));
+      }
+      const results = await Promise.all(promises);
+      const sorted = results.map(r => r.elapsed).sort((a, b) => a - b);
+      const p50 = percentile(sorted, 50);
+      const p90 = percentile(sorted, 90);
+      const p99 = percentile(sorted, 99);
+
+      const benchResult = { sequential, concurrent: { count: concurrentN, p50, p90, p99 } };
+
+      if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(benchResult, null, 2)); return; }
+
+      console.log(chalk.bold('  Sequential (3 rounds each):'));
+      for (const [label, data] of Object.entries(sequential)) {
+        console.log(`    ${chalk.yellow(label.padEnd(12))} avg: ${data.avg.toFixed(1)}ms  min: ${data.min.toFixed(1)}ms  max: ${data.max.toFixed(1)}ms`);
+      }
+      console.log(chalk.bold(`\n  Concurrent (${concurrentN}x search):`));
+      console.log(`    p50: ${p50.toFixed(1)}ms  p90: ${p90.toFixed(1)}ms  p99: ${p99.toFixed(1)}ms`);
+      console.log();
+    } catch (e) { console.error(chalk.red(`Error: ${e.message}`)); process.exit(1); }
+  });
+
 // ============================================================================
 // Edge Commands — Distributed compute via @ruvector/edge-net
 // ============================================================================
@@ -8219,7 +8535,9 @@ edgeCmd.command('balance')
     const piKey = process.env.PI;
     if (!piKey) { console.error(chalk.red('Set PI environment variable first.')); process.exit(1); }
     try {
-      const resp = await fetch(`${EDGE_GENESIS}/balance/${piKey}`, { headers: { 'Authorization': `Bearer ${piKey}` } });
+      const pseudonym = require('crypto').createHash('shake256', { outputLength: 16 }).update(piKey).digest('hex');
+      const resp = await fetch(`${EDGE_GENESIS}/balance/${pseudonym}`, { headers: { 'Authorization': `Bearer ${piKey}` } });
+      if (!resp.ok) { console.error(chalk.red(`Edge network returned ${resp.status} ${resp.statusText}`)); process.exit(1); }
       const data = await resp.json();
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(data, null, 2)); return; }
       console.log(chalk.bold.cyan('\nrUv Balance\n'));
@@ -8437,13 +8755,20 @@ function loadSona() {
   }
 }
 
+const SONA_DEFAULT_DIM = 128;
+function createSonaEngine(sona) {
+  if (sona.SonaEngine) return new sona.SonaEngine(SONA_DEFAULT_DIM);
+  if (sona.SonaCoordinator) return new sona.SonaCoordinator(SONA_DEFAULT_DIM);
+  throw new Error('No SONA engine class found');
+}
+
 sonaCmd.command('status')
   .description('Show SONA learning engine status')
   .option('--json', 'Output as JSON')
   .action((opts) => {
     const sona = loadSona();
     try {
-      const engine = sona.SonaEngine ? new sona.SonaEngine() : new sona.SonaCoordinator();
+      const engine = createSonaEngine(sona);
       const status = engine.getStatus ? engine.getStatus() : { ready: true };
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(status, null, 2)); return; }
       console.log(chalk.bold.cyan('\nSONA Status\n'));
@@ -8459,7 +8784,7 @@ sonaCmd.command('patterns <query>')
   .action((query, opts) => {
     const sona = loadSona();
     try {
-      const engine = sona.SonaEngine ? new sona.SonaEngine() : new sona.SonaCoordinator();
+      const engine = createSonaEngine(sona);
       const patterns = engine.findPatterns ? engine.findPatterns(query, { threshold: parseFloat(opts.threshold) }) : [];
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(patterns, null, 2)); return; }
       console.log(chalk.bold.cyan('\nLearned Patterns\n'));
@@ -8475,7 +8800,7 @@ sonaCmd.command('train <data>')
   .action((data, opts) => {
     const sona = loadSona();
     try {
-      const engine = sona.SonaEngine ? new sona.SonaEngine() : new sona.SonaCoordinator();
+      const engine = createSonaEngine(sona);
       if (engine.recordTrajectory) { engine.recordTrajectory(data, opts.outcome); }
       else if (engine.train) { engine.train(data); }
       console.log(chalk.green('Training trajectory recorded.'));
@@ -8488,7 +8813,7 @@ sonaCmd.command('export')
   .action((opts) => {
     const sona = loadSona();
     try {
-      const engine = sona.SonaEngine ? new sona.SonaEngine() : new sona.SonaCoordinator();
+      const engine = createSonaEngine(sona);
       const weights = engine.exportWeights ? engine.exportWeights() : engine.export ? engine.export() : {};
       fs.writeFileSync(opts.output, JSON.stringify(weights, null, 2));
       console.log(chalk.green(`Exported to ${opts.output}`));
@@ -8501,7 +8826,7 @@ sonaCmd.command('stats')
   .action((opts) => {
     const sona = loadSona();
     try {
-      const engine = sona.SonaEngine ? new sona.SonaEngine() : new sona.SonaCoordinator();
+      const engine = createSonaEngine(sona);
       const stats = engine.getStats ? engine.getStats() : engine.stats ? engine.stats() : {};
       if (opts.json || !process.stdout.isTTY) { console.log(JSON.stringify(stats, null, 2)); return; }
       console.log(chalk.bold.cyan('\nSONA Statistics\n'));

package/bin/mcp-server.js

@@ -363,7 +363,7 @@ class Intelligence {
 const server = new Server(
   {
     name: 'ruvector',
-    version: '0.2.2',
+    version: '0.2.4',
   },
   {
     capabilities: {
@@ -1396,6 +1396,85 @@ const TOOLS = [
       }
     }
   },
+  // ── Brain AGI Tools (6) ── AGI subsystem diagnostics via direct fetch ──
+  {
+    name: 'brain_agi_status',
+    description: 'Combined AGI subsystem diagnostics — SONA, GWT, temporal, meta-learning, midstream',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'brain_sona_stats',
+    description: 'SONA learning engine stats — patterns, trajectories, background ticks',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'brain_temporal',
+    description: 'Temporal delta tracking — velocity, trend, total deltas',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'brain_explore',
+    description: 'Meta-learning exploration — curiosity, regret, plateau status, Pareto frontier',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'brain_midstream',
+    description: 'Midstream platform diagnostics — scheduler, attractor, solver, strange-loop',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'brain_flags',
+    description: 'Show backend feature flag state (RVF, AGI, midstream flags)',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  // ── Midstream Tools (6) ── Real-time streaming analysis platform ──
+  {
+    name: 'midstream_status',
+    description: 'Full midstream platform diagnostics — scheduler, attractor, solver, strange-loop',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'midstream_attractor',
+    description: 'Attractor categories with Lyapunov exponent analysis',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: { type: 'string', description: 'Optional category to filter (e.g., pattern, solution)' }
+      }
+    }
+  },
+  {
+    name: 'midstream_scheduler',
+    description: 'Nanosecond scheduler performance metrics — ticks, tasks/sec',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'midstream_benchmark',
+    description: 'Run sequential + concurrent latency benchmark against brain backend',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        concurrent_count: { type: 'number', description: 'Number of concurrent search requests (default 20, max 100)' }
+      }
+    }
+  },
+  {
+    name: 'midstream_search',
+    description: 'Semantic search with midstream scoring metadata in response',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        limit: { type: 'number', description: 'Max results (default 10)' }
+      },
+      required: ['query']
+    }
+  },
+  {
+    name: 'midstream_health',
+    description: 'Combined health + midstream subsystem check',
+    inputSchema: { type: 'object', properties: {} }
+  },
   // ── Edge Tools (4) ── Distributed compute via @ruvector/edge-net ──
   {
     name: 'edge_status',
@@ -3239,6 +3318,189 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
       }
 
+      // ── Brain AGI Tool Handlers ────────────────────────────────────────────
+      case 'brain_agi_status':
+      case 'brain_sona_stats':
+      case 'brain_temporal':
+      case 'brain_explore':
+      case 'brain_midstream':
+      case 'brain_flags': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+
+          const endpointMap = {
+            brain_agi_status: '/v1/status',
+            brain_sona_stats: '/v1/sona/stats',
+            brain_temporal: '/v1/temporal',
+            brain_explore: '/v1/explore',
+            brain_midstream: '/v1/midstream',
+            brain_flags: '/v1/status',
+          };
+          const endpoint = endpointMap[name];
+          const resp = await fetch(`${brainUrl}${endpoint}`, { headers: hdrs });
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
+          let data = await resp.json();
+
+          // For brain_flags, extract only flag-related fields
+          if (name === 'brain_flags') {
+            const flags = {};
+            for (const [k, v] of Object.entries(data)) {
+              if (typeof v === 'boolean' || k.startsWith('rvf_') || k.endsWith('_enabled') || (k.startsWith('midstream_') && typeof v === 'boolean')) {
+                flags[k] = v;
+              }
+            }
+            data = flags;
+          }
+
+          // For brain_agi_status, extract AGI-specific fields
+          if (name === 'brain_agi_status') {
+            const agiFields = {};
+            const agiKeys = ['sona_patterns', 'sona_trajectories', 'sona_background_ticks', 'gwt_workspace_load', 'gwt_avg_salience', 'knowledge_velocity', 'temporal_deltas', 'temporal_trend', 'meta_avg_regret', 'meta_plateau_status', 'midstream_scheduler_ticks', 'midstream_attractor_categories', 'midstream_strange_loop_version'];
+            for (const k of agiKeys) {
+              if (data[k] !== undefined) agiFields[k] = data[k];
+            }
+            data = Object.keys(agiFields).length > 0 ? agiFields : data;
+          }
+
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...data }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      // ── Midstream Tool Handlers ────────────────────────────────────────────
+      case 'midstream_status':
+      case 'midstream_attractor':
+      case 'midstream_scheduler': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+
+          const resp = await fetch(`${brainUrl}/v1/midstream`, { headers: hdrs });
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
+          let data = await resp.json();
+
+          if (name === 'midstream_attractor') {
+            data = data.attractor_categories || data.attractors || data;
+            if (args.category && typeof data === 'object') data = data[args.category] || { error: `Category '${args.category}' not found` };
+          } else if (name === 'midstream_scheduler') {
+            data = data.scheduler || { ticks: data.scheduler_ticks || 0 };
+          }
+
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...data }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      case 'midstream_benchmark': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+          const concurrentN = Math.min(args.concurrent_count || 20, 100);
+
+          async function timeFetch(url) {
+            const start = performance.now();
+            const resp = await fetch(url, { headers: hdrs });
+            return { status: resp.status, elapsed: performance.now() - start };
+          }
+
+          // Sequential tests
+          const endpoints = [
+            { path: '/v1/health', label: 'health' },
+            { path: '/v1/status', label: 'status' },
+            { path: '/v1/memories/search?q=test&limit=3', label: 'search' },
+            { path: '/v1/midstream', label: 'midstream' },
+          ];
+
+          const sequential = {};
+          for (const ep of endpoints) {
+            const times = [];
+            for (let i = 0; i < 3; i++) {
+              const r = await timeFetch(brainUrl + ep.path);
+              times.push(r.elapsed);
+            }
+            sequential[ep.label] = {
+              avg_ms: +(times.reduce((a, b) => a + b, 0) / times.length).toFixed(1),
+              min_ms: +Math.min(...times).toFixed(1),
+              max_ms: +Math.max(...times).toFixed(1)
+            };
+          }
+
+          // Concurrent search
+          const promises = [];
+          for (let i = 0; i < concurrentN; i++) {
+            promises.push(timeFetch(brainUrl + '/v1/memories/search?q=test&limit=3'));
+          }
+          const results = await Promise.all(promises);
+          const sorted = results.map(r => r.elapsed).sort((a, b) => a - b);
+          const pct = (p) => +(sorted[Math.max(0, Math.ceil(sorted.length * p / 100) - 1)]).toFixed(1);
+
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            sequential,
+            concurrent: { count: concurrentN, p50_ms: pct(50), p90_ms: pct(90), p99_ms: pct(99) }
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      case 'midstream_search': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+          const limit = Math.min(Math.max(parseInt(args.limit) || 10, 1), 100);
+          const q = encodeURIComponent(args.query);
+          const resp = await fetch(`${brainUrl}/v1/memories/search?q=${q}&limit=${limit}`, { headers: hdrs });
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
+          const data = await resp.json();
+          return { content: [{ type: 'text', text: JSON.stringify({ success: true, results: data, count: Array.isArray(data) ? data.length : 0 }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
+      case 'midstream_health': {
+        try {
+          const brainUrl = process.env.BRAIN_URL || 'https://pi.ruv.io';
+          const brainKey = process.env.PI;
+          const hdrs = { 'Content-Type': 'application/json' };
+          if (brainKey) hdrs['Authorization'] = `Bearer ${brainKey}`;
+
+          const [healthResp, midResp] = await Promise.all([
+            fetch(`${brainUrl}/v1/health`, { headers: hdrs }).then(r => r.json()).catch(e => ({ error: e.message })),
+            fetch(`${brainUrl}/v1/midstream`, { headers: hdrs }).then(r => r.json()).catch(e => ({ error: e.message })),
+          ]);
+
+          return { content: [{ type: 'text', text: JSON.stringify({
+            success: true,
+            health: healthResp,
+            midstream: midResp
+          }, null, 2) }] };
+        } catch (e) {
+          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
+        }
+      }
+
       // ── Edge Tool Handlers ───────────────────────────────────────────────
       case 'edge_status':
       case 'edge_join':
@@ -3251,7 +3513,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
           switch (subCmd) {
             case 'status': endpoint = '/status'; break;
             case 'join': endpoint = '/join'; method = 'POST'; body = JSON.stringify({ contribution: args.contribution || 0.3, pi_key: process.env.PI }); break;
-            case 'balance': endpoint = `/balance/${process.env.PI || 'anonymous'}`; break;
+            case 'balance': { const ps = process.env.PI ? require('crypto').createHash('shake256', { outputLength: 16 }).update(process.env.PI).digest('hex') : 'anonymous'; endpoint = `/balance/${ps}`; break; }
             case 'tasks': endpoint = `/tasks?limit=${args.limit || 20}`; break;
           }
           const resp = await fetch(`${genesisUrl}${endpoint}`, {
@@ -3259,6 +3521,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             headers: { 'Content-Type': 'application/json', ...(process.env.PI ? { 'Authorization': `Bearer ${process.env.PI}` } : {}) },
             ...(body ? { body } : {})
           });
+          if (!resp.ok) {
+            const errText = await resp.text().catch(() => resp.statusText);
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `${resp.status} ${errText}` }, null, 2) }], isError: true };
+          }
           const data = await resp.json();
           return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...data }, null, 2) }] };
         } catch (e) {
@@ -3521,7 +3787,7 @@ async function main() {
           transport: 'sse',
           sessions: sessions.size,
           tools: 91,
-          version: '0.2.2'
+          version: '0.2.4'
         }));
 
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvector",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "High-performance vector database for Node.js with automatic native/WASM fallback",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",