claude-flow 3.6.13 → 3.6.15

package/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"36428a63-dfb2-42a4-a159-cf8be916193e","pid":86429,"procStart":"Sun May  3 19:17:47 2026","acquiredAt":1777840775529}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.6.13",
+  "version": "3.6.15",
   "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",
@@ -70,7 +70,18 @@
   },
   "overrides": {
     "hono": ">=4.11.4",
-    "@ruvector/rvf-wasm": "0.1.5"
+    "@ruvector/rvf-wasm": "0.1.5",
+    "@hono/node-server": ">=1.19.10",
+    "flatted": ">=3.4.0",
+    "tar": ">=7.5.0",
+    "picomatch": ">=4.0.3",
+    "path-to-regexp": ">=8.2.1",
+    "undici": ">=7.18.0",
+    "minimatch": ">=10.0.0",
+    "@isaacs/brace-expansion": ">=5.0.1",
+    "cacache": ">=20.0.0",
+    "make-fetch-happen": ">=15.0.0",
+    "express-rate-limit": ">=8.4.1"
   },
   "devDependencies": {
     "@openai/codex": "^0.98.0",

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/coordination-tools.js

@@ -634,15 +634,40 @@ export const coordinationTools = [
             const agents = input.agents || Object.keys(store.nodes);
             const strategy = input.strategy || 'parallel';
             const orchestrationId = `orch-${Date.now()}`;
+            // ADR-093 F7: this tool only schedules an orchestration record — it
+            // does not actually execute. Previously it returned a hardcoded
+            // `estimatedCompletion: "50ms"` which was misleading. Now we return
+            // an honest stub-status with a note pointing callers at agent_spawn
+            // / Task tool / hive-mind tools for real orchestration. Persist the
+            // record so callers can list/inspect what was scheduled.
+            const orchestration = {
+                id: orchestrationId,
+                task,
+                strategy,
+                agents,
+                status: 'scheduled',
+                scheduledAt: new Date().toISOString(),
+                topology: store.topology.type,
+            };
+            const orchStore = store;
+            if (!Array.isArray(orchStore.orchestrations))
+                orchStore.orchestrations = [];
+            orchStore.orchestrations.push(orchestration);
+            if (orchStore.orchestrations.length > 100) {
+                orchStore.orchestrations = orchStore.orchestrations.slice(-100);
+            }
+            saveCoordStore(orchStore);
             return {
                 success: true,
                 orchestrationId,
                 task,
                 strategy,
                 agents,
-                status: 'initiated',
+                status: 'scheduled',
                 topology: store.topology.type,
-                estimatedCompletion: `${agents.length * (strategy === 'sequential' ? 100 : 50)}ms`,
+                // Honest stub: no executor wired up yet. Don't lie about completion time.
+                executor: 'none',
+                _note: 'coordination_orchestrate currently records the orchestration request but does not execute it. For real multi-agent execution use agent_spawn + the Task tool, or hive-mind_spawn for queen-led coordination.',
             };
         },
     },

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(),
         };
     },
@@ -2977,40 +2988,90 @@ export const hooksIntelligenceAttention = {
             }
         }
         else if (mode === 'flash') {
-            // Try Flash Attention
+            // Try Flash Attention. ADR-093 F10: previously this attended over
+            // synthetic cosine-derived keys/values with constant-vector values,
+            // which produced uniform 0.333 weights and labels like "Flash
+            // attention target #1/2/3". Now we attend over actual stored
+            // patterns when available — real semantic content yields non-uniform
+            // weights and human-readable labels.
             const flash = await getFlashAttention();
             if (flash) {
                 try {
                     const embResult = await getQueryEmbedding(query, 384);
                     embeddingSource = embResult.source;
                     const q = embResult.embedding;
+                    // Pull real stored patterns to attend over. If none exist yet,
+                    // fall back to the synthetic harness but mark it honestly.
+                    const realPatterns = [];
+                    try {
+                        const { searchEntries: searchFn } = await import('../memory/memory-initializer.js');
+                        const hits = await searchFn({ query, limit: topK });
+                        if (Array.isArray(hits)) {
+                            for (const h of hits.slice(0, topK)) {
+                                const content = h.content ?? h.value ?? '';
+                                const id = String(h.id ?? h.key ?? `pattern-${realPatterns.length}`);
+                                realPatterns.push({ id, content: String(content) });
+                            }
+                        }
+                    }
+                    catch { /* memory not initialized — fall through to synthetic */ }
+                    const useReal = realPatterns.length > 0;
                     const keys = [];
                     const values = [];
-                    // Generate some keys/values
-                    for (let k = 0; k < topK; k++) {
-                        const key = new Float32Array(384);
-                        const value = new Float32Array(384);
-                        for (let i = 0; i < 384; i++) {
-                            key[i] = Math.cos((k + 1) * (i + 1) * 0.01);
-                            value[i] = k + 1;
+                    const labels = [];
+                    if (useReal) {
+                        // Build keys from real pattern embeddings (re-embed if no vector cached)
+                        for (let k = 0; k < realPatterns.length; k++) {
+                            const p = realPatterns[k];
+                            let keyEmbedding;
+                            if (p.embedding && p.embedding.length === 384) {
+                                keyEmbedding = new Float32Array(p.embedding);
+                            }
+                            else {
+                                const enc = await getQueryEmbedding(p.content.slice(0, 1024), 384);
+                                keyEmbedding = enc.embedding;
+                            }
+                            const value = new Float32Array(384);
+                            // Value carries pattern identity strength — magnitude = recency proxy (k position)
+                            const strength = 1 / (k + 1);
+                            for (let i = 0; i < 384; i++)
+                                value[i] = keyEmbedding[i] * strength;
+                            keys.push(keyEmbedding);
+                            values.push(value);
+                            const label = p.content.length > 0
+                                ? `${p.id}: ${p.content.slice(0, 60)}${p.content.length > 60 ? '…' : ''}`
+                                : p.id;
+                            labels.push(label);
+                        }
+                    }
+                    else {
+                        // No real patterns — surface a synthetic harness honestly.
+                        for (let k = 0; k < topK; k++) {
+                            const key = new Float32Array(384);
+                            const value = new Float32Array(384);
+                            for (let i = 0; i < 384; i++) {
+                                key[i] = Math.cos((k + 1) * (i + 1) * 0.01);
+                                value[i] = k + 1;
+                            }
+                            keys.push(key);
+                            values.push(value);
+                            labels.push(`(synthetic harness) pattern #${k + 1}`);
                         }
-                        keys.push(key);
-                        values.push(value);
                     }
                     const attentionResult = flash.attention([q], keys, values);
                     // Compute softmax weights from output magnitudes
                     const outputMags = attentionResult.output[0]
-                        ? Array.from(attentionResult.output[0]).slice(0, topK).map(v => Math.abs(v))
-                        : new Array(topK).fill(1);
+                        ? Array.from(attentionResult.output[0]).slice(0, keys.length).map(v => Math.abs(v))
+                        : new Array(keys.length).fill(1);
                     const sumMags = outputMags.reduce((a, b) => a + b, 0) || 1;
-                    for (let i = 0; i < topK; i++) {
+                    for (let i = 0; i < keys.length; i++) {
                         results.push({
                             index: i,
                             weight: outputMags[i] / sumMags,
-                            pattern: `Flash attention target #${i + 1}`,
+                            pattern: labels[i],
                         });
                     }
-                    implementation = 'real-flash-attention';
+                    implementation = useReal ? 'real-flash-attention+memory' : 'real-flash-attention+synthetic-harness';
                 }
                 catch {
                     // Fall back to placeholder
@@ -3325,21 +3386,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 +3453,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/neural-tools.js

@@ -222,10 +222,38 @@ export const neuralTools = [
                         continue;
                     const embedding = await generateEmbedding(text, 384);
                     const patternId = `${modelId}-train-${i}`;
+                    // ADR-093 F11: extract a meaningful label instead of dumping raw
+                    // training JSON as the pattern name. Audit reported neural_predict
+                    // returned `label: <raw training data JSON>` because the previous
+                    // fallback was `text.slice(0, 100)` where text was `JSON.stringify(entry)`.
+                    let label;
+                    if (typeof entry === 'string') {
+                        label = entry.slice(0, 80);
+                    }
+                    else if (entry && typeof entry === 'object') {
+                        const e = entry;
+                        // Prefer common semantic fields over a JSON dump
+                        const labelField = e.label ?? e.category ?? e.class ?? e.tag ?? e.intent ?? e.name ?? e.title;
+                        if (typeof labelField === 'string' && labelField.length > 0) {
+                            label = labelField.slice(0, 80);
+                        }
+                        else {
+                            const summaryField = e.text ?? e.input ?? e.task ?? e.description ?? e.content;
+                            if (typeof summaryField === 'string' && summaryField.length > 0) {
+                                label = `${summaryField.slice(0, 60)}${summaryField.length > 60 ? '…' : ''}`;
+                            }
+                            else {
+                                // Last resort: reduce to a stable short hash-like id
+                                label = `${modelType}:entry-${i}`;
+                            }
+                        }
+                    }
+                    else {
+                        label = `${modelType}:entry-${i}`;
+                    }
                     store.patterns[patternId] = {
                         id: patternId,
-                        name: typeof entry === 'object' && entry !== null && 'label' in entry
-                            ? String(entry.label) : text.slice(0, 100),
+                        name: label,
                         type: modelType,
                         embedding,
                         metadata: { modelId, epoch: epochs, index: i, raw: entry },
@@ -294,36 +322,67 @@ export const neuralTools = [
             const startTime = performance.now();
             const embedding = await generateEmbedding(inputText, 384);
             const latency = Math.round(performance.now() - startTime);
-            // Search stored patterns via real cosine similarity
+            // ADR-093 F11: real classifier head over stored patterns. Previously
+            // confidence was the raw cosine similarity (often clamped to 0 when
+            // stored embeddings were stale or zero-vectored). Now we run k-NN
+            // with cosine distance and apply a temperature-controlled softmax
+            // over the top-K so confidence is a proper distribution that sums
+            // to 1, and we surface enough metadata to trust the result.
             const storedPatterns = Object.values(store.patterns);
             let predictions;
             if (storedPatterns.length > 0) {
-                // Real nearest-neighbor prediction using stored pattern embeddings
-                predictions = storedPatterns
-                    .map(p => ({
-                    label: p.name || p.type || p.id,
-                    confidence: Math.max(0, cosineSimilarity(embedding, p.embedding)),
-                    patternId: p.id,
-                }))
-                    .sort((a, b) => b.confidence - a.confidence)
+                // Step 1: k-NN with cosine
+                const scored = storedPatterns
+                    .map(p => {
+                    const sim = cosineSimilarity(embedding, p.embedding);
+                    return {
+                        patternId: p.id,
+                        label: p.name || p.type || p.id,
+                        cosineSimilarity: sim,
+                    };
+                })
+                    .sort((a, b) => b.cosineSimilarity - a.cosineSimilarity)
                     .slice(0, topK);
+                // Step 2: temperature-softmax over the top-K so confidence sums to 1.
+                // Temperature 0.1 sharpens differences between similar candidates.
+                const tau = 0.1;
+                const exps = scored.map(s => Math.exp(s.cosineSimilarity / tau));
+                const z = exps.reduce((a, b) => a + b, 0) || 1;
+                predictions = scored.map((s, i) => ({
+                    label: s.label,
+                    patternId: s.patternId,
+                    cosineSimilarity: Number(s.cosineSimilarity.toFixed(4)),
+                    confidence: Number((exps[i] / z).toFixed(4)),
+                }));
             }
             else {
-                // No patterns stored — no predictions possible
+                // No patterns stored — no predictions possible. Be honest about it
+                // instead of returning empty silently.
                 predictions = [];
             }
+            const topConfidence = predictions[0]?.confidence ?? 0;
+            const topSimilarity = predictions[0]?.cosineSimilarity ?? 0;
             return {
                 success: true,
                 _realEmbedding: !!realEmbeddings,
                 _embeddingSource: embeddingServiceName,
                 embeddingProvider: embeddingServiceName,
                 _hasStoredPatterns: storedPatterns.length > 0,
+                _classifierHead: storedPatterns.length > 0 ? 'knn-cosine+softmax(tau=0.1)' : 'none',
                 modelId: model?.id || 'default',
                 input: inputText,
                 predictions,
+                // Surface cosineSimilarity separately so callers know whether the
+                // softmax confidence reflects true match strength.
+                topPrediction: predictions[0]?.label ?? null,
+                topConfidence,
+                topSimilarity,
                 embedding: embedding.slice(0, 8), // Preview of embedding
                 embeddingDims: embedding.length,
                 latency,
+                ...(storedPatterns.length === 0 ? {
+                    _note: 'No patterns stored. Train with neural_train(modelType, trainingData) before predicting.',
+                } : {}),
             };
         },
     },

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

@@ -74,7 +74,27 @@ export const performanceTools = [
             const freeMem = os.freemem();
             // Calculate real CPU usage percentage from load average
             const cpuPercent = (loadAvg[0] / cpus.length) * 100;
-            // Generate current metrics with REAL values
+            // ADR-093 F8: replace hardcoded latency fixtures (50/40/100/200) with
+            // an actual self-measured latency probe. Throughput now reflects real
+            // metric collection cadence (calls/min over the stored history) rather
+            // than an arbitrary +1/+10 increment per call.
+            const probeStart = process.hrtime.bigint();
+            // Tiny CPU+memory work that mirrors a typical MCP tool call
+            let probeAcc = 0;
+            for (let i = 0; i < 1000; i++)
+                probeAcc += Math.sqrt(i);
+            const probeNs = Number(process.hrtime.bigint() - probeStart);
+            const selfLatencyMs = probeNs / 1e6;
+            const recent = store.metrics.slice(-10);
+            const recentLatencies = recent.map(m => m.latency.avg).filter(n => Number.isFinite(n));
+            recentLatencies.push(selfLatencyMs);
+            const sorted = [...recentLatencies].sort((a, b) => a - b);
+            const pct = (p) => sorted.length === 0 ? selfLatencyMs : sorted[Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length))];
+            const avg = recentLatencies.reduce((s, n) => s + n, 0) / Math.max(1, recentLatencies.length);
+            // Throughput from real cadence: count metric samples in the last 60s.
+            const cutoff = Date.now() - 60_000;
+            const samplesInLastMinute = store.metrics.filter(m => new Date(m.timestamp).getTime() >= cutoff).length + 1;
+            const opsPerSecond = samplesInLastMinute / 60;
             const currentMetrics = {
                 timestamp: new Date().toISOString(),
                 cpu: { usage: Math.min(cpuPercent, 100), cores: cpus.length },
@@ -84,17 +104,20 @@ export const performanceTools = [
                     heap: Math.round(memUsage.heapUsed / 1024 / 1024),
                 },
                 latency: {
-                    avg: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.avg, 0) / Math.min(store.metrics.length, 10) : 50,
-                    p50: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p50, 0) / Math.min(store.metrics.length, 10) : 40,
-                    p95: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p95, 0) / Math.min(store.metrics.length, 10) : 100,
-                    p99: store.metrics.length > 0 ? store.metrics.slice(-10).reduce((s, m) => s + m.latency.p99, 0) / Math.min(store.metrics.length, 10) : 200,
+                    avg: Number(avg.toFixed(3)),
+                    p50: Number(pct(50).toFixed(3)),
+                    p95: Number(pct(95).toFixed(3)),
+                    p99: Number(pct(99).toFixed(3)),
                 },
                 throughput: {
-                    requests: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.requests + 1 : 1,
-                    operations: store.metrics.length > 0 ? store.metrics[store.metrics.length - 1].throughput.operations + 10 : 10,
+                    requests: store.metrics.length + 1,
+                    operations: Number(opsPerSecond.toFixed(2)),
                 },
                 errors: { count: 0, rate: 0 },
             };
+            // probeAcc kept reachable to prevent V8 dead-code elimination of the loop
+            if (probeAcc < 0)
+                currentMetrics.errors.count = -1;
             store.metrics.push(currentMetrics);
             // Keep last 100 metrics
             if (store.metrics.length > 100) {

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/dist/src/memory/memory-bridge.js

@@ -131,6 +131,56 @@ async function getRegistry(dbPath) {
                         }
                     }
                     catch { /* AgentDB not available */ }
+                    // ADR-093 F9: post-init injection of low-risk disabled controllers.
+                    // Try multiple constructor names because the agentdb API renamed
+                    // SemanticRouter across alpha versions (alpha.10 had SemanticRouter,
+                    // alpha.11+ removed it in favor of @ruvector/router separately;
+                    // future versions may reintroduce). If the cwd's agentdb has a
+                    // viable router-shaped controller, wire it; otherwise leave it
+                    // unbound and let bridgeSemanticRoute return its actionable error.
+                    try {
+                        const agentdb = await import('agentdb');
+                        const candidates = ['SemanticRouter', 'IntentRouter', 'TaskRouter'];
+                        let routerInstance = null;
+                        for (const name of candidates) {
+                            const Ctor = agentdb[name];
+                            if (typeof Ctor === 'function') {
+                                try {
+                                    // Try with dimension config first (newer router classes), then no-args
+                                    const inst = (() => {
+                                        try {
+                                            return new Ctor({ dimension: 384 });
+                                        }
+                                        catch {
+                                            return new Ctor();
+                                        }
+                                    })();
+                                    if (inst && typeof inst.route === 'function') {
+                                        routerInstance = inst;
+                                        break;
+                                    }
+                                }
+                                catch { /* try next candidate */ }
+                            }
+                        }
+                        if (routerInstance && !reg.get('semanticRouter')) {
+                            if (typeof reg.set === 'function')
+                                reg.set('semanticRouter', routerInstance);
+                            else
+                                reg._controllers = { ...(reg._controllers || {}), semanticRouter: routerInstance };
+                        }
+                    }
+                    catch { /* SemanticRouter optional — bridgeSemanticRoute will surface "not available" */ }
+                    // Other disabled controllers remain disabled and tracked in
+                    // ADR-093 F9 for future enablement:
+                    //   - mutationGuard (write protection — needs config)
+                    //   - attestationLog (needs sqlite db handle the registry does
+                    //     not currently expose)
+                    //   - gnnService (graph neural net — heavy deps, needs WASM/CUDA)
+                    //   - guardedVectorBackend (secured vector backend variant —
+                    //     needs key material)
+                    //   - rvfOptimizer (RVF format optimizer — needs RVF storage)
+                    //   - graphAdapter (graph DB adapter — needs graph DB)
                 }
                 catch {
                     // Intelligence module not available — learning stays unwired
@@ -1545,13 +1595,22 @@ export async function bridgeSemanticRoute(params) {
         return null;
     try {
         const router = registry.get('semanticRouter');
-        if (!router)
-            return { route: null, error: 'SemanticRouter not available' };
+        if (!router) {
+            // ADR-093 F9: surface an actionable error pointing callers at the
+            // alternative routing surfaces that DO work, instead of just
+            // saying "not available".
+            return {
+                route: null,
+                error: 'SemanticRouter not available in current agentdb build',
+                recommendation: 'Use bridgeRouteTask (registers as `agentdb_route` MCP tool) for keyword+pattern routing, or hooks_model-route for ADR-026 model selection.',
+                controller: 'none',
+            };
+        }
         const result = await router.route(params.input);
         return { route: result, controller: 'semanticRouter' };
     }
     catch (e) {
-        return { route: null, error: e.message };
+        return { route: null, error: e.message, controller: 'error' };
     }
 }
 // ===== RaBitQ data export =====

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

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