claude-flow 3.7.0-alpha.6 → 3.7.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.7.0-alpha.6",
+  "version": "3.7.0-alpha.8",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/mcp-tools/agentdb-tools.d.ts

@@ -26,5 +26,8 @@ export declare const agentdbConsolidate: MCPTool;
 export declare const agentdbBatch: MCPTool;
 export declare const agentdbContextSynthesize: MCPTool;
 export declare const agentdbSemanticRoute: MCPTool;
+export declare const agentdbHierarchicalDelete: MCPTool;
+export declare const agentdbCausalEdgeDelete: MCPTool;
+export declare const agentdbCausalNodeDelete: MCPTool;
 export declare const agentdbTools: MCPTool[];
 //# sourceMappingURL=agentdb-tools.d.ts.map

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

@@ -661,6 +661,111 @@ export const agentdbSemanticRoute = {
         }
     },
 };
+// ===== #1784: Delete tools — symmetry for hierarchical-store + causal-edge =====
+export const agentdbHierarchicalDelete = {
+    name: 'agentdb_hierarchical-delete',
+    description: 'Delete a hierarchical-memory entry by key. Returns controller="native-unsupported" when the entry is in a backend without a public delete API.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'Memory entry key to delete' },
+            tier: {
+                type: 'string',
+                description: 'Optional tier filter (working, episodic, semantic)',
+                enum: ['working', 'episodic', 'semantic'],
+            },
+        },
+        required: ['key'],
+    },
+    handler: async (params) => {
+        try {
+            const vKey = validateIdentifier(params.key, 'key');
+            if (!vKey.valid)
+                return { success: false, deleted: false, error: vKey.error };
+            if (params.tier) {
+                const vTier = validateIdentifier(params.tier, 'tier');
+                if (!vTier.valid)
+                    return { success: false, deleted: false, error: vTier.error };
+            }
+            const key = validateString(params.key, 'key', 1000);
+            if (!key)
+                return { success: false, deleted: false, error: 'key is required (non-empty string, max 1KB)' };
+            const tier = validateString(params.tier, 'tier', 20);
+            if (tier && !['working', 'episodic', 'semantic'].includes(tier)) {
+                return { success: false, deleted: false, error: `Invalid tier: ${tier}. Must be working, episodic, or semantic` };
+            }
+            const bridge = await getBridge();
+            const result = await bridge.bridgeDeleteHierarchical({ key, tier: tier ?? undefined });
+            return result ?? { success: false, deleted: false, error: 'AgentDB bridge not available' };
+        }
+        catch (error) {
+            return { success: false, deleted: false, error: sanitizeError(error) };
+        }
+    },
+};
+export const agentdbCausalEdgeDelete = {
+    name: 'agentdb_causal-edge-delete',
+    description: 'Delete a causal edge between two memory entries. Returns controller="native-unsupported" when the edge lives in graph-node native storage (no public delete API).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sourceId: { type: 'string', description: 'Source entry ID' },
+            targetId: { type: 'string', description: 'Target entry ID' },
+            relation: { type: 'string', description: 'Optional relationship type filter' },
+        },
+        required: ['sourceId', 'targetId'],
+    },
+    handler: async (params) => {
+        try {
+            const vSourceId = validateIdentifier(params.sourceId, 'sourceId');
+            if (!vSourceId.valid)
+                return { success: false, deleted: false, error: vSourceId.error };
+            const vTargetId = validateIdentifier(params.targetId, 'targetId');
+            if (!vTargetId.valid)
+                return { success: false, deleted: false, error: vTargetId.error };
+            const sourceId = validateString(params.sourceId, 'sourceId', 500);
+            const targetId = validateString(params.targetId, 'targetId', 500);
+            if (!sourceId)
+                return { success: false, deleted: false, error: 'sourceId is required (non-empty string)' };
+            if (!targetId)
+                return { success: false, deleted: false, error: 'targetId is required (non-empty string)' };
+            const relation = validateString(params.relation, 'relation', 200) ?? undefined;
+            const bridge = await getBridge();
+            const result = await bridge.bridgeDeleteCausalEdge({ sourceId, targetId, relation });
+            return result ?? { success: false, deleted: false, error: 'AgentDB bridge not available' };
+        }
+        catch (error) {
+            return { success: false, deleted: false, error: sanitizeError(error) };
+        }
+    },
+};
+export const agentdbCausalNodeDelete = {
+    name: 'agentdb_causal-node-delete',
+    description: 'Cascade-delete a causal node and all its incident edges from the SQL fallback. Native graph-node entries are unaffected (no delete API in the binding).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            nodeId: { type: 'string', description: 'Node ID to delete (cascades to all incident edges)' },
+        },
+        required: ['nodeId'],
+    },
+    handler: async (params) => {
+        try {
+            const vNodeId = validateIdentifier(params.nodeId, 'nodeId');
+            if (!vNodeId.valid)
+                return { success: false, deletedNode: false, deletedEdges: 0, error: vNodeId.error };
+            const nodeId = validateString(params.nodeId, 'nodeId', 500);
+            if (!nodeId)
+                return { success: false, deletedNode: false, deletedEdges: 0, error: 'nodeId is required (non-empty string)' };
+            const bridge = await getBridge();
+            const result = await bridge.bridgeDeleteCausalNode({ nodeId });
+            return result ?? { success: false, deletedNode: false, deletedEdges: 0, error: 'AgentDB bridge not available' };
+        }
+        catch (error) {
+            return { success: false, deletedNode: false, deletedEdges: 0, error: sanitizeError(error) };
+        }
+    },
+};
 // ===== Export all tools =====
 export const agentdbTools = [
     agentdbHealth,
@@ -669,11 +774,14 @@ export const agentdbTools = [
     agentdbPatternSearch,
     agentdbFeedback,
     agentdbCausalEdge,
+    agentdbCausalEdgeDelete,
+    agentdbCausalNodeDelete,
     agentdbRoute,
     agentdbSessionStart,
     agentdbSessionEnd,
     agentdbHierarchicalStore,
     agentdbHierarchicalRecall,
+    agentdbHierarchicalDelete,
     agentdbConsolidate,
     agentdbBatch,
     agentdbContextSynthesize,

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

@@ -66,11 +66,12 @@ async function getEWCConsolidator() {
     return ewcConsolidator;
 }
 // MoE Router - lazy loaded
+// #1773 item 4 — moe-router migrated to @claude-flow/neural
 let moeRouter = null;
 async function getMoERouter() {
     if (!moeRouter) {
         try {
-            const { getMoERouter: getMoE } = await import('../ruvector/moe-router.js');
+            const { getMoERouter: getMoE } = await import('@claude-flow/neural');
             moeRouter = await getMoE();
         }
         catch {
@@ -336,11 +337,12 @@ function getRouterBackendInfo() {
     }
 }
 // Flash Attention - lazy loaded
+// #1773 item 4 — flash-attention migrated to @claude-flow/neural
 let flashAttention = null;
 async function getFlashAttention() {
     if (!flashAttention) {
         try {
-            const { getFlashAttention: getFlash } = await import('../ruvector/flash-attention.js');
+            const { getFlashAttention: getFlash } = await import('@claude-flow/neural');
             flashAttention = await getFlash();
         }
         catch {

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

@@ -668,7 +668,8 @@ export const neuralTools = [
                     // The two surfaces now agree on a single source of truth.
                     flashAttention: await (async () => {
                         try {
-                            const { getFlashAttention } = await import('../ruvector/flash-attention.js');
+                            // #1773 item 4 — flash-attention now lives in @claude-flow/neural
+                            const { getFlashAttention } = await import('@claude-flow/neural');
                             return getFlashAttention() !== null;
                         }
                         catch {

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

@@ -278,6 +278,75 @@ export declare function bridgeRecordCausalEdge(options: {
     success: boolean;
     controller: string;
 } | null>;
+/**
+ * Delete a hierarchical-memory entry by key (#1784).
+ *
+ * Reality check: agentdb's HierarchicalMemory class doesn't expose a public
+ * delete API today, so the real-backend path falls back to direct SQL on
+ * the underlying SQLite tables (status flip to 'deleted' + AttestationLog
+ * audit). The bridge-fallback path that bridgeHierarchicalStore uses when
+ * HierarchicalMemory isn't loaded writes plain memory_entries rows that
+ * `bridgeDeleteEntry` already handles.
+ *
+ * Returns { controller: 'native-unsupported' } when the real HM is loaded
+ * and the SQL fallback can't reach its private tables — surfacing the
+ * limitation honestly instead of silently returning success.
+ */
+export declare function bridgeDeleteHierarchical(options: {
+    key: string;
+    tier?: string;
+    dbPath?: string;
+}): Promise<{
+    success: boolean;
+    deleted: boolean;
+    key: string;
+    tier?: string;
+    controller: string;
+    guarded?: boolean;
+    error?: string;
+} | null>;
+/**
+ * Delete a causal edge between two memory entries (#1784).
+ *
+ * The bridge stores fallback edges in namespace='causal-edges' with key
+ * '{sourceId}→{targetId}'. Those CAN be soft-deleted. The native graph-node
+ * backend has no delete API (createNode/createEdge/createHyperedge only),
+ * so an edge that landed in graph-node native storage stays there. We
+ * surface that explicitly via controller: 'native-unsupported'.
+ */
+export declare function bridgeDeleteCausalEdge(options: {
+    sourceId: string;
+    targetId: string;
+    relation?: string;
+    dbPath?: string;
+}): Promise<{
+    success: boolean;
+    deleted: boolean;
+    sourceId: string;
+    targetId: string;
+    controller: string;
+    guarded?: boolean;
+    error?: string;
+} | null>;
+/**
+ * Cascade-delete a causal node and all its incident edges (#1784).
+ *
+ * Same constraint as bridgeDeleteCausalEdge — native graph-node lacks a
+ * delete API. SQL fallback path soft-deletes the node (if stored as a
+ * memory_entries row) and every edge whose key contains the nodeId.
+ */
+export declare function bridgeDeleteCausalNode(options: {
+    nodeId: string;
+    dbPath?: string;
+}): Promise<{
+    success: boolean;
+    deletedNode: boolean;
+    deletedEdges: number;
+    nodeId: string;
+    controller: string;
+    guarded?: boolean;
+    error?: string;
+} | null>;
 /**
  * Start a session with ReflexionMemory episodic replay.
  * Loads relevant past session patterns for the new session.

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

@@ -1354,6 +1354,259 @@ export async function bridgeRecordCausalEdge(options) {
         return null;
     }
 }
+// ===== #1784: Delete tools for hierarchical + causal-graph =====
+/**
+ * Delete a hierarchical-memory entry by key (#1784).
+ *
+ * Reality check: agentdb's HierarchicalMemory class doesn't expose a public
+ * delete API today, so the real-backend path falls back to direct SQL on
+ * the underlying SQLite tables (status flip to 'deleted' + AttestationLog
+ * audit). The bridge-fallback path that bridgeHierarchicalStore uses when
+ * HierarchicalMemory isn't loaded writes plain memory_entries rows that
+ * `bridgeDeleteEntry` already handles.
+ *
+ * Returns { controller: 'native-unsupported' } when the real HM is loaded
+ * and the SQL fallback can't reach its private tables — surfacing the
+ * limitation honestly instead of silently returning success.
+ */
+export async function bridgeDeleteHierarchical(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const { key, tier } = options;
+        // MutationGuard validation
+        const guardResult = await guardValidate(registry, 'delete', { key, namespace: 'hierarchical' });
+        if (!guardResult.allowed) {
+            return { success: false, deleted: false, key, tier, controller: 'guard', error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        const hm = registry.get('hierarchicalMemory');
+        // 1. agentdb@3.0.0-alpha.13+: ReflexionMemory.deleteEpisode propagates through
+        //    graph adapter / generic graph backend / vector backend AND purges SQL
+        //    episodes + episode_embeddings rows. Single call, durably consistent.
+        //    See agentic-flow#150/#151 (closes ruvnet/RuVector#427 the cli-visible way).
+        const reflexion = registry.get('reflexionMemory');
+        if (reflexion && typeof reflexion.deleteEpisode === 'function') {
+            try {
+                const removed = await reflexion.deleteEpisode(key);
+                if (removed) {
+                    await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                    return { success: true, deleted: true, key, tier, controller: 'reflexionMemory', guarded: true };
+                }
+            }
+            catch { /* fall through */ }
+        }
+        // 2. Try HierarchicalMemory's own delete API if it ever ships one.
+        if (hm && typeof hm.delete === 'function') {
+            try {
+                await hm.delete(key);
+                await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                return { success: true, deleted: true, key, tier, controller: 'hierarchicalMemory', guarded: true };
+            }
+            catch (err) {
+                // Fall through to SQL fallback
+            }
+        }
+        // 3. Stub HierarchicalMemory may expose `remove` or `forget`
+        if (hm && typeof hm.remove === 'function') {
+            try {
+                await hm.remove(key);
+                await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                return { success: true, deleted: true, key, tier, controller: 'hierarchicalMemory-stub', guarded: true };
+            }
+            catch { /* fall through */ }
+        }
+        // 3. Bridge-fallback: HM stored to memory_entries with namespace prefix
+        //    (used when the real controller isn't loaded). Soft-delete via SQL.
+        const ctx = getDb(registry);
+        if (ctx) {
+            try {
+                const result = ctx.db.prepare(`
+          UPDATE memory_entries
+          SET status = 'deleted', updated_at = ?
+          WHERE key = ? AND namespace LIKE 'hierarchical%' AND status = 'active'
+        `).run(Date.now(), key);
+                const changes = result?.changes ?? 0;
+                if (changes > 0) {
+                    await logAttestation(registry, 'delete', key, { namespace: 'hierarchical', tier });
+                    return { success: true, deleted: true, key, tier, controller: 'bridge-fallback', guarded: true };
+                }
+                // Nothing to delete in SQL fallback — and no real-HM delete API.
+                // Surface the situation honestly.
+                return {
+                    success: false, deleted: false, key, tier,
+                    controller: hm ? 'native-unsupported' : 'not-found',
+                    error: hm
+                        ? 'HierarchicalMemory has no public delete API; entry remains in native storage'
+                        : 'No hierarchical entry found with this key',
+                };
+            }
+            catch (err) {
+                return { success: false, deleted: false, key, tier, controller: 'sql-error', error: err.message };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Delete a causal edge between two memory entries (#1784).
+ *
+ * The bridge stores fallback edges in namespace='causal-edges' with key
+ * '{sourceId}→{targetId}'. Those CAN be soft-deleted. The native graph-node
+ * backend has no delete API (createNode/createEdge/createHyperedge only),
+ * so an edge that landed in graph-node native storage stays there. We
+ * surface that explicitly via controller: 'native-unsupported'.
+ */
+export async function bridgeDeleteCausalEdge(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const { sourceId, targetId, relation } = options;
+        const edgeKey = `${sourceId}→${targetId}`;
+        const guardResult = await guardValidate(registry, 'delete', { key: edgeKey, namespace: 'causal-edges' });
+        if (!guardResult.allowed) {
+            return { success: false, deleted: false, sourceId, targetId, controller: 'guard', error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        const causalGraph = registry.get('causalGraph');
+        // 1. agentdb@3.0.0-alpha.13+: GraphDatabaseAdapter.deleteEdgesByEndpoints
+        //    handles the (sourceId, targetId, relation?) tuple case directly via
+        //    Cypher MATCH … DETACH DELETE. Cypher-injection-safe (label validated
+        //    against /^[A-Za-z_][A-Za-z0-9_]*$/ upstream).
+        if (causalGraph && typeof causalGraph.deleteEdgesByEndpoints === 'function') {
+            try {
+                const r = await causalGraph.deleteEdgesByEndpoints(sourceId, targetId, relation);
+                const deletedCount = typeof r === 'object' && r ? (r.deleted ?? 0) : (r ? 1 : 0);
+                if (deletedCount > 0) {
+                    await logAttestation(registry, 'delete', edgeKey, { namespace: 'causal-edges', relation, count: deletedCount });
+                    return { success: true, deleted: true, sourceId, targetId, controller: 'causalGraph-cypher', guarded: true };
+                }
+            }
+            catch { /* fall through */ }
+        }
+        // 2. Pre-alpha.13 / different controller: try removeEdge() if exposed.
+        if (causalGraph && typeof causalGraph.removeEdge === 'function') {
+            try {
+                await causalGraph.removeEdge(sourceId, targetId, relation);
+                await logAttestation(registry, 'delete', edgeKey, { namespace: 'causal-edges', relation });
+                return { success: true, deleted: true, sourceId, targetId, controller: 'causalGraph', guarded: true };
+            }
+            catch { /* fall through */ }
+        }
+        // 2. Bridge-fallback: soft-delete the memory_entries row.
+        const ctx = getDb(registry);
+        if (ctx) {
+            try {
+                const result = ctx.db.prepare(`
+          UPDATE memory_entries
+          SET status = 'deleted', updated_at = ?
+          WHERE key = ? AND namespace = 'causal-edges' AND status = 'active'
+        `).run(Date.now(), edgeKey);
+                const changes = result?.changes ?? 0;
+                if (changes > 0) {
+                    await logAttestation(registry, 'delete', edgeKey, { namespace: 'causal-edges', relation });
+                    return { success: true, deleted: true, sourceId, targetId, controller: 'bridge-fallback', guarded: true };
+                }
+                return {
+                    success: false, deleted: false, sourceId, targetId,
+                    controller: 'native-unsupported',
+                    error: 'graph-node native backend has no delete API; edge cannot be removed from native storage. SQL fallback found no matching row.',
+                };
+            }
+            catch (err) {
+                return { success: false, deleted: false, sourceId, targetId, controller: 'sql-error', error: err.message };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Cascade-delete a causal node and all its incident edges (#1784).
+ *
+ * Same constraint as bridgeDeleteCausalEdge — native graph-node lacks a
+ * delete API. SQL fallback path soft-deletes the node (if stored as a
+ * memory_entries row) and every edge whose key contains the nodeId.
+ */
+export async function bridgeDeleteCausalNode(options) {
+    const registry = await getRegistry(options.dbPath);
+    if (!registry)
+        return null;
+    try {
+        const { nodeId } = options;
+        const guardResult = await guardValidate(registry, 'delete', { key: nodeId, namespace: 'causal-nodes' });
+        if (!guardResult.allowed) {
+            return { success: false, deletedNode: false, deletedEdges: 0, nodeId, controller: 'guard', error: `MutationGuard rejected: ${guardResult.reason}` };
+        }
+        // 1. agentdb@3.0.0-alpha.13+: GraphDatabaseAdapter.deleteNode(id, {cascade})
+        //    counts incident edges before delete so we get accurate audit numbers
+        //    regardless of binding stats. Cypher MATCH (n {id}) DETACH DELETE n.
+        const causalGraph = registry.get('causalGraph');
+        if (causalGraph && typeof causalGraph.deleteNode === 'function') {
+            try {
+                const r = await causalGraph.deleteNode(nodeId, { cascade: true });
+                if (r && typeof r === 'object') {
+                    const deletedNodeNative = !!r.deletedNode;
+                    const deletedEdgesNative = typeof r.deletedEdges === 'number' ? r.deletedEdges : 0;
+                    await logAttestation(registry, 'delete', nodeId, { namespace: 'causal-nodes', deletedEdges: deletedEdgesNative });
+                    return {
+                        success: true,
+                        deletedNode: deletedNodeNative,
+                        deletedEdges: deletedEdgesNative,
+                        nodeId,
+                        controller: 'causalGraph-cypher',
+                        guarded: true,
+                    };
+                }
+            }
+            catch { /* fall through to SQL */ }
+        }
+        // 2. SQL fallback: soft-delete the node row + every causal-edges row whose
+        //    key contains nodeId on either side. Used when agentdb pre-alpha.13 OR
+        //    when the entry was stored via the bridge's SQL fallback path.
+        const ctx = getDb(registry);
+        if (!ctx)
+            return null;
+        let deletedEdges = 0;
+        let deletedNode = false;
+        try {
+            const edgeResult = ctx.db.prepare(`
+        UPDATE memory_entries
+        SET status = 'deleted', updated_at = ?
+        WHERE namespace = 'causal-edges'
+          AND status = 'active'
+          AND (key LIKE ? OR key LIKE ?)
+      `).run(Date.now(), `${nodeId}→%`, `%→${nodeId}`);
+            deletedEdges = edgeResult?.changes ?? 0;
+            const nodeResult = ctx.db.prepare(`
+        UPDATE memory_entries
+        SET status = 'deleted', updated_at = ?
+        WHERE key = ? AND status = 'active'
+      `).run(Date.now(), nodeId);
+            deletedNode = (nodeResult?.changes ?? 0) > 0;
+            await logAttestation(registry, 'delete', nodeId, { namespace: 'causal-nodes', deletedEdges });
+        }
+        catch (err) {
+            return { success: false, deletedNode: false, deletedEdges: 0, nodeId, controller: 'sql-error', error: err.message };
+        }
+        return {
+            success: true,
+            deletedNode,
+            deletedEdges,
+            nodeId,
+            controller: 'bridge-fallback',
+            guarded: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 // ===== Phase 5: ReflexionMemory session lifecycle =====
 /**
  * Start a session with ReflexionMemory episodic replay.

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

@@ -13,13 +13,11 @@
  * @module @claude-flow/cli/ruvector
  */
 export { QLearningRouter, createQLearningRouter, type QLearningRouterConfig, type RouteDecision } from './q-learning-router.js';
-export { MoERouter, getMoERouter, resetMoERouter, createMoERouter, EXPERT_NAMES, NUM_EXPERTS, INPUT_DIM, HIDDEN_DIM, type ExpertType, type MoERouterConfig, type RoutingResult, type LoadBalanceStats, } from './moe-router.js';
 export { ASTAnalyzer, createASTAnalyzer, type ASTAnalysis, type ASTNode, type ASTAnalyzerConfig } from './ast-analyzer.js';
 export { DiffClassifier, createDiffClassifier, analyzeDiff, analyzeDiffSync, assessFileRisk, assessOverallRisk, classifyDiff, suggestReviewers, getGitDiffNumstat, getGitDiffNumstatAsync, clearDiffCache, clearAllDiffCaches, type DiffClassification, type DiffHunk, type DiffChange, type FileDiff, type DiffAnalysis, type DiffClassifierConfig, type DiffFile, type RiskLevel, type FileRisk, type OverallRisk, type DiffAnalysisResult, } from './diff-classifier.js';
 export { CoverageRouter, createCoverageRouter, coverageRoute, coverageSuggest, coverageGaps, clearCoverageCache, getCoverageCacheStats, type CoverageRouterConfig, type FileCoverage, type CoverageReport, type CoverageRouteResult, type CoverageSuggestResult, type CoverageGapsResult, type CoverageRouteOptions, type CoverageSuggestOptions, type CoverageGapsOptions, } from './coverage-router.js';
 export { coverageRouterTools, hooksCoverageRoute, hooksCoverageSuggest, hooksCoverageGaps } from './coverage-tools.js';
 export { buildDependencyGraph, analyzeGraph, analyzeMinCutBoundaries, analyzeModuleCommunities, detectCircularDependencies, exportToDot, loadRuVector, fallbackMinCut, fallbackLouvain, clearGraphCaches, getGraphCacheStats, type GraphNode, type GraphEdge, type DependencyGraph, type MinCutBoundary, type ModuleCommunity, type CircularDependency, type GraphAnalysisResult, } from './graph-analyzer.js';
-export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttention, benchmarkFlashAttention, getFlashAttentionSpeedup, type FlashAttentionConfig, type AttentionResult, type BenchmarkResult, } from './flash-attention.js';
 export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, type LoRAConfig, type LoRAWeights, type AdaptationResult, type LoRAStats, } from './lora-adapter.js';
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, type ClaudeModel, type ModelRouterConfig, type ModelRoutingResult, type ComplexityAnalysis, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, type Intent, type RouteResult, type RouterConfig, } from './semantic-router.js';

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

@@ -13,7 +13,10 @@
  * @module @claude-flow/cli/ruvector
  */
 export { QLearningRouter, createQLearningRouter } from './q-learning-router.js';
-export { MoERouter, getMoERouter, resetMoERouter, createMoERouter, EXPERT_NAMES, NUM_EXPERTS, INPUT_DIM, HIDDEN_DIM, } from './moe-router.js';
+// #1773 item 4 — moe-router migrated to @claude-flow/neural. Direct
+// consumers (hooks-tools.ts) import from '@claude-flow/neural' explicitly;
+// re-exporting through this barrel would force vitest to resolve the
+// neural pkg's transitive @ruvector/sona dep eagerly. Keep imports direct.
 export { ASTAnalyzer, createASTAnalyzer } from './ast-analyzer.js';
 export { DiffClassifier, createDiffClassifier, 
 // MCP tool exports
@@ -29,7 +32,10 @@ export { coverageRouterTools, hooksCoverageRoute, hooksCoverageSuggest, hooksCov
 export { buildDependencyGraph, analyzeGraph, analyzeMinCutBoundaries, analyzeModuleCommunities, detectCircularDependencies, exportToDot, loadRuVector, fallbackMinCut, fallbackLouvain, 
 // Cache utilities (NEW)
 clearGraphCaches, getGraphCacheStats, } from './graph-analyzer.js';
-export { FlashAttention, getFlashAttention, resetFlashAttention, computeAttention, benchmarkFlashAttention, getFlashAttentionSpeedup, } from './flash-attention.js';
+// #1773 item 4 — flash-attention migrated to @claude-flow/neural. Direct
+// consumers (hooks-tools.ts, neural-tools.ts) import from '@claude-flow/neural'
+// explicitly; re-exporting through this barrel pulls the package's
+// transitive @ruvector/sona dep into vitest's eager resolution.
 export { LoRAAdapter, getLoRAAdapter, resetLoRAAdapter, createLoRAAdapter, adaptEmbedding, trainLoRA, getLoRAStats, DEFAULT_RANK, DEFAULT_ALPHA, INPUT_DIM as LORA_INPUT_DIM, OUTPUT_DIM as LORA_OUTPUT_DIM, } from './lora-adapter.js';
 export { ModelRouter, getModelRouter, resetModelRouter, createModelRouter, routeToModel, routeToModelFull, analyzeTaskComplexity, getModelRouterStats, recordModelOutcome, MODEL_CAPABILITIES, COMPLEXITY_INDICATORS, } from './model-router.js';
 export { SemanticRouter, createSemanticRouter, } from './semantic-router.js';

package/v3/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.7.0-alpha.6",
+  "version": "3.7.0-alpha.8",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -97,7 +97,7 @@
   "dependencies": {
     "@claude-flow/cli-core": "^3.7.0-alpha.5",
     "@claude-flow/mcp": "^3.0.0-alpha.8",
-    "@claude-flow/neural": "^3.0.0-alpha.7",
+    "@claude-flow/neural": "^3.0.0-alpha.8",
     "@claude-flow/shared": "^3.0.0-alpha.7",
     "@noble/ed25519": "^2.1.0",
     "@ruvector/rabitq-wasm": "^0.1.0",
@@ -119,7 +119,7 @@
     "@ruvector/ruvllm-wasm": "^2.0.2",
     "@ruvector/rvagent-wasm": "^0.1.0",
     "@ruvector/sona": "^0.1.5",
-    "agentdb": "^3.0.0-alpha.11",
+    "agentdb": "^3.0.0-alpha.13",
     "agentic-flow": "^3.0.0-alpha.1"
   },
   "publishConfig": {