@sparkleideas/claude-flow-patch 3.1.0-alpha.44.patch.3

package/patch/060-DM-004-preload-worker-stub/fix.py

@@ -0,0 +1,34 @@
+# DM-004: Preload worker stub + missing from defaults
+# Adds missing workers to DEFAULT_WORKERS and implements real preload
+patch("11: add missing workers to defaults",
+    WD,
+    "    { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },\n];",
+    """    { type: 'document', intervalMs: 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Auto-documentation', enabled: false },
+    { type: 'ultralearn', intervalMs: 0, offsetMs: 0, priority: 'normal', description: 'Deep knowledge acquisition (headless, manual trigger)', enabled: false },
+    { type: 'deepdive', intervalMs: 4 * 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Deep code analysis', enabled: false },
+    { type: 'refactor', intervalMs: 4 * 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Refactoring suggestions', enabled: false },
+    { type: 'benchmark', intervalMs: 2 * 60 * 60 * 1000, offsetMs: 0, priority: 'low', description: 'Performance benchmarking', enabled: false },
+    { type: 'preload', intervalMs: 10 * 60 * 1000, offsetMs: 0, priority: 'high', description: 'Embedding model + HNSW preload', enabled: true },
+];""")
+
+patch("11: real preload worker",
+    WD,
+    """    async runPreloadWorkerLocal() {
+        return {
+            timestamp: new Date().toISOString(),
+            mode: 'local',
+            resourcesPreloaded: 0,
+            cacheStatus: 'active',
+        };
+    }""",
+    """    async runPreloadWorkerLocal() {
+        const result = { timestamp: new Date().toISOString(), mode: 'local', resourcesPreloaded: 0, cacheStatus: 'active' };
+        try {
+            const mi = await import('../memory/memory-initializer.js');
+            const modelResult = await mi.loadEmbeddingModel({ verbose: false });
+            if (modelResult.success) { result.resourcesPreloaded++; result.embeddingModel = modelResult.modelName; }
+            const hnswResult = await mi.getHNSWIndex();
+            if (hnswResult) { result.resourcesPreloaded++; result.hnswEntries = hnswResult.entries?.size ?? 0; }
+        } catch (e) { result.error = e?.message || String(e); }
+        return result;
+    }""")

package/patch/060-DM-004-preload-worker-stub/sentinel

@@ -0,0 +1 @@
+grep "loadEmbeddingModel" services/worker-daemon.js

package/patch/070-DM-005-consolidation-worker-stub/README.md

@@ -0,0 +1,11 @@
+# DM-005: Consolidation worker stub (no decay/rebuild)
+**Severity**: Enhancement
+**GitHub**: [#1140](https://github.com/ruvnet/claude-flow/issues/1140)
+## Root Cause
+The consolidation worker was a stub writing `{patternsConsolidated: 0}` to a JSON file. No actual memory consolidation occurred.
+## Fix
+Call `applyTemporalDecay()` to reduce confidence of stale patterns, then `clearHNSWIndex()` + `getHNSWIndex({ forceRebuild: true })` to rebuild the index with current data.
+## Files Patched
+- services/worker-daemon.js
+## Ops
+1 op in fix.py

package/patch/070-DM-005-consolidation-worker-stub/fix.py

@@ -0,0 +1,46 @@
+# DM-005: Consolidation worker stub (no decay/rebuild)
+# Makes consolidate worker actually call pattern decay + HNSW rebuild
+patch("12: real consolidate worker",
+    WD,
+    """    async runConsolidateWorker() {
+        // Memory consolidation - clean up old patterns
+        const consolidateFile = join(this.projectRoot, '.claude-flow', 'metrics', 'consolidation.json');
+        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+        if (!existsSync(metricsDir)) {
+            mkdirSync(metricsDir, { recursive: true });
+        }
+        const result = {
+            timestamp: new Date().toISOString(),
+            patternsConsolidated: 0,
+            memoryCleaned: 0,
+            duplicatesRemoved: 0,
+        };
+        writeFileSync(consolidateFile, JSON.stringify(result, null, 2));
+        return result;
+    }""",
+    """    async runConsolidateWorker() {
+        const consolidateFile = join(this.projectRoot, '.claude-flow', 'metrics', 'consolidation.json');
+        const metricsDir = join(this.projectRoot, '.claude-flow', 'metrics');
+        if (!existsSync(metricsDir)) {
+            mkdirSync(metricsDir, { recursive: true });
+        }
+        const result = {
+            timestamp: new Date().toISOString(),
+            patternsConsolidated: 0,
+            memoryCleaned: 0,
+            duplicatesRemoved: 0,
+        };
+        try {
+            const mi = await import('../memory/memory-initializer.js');
+            // 1. Apply temporal decay (reduce confidence of stale patterns)
+            const decayResult = await mi.applyTemporalDecay();
+            if (decayResult?.success) result.patternsConsolidated = decayResult.patternsDecayed || 0;
+            // 2. Rebuild HNSW index with current data
+            mi.clearHNSWIndex();
+            const hnsw = await mi.getHNSWIndex({ forceRebuild: true });
+            if (hnsw) result.hnswRebuilt = hnsw.entries?.size ?? 0;
+            result.memoryCleaned = 1;
+        } catch (e) { result.error = e?.message || String(e); }
+        writeFileSync(consolidateFile, JSON.stringify(result, null, 2));
+        return result;
+    }""")

package/patch/070-DM-005-consolidation-worker-stub/sentinel

@@ -0,0 +1 @@
+grep "applyTemporalDecay" services/worker-daemon.js

package/patch/080-EM-001-embedding-ignores-config/README.md

@@ -0,0 +1,11 @@
+# EM-001: Embedding system ignores project config (model + HNSW dims)
+**Severity**: High
+**GitHub**: [#1143](https://github.com/ruvnet/claude-flow/issues/1143)
+## Root Cause
+`loadEmbeddingModel()` hardcodes `Xenova/all-MiniLM-L6-v2` (384-dim). Projects configured with a different model via `embeddings.json` (e.g. `all-mpnet-base-v2` 768-dim) still get MiniLM 384-dim vectors. HNSW index also hardcodes 384 dimensions, causing dimension mismatch when the actual model produces 768-dim vectors. Every search falls back to brute-force SQLite.
+## Fix
+Read model name and dimensions from `.claude-flow/embeddings.json` at load time. Fall back to all-MiniLM-L6-v2 (384-dim) if no config exists. Delete stale persistent HNSW files on forceRebuild. Guard metadata loading and early-return to skip on forceRebuild.
+## Files Patched
+- memory/memory-initializer.js
+## Ops
+6 ops in fix.py (merged from old patches 8 + 9)

package/patch/080-EM-001-embedding-ignores-config/fix.py

@@ -0,0 +1,111 @@
+# EM-001: Embedding system ignores project config (model + HNSW dims)
+# Merged from old patches 8 (config-driven model) + 9 (HNSW dimension fix)
+
+# --- Old Patch 8: Config-driven embedding model loader ---
+patch("8: config-driven model",
+    MI,
+    """        // Try to import @xenova/transformers for ONNX embeddings
+        const transformers = await import('@xenova/transformers').catch(() => null);
+        if (transformers) {
+            if (verbose) {
+                console.log('Loading ONNX embedding model (all-MiniLM-L6-v2)...');
+            }
+            // Use small, fast model for local embeddings
+            const { pipeline } = transformers;
+            const embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+            embeddingModelState = {
+                loaded: true,
+                model: embedder,
+                tokenizer: null,
+                dimensions: 384 // MiniLM-L6 produces 384-dim vectors
+            };
+            return {
+                success: true,
+                dimensions: 384,
+                modelName: 'all-MiniLM-L6-v2',
+                loadTime: Date.now() - startTime
+            };
+        }""",
+    """        // Patch 8: Read embedding model from project config instead of hardcoding
+        let modelName = 'all-MiniLM-L6-v2';
+        let modelDimensions = 384;
+        try {
+            const embConfigPath = path.join(process.cwd(), '.claude-flow', 'embeddings.json');
+            if (fs.existsSync(embConfigPath)) {
+                const embConfig = JSON.parse(fs.readFileSync(embConfigPath, 'utf-8'));
+                if (embConfig.model) {
+                    modelName = embConfig.model;
+                    modelDimensions = embConfig.dimension || 768;
+                }
+            }
+        } catch { /* use defaults */ }
+        const xenovaModel = modelName.startsWith('Xenova/') ? modelName : `Xenova/${modelName}`;
+        // Try to import @xenova/transformers for ONNX embeddings
+        const transformers = await import('@xenova/transformers').catch(() => null);
+        if (transformers) {
+            if (verbose) {
+                console.log(`Loading ONNX embedding model (${modelName})...`);
+            }
+            const { pipeline } = transformers;
+            const embedder = await pipeline('feature-extraction', xenovaModel);
+            embeddingModelState = {
+                loaded: true,
+                model: embedder,
+                tokenizer: null,
+                dimensions: modelDimensions
+            };
+            return {
+                success: true,
+                dimensions: modelDimensions,
+                modelName: modelName,
+                loadTime: Date.now() - startTime
+            };
+        }""")
+
+# --- Old Patch 9: HNSW dimension fix ---
+patch("9: HNSW dim default",
+    MI,
+    "    const dimensions = options?.dimensions ?? 384;",
+    """    // Patch 9: Read dims from embeddings.json
+    let dimensions = options?.dimensions;
+    if (!dimensions) {
+        try {
+            const embConfigPath = path.join(process.cwd(), '.claude-flow', 'embeddings.json');
+            if (fs.existsSync(embConfigPath)) {
+                const embConfig = JSON.parse(fs.readFileSync(embConfigPath, 'utf-8'));
+                dimensions = embConfig.dimension || 768;
+            }
+        } catch { /* ignore */ }
+        dimensions = dimensions || 768;
+    }""")
+
+patch("9: HNSW stale cleanup",
+    MI,
+    """        const dbPath = options?.dbPath || path.join(swarmDir, 'memory.db');
+        // Create HNSW index with persistent storage""",
+    """        const dbPath = options?.dbPath || path.join(swarmDir, 'memory.db');
+        // Patch 9: delete stale persistent files on forceRebuild
+        if (options?.forceRebuild) {
+            try:
+                if (fs.existsSync(hnswPath)) fs.unlinkSync(hnswPath);
+            catch {}
+            try:
+                if (fs.existsSync(metadataPath)) fs.unlinkSync(metadataPath);
+            catch {}
+        }
+        // Create HNSW index with persistent storage""".replace("try:", "try {").replace("catch {}", "} catch {}"))
+
+patch("9: HNSW metadata guard",
+    MI,
+    "        if (fs.existsSync(metadataPath)) {",
+    "        if (!options?.forceRebuild && fs.existsSync(metadataPath)) {")
+
+patch("9: HNSW early-return guard",
+    MI,
+    "        if (existingLen > 0 && entries.size > 0) {",
+    "        if (existingLen > 0 && entries.size > 0 && !options?.forceRebuild) {")
+
+patch("9: HNSW status default",
+    MI,
+    "dimensions: hnswIndex?.dimensions ?? 384",
+    "dimensions: hnswIndex?.dimensions ?? 768")

package/patch/080-EM-001-embedding-ignores-config/sentinel

@@ -0,0 +1 @@
+grep "embeddings.json" memory/memory-initializer.js

package/patch/090-EM-002-transformers-cache-eacces/README.md

@@ -0,0 +1,11 @@
+# EM-002: @xenova/transformers cache EACCES
+**Severity**: Medium
+**GitHub**: [#1144](https://github.com/ruvnet/claude-flow/issues/1144)
+## Root Cause
+Global `npm install` creates root-owned directories. `@xenova/transformers` tries to write model cache next to its `package.json`, failing with EACCES.
+## Fix
+Create `.cache` directory with open permissions. Alternative: set `TRANSFORMERS_CACHE` env var.
+## Files Patched
+- N/A (filesystem permissions, not code)
+## Ops
+fix.sh (chmod, not Python)

package/patch/090-EM-002-transformers-cache-eacces/fix.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+# EM-002: @xenova/transformers cache EACCES on global install
+# Global npm install creates root-owned dirs. Model cache write fails.
+
+TRANSFORMERS_DIR=$(npm root -g)/claude-flow/node_modules/@xenova/transformers
+if [ -d "$TRANSFORMERS_DIR" ]; then
+    sudo mkdir -p "$TRANSFORMERS_DIR/.cache"
+    sudo chmod 777 "$TRANSFORMERS_DIR/.cache"
+    echo "  Applied: EM-002 transformers cache permissions"
+else
+    echo "  SKIP: EM-002 — @xenova/transformers not in global install"
+fi

package/patch/090-EM-002-transformers-cache-eacces/sentinel

@@ -0,0 +1 @@
+none

package/patch/100-GV-001-hnsw-ghost-vectors/README.md

@@ -0,0 +1,11 @@
+# GV-001: HNSW ghost vectors persist after memory delete
+**Severity**: Medium
+**GitHub**: [#1122](https://github.com/ruvnet/claude-flow/issues/1122)
+## Root Cause
+`deleteEntry()` soft-deletes the SQLite row but never removes the vector from the in-memory HNSW index or its persisted metadata. The search code (`searchHNSWIndex`) iterates HNSW results and looks up each ID in `hnswIndex.entries` Map — ghost vectors match but return stale metadata (key, namespace, content) because the Map entry was never removed.
+## Fix
+After the SQLite soft-delete, remove the entry from `hnswIndex.entries` Map and save updated metadata. The HNSW vector DB (`@ruvector/core`) doesn't support point removal, but the search code already skips entries missing from the Map (`if (!entry) continue`), so removing from the Map is sufficient to suppress ghost results.
+## Files Patched
+- memory/memory-initializer.js
+## Ops
+1 op in fix.py

package/patch/100-GV-001-hnsw-ghost-vectors/fix.py

@@ -0,0 +1,34 @@
+# GV-001: Remove HNSW ghost vectors on memory delete
+# GitHub: #1122
+# After SQLite soft-delete, remove entry from persisted HNSW metadata file
+# and in-memory map. Each CLI invocation is a fresh process so hnswIndex is
+# usually null — the file-based cleanup is the primary path.
+# 1 op
+
+patch("GV-001: remove HNSW entry on delete",
+    MI,
+    """        // Get remaining count
+        const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
+        const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
+        // Save updated database""",
+    """        // Remove ghost vector from HNSW metadata file
+        const entryId = String(checkResult[0].values[0][0]);
+        try {
+            const swarmDir = path.join(process.cwd(), '.swarm');
+            const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
+            if (fs.existsSync(metadataPath)) {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+                const filtered = metadata.filter(([id]) => id !== entryId);
+                if (filtered.length < metadata.length) {
+                    fs.writeFileSync(metadataPath, JSON.stringify(filtered));
+                }
+            }
+        } catch { /* best-effort */ }
+        // Also clear in-memory index if loaded
+        if (hnswIndex?.entries?.has(entryId)) {
+            hnswIndex.entries.delete(entryId);
+        }
+        // Get remaining count
+        const countResult = db.exec(`SELECT COUNT(*) FROM memory_entries WHERE status = 'active'`);
+        const remainingEntries = countResult[0]?.values?.[0]?.[0] || 0;
+        // Save updated database""")

package/patch/100-GV-001-hnsw-ghost-vectors/sentinel

@@ -0,0 +1 @@
+grep "hnswIndex.entries.delete" memory/memory-initializer.js

package/patch/110-HK-001-post-edit-file-path/README.md

@@ -0,0 +1,44 @@
+# HK-001: post-edit hook records file_path as "unknown"
+
+**Severity**: Medium
+**GitHub**: [#1155](https://github.com/ruvnet/claude-flow/issues/1155)
+
+## Root Cause
+
+The `hook-handler.cjs` template (in `helpers-generator.js`) reads the edited file
+path from `process.env.TOOL_INPUT_file_path`. However, Claude Code's PostToolUse
+hooks do **not** set individual `TOOL_INPUT_*` environment variables. Instead, tool
+input is delivered via **stdin** as a JSON object:
+
+```json
+{
+  "tool_name": "Edit",
+  "tool_input": { "file_path": "/path/to/file", ... },
+  "tool_response": { ... },
+  ...
+}
+```
+
+Because the env var is always empty, `recordEdit()` in `intelligence.cjs` logs
+every edit as `file: "unknown"`. The data is consumed by `consolidate()` at session
+end for edit-count analytics — cosmetic but wrong.
+
+## Fix
+
+Two changes in `init/helpers-generator.js`:
+
+1. **Add stdin parsing** after the `argv` line — read and parse the JSON that
+   Claude Code pipes to PostToolUse hook commands.
+2. **Update post-edit handler** — read `stdinData.tool_input.file_path` instead
+   of `process.env.TOOL_INPUT_file_path`.
+
+The `prompt` fallback for the `route` handler is also updated to prefer
+`stdinData.tool_input.command` over the env var.
+
+## Files Patched
+
+- init/helpers-generator.js
+
+## Ops
+
+2 ops in fix.py

package/patch/110-HK-001-post-edit-file-path/fix.py

@@ -0,0 +1,23 @@
+# HK-001: post-edit hook records file_path as "unknown"
+# Claude Code passes tool input via stdin JSON, not TOOL_INPUT_* env vars.
+# 3 ops: add stdin parsing, fix prompt fallback, fix post-edit file extraction.
+
+patch("HK-001a: add stdin parsing",
+    HELPERS_GEN,
+    """'const [,, command, ...args] = process.argv;',
+        "const prompt = process.env.PROMPT || process.env.TOOL_INPUT_command || args.join(' ') || '';",""",
+    """'const [,, command, ...args] = process.argv;',
+        '',
+        '// Read stdin JSON from Claude Code hooks (provides tool_input, tool_name, etc.)',
+        'let stdinData = {};',
+        'try {',
+        "  const raw = require(\\'fs\\').readFileSync(0, \\'utf-8\\').trim();",
+        "  if (raw) stdinData = JSON.parse(raw);",
+        '} catch (e) { /* stdin may be empty or non-JSON */ }',
+        '',
+        "const prompt = process.env.PROMPT || (stdinData.tool_input && stdinData.tool_input.command) || args.join(' ') || '';",""")
+
+patch("HK-001b: post-edit read file_path from stdin",
+    HELPERS_GEN,
+    """"        var file = process.env.TOOL_INPUT_file_path || args[0] || '';",""",
+    """"        var file = (stdinData.tool_input && stdinData.tool_input.file_path) || args[0] || '';",""")

package/patch/110-HK-001-post-edit-file-path/sentinel

@@ -0,0 +1 @@
+grep "stdinData" init/helpers-generator.js

package/patch/120-HK-002-hooks-tools-stub/README.md

@@ -0,0 +1,36 @@
+# HK-002: MCP hook handlers are stubs that don't persist data
+
+**Severity**: High
+**GitHub**: [#1058](https://github.com/ruvnet/claude-flow/issues/1058)
+
+## Root Cause
+
+Three MCP hook handlers in `hooks-tools.js` return success responses but **never persist any data**:
+
+1. **`hooksPostEdit`** (line 512) -- Returns `{recorded: true}` but has no database INSERT
+2. **`hooksPostCommand`** (line 568) -- Same, claims recorded but stores nothing
+3. **`hooksPostTask`** (line 886) -- Returns fake random duration and hardcoded pattern counts
+
+The store function `getRealStoreFunction()` (line 23) already exists in the file and is used correctly by other handlers (`hooks_intelligence_trajectory-end`, `hooks_intelligence_pattern-store`). These three just never call it.
+
+## Fix
+
+Patch each handler to call `getRealStoreFunction()` and persist to appropriate namespaces:
+- `hooksPostEdit` -> namespace: `edits`
+- `hooksPostCommand` -> namespace: `commands`
+- `hooksPostTask` -> namespace: `tasks`
+
+## Impact Without Patch
+
+- Edit patterns never stored -- can't learn from file edits
+- Command history lost -- can't learn from command outcomes
+- Task outcomes not tracked -- SONA learning has no data
+- Misleading metrics -- statusline shows fake pattern counts
+
+## Files Patched
+
+- `mcp-tools/hooks-tools.js`
+
+## Ops
+
+3 ops in fix.py

package/patch/120-HK-002-hooks-tools-stub/fix.py

@@ -0,0 +1,155 @@
+# HK-002: MCP hook handlers are stubs that don't persist data
+# GitHub: #1058
+# Restored from deleted HK-001 (commit 95a6a23)
+
+# HK-002a: hooksPostEdit - add persistence
+patch("HK-002a: hooksPostEdit persistence",
+    MCP_HOOKS,
+    """    handler: async (params) => {
+        const filePath = params.filePath;
+        const success = params.success !== false;
+        return {
+            recorded: true,
+            filePath,
+            success,
+            timestamp: new Date().toISOString(),
+            learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
+        };
+    },
+};
+export const hooksPreCommand""",
+    """    handler: async (params) => {
+        const filePath = params.filePath;
+        const success = params.success !== false;
+        const agent = params.agent || 'unknown';
+        const timestamp = new Date().toISOString();
+        const editId = `edit-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+        // HK-002a: Actually persist the edit record
+        const storeFn = await getRealStoreFunction();
+        let storeResult = { success: false };
+        if (storeFn) {
+            try {
+                storeResult = await storeFn({
+                    key: editId,
+                    value: JSON.stringify({ filePath, success, agent, timestamp }),
+                    namespace: 'edits',
+                    generateEmbeddingFlag: true,
+                    tags: [success ? 'success' : 'failure', 'edit', agent],
+                });
+            } catch (e) { storeResult = { success: false, error: String(e) }; }
+        }
+        return {
+            recorded: storeResult.success,
+            filePath,
+            success,
+            timestamp,
+            learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
+        };
+    },
+};
+export const hooksPreCommand""")
+
+# HK-002b: hooksPostCommand - add persistence
+patch("HK-002b: hooksPostCommand persistence",
+    MCP_HOOKS,
+    """    handler: async (params) => {
+        const command = params.command;
+        const exitCode = params.exitCode || 0;
+        return {
+            recorded: true,
+            command,
+            exitCode,
+            success: exitCode === 0,
+            timestamp: new Date().toISOString(),
+        };
+    },
+};
+export const hooksRoute""",
+    """    handler: async (params) => {
+        const command = params.command;
+        const exitCode = params.exitCode || 0;
+        const success = exitCode === 0;
+        const timestamp = new Date().toISOString();
+        const cmdId = `cmd-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+        // HK-002b: Actually persist the command record
+        const storeFn = await getRealStoreFunction();
+        let storeResult = { success: false };
+        if (storeFn) {
+            try {
+                storeResult = await storeFn({
+                    key: cmdId,
+                    value: JSON.stringify({ command, exitCode, success, timestamp }),
+                    namespace: 'commands',
+                    generateEmbeddingFlag: true,
+                    tags: [success ? 'success' : 'failure', 'command'],
+                });
+            } catch (e) { storeResult = { success: false, error: String(e) }; }
+        }
+        return {
+            recorded: storeResult.success,
+            command,
+            exitCode,
+            success,
+            timestamp,
+        };
+    },
+};
+export const hooksRoute""")
+
+# HK-002c: hooksPostTask - add persistence, remove fake random data
+patch("HK-002c: hooksPostTask persistence",
+    MCP_HOOKS,
+    """    handler: async (params) => {
+        const taskId = params.taskId;
+        const success = params.success !== false;
+        const quality = params.quality || (success ? 0.85 : 0.3);
+        return {
+            taskId,
+            success,
+            duration: Math.floor(Math.random() * 300) + 60, // 1-6 minutes in seconds
+            learningUpdates: {
+                patternsUpdated: success ? 2 : 1,
+                newPatterns: success ? 1 : 0,
+                trajectoryId: `traj-${Date.now()}`,
+            },
+            quality,
+            timestamp: new Date().toISOString(),
+        };
+    },
+};
+// Explain hook""",
+    """    handler: async (params) => {
+        const taskId = params.taskId;
+        const success = params.success !== false;
+        const agent = params.agent || 'unknown';
+        const quality = params.quality || (success ? 0.85 : 0.3);
+        const timestamp = new Date().toISOString();
+        // HK-002c: Actually persist the task record
+        const storeFn = await getRealStoreFunction();
+        let storeResult = { success: false };
+        if (storeFn) {
+            try {
+                storeResult = await storeFn({
+                    key: `task-${taskId}`,
+                    value: JSON.stringify({ taskId, success, agent, quality, timestamp }),
+                    namespace: 'tasks',
+                    generateEmbeddingFlag: true,
+                    tags: [success ? 'success' : 'failure', 'task', agent],
+                });
+            } catch (e) { storeResult = { success: false, error: String(e) }; }
+        }
+        return {
+            taskId,
+            success,
+            recorded: storeResult.success,
+            learningUpdates: {
+                patternsUpdated: storeResult.success ? 1 : 0,
+                newPatterns: storeResult.success ? 1 : 0,
+                trajectoryId: `task-${taskId}`,
+            },
+            quality,
+            timestamp,
+        };
+    },
+};
+// Explain hook""")

package/patch/120-HK-002-hooks-tools-stub/sentinel

@@ -0,0 +1 @@
+grep "HK-002a" mcp-tools/hooks-tools.js

package/patch/130-HK-003-metrics-hardcoded/README.md

@@ -0,0 +1,30 @@
+# HK-003: hooks_metrics MCP handler returns hardcoded fake data
+
+**Severity**: High
+**GitHub**: [#1158](https://github.com/ruvnet/claude-flow/issues/1158)
+
+## Root Cause
+
+The `hooksMetrics` handler in `mcp-tools/hooks-tools.js` returns a static
+object literal with fake values (15 patterns, 87% routing accuracy, 128
+commands executed). It never reads from any persistence layer.
+
+This is the same class of defect as HK-002 (hook handlers returning fake
+data without persisting), but for the metrics/dashboard endpoint.
+
+## Fix
+
+Replace the hardcoded return with a function that:
+1. Reads `.swarm/sona-patterns.json` for pattern counts, confidence, and routing stats
+2. Reads `.ruvector/intelligence.json` for trajectory/command counts and success rates
+3. Computes actual metrics from the persisted data
+4. Falls back to zeros when files don't exist
+5. Preserves the static performance targets (those are design goals, not metrics)
+
+## Files Patched
+
+- `mcp-tools/hooks-tools.js`
+
+## Ops
+
+1 op in fix.py