claude-flow 3.5.21 → 3.5.23

package/v3/@claude-flow/cli/dist/src/commands/init.js

@@ -21,9 +21,11 @@ async function initCodexAction(ctx, options) {
         // Dynamic import of the Codex initializer with lazy loading fallback
         let CodexInitializer;
         // Try multiple resolution strategies for the @claude-flow/codex package
+        // Use a variable to prevent TypeScript from statically resolving the optional module
+        const codexModuleId = '@claude-flow/codex';
         const resolutionStrategies = [
             // Strategy 1: Direct import (works if installed as CLI dependency)
-            async () => (await import('@claude-flow/codex')).CodexInitializer,
+            async () => (await import(codexModuleId)).CodexInitializer,
             // Strategy 2: Project node_modules (works if installed in user's project)
             async () => {
                 const projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');

package/v3/@claude-flow/cli/dist/src/commands/neural.js

@@ -68,7 +68,8 @@ const trainCommand = {
                 });
                 if (initResult.success) {
                     wasmFeatures = initResult.features;
-                    spinner.setText(`RuVector initialized: ${wasmFeatures.join(', ')}`);
+                    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`));
@@ -274,7 +275,8 @@ const trainCommand = {
             ];
             // Add WASM-specific metrics
             if (useWasm && wasmFeatures.length > 0) {
-                tableData.push({ 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) });
+                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) });
                 }
@@ -299,7 +301,11 @@ const trainCommand = {
             output.writeln();
             output.writeln(output.success(`✓ ${patternsRecorded} patterns saved to ${persistence.patternsFile}`));
             if (useWasm && wasmFeatures.length > 0) {
-                output.writeln(output.highlight(`✓ RuVector WASM: ${wasmFeatures.join(', ')}`));
+                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,
@@ -375,10 +381,10 @@ const statusCommand = {
                             : 'Not initialized',
                     },
                     {
-                        component: 'RuVector WASM',
+                        component: 'RuVector Training',
                         status: ruvectorStats.initialized ? output.success('Active') : output.dim('Not loaded'),
                         details: ruvectorStats.initialized
-                            ? `MicroLoRA: ${ruvectorStats.totalAdaptations} adapts`
+                            ? `${ruvectorStats.backend === 'wasm' ? 'WASM' : 'JS fallback'} | MicroLoRA: ${ruvectorStats.totalAdaptations} adapts`
                             : 'Call neural train to initialize',
                     },
                     {

package/v3/@claude-flow/cli/dist/src/index.d.ts

@@ -59,7 +59,7 @@ export * from './prompt.js';
 export * from './commands/index.js';
 export { MCPServerManager, createMCPServerManager, getServerManager, startMCPServer, stopMCPServer, getMCPServerStatus, type MCPServerOptions, type MCPServerStatus, } from './mcp-server.js';
 export { initializeMemoryDatabase, generateEmbedding, generateBatchEmbeddings, storeEntry, searchEntries, getHNSWIndex, addToHNSWIndex, searchHNSWIndex, getHNSWStatus, clearHNSWIndex, quantizeInt8, dequantizeInt8, quantizedCosineSim, getQuantizationStats, batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, type MemoryInitResult, } from './memory/memory-initializer.js';
-export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatterns, getIntelligenceStats, getSonaCoordinator, getReasoningBank, clearIntelligence, benchmarkAdaptation, getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, type SonaConfig, type TrajectoryStep, type Pattern, type IntelligenceStats, } from './memory/intelligence.js';
+export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatterns, getIntelligenceStats, getSonaCoordinator, getReasoningBank, clearIntelligence, benchmarkAdaptation, endTrajectoryWithVerdict, distillLearning, getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, type SonaConfig, type TrajectoryStep, type Pattern, type IntelligenceStats, } from './memory/intelligence.js';
 export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, type PatternWeights, type EWCConfig, type ConsolidationResult, type EWCStats, } from './memory/ewc-consolidation.js';
 export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, type TrajectoryOutcome, type LearnedPattern, type RoutingSuggestion, type SONAStats, } from './memory/sona-optimizer.js';
 export { ErrorHandler, withErrorHandling, } from './production/error-handler.js';

package/v3/@claude-flow/cli/dist/src/index.js

@@ -453,6 +453,8 @@ export { initializeMemoryDatabase, generateEmbedding, generateBatchEmbeddings, s
 // Flash Attention-style batch operations
 batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, } from './memory/memory-initializer.js';
 export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatterns, getIntelligenceStats, getSonaCoordinator, getReasoningBank, clearIntelligence, benchmarkAdaptation, 
+// RL loop API
+endTrajectoryWithVerdict, distillLearning, 
 // Pattern persistence API
 getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, } from './memory/intelligence.js';
 // EWC++ Consolidation (Prevents Catastrophic Forgetting)

package/v3/@claude-flow/cli/dist/src/mcp-tools/coordination-tools.js

@@ -350,55 +350,234 @@ export const coordinationTools = [
     },
     {
         name: 'coordination_consensus',
-        description: 'Manage consensus protocol',
+        description: 'Manage consensus protocol with BFT, Raft, or Quorum strategies',
         category: 'coordination',
         inputSchema: {
             type: 'object',
             properties: {
                 action: { type: 'string', enum: ['status', 'propose', 'vote', 'commit'], description: 'Action to perform' },
-                proposal: { type: 'object', description: 'Proposal data' },
+                proposal: { type: 'object', description: 'Proposal data (for propose)' },
+                proposalId: { type: 'string', description: 'Proposal ID (for vote/commit/status)' },
                 vote: { type: 'string', enum: ['accept', 'reject'], description: 'Vote' },
+                voterId: { type: 'string', description: 'Voter node ID' },
+                strategy: { type: 'string', enum: ['bft', 'raft', 'quorum'], description: 'Consensus strategy (default: raft)' },
+                quorumPreset: { type: 'string', enum: ['unanimous', 'majority', 'supermajority'], description: 'Quorum threshold preset (default: majority)' },
+                term: { type: 'number', description: 'Term number (for raft strategy)' },
             },
         },
         handler: async (input) => {
             const store = loadCoordStore();
             const action = input.action || 'status';
+            const strategy = input.strategy || 'raft';
+            const nodeCount = Object.keys(store.nodes).length || 1;
+            // Initialize consensus storage in the coordination store if missing
+            if (!store.consensus) {
+                store.consensus = { pending: [], history: [] };
+            }
+            const consensus = store.consensus;
+            function calcRequired(strat, total, preset) {
+                if (total <= 0)
+                    return 1;
+                if (strat === 'bft')
+                    return Math.floor((total * 2) / 3) + 1;
+                if (strat === 'quorum') {
+                    if (preset === 'unanimous')
+                        return total;
+                    if (preset === 'supermajority')
+                        return Math.floor((total * 2) / 3) + 1;
+                }
+                return Math.floor(total / 2) + 1;
+            }
             if (action === 'status') {
-                const nodeCount = Object.keys(store.nodes).length;
-                const quorum = Math.floor(nodeCount / 2) + 1;
+                if (input.proposalId) {
+                    // Status for specific proposal
+                    const p = consensus.pending.find(x => x.proposalId === input.proposalId);
+                    if (p) {
+                        const votesFor = Object.values(p.votes).filter(v => v).length;
+                        const votesAgainst = Object.values(p.votes).filter(v => !v).length;
+                        return {
+                            success: true,
+                            proposalId: p.proposalId,
+                            strategy: p.strategy,
+                            status: p.status,
+                            votesFor,
+                            votesAgainst,
+                            required: calcRequired(p.strategy, nodeCount, p.quorumPreset),
+                            totalNodes: nodeCount,
+                            resolved: false,
+                        };
+                    }
+                    const h = consensus.history.find(x => x.proposalId === input.proposalId);
+                    if (h)
+                        return { success: true, ...h, resolved: true, historical: true };
+                    return { success: false, error: 'Proposal not found' };
+                }
+                const quorum = calcRequired(strategy, nodeCount);
                 return {
                     success: true,
                     algorithm: store.topology.consensusAlgorithm,
+                    strategy,
                     nodes: nodeCount,
                     quorum,
+                    pendingProposals: consensus.pending.length,
+                    resolvedProposals: consensus.history.length,
                     status: nodeCount >= quorum ? 'operational' : 'degraded',
                 };
             }
             if (action === 'propose') {
-                const proposalId = `proposal-${Date.now()}`;
+                const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const quorumPreset = input.quorumPreset || 'majority';
+                const term = input.term || 1;
+                const required = calcRequired(strategy, nodeCount, quorumPreset);
+                // Raft: one pending proposal per term
+                if (strategy === 'raft') {
+                    const existing = consensus.pending.find(p => p.strategy === 'raft' && p.term === term);
+                    if (existing) {
+                        return {
+                            success: false,
+                            error: `Raft term ${term} already has pending proposal: ${existing.proposalId}`,
+                            existingProposalId: existing.proposalId,
+                        };
+                    }
+                }
+                consensus.pending.push({
+                    proposalId,
+                    type: 'coordination',
+                    proposal: input.proposal,
+                    proposedBy: input.voterId || 'system',
+                    proposedAt: new Date().toISOString(),
+                    votes: {},
+                    status: 'pending',
+                    strategy,
+                    term: strategy === 'raft' ? term : undefined,
+                    quorumPreset: strategy === 'quorum' ? quorumPreset : undefined,
+                    byzantineVoters: strategy === 'bft' ? [] : undefined,
+                });
+                saveCoordStore(store);
                 return {
                     success: true,
                     action: 'proposed',
                     proposalId,
                     proposal: input.proposal,
+                    strategy,
                     status: 'pending',
-                    requiredVotes: Math.floor(Object.keys(store.nodes).length / 2) + 1,
+                    required,
+                    totalNodes: nodeCount,
+                    term: strategy === 'raft' ? term : undefined,
                 };
             }
             if (action === 'vote') {
+                const p = consensus.pending.find(x => x.proposalId === input.proposalId);
+                if (!p)
+                    return { success: false, error: 'Proposal not found or already resolved' };
+                const voterId = input.voterId;
+                if (!voterId)
+                    return { success: false, error: 'voterId is required' };
+                const voteValue = input.vote === 'accept';
+                const pStrategy = p.strategy || 'raft';
+                const required = calcRequired(pStrategy, nodeCount, p.quorumPreset);
+                // Double-vote prevention
+                if (voterId in p.votes) {
+                    if (pStrategy === 'bft' && p.votes[voterId] !== voteValue) {
+                        if (!p.byzantineVoters)
+                            p.byzantineVoters = [];
+                        if (!p.byzantineVoters.includes(voterId))
+                            p.byzantineVoters.push(voterId);
+                        delete p.votes[voterId];
+                        saveCoordStore(store);
+                        return {
+                            success: false,
+                            byzantineDetected: true,
+                            message: `Byzantine behavior: voter ${voterId} attempted conflicting vote. Vote invalidated.`,
+                            byzantineVoters: p.byzantineVoters,
+                        };
+                    }
+                    return { success: false, error: `Voter ${voterId} has already voted on this proposal` };
+                }
+                // BFT cross-proposal conflict check
+                if (pStrategy === 'bft') {
+                    for (const other of consensus.pending) {
+                        if (other.proposalId === p.proposalId)
+                            continue;
+                        if (voterId in other.votes && other.votes[voterId] !== voteValue) {
+                            if (!p.byzantineVoters)
+                                p.byzantineVoters = [];
+                            if (!p.byzantineVoters.includes(voterId))
+                                p.byzantineVoters.push(voterId);
+                            saveCoordStore(store);
+                            return {
+                                success: false,
+                                byzantineDetected: true,
+                                message: `Byzantine behavior: voter ${voterId} cast conflicting votes across proposals.`,
+                                byzantineVoters: p.byzantineVoters,
+                            };
+                        }
+                    }
+                }
+                p.votes[voterId] = voteValue;
+                const votesFor = Object.values(p.votes).filter(v => v).length;
+                const votesAgainst = Object.values(p.votes).filter(v => !v).length;
+                // Resolution check
+                let resolved = false;
+                let result;
+                if (votesFor >= required) {
+                    resolved = true;
+                    result = 'approved';
+                }
+                else if (votesAgainst >= required) {
+                    resolved = true;
+                    result = 'rejected';
+                }
+                else if (pStrategy === 'quorum' && p.quorumPreset === 'unanimous' && votesAgainst > 0) {
+                    resolved = true;
+                    result = 'rejected';
+                }
+                if (resolved && result) {
+                    p.status = result;
+                    consensus.history.push({
+                        proposalId: p.proposalId,
+                        result,
+                        votes: { for: votesFor, against: votesAgainst },
+                        decidedAt: new Date().toISOString(),
+                        strategy: pStrategy,
+                        term: p.term,
+                        byzantineDetected: p.byzantineVoters?.length ? p.byzantineVoters : undefined,
+                    });
+                    consensus.pending = consensus.pending.filter(x => x.proposalId !== p.proposalId);
+                }
+                saveCoordStore(store);
                 return {
                     success: true,
                     action: 'voted',
+                    proposalId: p.proposalId,
+                    voterId,
                     vote: input.vote,
-                    timestamp: new Date().toISOString(),
+                    strategy: pStrategy,
+                    votesFor,
+                    votesAgainst,
+                    required,
+                    totalNodes: nodeCount,
+                    resolved,
+                    result: resolved ? result : undefined,
+                    status: p.status,
                 };
             }
             if (action === 'commit') {
-                return {
-                    success: true,
-                    action: 'committed',
-                    committedAt: new Date().toISOString(),
-                };
+                // Commit is a no-op confirmation for already-resolved proposals
+                if (input.proposalId) {
+                    const h = consensus.history.find(x => x.proposalId === input.proposalId);
+                    if (h) {
+                        return {
+                            success: true,
+                            action: 'committed',
+                            proposalId: input.proposalId,
+                            result: h.result,
+                            committedAt: new Date().toISOString(),
+                        };
+                    }
+                    return { success: false, error: 'Proposal not found in resolved history. Vote must reach quorum first.' };
+                }
+                return { success: false, error: 'proposalId is required for commit' };
             }
             return { success: false, error: 'Unknown action' };
         },