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

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@sparkleideas/claude-flow-patch",
+  "version": "3.1.0-alpha.44.patch.10",
+  "description": "Patch toolkit for @claude-flow/cli init/runtime defects with verify and post-init repair commands",
+  "scripts": {
+    "preflight": "node scripts/preflight.mjs",
+    "preflight:check": "node scripts/preflight.mjs --check",
+    "prepublishOnly": "npm run preflight && npm test",
+    "test": "node --test tests/*.test.mjs",
+    "package": "bash npm/package.sh",
+    "package:dry": "bash npm/package.sh --dry-run",
+    "publish:npm": "bash npm/publish.sh",
+    "publish:dry": "bash npm/publish.sh --dry-run",
+    "upstream-log": "node scripts/upstream-log.mjs",
+    "guidance:analyze": "guidance analyze",
+    "guidance:optimize": "guidance autopilot --once --apply --source manual",
+    "guidance:autopilot:once": "guidance autopilot --once --source manual",
+    "guidance:autopilot:daemon": "guidance autopilot --daemon --apply --source daemon",
+    "guidance:ab-benchmark": "guidance benchmark",
+    "guidance:scaffold": "guidance scaffold",
+    "guidance:all": "guidance run all",
+    "guidance:status": "guidance run status",
+    "guidance:hooks": "guidance run hooks",
+    "guidance:trust": "guidance run trust",
+    "guidance:adversarial": "guidance run adversarial",
+    "guidance:proof": "guidance run proof",
+    "guidance:conformance": "guidance run conformance",
+    "guidance:evolution": "guidance run evolution",
+    "guidance:runtime": "guidance runtime demo",
+    "guidance:codex:status": "guidance codex status",
+    "guidance:codex:pre-command": "guidance codex pre-command",
+    "guidance:codex:pre-edit": "guidance codex pre-edit",
+    "guidance:codex:pre-task": "guidance codex pre-task",
+    "guidance:codex:post-edit": "guidance codex post-edit",
+    "guidance:codex:post-task": "guidance codex post-task",
+    "guidance:codex:session-start": "guidance codex session-start",
+    "guidance:codex:session-end": "guidance codex session-end"
+  },
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "author": "Sparkling Ideas <henrik@sparklingideas.co.uk>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sparkling/claude-flow-patch.git"
+  },
+  "homepage": "https://sparklingideas.co.uk/patch/claude-flow",
+  "bugs": {
+    "url": "https://github.com/sparkling/claude-flow-patch/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "claude-flow-patch": "bin/claude-flow-patch.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "patch",
+    "scripts",
+    "patch-all.sh",
+    "check-patches.sh",
+    "repair-post-init.sh",
+    "README.md",
+    "AGENTS.md",
+    "CLAUDE.md"
+  ],
+  "keywords": [
+    "claude-flow",
+    "@claude-flow/cli",
+    "patch",
+    "hotfix",
+    "init",
+    "hook-handler",
+    "npm-cache",
+    "hooks",
+    "ruvector",
+    "ruv-swarm",
+    "automation"
+  ],
+  "packageManager": "npm@10"
+}

package/patch/010-CF-001-doctor-yaml/README.md

@@ -0,0 +1,11 @@
+# CF-001: Doctor ignores YAML config files
+**Severity**: Low
+**GitHub**: [#1141](https://github.com/ruvnet/claude-flow/issues/1141)
+## Root Cause
+`checkConfigFile()` only checks `.json` paths, but `claude-flow init` generates `config.yaml`. Also, `JSON.parse()` runs on all config content, crashing on YAML.
+## Fix
+Add `.claude-flow/config.yaml` and `.claude-flow/config.yml` to the config search paths. Skip `JSON.parse()` for non-JSON files.
+## Files Patched
+- commands/doctor.js
+## Ops
+2 ops in fix.py

package/patch/010-CF-001-doctor-yaml/fix.py

@@ -0,0 +1,20 @@
+# CF-001: Doctor ignores YAML config files
+patch("7: YAML config",
+    DOC,
+    """    const configPaths = [
+        '.claude-flow/config.json',
+        'claude-flow.config.json',
+        '.claude-flow.json'
+    ];""",
+    """    const configPaths = [
+        '.claude-flow/config.json',
+        'claude-flow.config.json',
+        '.claude-flow.json',
+        '.claude-flow/config.yaml',
+        '.claude-flow/config.yml'
+    ];""")
+
+patch("7: YAML JSON.parse skip",
+    DOC,
+    "                JSON.parse(content);",
+    "                if (configPath.endsWith('.json')) { JSON.parse(content); }")

package/patch/010-CF-001-doctor-yaml/sentinel

@@ -0,0 +1 @@
+grep "config.yaml" commands/doctor.js

package/patch/020-CF-002-config-export-yaml/README.md

@@ -0,0 +1,11 @@
+# CF-002: Config export shows hardcoded defaults
+**Severity**: Medium
+**GitHub**: [#1142](https://github.com/ruvnet/claude-flow/issues/1142)
+## Root Cause
+`config export` and `config get` use hardcoded defaults (topology: 'hybrid', cacheSize: 256) instead of reading `.claude-flow/config.yaml`. The commands are misleading when the project has custom config.
+## Fix
+Add `readYamlConfig()` helper function. Merge YAML config values over defaults in both `getCommand` and `exportCommand` actions.
+## Files Patched
+- commands/config.js
+## Ops
+3 ops in fix.py

package/patch/020-CF-002-config-export-yaml/fix.py

@@ -0,0 +1,130 @@
+# CF-002: Config export shows hardcoded defaults instead of reading YAML
+# Absorbed from old patch-16. Applied manually to npx cache.
+# NOTE: This patch was originally applied via sed, not via patch().
+# The patch() calls below replicate the same changes.
+
+# Add fs/path imports after existing imports
+patch("16a: config.js add readYamlConfig",
+    CONF,
+    "const getCommand = {",
+    """import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+// Helper to read config.yaml if it exists
+function readYamlConfig() {
+    const configPath = join(process.cwd(), '.claude-flow', 'config.yaml');
+    if (!existsSync(configPath)) { return {}; }
+    try {
+        const content = readFileSync(configPath, 'utf8');
+        const config = {};
+        const lines = content.split('\\n');
+        let currentSection = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) continue;
+            if (!trimmed.includes(':')) continue;
+            const indent = line.match(/^\\s*/)[0].length;
+            if (indent === 0) {
+                const [key, ...rest] = trimmed.split(':');
+                const value = rest.join(':').trim();
+                if (value && value !== '') {
+                    config[key.trim()] = value.replace(/^["']|["']$/g, '');
+                } else {
+                    currentSection = key.trim();
+                    config[currentSection] = {};
+                }
+            } else if (currentSection && indent > 0) {
+                const [key, ...rest] = trimmed.split(':');
+                const value = rest.join(':').trim();
+                if (value && value !== '') {
+                    config[currentSection][key.trim()] = value.replace(/^["']|["']$/g, '');
+                }
+            }
+        }
+        return config;
+    } catch (error) { return {}; }
+}
+
+const getCommand = {""")
+
+# Update getCommand to merge YAML config
+patch("16b: config get merge yaml",
+    CONF,
+    """const configValues = {
+            'version': '3.0.0',
+            'v3Mode': true,
+            'swarm.topology': 'hybrid',
+            'swarm.maxAgents': 15,
+            'swarm.autoScale': true,
+            'memory.backend': 'hybrid',
+            'memory.cacheSize': 256,
+            'mcp.transport': 'stdio',
+            'agents.defaultType': 'coder',
+            'agents.maxConcurrent': 15
+        };""",
+    """// Default config values
+        const defaults = {
+            'version': '3.0.0',
+            'v3Mode': true,
+            'swarm.topology': 'hybrid',
+            'swarm.maxAgents': 15,
+            'swarm.autoScale': true,
+            'memory.backend': 'hybrid',
+            'memory.cacheSize': 256,
+            'mcp.transport': 'stdio',
+            'agents.defaultType': 'coder',
+            'agents.maxConcurrent': 15
+        };
+        // Read YAML config and merge with defaults
+        const yamlConfig = readYamlConfig();
+        const configValues = { ...defaults };
+        if (yamlConfig.swarm) {
+            if (yamlConfig.swarm.topology) configValues['swarm.topology'] = yamlConfig.swarm.topology;
+            if (yamlConfig.swarm.maxAgents) configValues['swarm.maxAgents'] = parseInt(yamlConfig.swarm.maxAgents) || defaults['swarm.maxAgents'];
+            if (yamlConfig.swarm.autoScale !== undefined) configValues['swarm.autoScale'] = yamlConfig.swarm.autoScale === 'true' || yamlConfig.swarm.autoScale === true;
+        }
+        if (yamlConfig.memory) {
+            if (yamlConfig.memory.backend) configValues['memory.backend'] = yamlConfig.memory.backend;
+            if (yamlConfig.memory.cacheSize) configValues['memory.cacheSize'] = parseInt(yamlConfig.memory.cacheSize) || defaults['memory.cacheSize'];
+        }
+        if (yamlConfig.mcp && yamlConfig.mcp.transport) {
+            configValues['mcp.transport'] = yamlConfig.mcp.transport;
+        }
+        if (yamlConfig.version) {
+            configValues['version'] = yamlConfig.version;
+        }""")
+
+# Update exportCommand to merge YAML config
+patch("16c: config export merge yaml",
+    CONF,
+    """const config = {
+            version: '3.0.0',
+            exportedAt: new Date().toISOString(),
+            agents: { defaultType: 'coder', maxConcurrent: 15 },
+            swarm: { topology: 'hybrid', maxAgents: 15 },
+            memory: { backend: 'hybrid', cacheSize: 256 },
+            mcp: { transport: 'stdio', tools: 'all' }
+        };""",
+    """// Start with defaults
+        const config = {
+            version: '3.0.0',
+            exportedAt: new Date().toISOString(),
+            agents: { defaultType: 'coder', maxConcurrent: 15 },
+            swarm: { topology: 'hybrid', maxAgents: 15 },
+            memory: { backend: 'hybrid', cacheSize: 256 },
+            mcp: { transport: 'stdio', tools: 'all' }
+        };
+        // Read YAML config and merge
+        const yamlConfig = readYamlConfig();
+        if (yamlConfig.version) { config.version = yamlConfig.version; }
+        if (yamlConfig.swarm) {
+            if (yamlConfig.swarm.topology) config.swarm.topology = yamlConfig.swarm.topology;
+            if (yamlConfig.swarm.maxAgents) config.swarm.maxAgents = parseInt(yamlConfig.swarm.maxAgents) || 15;
+        }
+        if (yamlConfig.memory) {
+            if (yamlConfig.memory.backend) config.memory.backend = yamlConfig.memory.backend;
+            if (yamlConfig.memory.cacheSize) config.memory.cacheSize = parseInt(yamlConfig.memory.cacheSize) || 256;
+        }
+        if (yamlConfig.mcp && yamlConfig.mcp.transport) {
+            config.mcp.transport = yamlConfig.mcp.transport;
+        }""")

package/patch/020-CF-002-config-export-yaml/sentinel

@@ -0,0 +1 @@
+grep "readYamlConfig" commands/config.js

package/patch/030-DM-001-daemon-log-zero/README.md

@@ -0,0 +1,12 @@
+# DM-001: daemon.log always 0 bytes
+**Severity**: Medium
+**GitHub**: [#1116](https://github.com/ruvnet/claude-flow/issues/1116)
+## Root Cause
+Two issues: (1) `log()` method uses `require('fs')` which is undefined in ESM modules — `appendFileSync` silently fails. (2) Path mismatch — daemon spawn writes to `.claude-flow/daemon.log` but `log()` targets `.claude-flow/logs/daemon.log`.
+## Fix
+(A) Add `appendFileSync` to ESM import. (B) Replace `require('fs')` call with imported function. (C) Align spawn log path to `.claude-flow/logs/daemon.log`.
+## Files Patched
+- services/worker-daemon.js (Parts A, B)
+- commands/daemon.js (Part C)
+## Ops
+3 ops in fix.py

package/patch/030-DM-001-daemon-log-zero/fix.py

@@ -0,0 +1,37 @@
+# DM-001: daemon.log always 0 bytes (ESM require + path mismatch)
+# GitHub: #1116
+patch("4A: appendFileSync import",
+    WD,
+    "import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';",
+    "import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';")
+
+patch("4B: remove require('fs')",
+    WD,
+    """            const fs = require('fs');
+            fs.appendFileSync(logFile, logMessage + '\\n');""",
+    "            appendFileSync(logFile, logMessage + '\\n');")
+
+patch("4C: daemon log path",
+    DJ,
+    """    const logFile = join(stateDir, 'daemon.log');
+    // Validate all paths
+    validatePath(stateDir, 'State directory');
+    validatePath(pidFile, 'PID file');
+    validatePath(logFile, 'Log file');
+    // Ensure state directory exists
+    if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+    }""",
+    """    const logsDir = join(stateDir, 'logs');
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+    const logFile = join(logsDir, 'daemon.log');
+    // Validate all paths
+    validatePath(stateDir, 'State directory');
+    validatePath(pidFile, 'PID file');
+    validatePath(logFile, 'Log file');
+    // Ensure state directory exists
+    if (!fs.existsSync(stateDir)) {
+        fs.mkdirSync(stateDir, { recursive: true });
+    }""")

package/patch/030-DM-001-daemon-log-zero/sentinel

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

package/patch/040-DM-002-cpu-load-threshold/README.md

@@ -0,0 +1,11 @@
+# DM-002: maxCpuLoad=2.0 blocks all workers on multi-core
+**Severity**: Critical
+**GitHub**: [#1138](https://github.com/ruvnet/claude-flow/issues/1138)
+## Root Cause
+`maxCpuLoad` defaults to 2.0, but load average reflects total system load across all cores. An 8-core Mac idles at 3-5. A 32-core server idles at 1-3 but spikes above 2.0 easily. No worker ever passes the resource gate.
+## Fix
+Raise threshold to match hardware. Currently set to 28.0 for 32-core server. Adjust per machine (8-core Mac: 6.0).
+## Files Patched
+- services/worker-daemon.js
+## Ops
+1 op in fix.py

package/patch/040-DM-002-cpu-load-threshold/fix.py

@@ -0,0 +1,6 @@
+# DM-002: maxCpuLoad=2.0 blocks all workers on multi-core
+# NOTE: 32-core server uses 28.0. Adjust per machine (8-core Mac: 6.0).
+patch("5: CPU load threshold",
+    WD,
+    "maxCpuLoad: 2.0",
+    "maxCpuLoad: 28.0")

package/patch/040-DM-002-cpu-load-threshold/sentinel

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

package/patch/050-DM-003-macos-freemem/README.md

@@ -0,0 +1,11 @@
+# DM-003: macOS freemem() always ~0% — workers blocked
+**Severity**: Critical (macOS only)
+**GitHub**: [#1077](https://github.com/ruvnet/claude-flow/issues/1077)
+## Root Cause
+`os.freemem()` on macOS excludes file cache, always reporting ~0.3% free. macOS reclaims cache on demand, so the number is meaningless. The `minFreeMemoryPercent: 20` gate never passes.
+## Fix
+Skip the free memory check on macOS (`os.platform() !== 'darwin'`).
+## Files Patched
+- services/worker-daemon.js
+## Ops
+1 op in fix.py (skipped on Linux)

package/patch/050-DM-003-macos-freemem/fix.py

@@ -0,0 +1,7 @@
+# DM-003: macOS freemem() always ~0% — workers blocked
+# GitHub: #1077
+# SKIPPED on Linux (only affects macOS)
+patch("6: macOS memory",
+    WD,
+    "if (freePercent < this.config.resourceThresholds.minFreeMemoryPercent) {",
+    "if (os.platform() !== 'darwin' && freePercent < this.config.resourceThresholds.minFreeMemoryPercent) {")

package/patch/050-DM-003-macos-freemem/sentinel

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

package/patch/060-DM-004-preload-worker-stub/README.md

@@ -0,0 +1,11 @@
+# DM-004: Preload worker stub + missing from defaults
+**Severity**: Enhancement
+**GitHub**: [#1139](https://github.com/ruvnet/claude-flow/issues/1139)
+## Root Cause
+The `preload` worker type exists in the switch statement but was missing from `DEFAULT_WORKERS` — never scheduled. The `runPreloadWorkerLocal()` was a stub returning `{resourcesPreloaded: 0}`. Also missing: ultralearn, deepdive, refactor, benchmark workers.
+## Fix
+Add missing workers to DEFAULT_WORKERS. Implement real preload that calls `loadEmbeddingModel()` and `getHNSWIndex()` from memory-initializer.js.
+## Files Patched
+- services/worker-daemon.js
+## Ops
+2 ops in fix.py

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