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

package/patch/160-HW-003-aggressive-intervals/fix.py

@@ -0,0 +1,52 @@
+# HW-003: Worker scheduling intervals too aggressive
+# GitHub: #1113
+patch("3: audit 30m",
+    WD,
+    "type: 'audit', intervalMs: 10 * 60 * 1000",
+    "type: 'audit', intervalMs: 30 * 60 * 1000")
+
+patch("3: optimize 60m",
+    WD,
+    "type: 'optimize', intervalMs: 15 * 60 * 1000",
+    "type: 'optimize', intervalMs: 60 * 60 * 1000")
+
+patch("3: testgaps 60m",
+    WD,
+    "type: 'testgaps', intervalMs: 20 * 60 * 1000",
+    "type: 'testgaps', intervalMs: 60 * 60 * 1000")
+
+# HW-003 extension: Read daemon.schedules from .claude/settings.json
+# and merge user-configured intervals into worker defaults
+patch("3: settings-driven intervals",
+    WD,
+    "            workers: config?.workers ?? DEFAULT_WORKERS,",
+    """            workers: (() => {
+                const base = config?.workers ?? DEFAULT_WORKERS;
+                try {
+                    const sp = join(projectRoot, '.claude', 'settings.json');
+                    const s = JSON.parse(readFileSync(sp, 'utf-8'));
+                    const schedules = s?.claudeFlow?.daemon?.schedules;
+                    if (!schedules || typeof schedules !== 'object') return base;
+                    const parseInterval = (v) => {
+                        if (typeof v === 'number') return v;
+                        if (typeof v !== 'string') return null;
+                        const m = v.match(/^(\\d+(?:\\.\\d+)?)\\s*(ms|s|m|h)$/i);
+                        if (!m) return null;
+                        const n = parseFloat(m[1]);
+                        switch (m[2].toLowerCase()) {
+                            case 'ms': return n;
+                            case 's': return n * 1000;
+                            case 'm': return n * 60 * 1000;
+                            case 'h': return n * 3600 * 1000;
+                            default: return null;
+                        }
+                    };
+                    return base.map(w => {
+                        const sched = schedules[w.type];
+                        if (!sched) return w;
+                        const iv = parseInterval(sched.interval ?? sched.intervalMs);
+                        const en = typeof sched.enabled === 'boolean' ? sched.enabled : w.enabled;
+                        return { ...w, ...(iv !== null ? { intervalMs: iv } : {}), enabled: en };
+                    });
+                } catch { return base; }
+            })(),""")

package/patch/160-HW-003-aggressive-intervals/sentinel

@@ -0,0 +1,3 @@
+grep "intervalMs: 30" services/worker-daemon.js
+grep "parseInterval" services/worker-daemon.js
+grep "daemon?.schedules" services/worker-daemon.js

package/patch/170-IN-001-intelligence-stub/README.md

@@ -0,0 +1,64 @@
+# IN-001: intelligence.cjs is a stub that doesn't actually learn
+
+**Severity**: Critical
+**GitHub**: [#1154](https://github.com/ruvnet/claude-flow/issues/1154)
+**Status**: RESOLVED
+
+## Root Cause
+
+`findSourceHelpersDir()` in `dist/src/init/executor.js` (line 855) fails to resolve the package's `.claude/helpers/` directory when running via npx. It tries 4 path strategies, all fail with npx-cached installs. The comment at line 395 says it explicitly: *"Source not found (npx with broken paths) — use generated fallbacks"*.
+
+This causes `executeUpgrade()` to call `generateIntelligenceStub()` (from `helpers-generator.js` line 557) instead of copying the real file. The stub is 197 lines with:
+- `feedback()` as a no-op
+- `consolidate()` that counts lines and wipes the file
+- `getContext()` using simple Jaccard word overlap with no learning
+- No PageRank, no graph, no confidence tracking
+
+## The Full Version Exists in the Package
+
+The **916-line full `intelligence.cjs`** ships in the `@claude-flow/cli` package at:
+```
+node_modules/@claude-flow/cli/.claude/helpers/intelligence.cjs
+```
+
+It implements:
+- PageRank-ranked memory graph (nodes, edges, power iteration with damping)
+- Trigram matching with stop-word filtering
+- Confidence feedback loop (boost on success, decay on failure)
+- Consolidation: insight generation for hot files, confidence decay for stale entries, graph rebuild
+- Snapshot-based trend tracking (up to 50 snapshots)
+- Bootstrap from MEMORY.md files when store is empty
+- Same 6-method API: `{ init, getContext, recordEdit, feedback, consolidate, stats }`
+- Same data directory: `.claude-flow/data/`
+
+## Fix
+
+Copy the full `intelligence.cjs` from the package to replace the stub:
+
+```bash
+# Find the package's helpers directory
+SRC=$(find ~/.npm/_npx -path '*/@claude-flow/cli/.claude/helpers/intelligence.cjs' 2>/dev/null | head -1)
+
+# Copy to project
+cp "$SRC" .claude/helpers/intelligence.cjs
+```
+
+This is a drop-in replacement — same export signature, same data files, additive new files (`graph-state.json`, `intelligence-snapshot.json`).
+
+## Verification
+
+```bash
+# Should show nodes > 0, edges > 0 (stub always showed edges: 0)
+node .claude/helpers/intelligence.cjs stats
+
+# Should show PageRank sum ~1.0
+node .claude/helpers/intelligence.cjs stats --json
+```
+
+## Files Patched
+
+- `init/executor.js`
+
+## Ops
+
+2 ops in fix.py

package/patch/170-IN-001-intelligence-stub/fix.py

@@ -0,0 +1,63 @@
+# IN-001: intelligence.cjs generated as stub instead of full version
+# GitHub: #1154
+#
+# When findSourceHelpersDir() fails (npx broken paths), the fallback calls
+# generateIntelligenceStub() — a 197-line no-op. The full 916-line version
+# ships in the package at .claude/helpers/intelligence.cjs.
+#
+# Fix: In both fallback paths, try reading the real file from the package
+# root (via __dirname) before falling back to the stub.
+# 2 ops: upgrade path (line ~398) + writeHelpers path (line ~943)
+
+# Op 1: Upgrade path — when findSourceHelpersDir() returns null
+# old/new strings stop BEFORE generatedCritical to avoid overlap with SG-003j
+patch("IN-001a: upgrade fallback reads real intelligence.cjs",
+    EXECUTOR,
+    """        else {
+            // Source not found (npx with broken paths) — use generated fallbacks
+            const generatedCritical = {""",
+    """        else {
+            // Source not found (npx with broken paths) — use generated fallbacks
+            // IN-001: Try reading real intelligence.cjs from package before using stub
+            let intelligenceContent = generateIntelligenceStub();
+            try {
+                const realPath = path.resolve(__dirname, '..', '..', '..', '.claude', 'helpers', 'intelligence.cjs');
+                if (fs.existsSync(realPath)) {
+                    intelligenceContent = fs.readFileSync(realPath, 'utf-8');
+                }
+            } catch { /* use stub */ }
+            const generatedCritical = {""")
+
+# Op 2: writeHelpers path — fresh init when source dir not found
+patch("IN-001b: writeHelpers fallback reads real intelligence.cjs",
+    EXECUTOR,
+    """    // Fall back to generating helpers if source not available
+    const helpers = {
+        'pre-commit': generatePreCommitHook(),
+        'post-commit': generatePostCommitHook(),
+        'session.js': generateSessionManager(),
+        'router.js': generateAgentRouter(),
+        'memory.js': generateMemoryHelper(),
+        'hook-handler.cjs': generateHookHandler(),
+        'intelligence.cjs': generateIntelligenceStub(),
+        'auto-memory-hook.mjs': generateAutoMemoryHook(),
+    };""",
+    """    // Fall back to generating helpers if source not available
+    // IN-001: Try reading real intelligence.cjs from package before using stub
+    let intelligenceForInit = generateIntelligenceStub();
+    try {
+        const realIntelPath = path.resolve(__dirname, '..', '..', '..', '.claude', 'helpers', 'intelligence.cjs');
+        if (fs.existsSync(realIntelPath)) {
+            intelligenceForInit = fs.readFileSync(realIntelPath, 'utf-8');
+        }
+    } catch { /* use stub */ }
+    const helpers = {
+        'pre-commit': generatePreCommitHook(),
+        'post-commit': generatePostCommitHook(),
+        'session.cjs': generateSessionManager(),
+        'router.cjs': generateAgentRouter(),
+        'memory.cjs': generateMemoryHelper(),
+        'hook-handler.cjs': generateHookHandler(),
+        'intelligence.cjs': intelligenceForInit,
+        'auto-memory-hook.mjs': generateAutoMemoryHook(),
+    };""")

package/patch/170-IN-001-intelligence-stub/sentinel

@@ -0,0 +1 @@
+grep "intelligenceContent" init/executor.js

package/patch/180-MM-001-memory-persist-path/README.md

@@ -0,0 +1,27 @@
+# MM-001: Remove dead persistPath config option
+
+**Severity**: Low
+**GitHub**: [#1152](https://github.com/ruvnet/claude-flow/issues/1152)
+
+## Root Cause
+
+The `init` command generates a `persistPath: .claude-flow/data` setting in config.yaml, but **nothing reads it**. All memory storage code (15+ locations across memory-initializer.js and ruvector modules) uses hardcoded `.swarm/` paths.
+
+This creates user confusion: the config suggests data goes to `.claude-flow/data/` but it actually goes to `.swarm/`.
+
+## Fix
+
+Rather than patching 15+ files to respect the config, we:
+1. Remove the misleading `persistPath` line from the generated config.yaml
+2. Revert any previous attempts to read this config (restore `.swarm/` hardcoding)
+
+This aligns the config with actual behavior - all data lives in `.swarm/`.
+
+## Files Patched
+
+- init/executor.js (remove persistPath from config template)
+- memory/memory-initializer.js (revert config-reading code if present)
+
+## Ops
+
+2 ops in fix.py

package/patch/180-MM-001-memory-persist-path/fix.py

@@ -0,0 +1,54 @@
+# MM-001: Remove dead persistPath config from init command
+# The persistPath setting is generated but never consumed - all code uses hardcoded .swarm/
+# Rather than patching 15+ files to respect it, we remove the misleading config option.
+
+# First: Revert any previous MM-001 patch that tried to read persistPath
+patch("MM-001: revert config reading (restore .swarm/ hardcoding)",
+    MI,
+    """        // MM-001: Read persistPath from config instead of hardcoding .swarm/
+        let dataDir = path.join(process.cwd(), '.swarm'); // fallback
+        try {
+            const configJsonPath = path.join(process.cwd(), '.claude-flow', 'config.json');
+            const configYamlPath = path.join(process.cwd(), '.claude-flow', 'config.yaml');
+            if (fs.existsSync(configJsonPath)) {
+                const config = JSON.parse(fs.readFileSync(configJsonPath, 'utf-8'));
+                const persistPath = config.values?.['memory.persistPath'];
+                if (persistPath) {
+                    dataDir = path.isAbsolute(persistPath) ? persistPath : path.join(process.cwd(), persistPath);
+                }
+            } else if (fs.existsSync(configYamlPath)) {
+                const yamlContent = fs.readFileSync(configYamlPath, 'utf-8');
+                const match = yamlContent.match(/persistPath:\\s*([^\\n]+)/);
+                if (match) {
+                    const persistPath = match[1].trim();
+                    dataDir = path.isAbsolute(persistPath) ? persistPath : path.join(process.cwd(), persistPath);
+                }
+            }
+        } catch { /* use fallback */ }
+        if (!fs.existsSync(dataDir)) {
+            fs.mkdirSync(dataDir, { recursive: true });
+        }
+        const hnswPath = path.join(dataDir, 'hnsw.index');
+        const metadataPath = path.join(dataDir, 'hnsw.metadata.json');
+        const dbPath = options?.dbPath || path.join(dataDir, 'memory.db');""",
+    """        // Persistent storage paths
+        const swarmDir = path.join(process.cwd(), '.swarm');
+        if (!fs.existsSync(swarmDir)) {
+            fs.mkdirSync(swarmDir, { recursive: true });
+        }
+        const hnswPath = path.join(swarmDir, 'hnsw.index');
+        const metadataPath = path.join(swarmDir, 'hnsw.metadata.json');
+        const dbPath = options?.dbPath || path.join(swarmDir, 'memory.db');""")
+
+# Second: Remove persistPath from generated config.yaml (init/executor.js)
+patch("MM-001: remove persistPath from config.yaml template",
+    EXECUTOR,
+    """memory:
+  backend: ${options.runtime.memoryBackend}
+  enableHNSW: ${options.runtime.enableHNSW}
+  persistPath: .claude-flow/data
+  cacheSize: 100""",
+    """memory:
+  backend: ${options.runtime.memoryBackend}
+  enableHNSW: ${options.runtime.enableHNSW}
+  cacheSize: 100""")

package/patch/180-MM-001-memory-persist-path/sentinel

@@ -0,0 +1 @@
+absent "persistPath: .claude-flow/data" init/executor.js

package/patch/190-NS-001-discovery-default-namespace/README.md

@@ -0,0 +1,16 @@
+# NS-001: Discovery ops default to wrong namespace
+**Severity**: Critical
+**GitHub**: [#1123](https://github.com/ruvnet/claude-flow/issues/1123)
+## Root Cause
+MCP `memory_search` defaulted to `namespace='default'`, but entries live in 'patterns', 'solutions', etc. Every MCP search returned 0 results. MCP `memory_list` had no 'all' support — truthiness check treated 'all' as truthy, generating `WHERE namespace = 'all'` which returns 0 results.
+## Rule
+Discovery ops (search, list) default to 'all' — search across all namespaces.
+## Fix
+MCP search, core searchEntries(), embeddings search, MCP list, CLI list all default to 'all'. Core listEntries() uses nsFilter variable to distinguish between 'all' sentinel and real namespace filtering.
+## Files Patched
+- mcp-tools/memory-tools.js (search + list)
+- mcp-tools/embeddings-tools.js (search)
+- memory/memory-initializer.js (searchEntries, listEntries)
+- commands/memory.js (CLI list)
+## Ops
+10 ops in fix.py (19a-e + 21c,d,g,i,j)

package/patch/190-NS-001-discovery-default-namespace/fix.py

@@ -0,0 +1,68 @@
+# NS-001: Discovery ops (search + list) default to wrong namespace
+# GitHub: #1123
+# Rule: Default to 'all' (search across all namespaces)
+# 10 ops: 19a-e (search) + 21c,d,g,i,j (list)
+
+# ── Search ops (from old Patch 19) ──
+
+# 19a: MCP search handler — change default from 'default' to 'all'
+patch("19a: MCP search namespace default",
+    MCP_MEMORY,
+    "const query = input.query;\n            const namespace = input.namespace || 'default';",
+    "const query = input.query;\n            const namespace = input.namespace || 'all';")
+
+# 19b: MCP search schema — update description to reflect 'all' default
+patch("19b: MCP search namespace description",
+    MCP_MEMORY,
+    """namespace: { type: 'string', description: 'Namespace to search (default: "default")' }""",
+    """namespace: { type: 'string', description: 'Namespace to search (default: "all" = all namespaces)' }""")
+
+# 19c: Core searchEntries() — change function default from 'default' to 'all'
+patch("19c: searchEntries default all",
+    MI,
+    "const { query, namespace = 'default', limit = 10, threshold = 0.3, dbPath: customPath } = options;",
+    "const { query, namespace = 'all', limit = 10, threshold = 0.3, dbPath: customPath } = options;")
+
+# 19d: Embeddings search — pass 'all' instead of 'default' to searchEntries
+patch("19d: embeddings search namespace all",
+    EMB_TOOLS,
+    "namespace: namespace || 'default'\n                });",
+    "namespace: namespace || 'all'\n                });")
+
+# 19e: Embeddings metadata — all occurrences of namespace fallback
+patch_all("19e: embeddings metadata namespace all",
+    EMB_TOOLS,
+    "namespace: namespace || 'default',",
+    "namespace: namespace || 'all',")
+
+# ── List ops (from old Patch 21) ──
+
+# 21c: MCP list — update description to reflect 'all' default
+patch("21c: MCP list namespace description",
+    MCP_MEMORY,
+    "namespace: { type: 'string', description: 'Filter by namespace' },",
+    "namespace: { type: 'string', description: 'Namespace to list (default: \"all\" = all namespaces)' },")
+
+# 21d: MCP list — default to 'all' (read-only discovery, like search)
+patch("21d: MCP list namespace default all",
+    MCP_MEMORY,
+    "const { listEntries } = await getMemoryFunctions();\n            const namespace = input.namespace;\n            const limit = input.limit || 50;",
+    "const { listEntries } = await getMemoryFunctions();\n            const namespace = input.namespace || 'all';\n            const limit = input.limit || 50;")
+
+# 21g: CLI list — default to 'all' (read-only discovery, like search)
+patch("21g: CLI list namespace default all",
+    CLI_MEMORY,
+    "        const namespace = ctx.flags.namespace;\n        const limit = ctx.flags.limit;\n        // Use sql.js directly for consistent data access",
+    "        const namespace = ctx.flags.namespace || 'all';\n        const limit = ctx.flags.limit;\n        // Use sql.js directly for consistent data access")
+
+# 21i: Core listEntries() — use nsFilter variable instead of truthiness check
+patch("21i: listEntries nsFilter variable",
+    MI,
+    "        // Get total count\n        const countQuery = namespace",
+    "        // Get total count\n        const nsFilter = namespace && namespace !== 'all';\n        const countQuery = nsFilter")
+
+# 21j: Core listEntries() — use nsFilter in list query too
+patch("21j: listEntries listQuery all support",
+    MI,
+    "        ${namespace ? `AND namespace",
+    "        ${nsFilter ? `AND namespace")

package/patch/190-NS-001-discovery-default-namespace/sentinel

@@ -0,0 +1,2 @@
+grep "all namespaces" mcp-tools/memory-tools.js
+grep "nsFilter" memory/memory-initializer.js

package/patch/200-NS-002-targeted-require-namespace/README.md

@@ -0,0 +1,19 @@
+# NS-002: Store/delete/retrieve fall back to 'default' + accept 'all'
+**Severity**: Critical
+**GitHub**: [#581](https://github.com/ruvnet/claude-flow/issues/581)
+## Root Cause
+MCP/CLI/Core used `namespace || 'default'`, silently routing entries to wrong namespace. Also accepted 'all' (search/list sentinel) as a write namespace, creating invisible entries.
+## Rule
+Targeted ops (store, delete, retrieve) require explicit namespace. Block 'all' with clear error.
+## Fix
+Remove fallback. Add 'namespace' to MCP schema required fields. Add runtime throw for missing/invalid namespace. CLI commands check before executing. Core functions throw on missing namespace.
+## Files Patched
+- mcp-tools/memory-tools.js (store, delete, retrieve)
+- commands/memory.js (store, delete, retrieve)
+- memory/memory-initializer.js (storeEntry, deleteEntry, getEntry)
+## Dependencies
+
+Depends on NS-001 (190) — NS-002 builds on the namespace discovery changes from NS-001.
+
+## Ops
+14 ops in fix.py (20a-i + 21a,b,e,f,h)

package/patch/200-NS-002-targeted-require-namespace/fix.py

@@ -0,0 +1,158 @@
+# NS-002: Targeted ops (store/delete/retrieve) accept wrong namespace
+# GitHub: #581
+# Rule: Require explicit namespace, block 'all'
+# 14 ops: 20a-i (store/delete) + 21a,b,e,f,h (retrieve)
+
+# ── Store ops (from old Patch 20) ──
+
+# 20a: MCP store — add 'namespace' to required fields in schema
+patch("20a: MCP store require namespace",
+    MCP_MEMORY,
+    "required: ['key', 'value'],",
+    "required: ['key', 'value', 'namespace'],")
+
+# 20b: MCP store — remove || 'default' fallback + add runtime throw
+patch("20b: MCP store namespace no fallback",
+    MCP_MEMORY,
+    "const namespace = input.namespace || 'default';\n            const value = typeof",
+    "const namespace = input.namespace;\n            if (!namespace || namespace === 'all') {\n                throw new Error('Namespace is required (cannot be \"all\"). Use namespace: \"patterns\", \"solutions\", or \"tasks\"');\n            }\n            const value = typeof")
+
+# 20c: MCP delete — add 'namespace' to required + update description
+patch("20c: MCP delete require namespace",
+    MCP_MEMORY,
+    """        description: 'Delete a memory entry by key',
+        category: 'memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                namespace: { type: 'string', description: 'Namespace (default: "default")' },
+            },
+            required: ['key'],""",
+    """        description: 'Delete a memory entry by key',
+        category: 'memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                namespace: { type: 'string', description: 'Namespace (e.g. "patterns", "solutions", "tasks")' },
+            },
+            required: ['key', 'namespace'],""")
+
+# 20d: MCP delete — remove || 'default' fallback + add runtime throw
+patch("20d: MCP delete namespace no fallback",
+    MCP_MEMORY,
+    "const { deleteEntry } = await getMemoryFunctions();\n            const key = input.key;\n            const namespace = input.namespace || 'default';",
+    "const { deleteEntry } = await getMemoryFunctions();\n            const key = input.key;\n            const namespace = input.namespace;\n            if (!namespace || namespace === 'all') {\n                throw new Error('Namespace is required (cannot be \"all\"). Use namespace: \"patterns\", \"solutions\", or \"tasks\"');\n            }")
+
+# 20e: CLI store — add namespace-required check after key check
+patch("20e: CLI store require namespace",
+    CLI_MEMORY,
+    """        if (!key) {
+            output.printError('Key is required. Use --key or -k');
+            return { success: false, exitCode: 1 };
+        }
+        if (!value && ctx.interactive) {""",
+    """        if (!key) {
+            output.printError('Key is required. Use --key or -k');
+            return { success: false, exitCode: 1 };
+        }
+        if (!namespace || namespace === 'all') {
+            output.printError('Namespace is required (cannot be "all"). Use --namespace or -n (e.g. "patterns", "solutions", "tasks")');
+            return { success: false, exitCode: 1 };
+        }
+        if (!value && ctx.interactive) {""")
+
+# 20f: CLI delete — remove || 'default' fallback and fix error message
+patch("20f: CLI delete namespace no fallback",
+    CLI_MEMORY,
+    "const namespace = ctx.flags.namespace || 'default';\n        const force = ctx.flags.force;\n        if (!key) {\n            output.printError('Key is required. Use: memory delete -k \"key\" [-n \"namespace\"]');",
+    "const namespace = ctx.flags.namespace;\n        const force = ctx.flags.force;\n        if (!key) {\n            output.printError('Key is required. Use: memory delete -k \"key\" -n \"namespace\"');")
+
+# 20g: CLI delete — add namespace-required check
+patch("20g: CLI delete namespace check",
+    CLI_MEMORY,
+    """            output.printError('Key is required. Use: memory delete -k "key" -n "namespace"');
+            return { success: false, exitCode: 1 };
+        }
+        if (!force && ctx.interactive) {""",
+    """            output.printError('Key is required. Use: memory delete -k "key" -n "namespace"');
+            return { success: false, exitCode: 1 };
+        }
+        if (!namespace || namespace === 'all') {
+            output.printError('Namespace is required (cannot be "all"). Use: memory delete -k "key" -n "namespace" (e.g. "patterns", "solutions", "tasks")');
+            return { success: false, exitCode: 1 };
+        }
+        if (!force && ctx.interactive) {""")
+
+# 20h: Core storeEntry() — remove dead 'default' parameter default + throw
+patch("20h: storeEntry no default namespace",
+    MI,
+    "const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;",
+    "const { key, value, namespace, generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;\n    if (!namespace || namespace === 'all') throw new Error('storeEntry: namespace is required (cannot be \"all\")');")
+
+# 20i: Core deleteEntry() — remove dead 'default' parameter default + throw
+patch("20i: deleteEntry no default namespace",
+    MI,
+    "export async function deleteEntry(options) {\n    const { key, namespace = 'default', dbPath: customPath } = options;\n    const swarmDir = path.join(process.cwd(), '.swarm');\n    const dbPath = customPath || path.join(swarmDir, 'memory.db');",
+    "export async function deleteEntry(options) {\n    const { key, namespace, dbPath: customPath } = options;\n    if (!namespace || namespace === 'all') throw new Error('deleteEntry: namespace is required (cannot be \"all\")');\n    const swarmDir = path.join(process.cwd(), '.swarm');\n    const dbPath = customPath || path.join(swarmDir, 'memory.db');")
+
+# ── Retrieve ops (from old Patch 21) ──
+
+# 21a: MCP retrieve — add 'namespace' to required + update description
+patch("21a: MCP retrieve require namespace",
+    MCP_MEMORY,
+    """        description: 'Retrieve a value from memory by key',
+        category: 'memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                namespace: { type: 'string', description: 'Namespace (default: "default")' },
+            },
+            required: ['key'],""",
+    """        description: 'Retrieve a value from memory by key',
+        category: 'memory',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Memory key' },
+                namespace: { type: 'string', description: 'Namespace (e.g. "patterns", "solutions", "tasks")' },
+            },
+            required: ['key', 'namespace'],""")
+
+# 21b: MCP retrieve — remove || 'default' fallback + add runtime throw
+patch("21b: MCP retrieve namespace no fallback",
+    MCP_MEMORY,
+    "const { getEntry } = await getMemoryFunctions();\n            const key = input.key;\n            const namespace = input.namespace || 'default';",
+    "const { getEntry } = await getMemoryFunctions();\n            const key = input.key;\n            const namespace = input.namespace;\n            if (!namespace || namespace === 'all') {\n                throw new Error('Namespace is required (cannot be \"all\"). Use namespace: \"patterns\", \"solutions\", or \"tasks\"');\n            }")
+
+# 21e: CLI retrieve — remove default: 'default' from flag definition
+patch("21e: CLI retrieve remove default",
+    CLI_MEMORY,
+    "            type: 'string',\n            default: 'default'\n        }\n    ],\n    action: async (ctx) => {\n        const key = ctx.flags.key || ctx.args[0];\n        const namespace = ctx.flags.namespace;\n        if (!key) {\n            output.printError('Key is required');",
+    "            type: 'string'\n        }\n    ],\n    action: async (ctx) => {\n        const key = ctx.flags.key || ctx.args[0];\n        const namespace = ctx.flags.namespace;\n        if (!key) {\n            output.printError('Key is required');")
+
+# 21f: CLI retrieve — add namespace-required check
+patch("21f: CLI retrieve namespace check",
+    CLI_MEMORY,
+    """        if (!key) {
+            output.printError('Key is required');
+            return { success: false, exitCode: 1 };
+        }
+        // Use sql.js directly for consistent data access""",
+    """        if (!key) {
+            output.printError('Key is required');
+            return { success: false, exitCode: 1 };
+        }
+        if (!namespace || namespace === 'all') {
+            output.printError('Namespace is required (cannot be "all"). Use --namespace or -n (e.g. "patterns", "solutions", "tasks")');
+            return { success: false, exitCode: 1 };
+        }
+        // Use sql.js directly for consistent data access""")
+
+# 21h: Core getEntry() — remove dead 'default' parameter default + throw
+patch("21h: getEntry no default namespace",
+    MI,
+    "const { key, namespace = 'default', dbPath: customPath } = options;\n    const swarmDir = path.join(process.cwd(), '.swarm');\n    const dbPath = customPath || path.join(swarmDir, 'memory.db');",
+    "const { key, namespace, dbPath: customPath } = options;\n    if (!namespace || namespace === 'all') throw new Error('getEntry: namespace is required (cannot be \"all\")');\n    const swarmDir = path.join(process.cwd(), '.swarm');\n    const dbPath = customPath || path.join(swarmDir, 'memory.db');")

package/patch/200-NS-002-targeted-require-namespace/sentinel

@@ -0,0 +1,2 @@
+grep "Namespace is required" mcp-tools/memory-tools.js
+grep "cannot be .all." mcp-tools/memory-tools.js

package/patch/210-NS-003-namespace-typo-pattern/README.md

@@ -0,0 +1,15 @@
+# NS-003: Namespace typo 'pattern' vs 'patterns'
+**Severity**: Medium
+**GitHub**: [#1136](https://github.com/ruvnet/claude-flow/issues/1136)
+## Root Cause
+hooks-tools.js used singular 'pattern' in 4 locations while every other file (memory-tools.js, CLI, README) uses 'patterns' (plural). Patterns stored via hooks were invisible to search.
+## Fix
+Replace all 4 occurrences of 'pattern' with 'patterns' in hooks-tools.js.
+## Files Patched
+- mcp-tools/hooks-tools.js
+## Dependencies
+
+Depends on NS-002 (200) — NS-003 fixes typos in code paths that NS-002 modifies.
+
+## Ops
+4 ops in fix.py (22a-d)

package/patch/210-NS-003-namespace-typo-pattern/fix.py

@@ -0,0 +1,23 @@
+# NS-003: Namespace typo 'pattern' vs 'patterns'
+# GitHub: #1136
+# 4 ops: 22a-d
+
+patch("22a: hooks pattern-store namespace",
+    MCP_HOOKS,
+    "namespace: 'pattern',",
+    "namespace: 'patterns',")
+
+patch("22b: hooks pattern-search default",
+    MCP_HOOKS,
+    "const namespace = params.namespace || 'pattern';",
+    "const namespace = params.namespace || 'patterns';")
+
+patch("22c: hooks pattern-search description",
+    MCP_HOOKS,
+    "description: 'Namespace to search (default: pattern)'",
+    "description: 'Namespace to search (default: patterns)'")
+
+patch("22d: hooks pattern-search note",
+    MCP_HOOKS,
+    'namespace "pattern".',
+    'namespace "patterns".')

package/patch/210-NS-003-namespace-typo-pattern/sentinel

@@ -0,0 +1 @@
+grep "|| 'patterns'" mcp-tools/hooks-tools.js

package/patch/220-RS-001-better-sqlite3-node24/README.md

@@ -0,0 +1,54 @@
+# RS-001: ruv-swarm MCP fails on Node 24 — better-sqlite3 missing native bindings
+
+**Severity**: Critical
+**Package**: `ruv-swarm@1.0.20`
+**GitHub**: [ruv-FANN#185](https://github.com/ruvnet/ruv-FANN/issues/185)
+
+## Symptoms
+
+`ruv-swarm mcp start` crashes immediately with:
+
+```
+Could not locate the bindings file. Tried:
+ → .../better-sqlite3/lib/binding/node-v137-linux-x64/better_sqlite3.node
+```
+
+The MCP server never starts. All ruv-swarm MCP tools are unavailable.
+
+## Root Cause
+
+`ruv-swarm@1.0.20` declares `"better-sqlite3": "^11.6.0"` in `package.json`.
+When installed via `npx`, npm resolves this to `better-sqlite3@11.10.0`.
+
+`better-sqlite3` 11.x does **not** ship prebuilt binaries for Node 24
+(ABI version `node-v137`). The native addon compilation fails silently
+during `npx` install — `build/Release/` contains intermediate `obj/`
+directories but no `better_sqlite3.node` binary.
+
+`better-sqlite3` 12.x (`^12.0.0`) added Node 24 to its supported engines
+and ships prebuilt binaries for `node-v137-linux-x64`.
+
+## Why @claude-flow/cli is unaffected
+
+`@claude-flow/cli` uses `sql.js` (pure WASM SQLite) instead of `better-sqlite3`.
+WASM has no native bindings and works on any Node version.
+
+## Fix
+
+Bump the dependency from `^11.6.0` to `^12.0.0` in `ruv-swarm/package.json`.
+
+## Files Patched
+
+- `ruv-swarm` `package.json` (in npx cache)
+
+## Ops
+
+1 op in fix.py (JSON string replacement in package.json)
+1 op: `npm rebuild better-sqlite3` in the npx cache directory
+
+## Verification
+
+```bash
+npx -y ruv-swarm --version
+# Should print version without crashing
+```