@claude-flow/cli 3.18.2 → 3.20.0

package/dist/src/commands/neural.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"neural.d.ts","sourceRoot":"","sources":["../../../src/commands/neural.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AAmqI1E,eAAO,MAAM,aAAa,EAAE,OAmB3B,CAAC;AAEF,eAAe,aAAa,CAAC"}
+{"version":3,"file":"neural.d.ts","sourceRoot":"","sources":["../../../src/commands/neural.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAiC,MAAM,aAAa,CAAC;AA0wI1E,eAAO,MAAM,aAAa,EAAE,OAmB3B,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/src/commands/neural.js

@@ -23,6 +23,9 @@ const trainCommand = {
         { 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: 'backend', type: 'string', description: 'Training backend: auto (native when available), native (@ruvector/ruvllm TrainingPipeline, disk checkpoints), wasm (RuVector MicroLoRA/InfoNCE)', default: 'auto' },
+        { name: 'val-split', type: 'number', description: 'Validation holdout fraction 0..1 (native backend). >0 reports Best Val Loss + early stopping; 0 disables', default: '0.1' },
+        { name: 'resume', type: 'string', description: 'Resume native training from a checkpoint path (weights on 2.5.7; epoch position on >=2.6.0). Native backend only', default: '' },
     ],
     examples: [
         { command: 'claude-flow neural train -p coordination -e 100', description: 'Train coordination patterns' },
@@ -35,6 +38,22 @@ const trainCommand = {
         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);
+        // #2549 follow-up — backend routing: 'native' = @ruvector/ruvllm
+        // TrainingPipeline (real epochs/early-stopping/disk checkpoints),
+        // 'wasm' = RuVector MicroLoRA/InfoNCE (pre-3.19 behavior),
+        // 'auto' = native when the module resolves, else wasm.
+        const backendFlag = String(ctx.flags.backend || 'auto');
+        // Feature: validation split + resume (native TrainingPipeline leg).
+        const valSplitRaw = parseFloat(ctx.flags['val-split'] ?? '0.1');
+        const valSplit = Number.isFinite(valSplitRaw) ? Math.max(0, Math.min(1, valSplitRaw)) : 0.1;
+        const resumePath = ctx.flags.resume ? String(ctx.flags.resume) : undefined;
+        // --resume is a native-only capability; refuse the WASM combination up
+        // front so the user gets a clear error rather than a silently-ignored flag.
+        if (resumePath && backendFlag === 'wasm') {
+            output.writeln();
+            output.writeln(output.error('--resume is only supported by the native backend; drop --backend wasm.'));
+            return { success: false, exitCode: 1 };
+        }
         const useWasm = ctx.flags.wasm !== false;
         const useFlash = ctx.flags.flash !== false;
         const useMoE = ctx.flags.moe === true;
@@ -181,6 +200,50 @@ const trainCommand = {
                 }
             }
             spinner.setText(`Training with ${embeddings.length} embeddings...`);
+            // #2549 — native TrainingPipeline leg. In 'auto'/'native' mode the
+            // LoRA training runs through @ruvector/ruvllm with the checkpoint
+            // taken from the TRAINED pipeline (the old best-effort block saved
+            // a fresh adapter's untrained weights). SONA/ReasoningBank
+            // persistence in the loop below runs regardless of backend.
+            const nativeTraining = await import('../services/native-training.js');
+            const useNative = backendFlag === 'native'
+                || (backendFlag === 'auto' && nativeTraining.nativeTrainingAvailable());
+            // --resume only works on the native pipeline; if native is unavailable
+            // (module absent), fail loudly rather than silently fresh-train.
+            if (resumePath && !useNative) {
+                spinner.fail('--resume requires the native @ruvector/ruvllm backend, which is not available');
+                return { success: false, exitCode: 1 };
+            }
+            let nativeResult = null;
+            if (useNative) {
+                spinner.setText(`Training ${patternType} on native @ruvector/ruvllm pipeline...`);
+                const path = await import('path');
+                try {
+                    nativeResult = await nativeTraining.runNativeTraining({
+                        embeddings,
+                        epochs,
+                        batchSize,
+                        learningRate,
+                        dim,
+                        validationSplit: valSplit,
+                        resumeFrom: resumePath,
+                        checkpointPath: path.join(process.cwd(), '.claude-flow', 'neural', `lora-checkpoint-${Date.now()}.json`),
+                    });
+                }
+                catch (err) {
+                    // ResumeFailedError — an explicit --resume that could not load is a
+                    // loud, exit-1 failure, never a silent fall-through to fresh training.
+                    spinner.fail(`Resume failed: ${err.message}`);
+                    return { success: false, exitCode: 1 };
+                }
+                if (!nativeResult && backendFlag === 'native') {
+                    spinner.fail('Native backend requested (--backend native) but @ruvector/ruvllm training failed');
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            // Native handles the LoRA leg; WASM contrastive runs when native
+            // didn't (absent module, or explicit --backend wasm).
+            const runWasmLeg = !nativeResult;
             // Main training loop with WASM acceleration
             for (let epoch = 0; epoch < epochs; epoch++) {
                 const epochStart = performance.now();
@@ -192,7 +255,7 @@ const trainCommand = {
                 if (batch.length === 0)
                     continue;
                 // Training step with contrastive learning
-                if (useContrastive && batch.length >= 3 && useWasm && wasmFeatures.length > 0) {
+                if (runWasmLeg && useContrastive && batch.length >= 3 && useWasm && wasmFeatures.length > 0) {
                     const anchor = batch[0];
                     const positives = [batch[1]];
                     const negatives = batch.slice(2);
@@ -260,17 +323,22 @@ const trainCommand = {
             // Flush patterns to disk
             flushPatterns();
             const persistence = getPersistenceStatus();
-            // Save LoRA checkpoint via ruvllm TrainingPipeline if available
-            try {
-                const { LoRAAdapter } = await import('../ruvector/lora-adapter.js');
-                const path = await import('path');
-                const cpDir = path.join(process.cwd(), '.claude-flow', 'neural');
-                const cpPath = path.join(cpDir, `lora-checkpoint-${Date.now()}.json`);
-                const adapter = new LoRAAdapter({ inputDim: dim, outputDim: dim, rank: 4 });
-                await adapter.initBackend();
-                await adapter.saveCheckpoint(cpPath);
+            // Checkpoint: when the native pipeline trained, its checkpoint (the
+            // TRAINED weights) was already written by runNativeTraining. The
+            // pre-3.19 fallback below saved a FRESH adapter's weights — only
+            // meaningful as a fallback when the native leg didn't run.
+            if (!nativeResult?.checkpointPath) {
+                try {
+                    const { LoRAAdapter } = await import('../ruvector/lora-adapter.js');
+                    const path = await import('path');
+                    const cpDir = path.join(process.cwd(), '.claude-flow', 'neural');
+                    const cpPath = path.join(cpDir, `lora-checkpoint-${Date.now()}.json`);
+                    const adapter = new LoRAAdapter({ inputDim: dim, outputDim: dim, rank: 4 });
+                    await adapter.initBackend();
+                    await adapter.saveCheckpoint(cpPath);
+                }
+                catch { /* checkpoint save is best-effort */ }
             }
-            catch { /* checkpoint save is best-effort */ }
             output.writeln();
             // Display results
             const tableData = [
@@ -284,8 +352,31 @@ const trainCommand = {
                 { 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` },
             ];
+            // Native pipeline metrics (#2549 — the LoRA leg trained on ruvllm)
+            if (nativeResult) {
+                tableData.push({ metric: 'Backend', value: 'native (@ruvector/ruvllm TrainingPipeline)' }, { metric: 'Native Steps', value: String(nativeResult.steps) }, { metric: 'Final Loss', value: nativeResult.finalLoss.toExponential(3) });
+                // Validation metrics only surface when a holdout actually ran
+                // (bestValLoss is non-null); Early Stopped is only meaningful then.
+                if (nativeResult.bestValLoss !== null && nativeResult.bestValLoss !== undefined) {
+                    tableData.push({ metric: 'Best Val Loss', value: nativeResult.bestValLoss.toExponential(3) }, { metric: 'Early Stopped', value: nativeResult.earlyStopped ? 'yes' : 'no' });
+                }
+                if (nativeResult.resumed) {
+                    tableData.push({
+                        metric: 'Resumed',
+                        value: nativeResult.resumeMode === 'resumeFrom'
+                            ? `${resumePath} (epoch position restored)`
+                            : `${resumePath} (weights only — epoch-position resume needs @ruvector/ruvllm >=2.6.0)`,
+                    });
+                }
+                if (nativeResult.checkpointPath) {
+                    tableData.push({
+                        metric: 'Checkpoint',
+                        value: `${nativeResult.checkpointPath}${nativeResult.checkpointBytes ? ` (${(nativeResult.checkpointBytes / 1024).toFixed(1)} KB)` : ''}`,
+                    });
+                }
+            }
             // Add WASM-specific metrics
-            if (useWasm && wasmFeatures.length > 0) {
+            if (runWasmLeg && 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) {
@@ -474,10 +565,14 @@ const statusCommand = {
                         details: stats._trainingBackend === 'ruvllm'
                             ? await (async () => {
                                 try {
-                                    const { nativeCheckpointsSupported } = await import('../ruvector/lora-adapter.js');
-                                    return nativeCheckpointsSupported()
+                                    const { nativeCheckpointsSupported, latestCheckpointInfo } = await import('../ruvector/lora-adapter.js');
+                                    // Most important info first (truncation-friendly): backend
+                                    // capability, then the newest checkpoint + age when one exists.
+                                    const base = nativeCheckpointsSupported()
                                         ? 'native @ruvector/ruvllm pipeline + disk checkpoints'
                                         : 'native @ruvector/ruvllm pipeline (checkpoints need >=2.5.7)';
+                                    const cp = latestCheckpointInfo();
+                                    return cp ? `${base} · latest: ${cp.filename} (${cp.ageLabel})` : base;
                                 }
                                 catch {
                                     return 'native @ruvector/ruvllm pipeline';