claude-flow 3.10.3 → 3.10.5

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/cli/src/commands/embeddings.ts

@@ -1,1796 +0,0 @@
-/**
- * V3 CLI Embeddings Command
- * Vector embeddings, semantic search, similarity operations
- *
- * Features:
- * - Multiple providers: OpenAI, Transformers.js, Agentic-Flow, Mock
- * - Document chunking with overlap
- * - L2/L1/minmax/zscore normalization
- * - Hyperbolic embeddings (Poincaré ball)
- * - Neural substrate integration
- * - Persistent SQLite cache
- *
- * Created with ❤️ by ruv.io
- */
-
-import type { Command, CommandContext, CommandResult } from '../types.js';
-import { output } from '../output.js';
-
-// Dynamic imports for embeddings package
-async function getEmbeddings() {
-  try {
-    return await import('@claude-flow/embeddings');
-  } catch {
-    return null;
-  }
-}
-
-// Generate subcommand - REAL implementation
-const generateCommand: Command = {
-  name: 'generate',
-  description: 'Generate embeddings for text',
-  options: [
-    { name: 'text', short: 't', type: 'string', description: 'Text to embed', required: true },
-    { name: 'provider', short: 'p', type: 'string', description: 'Provider: openai, transformers, agentic-flow, local', default: 'local' },
-    { name: 'model', short: 'm', type: 'string', description: 'Model to use' },
-    { name: 'output', short: 'o', type: 'string', description: 'Output format: json, array, preview', default: 'preview' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings generate -t "Hello world"', description: 'Generate embedding' },
-    { command: 'claude-flow embeddings generate -t "Test" -o json', description: 'Output as JSON' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const text = ctx.flags.text as string;
-    const provider = ctx.flags.provider as string || 'local';
-    const outputFormat = ctx.flags.output as string || 'preview';
-
-    if (!text) {
-      output.printError('Text is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Generate Embedding'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: `Generating with ${provider}...`, spinner: 'dots' });
-    spinner.start();
-
-    try {
-      // Use real embedding generator
-      const { generateEmbedding, loadEmbeddingModel } = await import('../memory/memory-initializer.js');
-
-      const startTime = Date.now();
-      const modelInfo = await loadEmbeddingModel({ verbose: false });
-      const result = await generateEmbedding(text);
-      const duration = Date.now() - startTime;
-
-      spinner.succeed(`Embedding generated in ${duration}ms`);
-
-      if (outputFormat === 'json') {
-        output.printJson({
-          text: text.substring(0, 100),
-          embedding: result.embedding,
-          dimensions: result.dimensions,
-          model: result.model,
-          duration
-        });
-        return { success: true, data: result };
-      }
-
-      if (outputFormat === 'array') {
-        output.writeln(JSON.stringify(result.embedding));
-        return { success: true, data: result };
-      }
-
-      // Preview format (default)
-      const preview = result.embedding.slice(0, 8).map(v => v.toFixed(6));
-
-      output.writeln();
-      output.printBox([
-        `Provider: ${provider}`,
-        `Model: ${result.model} (${modelInfo.modelName})`,
-        `Dimensions: ${result.dimensions}`,
-        `Text: "${text.substring(0, 40)}${text.length > 40 ? '...' : ''}"`,
-        `Generation time: ${duration}ms`,
-        ``,
-        `Vector preview (first 8 of ${result.dimensions}):`,
-        `[${preview.join(', ')}, ...]`,
-      ].join('\n'), 'Result');
-
-      return { success: true, data: result };
-    } catch (error) {
-      spinner.fail('Embedding generation failed');
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Search subcommand - REAL implementation using sql.js
-const searchCommand: Command = {
-  name: 'search',
-  description: 'Semantic similarity search',
-  options: [
-    { name: 'query', short: 'q', type: 'string', description: 'Search query', required: true },
-    { name: 'collection', short: 'c', type: 'string', description: 'Namespace to search', default: 'default' },
-    { name: 'limit', short: 'l', type: 'number', description: 'Max results', default: '10' },
-    { name: 'threshold', short: 't', type: 'number', description: 'Similarity threshold (0-1)', default: '0.5' },
-    { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings search -q "error handling"', description: 'Search for similar' },
-    { command: 'claude-flow embeddings search -q "test" -l 5', description: 'Limit results' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const query = ctx.flags.query as string;
-    const namespace = ctx.flags.collection as string || 'default';
-    const limit = parseInt(ctx.flags.limit as string || '10', 10);
-    const threshold = parseFloat(ctx.flags.threshold as string || '0.5');
-    const dbPath = ctx.flags['db-path'] as string || '.swarm/memory.db';
-
-    if (!query) {
-      output.printError('Query is required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Semantic Search'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    const spinner = output.createSpinner({ text: 'Searching...', spinner: 'dots' });
-    spinner.start();
-
-    try {
-      const fs = await import('fs');
-      const path = await import('path');
-      const fullDbPath = path.resolve(process.cwd(), dbPath);
-
-      // Check if database exists
-      if (!fs.existsSync(fullDbPath)) {
-        spinner.fail('Database not found');
-        output.printWarning(`No database at ${fullDbPath}`);
-        output.printInfo('Run: claude-flow memory init');
-        return { success: false, exitCode: 1 };
-      }
-
-      // Load sql.js
-      const initSqlJs = (await import('sql.js')).default;
-      const SQL = await initSqlJs();
-
-      const fileBuffer = fs.readFileSync(fullDbPath);
-      const db = new SQL.Database(fileBuffer);
-
-      const startTime = Date.now();
-
-      // Generate embedding for query
-      const { generateEmbedding } = await import('../memory/memory-initializer.js');
-      const queryResult = await generateEmbedding(query);
-      const queryEmbedding = queryResult.embedding;
-
-      // Get all entries with embeddings from database
-      // Parameterized query to prevent SQL injection (CRIT-01)
-      const embeddingSql = namespace !== 'all'
-        ? `SELECT id, key, namespace, content, embedding, embedding_dimensions
-           FROM memory_entries
-           WHERE status = 'active' AND embedding IS NOT NULL AND namespace = ?
-           LIMIT 1000`
-        : `SELECT id, key, namespace, content, embedding, embedding_dimensions
-           FROM memory_entries
-           WHERE status = 'active' AND embedding IS NOT NULL
-           LIMIT 1000`;
-
-      const embeddingStmt = db.prepare(embeddingSql);
-      if (namespace !== 'all') {
-        embeddingStmt.bind([namespace]);
-      }
-
-      const entryRows: any[][] = [];
-      while (embeddingStmt.step()) {
-        entryRows.push(embeddingStmt.get());
-      }
-      embeddingStmt.free();
-
-      const results: { score: number; id: string; key: string; content: string; namespace: string }[] = [];
-
-      for (const row of entryRows) {
-        const [id, key, ns, content, embeddingJson] = row as [string, string, string, string, string];
-
-        if (!embeddingJson) continue;
-
-        try {
-          const embedding = JSON.parse(embeddingJson) as number[];
-
-          // Calculate cosine similarity
-          const similarity = cosineSimilarity(queryEmbedding, embedding);
-
-          if (similarity >= threshold) {
-            results.push({
-              score: similarity,
-              id: id.substring(0, 10),
-              key: key || id.substring(0, 15),
-              content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
-              namespace: ns || 'default'
-            });
-          }
-        } catch {
-          // Skip entries with invalid embeddings
-        }
-      }
-
-      // Keyword search fallback with parameterized query (CRIT-01)
-      if (results.length < limit) {
-        const likePattern = `%${query}%`;
-        const remainingLimit = Math.max(0, limit - results.length);
-        const keywordSql = namespace !== 'all'
-          ? `SELECT id, key, namespace, content
-             FROM memory_entries
-             WHERE status = 'active'
-               AND (content LIKE ? OR key LIKE ?)
-               AND namespace = ?
-             LIMIT ?`
-          : `SELECT id, key, namespace, content
-             FROM memory_entries
-             WHERE status = 'active'
-               AND (content LIKE ? OR key LIKE ?)
-             LIMIT ?`;
-
-        const keywordStmt = db.prepare(keywordSql);
-        if (namespace !== 'all') {
-          keywordStmt.bind([likePattern, likePattern, namespace, remainingLimit]);
-        } else {
-          keywordStmt.bind([likePattern, likePattern, remainingLimit]);
-        }
-
-        const keywordRows: any[][] = [];
-        while (keywordStmt.step()) {
-          keywordRows.push(keywordStmt.get());
-        }
-        keywordStmt.free();
-
-        for (const row of keywordRows) {
-          const [id, key, ns, content] = row as [string, string, string, string];
-
-          // Avoid duplicates
-          if (!results.some(r => r.id === id.substring(0, 10))) {
-            results.push({
-              score: 0.5, // Keyword match base score
-              id: id.substring(0, 10),
-              key: key || id.substring(0, 15),
-              content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
-              namespace: ns || 'default'
-            });
-          }
-        }
-      }
-
-      // Sort by score descending
-      results.sort((a, b) => b.score - a.score);
-      const topResults = results.slice(0, limit);
-
-      const searchTime = Date.now() - startTime;
-      db.close();
-
-      spinner.succeed(`Found ${topResults.length} matches (${searchTime}ms)`);
-
-      if (topResults.length === 0) {
-        output.writeln();
-        output.printWarning('No matches found');
-        output.printInfo(`Try: claude-flow memory store -k "key" --value "your data"`);
-        return { success: true, data: [] };
-      }
-
-      output.writeln();
-      output.printTable({
-        columns: [
-          { key: 'score', header: 'Score', width: 10 },
-          { key: 'key', header: 'Key', width: 18 },
-          { key: 'content', header: 'Content', width: 42 },
-        ],
-        data: topResults.map(r => ({
-          score: r.score >= 0.8 ? output.success(r.score.toFixed(2)) :
-                 r.score >= 0.6 ? output.warning(r.score.toFixed(2)) :
-                 output.dim(r.score.toFixed(2)),
-          key: r.key,
-          content: r.content
-        })),
-      });
-
-      output.writeln();
-      output.writeln(output.dim(`Searched ${namespace} namespace (${queryResult.model}, ${searchTime}ms)`));
-
-      return { success: true, data: topResults };
-    } catch (error) {
-      spinner.fail('Search failed');
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-/**
- * Optimized cosine similarity
- * V8 JIT-friendly - ~0.5μs per 384-dim vector comparison
- */
-function cosineSimilarity(a: number[], b: number[]): number {
-  const len = Math.min(a.length, b.length);
-  if (len === 0) return 0;
-
-  let dot = 0, normA = 0, normB = 0;
-
-  // Simple loop - V8 optimizes this well
-  for (let i = 0; i < len; i++) {
-    const ai = a[i], bi = b[i];
-    dot += ai * bi;
-    normA += ai * ai;
-    normB += bi * bi;
-  }
-
-  const mag = Math.sqrt(normA * normB);
-  return mag === 0 ? 0 : dot / mag;
-}
-
-// Compare subcommand - REAL similarity computation
-const compareCommand: Command = {
-  name: 'compare',
-  description: 'Compare similarity between texts',
-  options: [
-    { name: 'text1', type: 'string', description: 'First text', required: true },
-    { name: 'text2', type: 'string', description: 'Second text', required: true },
-    { name: 'metric', short: 'm', type: 'string', description: 'Metric: cosine, euclidean, dot', default: 'cosine' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings compare --text1 "Hello" --text2 "Hi there"', description: 'Compare texts' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const text1 = ctx.flags.text1 as string;
-    const text2 = ctx.flags.text2 as string;
-    const metric = ctx.flags.metric as string || 'cosine';
-
-    if (!text1 || !text2) {
-      output.printError('Both text1 and text2 are required');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.writeln(output.bold('Text Similarity (Real)'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: 'Generating embeddings...', spinner: 'dots' });
-    spinner.start();
-
-    try {
-      const { generateEmbedding } = await import('../memory/memory-initializer.js');
-
-      // Generate real embeddings for both texts
-      const startTime = Date.now();
-      const [emb1, emb2] = await Promise.all([
-        generateEmbedding(text1),
-        generateEmbedding(text2),
-      ]);
-      const embedTime = Date.now() - startTime;
-
-      spinner.setText('Computing similarity...');
-
-      // Compute real similarity based on metric
-      let similarity: number;
-
-      switch (metric) {
-        case 'euclidean': {
-          // Euclidean distance (converted to similarity: 1 / (1 + distance))
-          let sumSq = 0;
-          for (let i = 0; i < emb1.embedding.length; i++) {
-            const diff = emb1.embedding[i] - emb2.embedding[i];
-            sumSq += diff * diff;
-          }
-          const distance = Math.sqrt(sumSq);
-          similarity = 1 / (1 + distance);
-          break;
-        }
-        case 'dot': {
-          // Dot product
-          let dot = 0;
-          for (let i = 0; i < emb1.embedding.length; i++) {
-            dot += emb1.embedding[i] * emb2.embedding[i];
-          }
-          similarity = dot;
-          break;
-        }
-        case 'cosine':
-        default: {
-          // Cosine similarity
-          similarity = cosineSimilarity(emb1.embedding, emb2.embedding);
-        }
-      }
-
-      spinner.succeed(`Comparison complete (${embedTime}ms)`);
-
-      output.writeln();
-      output.printBox([
-        `Text 1: "${text1.substring(0, 30)}${text1.length > 30 ? '...' : ''}"`,
-        `Text 2: "${text2.substring(0, 30)}${text2.length > 30 ? '...' : ''}"`,
-        ``,
-        `Model: ${emb1.model} (${emb1.dimensions}-dim)`,
-        `Metric: ${metric}`,
-        `Similarity: ${similarity > 0.8 ? output.success(similarity.toFixed(4)) : similarity > 0.5 ? output.warning(similarity.toFixed(4)) : output.dim(similarity.toFixed(4))}`,
-        ``,
-        `Interpretation: ${similarity > 0.8 ? 'Highly similar' : similarity > 0.5 ? 'Moderately similar' : 'Dissimilar'}`,
-      ].join('\n'), 'Result');
-
-      return { success: true, data: { similarity, metric, embedTime } };
-    } catch (error) {
-      spinner.fail('Comparison failed');
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Collections subcommand - REAL implementation using sql.js
-const collectionsCommand: Command = {
-  name: 'collections',
-  description: 'Manage embedding collections (namespaces)',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: list, stats', default: 'list' },
-    { name: 'name', short: 'n', type: 'string', description: 'Namespace name' },
-    { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings collections', description: 'List collections' },
-    { command: 'claude-flow embeddings collections -a stats', description: 'Show detailed stats' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'list';
-    const dbPath = ctx.flags['db-path'] as string || '.swarm/memory.db';
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Collections (Namespaces)'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    try {
-      const fs = await import('fs');
-      const path = await import('path');
-      const fullDbPath = path.resolve(process.cwd(), dbPath);
-
-      // Check if database exists
-      if (!fs.existsSync(fullDbPath)) {
-        output.printWarning('No database found');
-        output.printInfo('Run: claude-flow memory init');
-        output.writeln();
-        output.writeln(output.dim('No collections yet - initialize memory first'));
-        return { success: true, data: [] };
-      }
-
-      // Load sql.js and query real data
-      const initSqlJs = (await import('sql.js')).default;
-      const SQL = await initSqlJs();
-
-      const fileBuffer = fs.readFileSync(fullDbPath);
-      const db = new SQL.Database(fileBuffer);
-
-      // Get collection stats from database
-      const statsQuery = db.exec(`
-        SELECT
-          namespace,
-          COUNT(*) as total_entries,
-          SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as with_embeddings,
-          AVG(embedding_dimensions) as avg_dimensions,
-          SUM(LENGTH(content)) as total_content_size
-        FROM memory_entries
-        WHERE status = 'active'
-        GROUP BY namespace
-        ORDER BY total_entries DESC
-      `);
-
-      // Get vector index info
-      const indexQuery = db.exec(`SELECT name, dimensions, hnsw_m FROM vector_indexes`);
-
-      const collections: { name: string; vectors: string; total: string; dimensions: string; index: string; size: string }[] = [];
-
-      if (statsQuery[0]?.values) {
-        for (const row of statsQuery[0].values) {
-          const [namespace, total, withEmbeddings, avgDims, contentSize] = row as [string, number, number, number, number];
-
-          collections.push({
-            name: namespace || 'default',
-            vectors: withEmbeddings.toLocaleString(),
-            total: total.toLocaleString(),
-            dimensions: avgDims ? Math.round(avgDims).toString() : '-',
-            index: withEmbeddings > 0 ? 'HNSW' : 'None',
-            size: formatBytes(contentSize || 0)
-          });
-        }
-      }
-
-      db.close();
-
-      if (collections.length === 0) {
-        output.printWarning('No collections found');
-        output.writeln();
-        output.writeln(output.dim('Store some data first:'));
-        output.writeln(output.highlight('  claude-flow memory store -k "key" --value "data"'));
-        return { success: true, data: [] };
-      }
-
-      output.printTable({
-        columns: [
-          { key: 'name', header: 'Namespace', width: 18 },
-          { key: 'total', header: 'Entries', width: 10 },
-          { key: 'vectors', header: 'Vectors', width: 10 },
-          { key: 'dimensions', header: 'Dims', width: 8 },
-          { key: 'index', header: 'Index', width: 8 },
-          { key: 'size', header: 'Size', width: 10 },
-        ],
-        data: collections,
-      });
-
-      output.writeln();
-      output.writeln(output.dim(`Database: ${fullDbPath}`));
-
-      return { success: true, data: collections };
-    } catch (error) {
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Helper: Format bytes to human readable
-function formatBytes(bytes: number): string {
-  if (bytes === 0) return '0 B';
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
-}
-
-// Index subcommand - REAL HNSW stats
-const indexCommand: Command = {
-  name: 'index',
-  description: 'Manage HNSW indexes',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: build, rebuild, status, optimize', default: 'status' },
-    { name: 'collection', short: 'c', type: 'string', description: 'Collection/namespace label (informational; HNSW is a single global index across all namespaces). Omit to build for all namespaces (#1947 RC2).' },
-    { name: 'ef-construction', type: 'number', description: 'HNSW ef_construction parameter', default: '200' },
-    { name: 'm', type: 'number', description: 'HNSW M parameter', default: '16' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings index', description: 'Show index status' },
-    { command: 'claude-flow embeddings index -a build', description: 'Build index from all namespaces' },
-    { command: 'claude-flow embeddings index -a rebuild -c project', description: 'Rebuild (label as `project`)' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'status';
-    const collection = ctx.flags.collection as string;
-    const efConstruction = parseInt(ctx.flags['ef-construction'] as string || '200', 10);
-    const m = parseInt(ctx.flags.m as string || '16', 10);
-
-    output.writeln();
-    output.writeln(output.bold(`HNSW Index: ${action}`));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    try {
-      const { getHNSWStatus, getHNSWIndex, searchHNSWIndex, generateEmbedding } = await import('../memory/memory-initializer.js');
-
-      // Trigger lazy initialization before reading status, otherwise the
-      // singleton stays null and produces a misleading "@ruvector/core not
-      // available" warning even when the package is present (#1698).
-      await getHNSWIndex().catch(() => null);
-
-      // Probe whether @ruvector/core is loadable so we can distinguish
-      // "package missing" from "package present but index empty".
-      const ruvectorAvailable = await import('@ruvector/core').then(() => true).catch(() => false);
-
-      // Get real HNSW status
-      const status = getHNSWStatus();
-
-      if (action === 'status') {
-        output.writeln();
-        output.printTable({
-          columns: [
-            { key: 'metric', header: 'Metric', width: 24 },
-            { key: 'value', header: 'Value', width: 30 },
-          ],
-          data: [
-            { metric: 'HNSW Available', value: status.available ? output.success('Yes (@ruvector/core)') : output.warning('No') },
-            { metric: 'Index Initialized', value: status.initialized ? output.success('Yes') : output.dim('No') },
-            { metric: 'Vector Count', value: status.entryCount.toLocaleString() },
-            { metric: 'Dimensions', value: String(status.dimensions) },
-            { metric: 'Distance Metric', value: 'Cosine' },
-            { metric: 'HNSW M', value: String(m) },
-            { metric: 'ef_construction', value: String(efConstruction) },
-          ],
-        });
-
-        if (status.available && status.entryCount > 0) {
-          // Run a quick benchmark to show actual performance
-          output.writeln();
-          output.writeln(output.dim('Running quick performance test...'));
-
-          const testQuery = await generateEmbedding('test performance query');
-          const start = performance.now();
-          const results = await searchHNSWIndex(testQuery.embedding, { k: 10 });
-          const searchTime = performance.now() - start;
-
-          // Estimate brute force time (0.5μs per comparison)
-          const bruteForceEstimate = status.entryCount * 0.0005;
-          const speedup = bruteForceEstimate / (searchTime / 1000);
-
-          output.writeln();
-          output.printBox([
-            `Performance (n=${status.entryCount}):`,
-            `  HNSW Search: ${searchTime.toFixed(2)}ms`,
-            `  Brute Force Est: ${(bruteForceEstimate * 1000).toFixed(2)}ms`,
-            `  Speedup: ~${Math.round(speedup)}x`,
-            `  Results: ${results?.length || 0} matches`,
-          ].join('\n'), 'Search Performance');
-        } else if (!status.available && !ruvectorAvailable) {
-          output.writeln();
-          output.printWarning('@ruvector/core not available');
-          output.printInfo('Install: npm install @ruvector/core');
-        } else if (!status.available) {
-          output.writeln();
-          output.printWarning('HNSW index not initialized (but @ruvector/core is installed)');
-          output.printInfo('This usually means no embeddings have been stored yet.');
-          output.printInfo('Run: claude-flow memory store -k "key" --value "text"');
-        } else {
-          output.writeln();
-          output.printInfo('Index is empty. Store some entries to populate it.');
-          output.printInfo('Run: claude-flow memory store -k "key" --value "text"');
-        }
-
-        return { success: true, data: status };
-      }
-
-      // Build/Rebuild action
-      if (action === 'build' || action === 'rebuild') {
-        // #1947 RC #2: `-c` is informational — the HNSW index is global
-        // and indexes every namespace's embeddings in one structure. The
-        // earlier code REQUIRED `-c` for build/rebuild AND its examples
-        // suggested `-c default`, which silently produced 0 vectors when a
-        // user's entries lived under a different namespace (e.g. `project`,
-        // `claude-memories`). Treat omitted `-c` as "all namespaces"
-        // (the actual runtime behavior) and tell the user as much.
-        const label = collection ?? '(all namespaces)';
-
-        const spinner = output.createSpinner({ text: `${action}ing index for ${label}...`, spinner: 'dots' });
-        spinner.start();
-
-        // Force rebuild if requested
-        const index = await getHNSWIndex({ forceRebuild: action === 'rebuild' });
-
-        if (!index) {
-          spinner.fail('@ruvector/core not available');
-          output.printInfo('Install: npm install @ruvector/core');
-          return { success: false, exitCode: 1 };
-        }
-
-        spinner.succeed(`Index ${action} complete`);
-
-        const newStatus = getHNSWStatus();
-        output.writeln();
-        output.printBox([
-          `Collection: ${label}`,
-          `Action: ${action}`,
-          `Vectors: ${newStatus.entryCount}`,
-          `Dimensions: ${newStatus.dimensions}`,
-          `M: ${m}`,
-          `ef_construction: ${efConstruction}`,
-        ].join('\n'), 'Index Built');
-
-        if (!collection && newStatus.entryCount === 0) {
-          output.writeln();
-          output.printInfo('No vectors indexed. Store some entries first:');
-          output.printInfo('  claude-flow memory store -k "key" --value "text" --namespace <ns>');
-        }
-
-        return { success: true, data: newStatus };
-      }
-
-      // Optimize action
-      if (action === 'optimize') {
-        output.printInfo('HNSW index is optimized automatically during search');
-        output.printInfo('No manual optimization required');
-        return { success: true };
-      }
-
-      output.printError(`Unknown action: ${action}`);
-      return { success: false, exitCode: 1 };
-    } catch (error) {
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Init subcommand - Initialize ONNX models and hyperbolic config
-const initCommand: Command = {
-  name: 'init',
-  description: 'Initialize embedding subsystem with ONNX model and hyperbolic config',
-  options: [
-    { name: 'model', short: 'm', type: 'string', description: 'ONNX model ID', default: 'Xenova/all-MiniLM-L6-v2' },
-    { name: 'hyperbolic', type: 'boolean', description: 'Enable hyperbolic (Poincaré ball) embeddings', default: 'true' },
-    { name: 'curvature', short: 'c', type: 'string', description: 'Poincaré ball curvature (use --curvature=-1 for negative)', default: '-1' },
-    { name: 'download', short: 'd', type: 'boolean', description: 'Download model during init', default: 'true' },
-    { name: 'cache-size', type: 'string', description: 'LRU cache entries', default: '256' },
-    { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite existing configuration', default: 'false' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings init', description: 'Initialize with defaults' },
-    { command: 'claude-flow embeddings init --model Xenova/all-mpnet-base-v2', description: 'Use higher quality model' },
-    { command: 'claude-flow embeddings init --no-hyperbolic', description: 'Euclidean only' },
-    { command: 'claude-flow embeddings init --curvature=-0.5', description: 'Custom curvature (use = for negative)' },
-    { command: 'claude-flow embeddings init --force', description: 'Overwrite existing config' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const model = ctx.flags.model as string || 'Xenova/all-MiniLM-L6-v2';
-    const hyperbolic = ctx.flags.hyperbolic !== false;
-    const download = ctx.flags.download !== false;
-    const force = ctx.flags.force === true;
-
-    // Parse curvature - handle both kebab-case and direct value
-    const curvatureRaw = ctx.flags.curvature as string || '-1';
-    const curvature = parseFloat(curvatureRaw);
-
-    // Parse cache-size - check both kebab-case and camelCase
-    const cacheSizeRaw = (ctx.flags['cache-size'] || ctx.flags.cacheSize || '256') as string;
-    const cacheSize = parseInt(cacheSizeRaw, 10);
-
-    output.writeln();
-    output.writeln(output.bold('Initialize Embedding Subsystem'));
-    output.writeln(output.dim('─'.repeat(55)));
-
-    try {
-      const fs = await import('fs');
-      const path = await import('path');
-
-      // Create directories
-      const configDir = path.join(process.cwd(), '.claude-flow');
-      const modelDir = path.join(configDir, 'models');
-      const configPath = path.join(configDir, 'embeddings.json');
-
-      // Check for existing config
-      if (fs.existsSync(configPath) && !force) {
-        output.printWarning('Embeddings already initialized');
-        output.printInfo(`Config exists: ${configPath}`);
-        output.writeln();
-        output.writeln(output.dim('Use --force to overwrite existing configuration'));
-        return { success: false, exitCode: 1 };
-      }
-
-      const spinner = output.createSpinner({ text: 'Initializing...', spinner: 'dots' });
-      spinner.start();
-
-      if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true });
-      }
-      if (!fs.existsSync(modelDir)) {
-        fs.mkdirSync(modelDir, { recursive: true });
-      }
-
-      // Download model if requested
-      if (download) {
-        spinner.setText(`Downloading ONNX model: ${model}...`);
-        const embeddings = await getEmbeddings();
-
-        if (embeddings) {
-          await embeddings.downloadEmbeddingModel(model, modelDir, (p) => {
-            spinner.setText(`Downloading ${model}... ${p.percent.toFixed(0)}%`);
-          });
-        } else {
-          // Embeddings package not available — skip download
-          await new Promise(r => setTimeout(r, 500));
-          output.writeln(output.dim('  (Skipped — @claude-flow/embeddings not installed)'));
-        }
-      }
-
-      // Write embeddings config
-      spinner.setText('Writing configuration...');
-      const dimension = model.includes('mpnet') ? 768 : 384;
-      const config = {
-        model,
-        modelPath: modelDir,
-        dimension,
-        cacheSize,
-        hyperbolic: {
-          enabled: hyperbolic,
-          curvature,
-          epsilon: 1e-15,
-          maxNorm: 1 - 1e-5,
-        },
-        neural: {
-          enabled: true,
-          driftThreshold: 0.3,
-          decayRate: 0.01,
-        },
-        initialized: new Date().toISOString(),
-      };
-
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-
-      spinner.succeed('Embedding subsystem initialized');
-
-      output.writeln();
-      output.printTable({
-        columns: [
-          { key: 'setting', header: 'Setting', width: 18 },
-          { key: 'value', header: 'Value', width: 40 },
-        ],
-        data: [
-          { setting: 'Model', value: model },
-          { setting: 'Dimension', value: String(dimension) },
-          { setting: 'Cache Size', value: String(cacheSize) + ' entries' },
-          { setting: 'Hyperbolic', value: hyperbolic ? `${output.success('Enabled')} (c=${curvature})` : output.dim('Disabled') },
-          { setting: 'Neural Substrate', value: output.success('Enabled') },
-          { setting: 'Model Path', value: modelDir },
-          { setting: 'Config', value: configPath },
-        ],
-      });
-
-      output.writeln();
-      if (hyperbolic) {
-        output.printBox([
-          'Hyperbolic Embeddings (Poincaré Ball):',
-          '• Better for hierarchical data (trees, taxonomies)',
-          '• Exponential capacity in low dimensions',
-          '• Distance preserves hierarchy structure',
-          '',
-          'Use: embeddings hyperbolic -a convert',
-        ].join('\n'), 'Hyperbolic Space');
-      }
-
-      output.writeln();
-      output.writeln(output.dim('Next steps:'));
-      output.printList([
-        'embeddings generate -t "test text"  - Test embedding generation',
-        'embeddings search -q "query"        - Semantic search',
-        'memory store -k key --value text    - Store with auto-embedding',
-      ]);
-
-      return { success: true, data: config };
-    } catch (error) {
-      output.printError('Initialization failed: ' + (error instanceof Error ? error.message : String(error)));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Providers subcommand
-const providersCommand: Command = {
-  name: 'providers',
-  description: 'List available embedding providers',
-  options: [],
-  examples: [
-    { command: 'claude-flow embeddings providers', description: 'List providers' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('Embedding Providers'));
-    output.writeln(output.dim('─'.repeat(70)));
-
-    output.printTable({
-      columns: [
-        { key: 'provider', header: 'Provider', width: 18 },
-        { key: 'model', header: 'Model', width: 25 },
-        { key: 'dims', header: 'Dims', width: 8 },
-        { key: 'type', header: 'Type', width: 10 },
-        { key: 'status', header: 'Status', width: 12 },
-      ],
-      data: [
-        { provider: 'OpenAI', model: 'text-embedding-3-small', dims: '1536', type: 'Cloud', status: output.success('Ready') },
-        { provider: 'OpenAI', model: 'text-embedding-3-large', dims: '3072', type: 'Cloud', status: output.success('Ready') },
-        { provider: 'Transformers.js', model: 'Xenova/all-MiniLM-L6-v2', dims: '384', type: 'Local', status: output.success('Ready') },
-        { provider: 'Agentic Flow', model: 'ONNX optimized', dims: '384', type: 'Local', status: output.success('Ready') },
-        { provider: 'Mock', model: 'mock-embedding', dims: '384', type: 'Dev', status: output.dim('Dev only') },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim('Agentic Flow provider uses WASM SIMD for 75x faster inference'));
-
-    return { success: true };
-  },
-};
-
-// Chunk subcommand
-const chunkCommand: Command = {
-  name: 'chunk',
-  description: 'Chunk text for embedding with overlap',
-  options: [
-    { name: 'text', short: 't', type: 'string', description: 'Text to chunk', required: true },
-    { name: 'max-size', short: 's', type: 'number', description: 'Max chunk size in chars', default: '512' },
-    { name: 'overlap', short: 'o', type: 'number', description: 'Overlap between chunks', default: '50' },
-    { name: 'strategy', type: 'string', description: 'Strategy: character, sentence, paragraph, token', default: 'sentence' },
-    { name: 'file', short: 'f', type: 'string', description: 'File to chunk (instead of text)' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings chunk -t "Long text..." -s 256', description: 'Chunk with 256 char limit' },
-    { command: 'claude-flow embeddings chunk -f doc.txt --strategy paragraph', description: 'Chunk file by paragraph' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const embeddings = await getEmbeddings();
-    const text = ctx.flags.text as string || '';
-    const maxSize = parseInt(ctx.flags['max-size'] as string || '512', 10);
-    const overlap = parseInt(ctx.flags.overlap as string || '50', 10);
-    const strategy = ctx.flags.strategy as string || 'sentence';
-
-    output.writeln();
-    output.writeln(output.bold('Document Chunking'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    if (!embeddings) {
-      output.printWarning('@claude-flow/embeddings not installed, showing preview');
-      output.writeln();
-      output.printBox([
-        `Strategy: ${strategy}`,
-        `Max Size: ${maxSize} chars`,
-        `Overlap: ${overlap} chars`,
-        ``,
-        `Estimated chunks: ${Math.ceil(text.length / (maxSize - overlap))}`,
-      ].join('\n'), 'Chunking Preview');
-      return { success: true };
-    }
-
-    const result = embeddings.chunkText(text, { maxChunkSize: maxSize, overlap, strategy: strategy as 'character' | 'sentence' | 'paragraph' | 'token' });
-
-    output.writeln();
-    output.printTable({
-      columns: [
-        { key: 'idx', header: '#', width: 5 },
-        { key: 'length', header: 'Chars', width: 8 },
-        { key: 'tokens', header: 'Tokens', width: 8 },
-        { key: 'preview', header: 'Preview', width: 45 },
-      ],
-      data: result.chunks.map((c, i) => ({
-        idx: String(i + 1),
-        length: String(c.length),
-        tokens: String(c.tokenCount),
-        preview: c.text.substring(0, 42) + (c.text.length > 42 ? '...' : ''),
-      })),
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Total: ${result.totalChunks} chunks from ${result.originalLength} chars`));
-
-    return { success: true };
-  },
-};
-
-// Normalize subcommand
-const normalizeCommand: Command = {
-  name: 'normalize',
-  description: 'Normalize embedding vectors',
-  options: [
-    { name: 'type', short: 't', type: 'string', description: 'Type: l2, l1, minmax, zscore', default: 'l2' },
-    { name: 'input', short: 'i', type: 'string', description: 'Input embedding (JSON array)' },
-    { name: 'check', short: 'c', type: 'boolean', description: 'Check if already normalized' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings normalize -i "[0.5, 0.3, 0.8]" -t l2', description: 'L2 normalize' },
-    { command: 'claude-flow embeddings normalize --check -i "[...]"', description: 'Check if normalized' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const type = ctx.flags.type as string || 'l2';
-    const check = ctx.flags.check as boolean;
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Normalization'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    output.printTable({
-      columns: [
-        { key: 'type', header: 'Type', width: 12 },
-        { key: 'formula', header: 'Formula', width: 30 },
-        { key: 'use', header: 'Best For', width: 25 },
-      ],
-      data: [
-        { type: output.success('L2'), formula: 'v / ||v||₂', use: 'Cosine similarity' },
-        { type: 'L1', formula: 'v / ||v||₁', use: 'Sparse vectors' },
-        { type: 'Min-Max', formula: '(v - min) / (max - min)', use: 'Bounded range [0,1]' },
-        { type: 'Z-Score', formula: '(v - μ) / σ', use: 'Statistical analysis' },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Selected: ${type.toUpperCase()} normalization`));
-    output.writeln(output.dim('Most embedding models pre-normalize with L2'));
-
-    return { success: true };
-  },
-};
-
-// Hyperbolic subcommand
-const hyperbolicCommand: Command = {
-  name: 'hyperbolic',
-  description: 'Hyperbolic embedding operations (Poincaré ball)',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: convert, distance, centroid', default: 'convert' },
-    { name: 'curvature', short: 'c', type: 'number', description: 'Hyperbolic curvature', default: '-1' },
-    { name: 'input', short: 'i', type: 'string', description: 'Input embedding(s) JSON' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings hyperbolic -a convert -i "[0.5, 0.3]"', description: 'Convert to Poincaré' },
-    { command: 'claude-flow embeddings hyperbolic -a distance', description: 'Compute hyperbolic distance' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'convert';
-    const curvature = parseFloat(ctx.flags.curvature as string || '-1');
-    const inputJson = ctx.flags.input as string;
-
-    output.writeln();
-    output.writeln(output.bold('Hyperbolic Embeddings'));
-    output.writeln(output.dim('Poincaré Ball Model'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    // Try to import hyperbolic functions from embeddings package
-    try {
-      const hyperbolic = await import('@claude-flow/embeddings').then(m => m).catch(() => null);
-
-      if (!hyperbolic || !hyperbolic.euclideanToPoincare) {
-        output.printWarning('@claude-flow/embeddings hyperbolic module not available');
-        output.printInfo('Install with: npm install @claude-flow/embeddings');
-        return { success: false, exitCode: 1 };
-      }
-
-      if (!inputJson) {
-        // Show help if no input
-        output.printBox([
-          'Hyperbolic embeddings excel at:',
-          '• Hierarchical data representation',
-          '• Tree-like structure preservation',
-          '• Low-dimensional hierarchy encoding',
-          '',
-          'Actions: convert, distance, centroid',
-          '',
-          'Examples:',
-          '  -a convert -i "[0.5, 0.3, 0.1]"',
-          '  -a distance -i "[[0.1,0.2],[0.3,0.4]]"',
-        ].join('\n'), 'Hyperbolic Geometry');
-        return { success: true };
-      }
-
-      // Parse input vector(s)
-      let input: number[] | number[][];
-      try {
-        input = JSON.parse(inputJson);
-      } catch {
-        output.printError('Invalid JSON input. Use format: "[0.5, 0.3]" or "[[0.1,0.2],[0.3,0.4]]"');
-        return { success: false, exitCode: 1 };
-      }
-
-      switch (action) {
-        case 'convert': {
-          const vec = Array.isArray(input[0]) ? input[0] as number[] : input as number[];
-          const rawResult = hyperbolic.euclideanToPoincare(vec, { curvature });
-          const result = Array.from(rawResult) as number[];
-          output.writeln(output.success('Euclidean → Poincaré conversion:'));
-          output.writeln();
-          output.writeln(`Input (Euclidean):  [${vec.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${vec.length > 6 ? ', ...' : ''}]`);
-          output.writeln(`Output (Poincaré):  [${result.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${result.length > 6 ? ', ...' : ''}]`);
-          output.writeln(`Curvature: ${curvature}`);
-          output.writeln(`Norm: ${Math.sqrt(result.reduce((s, v) => s + v * v, 0)).toFixed(6)} (must be < 1)`);
-          return { success: true, data: { result } };
-        }
-
-        case 'distance': {
-          if (!Array.isArray(input[0]) || input.length < 2) {
-            output.printError('Distance requires two vectors: "[[v1],[v2]]"');
-            return { success: false, exitCode: 1 };
-          }
-          const [v1, v2] = input as number[][];
-          const dist = hyperbolic.hyperbolicDistance(v1, v2, { curvature });
-          output.writeln(output.success('Hyperbolic (geodesic) distance:'));
-          output.writeln();
-          output.writeln(`Vector 1: [${v1.slice(0, 4).map(v => v.toFixed(4)).join(', ')}...]`);
-          output.writeln(`Vector 2: [${v2.slice(0, 4).map(v => v.toFixed(4)).join(', ')}...]`);
-          output.writeln(`Distance: ${dist.toFixed(6)}`);
-          return { success: true, data: { distance: dist } };
-        }
-
-        case 'centroid': {
-          if (!Array.isArray(input[0])) {
-            output.printError('Centroid requires multiple vectors: "[[v1],[v2],...]"');
-            return { success: false, exitCode: 1 };
-          }
-          const vectors = input as number[][];
-          const rawCentroid = hyperbolic.hyperbolicCentroid(vectors, { curvature });
-          const centroid = Array.from(rawCentroid) as number[];
-          output.writeln(output.success('Hyperbolic centroid (Fréchet mean):'));
-          output.writeln();
-          output.writeln(`Input vectors: ${vectors.length}`);
-          output.writeln(`Centroid: [${centroid.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${centroid.length > 6 ? ', ...' : ''}]`);
-          return { success: true, data: { centroid } };
-        }
-
-        default:
-          output.printError(`Unknown action: ${action}. Use: convert, distance, centroid`);
-          return { success: false, exitCode: 1 };
-      }
-    } catch (error) {
-      output.printError(`Hyperbolic operation failed: ${(error as Error).message}`);
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Neural subcommand
-const neuralCommand: Command = {
-  name: 'neural',
-  description: 'Neural substrate features (RuVector integration)',
-  options: [
-    { name: 'feature', short: 'f', type: 'string', description: 'Feature: drift, memory, swarm, coherence, all', default: 'all' },
-    { name: 'init', type: 'boolean', description: 'Initialize neural substrate with RuVector' },
-    { name: 'drift-threshold', type: 'string', description: 'Semantic drift detection threshold', default: '0.3' },
-    { name: 'decay-rate', type: 'string', description: 'Memory decay rate (hippocampal dynamics)', default: '0.01' },
-    { name: 'consolidation-interval', type: 'string', description: 'Memory consolidation interval (ms)', default: '60000' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings neural --init', description: 'Initialize RuVector substrate' },
-    { command: 'claude-flow embeddings neural -f drift', description: 'Semantic drift detection' },
-    { command: 'claude-flow embeddings neural -f memory', description: 'Memory physics (hippocampal)' },
-    { command: 'claude-flow embeddings neural -f coherence', description: 'Safety & alignment monitoring' },
-    { command: 'claude-flow embeddings neural --drift-threshold=0.2', description: 'Custom drift threshold' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const feature = ctx.flags.feature as string || 'all';
-    const init = ctx.flags.init as boolean;
-    const driftThreshold = parseFloat((ctx.flags['drift-threshold'] || ctx.flags.driftThreshold || '0.3') as string);
-    const decayRate = parseFloat((ctx.flags['decay-rate'] || ctx.flags.decayRate || '0.01') as string);
-    const consolidationInterval = parseInt((ctx.flags['consolidation-interval'] || ctx.flags.consolidationInterval || '60000') as string, 10);
-
-    output.writeln();
-    output.writeln(output.bold('Neural Embedding Substrate (RuVector)'));
-    output.writeln(output.dim('Treating embeddings as a synthetic nervous system'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    // Check if embeddings config exists
-    const fs = await import('fs');
-    const path = await import('path');
-    const configPath = path.join(process.cwd(), '.claude-flow', 'embeddings.json');
-
-    if (!fs.existsSync(configPath)) {
-      output.printWarning('Embeddings not initialized');
-      output.printInfo('Run "embeddings init" first to configure ONNX model');
-      return { success: false, exitCode: 1 };
-    }
-
-    // Load and update config
-    let config: Record<string, unknown> = {};
-    try {
-      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    } catch {
-      config = {};
-    }
-
-    if (init) {
-      // Initialize neural substrate configuration
-      config.neural = {
-        enabled: true,
-        driftThreshold,
-        decayRate,
-        consolidationInterval,
-        ruvector: {
-          enabled: true,
-          sona: true, // Self-Optimizing Neural Architecture
-          flashAttention: true,
-          ewcPlusPlus: true, // Elastic Weight Consolidation
-        },
-        features: {
-          semanticDrift: true,
-          memoryPhysics: true,
-          stateMachine: true,
-          swarmCoordination: true,
-          coherenceMonitor: true,
-        },
-        initializedAt: new Date().toISOString(),
-      };
-
-      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-      output.printSuccess('Neural substrate initialized');
-      output.writeln();
-    }
-
-    const neuralConfig = (config.neural || {}) as Record<string, unknown>;
-    const features = (neuralConfig.features || {}) as Record<string, boolean>;
-    const ruvector = (neuralConfig.ruvector || {}) as Record<string, boolean>;
-
-    output.printTable({
-      columns: [
-        { key: 'feature', header: 'Feature', width: 24 },
-        { key: 'description', header: 'Description', width: 38 },
-        { key: 'status', header: 'Status', width: 12 },
-      ],
-      data: [
-        {
-          feature: 'SemanticDriftDetector',
-          description: `Monitor semantic movement (threshold: ${driftThreshold})`,
-          status: features.semanticDrift ? output.success('Active') : output.dim('Inactive')
-        },
-        {
-          feature: 'MemoryPhysics',
-          description: `Hippocampal dynamics (decay: ${decayRate})`,
-          status: features.memoryPhysics ? output.success('Active') : output.dim('Inactive')
-        },
-        {
-          feature: 'EmbeddingStateMachine',
-          description: 'Agent state through geometry',
-          status: features.stateMachine ? output.success('Active') : output.dim('Inactive')
-        },
-        {
-          feature: 'SwarmCoordinator',
-          description: 'Multi-agent embedding coordination',
-          status: features.swarmCoordination ? output.success('Active') : output.dim('Inactive')
-        },
-        {
-          feature: 'CoherenceMonitor',
-          description: 'Safety & alignment detection',
-          status: features.coherenceMonitor ? output.success('Active') : output.dim('Inactive')
-        },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.bold('RuVector Integration'));
-    output.printTable({
-      columns: [
-        { key: 'component', header: 'Component', width: 24 },
-        { key: 'description', header: 'Description', width: 38 },
-        { key: 'status', header: 'Status', width: 12 },
-      ],
-      data: [
-        {
-          component: 'SONA',
-          description: 'Self-Optimizing Neural Architecture (<0.05ms)',
-          status: ruvector.sona ? output.success('Enabled') : output.dim('Disabled')
-        },
-        {
-          component: 'Flash Attention',
-          description: '2.49x-7.47x attention speedup',
-          status: ruvector.flashAttention ? output.success('Enabled') : output.dim('Disabled')
-        },
-        {
-          component: 'EWC++',
-          description: 'Elastic Weight Consolidation (anti-forgetting)',
-          status: ruvector.ewcPlusPlus ? output.success('Enabled') : output.dim('Disabled')
-        },
-        {
-          component: 'Hyperbolic Space',
-          description: 'Poincaré ball for hierarchy preservation',
-          status: config.hyperbolic ? output.success('Enabled') : output.dim('Disabled')
-        },
-      ],
-    });
-
-    output.writeln();
-
-    if (!neuralConfig.enabled) {
-      output.printInfo('Run with --init to enable neural substrate');
-    } else {
-      output.writeln(output.dim('Configuration: .claude-flow/embeddings.json'));
-      output.writeln(output.dim('Next: Use "hooks pretrain" to train patterns'));
-    }
-
-    return { success: true, data: { config: neuralConfig, feature } };
-  },
-};
-
-// Models subcommand
-const modelsCommand: Command = {
-  name: 'models',
-  description: 'List and download embedding models',
-  options: [
-    { name: 'download', short: 'd', type: 'string', description: 'Model ID to download' },
-    { name: 'list', short: 'l', type: 'boolean', description: 'List available models', default: 'true' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings models', description: 'List models' },
-    { command: 'claude-flow embeddings models -d all-MiniLM-L6-v2', description: 'Download model' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const download = ctx.flags.download as string;
-    const embeddings = await getEmbeddings();
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Models'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    if (download) {
-      const spinner = output.createSpinner({ text: `Downloading ${download}...`, spinner: 'dots' });
-      spinner.start();
-
-      if (embeddings) {
-        try {
-          await embeddings.downloadEmbeddingModel(download, '.models', (p) => {
-            spinner.setText(`Downloading ${download}... ${p.percent.toFixed(1)}%`);
-          });
-          spinner.succeed(`Downloaded ${download}`);
-        } catch (err) {
-          spinner.fail(`Failed to download: ${err}`);
-          return { success: false, exitCode: 1 };
-        }
-      } else {
-        await new Promise(r => setTimeout(r, 500));
-        spinner.succeed(`Download skipped — @claude-flow/embeddings not installed`);
-      }
-      return { success: true };
-    }
-
-    // List models
-    let models = [
-      { id: 'Xenova/all-MiniLM-L6-v2', dimension: 384, size: '23MB', quantized: false, downloaded: true },
-      { id: 'Xenova/all-mpnet-base-v2', dimension: 768, size: '110MB', quantized: false, downloaded: false },
-      { id: 'Xenova/paraphrase-MiniLM-L3-v2', dimension: 384, size: '17MB', quantized: false, downloaded: false },
-    ];
-
-    if (embeddings) {
-      try {
-        models = await embeddings.listEmbeddingModels();
-      } catch { /* use defaults */ }
-    }
-
-    output.printTable({
-      columns: [
-        { key: 'id', header: 'Model ID', width: 28 },
-        { key: 'dimension', header: 'Dims', width: 8 },
-        { key: 'size', header: 'Size', width: 10 },
-        { key: 'quantized', header: 'Quant', width: 8 },
-        { key: 'downloaded', header: 'Status', width: 12 },
-      ],
-      data: models.map(m => ({
-        id: m.id,
-        dimension: String(m.dimension),
-        size: m.size,
-        quantized: m.quantized ? 'Yes' : 'No',
-        downloaded: m.downloaded ? output.success('Downloaded') : output.dim('Available'),
-      })),
-    });
-
-    return { success: true };
-  },
-};
-
-// Cache subcommand
-const cacheCommand: Command = {
-  name: 'cache',
-  description: 'Manage embedding cache',
-  options: [
-    { name: 'action', short: 'a', type: 'string', description: 'Action: stats, clear, persist', default: 'stats' },
-    { name: 'db-path', type: 'string', description: 'SQLite database path', default: '.cache/embeddings.db' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings cache', description: 'Show cache stats' },
-    { command: 'claude-flow embeddings cache -a clear', description: 'Clear cache' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const action = ctx.flags.action as string || 'stats';
-    const dbPath = ctx.flags['db-path'] as string || '.cache/embeddings.db';
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Cache'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const fs = await import('fs');
-    const path = await import('path');
-
-    // Get real cache stats
-    const resolvedDbPath = path.resolve(dbPath);
-    let sqliteEntries = 0;
-    let sqliteSize = '0 B';
-    let sqliteExists = false;
-
-    try {
-      if (fs.existsSync(resolvedDbPath)) {
-        sqliteExists = true;
-        const stats = fs.statSync(resolvedDbPath);
-        const sizeBytes = stats.size;
-
-        // Format size
-        if (sizeBytes >= 1024 * 1024) {
-          sqliteSize = `${(sizeBytes / 1024 / 1024).toFixed(1)} MB`;
-        } else if (sizeBytes >= 1024) {
-          sqliteSize = `${(sizeBytes / 1024).toFixed(1)} KB`;
-        } else {
-          sqliteSize = `${sizeBytes} B`;
-        }
-
-        // Try to count real entries via sql.js
-        try {
-          const initSqlJs = (await import('sql.js')).default;
-          const SQL = await initSqlJs();
-          const fileBuffer = fs.readFileSync(resolvedDbPath);
-          const db = new SQL.Database(fileBuffer);
-          const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
-          if (result.length > 0 && result[0].values.length > 0) {
-            sqliteEntries = result[0].values[0][0] as number;
-          }
-          db.close();
-        } catch {
-          // Estimate entries from file size (~1600 bytes per entry for 384-dim embeddings)
-          sqliteEntries = Math.floor(stats.size / 1600);
-        }
-      }
-    } catch { /* file access error */ }
-
-    // Get in-memory HNSW stats if available
-    let memoryEntries = 0;
-    let memorySize = '0 B';
-    try {
-      const { getHNSWStatus } = await import('../memory/memory-initializer.js');
-      const hnswStatus = getHNSWStatus();
-      if (hnswStatus && hnswStatus.initialized) {
-        memoryEntries = hnswStatus.entryCount || 0;
-        const memBytes = memoryEntries * (hnswStatus.dimensions || 384) * 4; // Float32 = 4 bytes per dimension
-        if (memBytes >= 1024 * 1024) {
-          memorySize = `${(memBytes / 1024 / 1024).toFixed(1)} MB`;
-        } else if (memBytes >= 1024) {
-          memorySize = `${(memBytes / 1024).toFixed(1)} KB`;
-        } else {
-          memorySize = `${memBytes} B`;
-        }
-      }
-    } catch { /* HNSW not initialized */ }
-
-    if (action === 'clear') {
-      try {
-        if (fs.existsSync(resolvedDbPath)) {
-          fs.unlinkSync(resolvedDbPath);
-          output.writeln(output.success('Cache cleared!'));
-        } else {
-          output.writeln(output.dim('No cache to clear.'));
-        }
-        return { success: true };
-      } catch (error) {
-        output.printError(`Failed to clear cache: ${error}`);
-        return { success: false };
-      }
-    }
-
-    // Display real stats
-    output.printTable({
-      columns: [
-        { key: 'cache', header: 'Cache Type', width: 18 },
-        { key: 'entries', header: 'Entries', width: 12 },
-        { key: 'status', header: 'Status', width: 12 },
-        { key: 'size', header: 'Size', width: 12 },
-      ],
-      data: [
-        {
-          cache: 'LRU (Memory)',
-          entries: String(memoryEntries),
-          status: memoryEntries > 0 ? output.success('Active') : output.dim('Empty'),
-          size: memorySize,
-        },
-        {
-          cache: 'SQLite (Disk)',
-          entries: String(sqliteEntries),
-          status: sqliteExists ? output.success('Active') : output.dim('Not Found'),
-          size: sqliteSize,
-        },
-      ],
-    });
-
-    output.writeln();
-    output.writeln(output.dim(`Database: ${resolvedDbPath}`));
-    if (sqliteExists) {
-      output.writeln(output.dim('Persistent cache survives restarts'));
-    } else {
-      output.writeln(output.dim('Cache will be created on first embedding operation'));
-    }
-
-    return { success: true };
-  },
-};
-
-// Warmup subcommand - Preload model for faster first embed
-const warmupCommand: Command = {
-  name: 'warmup',
-  description: 'Preload embedding model for faster subsequent operations',
-  options: [
-    { name: 'background', short: 'b', type: 'boolean', description: 'Run warmup in background daemon', default: 'false' },
-    { name: 'test', short: 't', type: 'boolean', description: 'Run test embedding after warmup', default: 'true' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings warmup', description: 'Preload model with test' },
-    { command: 'claude-flow embeddings warmup -b', description: 'Background warmup' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const runTest = ctx.flags.test !== false;
-    const background = ctx.flags.background === true;
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Model Warmup'));
-    output.writeln(output.dim('─'.repeat(50)));
-
-    const spinner = output.createSpinner({ text: 'Loading embedding model...', spinner: 'dots' });
-    spinner.start();
-
-    const overallStart = Date.now();
-
-    try {
-      const { loadEmbeddingModel, generateEmbedding } = await import('../memory/memory-initializer.js');
-
-      // Phase 1: Load model
-      const loadStart = Date.now();
-      const modelInfo = await loadEmbeddingModel({ verbose: false });
-      const loadTime = Date.now() - loadStart;
-
-      spinner.succeed(`Model loaded in ${loadTime}ms`);
-
-      // Phase 2: Test embed (warms ONNX runtime)
-      if (runTest) {
-        const testSpinner = output.createSpinner({ text: 'Running warmup embedding...', spinner: 'dots' });
-        testSpinner.start();
-
-        const warmupTexts = [
-          'The quick brown fox jumps over the lazy dog',
-          'Machine learning embeddings enable semantic search',
-          'Vector databases use HNSW for fast similarity'
-        ];
-
-        const embedTimes: number[] = [];
-        for (const text of warmupTexts) {
-          const embedStart = Date.now();
-          await generateEmbedding(text);
-          embedTimes.push(Date.now() - embedStart);
-        }
-
-        const avgWarmEmbed = embedTimes.slice(1).reduce((a, b) => a + b, 0) / (embedTimes.length - 1);
-        testSpinner.succeed(`Warmup complete: ${avgWarmEmbed.toFixed(1)}ms avg (warm)`);
-      }
-
-      const totalTime = Date.now() - overallStart;
-
-      output.writeln();
-      output.printTable({
-        columns: [
-          { key: 'metric', header: 'Metric', width: 22 },
-          { key: 'value', header: 'Value', width: 25 },
-        ],
-        data: [
-          { metric: 'Model', value: modelInfo.modelName },
-          { metric: 'Dimensions', value: String(modelInfo.dimensions) },
-          { metric: 'Initial Load', value: `${loadTime}ms` },
-          { metric: 'Warm Embed', value: runTest ? `~2-3ms` : 'Skipped' },
-          { metric: 'Total Warmup', value: `${totalTime}ms` },
-          { metric: 'Status', value: output.success('Ready') },
-        ],
-      });
-
-      output.writeln();
-      output.writeln(output.dim('Model is now cached for fast subsequent embeddings'));
-
-      return { success: true, data: { loadTime, totalTime, dimensions: modelInfo.dimensions } };
-    } catch (error) {
-      spinner.fail('Warmup failed');
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Benchmark subcommand - Performance testing
-const benchmarkCommand: Command = {
-  name: 'benchmark',
-  description: 'Run embedding performance benchmarks',
-  options: [
-    { name: 'iterations', short: 'n', type: 'number', description: 'Number of iterations', default: '10' },
-    { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size for batch test', default: '5' },
-    { name: 'full', short: 'f', type: 'boolean', description: 'Run full benchmark suite', default: 'false' },
-  ],
-  examples: [
-    { command: 'claude-flow embeddings benchmark', description: 'Quick benchmark' },
-    { command: 'claude-flow embeddings benchmark -n 50 -f', description: 'Full benchmark' },
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const iterations = parseInt(ctx.flags.iterations as string || '10', 10);
-    const batchSize = parseInt(ctx.flags['batch-size'] as string || '5', 10);
-    const full = ctx.flags.full === true;
-
-    output.writeln();
-    output.writeln(output.bold('Embedding Performance Benchmark'));
-    output.writeln(output.dim('─'.repeat(60)));
-
-    const results: { test: string; time: string; opsPerSec: string }[] = [];
-
-    try {
-      const { loadEmbeddingModel, generateEmbedding } = await import('../memory/memory-initializer.js');
-
-      // Test 1: Cold start (model load)
-      output.writeln(output.dim('Testing cold start...'));
-      const coldStart = Date.now();
-      const modelInfo = await loadEmbeddingModel({ verbose: false });
-      const coldTime = Date.now() - coldStart;
-      results.push({
-        test: 'Cold Start (model load)',
-        time: `${coldTime}ms`,
-        opsPerSec: '-'
-      });
-
-      // Test 2: First embed
-      const firstStart = Date.now();
-      await generateEmbedding('First embedding test');
-      const firstTime = Date.now() - firstStart;
-      results.push({
-        test: 'First Embed',
-        time: `${firstTime}ms`,
-        opsPerSec: `${(1000 / firstTime).toFixed(1)}`
-      });
-
-      // Test 3: Warm embeds (multiple iterations)
-      output.writeln(output.dim(`Testing ${iterations} warm embeds...`));
-      const warmTimes: number[] = [];
-      for (let i = 0; i < iterations; i++) {
-        const start = Date.now();
-        await generateEmbedding(`Warm embedding test ${i} with some content`);
-        warmTimes.push(Date.now() - start);
-      }
-      const avgWarm = warmTimes.reduce((a, b) => a + b, 0) / warmTimes.length;
-      const minWarm = Math.min(...warmTimes);
-      const maxWarm = Math.max(...warmTimes);
-      results.push({
-        test: `Warm Embed (n=${iterations})`,
-        time: `${avgWarm.toFixed(1)}ms avg (${minWarm}-${maxWarm})`,
-        opsPerSec: `${(1000 / avgWarm).toFixed(1)}`
-      });
-
-      // Test 4a: Sequential batch embed
-      output.writeln(output.dim(`Testing sequential batch of ${batchSize}...`));
-      const batchTexts = Array.from({ length: batchSize }, (_, i) => `Batch text ${i + 1} for testing`);
-      const seqStart = Date.now();
-      for (const text of batchTexts) {
-        await generateEmbedding(text);
-      }
-      const seqTime = Date.now() - seqStart;
-      results.push({
-        test: `Sequential (n=${batchSize})`,
-        time: `${seqTime}ms total (${(seqTime / batchSize).toFixed(1)}ms/item)`,
-        opsPerSec: `${(1000 * batchSize / seqTime).toFixed(1)}`
-      });
-
-      // Test 4b: Parallel batch embed
-      // Note: Local ONNX is CPU-bound so parallelism has limited benefit
-      // Parallelism gives 2-4x speedup for API-based providers (OpenAI, etc.)
-      output.writeln(output.dim(`Testing parallel batch of ${batchSize}...`));
-      const parallelTexts = Array.from({ length: batchSize }, (_, i) => `Parallel batch text ${i + 1}`);
-      const parallelStart = Date.now();
-      await Promise.all(parallelTexts.map(text => generateEmbedding(text)));
-      const parallelTime = Date.now() - parallelStart;
-      const speedup = seqTime / parallelTime;
-      results.push({
-        test: `Parallel (n=${batchSize})`,
-        time: `${parallelTime}ms total (${(parallelTime / batchSize).toFixed(1)}ms/item)`,
-        opsPerSec: `${(1000 * batchSize / parallelTime).toFixed(1)} (${speedup.toFixed(2)}x vs seq)`
-      });
-
-      // Test 5: Cache hit (same text)
-      if (full) {
-        output.writeln(output.dim('Testing cache hits...'));
-        const cacheText = 'Cached embedding test text';
-        await generateEmbedding(cacheText); // Prime cache
-        const cacheTimes: number[] = [];
-        for (let i = 0; i < 10; i++) {
-          const start = Date.now();
-          await generateEmbedding(cacheText);
-          cacheTimes.push(Date.now() - start);
-        }
-        const avgCache = cacheTimes.reduce((a, b) => a + b, 0) / cacheTimes.length;
-        results.push({
-          test: 'Cache Hit',
-          time: `${avgCache.toFixed(2)}ms avg`,
-          opsPerSec: `${(1000 / avgCache).toFixed(0)}`
-        });
-
-        // Test 6: Similarity computation
-        output.writeln(output.dim('Testing similarity...'));
-        const emb1 = (await generateEmbedding('Hello world')).embedding;
-        const emb2 = (await generateEmbedding('Hi there')).embedding;
-        const simTimes: number[] = [];
-        for (let i = 0; i < 1000; i++) {
-          const start = performance.now();
-          cosineSimilarity(emb1, emb2);
-          simTimes.push(performance.now() - start);
-        }
-        const avgSim = simTimes.reduce((a, b) => a + b, 0) / simTimes.length;
-        results.push({
-          test: 'Cosine Similarity',
-          time: `${(avgSim * 1000).toFixed(2)}μs`,
-          opsPerSec: `${(1000000 / (avgSim * 1000)).toFixed(0)}`
-        });
-      }
-
-      output.writeln();
-      output.printTable({
-        columns: [
-          { key: 'test', header: 'Test', width: 28 },
-          { key: 'time', header: 'Time', width: 32 },
-          { key: 'opsPerSec', header: 'Ops/sec', width: 12 },
-        ],
-        data: results,
-      });
-
-      output.writeln();
-      output.writeln(output.bold('Summary:'));
-      output.writeln(`  Model: ${modelInfo.modelName} (${modelInfo.dimensions}-dim)`);
-      output.writeln(`  Cold start: ${coldTime}ms`);
-      output.writeln(`  Warm embed: ~${avgWarm.toFixed(1)}ms`);
-      output.writeln(`  Throughput: ~${(1000 / avgWarm).toFixed(0)} embeds/sec`);
-
-      return { success: true, data: { results, avgWarm, coldTime } };
-    } catch (error) {
-      output.printError(error instanceof Error ? error.message : String(error));
-      return { success: false, exitCode: 1 };
-    }
-  },
-};
-
-// Main embeddings command
-export const embeddingsCommand: Command = {
-  name: 'embeddings',
-  description: 'Vector embeddings, semantic search, similarity operations',
-  aliases: ['embed'],
-  subcommands: [
-    initCommand,
-    generateCommand,
-    searchCommand,
-    compareCommand,
-    collectionsCommand,
-    indexCommand,
-    providersCommand,
-    chunkCommand,
-    normalizeCommand,
-    hyperbolicCommand,
-    neuralCommand,
-    modelsCommand,
-    cacheCommand,
-    warmupCommand,
-    benchmarkCommand,
-  ],
-  examples: [
-    { command: 'claude-flow embeddings init', description: 'Initialize ONNX embedding system' },
-    { command: 'claude-flow embeddings init --model all-mpnet-base-v2', description: 'Init with larger model' },
-    { command: 'claude-flow embeddings generate -t "Hello"', description: 'Generate embedding' },
-    { command: 'claude-flow embeddings search -q "error handling"', description: 'Semantic search' },
-    { command: 'claude-flow embeddings chunk -t "Long doc..."', description: 'Chunk document' },
-    { command: 'claude-flow embeddings hyperbolic -a convert', description: 'Hyperbolic space' },
-    { command: 'claude-flow embed neural -f drift', description: 'Neural substrate' },
-  ],
-  action: async (): Promise<CommandResult> => {
-    output.writeln();
-    output.writeln(output.bold('RuFlo Embeddings'));
-    output.writeln(output.dim('Vector embeddings and semantic search'));
-    output.writeln();
-    output.writeln('Core Commands:');
-    output.printList([
-      'init        - Initialize ONNX models and hyperbolic config',
-      'generate    - Generate embeddings for text',
-      'search      - Semantic similarity search',
-      'compare     - Compare similarity between texts',
-      'collections - Manage embedding collections',
-      'index       - Manage HNSW indexes',
-      'providers   - List available providers',
-    ]);
-    output.writeln();
-    output.writeln('Advanced Features:');
-    output.printList([
-      'chunk       - Document chunking with overlap',
-      'normalize   - L2/L1/minmax/zscore normalization',
-      'hyperbolic  - Poincaré ball embeddings',
-      'neural      - Neural substrate (drift, memory, swarm)',
-      'models      - List/download ONNX models',
-      'cache       - Manage persistent SQLite cache',
-    ]);
-    output.writeln();
-    output.writeln('Performance:');
-    output.printList([
-      'HNSW indexing: 150x-12,500x faster search',
-      'Agentic Flow: 75x faster than Transformers.js (~3ms)',
-      'Persistent cache: SQLite-backed, survives restarts',
-      'Hyperbolic: Better hierarchical representation',
-    ]);
-    output.writeln();
-    output.writeln(output.dim('Created with ❤️ by ruv.io'));
-    return { success: true };
-  },
-};
-
-export default embeddingsCommand;