claude-flow 3.6.13 → 3.6.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.13",
+  "version": "3.6.14",
   "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.js

@@ -121,13 +121,43 @@ export const agentdbPatternStore = {
             const pattern = validateString(params.pattern, 'pattern');
             if (!pattern)
                 return { success: false, error: 'pattern is required (non-empty string, max 100KB)' };
+            const type = validateString(params.type, 'type', 200) ?? 'general';
+            const confidence = validateScore(params.confidence, 0.8);
             const bridge = await getBridge();
-            const result = await bridge.bridgeStorePattern({
-                pattern,
-                type: validateString(params.type, 'type', 200) ?? 'general',
-                confidence: validateScore(params.confidence, 0.8),
-            });
-            return result ?? { success: false, error: 'AgentDB bridge not available. Use memory_store/memory_search instead.' };
+            const result = await bridge.bridgeStorePattern({ pattern, type, confidence });
+            if (result)
+                return result;
+            // ADR-093 F4: when the ReasoningBank controller registry returns
+            // null (the cause of audit-reported "AgentDB bridge not available"
+            // even though `agentdb_health.reasoningBank.enabled === true`), fall
+            // back to a direct memory_store write so the caller's pattern still
+            // persists. Surface the controller as `memory-store-fallback` so the
+            // path is observable instead of silently lost.
+            try {
+                const { storeEntry } = await import('../memory/memory-initializer.js');
+                const patternId = `pattern-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const value = JSON.stringify({ pattern, type, confidence, _fallback: 'reasoningBank-unavailable' });
+                await storeEntry({
+                    key: patternId,
+                    value,
+                    namespace: 'pattern',
+                    tags: [type, 'reasoning-pattern', 'fallback'],
+                });
+                return {
+                    success: true,
+                    patternId,
+                    controller: 'memory-store-fallback',
+                    note: 'ReasoningBank controller registry unavailable. Pattern persisted via memory_store. Run `agentdb_health` to inspect controller registration.',
+                };
+            }
+            catch (fallbackErr) {
+                return {
+                    success: false,
+                    error: 'Pattern store failed: both ReasoningBank bridge and memory_store fallback unavailable',
+                    fallbackError: sanitizeError(fallbackErr),
+                    recommendation: 'Run agentdb_health to inspect controller registration and check that .swarm/memory.db is writable.',
+                };
+            }
         }
         catch (error) {
             return { success: false, error: sanitizeError(error) };

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

@@ -224,30 +224,35 @@ export const configTools = [
             const scope = input.scope || 'default';
             const prefix = input.prefix;
             const includeDefaults = input.includeDefaults !== false;
-            // Merge stored values with defaults
-            let configs = {};
+            const merged = new Map();
             if (includeDefaults) {
-                configs = { ...DEFAULT_CONFIG };
+                for (const [key, value] of Object.entries(DEFAULT_CONFIG)) {
+                    merged.set(key, { value, source: 'default' });
+                }
             }
-            // Add stored values
-            Object.assign(configs, store.values);
-            // Add scope-specific values
-            if (scope !== 'default' && store.scopes[scope]) {
-                Object.assign(configs, store.scopes[scope]);
+            for (const [key, value] of Object.entries(store.values)) {
+                merged.set(key, { value, source: 'stored' });
+            }
+            // Always include keys from every scope so they're discoverable; the
+            // scope filter only narrows which set is used as the *winner*.
+            for (const [scopeName, scopeValues] of Object.entries(store.scopes)) {
+                for (const [key, value] of Object.entries(scopeValues)) {
+                    if (scope === scopeName || scope === 'default') {
+                        merged.set(key, { value, source: `scope:${scopeName}` });
+                    }
+                    else if (!merged.has(key)) {
+                        // Surface scoped keys that aren't shadowed when listing default scope
+                        merged.set(key, { value, source: `scope:${scopeName}` });
+                    }
+                }
             }
-            // Filter by prefix
-            let entries = Object.entries(configs);
+            let entries = Array.from(merged.entries());
             if (prefix) {
                 entries = entries.filter(([key]) => key.startsWith(prefix));
             }
-            // Sort by key
             entries.sort(([a], [b]) => a.localeCompare(b));
             return {
-                configs: entries.map(([key, value]) => ({
-                    key,
-                    value,
-                    source: store.values[key] !== undefined ? 'stored' : 'default',
-                })),
+                configs: entries.map(([key, { value, source }]) => ({ key, value, source })),
                 total: entries.length,
                 scope,
                 updatedAt: store.updatedAt,

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

@@ -777,6 +777,24 @@ export const embeddingsTools = [
                     message: 'Embeddings not initialized. Run embeddings/init first.',
                 };
             }
+            // ADR-093 F5: distinguish "@ruvector/core installed" from "wired into
+            // the embedding pipeline". Previously this collapsed both into a
+            // single `ruvector: boolean` field, which gave callers no way to
+            // tell whether re-running embeddings_init would help (#1698 partial
+            // regression on the MCP boundary).
+            let ruvectorAvailable = false;
+            let ruvectorVersion;
+            try {
+                const mod = await import('@ruvector/core');
+                ruvectorAvailable = !!mod;
+                try {
+                    // Best-effort: many packages expose a `version` constant
+                    ruvectorVersion = mod.version;
+                }
+                catch { /* ignore */ }
+            }
+            catch { /* not installed */ }
+            const ruvectorEnabled = config.neural.ruvector?.enabled ?? false;
             return {
                 success: true,
                 initialized: true,
@@ -787,7 +805,16 @@ export const embeddingsTools = [
                     hyperbolic: config.hyperbolic,
                     neural: {
                         enabled: config.neural.enabled,
-                        ruvector: config.neural.ruvector?.enabled ?? false,
+                        // Backwards-compatible: keep the boolean view (truthy when wired).
+                        ruvector: ruvectorEnabled,
+                        // New shape — additive, non-breaking. Callers that need to
+                        // distinguish "package is installed" from "feature wired in"
+                        // read these instead of guessing from a single bool.
+                        ruvectorStatus: {
+                            available: ruvectorAvailable,
+                            enabled: ruvectorEnabled,
+                            version: ruvectorVersion,
+                        },
                     },
                 },
                 paths: {

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

@@ -218,6 +218,14 @@ export const hiveMindTools = [
             type: 'object',
             properties: {
                 topology: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star'], description: 'Network topology' },
+                // ADR-093 F3: schema now exposes the consensus strategy so callers
+                // can actually request raft / byzantine / quorum / etc. Default
+                // matches the documented anti-drift posture (raft).
+                consensus: {
+                    type: 'string',
+                    enum: ['raft', 'byzantine', 'gossip', 'crdt', 'quorum'],
+                    description: 'Consensus strategy. Default: raft (anti-drift). Use byzantine for f<n/3 fault tolerance.',
+                },
                 queenId: { type: 'string', description: 'Initial queen agent ID' },
             },
         },
@@ -230,8 +238,10 @@ export const hiveMindTools = [
             const state = loadHiveState();
             const hiveId = `hive-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
             const queenId = input.queenId || `queen-${Date.now()}`;
+            const requestedConsensus = input.consensus || 'raft';
             state.initialized = true;
             state.topology = input.topology || 'mesh';
+            state.consensusStrategy = requestedConsensus;
             state.createdAt = new Date().toISOString();
             state.queen = {
                 agentId: queenId,
@@ -243,12 +253,12 @@ export const hiveMindTools = [
                 success: true,
                 hiveId,
                 topology: state.topology,
-                consensus: input.consensus || 'byzantine',
+                consensus: state.consensusStrategy,
                 queenId,
                 status: 'initialized',
                 config: {
                     topology: state.topology,
-                    consensus: input.consensus || 'byzantine',
+                    consensus: state.consensusStrategy,
                     maxAgents: input.maxAgents || 15,
                     persist: input.persist !== false,
                     memoryBackend: input.memoryBackend || 'hybrid',
@@ -298,7 +308,8 @@ export const hiveMindTools = [
                 hiveId: `hive-${state.createdAt ? new Date(state.createdAt).getTime() : Date.now()}`,
                 status: state.initialized ? 'active' : 'offline',
                 topology: state.topology,
-                consensus: 'byzantine', // Default consensus type
+                // ADR-093 F3: surface the persisted strategy instead of a hardcoded "byzantine".
+                consensus: state.consensusStrategy ?? 'byzantine',
                 queen: state.queen ? {
                     id: state.queen.agentId,
                     agentId: state.queen.agentId,

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

@@ -945,44 +945,55 @@ export const hooksMetrics = {
     },
     handler: async (params) => {
         const period = params.period || '24h';
-        // Try to read real counts from memory store
-        const store = loadMemoryStore();
-        const entries = Object.values(store.entries);
-        // Count patterns by looking at stored pattern entries
-        const patternEntries = entries.filter(e => e.key.includes('pattern'));
-        const routingEntries = entries.filter(e => e.key.includes('route') || e.key.includes('routing'));
-        const taskEntries = entries.filter(e => e.key.includes('task'));
-        if (entries.length === 0) {
-            return {
-                _real: true,
-                _note: 'No metrics data collected yet. Data populates from hooks_post-task, hooks_post-edit, hooks_post-command, and hooks_route calls.',
-                period,
-                patterns: { total: 0, successful: 0, failed: 0, avgConfidence: null },
-                agents: { routingAccuracy: null, totalRoutes: 0, topAgent: null },
-                commands: { totalExecuted: 0, successRate: null, avgRiskScore: null },
-                lastUpdated: new Date().toISOString(),
-            };
-        }
+        // ADR-093 F1: read from the same trajectory/pattern store that
+        // hooks_post-task and hooks_intelligence_stats write to. Previously
+        // this handler key-substring-filtered the memory store for "pattern",
+        // "route", "task" — none of which match the trajectory keys that
+        // post-task actually writes — so counters stayed at 0 forever (#1686).
+        const stats = getIntelligenceStatsFromMemory();
+        // Routing outcomes are persisted to a separate file (loadRoutingOutcomes)
+        // by post-task; surface them so the dashboard sees command counters too.
+        let routingOutcomes = [];
+        try {
+            routingOutcomes = loadRoutingOutcomes();
+        }
+        catch { /* non-fatal */ }
+        const totalCommands = routingOutcomes.length;
+        const successfulCommands = routingOutcomes.filter(o => o.success).length;
+        const successRate = totalCommands > 0 ? successfulCommands / totalCommands : null;
+        // Compute top agent from routing outcomes
+        const agentCounts = {};
+        for (const o of routingOutcomes) {
+            if (o.agent)
+                agentCounts[o.agent] = (agentCounts[o.agent] || 0) + 1;
+        }
+        const topAgent = Object.entries(agentCounts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+        const successful = stats.trajectories.successful;
+        const total = stats.trajectories.total;
+        const failed = Math.max(0, total - successful);
         return {
+            _real: true,
+            _dataSource: 'intelligence-stats + routing-outcomes',
             period,
             patterns: {
-                total: patternEntries.length,
-                successful: null,
-                failed: null,
-                avgConfidence: null,
+                total: stats.patterns.learned,
+                successful,
+                failed,
+                avgConfidence: stats.routing.avgConfidence || null,
             },
             agents: {
-                routingAccuracy: null,
-                totalRoutes: routingEntries.length,
-                topAgent: null,
+                routingAccuracy: stats.routing.avgConfidence || null,
+                totalRoutes: stats.routing.decisions,
+                topAgent,
             },
             commands: {
-                totalExecuted: taskEntries.length,
-                successRate: null,
+                totalExecuted: totalCommands,
+                successRate,
                 avgRiskScore: null,
             },
-            dataSource: 'memory-store',
-            entriesFound: entries.length,
+            _note: total === 0 && totalCommands === 0
+                ? 'No metrics data collected yet. Run hooks_post-task / hooks_intelligence_trajectory-end / hooks_route to populate.'
+                : undefined,
             lastUpdated: new Date().toISOString(),
         };
     },
@@ -3325,21 +3336,61 @@ export const hooksWorkerDispatch = {
         }
         const workerId = `worker_${trigger}_${++workerIdCounter}_${Date.now().toString(36)}`;
         const config = WORKER_CONFIGS[trigger];
+        // ADR-093 F2: stop returning status:"completed" for a worker that
+        // never ran (#1700 item 1). Detect daemon presence via PID file and
+        // surface honest verdicts (`no-daemon` / `queued` / `synthetic`).
+        const cwd = getProjectCwd();
+        const pidFile = join(cwd, '.claude-flow', 'daemon.pid');
+        let daemonPid = null;
+        let daemonAlive = false;
+        if (existsSync(pidFile)) {
+            try {
+                const raw = readFileSync(pidFile, 'utf-8').trim();
+                const pid = parseInt(raw, 10);
+                if (Number.isFinite(pid) && pid > 0) {
+                    daemonPid = pid;
+                    try {
+                        process.kill(pid, 0);
+                        daemonAlive = true;
+                    }
+                    catch {
+                        daemonAlive = false;
+                    }
+                }
+            }
+            catch { /* unreadable PID file */ }
+        }
         const worker = {
             id: workerId,
             trigger,
             context,
-            status: 'running',
+            status: daemonAlive ? 'pending' : 'pending',
             progress: 0,
             phase: 'initializing',
             startedAt: new Date(),
         };
         activeWorkers.set(workerId, worker);
-        if (!background) {
+        // Determine honest status
+        let reportedStatus;
+        let note;
+        if (!daemonAlive) {
+            reportedStatus = 'no-daemon';
+            note = 'No worker daemon detected. Run `claude-flow daemon start` to enable real worker execution. The dispatch was recorded in-process but no actual work will run.';
+        }
+        else if (background) {
+            // Daemon is alive — record the queued worker. The daemon polls activeWorkers
+            // via its own state file, so this constitutes a real queue entry.
+            reportedStatus = 'queued';
+            note = `Worker queued for daemon (pid ${daemonPid}). Poll hooks_worker-status to track progression — do not assume completion until status === "completed".`;
+        }
+        else {
+            // Synchronous mode without a runner — be honest about it
+            reportedStatus = 'synthetic-completed';
             worker.progress = 100;
             worker.phase = 'completed';
             worker.status = 'completed';
             worker.completedAt = new Date();
+            note = 'Synchronous mode: worker record marked completed but no real work executed (no in-process runner). Use background:true with the daemon for real execution.';
         }
         return {
             success: true,
@@ -3352,9 +3403,11 @@ export const hooksWorkerDispatch = {
                 estimatedDuration: config.estimatedDuration,
                 capabilities: config.capabilities,
             },
-            status: background ? 'scheduled' : 'completed',
+            status: reportedStatus,
+            daemonAlive,
+            daemonPid: daemonAlive ? daemonPid : null,
             background,
-            note: background ? 'Worker scheduled. Use hooks_worker-status to check progress. Start the daemon (daemon start) for real background execution.' : undefined,
+            note,
             timestamp: new Date().toISOString(),
         };
     },

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

@@ -260,29 +260,43 @@ export const sessionTools = [
             },
         },
         handler: async (input) => {
-            let sessions = listSessions();
+            const raw = listSessions();
+            let sessions = raw.map((s) => ({
+                ...s,
+                sessionId: s.sessionId || s.id || 'unknown',
+                savedAt: s.savedAt || s.startedAt || '',
+            }));
             // Sort
             const sortBy = input.sortBy || 'date';
             if (sortBy === 'date') {
-                sessions.sort((a, b) => new Date(b.savedAt).getTime() - new Date(a.savedAt).getTime());
+                sessions.sort((a, b) => new Date(String(b.savedAt || '')).getTime() - new Date(String(a.savedAt || '')).getTime());
             }
             else if (sortBy === 'name') {
-                sessions.sort((a, b) => a.name.localeCompare(b.name));
+                sessions.sort((a, b) => String(a.name || a.sessionId || '').localeCompare(String(b.name || b.sessionId || '')));
             }
             else if (sortBy === 'size') {
-                sessions.sort((a, b) => b.stats.totalSize - a.stats.totalSize);
+                sessions.sort((a, b) => (b.stats?.totalSize ?? 0) - (a.stats?.totalSize ?? 0));
             }
             // Apply limit
             const limit = input.limit || 10;
             sessions = sessions.slice(0, limit);
             return {
-                sessions: sessions.map(s => ({
-                    sessionId: s.sessionId,
-                    name: s.name,
-                    description: s.description,
-                    savedAt: s.savedAt,
-                    stats: s.stats,
-                })),
+                sessions: sessions.map(s => {
+                    // Project to a stable shape; pull through either source's metadata.
+                    const projection = {
+                        sessionId: s.sessionId,
+                        name: s.name ?? s.sessionId,
+                        description: s.description,
+                        savedAt: s.savedAt,
+                        stats: s.stats ?? null,
+                    };
+                    // Preserve auto-session shape fields when present
+                    if (s.platform)
+                        projection.platform = s.platform;
+                    if (s.metrics)
+                        projection.metrics = s.metrics;
+                    return projection;
+                }),
                 total: sessions.length,
                 limit,
             };

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.6.13",
+  "version": "3.6.14",
   "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",