claude-flow 3.5.21 → 3.5.23

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

@@ -9,6 +9,78 @@ import { join } from 'node:path';
 const STORAGE_DIR = '.claude-flow';
 const HIVE_DIR = 'hive-mind';
 const HIVE_FILE = 'state.json';
+/**
+ * Calculate required votes for a given strategy and total node count.
+ */
+function calculateRequiredVotes(strategy, totalNodes, quorumPreset = 'majority') {
+    if (totalNodes <= 0)
+        return 1;
+    switch (strategy) {
+        case 'bft':
+            // BFT: requires 2/3 + 1 of total nodes
+            return Math.floor((totalNodes * 2) / 3) + 1;
+        case 'raft':
+            // Raft: simple majority
+            return Math.floor(totalNodes / 2) + 1;
+        case 'quorum':
+            switch (quorumPreset) {
+                case 'unanimous':
+                    return totalNodes;
+                case 'supermajority':
+                    return Math.floor((totalNodes * 2) / 3) + 1;
+                case 'majority':
+                default:
+                    return Math.floor(totalNodes / 2) + 1;
+            }
+        default:
+            return Math.floor(totalNodes / 2) + 1;
+    }
+}
+/**
+ * Detect Byzantine behavior: a voter who has cast conflicting votes
+ * across proposals in the same round (same type, overlapping time).
+ * Here we check if the voter already voted differently on this proposal
+ * (which shouldn't happen if we block double-votes, so this checks
+ * cross-proposal conflicting votes for same type within the pending set).
+ */
+function detectByzantineVoters(pending, currentProposal, voterId, newVote) {
+    // Check if voter cast opposite votes on proposals of the same type
+    for (const p of pending) {
+        if (p.proposalId === currentProposal.proposalId)
+            continue;
+        if (p.type !== currentProposal.type)
+            continue;
+        if (voterId in p.votes && p.votes[voterId] !== newVote) {
+            return true; // Conflicting vote detected
+        }
+    }
+    return false;
+}
+/**
+ * Try to resolve a proposal based on its strategy.
+ * Returns 'approved', 'rejected', or null if still pending.
+ */
+function tryResolveProposal(proposal, totalNodes) {
+    const votesFor = Object.values(proposal.votes).filter(v => v).length;
+    const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+    const required = calculateRequiredVotes(proposal.strategy, totalNodes, proposal.quorumPreset);
+    if (votesFor >= required)
+        return 'approved';
+    if (votesAgainst >= required)
+        return 'rejected';
+    // For quorum with 'unanimous', also reject if any vote is against
+    if (proposal.strategy === 'quorum' && proposal.quorumPreset === 'unanimous' && votesAgainst > 0) {
+        return 'rejected';
+    }
+    // Check if it's impossible to reach quorum (remaining potential votes can't tip it)
+    const totalVotes = Object.keys(proposal.votes).length;
+    const remaining = totalNodes - totalVotes;
+    if (votesFor + remaining < required && votesAgainst + remaining < required) {
+        // Deadlock: neither side can win -- reject
+        return 'rejected';
+    }
+    return null;
+}
 function getHiveDir() {
     return join(process.cwd(), STORAGE_DIR, HIVE_DIR);
 }
@@ -300,7 +372,7 @@ export const hiveMindTools = [
     },
     {
         name: 'hive-mind_consensus',
-        description: 'Propose or vote on consensus',
+        description: 'Propose or vote on consensus with BFT, Raft, or Quorum strategies',
         category: 'hive-mind',
         inputSchema: {
             type: 'object',
@@ -311,14 +383,36 @@ export const hiveMindTools = [
                 value: { description: 'Proposal value (for propose)' },
                 vote: { type: 'boolean', description: 'Vote (true=for, false=against)' },
                 voterId: { type: 'string', description: 'Voter agent ID' },
+                strategy: { type: 'string', enum: ['bft', 'raft', 'quorum'], description: 'Consensus strategy (default: raft)' },
+                quorumPreset: { type: 'string', enum: ['unanimous', 'majority', 'supermajority'], description: 'Quorum threshold preset (for quorum strategy, default: majority)' },
+                term: { type: 'number', description: 'Term number (for raft strategy)' },
+                timeoutMs: { type: 'number', description: 'Timeout in ms for raft re-proposal (default: 30000)' },
             },
             required: ['action'],
         },
         handler: async (input) => {
             const state = loadHiveState();
             const action = input.action;
+            const strategy = input.strategy || 'raft';
+            const totalNodes = state.workers.length || 1;
             if (action === 'propose') {
                 const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const quorumPreset = input.quorumPreset || 'majority';
+                const term = input.term || (state.queen?.term ?? 1);
+                const timeoutMs = input.timeoutMs || 30000;
+                // Raft: check if there's already a pending proposal for this term
+                if (strategy === 'raft') {
+                    const existingTermProposal = state.consensus.pending.find(p => p.strategy === 'raft' && p.term === term && p.status === 'pending');
+                    if (existingTermProposal) {
+                        return {
+                            action,
+                            error: `Raft term ${term} already has a pending proposal: ${existingTermProposal.proposalId}. Wait for resolution or use a higher term.`,
+                            existingProposalId: existingTermProposal.proposalId,
+                            term,
+                        };
+                    }
+                }
+                const required = calculateRequiredVotes(strategy, totalNodes, quorumPreset);
                 const proposal = {
                     proposalId,
                     type: input.type || 'general',
@@ -327,6 +421,11 @@ export const hiveMindTools = [
                     proposedAt: new Date().toISOString(),
                     votes: {},
                     status: 'pending',
+                    strategy,
+                    term: strategy === 'raft' ? term : undefined,
+                    quorumPreset: strategy === 'quorum' ? quorumPreset : undefined,
+                    byzantineVoters: strategy === 'bft' ? [] : undefined,
+                    timeoutAt: strategy === 'raft' ? new Date(Date.now() + timeoutMs).toISOString() : undefined,
                 };
                 state.consensus.pending.push(proposal);
                 saveHiveState(state);
@@ -334,40 +433,115 @@ export const hiveMindTools = [
                     action,
                     proposalId,
                     type: proposal.type,
+                    strategy,
                     status: 'pending',
-                    requiredVotes: Math.ceil(state.workers.length / 2) + 1,
+                    required,
+                    totalNodes,
+                    term: proposal.term,
+                    quorumPreset: proposal.quorumPreset,
+                    timeoutAt: proposal.timeoutAt,
                 };
             }
             if (action === 'vote') {
                 const proposal = state.consensus.pending.find(p => p.proposalId === input.proposalId);
                 if (!proposal) {
-                    return { action, error: 'Proposal not found' };
+                    return { action, error: 'Proposal not found or already resolved' };
                 }
                 const voterId = input.voterId;
-                proposal.votes[voterId] = input.vote;
-                // Check if we have majority
-                const votesFor = Object.values(proposal.votes).filter(v => v).length;
-                const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
-                const majority = Math.ceil(state.workers.length / 2) + 1;
-                if (votesFor >= majority) {
-                    proposal.status = 'approved';
-                    state.consensus.history.push({
+                if (!voterId) {
+                    return { action, error: 'voterId is required for voting' };
+                }
+                const voteValue = input.vote;
+                const proposalStrategy = proposal.strategy || 'raft';
+                const required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal.quorumPreset);
+                // Prevent double-voting
+                if (voterId in proposal.votes) {
+                    const previousVote = proposal.votes[voterId];
+                    if (previousVote === voteValue) {
+                        return {
+                            action,
+                            error: `Voter ${voterId} has already cast the same vote on this proposal`,
+                            proposalId: proposal.proposalId,
+                            existingVote: previousVote,
+                        };
+                    }
+                    // Conflicting vote from same voter
+                    if (proposalStrategy === 'bft') {
+                        // BFT: detect as Byzantine behavior
+                        if (!proposal.byzantineVoters)
+                            proposal.byzantineVoters = [];
+                        if (!proposal.byzantineVoters.includes(voterId)) {
+                            proposal.byzantineVoters.push(voterId);
+                        }
+                        // Remove their vote entirely -- Byzantine voter is excluded
+                        delete proposal.votes[voterId];
+                        saveHiveState(state);
+                        return {
+                            action,
+                            proposalId: proposal.proposalId,
+                            voterId,
+                            byzantineDetected: true,
+                            message: `Byzantine behavior detected: voter ${voterId} attempted conflicting vote. Vote invalidated.`,
+                            byzantineVoters: proposal.byzantineVoters,
+                            status: proposal.status,
+                        };
+                    }
+                    if (proposalStrategy === 'raft') {
+                        // Raft: only one vote per node per term, reject the change
+                        return {
+                            action,
+                            error: `Raft: voter ${voterId} already voted in term ${proposal.term}. Cannot change vote.`,
+                            proposalId: proposal.proposalId,
+                            term: proposal.term,
+                        };
+                    }
+                    // Quorum: reject double-vote
+                    return {
+                        action,
+                        error: `Voter ${voterId} has already voted on this proposal`,
                         proposalId: proposal.proposalId,
-                        type: proposal.type,
-                        result: 'approved',
-                        votes: { for: votesFor, against: votesAgainst },
-                        decidedAt: new Date().toISOString(),
-                    });
-                    state.consensus.pending = state.consensus.pending.filter(p => p.proposalId !== proposal.proposalId);
+                    };
+                }
+                // BFT: check for cross-proposal Byzantine behavior
+                if (proposalStrategy === 'bft') {
+                    const isByzantine = detectByzantineVoters(state.consensus.pending, proposal, voterId, voteValue);
+                    if (isByzantine) {
+                        if (!proposal.byzantineVoters)
+                            proposal.byzantineVoters = [];
+                        if (!proposal.byzantineVoters.includes(voterId)) {
+                            proposal.byzantineVoters.push(voterId);
+                        }
+                        saveHiveState(state);
+                        return {
+                            action,
+                            proposalId: proposal.proposalId,
+                            voterId,
+                            byzantineDetected: true,
+                            message: `Byzantine behavior detected: voter ${voterId} cast conflicting votes across proposals of same type. Vote rejected.`,
+                            byzantineVoters: proposal.byzantineVoters,
+                            status: proposal.status,
+                        };
+                    }
                 }
-                else if (votesAgainst >= majority) {
-                    proposal.status = 'rejected';
+                // Record the vote
+                proposal.votes[voterId] = voteValue;
+                const votesFor = Object.values(proposal.votes).filter(v => v).length;
+                const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+                // Try to resolve
+                const resolution = tryResolveProposal(proposal, totalNodes);
+                let resolved = false;
+                if (resolution !== null) {
+                    resolved = true;
+                    proposal.status = resolution;
                     state.consensus.history.push({
                         proposalId: proposal.proposalId,
                         type: proposal.type,
-                        result: 'rejected',
+                        result: resolution,
                         votes: { for: votesFor, against: votesAgainst },
                         decidedAt: new Date().toISOString(),
+                        strategy: proposalStrategy,
+                        term: proposal.term,
+                        byzantineDetected: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
                     });
                     state.consensus.pending = state.consensus.pending.filter(p => p.proposalId !== proposal.proposalId);
                 }
@@ -376,10 +550,17 @@ export const hiveMindTools = [
                     action,
                     proposalId: proposal.proposalId,
                     voterId,
-                    vote: input.vote,
+                    vote: voteValue,
+                    strategy: proposalStrategy,
                     votesFor,
                     votesAgainst,
+                    required,
+                    totalNodes,
+                    resolved,
+                    result: resolved ? resolution : undefined,
                     status: proposal.status,
+                    term: proposal.term,
+                    byzantineVoters: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
                 };
             }
             if (action === 'status') {
@@ -388,21 +569,37 @@ export const hiveMindTools = [
                     // Check history
                     const historical = state.consensus.history.find(h => h.proposalId === input.proposalId);
                     if (historical) {
-                        return { action, ...historical, historical: true };
+                        return { action, ...historical, historical: true, resolved: true };
                     }
                     return { action, error: 'Proposal not found' };
                 }
                 const votesFor = Object.values(proposal.votes).filter(v => v).length;
                 const votesAgainst = Object.values(proposal.votes).filter(v => !v).length;
+                const proposalStrategy = proposal.strategy || 'raft';
+                const required = calculateRequiredVotes(proposalStrategy, totalNodes, proposal.quorumPreset);
+                // Raft: check timeout
+                let timedOut = false;
+                if (proposalStrategy === 'raft' && proposal.timeoutAt) {
+                    timedOut = new Date().getTime() > new Date(proposal.timeoutAt).getTime();
+                }
                 return {
                     action,
                     proposalId: proposal.proposalId,
                     type: proposal.type,
+                    strategy: proposalStrategy,
                     status: proposal.status,
                     votesFor,
                     votesAgainst,
                     totalVotes: Object.keys(proposal.votes).length,
-                    requiredMajority: Math.ceil(state.workers.length / 2) + 1,
+                    required,
+                    totalNodes,
+                    resolved: false,
+                    term: proposal.term,
+                    quorumPreset: proposal.quorumPreset,
+                    byzantineVoters: proposal.byzantineVoters?.length ? proposal.byzantineVoters : undefined,
+                    timedOut,
+                    timeoutAt: proposal.timeoutAt,
+                    hint: timedOut ? `Raft timeout reached. Re-propose with term ${(proposal.term || 1) + 1}.` : undefined,
                 };
             }
             if (action === 'list') {
@@ -411,8 +608,12 @@ export const hiveMindTools = [
                     pending: state.consensus.pending.map(p => ({
                         proposalId: p.proposalId,
                         type: p.type,
+                        strategy: p.strategy || 'raft',
                         proposedAt: p.proposedAt,
                         totalVotes: Object.keys(p.votes).length,
+                        required: calculateRequiredVotes(p.strategy || 'raft', totalNodes, p.quorumPreset),
+                        term: p.term,
+                        status: p.status,
                     })),
                     recentHistory: state.consensus.history.slice(-5),
                 };

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

@@ -344,6 +344,7 @@ export const memoryTools = [
                     key,
                     namespace,
                     deleted: result.deleted,
+                    hnswIndexInvalidated: result.deleted,
                     backend: 'sql.js + HNSW',
                 };
             }

package/v3/@claude-flow/cli/dist/src/memory/ewc-consolidation.d.ts

@@ -197,6 +197,30 @@ export declare class EWCConsolidator {
      * Reset Fisher matrix (use with caution - allows forgetting)
      */
     resetFisher(): void;
+    /**
+     * Update Fisher matrix from pattern confidence changes.
+     * Called by SONA after distillLearning to track which patterns
+     * are important and should be protected from forgetting.
+     *
+     * Uses online averaging: F_new = alpha * F_old + (1-alpha) * F_current
+     *
+     * @param confidenceChanges - Array of {id, embedding, oldConf, newConf}
+     */
+    updateFisherFromConfidences(confidenceChanges: {
+        id: string;
+        embedding: number[];
+        oldConf: number;
+        newConf: number;
+    }[]): void;
+    /**
+     * Compute consolidation penalty for a proposed confidence update.
+     * Used by SONA to check whether a pattern update would cause forgetting.
+     *
+     * @param oldConfidence - Current confidence value
+     * @param newConfidence - Proposed new confidence value
+     * @returns Penalty value (higher = more forgetting risk)
+     */
+    computeConfidencePenalty(oldConfidence: number, newConfidence: number): number;
     /**
      * Clear all patterns and history (full reset)
      */

package/v3/@claude-flow/cli/dist/src/memory/ewc-consolidation.js

@@ -342,6 +342,65 @@ export class EWCConsolidator {
     resetFisher() {
         this.globalFisher = new Array(this.config.dimensions).fill(0);
     }
+    /**
+     * Update Fisher matrix from pattern confidence changes.
+     * Called by SONA after distillLearning to track which patterns
+     * are important and should be protected from forgetting.
+     *
+     * Uses online averaging: F_new = alpha * F_old + (1-alpha) * F_current
+     *
+     * @param confidenceChanges - Array of {id, embedding, oldConf, newConf}
+     */
+    updateFisherFromConfidences(confidenceChanges) {
+        if (confidenceChanges.length === 0)
+            return;
+        const alpha = this.config.fisherDecayRate;
+        const currentFisher = new Array(this.config.dimensions).fill(0);
+        let sampleCount = 0;
+        for (const change of confidenceChanges) {
+            if (!change.embedding || change.embedding.length === 0)
+                continue;
+            const confDelta = Math.abs(change.newConf - change.oldConf);
+            if (confDelta === 0)
+                continue;
+            sampleCount++;
+            const len = Math.min(change.embedding.length, this.config.dimensions);
+            // Squared gradient proxy: embedding scaled by confidence change magnitude
+            for (let i = 0; i < len; i++) {
+                const grad = change.embedding[i] * confDelta;
+                currentFisher[i] += grad * grad;
+            }
+        }
+        if (sampleCount > 0) {
+            for (let i = 0; i < this.config.dimensions; i++) {
+                currentFisher[i] /= sampleCount;
+            }
+        }
+        // Online EMA: F_new = alpha * F_old + (1-alpha) * F_current
+        for (let i = 0; i < this.config.dimensions; i++) {
+            this.globalFisher[i] = alpha * this.globalFisher[i] + (1 - alpha) * currentFisher[i];
+        }
+        this.saveToDisk();
+    }
+    /**
+     * Compute consolidation penalty for a proposed confidence update.
+     * Used by SONA to check whether a pattern update would cause forgetting.
+     *
+     * @param oldConfidence - Current confidence value
+     * @param newConfidence - Proposed new confidence value
+     * @returns Penalty value (higher = more forgetting risk)
+     */
+    computeConfidencePenalty(oldConfidence, newConfidence) {
+        // Use the global Fisher to estimate penalty for scalar confidence change
+        // Average Fisher value represents overall importance
+        let avgFisher = 0;
+        for (let i = 0; i < this.globalFisher.length; i++) {
+            avgFisher += this.globalFisher[i];
+        }
+        avgFisher = this.globalFisher.length > 0 ? avgFisher / this.globalFisher.length : 0;
+        const diff = newConfidence - oldConfidence;
+        return (this.config.lambda / 2) * avgFisher * diff * diff;
+    }
     /**
      * Clear all patterns and history (full reset)
      */

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

@@ -76,6 +76,7 @@ declare class LocalSonaCoordinator {
     private signalCount;
     private trajectories;
     private adaptationTimes;
+    private currentTrajectorySteps;
     constructor(config: SonaConfig);
     /**
      * Record a signal - O(1) operation
@@ -98,6 +99,37 @@ declare class LocalSonaCoordinator {
      * Get average adaptation time
      */
     getAvgAdaptationTime(): number;
+    /**
+     * Add a step to the current in-progress trajectory
+     */
+    addTrajectoryStep(step: TrajectoryStep): void;
+    /**
+     * End the current trajectory with a verdict and apply RL updates.
+     * Reward mapping: success=1.0, partial=0.5, failure=-0.5
+     *
+     * For successful/partial trajectories, boosts confidence of similar patterns
+     * in the ReasoningBank. For failures, reduces confidence scores.
+     */
+    endTrajectory(verdict: 'success' | 'failure' | 'partial', bank: LocalReasoningBank): Promise<{
+        reward: number;
+        patternsUpdated: number;
+    }>;
+    /**
+     * Distill learning from recent successful trajectories.
+     * Applies LoRA-style confidence updates and integrates EWC++ consolidation.
+     *
+     * For each successful trajectory step with high confidence,
+     * increases the pattern's stored confidence by loraLearningRate * reward.
+     * Before applying updates, checks EWC penalty to prevent catastrophic forgetting.
+     */
+    distillLearning(bank: LocalReasoningBank): Promise<{
+        patternsDistilled: number;
+        ewcPenalty: number;
+    }>;
+    /**
+     * Get current trajectory steps (for inspection)
+     */
+    getCurrentTrajectorySteps(): TrajectoryStep[];
     /**
      * Get statistics
      */
@@ -221,6 +253,27 @@ export declare function getSonaCoordinator(): LocalSonaCoordinator | null;
  * Get ReasoningBank for advanced operations
  */
 export declare function getReasoningBank(): LocalReasoningBank | null;
+/**
+ * End the current trajectory with a verdict and apply RL updates.
+ * This is the public API for the SONA RL loop.
+ *
+ * @param verdict - 'success' (reward=1.0), 'partial' (0.5), or 'failure' (-0.5)
+ * @returns Update statistics or null if not initialized
+ */
+export declare function endTrajectoryWithVerdict(verdict: 'success' | 'failure' | 'partial'): Promise<{
+    reward: number;
+    patternsUpdated: number;
+} | null>;
+/**
+ * Distill learning from recent successful trajectories.
+ * Applies LoRA-style confidence updates with EWC++ consolidation protection.
+ *
+ * @returns Distillation statistics or null if not initialized
+ */
+export declare function distillLearning(): Promise<{
+    patternsDistilled: number;
+    ewcPenalty: number;
+} | null>;
 /**
  * Clear intelligence state
  */