@sparkleideas/claude-flow-patch 3.1.0-alpha.44.patch.10 → 3.1.0-alpha.44.patch.11

package/patch/560-WM-008-agentdb-v3-upgrade/fix.py

@@ -0,0 +1,257 @@
+# WM-008: Upgrade AgentDB v2 to v3 (RVF backend, self-learning, witness chain)
+# GitHub: #1207
+
+# ── Op A: DEFAULT_CONFIG vectorBackend 'auto' -> 'rvf' ──
+patch("WM-008a: change default vectorBackend from 'auto' to 'rvf'",
+    AGENTDB_BACKEND,
+    """    vectorBackend: 'auto',""",
+    """    vectorBackend: 'rvf',""")
+
+# ── Op B: shutdown() — save unified .rvf before close + destroy learning backend ──
+patch("WM-008b: save unified .rvf before close, destroy learning backend in shutdown",
+    AGENTDB_BACKEND,
+    """    async shutdown() {
+        if (!this.initialized)
+            return;
+        if (this.agentdb) {
+            await this.agentdb.close();
+        }""",
+    """    async shutdown() {
+        if (!this.initialized)
+            return;
+        if (this.agentdb) {
+            // WM-008b: Save unified .rvf file before closing (v3)
+            if (this.agentdb.isUnifiedMode && typeof this.agentdb.save === 'function') {
+                try { await this.agentdb.save(); } catch {}
+            }
+            // WM-008b: Destroy learning backend if active
+            if (this.learningBackend) {
+                try { await this.learningBackend.destroy(); } catch {}
+                this.learningBackend = null;
+            }
+            await this.agentdb.close();
+        }""")
+
+# ── Op C: Import SelfLearningRvfBackend alongside AgentDB ──
+patch("WM-008c: add SelfLearningRvfBackend variable declaration",
+    AGENTDB_BACKEND,
+    """let AgentDB;
+let HNSWIndex;
+let isHnswlibAvailable;""",
+    """let AgentDB;
+let HNSWIndex;
+let isHnswlibAvailable;
+let SelfLearningRvfBackend;""")
+
+patch("WM-008c2: import SelfLearningRvfBackend in ensureAgentDBImport",
+    AGENTDB_BACKEND,
+    """                AgentDB = agentdbModule.AgentDB || agentdbModule.default;
+                HNSWIndex = agentdbModule.HNSWIndex;
+                isHnswlibAvailable = agentdbModule.isHnswlibAvailable;""",
+    """                AgentDB = agentdbModule.AgentDB || agentdbModule.default;
+                HNSWIndex = agentdbModule.HNSWIndex;
+                isHnswlibAvailable = agentdbModule.isHnswlibAvailable;
+                // WM-008c: Import SelfLearningRvfBackend (v3-only, undefined on v2)
+                SelfLearningRvfBackend = agentdbModule.SelfLearningRvfBackend;""")
+
+# ── Op D: After initialize, create learning backend + capture witness chain hash ──
+patch("WM-008d: create learning backend and capture witness chain in initialize",
+    AGENTDB_BACKEND,
+    """            this.initialized = true;
+            this.emit('initialized', {
+                backend: this.agentdb.vectorBackendName,
+                isWasm: this.agentdb.isWasm,
+            });""",
+    """            this.initialized = true;
+            // WM-008d: Create self-learning backend when enabled (v3-only)
+            if (this.config.enableLearning && SelfLearningRvfBackend) {
+                try {
+                    this.learningBackend = await SelfLearningRvfBackend.create({
+                        dimension: this.config.vectorDimension || 1536,
+                        metric: 'cosine',
+                        storagePath: this.config.dbPath || ':memory:',
+                        learning: true,
+                        positiveThreshold: this.config.learningPositiveThreshold ?? 0.7,
+                        negativeThreshold: this.config.learningNegativeThreshold ?? 0.3,
+                        trainingBatchSize: this.config.learningBatchSize ?? 32,
+                        tickIntervalMs: this.config.learningTickInterval ?? 30000,
+                    });
+                } catch (learnErr) {
+                    // Non-fatal: self-learning is an optional enhancement
+                }
+            }
+            // WM-008f: Capture witness chain hash at init (v3-only)
+            let witnessChainHash;
+            if (this.agentdb && typeof this.agentdb.getWitnessChain === 'function') {
+                try {
+                    const chain = this.agentdb.getWitnessChain();
+                    witnessChainHash = chain?.currentHash;
+                } catch {}
+            }
+            this.emit('initialized', {
+                backend: this.agentdb.vectorBackendName,
+                isWasm: this.agentdb.isWasm,
+                learning: !!this.learningBackend,
+                unifiedMode: !!this.agentdb.isUnifiedMode,
+                witnessChainHash,
+            });""")
+
+# ── Op E+F: Add recordFeedback, getWitnessChain, verifyWitnessChain methods ──
+patch("WM-008ef: add recordFeedback + witness chain methods",
+    AGENTDB_BACKEND,
+    """    getAgentDB() {
+        return this.agentdb;
+    }
+}""",
+    """    getAgentDB() {
+        return this.agentdb;
+    }
+    /**
+     * WM-008e: Record search feedback for self-learning (v3-only)
+     */
+    async recordFeedback(queryId, quality) {
+        if (!this.learningBackend || typeof this.learningBackend.recordFeedback !== 'function') return;
+        try {
+            await this.learningBackend.recordFeedback(queryId, quality);
+        } catch {}
+    }
+    /**
+     * WM-008f: Get witness chain for tamper detection (v3-only)
+     */
+    getWitnessChain() {
+        if (!this.agentdb) return null;
+        if (typeof this.agentdb.getWitnessChain === 'function') {
+            try { return this.agentdb.getWitnessChain(); } catch { return null; }
+        }
+        return null;
+    }
+    /**
+     * WM-008f: Verify witness chain integrity (v3-only)
+     */
+    async verifyWitnessChain() {
+        if (!this.agentdb) return { valid: false, reason: 'agentdb not initialized' };
+        if (typeof this.agentdb.verifyWitnessChain === 'function') {
+            try { return await this.agentdb.verifyWitnessChain(); } catch (e) { return { valid: false, reason: String(e) }; }
+        }
+        return { valid: false, reason: 'witness chain not available (requires agentdb v3)' };
+    }
+}""")
+
+# ── Op G: memory-initializer.js — .db -> .rvf + vectorBackend + learning config ──
+# Targets the state AFTER WM-007a2 has been applied (execution order 530 < 560)
+patch("WM-008g1: change agentdb path from .db to .rvf",
+    MI,
+    """            const agentDbPath = path.join(swarmDir, 'agentdb-memory.db');""",
+    """            const agentDbPath = path.join(swarmDir, 'agentdb-memory.rvf');""")
+
+patch("WM-008g2: replace v2 agentdb config with v3 RVF + learning config",
+    MI,
+    """            if (backendChoice === 'hybrid' || backendChoice === 'agentdb') {
+                hybridConfig.agentdb = {
+                    dbPath: agentDbPath,
+                    vectorDimension: modelDimensions,
+                    indexType: enableHNSW ? 'hnsw' : 'flat',
+                };
+            }""",
+    """            if (backendChoice === 'hybrid' || backendChoice === 'agentdb') {
+                // WM-008g: AgentDB v3 config with RVF backend + self-learning
+                const agentdbCfg = cfgMemory.agentdb || {};
+                hybridConfig.agentdb = {
+                    dbPath: agentDbPath,
+                    vectorDimension: modelDimensions,
+                    vectorBackend: 'rvf',
+                    enableLearning: agentdbCfg.enableLearning !== false,
+                    learningPositiveThreshold: agentdbCfg.learningPositiveThreshold ?? 0.7,
+                    learningNegativeThreshold: agentdbCfg.learningNegativeThreshold ?? 0.3,
+                    learningBatchSize: agentdbCfg.learningBatchSize ?? 32,
+                    learningTickInterval: agentdbCfg.learningTickInterval ?? 30000,
+                };
+            }""")
+
+# ── Op H: executor.js — add agentdb subsection to config.json template ──
+# Targets the state AFTER SG-010c has been applied (execution order 540 < 560)
+patch("WM-008h: add agentdb v3 config subsection to config.json template",
+    EXECUTOR,
+    """            agentScopes: {
+                enabled: !!(options.runtime.enableAgentScopes ?? true),
+                defaultScope: options.runtime.defaultScope || 'project',
+            },
+        },
+        neural: {""",
+    """            agentScopes: {
+                enabled: !!(options.runtime.enableAgentScopes ?? true),
+                defaultScope: options.runtime.defaultScope || 'project',
+            },
+            // WM-008h: AgentDB v3 self-learning config
+            agentdb: {
+                vectorBackend: 'rvf',
+                enableLearning: !!(options.runtime.enableAgentdbLearning ?? true),
+                learningPositiveThreshold: options.runtime.agentdbPositiveThreshold ?? 0.7,
+                learningNegativeThreshold: options.runtime.agentdbNegativeThreshold ?? 0.3,
+                learningBatchSize: options.runtime.agentdbBatchSize ?? 32,
+                learningTickInterval: options.runtime.agentdbTickInterval ?? 30000,
+            },
+        },
+        neural: {""")
+
+# ── Op I: @claude-flow/memory package.json — update agentdb dep version ──
+patch("WM-008i: update @claude-flow/memory agentdb dep from v2 to v3",
+    MEMORY_PKG_JSON,
+    """    "agentdb": "2.0.0-alpha.3.7",""",
+    """    "agentdb": "3.0.0-alpha.3",""")
+
+# ── Op J: agentdb-backend.js header comment — update version ref ──
+patch("WM-008j: update agentdb-backend.js header comment to v3",
+    AGENTDB_BACKEND,
+    """ * AgentDB Backend - Integration with agentdb@2.0.0-alpha.3.4""",
+    """ * AgentDB Backend - Integration with agentdb@3.0.0-alpha.3""")
+
+# ── Op K: helpers-generator.js — .db -> .rvf + v3 config (3 HybridBackend blocks) ──
+# All 3 blocks have identical agentdb config; patch_all replaces them all at once
+patch_all("WM-008k: helpers-generator.js agentdb-memory.db -> .rvf + v3 config",
+    HELPERS_GEN,
+    """      agentdb: { dbPath: join(PROJECT_ROOT, '.swarm', 'agentdb-memory.db') },""",
+    """      agentdb: { dbPath: join(PROJECT_ROOT, '.swarm', 'agentdb-memory.rvf'), vectorBackend: 'rvf' },""")
+
+# ── Op L: auto-memory-hook.mjs (source helper) — .db -> .rvf + v3 config ──
+# createBackend() uses swarmDir variable; patch_all covers any remaining PROJECT_ROOT variants
+patch("WM-008l: auto-memory-hook.mjs createBackend agentdb-memory.db -> .rvf",
+    SRC_AUTO_MEMORY_HOOK,
+    """      agentdb: { dbPath: join(swarmDir, 'agentdb-memory.db') },""",
+    """      agentdb: { dbPath: join(swarmDir, 'agentdb-memory.rvf'), vectorBackend: 'rvf', enableLearning: config.agentdb?.enableLearning !== false },""")
+
+patch_all("WM-008l2: auto-memory-hook.mjs remaining agentdb-memory.db -> .rvf",
+    SRC_AUTO_MEMORY_HOOK,
+    """agentdb-memory.db""",
+    """agentdb-memory.rvf""")
+
+# ── Op M: @claude-flow/neural reasoning-bank.js — vectorBackend 'auto' -> 'rvf' ──
+patch("WM-008m: reasoning-bank.js vectorBackend auto -> rvf",
+    NEURAL_REASONING_BANK,
+    """                        vectorBackend: 'auto',""",
+    """                        vectorBackend: 'rvf',""")
+
+# ── Op N: @claude-flow/shared defaults.js — replace v2 indexType with v3 vectorBackend ──
+patch("WM-008n: shared defaults.js add vectorBackend rvf to agentdb defaults",
+    SHARED_DEFAULTS,
+    """    agentdb: {
+        dimensions: 1536,
+        indexType: 'hnsw',
+        efConstruction: 200,
+        m: 16,
+        quantization: 'none',
+    },""",
+    """    agentdb: {
+        dimensions: 1536,
+        vectorBackend: 'rvf',
+        indexType: 'hnsw',
+        efConstruction: 200,
+        m: 16,
+        quantization: 'none',
+    },""")
+
+# ── Op O: executor.js — update version table from v2 to v3 ──
+patch("WM-008o: executor.js version table agentdb 2.x -> 3.x",
+    EXECUTOR,
+    """| agentdb | 2.0.0-alpha.3.4 | Vector database |""",
+    """| agentdb | 3.0.0-alpha.3 | Vector database (RVF + self-learning) |""")

package/patch/560-WM-008-agentdb-v3-upgrade/fix.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# WM-008: Upgrade agentdb v2 -> v3 in npm cache
+# GitHub: #1207
+# Skips if agentdb is already v3 or not installed
+
+set -euo pipefail
+
+# BASE is set by patch-all.sh to the dist/src directory
+if [ -z "${BASE:-}" ] || [ "$BASE" = "/dev/null" ]; then
+    exit 0  # No @claude-flow/cli found
+fi
+
+# node_modules/@claude-flow/cli/dist/src -> node_modules
+NM_ROOT="$(cd "$BASE/../../../.." 2>/dev/null && pwd)" || exit 0
+AGENTDB_DIR="$NM_ROOT/agentdb"
+
+# Skip if agentdb not installed
+[ -d "$AGENTDB_DIR" ] || exit 0
+
+# Check current version
+CURRENT_VERSION=$(node -e "console.log(require('$AGENTDB_DIR/package.json').version)" 2>/dev/null || echo "unknown")
+if [[ "$CURRENT_VERSION" == 3.* ]]; then
+    echo "  WM-008: agentdb already at v$CURRENT_VERSION (skip)"
+    exit 0
+fi
+
+echo "  WM-008: Upgrading agentdb from v$CURRENT_VERSION to 3.0.0-alpha.3..."
+
+# Pack v3 into a tarball
+WORK=$(mktemp -d)
+trap "rm -rf $WORK" EXIT
+
+(cd "$WORK" && npm pack agentdb@3.0.0-alpha.3 --silent 2>/dev/null) || {
+    echo "  WM-008: WARN -- npm pack failed (offline?), skipping agentdb upgrade"
+    exit 0
+}
+
+TARBALL=$(ls "$WORK"/agentdb-*.tgz 2>/dev/null | head -1)
+if [ -z "$TARBALL" ]; then
+    echo "  WM-008: WARN -- tarball not found, skipping"
+    exit 0
+fi
+
+# Remove old, extract new
+rm -rf "$AGENTDB_DIR"
+mkdir -p "$AGENTDB_DIR"
+tar xzf "$TARBALL" -C "$AGENTDB_DIR" --strip-components=1
+
+echo "  Applied: WM-008 agentdb upgrade to v3.0.0-alpha.3"

package/patch/560-WM-008-agentdb-v3-upgrade/sentinel

@@ -0,0 +1,13 @@
+grep "agentdb-memory.rvf" memory/memory-initializer.js
+grep "vectorBackend: 'rvf'" memory/memory-initializer.js
+grep "enableAgentdbLearning" init/executor.js
+grep "agentdb-memory.rvf" init/helpers-generator.js
+grep "agentdb-memory.rvf" .claude/helpers/auto-memory-hook.mjs
+package: @claude-flow/memory
+grep "SelfLearningRvfBackend" agentdb-backend.js
+grep "vectorBackend: 'rvf'" agentdb-backend.js
+grep "3.0.0-alpha.3" package.json
+package: @claude-flow/neural
+grep "vectorBackend: 'rvf'" dist/reasoning-bank.js
+package: @claude-flow/shared
+grep "vectorBackend: 'rvf'" dist/core/config/defaults.js

package/patch/570-WM-009-agentdb-learning-loop/README.md

@@ -0,0 +1,35 @@
+# WM-009: Wire AgentDB learning loop (recordFeedback)
+
+**Severity**: High
+**GitHub**: [#1209](https://github.com/ruvnet/claude-flow/issues/1209)
+
+## Root Cause
+
+WM-008 upgraded AgentDB v2 to v3 and exposed `recordFeedback(queryId, quality)` on the
+agentdb-backend, but no MCP handler or CLI command ever calls it. The self-learning
+feedback loop is wired at the backend level but dead from the user-facing layer.
+
+`memory-tools.js` MCP handlers (`memory_search`, `memory_retrieve`) never track which
+search results the agent subsequently retrieves. Without this implicit signal, the
+`SelfLearningRvfBackend` cannot learn which results were useful.
+
+## Fix
+
+| Op | Target | Change |
+|----|--------|--------|
+| A | `memory/memory-initializer.js` | Export `recordSearchFeedback(entryId, quality)` that delegates to `_hybridBackend.recordFeedback()` |
+| B | `mcp-tools/memory-tools.js` | Add module-level `_recentSearchHits` Map; populate after `memory_search` returns results |
+| C | `mcp-tools/memory-tools.js` | In `memory_retrieve`, call `recordSearchFeedback` when retrieved key was a recent search hit |
+
+**Implicit feedback signal**: When an agent searches, then retrieves a specific result,
+the retrieval is implicit positive feedback (quality = 1.0). The Map tracks
+`namespace:key` -> `entryId` from the most recent search, enabling the feedback call.
+
+## Files Patched
+
+- `memory/memory-initializer.js`
+- `mcp-tools/memory-tools.js`
+
+## Ops
+
+3 ops in fix.py

package/patch/570-WM-009-agentdb-learning-loop/fix.py

@@ -0,0 +1,141 @@
+# WM-009: Wire AgentDB learning loop (recordFeedback)
+# GitHub: #1209
+
+# ── Op A: Export recordSearchFeedback from memory-initializer.js ──
+# Adds a thin wrapper that delegates to _hybridBackend.recordFeedback()
+# Targets the code just before `export default {` at end of file
+patch("WM-009a: add recordSearchFeedback export to memory-initializer.js",
+    MI,
+    """export default {
+    initializeMemoryDatabase,""",
+    """// WM-009a: Expose search feedback for self-learning loop
+export async function recordSearchFeedback(entryId, quality) {
+    if (!_hybridBackend) return;
+    if (typeof _hybridBackend.recordFeedback === 'function') {
+        try { await _hybridBackend.recordFeedback(entryId, quality); } catch {}
+    }
+}
+export default {
+    initializeMemoryDatabase,""")
+
+# ── Op B: Track search result entry IDs in memory-tools.js ──
+# Adds a module-level Map and patches the import to include recordSearchFeedback.
+patch("WM-009b: import recordSearchFeedback and add _recentSearchHits Map",
+    MCP_MEMORY,
+    """async function getMemoryFunctions() {
+    const { storeEntry, searchEntries, listEntries, getEntry, deleteEntry, initializeMemoryDatabase, checkMemoryInitialization, } = await import('../memory/memory-initializer.js');
+    return {
+        storeEntry,
+        searchEntries,
+        listEntries,
+        getEntry,
+        deleteEntry,
+        initializeMemoryDatabase,
+        checkMemoryInitialization,
+    };
+}""",
+    """// WM-009b: Track recent search hits for implicit feedback
+const _recentSearchHits = new Map();
+async function getMemoryFunctions() {
+    const { storeEntry, searchEntries, listEntries, getEntry, deleteEntry, initializeMemoryDatabase, checkMemoryInitialization, recordSearchFeedback, } = await import('../memory/memory-initializer.js');
+    return {
+        storeEntry,
+        searchEntries,
+        listEntries,
+        getEntry,
+        deleteEntry,
+        initializeMemoryDatabase,
+        checkMemoryInitialization,
+        recordSearchFeedback,
+    };
+}""")
+
+# ── Op C: Populate _recentSearchHits after search returns results ──
+# After results are mapped and before the return, record entry IDs in the Map.
+# The raw result.results from searchEntries include .id fields from the backend.
+patch("WM-009c: populate _recentSearchHits after memory_search",
+    MCP_MEMORY,
+    """                const results = result.results.map(r => {
+                    let value = r.content;
+                    try {
+                        value = JSON.parse(r.content);
+                    }
+                    catch {
+                        // Keep as string
+                    }
+                    return {
+                        key: r.key,
+                        namespace: r.namespace,
+                        value,
+                        similarity: r.score,
+                    };
+                });
+                return {
+                    query,
+                    results,
+                    total: results.length,
+                    searchTime: `${duration.toFixed(2)}ms`,
+                    backend: 'HNSW + sql.js',
+                };""",
+    """                const results = result.results.map(r => {
+                    let value = r.content;
+                    try {
+                        value = JSON.parse(r.content);
+                    }
+                    catch {
+                        // Keep as string
+                    }
+                    // WM-009c: Track entry ID for implicit feedback on later retrieve
+                    if (r.id && r.key) {
+                        const ns = r.namespace || 'default';
+                        _recentSearchHits.set(`${ns}:${r.key}`, r.id);
+                    }
+                    return {
+                        key: r.key,
+                        namespace: r.namespace,
+                        value,
+                        similarity: r.score,
+                    };
+                });
+                return {
+                    query,
+                    results,
+                    total: results.length,
+                    searchTime: `${duration.toFixed(2)}ms`,
+                    backend: 'HNSW + sql.js',
+                };""")
+
+# ── Op D: Record implicit positive feedback on retrieve ──
+# When memory_retrieve successfully finds an entry that was in recent search results,
+# call recordSearchFeedback with quality 1.0 (positive implicit feedback).
+patch("WM-009d: call recordSearchFeedback on retrieve of recent search hit",
+    MCP_MEMORY,
+    """        handler: async (input) => {
+            await ensureInitialized();
+            const { getEntry } = await getMemoryFunctions();
+            const key = input.key;
+            const namespace = input.namespace;
+            if (!namespace || namespace === 'all') {
+                throw new Error('Namespace is required (cannot be "all"). Use namespace: "patterns", "solutions", or "tasks"');
+            }
+            try {
+                const result = await getEntry({ key, namespace });
+                if (result.found && result.entry) {""",
+    """        handler: async (input) => {
+            await ensureInitialized();
+            const { getEntry, recordSearchFeedback } = await getMemoryFunctions();
+            const key = input.key;
+            const namespace = input.namespace;
+            if (!namespace || namespace === 'all') {
+                throw new Error('Namespace is required (cannot be "all"). Use namespace: "patterns", "solutions", or "tasks"');
+            }
+            try {
+                const result = await getEntry({ key, namespace });
+                if (result.found && result.entry) {
+                    // WM-009d: Implicit positive feedback — agent retrieved a search hit
+                    const hitKey = `${namespace}:${key}`;
+                    const trackedId = _recentSearchHits.get(hitKey);
+                    if (trackedId && recordSearchFeedback) {
+                        _recentSearchHits.delete(hitKey);
+                        recordSearchFeedback(trackedId, 1.0).catch(() => {});
+                    }""")

package/patch/570-WM-009-agentdb-learning-loop/sentinel

@@ -0,0 +1,3 @@
+grep "_recentSearchHits" mcp-tools/memory-tools.js
+grep "recordSearchFeedback" memory/memory-initializer.js
+grep "WM-009d" mcp-tools/memory-tools.js

package/patch/580-WM-010-witness-chain-verify/README.md

@@ -0,0 +1,33 @@
+# WM-010: Wire witness chain verification at session start
+
+**Severity**: High
+**GitHub**: [#1208](https://github.com/ruvnet/claude-flow/issues/1208)
+
+## Root Cause
+
+WM-008 exposed `verifyWitnessChain()` and `getWitnessChain()` methods on the
+AgentDB backend, but no code in the session lifecycle actually calls them. The
+witness chain hash is captured at init time (WM-008d) but never verified during
+`doImport()`, so tampered memory databases go undetected at session start.
+
+## Fix
+
+Patch `doImport()` in both the helpers-generator template and the source hook
+to call `backend.verifyWitnessChain()` after `backend.initialize()`. The
+verification is wrapped in try/catch so it is non-fatal -- if the backend
+doesn't support witness chains (e.g. JSON backend or AgentDB v2), it silently
+skips.
+
+| Op | Target | Change |
+|----|--------|--------|
+| WM-010a | `init/helpers-generator.js` | After `await backend.initialize()` + busy_timeout in doImport template, add witness chain verification |
+| WM-010b | `.claude/helpers/auto-memory-hook.mjs` | After `await backend.initialize()` + busy_timeout in doImport, add witness chain verification |
+
+## Files Patched
+
+- `init/helpers-generator.js`
+- `.claude/helpers/auto-memory-hook.mjs` (source hook)
+
+## Ops
+
+2 ops in fix.py

package/patch/580-WM-010-witness-chain-verify/fix.py

@@ -0,0 +1,45 @@
+# WM-010: Wire witness chain verification at session start
+# GitHub: #1208
+
+# ── Op A: helpers-generator.js doImport() — add witness chain verify after init ──
+# Targets the state AFTER WM-003a (doImport HybridBackend) has been applied.
+# Unique context: "const sqlBe = backend.getSQLiteBackend();" only appears in doImport
+# (doSync uses different code after initialize).
+patch("WM-010a: helpers-generator doImport() witness chain verification",
+    HELPERS_GEN,
+    """    await backend.initialize();
+    const sqlBe = backend.getSQLiteBackend();
+    if (sqlBe && sqlBe.db) sqlBe.db.pragma('busy_timeout = 5000');
+    const bridge = new AutoMemoryBridge(backend, {""",
+    """    await backend.initialize();
+    const sqlBe = backend.getSQLiteBackend();
+    if (sqlBe && sqlBe.db) sqlBe.db.pragma('busy_timeout = 5000');
+    // WM-010a: Verify witness chain integrity at session start
+    try {
+      if (typeof backend.verifyWitnessChain === 'function') {
+        const wc = await backend.verifyWitnessChain();
+        if (wc && !wc.valid) dim('WARNING: witness chain verification failed \\u2014 memory may be tampered');
+      }
+    } catch (e) { /* witness chain not available, skip */ }
+    const bridge = new AutoMemoryBridge(backend, {""")
+
+# ── Op B: auto-memory-hook.mjs doImport() — add witness chain verify after init ──
+# Targets the state AFTER WM-004b (createBackend).
+# Unique context: "await backend.initialize();\n\n  const bridgeConfig" only in doImport
+# (doSync has "const entryCount" after initialize, not "const bridgeConfig").
+patch("WM-010b: source hook doImport() witness chain verification",
+    SRC_AUTO_MEMORY_HOOK,
+    """  await backend.initialize();
+
+  const bridgeConfig = {""",
+    """  await backend.initialize();
+
+  // WM-010b: Verify witness chain integrity at session start
+  try {
+    if (typeof backend.verifyWitnessChain === 'function') {
+      const wc = await backend.verifyWitnessChain();
+      if (wc && !wc.valid) dim('WARNING: witness chain verification failed \u2014 memory may be tampered');
+    }
+  } catch { /* witness chain not available, skip */ }
+
+  const bridgeConfig = {""")

package/patch/580-WM-010-witness-chain-verify/sentinel

@@ -0,0 +1 @@
+grep "WM-010a" init/helpers-generator.js

package/patch/590-WM-011-reasoning-bank-controller/README.md

@@ -0,0 +1,34 @@
+# WM-011: Instantiate ReasoningBank controller
+
+**Severity**: High
+**GitHub**: [#1210](https://github.com/ruvnet/claude-flow/issues/1210)
+
+## Root Cause
+
+`memory-initializer.js` creates HybridBackend + AgentDB v3 but never instantiates `ReasoningBank` from `@claude-flow/neural`. The `hooks_intelligence_pattern-store` and `hooks_intelligence_pattern-search` MCP tools use generic `storeEntry`/`searchEntries` which lack the ReasoningBank's 4-step learning pipeline (retrieve, judge, distill, consolidate), MMR-diverse retrieval, deduplication, and contradiction detection.
+
+As a result:
+- Patterns stored as plain key-value entries instead of trajectory-backed patterns
+- Pattern search uses generic SQLite/keyword search instead of MMR-diverse vector retrieval
+- Consolidation pipeline never runs (dedup, contradiction detection, pruning)
+- Pattern evolution tracking and quality history are lost
+
+## Fix
+
+| Op | Target | Change |
+|----|--------|--------|
+| WM-011a | `memory/memory-initializer.js` | After HybridBackend init, import `ReasoningBank` from `@claude-flow/neural` and create+initialize an instance sharing the AgentDB RVF path |
+| WM-011a2 | `memory/memory-initializer.js` | Add `_reasoningBank` module-level variable declaration |
+| WM-011a3 | `memory/memory-initializer.js` | Export `getReasoningBank()` getter function |
+| WM-011b | `mcp-tools/hooks-tools.js` | Add `getReasoningBankInstance()` lazy loader |
+| WM-011c | `mcp-tools/hooks-tools.js` | Replace `hooksPatternStore` handler to use ReasoningBank trajectory distillation with fallback |
+| WM-011d | `mcp-tools/hooks-tools.js` | Replace `hooksPatternSearch` handler to use ReasoningBank MMR-diverse retrieval with fallback |
+
+## Files Patched
+
+- `memory/memory-initializer.js`
+- `mcp-tools/hooks-tools.js`
+
+## Ops
+
+6 ops in fix.py