monomind 1.18.9 → 1.18.10

package/packages/@monomind/cli/dist/src/commands/benchmark.js

@@ -1,586 +0,0 @@
-/**
- * CLI Benchmark Command
- * Comprehensive benchmarking for self-learning, pre-training, and neural systems
- *
- * @module v1/cli/commands/benchmark
- */
-import { output } from '../output.js';
-import { writeFileSync, renameSync, readFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { BenchmarkRunner } from '../benchmarks/benchmark-runner.js';
-// ============================================================================
-// Pretrain Benchmark Subcommand
-// ============================================================================
-const pretrainCommand = {
-    name: 'pretrain',
-    description: 'Benchmark pattern-learning pre-training system',
-    options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: '10' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
-        { name: 'save', short: 's', type: 'string', description: 'Save results to file' },
-        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output', default: 'false' },
-    ],
-    examples: [
-        { command: 'monomind benchmark pretrain', description: 'Run pre-training benchmarks' },
-        { command: 'monomind benchmark pretrain -i 500 --save results.json', description: 'Extended benchmark with results saved' },
-        { command: 'monomind benchmark pretrain -o json', description: 'Output results as JSON' },
-    ],
-    action: async (ctx) => {
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
-        const warmup = parseInt(ctx.flags.warmup || '10', 10);
-        const outputFormat = ctx.flags.output || 'text';
-        const saveFile = ctx.flags.save;
-        const verbose = ctx.flags.verbose === true;
-        void iterations;
-        void warmup;
-        void verbose;
-        void outputFormat;
-        void saveFile;
-        output.writeln();
-        output.writeln(output.bold('Pattern-Learning Benchmark'));
-        output.writeln(output.dim('─'.repeat(50)));
-        output.writeln(output.dim('  The native SONA/EWC++/MoE pre-training benchmark was removed in the lean build.'));
-        output.writeln(output.dim('  Use "monomind benchmark neural" to benchmark the active pure-JS intelligence layer.'));
-        output.writeln();
-        return { success: true };
-    },
-};
-// ============================================================================
-// Neural Benchmark Subcommand
-// ============================================================================
-const neuralCommand = {
-    name: 'neural',
-    description: 'Benchmark neural operations (embeddings, HNSW, cosine similarity)',
-    options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'dimension', short: 'd', type: 'number', description: 'Embedding dimension', default: '384' },
-        { name: 'vectors', short: 'n', type: 'number', description: 'Number of test vectors', default: '1000' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
-    ],
-    examples: [
-        { command: 'monomind benchmark neural', description: 'Run neural benchmarks' },
-        { command: 'monomind benchmark neural -d 768 -n 5000', description: 'Higher dimension, more vectors' },
-    ],
-    action: async (ctx) => {
-        const iterationsRaw = parseInt(ctx.flags.iterations || '100', 10);
-        const iterations = Number.isFinite(iterationsRaw) ? Math.max(1, Math.min(iterationsRaw, 10_000)) : 100;
-        const dimensionRaw = parseInt(ctx.flags.dimension || '384', 10);
-        const dimension = Number.isFinite(dimensionRaw) ? Math.max(1, Math.min(dimensionRaw, 4096)) : 384;
-        const numVectorsRaw = parseInt(ctx.flags.vectors || '1000', 10);
-        const numVectors = Number.isFinite(numVectorsRaw) ? Math.max(1, Math.min(numVectorsRaw, 100_000)) : 1000;
-        const outputFormat = ctx.flags.output || 'text';
-        output.writeln();
-        output.writeln(output.bold('Neural Operations Benchmark'));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.writeln(`Iterations: ${iterations} | Dimension: ${dimension} | Vectors: ${numVectors}`);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Running neural benchmarks...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const { performance } = await import('node:perf_hooks');
-            // Helper functions
-            const percentile = (sorted, p) => {
-                const idx = Math.ceil((p / 100) * sorted.length) - 1;
-                return sorted[Math.max(0, idx)];
-            };
-            const results = [];
-            // 1. Embedding Generation
-            spinner.setText('Benchmarking embedding generation...');
-            let generateEmbedding;
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                generateEmbedding = memory.generateEmbedding;
-            }
-            catch {
-                generateEmbedding = async (text) => {
-                    const emb = [];
-                    for (let i = 0; i < dimension; i++) {
-                        emb.push(Math.sin(text.charCodeAt(i % text.length) * (i + 1)));
-                    }
-                    return { embedding: emb, dimensions: dimension, model: 'fallback' };
-                };
-            }
-            const embedTimes = [];
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await generateEmbedding(`benchmark text ${i}`);
-                embedTimes.push(performance.now() - start);
-            }
-            const embedMean = embedTimes.reduce((a, b) => a + b, 0) / embedTimes.length;
-            const embedSorted = [...embedTimes].sort((a, b) => a - b);
-            results.push({
-                name: 'Embedding Generation',
-                mean: embedMean,
-                p95: percentile(embedSorted, 95),
-                p99: percentile(embedSorted, 99),
-                target: 5.0,
-                met: embedMean <= 5.0,
-            });
-            // 2. Batch Cosine Similarity
-            spinner.setText('Benchmarking batch cosine similarity...');
-            let batchCosineSim;
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                batchCosineSim = memory.batchCosineSim;
-            }
-            catch {
-                batchCosineSim = (query, vectors) => {
-                    const res = new Float32Array(vectors.length);
-                    for (let i = 0; i < vectors.length; i++) {
-                        let dot = 0, nQ = 0, nV = 0;
-                        for (let j = 0; j < query.length; j++) {
-                            dot += query[j] * vectors[i][j];
-                            nQ += query[j] * query[j];
-                            nV += vectors[i][j] * vectors[i][j];
-                        }
-                        res[i] = dot / (Math.sqrt(nQ) * Math.sqrt(nV));
-                    }
-                    return res;
-                };
-            }
-            const query = new Float32Array(dimension).map(() => Math.random());
-            const vectors = Array.from({ length: numVectors }, () => new Float32Array(dimension).map(() => Math.random()));
-            const cosineTimes = [];
-            for (let i = 0; i < Math.min(iterations, 50); i++) {
-                const start = performance.now();
-                batchCosineSim(query, vectors);
-                cosineTimes.push(performance.now() - start);
-            }
-            const cosineMean = cosineTimes.reduce((a, b) => a + b, 0) / cosineTimes.length;
-            const cosineSorted = [...cosineTimes].sort((a, b) => a - b);
-            results.push({
-                name: `Batch Cosine (${numVectors} vectors)`,
-                mean: cosineMean,
-                p95: percentile(cosineSorted, 95),
-                p99: percentile(cosineSorted, 99),
-                target: 5.0,
-                met: cosineMean <= 5.0,
-            });
-            // 3. Softmax-weighted top-K search (pure-JS)
-            spinner.setText('Benchmarking softmax top-K search...');
-            const flashTimes = [];
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                if (memory.flashAttentionSearch) {
-                    for (let i = 0; i < Math.min(iterations, 50); i++) {
-                        const start = performance.now();
-                        memory.flashAttentionSearch(query, vectors, { k: 10 });
-                        flashTimes.push(performance.now() - start);
-                    }
-                }
-            }
-            catch {
-                // not available
-            }
-            if (flashTimes.length > 0) {
-                const flashMean = flashTimes.reduce((a, b) => a + b, 0) / flashTimes.length;
-                const flashSorted = [...flashTimes].sort((a, b) => a - b);
-                results.push({
-                    name: 'Softmax Top-K Search',
-                    mean: flashMean,
-                    p95: percentile(flashSorted, 95),
-                    p99: percentile(flashSorted, 99),
-                    target: 2.0,
-                    met: flashMean <= 2.0,
-                });
-            }
-            spinner.stop();
-            // Display results
-            output.writeln();
-            output.writeln(output.bold('Results'));
-            output.writeln(output.dim('─'.repeat(60)));
-            for (const r of results) {
-                const status = r.met ? output.success('✓') : output.error('✗');
-                output.writeln(`${status} ${r.name}`);
-                output.writeln(`   Mean: ${r.mean.toFixed(3)}ms | p95: ${r.p95.toFixed(3)}ms | p99: ${r.p99.toFixed(3)}ms`);
-                output.writeln(`   Target: ${r.target}ms | Status: ${r.met ? 'Met' : 'Not met'}`);
-                output.writeln();
-            }
-            if (outputFormat === 'json') {
-                output.writeln(JSON.stringify(results, null, 2));
-            }
-            const allPassed = results.every(r => r.met);
-            return {
-                success: true,
-                message: allPassed ? 'All neural benchmarks passed!' : 'Some benchmarks below target',
-            };
-        }
-        catch (err) {
-            spinner.stop();
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            output.writeln(output.error(`Neural benchmark failed: ${errorMsg}`));
-            return {
-                success: false,
-                message: `Neural benchmark failed: ${errorMsg}`,
-            };
-        }
-    },
-};
-// ============================================================================
-// Memory Benchmark Subcommand
-// ============================================================================
-const memoryCommand = {
-    name: 'memory',
-    description: 'Benchmark memory operations (HNSW search, store, retrieve)',
-    options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
-    ],
-    examples: [
-        { command: 'monomind benchmark memory', description: 'Run memory benchmarks' },
-    ],
-    action: async (ctx) => {
-        const iterationsRaw = parseInt(ctx.flags.iterations || '100', 10);
-        const iterations = Number.isFinite(iterationsRaw) ? Math.max(1, Math.min(iterationsRaw, 10_000)) : 100;
-        const outputFormat = ctx.flags.output || 'text';
-        output.writeln();
-        output.writeln(output.bold('Memory Operations Benchmark'));
-        output.writeln(output.dim('─'.repeat(60)));
-        const spinner = output.createSpinner({ text: 'Running memory benchmarks...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const { performance } = await import('node:perf_hooks');
-            const percentile = (sorted, p) => {
-                const idx = Math.ceil((p / 100) * sorted.length) - 1;
-                return sorted[Math.max(0, idx)];
-            };
-            const results = [];
-            // Import memory functions
-            let storeEntry;
-            let searchEntries;
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                storeEntry = memory.storeEntry;
-                searchEntries = memory.searchEntries;
-            }
-            catch {
-                // @monomind/memory not available — return null metrics instead of fake numbers
-                storeEntry = async () => ({ success: true });
-                searchEntries = async () => ({ results: [], searchTime: 0 }); // 0 = no-op fallback, not a real benchmark
-            }
-            // 1. Store benchmark
-            spinner.setText('Benchmarking memory store...');
-            const storeTimes = [];
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await storeEntry({
-                    key: `bench-key-${i}`,
-                    value: `Benchmark value ${i} with some additional content`,
-                    namespace: 'benchmark',
-                });
-                storeTimes.push(performance.now() - start);
-            }
-            const storeMean = storeTimes.reduce((a, b) => a + b, 0) / storeTimes.length;
-            results.push({
-                name: 'Memory Store',
-                mean: storeMean,
-                p95: percentile([...storeTimes].sort((a, b) => a - b), 95),
-                target: 10.0,
-                met: storeMean <= 10.0,
-            });
-            // 2. Search benchmark
-            spinner.setText('Benchmarking memory search...');
-            const queries = [
-                'authentication patterns',
-                'error handling best practices',
-                'performance optimization',
-                'testing strategies',
-                'security vulnerabilities',
-            ];
-            const searchTimes = [];
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await searchEntries({
-                    query: queries[i % queries.length],
-                    namespace: 'benchmark',
-                    limit: 10,
-                });
-                searchTimes.push(performance.now() - start);
-            }
-            const searchMean = searchTimes.reduce((a, b) => a + b, 0) / searchTimes.length;
-            results.push({
-                name: 'Memory Search (HNSW)',
-                mean: searchMean,
-                p95: percentile([...searchTimes].sort((a, b) => a - b), 95),
-                target: 10.0,
-                met: searchMean <= 10.0,
-            });
-            spinner.stop();
-            // Display results
-            output.writeln();
-            output.writeln(output.bold('Results'));
-            output.writeln(output.dim('─'.repeat(60)));
-            for (const r of results) {
-                const status = r.met ? output.success('✓') : output.error('✗');
-                output.writeln(`${status} ${r.name}`);
-                output.writeln(`   Mean: ${r.mean.toFixed(3)}ms | p95: ${r.p95.toFixed(3)}ms | Target: ${r.target}ms`);
-                output.writeln();
-            }
-            if (outputFormat === 'json') {
-                output.writeln(JSON.stringify(results, null, 2));
-            }
-            return { success: true, message: 'Memory benchmarks complete' };
-        }
-        catch (err) {
-            spinner.stop();
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            output.writeln(output.error(`Memory benchmark failed: ${errorMsg}`));
-            return {
-                success: false,
-                message: `Memory benchmark failed: ${errorMsg}`,
-            };
-        }
-    },
-};
-// ============================================================================
-// Full Suite Benchmark Subcommand
-// ============================================================================
-const allCommand = {
-    name: 'all',
-    description: 'Run all benchmark suites',
-    options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '50' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
-        { name: 'save', short: 's', type: 'string', description: 'Save results to file' },
-    ],
-    examples: [
-        { command: 'monomind benchmark all', description: 'Run all benchmarks' },
-        { command: 'monomind benchmark all --save full-results.json', description: 'Run all and save results' },
-    ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        output.writeln(output.bold('  Monomind - Full Benchmark Suite'));
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        const startTime = Date.now();
-        const allResults = {};
-        // Run pretrain benchmarks
-        output.writeln();
-        output.writeln(output.bold('▸ Pre-Training Benchmarks'));
-        if (pretrainCommand.action) {
-            const pretrainResult = await pretrainCommand.action(ctx);
-            allResults.pretrain = pretrainResult;
-        }
-        // Run neural benchmarks
-        output.writeln();
-        output.writeln(output.bold('▸ Neural Benchmarks'));
-        if (neuralCommand.action) {
-            const neuralResult = await neuralCommand.action(ctx);
-            allResults.neural = neuralResult;
-        }
-        // Run memory benchmarks
-        output.writeln();
-        output.writeln(output.bold('▸ Memory Benchmarks'));
-        if (memoryCommand.action) {
-            const memoryResult = await memoryCommand.action(ctx);
-            allResults.memory = memoryResult;
-        }
-        const totalDuration = Date.now() - startTime;
-        output.writeln();
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        output.writeln(`  Total Duration: ${(totalDuration / 1000).toFixed(2)}s`);
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        // Save if requested
-        const saveFile = ctx.flags.save;
-        if (saveFile) {
-            const resultsDir = join(process.cwd(), '.monomind', 'benchmarks');
-            if (!existsSync(resultsDir)) {
-                mkdirSync(resultsDir, { recursive: true });
-            }
-            // Path traversal guard: resolve within resultsDir regardless of whether saveFile is absolute
-            const { resolve: resolvePath, basename } = await import('node:path');
-            const safeName = basename(saveFile);
-            const savePath = resolvePath(resultsDir, safeName);
-            const resolvedResultsDir = resolvePath(resultsDir);
-            if (!savePath.startsWith(resolvedResultsDir + '/') && savePath !== resolvedResultsDir) {
-                output.writeln(output.error(`Save path must be within ${resultsDir}`));
-                return { success: false, message: 'Invalid save path' };
-            }
-            const saveTmp2 = savePath + '.tmp';
-            writeFileSync(saveTmp2, JSON.stringify({
-                timestamp: new Date().toISOString(),
-                duration: totalDuration,
-                results: allResults,
-            }, null, 2));
-            renameSync(saveTmp2, savePath);
-            output.writeln(output.success(`Results saved to ${savePath}`));
-        }
-        return { success: true, message: 'All benchmarks complete' };
-    },
-};
-// ============================================================================
-// Regression Benchmark Subcommand
-// ============================================================================
-const regressionCommand = {
-    name: 'regression',
-    description: 'Quality regression testing using benchmark definitions and baselines',
-    options: [
-        { name: 'suite', short: 's', type: 'string', description: 'Path to benchmark definitions directory', default: '.monomind/benchmarks/definitions' },
-        { name: 'benchmark-id', short: 'b', type: 'string', description: 'Run a specific benchmark by ID' },
-        { name: 'agent-output', short: 'a', type: 'string', description: 'Path to file containing agent output to evaluate' },
-        { name: 'pin-baseline', type: 'boolean', description: 'Save current results as the new baseline', default: 'false' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
-    ],
-    examples: [
-        { command: 'monomind benchmark regression', description: 'List all benchmark definitions' },
-        { command: 'monomind benchmark regression -b agent-spawn -a output.txt', description: 'Evaluate agent output against a benchmark' },
-        { command: 'monomind benchmark regression -b agent-spawn -a output.txt --pin-baseline', description: 'Evaluate and pin results as new baseline' },
-    ],
-    action: async (ctx) => {
-        const suiteDirRaw = ctx.flags.suite || '.monomind/benchmarks/definitions';
-        const benchmarkId = ctx.flags['benchmark-id'];
-        const agentOutputFile = ctx.flags['agent-output'];
-        const pinBaseline = ctx.flags['pin-baseline'] === true;
-        const outputFormat = ctx.flags.output || 'text';
-        // Validate benchmarkId to prevent path traversal in baseline file names
-        if (benchmarkId !== undefined) {
-            if (!/^[a-zA-Z0-9_-]{1,128}$/.test(benchmarkId)) {
-                output.writeln(output.error('Invalid benchmark-id: must contain only alphanumeric, dash, or underscore characters (max 128).'));
-                return { success: false, message: 'Invalid benchmark-id' };
-            }
-        }
-        const runner = new BenchmarkRunner();
-        const baselinesDir = join(process.cwd(), '.monomind', 'benchmarks', 'baselines');
-        // Path traversal guard for suiteDir
-        const { resolve: resolvePath2 } = await import('node:path');
-        const projectRoot = resolvePath2(process.cwd());
-        const resolvedSuiteDir = resolvePath2(process.cwd(), suiteDirRaw);
-        if (!resolvedSuiteDir.startsWith(projectRoot + '/') && resolvedSuiteDir !== projectRoot) {
-            output.writeln(output.error(`Suite directory must be within the project: ${projectRoot}`));
-            return { success: false, message: 'Invalid suite directory' };
-        }
-        const suiteDir = suiteDirRaw;
-        const definitions = runner.loadBenchmarks(resolvedSuiteDir);
-        if (definitions.length === 0) {
-            output.writeln(output.dim(`No benchmark definitions found in ${suiteDir}`));
-            output.writeln(output.dim('Create JSON files there to define quality benchmarks.'));
-            return { success: true, message: 'No benchmarks defined' };
-        }
-        // List mode — no agent output provided
-        if (!agentOutputFile) {
-            output.writeln();
-            output.writeln(output.bold('Benchmark Definitions'));
-            output.writeln(output.dim('─'.repeat(50)));
-            for (const def of definitions) {
-                output.writeln(`  ${output.highlight(def.benchmarkId)}  ${output.dim(def.agentSlug)}  — ${def.qualityMetrics?.length ?? 0} metrics`);
-            }
-            output.writeln();
-            output.writeln(output.dim('Use --agent-output <file> to evaluate against a benchmark.'));
-            return { success: true, message: `${definitions.length} benchmarks loaded` };
-        }
-        // Evaluation mode
-        if (!existsSync(agentOutputFile)) {
-            output.writeln(output.error(`Agent output file not found: ${agentOutputFile}`));
-            return { success: false, message: 'Agent output file not found' };
-        }
-        const MAX_AGENT_OUTPUT_BYTES = 10 * 1024 * 1024; // 10 MB
-        try {
-            const agentOutputStat = statSync(agentOutputFile);
-            if (agentOutputStat.size > MAX_AGENT_OUTPUT_BYTES) {
-                output.writeln(output.error(`Agent output file too large: ${agentOutputFile} (max 10 MB)`));
-                return { success: false, message: 'Agent output file too large' };
-            }
-        }
-        catch { /* existsSync already passed; ignore stat failure */ }
-        const agentOutput = readFileSync(agentOutputFile, 'utf-8');
-        const targetDefs = benchmarkId
-            ? definitions.filter((d) => d.benchmarkId === benchmarkId)
-            : definitions;
-        if (targetDefs.length === 0) {
-            output.writeln(output.error(`No benchmark found with id: ${benchmarkId}`));
-            return { success: false, message: 'Benchmark not found' };
-        }
-        const results = targetDefs.map((def) => runner.runBenchmark(def, agentOutput));
-        if (outputFormat === 'json') {
-            output.writeln(JSON.stringify(results, null, 2));
-        }
-        else {
-            output.writeln();
-            output.writeln(output.bold('Regression Results'));
-            output.writeln(output.dim('─'.repeat(50)));
-            for (const result of results) {
-                const status = result.passed ? output.success('PASS') : output.error('FAIL');
-                output.writeln(`  ${status}  ${result.benchmarkId}  ${output.dim(`${result.durationMs}ms`)}`);
-                for (const m of result.metricResults) {
-                    const mStatus = m.passed ? '  ✓' : '  ✗';
-                    output.writeln(`    ${mStatus}  ${m.type}`);
-                }
-            }
-            output.writeln();
-        }
-        // Baseline comparison
-        const MAX_BASELINE_BYTES = 5 * 1024 * 1024; // 5 MB
-        const baselinePath = join(baselinesDir, `${benchmarkId ?? 'all'}.json`);
-        if (existsSync(baselinePath)) {
-            const baselineStat = statSync(baselinePath);
-            if (baselineStat.size > MAX_BASELINE_BYTES) {
-                output.writeln(output.error(`Baseline file too large (max 5 MB)`));
-                return { success: false, message: 'Baseline file too large' };
-            }
-            const baseline = JSON.parse(readFileSync(baselinePath, 'utf-8'));
-            const hasRegression = runner.detectRegression(results, baseline);
-            if (hasRegression) {
-                output.writeln(output.error(`Regression detected — pass rate dropped below baseline (${(baseline.passRate * 100).toFixed(0)}%)`));
-            }
-            else {
-                output.writeln(output.success('No regression detected vs baseline'));
-            }
-        }
-        // Pin baseline
-        if (pinBaseline) {
-            if (!existsSync(baselinesDir))
-                mkdirSync(baselinesDir, { recursive: true });
-            const id = benchmarkId ?? 'all';
-            const baseline = runner.pinBaseline(id, results);
-            const baselineTmp = baselinePath + '.tmp';
-            writeFileSync(baselineTmp, JSON.stringify(baseline, null, 2));
-            renameSync(baselineTmp, baselinePath);
-            output.writeln(output.success(`Baseline pinned: ${(baseline.passRate * 100).toFixed(0)}% pass rate`));
-        }
-        const allPassed = results.every((r) => r.passed);
-        return { success: allPassed, message: allPassed ? 'All metrics passed' : 'Some metrics failed' };
-    },
-};
-// ============================================================================
-// Main Benchmark Command
-// ============================================================================
-export const benchmarkCommand = {
-    name: 'benchmark',
-    description: 'Performance benchmarking for self-learning and neural systems',
-    subcommands: [
-        pretrainCommand,
-        neuralCommand,
-        memoryCommand,
-        allCommand,
-        regressionCommand,
-    ],
-    examples: [
-        { command: 'monomind benchmark pretrain', description: 'Benchmark pre-training system' },
-        { command: 'monomind benchmark neural', description: 'Benchmark neural operations' },
-        { command: 'monomind benchmark memory', description: 'Benchmark memory operations' },
-        { command: 'monomind benchmark all', description: 'Run all benchmarks' },
-        { command: 'monomind benchmark regression', description: 'List quality regression benchmarks' },
-        { command: 'monomind benchmark regression -b my-bench -a output.txt', description: 'Evaluate agent output against a benchmark' },
-    ],
-    action: async (_ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Monomind Benchmark Suite'));
-        output.writeln(output.dim('─'.repeat(50)));
-        output.writeln();
-        output.writeln('Available subcommands:');
-        output.writeln(`  ${output.highlight('pretrain')}    - Benchmark pattern-learning pre-training`);
-        output.writeln(`  ${output.highlight('neural')}      - Benchmark neural operations (embeddings, WASM)`);
-        output.writeln(`  ${output.highlight('memory')}      - Benchmark memory operations (HNSW, store, search)`);
-        output.writeln(`  ${output.highlight('all')}         - Run all benchmark suites`);
-        output.writeln(`  ${output.highlight('regression')}  - Quality regression testing with baselines`);
-        output.writeln();
-        output.writeln('Examples:');
-        output.writeln('  monomind benchmark pretrain -i 200');
-        output.writeln('  monomind benchmark all --save results.json');
-        output.writeln();
-        return { success: true, message: 'Use a subcommand to run benchmarks' };
-    },
-};
-export default benchmarkCommand;
-//# sourceMappingURL=benchmark.js.map

package/packages/@monomind/cli/dist/src/commands/migrate.d.ts

@@ -1,8 +0,0 @@
-/**
- * CLI Migrate Command
- * Migration tools for V2 to v1 transition
- */
-import type { Command } from '../types.js';
-export declare const migrateCommand: Command;
-export default migrateCommand;
-//# sourceMappingURL=migrate.d.ts.map