claude-flow 3.6.14 → 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.14",
+  "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/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/hooks-tools.js

@@ -2988,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

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/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.14",
+  "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",