kynjal-cli 4.0.0 → 4.0.2

package/dist/src/commands/neural.js

@@ -4,422 +4,333 @@
  *
  * Created with ❤️ by ruv.io
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { output } from '../output.js';
 // Train subcommand - REAL WASM training with RuVector
-var trainCommand = {
+const trainCommand = {
     name: 'train',
     description: 'Train neural patterns with WASM SIMD acceleration (MicroLoRA + Flash Attention)',
     options: [
-        { name: 'pattern', short: 'p', type: 'string', description: 'Pattern type: coordination, optimization, prediction, security, testing', "default": 'coordination' },
-        { name: 'epochs', short: 'e', type: 'number', description: 'Number of training epochs', "default": '50' },
+        { name: 'pattern', short: 'p', type: 'string', description: 'Pattern type: coordination, optimization, prediction, security, testing', default: 'coordination' },
+        { name: 'epochs', short: 'e', type: 'number', description: 'Number of training epochs', default: '50' },
         { name: 'data', short: 'd', type: 'string', description: 'Training data file or inline JSON' },
         { name: 'model', short: 'm', type: 'string', description: 'Model ID to train' },
-        { name: 'learning-rate', short: 'l', type: 'number', description: 'Learning rate', "default": '0.01' },
-        { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size', "default": '32' },
-        { name: 'dim', type: 'number', description: 'Embedding dimension (max 256)', "default": '256' },
-        { name: 'wasm', short: 'w', type: 'boolean', description: 'Use RuVector WASM acceleration', "default": 'true' },
-        { name: 'flash', type: 'boolean', description: 'Enable Flash Attention (2.49x-7.47x speedup)', "default": 'true' },
-        { name: 'moe', type: 'boolean', description: 'Enable Mixture of Experts routing', "default": 'false' },
-        { name: 'hyperbolic', type: 'boolean', description: 'Enable hyperbolic attention for hierarchical patterns', "default": 'false' },
-        { name: 'contrastive', type: 'boolean', description: 'Use contrastive learning (InfoNCE)', "default": 'true' },
-        { name: 'curriculum', type: 'boolean', description: 'Enable curriculum learning', "default": 'false' },
+        { name: 'learning-rate', short: 'l', type: 'number', description: 'Learning rate', default: '0.01' },
+        { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size', default: '32' },
+        { name: 'dim', type: 'number', description: 'Embedding dimension (max 256)', default: '256' },
+        { name: 'wasm', short: 'w', type: 'boolean', description: 'Use RuVector WASM acceleration', default: 'true' },
+        { name: 'flash', type: 'boolean', description: 'Enable Flash Attention (2.49x-7.47x speedup)', default: 'true' },
+        { name: 'moe', type: 'boolean', description: 'Enable Mixture of Experts routing', default: 'false' },
+        { name: 'hyperbolic', type: 'boolean', description: 'Enable hyperbolic attention for hierarchical patterns', default: 'false' },
+        { name: 'contrastive', type: 'boolean', description: 'Use contrastive learning (InfoNCE)', default: 'true' },
+        { name: 'curriculum', type: 'boolean', description: 'Enable curriculum learning', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow neural train -p coordination -e 100', description: 'Train coordination patterns' },
         { command: 'claude-flow neural train -d ./training-data.json --flash', description: 'Train from file with Flash Attention' },
         { command: 'claude-flow neural train -p security --wasm --contrastive', description: 'Security patterns with contrastive learning' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var patternType, epochs, learningRate, batchSize, dim, useWasm, useFlash, useMoE, useHyperbolic, useContrastive, useCurriculum, dataFile, spinner, ruvector, generateEmbedding, _a, initializeIntelligence, recordStep, recordTrajectory, getIntelligenceStats, flushPatterns, getPersistenceStatus, wasmFeatures, initResult, backendLabel, operatorMap, operatorType, trainingData, fs, raw, templates, patterns, i, startTime, epochTimes, patternsRecorded, trajectoriesCompleted, totalLoss, adaptations, embeddings, _i, _b, item, embeddingResult, embeddingArray, resized, i, epoch, epochStart, difficulty, batchStart, batch, anchor, positives, negatives, _c, loss, gradient, scaledGradient, i, baselineMs, executionMs, _d, item, steps, epochTime, progress, avgEpochTime, eta, totalTime, ruvectorStats, trajectoryStats, benchmark, _e, stats, persistence, tableData, backendUsed, flashBench, backendUsed, backendMsg, error_1;
-        var _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0:
-                    patternType = (ctx.flags.pattern || ctx.flags.patternType || ctx.flags['pattern-type']) || 'coordination';
-                    epochs = parseInt(ctx.flags.epochs || '50', 10);
-                    learningRate = parseFloat(ctx.flags['learning-rate'] || '0.01');
-                    batchSize = parseInt(ctx.flags['batch-size'] || '32', 10);
-                    dim = Math.min(parseInt(ctx.flags.dim || '256', 10), 256);
-                    useWasm = ctx.flags.wasm !== false;
-                    useFlash = ctx.flags.flash !== false;
-                    useMoE = ctx.flags.moe === true;
-                    useHyperbolic = ctx.flags.hyperbolic === true;
-                    useContrastive = ctx.flags.contrastive !== false;
-                    useCurriculum = ctx.flags.curriculum === true;
-                    dataFile = ctx.flags.data;
-                    output.writeln();
-                    output.writeln(output.bold('Neural Pattern Training (RuVector WASM)'));
-                    output.writeln(output.dim('─'.repeat(55)));
-                    spinner = output.createSpinner({ text: 'Initializing RuVector training systems...', spinner: 'dots' });
-                    spinner.start();
-                    _g.label = 1;
-                case 1:
-                    _g.trys.push([1, 29, , 30]);
-                    return [4 /*yield*/, import('../services/ruvector-training.js')];
-                case 2:
-                    ruvector = _g.sent();
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 3:
-                    generateEmbedding = (_g.sent()).generateEmbedding;
-                    return [4 /*yield*/, import('../memory/intelligence.js')];
-                case 4:
-                    _a = _g.sent(), initializeIntelligence = _a.initializeIntelligence, recordStep = _a.recordStep, recordTrajectory = _a.recordTrajectory, getIntelligenceStats = _a.getIntelligenceStats, flushPatterns = _a.flushPatterns, getPersistenceStatus = _a.getPersistenceStatus;
-                    wasmFeatures = [];
-                    if (!useWasm) return [3 /*break*/, 6];
-                    return [4 /*yield*/, ruvector.initializeTraining({
-                            dim: dim,
-                            learningRate: learningRate,
-                            alpha: 0.1,
-                            trajectoryCapacity: epochs * batchSize,
-                            useFlashAttention: useFlash,
-                            useMoE: useMoE,
-                            useHyperbolic: useHyperbolic,
-                            totalSteps: useCurriculum ? epochs : undefined,
-                            warmupSteps: useCurriculum ? Math.floor(epochs * 0.1) : undefined
-                        })];
-                case 5:
-                    initResult = _g.sent();
-                    if (initResult.success) {
-                        wasmFeatures = initResult.features;
-                        backendLabel = initResult.backend === 'wasm' ? 'WASM' : 'JS fallback';
-                        spinner.setText("RuVector initialized [" + backendLabel + "]: " + wasmFeatures.join(', '));
-                    }
-                    else {
-                        output.writeln(output.warning("WASM init failed: " + initResult.error + " - falling back"));
-                    }
-                    _g.label = 6;
-                case 6: 
-                // Also initialize SONA + ReasoningBank for persistence
-                return [4 /*yield*/, initializeIntelligence({
-                        loraLearningRate: learningRate,
-                        maxTrajectorySize: epochs
-                    })];
-                case 7:
-                    // Also initialize SONA + ReasoningBank for persistence
-                    _g.sent();
-                    operatorMap = {
-                        coordination: ruvector.OperatorType.COORDINATION,
-                        optimization: ruvector.OperatorType.OPTIMIZATION,
-                        prediction: ruvector.OperatorType.ROUTING,
-                        security: ruvector.OperatorType.SECURITY,
-                        testing: ruvector.OperatorType.TESTING,
-                        debugging: ruvector.OperatorType.DEBUGGING,
-                        memory: ruvector.OperatorType.MEMORY,
-                        reasoning: ruvector.OperatorType.REASONING
-                    };
-                    operatorType = (_f = operatorMap[patternType]) !== null && _f !== void 0 ? _f : ruvector.OperatorType.GENERAL;
-                    spinner.setText("Training " + patternType + " patterns...");
-                    trainingData = [];
-                    if (!dataFile) return [3 /*break*/, 9];
-                    return [4 /*yield*/, import('fs')];
-                case 8:
-                    fs = _g.sent();
-                    if (fs.existsSync(dataFile)) {
-                        raw = fs.readFileSync(dataFile, 'utf8');
-                        trainingData = JSON.parse(raw);
-                    }
-                    else {
-                        spinner.fail("Training data file not found: " + dataFile);
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    return [3 /*break*/, 10];
-                case 9:
-                    templates = {
-                        coordination: [
-                            'Route task to coder agent for implementation',
-                            'Coordinate researcher and architect for design phase',
-                            'Distribute workload across mesh topology',
-                            'Synchronize agents via gossip protocol',
-                            'Balance load between active workers',
-                            'Spawn hierarchical swarm for complex task',
-                            'Assign reviewer to completed implementation'
-                        ],
-                        optimization: [
-                            'Apply Int8 quantization for memory reduction',
-                            'Enable HNSW indexing for faster search',
-                            'Batch operations for throughput improvement',
-                            'Cache frequently accessed patterns',
-                            'Prune unused neural pathways',
-                            'Use Flash Attention for large sequences',
-                            'Enable SIMD for vector operations'
-                        ],
-                        prediction: [
-                            'Predict optimal agent for task type',
-                            'Forecast resource requirements',
-                            'Anticipate failure modes and mitigate',
-                            'Estimate completion time for workflow',
-                            'Predict pattern similarity before search'
-                        ],
-                        security: [
-                            'Validate input at system boundaries',
-                            'Check for path traversal attempts',
-                            'Sanitize user-provided data',
-                            'Apply parameterized queries for SQL',
-                            'Verify JWT token signatures',
-                            'Audit sensitive operation access'
-                        ],
-                        testing: [
-                            'Generate unit tests for function',
-                            'Create integration test suite',
-                            'Mock external dependencies',
-                            'Assert expected outcomes',
-                            'Coverage gap analysis'
-                        ]
-                    };
-                    patterns = templates[patternType] || templates.coordination;
-                    for (i = 0; i < epochs; i++) {
-                        trainingData.push({
-                            content: patterns[i % patterns.length],
-                            type: patternType
-                        });
+    action: async (ctx) => {
+        const patternType = (ctx.flags.pattern || ctx.flags.patternType || ctx.flags['pattern-type']) || 'coordination';
+        const epochs = parseInt(ctx.flags.epochs || '50', 10);
+        const learningRate = parseFloat(ctx.flags['learning-rate'] || '0.01');
+        const batchSize = parseInt(ctx.flags['batch-size'] || '32', 10);
+        const dim = Math.min(parseInt(ctx.flags.dim || '256', 10), 256);
+        const useWasm = ctx.flags.wasm !== false;
+        const useFlash = ctx.flags.flash !== false;
+        const useMoE = ctx.flags.moe === true;
+        const useHyperbolic = ctx.flags.hyperbolic === true;
+        const useContrastive = ctx.flags.contrastive !== false;
+        const useCurriculum = ctx.flags.curriculum === true;
+        const dataFile = ctx.flags.data;
+        output.writeln();
+        output.writeln(output.bold('Neural Pattern Training (RuVector WASM)'));
+        output.writeln(output.dim('─'.repeat(55)));
+        const spinner = output.createSpinner({ text: 'Initializing RuVector training systems...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Import RuVector training service
+            const ruvector = await import('../services/ruvector-training.js');
+            const { generateEmbedding } = await import('../memory/memory-initializer.js');
+            const { initializeIntelligence, recordStep, recordTrajectory, getIntelligenceStats, flushPatterns, getPersistenceStatus } = await import('../memory/intelligence.js');
+            // Initialize RuVector WASM training
+            let wasmFeatures = [];
+            if (useWasm) {
+                const initResult = await ruvector.initializeTraining({
+                    dim,
+                    learningRate,
+                    alpha: 0.1,
+                    trajectoryCapacity: epochs * batchSize,
+                    useFlashAttention: useFlash,
+                    useMoE,
+                    useHyperbolic,
+                    totalSteps: useCurriculum ? epochs : undefined,
+                    warmupSteps: useCurriculum ? Math.floor(epochs * 0.1) : undefined,
+                });
+                if (initResult.success) {
+                    wasmFeatures = initResult.features;
+                    const backendLabel = initResult.backend === 'wasm' ? 'WASM' : 'JS fallback';
+                    spinner.setText(`RuVector initialized [${backendLabel}]: ${wasmFeatures.join(', ')}`);
+                }
+                else {
+                    output.writeln(output.warning(`WASM init failed: ${initResult.error} - falling back`));
+                }
+            }
+            // Also initialize SONA + ReasoningBank for persistence
+            await initializeIntelligence({
+                loraLearningRate: learningRate,
+                maxTrajectorySize: epochs
+            });
+            // Pattern type to operator mapping
+            const operatorMap = {
+                coordination: ruvector.OperatorType.COORDINATION,
+                optimization: ruvector.OperatorType.OPTIMIZATION,
+                prediction: ruvector.OperatorType.ROUTING,
+                security: ruvector.OperatorType.SECURITY,
+                testing: ruvector.OperatorType.TESTING,
+                debugging: ruvector.OperatorType.DEBUGGING,
+                memory: ruvector.OperatorType.MEMORY,
+                reasoning: ruvector.OperatorType.REASONING,
+            };
+            const operatorType = operatorMap[patternType] ?? ruvector.OperatorType.GENERAL;
+            spinner.setText(`Training ${patternType} patterns...`);
+            // Training data - load from file or generate synthetic
+            let trainingData = [];
+            if (dataFile) {
+                const fs = await import('fs');
+                if (fs.existsSync(dataFile)) {
+                    const raw = fs.readFileSync(dataFile, 'utf8');
+                    trainingData = JSON.parse(raw);
+                }
+                else {
+                    spinner.fail(`Training data file not found: ${dataFile}`);
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            else {
+                // Generate synthetic training data based on pattern type
+                const templates = {
+                    coordination: [
+                        'Route task to coder agent for implementation',
+                        'Coordinate researcher and architect for design phase',
+                        'Distribute workload across mesh topology',
+                        'Synchronize agents via gossip protocol',
+                        'Balance load between active workers',
+                        'Spawn hierarchical swarm for complex task',
+                        'Assign reviewer to completed implementation'
+                    ],
+                    optimization: [
+                        'Apply Int8 quantization for memory reduction',
+                        'Enable HNSW indexing for faster search',
+                        'Batch operations for throughput improvement',
+                        'Cache frequently accessed patterns',
+                        'Prune unused neural pathways',
+                        'Use Flash Attention for large sequences',
+                        'Enable SIMD for vector operations'
+                    ],
+                    prediction: [
+                        'Predict optimal agent for task type',
+                        'Forecast resource requirements',
+                        'Anticipate failure modes and mitigate',
+                        'Estimate completion time for workflow',
+                        'Predict pattern similarity before search'
+                    ],
+                    security: [
+                        'Validate input at system boundaries',
+                        'Check for path traversal attempts',
+                        'Sanitize user-provided data',
+                        'Apply parameterized queries for SQL',
+                        'Verify JWT token signatures',
+                        'Audit sensitive operation access'
+                    ],
+                    testing: [
+                        'Generate unit tests for function',
+                        'Create integration test suite',
+                        'Mock external dependencies',
+                        'Assert expected outcomes',
+                        'Coverage gap analysis'
+                    ]
+                };
+                const patterns = templates[patternType] || templates.coordination;
+                for (let i = 0; i < epochs; i++) {
+                    trainingData.push({
+                        content: patterns[i % patterns.length],
+                        type: patternType
+                    });
+                }
+            }
+            // Training metrics
+            const startTime = Date.now();
+            const epochTimes = [];
+            let patternsRecorded = 0;
+            let trajectoriesCompleted = 0;
+            let totalLoss = 0;
+            let adaptations = 0;
+            // Generate embeddings for training data
+            const embeddings = [];
+            spinner.setText('Generating embeddings...');
+            for (const item of trainingData.slice(0, Math.min(100, trainingData.length))) {
+                const embeddingResult = await generateEmbedding(item.content);
+                if (embeddingResult && embeddingResult.embedding) {
+                    // Convert to Float32Array and resize to dim
+                    const embeddingArray = embeddingResult.embedding;
+                    const resized = new Float32Array(dim);
+                    for (let i = 0; i < Math.min(embeddingArray.length, dim); i++) {
+                        resized[i] = embeddingArray[i];
                     }
-                    _g.label = 10;
-                case 10:
-                    startTime = Date.now();
-                    epochTimes = [];
-                    patternsRecorded = 0;
-                    trajectoriesCompleted = 0;
-                    totalLoss = 0;
-                    adaptations = 0;
-                    embeddings = [];
-                    spinner.setText('Generating embeddings...');
-                    _i = 0, _b = trainingData.slice(0, Math.min(100, trainingData.length));
-                    _g.label = 11;
-                case 11:
-                    if (!(_i < _b.length)) return [3 /*break*/, 14];
-                    item = _b[_i];
-                    return [4 /*yield*/, generateEmbedding(item.content)];
-                case 12:
-                    embeddingResult = _g.sent();
-                    if (embeddingResult && embeddingResult.embedding) {
-                        embeddingArray = embeddingResult.embedding;
-                        resized = new Float32Array(dim);
-                        for (i = 0; i < Math.min(embeddingArray.length, dim); i++) {
-                            resized[i] = embeddingArray[i];
+                    embeddings.push(resized);
+                }
+            }
+            spinner.setText(`Training with ${embeddings.length} embeddings...`);
+            // Main training loop with WASM acceleration
+            for (let epoch = 0; epoch < epochs; epoch++) {
+                const epochStart = performance.now();
+                // Get curriculum difficulty if enabled
+                const difficulty = useCurriculum ? ruvector.getCurriculumDifficulty(epoch) : 1.0;
+                // Process batch
+                const batchStart = (epoch * batchSize) % embeddings.length;
+                const batch = embeddings.slice(batchStart, batchStart + batchSize);
+                if (batch.length === 0)
+                    continue;
+                // Training step with contrastive learning
+                if (useContrastive && batch.length >= 3 && useWasm && wasmFeatures.length > 0) {
+                    const anchor = batch[0];
+                    const positives = [batch[1]];
+                    const negatives = batch.slice(2);
+                    try {
+                        // Compute contrastive loss
+                        const { loss, gradient } = ruvector.computeContrastiveLoss(anchor, positives, negatives);
+                        totalLoss += loss;
+                        // Scale gradient by difficulty
+                        const scaledGradient = new Float32Array(gradient.length);
+                        for (let i = 0; i < gradient.length; i++) {
+                            scaledGradient[i] = gradient[i] * difficulty;
                         }
-                        embeddings.push(resized);
+                        // Train with MicroLoRA
+                        await ruvector.trainPattern(anchor, scaledGradient, operatorType);
+                        adaptations++;
+                        // Record trajectory for learning
+                        const baselineMs = 10; // Baseline execution time
+                        const executionMs = performance.now() - epochStart;
+                        ruvector.recordTrajectory(anchor, operatorType, useFlash ? 1 : 0, executionMs, baselineMs);
                     }
-                    _g.label = 13;
-                case 13:
-                    _i++;
-                    return [3 /*break*/, 11];
-                case 14:
-                    spinner.setText("Training with " + embeddings.length + " embeddings...");
-                    epoch = 0;
-                    _g.label = 15;
-                case 15:
-                    if (!(epoch < epochs)) return [3 /*break*/, 24];
-                    epochStart = performance.now();
-                    difficulty = useCurriculum ? ruvector.getCurriculumDifficulty(epoch) : 1.0;
-                    batchStart = (epoch * batchSize) % embeddings.length;
-                    batch = embeddings.slice(batchStart, batchStart + batchSize);
-                    if (batch.length === 0)
-                        return [3 /*break*/, 23];
-                    if (!(useContrastive && batch.length >= 3 && useWasm && wasmFeatures.length > 0)) return [3 /*break*/, 19];
-                    anchor = batch[0];
-                    positives = [batch[1]];
-                    negatives = batch.slice(2);
-                    _g.label = 16;
-                case 16:
-                    _g.trys.push([16, 18, , 19]);
-                    _c = ruvector.computeContrastiveLoss(anchor, positives, negatives), loss = _c.loss, gradient = _c.gradient;
-                    totalLoss += loss;
-                    scaledGradient = new Float32Array(gradient.length);
-                    for (i = 0; i < gradient.length; i++) {
-                        scaledGradient[i] = gradient[i] * difficulty;
+                    catch {
+                        // WASM training failed, fall back to basic
                     }
-                    // Train with MicroLoRA
-                    return [4 /*yield*/, ruvector.trainPattern(anchor, scaledGradient, operatorType)];
-                case 17:
-                    // Train with MicroLoRA
-                    _g.sent();
-                    adaptations++;
-                    baselineMs = 10;
-                    executionMs = performance.now() - epochStart;
-                    ruvector.recordTrajectory(anchor, operatorType, useFlash ? 1 : 0, executionMs, baselineMs);
-                    return [3 /*break*/, 19];
-                case 18:
-                    _d = _g.sent();
-                    return [3 /*break*/, 19];
-                case 19:
-                    item = trainingData[epoch % trainingData.length];
-                    return [4 /*yield*/, recordStep({
-                            type: 'action',
-                            content: item.content,
-                            metadata: { epoch: epoch, patternType: patternType, learningRate: learningRate, difficulty: difficulty }
-                        })];
-                case 20:
-                    _g.sent();
-                    patternsRecorded++;
-                    if (!((epoch + 1) % 10 === 0 || epoch === epochs - 1)) return [3 /*break*/, 22];
-                    steps = trainingData.slice(Math.max(0, epoch - 9), epoch + 1).map(function (d) { return ({ type: 'action', content: d.content }); });
-                    return [4 /*yield*/, recordTrajectory(steps, 'success')];
-                case 21:
-                    _g.sent();
+                }
+                // Also record in SONA/ReasoningBank for persistence
+                const item = trainingData[epoch % trainingData.length];
+                await recordStep({
+                    type: 'action',
+                    content: item.content,
+                    metadata: { epoch, patternType, learningRate, difficulty }
+                });
+                patternsRecorded++;
+                // Record trajectory every 10 epochs
+                if ((epoch + 1) % 10 === 0 || epoch === epochs - 1) {
+                    const steps = trainingData.slice(Math.max(0, epoch - 9), epoch + 1).map(d => ({ type: 'action', content: d.content }));
+                    await recordTrajectory(steps, 'success');
                     trajectoriesCompleted++;
-                    _g.label = 22;
-                case 22:
-                    epochTime = performance.now() - epochStart;
-                    epochTimes.push(epochTime);
-                    progress = Math.round(((epoch + 1) / epochs) * 100);
-                    avgEpochTime = epochTimes.reduce(function (a, b) { return a + b; }, 0) / epochTimes.length;
-                    eta = Math.round((epochs - epoch - 1) * avgEpochTime / 1000);
-                    spinner.setText("Training " + patternType + " patterns... " + progress + "% (ETA: " + eta + "s, loss: " + (totalLoss / Math.max(1, epoch + 1)).toFixed(4) + ")");
-                    _g.label = 23;
-                case 23:
-                    epoch++;
-                    return [3 /*break*/, 15];
-                case 24:
-                    totalTime = Date.now() - startTime;
-                    ruvectorStats = useWasm && wasmFeatures.length > 0 ? ruvector.getTrainingStats() : null;
-                    trajectoryStats = ruvectorStats === null || ruvectorStats === void 0 ? void 0 : ruvectorStats.trajectoryStats;
-                    benchmark = null;
-                    if (!(useWasm && wasmFeatures.length > 0)) return [3 /*break*/, 28];
-                    _g.label = 25;
-                case 25:
-                    _g.trys.push([25, 27, , 28]);
+                }
+                const epochTime = performance.now() - epochStart;
+                epochTimes.push(epochTime);
+                // Update progress
+                const progress = Math.round(((epoch + 1) / epochs) * 100);
+                const avgEpochTime = epochTimes.reduce((a, b) => a + b, 0) / epochTimes.length;
+                const eta = Math.round((epochs - epoch - 1) * avgEpochTime / 1000);
+                spinner.setText(`Training ${patternType} patterns... ${progress}% (ETA: ${eta}s, loss: ${(totalLoss / Math.max(1, epoch + 1)).toFixed(4)})`);
+            }
+            const totalTime = Date.now() - startTime;
+            // Get RuVector stats
+            const ruvectorStats = useWasm && wasmFeatures.length > 0 ? ruvector.getTrainingStats() : null;
+            const trajectoryStats = ruvectorStats?.trajectoryStats;
+            // Benchmark if WASM was used
+            let benchmark = null;
+            if (useWasm && wasmFeatures.length > 0) {
+                try {
                     spinner.setText('Running benchmark...');
-                    return [4 /*yield*/, ruvector.benchmarkTraining(dim, 100)];
-                case 26:
-                    benchmark = _g.sent();
-                    return [3 /*break*/, 28];
-                case 27:
-                    _e = _g.sent();
-                    return [3 /*break*/, 28];
-                case 28:
-                    stats = getIntelligenceStats();
-                    spinner.succeed("Training complete: " + epochs + " epochs in " + (totalTime / 1000).toFixed(1) + "s");
-                    // Flush patterns to disk
-                    flushPatterns();
-                    persistence = getPersistenceStatus();
-                    output.writeln();
-                    tableData = [
-                        { metric: 'Pattern Type', value: patternType },
-                        { metric: 'Epochs', value: String(epochs) },
-                        { metric: 'Batch Size', value: String(batchSize) },
-                        { metric: 'Embedding Dim', value: String(dim) },
-                        { metric: 'Learning Rate', value: String(learningRate) },
-                        { metric: 'Patterns Recorded', value: patternsRecorded.toLocaleString() },
-                        { metric: 'Trajectories', value: String(trajectoriesCompleted) },
-                        { metric: 'Total Time', value: (totalTime / 1000).toFixed(1) + "s" },
-                        { metric: 'Avg Epoch Time', value: (epochTimes.reduce(function (a, b) { return a + b; }, 0) / epochTimes.length).toFixed(2) + "ms" },
-                    ];
-                    // Add WASM-specific metrics
-                    if (useWasm && wasmFeatures.length > 0) {
-                        backendUsed = (ruvectorStats === null || ruvectorStats === void 0 ? void 0 : ruvectorStats.backend) || 'unknown';
-                        tableData.push({ metric: 'Backend', value: backendUsed === 'wasm' ? 'WASM (native)' : 'JS (fallback)' }, { metric: 'WASM Features', value: wasmFeatures.slice(0, 3).join(', ') }, { metric: 'LoRA Adaptations', value: String(adaptations) }, { metric: 'Avg Loss', value: (totalLoss / Math.max(1, epochs)).toFixed(4) });
-                        if (ruvectorStats === null || ruvectorStats === void 0 ? void 0 : ruvectorStats.microLoraStats) {
-                            tableData.push({ metric: 'MicroLoRA Delta Norm', value: ruvectorStats.microLoraStats.deltaNorm.toFixed(6) });
-                        }
-                        if (trajectoryStats) {
-                            tableData.push({ metric: 'Success Rate', value: (trajectoryStats.successRate * 100).toFixed(1) + "%" }, { metric: 'Mean Improvement', value: (trajectoryStats.meanImprovement * 100).toFixed(1) + "%" });
-                        }
-                        if (benchmark && benchmark.length > 0) {
-                            flashBench = benchmark.find(function (b) { return b.name.includes('Flash'); });
-                            if (flashBench) {
-                                tableData.push({ metric: 'Flash Attention', value: flashBench.opsPerSecond.toLocaleString() + " ops/s" });
-                            }
-                        }
-                    }
-                    tableData.push({ metric: 'ReasoningBank Size', value: stats.reasoningBankSize.toLocaleString() }, { metric: 'Persisted To', value: output.dim(persistence.dataDir) });
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 26 },
-                            { key: 'value', header: 'Value', width: 32 },
-                        ],
-                        data: tableData
-                    });
-                    output.writeln();
-                    output.writeln(output.success("\u2713 " + patternsRecorded + " patterns saved to " + persistence.patternsFile));
-                    if (useWasm && wasmFeatures.length > 0) {
-                        backendUsed = (ruvectorStats === null || ruvectorStats === void 0 ? void 0 : ruvectorStats.backend) || 'unknown';
-                        backendMsg = backendUsed === 'wasm'
-                            ? "RuVector WASM backend: " + wasmFeatures.join(', ')
-                            : "RuVector JS fallback (install @ruvector/learning-wasm for native speed): " + wasmFeatures.join(', ');
-                        output.writeln(output.highlight("\u2713 " + backendMsg));
+                    benchmark = await ruvector.benchmarkTraining(dim, 100);
+                }
+                catch {
+                    // Benchmark failed, continue
+                }
+            }
+            // Get SONA stats
+            const stats = getIntelligenceStats();
+            spinner.succeed(`Training complete: ${epochs} epochs in ${(totalTime / 1000).toFixed(1)}s`);
+            // Flush patterns to disk
+            flushPatterns();
+            const persistence = getPersistenceStatus();
+            output.writeln();
+            // Display results
+            const tableData = [
+                { metric: 'Pattern Type', value: patternType },
+                { metric: 'Epochs', value: String(epochs) },
+                { metric: 'Batch Size', value: String(batchSize) },
+                { metric: 'Embedding Dim', value: String(dim) },
+                { metric: 'Learning Rate', value: String(learningRate) },
+                { metric: 'Patterns Recorded', value: patternsRecorded.toLocaleString() },
+                { metric: 'Trajectories', value: String(trajectoriesCompleted) },
+                { metric: 'Total Time', value: `${(totalTime / 1000).toFixed(1)}s` },
+                { metric: 'Avg Epoch Time', value: `${(epochTimes.reduce((a, b) => a + b, 0) / epochTimes.length).toFixed(2)}ms` },
+            ];
+            // Add WASM-specific metrics
+            if (useWasm && wasmFeatures.length > 0) {
+                const backendUsed = ruvectorStats?.backend || 'unknown';
+                tableData.push({ metric: 'Backend', value: backendUsed === 'wasm' ? 'WASM (native)' : 'JS (fallback)' }, { metric: 'WASM Features', value: wasmFeatures.slice(0, 3).join(', ') }, { metric: 'LoRA Adaptations', value: String(adaptations) }, { metric: 'Avg Loss', value: (totalLoss / Math.max(1, epochs)).toFixed(4) });
+                if (ruvectorStats?.microLoraStats) {
+                    tableData.push({ metric: 'MicroLoRA Delta Norm', value: ruvectorStats.microLoraStats.deltaNorm.toFixed(6) });
+                }
+                if (trajectoryStats) {
+                    tableData.push({ metric: 'Success Rate', value: `${(trajectoryStats.successRate * 100).toFixed(1)}%` }, { metric: 'Mean Improvement', value: `${(trajectoryStats.meanImprovement * 100).toFixed(1)}%` });
+                }
+                if (benchmark && benchmark.length > 0) {
+                    const flashBench = benchmark.find(b => b.name.includes('Flash'));
+                    if (flashBench) {
+                        tableData.push({ metric: 'Flash Attention', value: `${flashBench.opsPerSecond.toLocaleString()} ops/s` });
                     }
-                    return [2 /*return*/, {
-                            success: true,
-                            data: {
-                                epochs: epochs,
-                                patternsRecorded: patternsRecorded,
-                                trajectoriesCompleted: trajectoriesCompleted,
-                                totalTime: totalTime,
-                                wasmFeatures: wasmFeatures,
-                                ruvectorStats: ruvectorStats,
-                                benchmark: benchmark,
-                                stats: stats,
-                                persistence: persistence
-                            }
-                        }];
-                case 29:
-                    error_1 = _g.sent();
-                    spinner.fail('Training failed');
-                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 30: return [2 /*return*/];
+                }
+            }
+            tableData.push({ metric: 'ReasoningBank Size', value: stats.reasoningBankSize.toLocaleString() }, { metric: 'Persisted To', value: output.dim(persistence.dataDir) });
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 26 },
+                    { key: 'value', header: 'Value', width: 32 },
+                ],
+                data: tableData,
+            });
+            output.writeln();
+            output.writeln(output.success(`✓ ${patternsRecorded} patterns saved to ${persistence.patternsFile}`));
+            if (useWasm && wasmFeatures.length > 0) {
+                const backendUsed = ruvectorStats?.backend || 'unknown';
+                const backendMsg = backendUsed === 'wasm'
+                    ? `RuVector WASM backend: ${wasmFeatures.join(', ')}`
+                    : `RuVector JS fallback (install @ruvector/learning-wasm for native speed): ${wasmFeatures.join(', ')}`;
+                output.writeln(output.highlight(`✓ ${backendMsg}`));
             }
-        });
-    }); }
+            return {
+                success: true,
+                data: {
+                    epochs,
+                    patternsRecorded,
+                    trajectoriesCompleted,
+                    totalTime,
+                    wasmFeatures,
+                    ruvectorStats,
+                    benchmark,
+                    stats,
+                    persistence
+                }
+            };
+        }
+        catch (error) {
+            spinner.fail('Training failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Status subcommand - REAL measurements
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Check neural network status and loaded models',
     options: [
@@ -430,769 +341,666 @@ var statusCommand = {
         { command: 'claude-flow neural status', description: 'Show all neural status' },
         { command: 'claude-flow neural status -m model-123', description: 'Check specific model' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var verbose, spinner, _a, getIntelligenceStats, initializeIntelligence, benchmarkAdaptation, _b, getHNSWStatus, loadEmbeddingModel, ruvector, stats, hnswStatus, adaptBench, modelInfo, ruvectorStats, sonaAvailable, detailedData, sonaStats, error_2;
-        var _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    verbose = ctx.flags.verbose === true;
-                    output.writeln();
-                    output.writeln(output.bold('Neural Network Status (Real)'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Checking neural systems...', spinner: 'dots' });
-                    spinner.start();
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 7, , 8]);
-                    return [4 /*yield*/, import('../memory/intelligence.js')];
-                case 2:
-                    _a = _d.sent(), getIntelligenceStats = _a.getIntelligenceStats, initializeIntelligence = _a.initializeIntelligence, benchmarkAdaptation = _a.benchmarkAdaptation;
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 3:
-                    _b = _d.sent(), getHNSWStatus = _b.getHNSWStatus, loadEmbeddingModel = _b.loadEmbeddingModel;
-                    return [4 /*yield*/, import('../services/ruvector-training.js')];
-                case 4:
-                    ruvector = _d.sent();
-                    // Initialize if needed and get real stats
-                    return [4 /*yield*/, initializeIntelligence()];
-                case 5:
-                    // Initialize if needed and get real stats
-                    _d.sent();
-                    stats = getIntelligenceStats();
-                    hnswStatus = getHNSWStatus();
-                    adaptBench = benchmarkAdaptation(100);
-                    return [4 /*yield*/, loadEmbeddingModel({ verbose: false })];
-                case 6:
-                    modelInfo = _d.sent();
-                    ruvectorStats = ruvector.getTrainingStats();
-                    sonaAvailable = ruvector.isSonaAvailable();
-                    spinner.succeed('Neural systems checked');
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'component', header: 'Component', width: 22 },
-                            { key: 'status', header: 'Status', width: 12 },
-                            { key: 'details', header: 'Details', width: 32 },
-                        ],
-                        data: [
-                            {
-                                component: 'SONA Coordinator',
-                                status: stats.sonaEnabled ? output.success('Active') : output.warning('Inactive'),
-                                details: stats.sonaEnabled
-                                    ? "Adaptation: " + (adaptBench.avgMs * 1000).toFixed(2) + "\u03BCs avg"
-                                    : 'Not initialized'
-                            },
-                            {
-                                component: 'RuVector Training',
-                                status: ruvectorStats.initialized ? output.success('Active') : output.dim('Not loaded'),
-                                details: ruvectorStats.initialized
-                                    ? (ruvectorStats.backend === 'wasm' ? 'WASM' : 'JS fallback') + " | MicroLoRA: " + ruvectorStats.totalAdaptations + " adapts"
-                                    : 'Call neural train to initialize'
-                            },
-                            {
-                                component: 'SONA Engine',
-                                status: sonaAvailable ? output.success('Active') : output.dim('Not loaded'),
-                                details: sonaAvailable && ruvectorStats.sonaStats
-                                    ? ruvectorStats.sonaStats.totalLearns + " learns, " + ruvectorStats.sonaStats.totalSearches + " searches"
-                                    : 'Optional, enable with --sona'
-                            },
-                            {
-                                component: 'ReasoningBank',
-                                status: stats.reasoningBankSize > 0 ? output.success('Active') : output.dim('Empty'),
-                                details: stats.patternsLearned + " patterns stored"
-                            },
-                            {
-                                component: 'HNSW Index',
-                                status: hnswStatus.available ? output.success('Ready') : output.dim('Not loaded'),
-                                details: hnswStatus.available
-                                    ? hnswStatus.entryCount + " vectors, " + hnswStatus.dimensions + "-dim"
-                                    : '@ruvector/core not available'
-                            },
-                            {
-                                component: 'Embedding Model',
-                                status: modelInfo.success ? output.success('Loaded') : output.warning('Fallback'),
-                                details: modelInfo.modelName + " (" + modelInfo.dimensions + "-dim)"
-                            },
-                            {
-                                component: 'Flash Attention Ops',
-                                status: output.success('Available'),
-                                details: 'batchCosineSim, softmax, topK'
-                            },
-                            {
-                                component: 'Int8 Quantization',
-                                status: output.success('Available'),
-                                details: '~4x memory reduction'
-                            },
-                        ]
-                    });
-                    if (verbose) {
-                        output.writeln();
-                        output.writeln(output.bold('Detailed Metrics'));
-                        detailedData = [
-                            { metric: 'Trajectories Recorded', value: String(stats.trajectoriesRecorded) },
-                            { metric: 'Patterns Learned', value: String(stats.patternsLearned) },
-                            { metric: 'HNSW Dimensions', value: String(hnswStatus.dimensions) },
-                            { metric: 'SONA Adaptation (avg)', value: (adaptBench.avgMs * 1000).toFixed(2) + "\u03BCs" },
-                            { metric: 'SONA Adaptation (max)', value: (adaptBench.maxMs * 1000).toFixed(2) + "\u03BCs" },
-                            { metric: 'Target Met (<0.05ms)', value: adaptBench.targetMet ? output.success('Yes') : output.warning('No') },
-                            {
-                                metric: 'Last Adaptation',
-                                value: stats.lastAdaptation
-                                    ? new Date(stats.lastAdaptation).toLocaleTimeString()
-                                    : 'Never'
-                            },
-                        ];
-                        // Add RuVector WASM metrics if initialized
-                        if (ruvectorStats.initialized) {
-                            detailedData.push({ metric: 'RuVector Adaptations', value: String(ruvectorStats.totalAdaptations) }, { metric: 'RuVector Forwards', value: String(ruvectorStats.totalForwards) });
-                            if (ruvectorStats.microLoraStats) {
-                                detailedData.push({ metric: 'MicroLoRA Delta Norm', value: ruvectorStats.microLoraStats.deltaNorm.toFixed(6) }, { metric: 'MicroLoRA Adapt Count', value: String(ruvectorStats.microLoraStats.adaptCount) });
-                            }
-                            if (sonaAvailable && ((_c = ruvectorStats.sonaStats) === null || _c === void 0 ? void 0 : _c.stats)) {
-                                sonaStats = ruvectorStats.sonaStats.stats;
-                                detailedData.push({ metric: 'SONA Patterns Stored', value: String(sonaStats.patterns_stored || 0) }, { metric: 'SONA EWC Tasks', value: String(sonaStats.ewc_tasks || 0) });
-                            }
-                        }
-                        output.printTable({
-                            columns: [
-                                { key: 'metric', header: 'Metric', width: 28 },
-                                { key: 'value', header: 'Value', width: 20 },
-                            ],
-                            data: detailedData
-                        });
+    action: async (ctx) => {
+        const verbose = ctx.flags.verbose === true;
+        output.writeln();
+        output.writeln(output.bold('Neural Network Status (Real)'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Checking neural systems...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Import real implementations
+            const { getIntelligenceStats, initializeIntelligence, benchmarkAdaptation } = await import('../memory/intelligence.js');
+            const { getHNSWStatus, loadEmbeddingModel } = await import('../memory/memory-initializer.js');
+            const ruvector = await import('../services/ruvector-training.js');
+            // Initialize if needed and get real stats
+            await initializeIntelligence();
+            const stats = getIntelligenceStats();
+            const hnswStatus = getHNSWStatus();
+            // Quick benchmark for actual adaptation time
+            const adaptBench = benchmarkAdaptation(100);
+            // Check embedding model
+            const modelInfo = await loadEmbeddingModel({ verbose: false });
+            // Check RuVector WASM status
+            const ruvectorStats = ruvector.getTrainingStats();
+            const sonaAvailable = ruvector.isSonaAvailable();
+            spinner.succeed('Neural systems checked');
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'component', header: 'Component', width: 22 },
+                    { key: 'status', header: 'Status', width: 12 },
+                    { key: 'details', header: 'Details', width: 32 },
+                ],
+                data: [
+                    {
+                        component: 'SONA Coordinator',
+                        status: stats.sonaEnabled ? output.success('Active') : output.warning('Inactive'),
+                        details: stats.sonaEnabled
+                            ? `Adaptation: ${(adaptBench.avgMs * 1000).toFixed(2)}μs avg`
+                            : 'Not initialized',
+                    },
+                    {
+                        component: 'RuVector Training',
+                        status: ruvectorStats.initialized ? output.success('Active') : output.dim('Not loaded'),
+                        details: ruvectorStats.initialized
+                            ? `${ruvectorStats.backend === 'wasm' ? 'WASM' : 'JS fallback'} | MicroLoRA: ${ruvectorStats.totalAdaptations} adapts`
+                            : 'Call neural train to initialize',
+                    },
+                    {
+                        component: 'SONA Engine',
+                        status: sonaAvailable ? output.success('Active') : output.dim('Not loaded'),
+                        details: sonaAvailable && ruvectorStats.sonaStats
+                            ? `${ruvectorStats.sonaStats.totalLearns} learns, ${ruvectorStats.sonaStats.totalSearches} searches`
+                            : 'Optional, enable with --sona',
+                    },
+                    {
+                        component: 'ReasoningBank',
+                        status: stats.reasoningBankSize > 0 ? output.success('Active') : output.dim('Empty'),
+                        details: `${stats.patternsLearned} patterns stored`,
+                    },
+                    {
+                        component: 'HNSW Index',
+                        status: hnswStatus.available ? output.success('Ready') : output.dim('Not loaded'),
+                        details: hnswStatus.available
+                            ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim`
+                            : '@ruvector/core not available',
+                    },
+                    {
+                        component: 'Embedding Model',
+                        status: modelInfo.success ? output.success('Loaded') : output.warning('Fallback'),
+                        details: `${modelInfo.modelName} (${modelInfo.dimensions}-dim)`,
+                    },
+                    {
+                        component: 'Flash Attention Ops',
+                        status: output.success('Available'),
+                        details: 'batchCosineSim, softmax, topK',
+                    },
+                    {
+                        component: 'Int8 Quantization',
+                        status: output.success('Available'),
+                        details: '~4x memory reduction',
+                    },
+                ],
+            });
+            if (verbose) {
+                output.writeln();
+                output.writeln(output.bold('Detailed Metrics'));
+                const detailedData = [
+                    { metric: 'Trajectories Recorded', value: String(stats.trajectoriesRecorded) },
+                    { metric: 'Patterns Learned', value: String(stats.patternsLearned) },
+                    { metric: 'HNSW Dimensions', value: String(hnswStatus.dimensions) },
+                    { metric: 'SONA Adaptation (avg)', value: `${(adaptBench.avgMs * 1000).toFixed(2)}μs` },
+                    { metric: 'SONA Adaptation (max)', value: `${(adaptBench.maxMs * 1000).toFixed(2)}μs` },
+                    { metric: 'Target Met (<0.05ms)', value: adaptBench.targetMet ? output.success('Yes') : output.warning('No') },
+                    {
+                        metric: 'Last Adaptation',
+                        value: stats.lastAdaptation
+                            ? new Date(stats.lastAdaptation).toLocaleTimeString()
+                            : 'Never',
+                    },
+                ];
+                // Add RuVector WASM metrics if initialized
+                if (ruvectorStats.initialized) {
+                    detailedData.push({ metric: 'RuVector Adaptations', value: String(ruvectorStats.totalAdaptations) }, { metric: 'RuVector Forwards', value: String(ruvectorStats.totalForwards) });
+                    if (ruvectorStats.microLoraStats) {
+                        detailedData.push({ metric: 'MicroLoRA Delta Norm', value: ruvectorStats.microLoraStats.deltaNorm.toFixed(6) }, { metric: 'MicroLoRA Adapt Count', value: String(ruvectorStats.microLoraStats.adaptCount) });
                     }
-                    return [2 /*return*/, { success: true, data: { stats: stats, hnswStatus: hnswStatus, adaptBench: adaptBench, modelInfo: modelInfo, ruvectorStats: ruvectorStats } }];
-                case 7:
-                    error_2 = _d.sent();
-                    spinner.fail('Failed to check neural systems');
-                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 8: return [2 /*return*/];
+                    if (sonaAvailable && ruvectorStats.sonaStats?.stats) {
+                        const sonaStats = ruvectorStats.sonaStats.stats;
+                        detailedData.push({ metric: 'SONA Patterns Stored', value: String(sonaStats.patterns_stored || 0) }, { metric: 'SONA EWC Tasks', value: String(sonaStats.ewc_tasks || 0) });
+                    }
+                }
+                output.printTable({
+                    columns: [
+                        { key: 'metric', header: 'Metric', width: 28 },
+                        { key: 'value', header: 'Value', width: 20 },
+                    ],
+                    data: detailedData,
+                });
             }
-        });
-    }); }
+            return { success: true, data: { stats, hnswStatus, adaptBench, modelInfo, ruvectorStats } };
+        }
+        catch (error) {
+            spinner.fail('Failed to check neural systems');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Patterns subcommand
-var patternsCommand = {
+const patternsCommand = {
     name: 'patterns',
     description: 'Analyze and manage cognitive patterns',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: analyze, learn, predict, list', "default": 'list' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: analyze, learn, predict, list', default: 'list' },
         { name: 'query', short: 'q', type: 'string', description: 'Pattern query for search' },
-        { name: 'limit', short: 'l', type: 'number', description: 'Max patterns to return', "default": '10' },
+        { name: 'limit', short: 'l', type: 'number', description: 'Max patterns to return', default: '10' },
     ],
     examples: [
         { command: 'claude-flow neural patterns --action list', description: 'List all patterns' },
         { command: 'claude-flow neural patterns -a analyze -q "error handling"', description: 'Analyze patterns' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var action, query, limit, _a, initializeIntelligence, getIntelligenceStats, findSimilarPatterns, getAllPatterns, getPersistenceStatus, stats, persistence, allPatterns, patterns, _b, related, error_3;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    action = ctx.flags.action || 'list';
-                    query = ctx.flags.query;
-                    limit = parseInt(ctx.flags.limit, 10) || 10;
-                    output.writeln();
-                    output.writeln(output.bold("Neural Patterns - " + action));
-                    output.writeln(output.dim('─'.repeat(40)));
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 11, , 12]);
-                    return [4 /*yield*/, import('../memory/intelligence.js')];
-                case 2:
-                    _a = _c.sent(), initializeIntelligence = _a.initializeIntelligence, getIntelligenceStats = _a.getIntelligenceStats, findSimilarPatterns = _a.findSimilarPatterns, getAllPatterns = _a.getAllPatterns, getPersistenceStatus = _a.getPersistenceStatus;
-                    return [4 /*yield*/, initializeIntelligence()];
-                case 3:
-                    _c.sent();
-                    stats = getIntelligenceStats();
-                    persistence = getPersistenceStatus();
-                    if (!(action === 'list')) return [3 /*break*/, 8];
-                    return [4 /*yield*/, getAllPatterns()];
-                case 4:
-                    allPatterns = _c.sent();
-                    if (!query) return [3 /*break*/, 6];
-                    return [4 /*yield*/, findSimilarPatterns(query, { k: limit })];
-                case 5:
-                    _b = _c.sent();
-                    return [3 /*break*/, 7];
-                case 6:
-                    _b = allPatterns.slice(0, limit);
-                    _c.label = 7;
-                case 7:
-                    patterns = _b;
-                    if (patterns.length === 0) {
-                        output.writeln(output.dim('No patterns found. Train some patterns first with: neural train'));
-                        output.writeln();
-                        output.printBox([
-                            "Total Patterns: " + stats.patternsLearned,
-                            "Trajectories: " + stats.trajectoriesRecorded,
-                            "ReasoningBank Size: " + stats.reasoningBankSize,
-                            "Persistence: " + (persistence.patternsExist ? 'Loaded from disk' : 'Not persisted'),
-                            "Data Dir: " + persistence.dataDir,
-                        ].join('\n'), 'Pattern Statistics');
-                    }
-                    else {
-                        output.printTable({
-                            columns: [
-                                { key: 'id', header: 'ID', width: 20 },
-                                { key: 'type', header: 'Type', width: 18 },
-                                { key: 'confidence', header: 'Confidence', width: 12 },
-                                { key: 'usage', header: 'Usage', width: 10 },
-                            ],
-                            data: patterns.map(function (p, i) { return ({
-                                id: (p.id || "P" + String(i + 1).padStart(3, '0')).substring(0, 18),
-                                type: output.highlight(p.type || 'unknown'),
-                                confidence: ((p.confidence || 0.5) * 100).toFixed(1) + "%",
-                                usage: String(p.usageCount || 0)
-                            }); })
-                        });
-                    }
-                    output.writeln();
-                    output.writeln(output.dim("Total: " + allPatterns.length + " patterns (persisted) | Trajectories: " + stats.trajectoriesRecorded));
-                    if (persistence.patternsExist) {
-                        output.writeln(output.success("\u2713 Loaded from: " + persistence.patternsFile));
-                    }
-                    return [3 /*break*/, 10];
-                case 8:
-                    if (!(action === 'analyze' && query)) return [3 /*break*/, 10];
-                    return [4 /*yield*/, findSimilarPatterns(query, { k: limit })];
-                case 9:
-                    related = _c.sent();
-                    output.writeln("Analyzing patterns related to: \"" + query + "\"");
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'list';
+        const query = ctx.flags.query;
+        const limit = parseInt(ctx.flags.limit, 10) || 10;
+        output.writeln();
+        output.writeln(output.bold(`Neural Patterns - ${action}`));
+        output.writeln(output.dim('─'.repeat(40)));
+        try {
+            const { initializeIntelligence, getIntelligenceStats, findSimilarPatterns, getAllPatterns, getPersistenceStatus, } = await import('../memory/intelligence.js');
+            await initializeIntelligence();
+            const stats = getIntelligenceStats();
+            const persistence = getPersistenceStatus();
+            if (action === 'list') {
+                // Get ALL patterns from ReasoningBank (loaded from disk)
+                const allPatterns = await getAllPatterns();
+                const patterns = query
+                    ? await findSimilarPatterns(query, { k: limit })
+                    : allPatterns.slice(0, limit);
+                if (patterns.length === 0) {
+                    output.writeln(output.dim('No patterns found. Train some patterns first with: neural train'));
                     output.writeln();
-                    if (related.length > 0) {
-                        output.printTable({
-                            columns: [
-                                { key: 'content', header: 'Pattern', width: 40 },
-                                { key: 'confidence', header: 'Confidence', width: 12 },
-                                { key: 'type', header: 'Type', width: 15 },
-                            ],
-                            data: related.slice(0, 5).map(function (p) {
-                                var _a;
-                                return ({
-                                    content: (p.content || '').substring(0, 38) + (((_a = p.content) === null || _a === void 0 ? void 0 : _a.length) > 38 ? '...' : ''),
-                                    confidence: ((p.confidence || 0) * 100).toFixed(0) + "%",
-                                    type: p.type || 'general'
-                                });
-                            })
-                        });
-                    }
-                    else {
-                        output.writeln(output.dim('No related patterns found.'));
-                    }
-                    _c.label = 10;
-                case 10: return [2 /*return*/, { success: true }];
-                case 11:
-                    error_3 = _c.sent();
-                    // Fallback if intelligence not initialized
-                    output.writeln(output.dim('Intelligence system not initialized.'));
-                    output.writeln(output.dim('Run: claude-flow neural train --pattern-type general'));
-                    return [2 /*return*/, { success: false }];
-                case 12: return [2 /*return*/];
+                    output.printBox([
+                        `Total Patterns: ${stats.patternsLearned}`,
+                        `Trajectories: ${stats.trajectoriesRecorded}`,
+                        `ReasoningBank Size: ${stats.reasoningBankSize}`,
+                        `Persistence: ${persistence.patternsExist ? 'Loaded from disk' : 'Not persisted'}`,
+                        `Data Dir: ${persistence.dataDir}`,
+                    ].join('\n'), 'Pattern Statistics');
+                }
+                else {
+                    output.printTable({
+                        columns: [
+                            { key: 'id', header: 'ID', width: 20 },
+                            { key: 'type', header: 'Type', width: 18 },
+                            { key: 'confidence', header: 'Confidence', width: 12 },
+                            { key: 'usage', header: 'Usage', width: 10 },
+                        ],
+                        data: patterns.map((p, i) => ({
+                            id: (p.id || `P${String(i + 1).padStart(3, '0')}`).substring(0, 18),
+                            type: output.highlight(p.type || 'unknown'),
+                            confidence: `${((p.confidence || 0.5) * 100).toFixed(1)}%`,
+                            usage: String(p.usageCount || 0),
+                        })),
+                    });
+                }
+                output.writeln();
+                output.writeln(output.dim(`Total: ${allPatterns.length} patterns (persisted) | Trajectories: ${stats.trajectoriesRecorded}`));
+                if (persistence.patternsExist) {
+                    output.writeln(output.success(`✓ Loaded from: ${persistence.patternsFile}`));
+                }
+            }
+            else if (action === 'analyze' && query) {
+                // Analyze patterns related to query
+                const related = await findSimilarPatterns(query, { k: limit });
+                output.writeln(`Analyzing patterns related to: "${query}"`);
+                output.writeln();
+                if (related.length > 0) {
+                    output.printTable({
+                        columns: [
+                            { key: 'content', header: 'Pattern', width: 40 },
+                            { key: 'confidence', header: 'Confidence', width: 12 },
+                            { key: 'type', header: 'Type', width: 15 },
+                        ],
+                        data: related.slice(0, 5).map(p => ({
+                            content: (p.content || '').substring(0, 38) + (p.content?.length > 38 ? '...' : ''),
+                            confidence: `${((p.confidence || 0) * 100).toFixed(0)}%`,
+                            type: p.type || 'general',
+                        })),
+                    });
+                }
+                else {
+                    output.writeln(output.dim('No related patterns found.'));
+                }
             }
-        });
-    }); }
+            return { success: true };
+        }
+        catch (error) {
+            // Fallback if intelligence not initialized
+            output.writeln(output.dim('Intelligence system not initialized.'));
+            output.writeln(output.dim('Run: claude-flow neural train --pattern-type general'));
+            return { success: false };
+        }
+    },
 };
 // Predict subcommand
-var predictCommand = {
+const predictCommand = {
     name: 'predict',
     description: 'Make AI predictions using trained models',
     options: [
         { name: 'input', short: 'i', type: 'string', description: 'Input text to predict routing for', required: true },
-        { name: 'k', short: 'k', type: 'number', description: 'Number of top predictions', "default": '5' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: json, table', "default": 'table' },
+        { name: 'k', short: 'k', type: 'number', description: 'Number of top predictions', default: '5' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: json, table', default: 'table' },
     ],
     examples: [
         { command: 'claude-flow neural predict -i "implement authentication"', description: 'Predict routing for task' },
         { command: 'claude-flow neural predict -i "fix bug in login" -k 3', description: 'Get top 3 predictions' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var input, k, format, spinner, _a, initializeIntelligence, findSimilarPatterns, startSearch, matches, searchTime, patternTypes, _i, matches_1, match, type, sorted, topType, confidence, error_4;
-        var _b, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    input = ctx.flags.input;
-                    k = parseInt(ctx.flags.k || '5', 10);
-                    format = ctx.flags.format || 'table';
-                    if (!input) {
-                        output.printError('--input is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Neural Prediction (Real)'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Running inference...', spinner: 'dots' });
-                    spinner.start();
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 5, , 6]);
-                    return [4 /*yield*/, import('../memory/intelligence.js')];
-                case 2:
-                    _a = _d.sent(), initializeIntelligence = _a.initializeIntelligence, findSimilarPatterns = _a.findSimilarPatterns;
-                    // Initialize intelligence system
-                    return [4 /*yield*/, initializeIntelligence()];
-                case 3:
-                    // Initialize intelligence system
-                    _d.sent();
-                    startSearch = performance.now();
-                    return [4 /*yield*/, findSimilarPatterns(input, { k: k })];
-                case 4:
-                    matches = _d.sent();
-                    searchTime = performance.now() - startSearch;
-                    spinner.succeed("Prediction complete (search: " + searchTime.toFixed(1) + "ms)");
-                    output.writeln();
-                    if (matches.length === 0) {
-                        output.writeln(output.warning('No similar patterns found. Try training first: claude-flow neural train'));
-                        return [2 /*return*/, { success: true, data: { matches: [] } }];
-                    }
-                    if (format === 'json') {
-                        output.writeln(JSON.stringify(matches, null, 2));
-                    }
-                    else {
-                        patternTypes = {};
-                        for (_i = 0, matches_1 = matches; _i < matches_1.length; _i++) {
-                            match = matches_1[_i];
-                            type = match.type || 'unknown';
-                            patternTypes[type] = (patternTypes[type] || 0) + match.similarity;
-                        }
-                        sorted = Object.entries(patternTypes).sort(function (a, b) { return b[1] - a[1]; });
-                        topType = ((_b = sorted[0]) === null || _b === void 0 ? void 0 : _b[0]) || 'unknown';
-                        confidence = ((_c = matches[0]) === null || _c === void 0 ? void 0 : _c.similarity) || 0;
-                        output.printBox([
-                            "Input: " + input.substring(0, 60) + (input.length > 60 ? '...' : ''),
-                            "",
-                            "Predicted Type: " + topType,
-                            "Confidence: " + (confidence * 100).toFixed(1) + "%",
-                            "Latency: " + searchTime.toFixed(1) + "ms",
-                            "",
-                            "Top " + matches.length + " Similar Patterns:",
-                        ].join('\n'), 'Result');
-                        output.printTable({
-                            columns: [
-                                { key: 'rank', header: '#', width: 3 },
-                                { key: 'id', header: 'Pattern ID', width: 20 },
-                                { key: 'type', header: 'Type', width: 15 },
-                                { key: 'similarity', header: 'Similarity', width: 12 },
-                            ],
-                            data: matches.slice(0, k).map(function (m, i) {
-                                var _a;
-                                return ({
-                                    rank: String(i + 1),
-                                    id: ((_a = m.id) === null || _a === void 0 ? void 0 : _a.substring(0, 20)) || 'unknown',
-                                    type: m.type || 'action',
-                                    similarity: (m.similarity * 100).toFixed(1) + "%"
-                                });
-                            })
-                        });
-                    }
-                    return [2 /*return*/, { success: true, data: { matches: matches, searchTime: searchTime } }];
-                case 5:
-                    error_4 = _d.sent();
-                    spinner.fail('Prediction failed');
-                    output.printError(error_4 instanceof Error ? error_4.message : String(error_4));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 6: return [2 /*return*/];
+    action: async (ctx) => {
+        const input = ctx.flags.input;
+        const k = parseInt(ctx.flags.k || '5', 10);
+        const format = ctx.flags.format || 'table';
+        if (!input) {
+            output.printError('--input is required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Neural Prediction (Real)'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Running inference...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const { initializeIntelligence, findSimilarPatterns } = await import('../memory/intelligence.js');
+            // Initialize intelligence system
+            await initializeIntelligence();
+            // Find similar patterns (embedding is done internally)
+            const startSearch = performance.now();
+            const matches = await findSimilarPatterns(input, { k });
+            const searchTime = performance.now() - startSearch;
+            spinner.succeed(`Prediction complete (search: ${searchTime.toFixed(1)}ms)`);
+            output.writeln();
+            if (matches.length === 0) {
+                output.writeln(output.warning('No similar patterns found. Try training first: claude-flow neural train'));
+                return { success: true, data: { matches: [] } };
+            }
+            if (format === 'json') {
+                output.writeln(JSON.stringify(matches, null, 2));
             }
-        });
-    }); }
+            else {
+                // Determine best prediction based on patterns
+                const patternTypes = {};
+                for (const match of matches) {
+                    const type = match.type || 'unknown';
+                    patternTypes[type] = (patternTypes[type] || 0) + match.similarity;
+                }
+                const sorted = Object.entries(patternTypes).sort((a, b) => b[1] - a[1]);
+                const topType = sorted[0]?.[0] || 'unknown';
+                const confidence = matches[0]?.similarity || 0;
+                output.printBox([
+                    `Input: ${input.substring(0, 60)}${input.length > 60 ? '...' : ''}`,
+                    ``,
+                    `Predicted Type: ${topType}`,
+                    `Confidence: ${(confidence * 100).toFixed(1)}%`,
+                    `Latency: ${searchTime.toFixed(1)}ms`,
+                    ``,
+                    `Top ${matches.length} Similar Patterns:`,
+                ].join('\n'), 'Result');
+                output.printTable({
+                    columns: [
+                        { key: 'rank', header: '#', width: 3 },
+                        { key: 'id', header: 'Pattern ID', width: 20 },
+                        { key: 'type', header: 'Type', width: 15 },
+                        { key: 'similarity', header: 'Similarity', width: 12 },
+                    ],
+                    data: matches.slice(0, k).map((m, i) => ({
+                        rank: String(i + 1),
+                        id: m.id?.substring(0, 20) || 'unknown',
+                        type: m.type || 'action',
+                        similarity: `${(m.similarity * 100).toFixed(1)}%`,
+                    })),
+                });
+            }
+            return { success: true, data: { matches, searchTime } };
+        }
+        catch (error) {
+            spinner.fail('Prediction failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Optimize subcommand - Real Int8 quantization and pattern optimization
-var optimizeCommand = {
+const optimizeCommand = {
     name: 'optimize',
     description: 'Optimize neural patterns (Int8 quantization, memory compression)',
     options: [
-        { name: 'method', type: 'string', description: 'Method: quantize, analyze, compact', "default": 'quantize' },
+        { name: 'method', type: 'string', description: 'Method: quantize, analyze, compact', default: 'quantize' },
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
     ],
     examples: [
         { command: 'claude-flow neural optimize --method quantize', description: 'Quantize patterns to Int8' },
         { command: 'claude-flow neural optimize --method analyze -v', description: 'Analyze memory usage' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var method, verbose, spinner, _a, initializeIntelligence, getIntelligenceStats, getAllPatterns, flushPatterns, compactPatterns, fs, path, patterns, stats, patternDir, beforeSize, patternFile, quantizedCount, memoryReduction, _i, patterns_1, pattern, beforeBytes, afterBytes, afterSize, patternFile, embeddingBytes, metadataEstimate, recommendations, compacted, error_5;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    method = ctx.flags.method || 'quantize';
-                    verbose = ctx.flags.verbose === true;
+    action: async (ctx) => {
+        const method = ctx.flags.method || 'quantize';
+        const verbose = ctx.flags.verbose === true;
+        output.writeln();
+        output.writeln(output.bold('Pattern Optimization (Real)'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: `Running ${method} optimization...`, spinner: 'dots' });
+        spinner.start();
+        try {
+            const { initializeIntelligence, getIntelligenceStats, getAllPatterns, flushPatterns, compactPatterns } = await import('../memory/intelligence.js');
+            const fs = await import('fs');
+            const path = await import('path');
+            await initializeIntelligence();
+            const patterns = await getAllPatterns();
+            const stats = getIntelligenceStats();
+            // Get actual pattern storage size
+            const patternDir = path.join(process.cwd(), '.claude-flow', 'neural');
+            let beforeSize = 0;
+            try {
+                const patternFile = path.join(patternDir, 'patterns.json');
+                if (fs.existsSync(patternFile)) {
+                    beforeSize = fs.statSync(patternFile).size;
+                }
+            }
+            catch { /* ignore */ }
+            if (method === 'quantize') {
+                // Perform real Int8 quantization on pattern embeddings
+                spinner.setText('Quantizing pattern embeddings to Int8...');
+                let quantizedCount = 0;
+                let memoryReduction = 0;
+                for (const pattern of patterns) {
+                    if (pattern.embedding && pattern.embedding.length > 0) {
+                        // Float32 (4 bytes) -> Int8 (1 byte) = 4x reduction
+                        const beforeBytes = pattern.embedding.length * 4;
+                        const afterBytes = pattern.embedding.length; // Int8
+                        memoryReduction += beforeBytes - afterBytes;
+                        quantizedCount++;
+                    }
+                }
+                // Save optimized patterns
+                await flushPatterns();
+                // Get after size
+                let afterSize = beforeSize;
+                try {
+                    const patternFile = path.join(patternDir, 'patterns.json');
+                    if (fs.existsSync(patternFile)) {
+                        afterSize = fs.statSync(patternFile).size;
+                    }
+                }
+                catch { /* ignore */ }
+                spinner.succeed(`Quantized ${quantizedCount} patterns`);
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'metric', header: 'Metric', width: 25 },
+                        { key: 'before', header: 'Before', width: 18 },
+                        { key: 'after', header: 'After', width: 18 },
+                    ],
+                    data: [
+                        { metric: 'Pattern Count', before: String(patterns.length), after: String(patterns.length) },
+                        { metric: 'Storage Size', before: `${(beforeSize / 1024).toFixed(1)} KB`, after: `${(afterSize / 1024).toFixed(1)} KB` },
+                        { metric: 'Embedding Memory', before: `${((memoryReduction * 4) / 1024).toFixed(1)} KB`, after: `${(memoryReduction / 1024).toFixed(1)} KB` },
+                        { metric: 'Memory Reduction', before: '-', after: `~${(3.92).toFixed(2)}x (Int8)` },
+                        { metric: 'Precision', before: 'Float32', after: 'Int8 (±0.5%)' },
+                    ],
+                });
+            }
+            else if (method === 'analyze') {
+                spinner.succeed('Analysis complete');
+                output.writeln();
+                output.writeln(output.bold('Pattern Memory Analysis'));
+                const embeddingBytes = patterns.reduce((sum, p) => sum + (p.embedding?.length || 0) * 4, 0);
+                const metadataEstimate = patterns.length * 100; // ~100 bytes per pattern metadata
+                output.printTable({
+                    columns: [
+                        { key: 'component', header: 'Component', width: 25 },
+                        { key: 'size', header: 'Size', width: 18 },
+                        { key: 'count', header: 'Count', width: 12 },
+                    ],
+                    data: [
+                        { component: 'Pattern Embeddings (F32)', size: `${(embeddingBytes / 1024).toFixed(1)} KB`, count: String(patterns.length) },
+                        { component: 'Pattern Metadata', size: `${(metadataEstimate / 1024).toFixed(1)} KB`, count: '-' },
+                        { component: 'Total In-Memory', size: `${((embeddingBytes + metadataEstimate) / 1024).toFixed(1)} KB`, count: '-' },
+                        { component: 'Storage (patterns.json)', size: `${(beforeSize / 1024).toFixed(1)} KB`, count: '-' },
+                        { component: 'Trajectories', size: '-', count: String(stats.trajectoriesRecorded) },
+                    ],
+                });
+                if (verbose) {
                     output.writeln();
-                    output.writeln(output.bold('Pattern Optimization (Real)'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: "Running " + method + " optimization...", spinner: 'dots' });
-                    spinner.start();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 12, , 13]);
-                    return [4 /*yield*/, import('../memory/intelligence.js')];
-                case 2:
-                    _a = _b.sent(), initializeIntelligence = _a.initializeIntelligence, getIntelligenceStats = _a.getIntelligenceStats, getAllPatterns = _a.getAllPatterns, flushPatterns = _a.flushPatterns, compactPatterns = _a.compactPatterns;
-                    return [4 /*yield*/, import('fs')];
-                case 3:
-                    fs = _b.sent();
-                    return [4 /*yield*/, import('path')];
-                case 4:
-                    path = _b.sent();
-                    return [4 /*yield*/, initializeIntelligence()];
-                case 5:
-                    _b.sent();
-                    return [4 /*yield*/, getAllPatterns()];
-                case 6:
-                    patterns = _b.sent();
-                    stats = getIntelligenceStats();
-                    patternDir = path.join(process.cwd(), '.claude-flow', 'neural');
-                    beforeSize = 0;
-                    try {
-                        patternFile = path.join(patternDir, 'patterns.json');
-                        if (fs.existsSync(patternFile)) {
-                            beforeSize = fs.statSync(patternFile).size;
-                        }
+                    output.writeln(output.bold('Optimization Recommendations'));
+                    const recommendations = [];
+                    if (patterns.length > 1000) {
+                        recommendations.push('- Consider pruning low-usage patterns');
                     }
-                    catch ( /* ignore */_c) { /* ignore */ }
-                    if (!(method === 'quantize')) return [3 /*break*/, 8];
-                    // Perform real Int8 quantization on pattern embeddings
-                    spinner.setText('Quantizing pattern embeddings to Int8...');
-                    quantizedCount = 0;
-                    memoryReduction = 0;
-                    for (_i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
-                        pattern = patterns_1[_i];
-                        if (pattern.embedding && pattern.embedding.length > 0) {
-                            beforeBytes = pattern.embedding.length * 4;
-                            afterBytes = pattern.embedding.length;
-                            memoryReduction += beforeBytes - afterBytes;
-                            quantizedCount++;
-                        }
+                    if (embeddingBytes > 1024 * 1024) {
+                        recommendations.push('- Int8 quantization would reduce memory by ~75%');
                     }
-                    // Save optimized patterns
-                    return [4 /*yield*/, flushPatterns()];
-                case 7:
-                    // Save optimized patterns
-                    _b.sent();
-                    afterSize = beforeSize;
-                    try {
-                        patternFile = path.join(patternDir, 'patterns.json');
-                        if (fs.existsSync(patternFile)) {
-                            afterSize = fs.statSync(patternFile).size;
-                        }
+                    if (stats.trajectoriesRecorded > 100) {
+                        recommendations.push('- Trajectory consolidation available');
                     }
-                    catch ( /* ignore */_d) { /* ignore */ }
-                    spinner.succeed("Quantized " + quantizedCount + " patterns");
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 25 },
-                            { key: 'before', header: 'Before', width: 18 },
-                            { key: 'after', header: 'After', width: 18 },
-                        ],
-                        data: [
-                            { metric: 'Pattern Count', before: String(patterns.length), after: String(patterns.length) },
-                            { metric: 'Storage Size', before: (beforeSize / 1024).toFixed(1) + " KB", after: (afterSize / 1024).toFixed(1) + " KB" },
-                            { metric: 'Embedding Memory', before: ((memoryReduction * 4) / 1024).toFixed(1) + " KB", after: (memoryReduction / 1024).toFixed(1) + " KB" },
-                            { metric: 'Memory Reduction', before: '-', after: "~" + (3.92).toFixed(2) + "x (Int8)" },
-                            { metric: 'Precision', before: 'Float32', after: 'Int8 (±0.5%)' },
-                        ]
-                    });
-                    return [3 /*break*/, 11];
-                case 8:
-                    if (!(method === 'analyze')) return [3 /*break*/, 9];
-                    spinner.succeed('Analysis complete');
-                    output.writeln();
-                    output.writeln(output.bold('Pattern Memory Analysis'));
-                    embeddingBytes = patterns.reduce(function (sum, p) { var _a; return sum + (((_a = p.embedding) === null || _a === void 0 ? void 0 : _a.length) || 0) * 4; }, 0);
-                    metadataEstimate = patterns.length * 100;
-                    output.printTable({
-                        columns: [
-                            { key: 'component', header: 'Component', width: 25 },
-                            { key: 'size', header: 'Size', width: 18 },
-                            { key: 'count', header: 'Count', width: 12 },
-                        ],
-                        data: [
-                            { component: 'Pattern Embeddings (F32)', size: (embeddingBytes / 1024).toFixed(1) + " KB", count: String(patterns.length) },
-                            { component: 'Pattern Metadata', size: (metadataEstimate / 1024).toFixed(1) + " KB", count: '-' },
-                            { component: 'Total In-Memory', size: ((embeddingBytes + metadataEstimate) / 1024).toFixed(1) + " KB", count: '-' },
-                            { component: 'Storage (patterns.json)', size: (beforeSize / 1024).toFixed(1) + " KB", count: '-' },
-                            { component: 'Trajectories', size: '-', count: String(stats.trajectoriesRecorded) },
-                        ]
-                    });
-                    if (verbose) {
-                        output.writeln();
-                        output.writeln(output.bold('Optimization Recommendations'));
-                        recommendations = [];
-                        if (patterns.length > 1000) {
-                            recommendations.push('- Consider pruning low-usage patterns');
-                        }
-                        if (embeddingBytes > 1024 * 1024) {
-                            recommendations.push('- Int8 quantization would reduce memory by ~75%');
-                        }
-                        if (stats.trajectoriesRecorded > 100) {
-                            recommendations.push('- Trajectory consolidation available');
-                        }
-                        if (recommendations.length === 0) {
-                            recommendations.push('- Patterns are already well optimized');
-                        }
-                        recommendations.forEach(function (r) { return output.writeln(r); });
+                    if (recommendations.length === 0) {
+                        recommendations.push('- Patterns are already well optimized');
                     }
-                    return [3 /*break*/, 11];
-                case 9:
-                    if (!(method === 'compact')) return [3 /*break*/, 11];
-                    spinner.setText('Compacting pattern storage...');
-                    return [4 /*yield*/, compactPatterns(0.95)];
-                case 10:
-                    compacted = _b.sent();
-                    spinner.succeed("Compacted " + compacted.removed + " patterns");
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 20 },
-                            { key: 'value', header: 'Value', width: 15 },
-                        ],
-                        data: [
-                            { metric: 'Patterns Before', value: String(compacted.before) },
-                            { metric: 'Patterns After', value: String(compacted.after) },
-                            { metric: 'Removed', value: String(compacted.removed) },
-                            { metric: 'Similarity Threshold', value: '95%' },
-                        ]
-                    });
-                    _b.label = 11;
-                case 11: return [2 /*return*/, { success: true }];
-                case 12:
-                    error_5 = _b.sent();
-                    spinner.fail('Optimization failed');
-                    output.printError(error_5 instanceof Error ? error_5.message : String(error_5));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 13: return [2 /*return*/];
+                    recommendations.forEach(r => output.writeln(r));
+                }
             }
-        });
-    }); }
+            else if (method === 'compact') {
+                spinner.setText('Compacting pattern storage...');
+                // Remove duplicate or very similar patterns
+                const compacted = await compactPatterns(0.95); // Remove patterns with >95% similarity
+                spinner.succeed(`Compacted ${compacted.removed} patterns`);
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'metric', header: 'Metric', width: 20 },
+                        { key: 'value', header: 'Value', width: 15 },
+                    ],
+                    data: [
+                        { metric: 'Patterns Before', value: String(compacted.before) },
+                        { metric: 'Patterns After', value: String(compacted.after) },
+                        { metric: 'Removed', value: String(compacted.removed) },
+                        { metric: 'Similarity Threshold', value: '95%' },
+                    ],
+                });
+            }
+            return { success: true };
+        }
+        catch (error) {
+            spinner.fail('Optimization failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Export subcommand - Securely export trained models to IPFS
-var exportCommand = {
+const exportCommand = {
     name: 'export',
     description: 'Export trained models to IPFS for sharing (Ed25519 signed)',
     options: [
         { name: 'model', short: 'm', type: 'string', description: 'Model ID or category to export' },
         { name: 'output', short: 'o', type: 'string', description: 'Output file path (optional)' },
         { name: 'ipfs', short: 'i', type: 'boolean', description: 'Pin to IPFS (requires Pinata credentials)' },
-        { name: 'sign', short: 's', type: 'boolean', description: 'Sign with Ed25519 key', "default": 'true' },
-        { name: 'strip-pii', type: 'boolean', description: 'Strip potential PII from export', "default": 'true' },
+        { name: 'sign', short: 's', type: 'boolean', description: 'Sign with Ed25519 key', default: 'true' },
+        { name: 'strip-pii', type: 'boolean', description: 'Strip potential PII from export', default: 'true' },
         { name: 'name', short: 'n', type: 'string', description: 'Custom name for exported model' },
     ],
     examples: [
         { command: 'claude-flow neural export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
         { command: 'claude-flow neural export -m code-review -o ./export.json', description: 'Export to file' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var modelId, outputFile, pinToIpfs, signExport, stripPii, customName, spinner, fs, path, crypto, _a, getIntelligenceStats, flushPatterns, stats, exportData, memoryDir, patternsFile, patterns, _i, patterns_2, pattern, signature, publicKey, webcrypto, keyPair, exportBytes, signatureBytes, publicKeyBytes, exportPackage, exportStr, secretPatterns, _b, secretPatterns_1, pattern, pinataKey, pinataSecret, response, error, result, error_6;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    modelId = ctx.flags.model || 'all';
-                    outputFile = ctx.flags.output;
-                    pinToIpfs = ctx.flags.ipfs;
-                    signExport = ctx.flags.sign !== false;
-                    stripPii = ctx.flags['strip-pii'] !== false;
-                    customName = ctx.flags.name;
-                    output.writeln();
-                    output.writeln(output.bold('Secure Model Export'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Preparing export...', spinner: 'dots' });
-                    spinner.start();
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 17, , 18]);
-                    return [4 /*yield*/, import('fs')];
-                case 2:
-                    fs = _c.sent();
-                    return [4 /*yield*/, import('path')];
-                case 3:
-                    path = _c.sent();
-                    return [4 /*yield*/, import('crypto')];
-                case 4:
-                    crypto = _c.sent();
-                    // Collect trained patterns from memory
-                    spinner.setText('Collecting trained patterns...');
-                    return [4 /*yield*/, import('../memory/intelligence.js')];
-                case 5:
-                    _a = _c.sent(), getIntelligenceStats = _a.getIntelligenceStats, flushPatterns = _a.flushPatterns;
-                    return [4 /*yield*/, flushPatterns()];
-                case 6:
-                    _c.sent(); // Ensure all patterns are persisted
-                    return [4 /*yield*/, getIntelligenceStats()];
-                case 7:
-                    stats = _c.sent();
-                    exportData = {
-                        type: 'learning-pattern',
-                        version: '1.0.0',
-                        name: customName || "claude-flow-model-" + Date.now(),
-                        exportedAt: new Date().toISOString(),
-                        modelId: modelId,
-                        patterns: [],
-                        metadata: {
-                            sourceVersion: '3.0.0-alpha',
-                            piiStripped: stripPii,
-                            signed: signExport,
-                            accuracy: 0,
-                            totalUsage: 0
-                        }
-                    };
-                    memoryDir = path.join(process.cwd(), '.claude-flow', 'memory');
-                    patternsFile = path.join(memoryDir, 'patterns.json');
-                    if (fs.existsSync(patternsFile)) {
-                        patterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
-                        for (_i = 0, patterns_2 = patterns; _i < patterns_2.length; _i++) {
-                            pattern = patterns_2[_i];
-                            // Security: Strip potential PII
-                            if (stripPii) {
-                                // Remove any paths, usernames, or sensitive data
-                                if (pattern.content) {
-                                    pattern.content = pattern.content
-                                        .replace(/\/Users\/[^\/]+/g, '/Users/[REDACTED]')
-                                        .replace(/\/home\/[^\/]+/g, '/home/[REDACTED]')
-                                        .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL_REDACTED]')
-                                        .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '[IP_REDACTED]');
-                                }
-                            }
-                            exportData.patterns.push({
-                                id: pattern.id || crypto.randomBytes(8).toString('hex'),
-                                trigger: pattern.trigger || pattern.type || 'general',
-                                action: pattern.action || pattern.recommendation || 'apply-pattern',
-                                confidence: pattern.confidence || 0.85,
-                                usageCount: pattern.usageCount || 1
-                            });
-                        }
-                    }
-                    // Add stats metadata
-                    exportData.metadata.accuracy = stats.retrievalPrecision || 0.85;
-                    exportData.metadata.totalUsage = exportData.patterns.reduce(function (sum, p) { return sum + p.usageCount; }, 0);
-                    spinner.setText('Generating secure signature...');
-                    signature = null;
-                    publicKey = null;
-                    if (!signExport) return [3 /*break*/, 11];
-                    webcrypto = crypto.webcrypto;
-                    return [4 /*yield*/, webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, ['sign', 'verify']
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        )];
-                case 8:
-                    keyPair = _c.sent();
-                    exportBytes = new TextEncoder().encode(JSON.stringify(exportData));
-                    return [4 /*yield*/, webcrypto.subtle.sign('Ed25519', keyPair.privateKey, exportBytes)];
-                case 9:
-                    signatureBytes = _c.sent();
-                    signature = Buffer.from(signatureBytes).toString('hex');
-                    return [4 /*yield*/, webcrypto.subtle.exportKey('raw', keyPair.publicKey)];
-                case 10:
-                    publicKeyBytes = _c.sent();
-                    publicKey = Buffer.from(publicKeyBytes).toString('hex');
-                    _c.label = 11;
-                case 11:
-                    exportPackage = {
-                        pinataContent: exportData,
-                        pinataMetadata: {
-                            name: exportData.name,
-                            keyvalues: {
-                                type: 'learning-pattern',
-                                version: '1.0.0',
-                                signed: signExport ? 'true' : 'false'
-                            }
-                        },
-                        signature: signature,
-                        publicKey: publicKey ? "ed25519:" + publicKey : null
-                    };
-                    exportStr = JSON.stringify(exportPackage);
-                    secretPatterns = [
-                        /sk-ant-[a-zA-Z0-9-]+/,
-                        /sk-[a-zA-Z0-9]{48}/,
-                        /AIza[a-zA-Z0-9-_]{35}/,
-                        /pinata_[a-zA-Z0-9]+/,
-                        /-----BEGIN.*KEY-----/, // PEM keys
-                    ];
-                    for (_b = 0, secretPatterns_1 = secretPatterns; _b < secretPatterns_1.length; _b++) {
-                        pattern = secretPatterns_1[_b];
-                        if (pattern.test(exportStr)) {
-                            spinner.fail('SECURITY: Export contains potential API keys - aborting');
-                            return [2 /*return*/, { success: false, exitCode: 1 }];
+    action: async (ctx) => {
+        const modelId = ctx.flags.model || 'all';
+        const outputFile = ctx.flags.output;
+        const pinToIpfs = ctx.flags.ipfs;
+        const signExport = ctx.flags.sign !== false;
+        const stripPii = ctx.flags['strip-pii'] !== false;
+        const customName = ctx.flags.name;
+        output.writeln();
+        output.writeln(output.bold('Secure Model Export'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Preparing export...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const crypto = await import('crypto');
+            // Collect trained patterns from memory
+            spinner.setText('Collecting trained patterns...');
+            const { getIntelligenceStats, flushPatterns } = await import('../memory/intelligence.js');
+            await flushPatterns(); // Ensure all patterns are persisted
+            const stats = await getIntelligenceStats();
+            // SECURITY: Build export data - NEVER include secrets
+            // - API keys read from env but NEVER included in export
+            // - Uses ephemeral signing keys (generated per-export, not stored)
+            // - PII stripping enabled by default
+            // - Suspicious pattern content blocked
+            const exportData = {
+                type: 'learning-pattern',
+                version: '1.0.0',
+                name: customName || `claude-flow-model-${Date.now()}`,
+                exportedAt: new Date().toISOString(),
+                modelId,
+                patterns: [],
+                metadata: {
+                    sourceVersion: '3.0.0-alpha',
+                    piiStripped: stripPii,
+                    signed: signExport,
+                    accuracy: 0,
+                    totalUsage: 0,
+                },
+            };
+            // Load patterns from local storage
+            const memoryDir = path.join(process.cwd(), '.claude-flow', 'memory');
+            const patternsFile = path.join(memoryDir, 'patterns.json');
+            if (fs.existsSync(patternsFile)) {
+                const patterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
+                for (const pattern of patterns) {
+                    // Security: Strip potential PII
+                    if (stripPii) {
+                        // Remove any paths, usernames, or sensitive data
+                        if (pattern.content) {
+                            pattern.content = pattern.content
+                                .replace(/\/Users\/[^\/]+/g, '/Users/[REDACTED]')
+                                .replace(/\/home\/[^\/]+/g, '/home/[REDACTED]')
+                                .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL_REDACTED]')
+                                .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '[IP_REDACTED]');
                         }
                     }
-                    // Output handling
-                    if (outputFile) {
-                        fs.writeFileSync(outputFile, JSON.stringify(exportPackage, null, 2));
-                        spinner.succeed("Exported to: " + outputFile);
-                    }
-                    if (!pinToIpfs) return [3 /*break*/, 16];
-                    spinner.setText('Pinning to IPFS...');
-                    pinataKey = process.env.PINATA_API_KEY;
-                    pinataSecret = process.env.PINATA_API_SECRET;
-                    if (!pinataKey || !pinataSecret) {
-                        spinner.fail('PINATA_API_KEY and PINATA_API_SECRET required for IPFS export');
-                        output.writeln(output.dim('Set these in your environment or .env file'));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    return [4 /*yield*/, fetch('https://api.pinata.cloud/pinning/pinJSONToIPFS', {
-                            method: 'POST',
-                            headers: {
-                                'Content-Type': 'application/json',
-                                'pinata_api_key': pinataKey,
-                                'pinata_secret_api_key': pinataSecret
-                            },
-                            body: JSON.stringify(exportPackage)
-                        })];
-                case 12:
-                    response = _c.sent();
-                    if (!!response.ok) return [3 /*break*/, 14];
-                    return [4 /*yield*/, response.text()];
-                case 13:
-                    error = _c.sent();
-                    spinner.fail("IPFS pin failed: " + error);
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 14: return [4 /*yield*/, response.json()];
-                case 15:
-                    result = _c.sent();
-                    spinner.succeed('Successfully exported to IPFS');
-                    output.writeln();
-                    output.table({
-                        columns: [
-                            { key: 'property', header: 'Property', width: 20 },
-                            { key: 'value', header: 'Value', width: 50 },
-                        ],
-                        data: [
-                            { property: 'CID', value: result.IpfsHash },
-                            { property: 'Size', value: result.PinSize + " bytes" },
-                            { property: 'Gateway URL', value: "https://gateway.pinata.cloud/ipfs/" + result.IpfsHash },
-                            { property: 'Patterns', value: String(exportData.patterns.length) },
-                            { property: 'Signed', value: signExport ? 'Yes (Ed25519)' : 'No' },
-                            { property: 'PII Stripped', value: stripPii ? 'Yes' : 'No' },
-                        ]
+                    exportData.patterns.push({
+                        id: pattern.id || crypto.randomBytes(8).toString('hex'),
+                        trigger: pattern.trigger || pattern.type || 'general',
+                        action: pattern.action || pattern.recommendation || 'apply-pattern',
+                        confidence: pattern.confidence || 0.85,
+                        usageCount: pattern.usageCount || 1,
                     });
-                    output.writeln();
-                    output.writeln(output.success('Share this CID for others to import your trained patterns'));
-                    output.writeln(output.dim("Import command: claude-flow neural import --cid " + result.IpfsHash));
-                    _c.label = 16;
-                case 16:
-                    if (!outputFile && !pinToIpfs) {
-                        // Just display the export
-                        spinner.succeed('Export prepared');
-                        output.writeln();
-                        output.writeln(JSON.stringify(exportPackage, null, 2));
-                    }
-                    return [2 /*return*/, { success: true }];
-                case 17:
-                    error_6 = _c.sent();
-                    spinner.fail("Export failed: " + (error_6 instanceof Error ? error_6.message : String(error_6)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 18: return [2 /*return*/];
+                }
+            }
+            // Add stats metadata
+            exportData.metadata.accuracy = stats.retrievalPrecision || 0.85;
+            exportData.metadata.totalUsage = exportData.patterns.reduce((sum, p) => sum + p.usageCount, 0);
+            spinner.setText('Generating secure signature...');
+            // Sign with Ed25519 if requested
+            let signature = null;
+            let publicKey = null;
+            if (signExport) {
+                // Generate ephemeral key pair for signing
+                // Use Node.js webcrypto for Ed25519 signing
+                const { webcrypto } = crypto;
+                const keyPair = await webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, ['sign', 'verify']
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                );
+                const exportBytes = new TextEncoder().encode(JSON.stringify(exportData));
+                const signatureBytes = await webcrypto.subtle.sign('Ed25519', keyPair.privateKey, exportBytes);
+                signature = Buffer.from(signatureBytes).toString('hex');
+                const publicKeyBytes = await webcrypto.subtle.exportKey('raw', keyPair.publicKey);
+                publicKey = Buffer.from(publicKeyBytes).toString('hex');
+            }
+            // SECURITY: Final export package - verify no secrets leaked
+            const exportPackage = {
+                pinataContent: exportData,
+                pinataMetadata: {
+                    name: exportData.name,
+                    keyvalues: {
+                        type: 'learning-pattern',
+                        version: '1.0.0',
+                        signed: signExport ? 'true' : 'false',
+                    },
+                },
+                signature,
+                publicKey: publicKey ? `ed25519:${publicKey}` : null,
+                // Note: Private key is ephemeral and NEVER stored or exported
+            };
+            // SECURITY AUDIT: Ensure no secrets in export
+            const exportStr = JSON.stringify(exportPackage);
+            const secretPatterns = [
+                /sk-ant-[a-zA-Z0-9-]+/, // Anthropic keys
+                /sk-[a-zA-Z0-9]{48}/, // OpenAI keys
+                /AIza[a-zA-Z0-9-_]{35}/, // Google keys
+                /pinata_[a-zA-Z0-9]+/, // Pinata JWT
+                /-----BEGIN.*KEY-----/, // PEM keys
+            ];
+            for (const pattern of secretPatterns) {
+                if (pattern.test(exportStr)) {
+                    spinner.fail('SECURITY: Export contains potential API keys - aborting');
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            // Output handling
+            if (outputFile) {
+                fs.writeFileSync(outputFile, JSON.stringify(exportPackage, null, 2));
+                spinner.succeed(`Exported to: ${outputFile}`);
+            }
+            if (pinToIpfs) {
+                spinner.setText('Pinning to IPFS...');
+                // Check for Pinata credentials
+                const pinataKey = process.env.PINATA_API_KEY;
+                const pinataSecret = process.env.PINATA_API_SECRET;
+                if (!pinataKey || !pinataSecret) {
+                    spinner.fail('PINATA_API_KEY and PINATA_API_SECRET required for IPFS export');
+                    output.writeln(output.dim('Set these in your environment or .env file'));
+                    return { success: false, exitCode: 1 };
+                }
+                const response = await fetch('https://api.pinata.cloud/pinning/pinJSONToIPFS', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'pinata_api_key': pinataKey,
+                        'pinata_secret_api_key': pinataSecret,
+                    },
+                    body: JSON.stringify(exportPackage),
+                });
+                if (!response.ok) {
+                    const error = await response.text();
+                    spinner.fail(`IPFS pin failed: ${error}`);
+                    return { success: false, exitCode: 1 };
+                }
+                const result = await response.json();
+                spinner.succeed('Successfully exported to IPFS');
+                output.writeln();
+                output.table({
+                    columns: [
+                        { key: 'property', header: 'Property', width: 20 },
+                        { key: 'value', header: 'Value', width: 50 },
+                    ],
+                    data: [
+                        { property: 'CID', value: result.IpfsHash },
+                        { property: 'Size', value: `${result.PinSize} bytes` },
+                        { property: 'Gateway URL', value: `https://gateway.pinata.cloud/ipfs/${result.IpfsHash}` },
+                        { property: 'Patterns', value: String(exportData.patterns.length) },
+                        { property: 'Signed', value: signExport ? 'Yes (Ed25519)' : 'No' },
+                        { property: 'PII Stripped', value: stripPii ? 'Yes' : 'No' },
+                    ],
+                });
+                output.writeln();
+                output.writeln(output.success('Share this CID for others to import your trained patterns'));
+                output.writeln(output.dim(`Import command: claude-flow neural import --cid ${result.IpfsHash}`));
+            }
+            if (!outputFile && !pinToIpfs) {
+                // Just display the export
+                spinner.succeed('Export prepared');
+                output.writeln();
+                output.writeln(JSON.stringify(exportPackage, null, 2));
             }
-        });
-    }); }
+            return { success: true };
+        }
+        catch (error) {
+            spinner.fail(`Export failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // List subcommand - List available pre-trained models
-var listCommand = {
+const listCommand = {
     name: 'list',
     description: 'List available pre-trained models from the official registry',
     options: [
         { name: 'category', type: 'string', description: 'Filter by category (security, quality, performance, etc.)' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json, simple', "default": 'table' },
+        { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json, simple', default: 'table' },
         { name: 'cid', type: 'string', description: 'Custom registry CID (default: official registry)' },
     ],
     examples: [
@@ -1200,137 +1008,116 @@ var listCommand = {
         { command: 'claude-flow neural list --category security', description: 'List only security models' },
         { command: 'claude-flow neural list -f json', description: 'Output as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var category, format, customCid, registryCid, spinner, gateways, registry, _i, gateways_1, gateway, response, _a, registryData, models, _b, models_1, model, error_7;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    category = ctx.flags.category;
-                    format = ctx.flags.format || 'table';
-                    customCid = ctx.flags.cid;
-                    registryCid = customCid || 'QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc';
-                    output.writeln();
-                    output.writeln(output.bold('Pre-trained Model Registry'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    spinner = output.createSpinner({ text: 'Fetching model registry...', spinner: 'dots' });
-                    spinner.start();
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 10, , 11]);
-                    gateways = [
-                        'https://gateway.pinata.cloud',
-                        'https://ipfs.io',
-                        'https://dweb.link',
-                    ];
-                    registry = null;
-                    _i = 0, gateways_1 = gateways;
-                    _c.label = 2;
-                case 2:
-                    if (!(_i < gateways_1.length)) return [3 /*break*/, 9];
-                    gateway = gateways_1[_i];
-                    _c.label = 3;
-                case 3:
-                    _c.trys.push([3, 7, , 8]);
-                    return [4 /*yield*/, fetch(gateway + "/ipfs/" + registryCid, {
-                            signal: AbortSignal.timeout(15000),
-                            headers: { 'Accept': 'application/json' }
-                        })];
-                case 4:
-                    response = _c.sent();
-                    if (!response.ok) return [3 /*break*/, 6];
-                    return [4 /*yield*/, response.json()];
-                case 5:
-                    registry = (_c.sent());
-                    return [3 /*break*/, 9];
-                case 6: return [3 /*break*/, 8];
-                case 7:
-                    _a = _c.sent();
-                    return [3 /*break*/, 8];
-                case 8:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 9:
-                    if (!registry || !registry.models) {
-                        spinner.fail('Could not fetch model registry');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    registryData = registry;
-                    models = registryData.models;
-                    if (category) {
-                        models = models.filter(function (m) {
-                            return m.category === category ||
-                                m.id.includes(category) ||
-                                m.name.toLowerCase().includes(category.toLowerCase());
-                        });
-                        spinner.succeed("Found " + models.length + " models matching \"" + category + "\"");
-                    }
-                    else {
-                        spinner.succeed("Found " + registryData.models.length + " models");
-                    }
-                    if (models.length === 0) {
-                        output.writeln(output.warning("No models found for category: " + category));
-                        output.writeln(output.dim('Available categories: security, quality, performance, testing, api, debugging, refactoring, documentation'));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    if (format === 'json') {
-                        output.writeln(JSON.stringify(models, null, 2));
-                    }
-                    else if (format === 'simple') {
-                        for (_b = 0, models_1 = models; _b < models_1.length; _b++) {
-                            model = models_1[_b];
-                            output.writeln(model.id + " (" + model.category + ") - " + model.patterns.length + " patterns, " + (model.metadata.accuracy * 100).toFixed(0) + "% accuracy");
-                        }
-                    }
-                    else {
-                        // Table format
-                        output.printTable({
-                            columns: [
-                                { key: 'id', header: 'Model ID', width: 35 },
-                                { key: 'category', header: 'Category', width: 14 },
-                                { key: 'patterns', header: 'Patterns', width: 10 },
-                                { key: 'accuracy', header: 'Accuracy', width: 10 },
-                                { key: 'usage', header: 'Usage', width: 10 },
-                            ],
-                            data: models.map(function (m) { return ({
-                                id: m.id,
-                                category: m.category,
-                                patterns: String(m.patterns.length),
-                                accuracy: (m.metadata.accuracy * 100).toFixed(0) + "%",
-                                usage: m.metadata.totalUsage.toLocaleString()
-                            }); })
-                        });
-                        output.writeln();
-                        output.writeln(output.dim('Registry CID: ' + registryCid));
-                        output.writeln();
-                        output.writeln(output.bold('Import Commands:'));
-                        output.writeln(output.dim('  All models:      ') + ("claude-flow neural import --cid " + registryCid));
-                        if (category) {
-                            output.writeln(output.dim("  " + category + " only: ") + ("claude-flow neural import --cid " + registryCid + " --category " + category));
-                        }
-                        else {
-                            output.writeln(output.dim('  By category:     ') + ("claude-flow neural import --cid " + registryCid + " --category <category>"));
-                        }
+    action: async (ctx) => {
+        const category = ctx.flags.category;
+        const format = ctx.flags.format || 'table';
+        const customCid = ctx.flags.cid;
+        // Official model registry CID
+        const registryCid = customCid || 'QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc';
+        output.writeln();
+        output.writeln(output.bold('Pre-trained Model Registry'));
+        output.writeln(output.dim('─'.repeat(60)));
+        const spinner = output.createSpinner({ text: 'Fetching model registry...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const gateways = [
+                'https://gateway.pinata.cloud',
+                'https://ipfs.io',
+                'https://dweb.link',
+            ];
+            let registry = null;
+            for (const gateway of gateways) {
+                try {
+                    const response = await fetch(`${gateway}/ipfs/${registryCid}`, {
+                        signal: AbortSignal.timeout(15000),
+                        headers: { 'Accept': 'application/json' },
+                    });
+                    if (response.ok) {
+                        registry = await response.json();
+                        break;
                     }
-                    return [2 /*return*/, { success: true }];
-                case 10:
-                    error_7 = _c.sent();
-                    spinner.fail("Failed to list models: " + (error_7 instanceof Error ? error_7.message : String(error_7)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 11: return [2 /*return*/];
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!registry || !registry.models) {
+                spinner.fail('Could not fetch model registry');
+                return { success: false, exitCode: 1 };
+            }
+            const registryData = registry;
+            // Filter by category if specified
+            let models = registryData.models;
+            if (category) {
+                models = models.filter(m => m.category === category ||
+                    m.id.includes(category) ||
+                    m.name.toLowerCase().includes(category.toLowerCase()));
+                spinner.succeed(`Found ${models.length} models matching "${category}"`);
             }
-        });
-    }); }
+            else {
+                spinner.succeed(`Found ${registryData.models.length} models`);
+            }
+            if (models.length === 0) {
+                output.writeln(output.warning(`No models found for category: ${category}`));
+                output.writeln(output.dim('Available categories: security, quality, performance, testing, api, debugging, refactoring, documentation'));
+                return { success: false, exitCode: 1 };
+            }
+            output.writeln();
+            if (format === 'json') {
+                output.writeln(JSON.stringify(models, null, 2));
+            }
+            else if (format === 'simple') {
+                for (const model of models) {
+                    output.writeln(`${model.id} (${model.category}) - ${model.patterns.length} patterns, ${(model.metadata.accuracy * 100).toFixed(0)}% accuracy`);
+                }
+            }
+            else {
+                // Table format
+                output.printTable({
+                    columns: [
+                        { key: 'id', header: 'Model ID', width: 35 },
+                        { key: 'category', header: 'Category', width: 14 },
+                        { key: 'patterns', header: 'Patterns', width: 10 },
+                        { key: 'accuracy', header: 'Accuracy', width: 10 },
+                        { key: 'usage', header: 'Usage', width: 10 },
+                    ],
+                    data: models.map(m => ({
+                        id: m.id,
+                        category: m.category,
+                        patterns: String(m.patterns.length),
+                        accuracy: `${(m.metadata.accuracy * 100).toFixed(0)}%`,
+                        usage: m.metadata.totalUsage.toLocaleString(),
+                    })),
+                });
+                output.writeln();
+                output.writeln(output.dim('Registry CID: ' + registryCid));
+                output.writeln();
+                output.writeln(output.bold('Import Commands:'));
+                output.writeln(output.dim('  All models:      ') + `claude-flow neural import --cid ${registryCid}`);
+                if (category) {
+                    output.writeln(output.dim(`  ${category} only: `) + `claude-flow neural import --cid ${registryCid} --category ${category}`);
+                }
+                else {
+                    output.writeln(output.dim('  By category:     ') + `claude-flow neural import --cid ${registryCid} --category <category>`);
+                }
+            }
+            return { success: true };
+        }
+        catch (error) {
+            spinner.fail(`Failed to list models: ${error instanceof Error ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Import subcommand - Securely import models from IPFS
-var importCommand = {
+const importCommand = {
     name: 'import',
     description: 'Import trained models from IPFS with signature verification',
     options: [
         { name: 'cid', short: 'c', type: 'string', description: 'IPFS CID to import from' },
         { name: 'file', short: 'f', type: 'string', description: 'Local file to import' },
-        { name: 'verify', short: 'v', type: 'boolean', description: 'Verify Ed25519 signature', "default": 'true' },
-        { name: 'merge', type: 'boolean', description: 'Merge with existing patterns (vs replace)', "default": 'true' },
+        { name: 'verify', short: 'v', type: 'boolean', description: 'Verify Ed25519 signature', default: 'true' },
+        { name: 'merge', type: 'boolean', description: 'Merge with existing patterns (vs replace)', default: 'true' },
         { name: 'category', type: 'string', description: 'Only import patterns from specific category' },
     ],
     examples: [
@@ -1338,371 +1125,312 @@ var importCommand = {
         { command: 'claude-flow neural import -f ./patterns.json --verify', description: 'Import from file' },
         { command: 'claude-flow neural import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var cid, file, verifySignature, merge, categoryFilter, spinner, fs, path, crypto, importData, gateways, _i, gateways_2, gateway, response, _a, webcrypto, publicKeyHex, publicKeyBytes, signatureBytes, publicKey, dataBytes, valid, err_1, content, patterns, registry, _b, _c, model, _d, _e, pattern, validPatterns, memoryDir, patternsFile, existingPatterns, existingIds_1, newPatterns, finalPatterns, error_8;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    cid = ctx.flags.cid;
-                    file = ctx.flags.file;
-                    verifySignature = ctx.flags.verify !== false;
-                    merge = ctx.flags.merge !== false;
-                    categoryFilter = ctx.flags.category;
-                    if (!cid && !file) {
-                        output.writeln(output.error('Either --cid or --file is required'));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Secure Model Import'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Fetching model...', spinner: 'dots' });
-                    spinner.start();
-                    _f.label = 1;
-                case 1:
-                    _f.trys.push([1, 20, , 21]);
-                    return [4 /*yield*/, import('fs')];
-                case 2:
-                    fs = _f.sent();
-                    return [4 /*yield*/, import('path')];
-                case 3:
-                    path = _f.sent();
-                    return [4 /*yield*/, import('crypto')];
-                case 4:
-                    crypto = _f.sent();
-                    importData = null;
-                    if (!cid) return [3 /*break*/, 13];
-                    gateways = [
-                        'https://gateway.pinata.cloud',
-                        'https://ipfs.io',
-                        'https://dweb.link',
-                    ];
-                    _i = 0, gateways_2 = gateways;
-                    _f.label = 5;
-                case 5:
-                    if (!(_i < gateways_2.length)) return [3 /*break*/, 12];
-                    gateway = gateways_2[_i];
-                    _f.label = 6;
-                case 6:
-                    _f.trys.push([6, 10, , 11]);
-                    spinner.setText("Fetching from " + gateway + "...");
-                    return [4 /*yield*/, fetch(gateway + "/ipfs/" + cid, {
+    action: async (ctx) => {
+        const cid = ctx.flags.cid;
+        const file = ctx.flags.file;
+        const verifySignature = ctx.flags.verify !== false;
+        const merge = ctx.flags.merge !== false;
+        const categoryFilter = ctx.flags.category;
+        if (!cid && !file) {
+            output.writeln(output.error('Either --cid or --file is required'));
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Secure Model Import'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Fetching model...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const crypto = await import('crypto');
+            let importData = null;
+            // Fetch from IPFS or file
+            if (cid) {
+                const gateways = [
+                    'https://gateway.pinata.cloud',
+                    'https://ipfs.io',
+                    'https://dweb.link',
+                ];
+                for (const gateway of gateways) {
+                    try {
+                        spinner.setText(`Fetching from ${gateway}...`);
+                        const response = await fetch(`${gateway}/ipfs/${cid}`, {
                             signal: AbortSignal.timeout(30000),
-                            headers: { 'Accept': 'application/json' }
-                        })];
-                case 7:
-                    response = _f.sent();
-                    if (!response.ok) return [3 /*break*/, 9];
-                    return [4 /*yield*/, response.json()];
-                case 8:
-                    importData = (_f.sent());
-                    return [3 /*break*/, 12];
-                case 9: return [3 /*break*/, 11];
-                case 10:
-                    _a = _f.sent();
-                    return [3 /*break*/, 11];
-                case 11:
-                    _i++;
-                    return [3 /*break*/, 5];
-                case 12:
-                    if (!importData) {
-                        spinner.fail('Could not fetch from any IPFS gateway');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    return [3 /*break*/, 14];
-                case 13:
-                    if (!fs.existsSync(file)) {
-                        spinner.fail("File not found: " + file);
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                            headers: { 'Accept': 'application/json' },
+                        });
+                        if (response.ok) {
+                            importData = await response.json();
+                            break;
+                        }
                     }
-                    importData = JSON.parse(fs.readFileSync(file, 'utf8'));
-                    _f.label = 14;
-                case 14:
-                    if (!importData) {
-                        spinner.fail('No import data available');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    catch {
+                        continue;
                     }
-                    if (!(verifySignature && importData.signature && importData.publicKey)) return [3 /*break*/, 19];
-                    spinner.setText('Verifying Ed25519 signature...');
-                    _f.label = 15;
-                case 15:
-                    _f.trys.push([15, 18, , 19]);
-                    webcrypto = crypto.webcrypto;
-                    publicKeyHex = importData.publicKey.replace('ed25519:', '');
-                    publicKeyBytes = Buffer.from(publicKeyHex, 'hex');
-                    signatureBytes = Buffer.from(importData.signature, 'hex');
-                    return [4 /*yield*/, webcrypto.subtle.importKey('raw', publicKeyBytes, { name: 'Ed25519' }, false, ['verify'])];
-                case 16:
-                    publicKey = _f.sent();
-                    dataBytes = new TextEncoder().encode(JSON.stringify(importData.pinataContent));
-                    return [4 /*yield*/, webcrypto.subtle.verify('Ed25519', publicKey, signatureBytes, dataBytes)];
-                case 17:
-                    valid = _f.sent();
+                }
+                if (!importData) {
+                    spinner.fail('Could not fetch from any IPFS gateway');
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            else {
+                if (!fs.existsSync(file)) {
+                    spinner.fail(`File not found: ${file}`);
+                    return { success: false, exitCode: 1 };
+                }
+                importData = JSON.parse(fs.readFileSync(file, 'utf8'));
+            }
+            if (!importData) {
+                spinner.fail('No import data available');
+                return { success: false, exitCode: 1 };
+            }
+            // Verify signature if present and requested
+            if (verifySignature && importData.signature && importData.publicKey) {
+                spinner.setText('Verifying Ed25519 signature...');
+                try {
+                    const { webcrypto } = crypto;
+                    const publicKeyHex = importData.publicKey.replace('ed25519:', '');
+                    const publicKeyBytes = Buffer.from(publicKeyHex, 'hex');
+                    const signatureBytes = Buffer.from(importData.signature, 'hex');
+                    const publicKey = await webcrypto.subtle.importKey('raw', publicKeyBytes, { name: 'Ed25519' }, false, ['verify']);
+                    const dataBytes = new TextEncoder().encode(JSON.stringify(importData.pinataContent));
+                    const valid = await webcrypto.subtle.verify('Ed25519', publicKey, signatureBytes, dataBytes);
                     if (!valid) {
                         spinner.fail('Signature verification FAILED - data may be tampered');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                        return { success: false, exitCode: 1 };
                     }
                     output.writeln(output.success('Signature verified'));
-                    return [3 /*break*/, 19];
-                case 18:
-                    err_1 = _f.sent();
-                    output.writeln(output.warning("Signature verification skipped: " + (err_1 instanceof Error ? err_1.message : String(err_1))));
-                    return [3 /*break*/, 19];
-                case 19:
-                    // Extract patterns - handle both single model and model registry formats
-                    spinner.setText('Importing patterns...');
-                    content = importData.pinataContent || importData;
-                    patterns = [];
-                    registry = content;
-                    if (registry.models && Array.isArray(registry.models)) {
-                        // Model registry format - extract patterns from each model
-                        for (_b = 0, _c = registry.models; _b < _c.length; _b++) {
-                            model = _c[_b];
-                            if (!categoryFilter || model.category === categoryFilter || model.id.includes(categoryFilter)) {
-                                for (_d = 0, _e = model.patterns || []; _d < _e.length; _d++) {
-                                    pattern = _e[_d];
-                                    patterns.push(__assign(__assign({}, pattern), { category: model.category }));
-                                }
-                            }
+                }
+                catch (err) {
+                    output.writeln(output.warning(`Signature verification skipped: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            }
+            // Extract patterns - handle both single model and model registry formats
+            spinner.setText('Importing patterns...');
+            const content = importData.pinataContent || importData;
+            let patterns = [];
+            // Check if this is a model registry (has models array)
+            const registry = content;
+            if (registry.models && Array.isArray(registry.models)) {
+                // Model registry format - extract patterns from each model
+                for (const model of registry.models) {
+                    if (!categoryFilter || model.category === categoryFilter || model.id.includes(categoryFilter)) {
+                        for (const pattern of model.patterns || []) {
+                            patterns.push({
+                                ...pattern,
+                                category: model.category, // Tag with model category
+                            });
                         }
                     }
-                    else {
-                        // Single model format - patterns at top level
-                        patterns = content.patterns || [];
-                    }
-                    // Filter by category if specified (additional filtering)
-                    if (categoryFilter && patterns.length > 0) {
-                        patterns = patterns.filter(function (p) {
-                            return p.category === categoryFilter ||
-                                p.trigger.includes(categoryFilter);
-                        });
-                    }
-                    validPatterns = patterns.filter(function (p) {
-                        // Security: Reject patterns with suspicious content
-                        var suspicious = [
-                            'eval(', 'Function(', 'exec(', 'spawn(',
-                            'child_process', 'rm -rf', 'sudo',
-                            '<script>', 'javascript:', 'data:',
-                        ];
-                        var content = JSON.stringify(p);
-                        return !suspicious.some(function (s) { return content.includes(s); });
-                    });
-                    if (validPatterns.length < patterns.length) {
-                        output.writeln(output.warning("Filtered " + (patterns.length - validPatterns.length) + " suspicious patterns"));
-                    }
-                    memoryDir = path.join(process.cwd(), '.claude-flow', 'memory');
-                    if (!fs.existsSync(memoryDir)) {
-                        fs.mkdirSync(memoryDir, { recursive: true });
-                    }
-                    patternsFile = path.join(memoryDir, 'patterns.json');
-                    existingPatterns = [];
-                    if (merge && fs.existsSync(patternsFile)) {
-                        existingPatterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
-                    }
-                    existingIds_1 = new Set(existingPatterns.map(function (p) { return p.id; }));
-                    newPatterns = validPatterns.filter(function (p) { return !existingIds_1.has(p.id); });
-                    finalPatterns = merge ? __spreadArray(__spreadArray([], existingPatterns, true), newPatterns, true) : validPatterns;
-                    fs.writeFileSync(patternsFile, JSON.stringify(finalPatterns, null, 2));
-                    spinner.succeed('Import complete');
-                    output.writeln();
-                    output.table({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 25 },
-                            { key: 'value', header: 'Value', width: 20 },
-                        ],
-                        data: [
-                            { metric: 'Patterns Imported', value: String(validPatterns.length) },
-                            { metric: 'New Patterns', value: String(newPatterns.length) },
-                            { metric: 'Total Patterns', value: String(finalPatterns.length) },
-                            { metric: 'Signature Verified', value: importData.signature ? 'Yes' : 'N/A' },
-                            { metric: 'Merge Mode', value: merge ? 'Yes' : 'Replace' },
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.success('Patterns imported and ready to use'));
-                    output.writeln(output.dim('Run "claude-flow neural patterns --action list" to see imported patterns'));
-                    return [2 /*return*/, { success: true }];
-                case 20:
-                    error_8 = _f.sent();
-                    spinner.fail("Import failed: " + (error_8 instanceof Error ? error_8.message : String(error_8)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 21: return [2 /*return*/];
+                }
+            }
+            else {
+                // Single model format - patterns at top level
+                patterns = content.patterns || [];
+            }
+            // Filter by category if specified (additional filtering)
+            if (categoryFilter && patterns.length > 0) {
+                patterns = patterns.filter(p => p.category === categoryFilter ||
+                    p.trigger.includes(categoryFilter));
+            }
+            // Validate patterns (security check)
+            const validPatterns = patterns.filter(p => {
+                // Security: Reject patterns with suspicious content
+                const suspicious = [
+                    'eval(', 'Function(', 'exec(', 'spawn(',
+                    'child_process', 'rm -rf', 'sudo',
+                    '<script>', 'javascript:', 'data:',
+                ];
+                const content = JSON.stringify(p);
+                return !suspicious.some(s => content.includes(s));
+            });
+            if (validPatterns.length < patterns.length) {
+                output.writeln(output.warning(`Filtered ${patterns.length - validPatterns.length} suspicious patterns`));
+            }
+            // Save to local memory
+            const memoryDir = path.join(process.cwd(), '.claude-flow', 'memory');
+            if (!fs.existsSync(memoryDir)) {
+                fs.mkdirSync(memoryDir, { recursive: true });
+            }
+            const patternsFile = path.join(memoryDir, 'patterns.json');
+            let existingPatterns = [];
+            if (merge && fs.existsSync(patternsFile)) {
+                existingPatterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
             }
-        });
-    }); }
+            // Merge or replace
+            const existingIds = new Set(existingPatterns.map(p => p.id));
+            const newPatterns = validPatterns.filter(p => !existingIds.has(p.id));
+            const finalPatterns = merge ? [...existingPatterns, ...newPatterns] : validPatterns;
+            fs.writeFileSync(patternsFile, JSON.stringify(finalPatterns, null, 2));
+            spinner.succeed('Import complete');
+            output.writeln();
+            output.table({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 25 },
+                    { key: 'value', header: 'Value', width: 20 },
+                ],
+                data: [
+                    { metric: 'Patterns Imported', value: String(validPatterns.length) },
+                    { metric: 'New Patterns', value: String(newPatterns.length) },
+                    { metric: 'Total Patterns', value: String(finalPatterns.length) },
+                    { metric: 'Signature Verified', value: importData.signature ? 'Yes' : 'N/A' },
+                    { metric: 'Merge Mode', value: merge ? 'Yes' : 'Replace' },
+                ],
+            });
+            output.writeln();
+            output.writeln(output.success('Patterns imported and ready to use'));
+            output.writeln(output.dim('Run "claude-flow neural patterns --action list" to see imported patterns'));
+            return { success: true };
+        }
+        catch (error) {
+            spinner.fail(`Import failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Benchmark subcommand - Real WASM benchmarks
-var benchmarkCommand = {
+const benchmarkCommand = {
     name: 'benchmark',
     description: 'Benchmark RuVector WASM training performance',
     options: [
-        { name: 'dim', short: 'd', type: 'number', description: 'Embedding dimension (max 256)', "default": '256' },
-        { name: 'iterations', short: 'i', type: 'number', description: 'Number of iterations', "default": '1000' },
-        { name: 'keys', short: 'k', type: 'number', description: 'Number of keys for attention', "default": '100' },
+        { name: 'dim', short: 'd', type: 'number', description: 'Embedding dimension (max 256)', default: '256' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Number of iterations', default: '1000' },
+        { name: 'keys', short: 'k', type: 'number', description: 'Number of keys for attention', default: '100' },
     ],
     examples: [
         { command: 'claude-flow neural benchmark', description: 'Run default benchmark' },
         { command: 'claude-flow neural benchmark -d 128 -i 5000', description: 'Custom benchmark' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var dim, iterations, numKeys, spinner, attention, benchmarkMechanism, results, dotProduct, _a, _b, flash, _c, _d, multiHead, _e, _f, hyperbolic, _g, _h, linear, _j, _k, dotProductResult, flashResult, hyperbolicResult, speedup, fs, createRequire, require, wasmPath, wasmBuffer, learningWasm, lora, gradient, i, loraStart, i, loraTime, loraAvg, error_9;
-        return __generator(this, function (_l) {
-            switch (_l.label) {
-                case 0:
-                    dim = Math.min(parseInt(ctx.flags.dim || '256', 10), 256);
-                    iterations = parseInt(ctx.flags.iterations || '1000', 10);
-                    numKeys = parseInt(ctx.flags.keys || '100', 10);
-                    output.writeln();
-                    output.writeln(output.bold('RuVector WASM Benchmark'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Running benchmarks...', spinner: 'dots' });
-                    spinner.start();
-                    _l.label = 1;
-                case 1:
-                    _l.trys.push([1, 11, , 12]);
-                    return [4 /*yield*/, import('@ruvector/attention')];
-                case 2:
-                    attention = _l.sent();
-                    benchmarkMechanism = function (name, mechanism) { return __awaiter(void 0, void 0, void 0, function () {
-                        var query, keys, values, i, k, key, val, i, i, start, i, elapsed;
-                        return __generator(this, function (_a) {
-                            query = new Float32Array(dim);
-                            keys = [];
-                            values = [];
-                            for (i = 0; i < dim; i++)
-                                query[i] = Math.random();
-                            for (k = 0; k < numKeys; k++) {
-                                key = new Float32Array(dim);
-                                val = new Float32Array(dim);
-                                for (i = 0; i < dim; i++) {
-                                    key[i] = Math.random();
-                                    val[i] = Math.random();
-                                }
-                                keys.push(key);
-                                values.push(val);
-                            }
-                            // Warmup
-                            for (i = 0; i < 10; i++)
-                                mechanism.computeRaw(query, keys, values);
-                            start = performance.now();
-                            for (i = 0; i < iterations; i++) {
-                                mechanism.computeRaw(query, keys, values);
-                            }
-                            elapsed = performance.now() - start;
-                            return [2 /*return*/, {
-                                    name: name,
-                                    averageTimeMs: elapsed / iterations,
-                                    opsPerSecond: Math.round((iterations / elapsed) * 1000)
-                                }];
-                        });
-                    }); };
-                    spinner.setText("Benchmarking attention mechanisms (dim=" + dim + ", keys=" + numKeys + ", iter=" + iterations + ")...");
-                    results = [];
-                    dotProduct = new attention.DotProductAttention(dim);
-                    _b = (_a = results).push;
-                    return [4 /*yield*/, benchmarkMechanism('DotProduct', dotProduct)];
-                case 3:
-                    _b.apply(_a, [_l.sent()]);
-                    flash = new attention.FlashAttention(dim, 64);
-                    _d = (_c = results).push;
-                    return [4 /*yield*/, benchmarkMechanism('FlashAttention', flash)];
-                case 4:
-                    _d.apply(_c, [_l.sent()]);
-                    multiHead = new attention.MultiHeadAttention(dim, 4);
-                    _f = (_e = results).push;
-                    return [4 /*yield*/, benchmarkMechanism('MultiHead (4 heads)', multiHead)];
-                case 5:
-                    _f.apply(_e, [_l.sent()]);
-                    hyperbolic = new attention.HyperbolicAttention(dim, 1.0);
-                    _h = (_g = results).push;
-                    return [4 /*yield*/, benchmarkMechanism('Hyperbolic', hyperbolic)];
-                case 6:
-                    _h.apply(_g, [_l.sent()]);
-                    linear = new attention.LinearAttention(dim, dim);
-                    _k = (_j = results).push;
-                    return [4 /*yield*/, benchmarkMechanism('Linear', linear)];
-                case 7:
-                    _k.apply(_j, [_l.sent()]);
-                    spinner.succeed('Benchmark complete');
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'name', header: 'Mechanism', width: 25 },
-                            { key: 'avgTime', header: 'Avg Time (ms)', width: 15 },
-                            { key: 'opsPerSec', header: 'Ops/sec', width: 15 },
-                        ],
-                        data: results.map(function (r) { return ({
-                            name: r.name,
-                            avgTime: r.averageTimeMs.toFixed(4),
-                            opsPerSec: r.opsPerSecond.toLocaleString()
-                        }); })
-                    });
-                    dotProductResult = results.find(function (r) { return r.name.includes('DotProduct'); });
-                    flashResult = results.find(function (r) { return r.name.includes('Flash'); });
-                    hyperbolicResult = results.find(function (r) { return r.name.includes('Hyperbolic'); });
-                    if (dotProductResult && flashResult) {
-                        speedup = dotProductResult.averageTimeMs / flashResult.averageTimeMs;
-                        output.writeln();
-                        output.writeln(output.highlight("Flash Attention speedup: " + speedup.toFixed(2) + "x faster than DotProduct"));
+    action: async (ctx) => {
+        const dim = Math.min(parseInt(ctx.flags.dim || '256', 10), 256);
+        const iterations = parseInt(ctx.flags.iterations || '1000', 10);
+        const numKeys = parseInt(ctx.flags.keys || '100', 10);
+        output.writeln();
+        output.writeln(output.bold('RuVector WASM Benchmark'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Running benchmarks...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const attention = await import('@ruvector/attention');
+            // Manual benchmark since benchmarkAttention has a binding bug
+            const benchmarkMechanism = async (name, mechanism) => {
+                const query = new Float32Array(dim);
+                const keys = [];
+                const values = [];
+                for (let i = 0; i < dim; i++)
+                    query[i] = Math.random();
+                for (let k = 0; k < numKeys; k++) {
+                    const key = new Float32Array(dim);
+                    const val = new Float32Array(dim);
+                    for (let i = 0; i < dim; i++) {
+                        key[i] = Math.random();
+                        val[i] = Math.random();
                     }
-                    if (dotProductResult && hyperbolicResult) {
-                        output.writeln(output.dim("Hyperbolic overhead: " + (hyperbolicResult.averageTimeMs / dotProductResult.averageTimeMs).toFixed(2) + "x (expected for manifold ops)"));
-                    }
-                    // Also benchmark MicroLoRA
-                    spinner.start();
-                    spinner.setText('Benchmarking MicroLoRA adaptation...');
-                    return [4 /*yield*/, import('fs')];
-                case 8:
-                    fs = _l.sent();
-                    return [4 /*yield*/, import('module')];
-                case 9:
-                    createRequire = (_l.sent()).createRequire;
-                    require = createRequire(import.meta.url);
-                    wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
-                    wasmBuffer = fs.readFileSync(wasmPath);
-                    return [4 /*yield*/, import('@ruvector/learning-wasm')];
-                case 10:
-                    learningWasm = _l.sent();
-                    learningWasm.initSync({ module: wasmBuffer });
-                    lora = new learningWasm.WasmMicroLoRA(dim, 0.1, 0.01);
-                    gradient = new Float32Array(dim);
-                    for (i = 0; i < dim; i++)
-                        gradient[i] = Math.random() - 0.5;
-                    loraStart = performance.now();
-                    for (i = 0; i < iterations; i++) {
-                        lora.adapt_array(gradient);
-                    }
-                    loraTime = performance.now() - loraStart;
-                    loraAvg = loraTime / iterations;
-                    spinner.succeed('MicroLoRA benchmark complete');
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'MicroLoRA Metric', width: 25 },
-                            { key: 'value', header: 'Value', width: 25 },
-                        ],
-                        data: [
-                            { metric: 'Dimension', value: String(dim) },
-                            { metric: 'Iterations', value: iterations.toLocaleString() },
-                            { metric: 'Total Time', value: loraTime.toFixed(2) + "ms" },
-                            { metric: 'Avg Adaptation', value: (loraAvg * 1000).toFixed(2) + "\u03BCs" },
-                            { metric: 'Adaptations/sec', value: Math.round(1000 / loraAvg).toLocaleString() },
-                            { metric: 'Target (<100μs)', value: loraAvg * 1000 < 100 ? output.success('✓ PASS') : output.warning('✗ FAIL') },
-                        ]
-                    });
-                    lora.free();
-                    return [2 /*return*/, { success: true, data: { results: results, loraAvg: loraAvg } }];
-                case 11:
-                    error_9 = _l.sent();
-                    spinner.fail('Benchmark failed');
-                    output.printError(error_9 instanceof Error ? error_9.message : String(error_9));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 12: return [2 /*return*/];
+                    keys.push(key);
+                    values.push(val);
+                }
+                // Warmup
+                for (let i = 0; i < 10; i++)
+                    mechanism.computeRaw(query, keys, values);
+                const start = performance.now();
+                for (let i = 0; i < iterations; i++) {
+                    mechanism.computeRaw(query, keys, values);
+                }
+                const elapsed = performance.now() - start;
+                return {
+                    name,
+                    averageTimeMs: elapsed / iterations,
+                    opsPerSecond: Math.round((iterations / elapsed) * 1000),
+                };
+            };
+            spinner.setText(`Benchmarking attention mechanisms (dim=${dim}, keys=${numKeys}, iter=${iterations})...`);
+            const results = [];
+            // Benchmark each mechanism
+            const dotProduct = new attention.DotProductAttention(dim);
+            results.push(await benchmarkMechanism('DotProduct', dotProduct));
+            const flash = new attention.FlashAttention(dim, 64);
+            results.push(await benchmarkMechanism('FlashAttention', flash));
+            const multiHead = new attention.MultiHeadAttention(dim, 4);
+            results.push(await benchmarkMechanism('MultiHead (4 heads)', multiHead));
+            const hyperbolic = new attention.HyperbolicAttention(dim, 1.0);
+            results.push(await benchmarkMechanism('Hyperbolic', hyperbolic));
+            const linear = new attention.LinearAttention(dim, dim);
+            results.push(await benchmarkMechanism('Linear', linear));
+            spinner.succeed('Benchmark complete');
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'name', header: 'Mechanism', width: 25 },
+                    { key: 'avgTime', header: 'Avg Time (ms)', width: 15 },
+                    { key: 'opsPerSec', header: 'Ops/sec', width: 15 },
+                ],
+                data: results.map(r => ({
+                    name: r.name,
+                    avgTime: r.averageTimeMs.toFixed(4),
+                    opsPerSec: r.opsPerSecond.toLocaleString(),
+                })),
+            });
+            // Show speedup comparisons
+            const dotProductResult = results.find(r => r.name.includes('DotProduct'));
+            const flashResult = results.find(r => r.name.includes('Flash'));
+            const hyperbolicResult = results.find(r => r.name.includes('Hyperbolic'));
+            if (dotProductResult && flashResult) {
+                const speedup = dotProductResult.averageTimeMs / flashResult.averageTimeMs;
+                output.writeln();
+                output.writeln(output.highlight(`Flash Attention speedup: ${speedup.toFixed(2)}x faster than DotProduct`));
+            }
+            if (dotProductResult && hyperbolicResult) {
+                output.writeln(output.dim(`Hyperbolic overhead: ${(hyperbolicResult.averageTimeMs / dotProductResult.averageTimeMs).toFixed(2)}x (expected for manifold ops)`));
+            }
+            // Also benchmark MicroLoRA
+            spinner.start();
+            spinner.setText('Benchmarking MicroLoRA adaptation...');
+            // Load WASM file directly (Node.js compatible)
+            const fs = await import('fs');
+            const { createRequire } = await import('module');
+            const require = createRequire(import.meta.url);
+            const wasmPath = require.resolve('@ruvector/learning-wasm/ruvector_learning_wasm_bg.wasm');
+            const wasmBuffer = fs.readFileSync(wasmPath);
+            const learningWasm = await import('@ruvector/learning-wasm');
+            learningWasm.initSync({ module: wasmBuffer });
+            const lora = new learningWasm.WasmMicroLoRA(dim, 0.1, 0.01);
+            const gradient = new Float32Array(dim);
+            for (let i = 0; i < dim; i++)
+                gradient[i] = Math.random() - 0.5;
+            const loraStart = performance.now();
+            for (let i = 0; i < iterations; i++) {
+                lora.adapt_array(gradient);
             }
-        });
-    }); }
+            const loraTime = performance.now() - loraStart;
+            const loraAvg = loraTime / iterations;
+            spinner.succeed('MicroLoRA benchmark complete');
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'MicroLoRA Metric', width: 25 },
+                    { key: 'value', header: 'Value', width: 25 },
+                ],
+                data: [
+                    { metric: 'Dimension', value: String(dim) },
+                    { metric: 'Iterations', value: iterations.toLocaleString() },
+                    { metric: 'Total Time', value: `${loraTime.toFixed(2)}ms` },
+                    { metric: 'Avg Adaptation', value: `${(loraAvg * 1000).toFixed(2)}μs` },
+                    { metric: 'Adaptations/sec', value: Math.round(1000 / loraAvg).toLocaleString() },
+                    { metric: 'Target (<100μs)', value: loraAvg * 1000 < 100 ? output.success('✓ PASS') : output.warning('✗ FAIL') },
+                ],
+            });
+            lora.free();
+            return { success: true, data: { results, loraAvg } };
+        }
+        catch (error) {
+            spinner.fail('Benchmark failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Main neural command
-export var neuralCommand = {
+export const neuralCommand = {
     name: 'neural',
     description: 'Neural pattern training, MoE, Flash Attention, pattern learning',
     subcommands: [trainCommand, statusCommand, patternsCommand, predictCommand, optimizeCommand, benchmarkCommand, listCommand, exportCommand, importCommand],
@@ -1711,18 +1439,16 @@ export var neuralCommand = {
         { command: 'claude-flow neural train -p coordination', description: 'Train coordination patterns' },
         { command: 'claude-flow neural patterns --action list', description: 'List learned patterns' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('RuFlo Neural System'));
-            output.writeln(output.dim('Advanced AI pattern learning and inference'));
-            output.writeln();
-            output.writeln('Use --help with subcommands for more info');
-            output.writeln();
-            output.writeln(output.dim('Created with ❤️ by ruv.io'));
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('RuFlo Neural System'));
+        output.writeln(output.dim('Advanced AI pattern learning and inference'));
+        output.writeln();
+        output.writeln('Use --help with subcommands for more info');
+        output.writeln();
+        output.writeln(output.dim('Created with ❤️ by ruv.io'));
+        return { success: true };
+    },
 };
 export default neuralCommand;
 //# sourceMappingURL=neural.js.map