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

package/lib/common.py

@@ -0,0 +1,92 @@
+# common.py — shared patch infrastructure
+# Extracted from apply-patches.sh. Provides patch()/patch_all() + path variables.
+
+import sys, os, re
+
+base = os.environ.get("BASE", "")
+if not base or base == "/dev/null":
+    base = ""  # No claude-flow/cli, paths will be invalid (patch() will skip gracefully)
+services = base + "/services" if base else ""
+commands = base + "/commands" if base else ""
+memory = base + "/memory" if base else ""
+
+applied = 0
+skipped = 0
+
+def patch(label, filepath, old, new):
+    global applied, skipped
+    if not filepath:
+        return  # Skip if path is empty (package not found)
+    try:
+        with open(filepath, 'r') as f:
+            code = f.read()
+        if new in code:
+            skipped += 1
+            return
+        if old not in code:
+            print(f"  WARN: {label} — pattern not found (code may have changed)")
+            return
+        code = code.replace(old, new, 1)
+        with open(filepath, 'w') as f:
+            f.write(code)
+        print(f"  Applied: {label}")
+        applied += 1
+    except FileNotFoundError:
+        pass  # Silently skip if file doesn't exist (package not installed)
+    except Exception as e:
+        print(f"  ERROR: {label} — {e}")
+
+def patch_all(label, filepath, old, new):
+    """Replace ALL occurrences"""
+    global applied, skipped
+    if not filepath:
+        return  # Skip if path is empty (package not found)
+    try:
+        with open(filepath, 'r') as f:
+            code = f.read()
+        if new in code and old not in code:
+            skipped += 1
+            return
+        if old not in code:
+            print(f"  WARN: {label} — pattern not found")
+            return
+        code = code.replace(old, new)
+        with open(filepath, 'w') as f:
+            f.write(code)
+        print(f"  Applied: {label}")
+        applied += 1
+    except FileNotFoundError:
+        pass  # Silently skip if file doesn't exist (package not installed)
+    except Exception as e:
+        print(f"  ERROR: {label} — {e}")
+
+# ── Target file paths ──
+# These may be empty strings if base is not set (no claude-flow/cli found)
+HWE = services + "/headless-worker-executor.js" if services else ""
+WD = services + "/worker-daemon.js" if services else ""
+DJ = commands + "/daemon.js" if commands else ""
+DOC = commands + "/doctor.js" if commands else ""
+MI = memory + "/memory-initializer.js" if memory else ""
+
+MCP_MEMORY = base + "/mcp-tools/memory-tools.js" if base else ""
+MCP_HOOKS = base + "/mcp-tools/hooks-tools.js" if base else ""
+CLI_MEMORY = commands + "/memory.js" if commands else ""
+CONF = commands + "/config.js" if commands else ""
+HOOKS_CMD = commands + "/hooks.js" if commands else ""
+NEURAL = commands + "/neural.js" if commands else ""
+EMB_TOOLS = base + "/mcp-tools/embeddings-tools.js" if base else ""
+
+# Init module
+init = base + "/init" if base else ""
+SETTINGS_GEN = init + "/settings-generator.js" if init else ""
+HELPERS_GEN = init + "/helpers-generator.js" if init else ""
+EXECUTOR = init + "/executor.js" if init else ""
+TYPES = init + "/types.js" if init else ""
+INIT_CMD = commands + "/init.js" if commands else ""
+
+# Source helpers (shipped with package, copied by writeHelpers when source dir found)
+_pkg_root = os.path.dirname(os.path.dirname(base)) if base else ""
+SRC_HOOK_HANDLER = os.path.join(_pkg_root, ".claude", "helpers", "hook-handler.cjs") if _pkg_root else ""
+
+# RuVector (separate package, path set by patch-all.sh)
+ruvector_cli = os.environ.get("RUVECTOR_CLI", "")

package/lib/discover.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+// lib/discover.mjs — Dynamic patch discovery
+// Scans patch/*/ directories, parses README.md + fix.py headers for metadata.
+// Single source of truth for scripts, sentinel checks, and documentation.
+
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const PATCH_DIR = resolve(ROOT, 'patch');
+
+// Category labels from lib/categories.json
+const CATEGORY_MAP = JSON.parse(
+  readFileSync(resolve(__dirname, 'categories.json'), 'utf-8')
+);
+
+/**
+ * Parse a patch README.md for doc metadata.
+ * Expected format:
+ *   # {ID}: {title}
+ *   **Severity**: {severity}
+ *   **GitHub**: [{label}]({url})
+ *   ## Files Patched
+ *   - {file}
+ *   ## Ops
+ *   {N} op(s) in fix.py
+ */
+function parseReadme(readmePath, dirName) {
+  const text = readFileSync(readmePath, 'utf-8');
+  const lines = text.split('\n');
+
+  const titleMatch = lines[0]?.match(/^#\s+(\S+):\s+(.+)/);
+  const stripped = dirName.replace(/^\d+-/, '');
+  const id = titleMatch?.[1] ?? stripped.split('-').slice(0, 2).join('-');
+  const title = titleMatch?.[2]?.trim() ?? '';
+
+  const sevLine = lines.find(l => l.startsWith('**Severity**'));
+  const severity = sevLine?.match(/\*\*Severity\*\*:\s*(\S+)/)?.[1] ?? 'Unknown';
+
+  const ghLine = lines.find(l => l.startsWith('**GitHub**'));
+  const ghMatch = ghLine?.match(/\[([^\]]+)\]\(([^)]+)\)/);
+  const github = ghMatch?.[1] ?? '';
+  const githubUrl = ghMatch?.[2] ?? '';
+
+  const filesIdx = lines.findIndex(l => /^##\s+Files Patched/i.test(l));
+  const files = [];
+  if (filesIdx >= 0) {
+    for (let i = filesIdx + 1; i < lines.length; i++) {
+      const m = lines[i].match(/^-\s+`?([^`\n]+)`?\s*$/);
+      if (m) files.push(m[1].trim());
+      else if (lines[i].startsWith('#') || (lines[i].trim() === '' && files.length > 0)) break;
+    }
+  }
+
+  const opsLine = lines.find(l => /^\d+\s+ops?\b/i.test(l));
+  const ops = opsLine ? parseInt(opsLine, 10) : 0;
+
+  return { id, title, severity, github, githubUrl, files, ops };
+}
+
+/**
+ * Parse a sentinel file for verification metadata.
+ * Each line is one of:
+ *   package: <name>          — target package (default: @claude-flow/cli)
+ *   grep "<pattern>" <file>  — pass if pattern found
+ *   absent "<pattern>" <file> — pass if pattern NOT found
+ *   none                     — skip verification
+ */
+function parseSentinels(sentinelPath) {
+  const text = readFileSync(sentinelPath, 'utf-8');
+  const lines = text.split('\n');
+
+  let pkg = null;
+  const sentinels = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    if (trimmed.startsWith('package:')) {
+      pkg = trimmed.replace('package:', '').trim();
+    } else if (trimmed === 'none') {
+      sentinels.push({ type: 'none' });
+    } else {
+      const absentMatch = trimmed.match(/^absent\s+"(.+)"\s+(.+)$/);
+      if (absentMatch) {
+        sentinels.push({ type: 'absent', pattern: absentMatch[1], file: absentMatch[2] });
+        continue;
+      }
+      const grepMatch = trimmed.match(/^grep\s+"(.+)"\s+(.+)$/);
+      if (grepMatch) {
+        sentinels.push({ type: 'grep', pattern: grepMatch[1], file: grepMatch[2] });
+      }
+    }
+  }
+
+  return { package: pkg, sentinels };
+}
+
+/**
+ * Discover all patches. Returns structured JSON with everything needed
+ * by scripts, sentinel checks, and documentation.
+ */
+export function discover() {
+  let dirs;
+  try {
+    dirs = readdirSync(PATCH_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name)
+      .sort();
+  } catch {
+    return { patches: [], categories: {}, stats: { total: 0, categories: 0 } };
+  }
+
+  const patches = [];
+  const categorySet = new Set();
+
+  for (const dirName of dirs) {
+    const readmePath = resolve(PATCH_DIR, dirName, 'README.md');
+    if (!existsSync(readmePath)) continue;
+
+    const meta = parseReadme(readmePath, dirName);
+    const prefix = meta.id.split('-')[0];
+    const stripped = dirName.replace(/^\d+-/, '');
+    const slug = stripped.replace(/^[A-Z]+-\d+-/, '');
+    const orderMatch = dirName.match(/^(\d+)-/);
+    const order = orderMatch ? parseInt(orderMatch[1], 10) : null;
+    const hasPy = existsSync(resolve(PATCH_DIR, dirName, 'fix.py'));
+    const hasSh = existsSync(resolve(PATCH_DIR, dirName, 'fix.sh'));
+    const fixType = hasPy ? 'python' : hasSh ? 'shell' : 'unknown';
+    const category = CATEGORY_MAP[prefix] ?? prefix;
+    categorySet.add(category);
+
+    // Parse sentinel metadata from dedicated sentinel file
+    const sentinelPath = resolve(PATCH_DIR, dirName, 'sentinel');
+    const sentinel = existsSync(sentinelPath) ? parseSentinels(sentinelPath) : { package: null, sentinels: [] };
+
+    patches.push({
+      id: meta.id,
+      order,
+      slug,
+      dir: dirName,
+      title: meta.title,
+      severity: meta.severity,
+      github: meta.github,
+      githubUrl: meta.githubUrl,
+      category,
+      prefix,
+      type: fixType,
+      files: meta.files,
+      ops: meta.ops,
+      package: sentinel.package,
+      sentinels: sentinel.sentinels,
+    });
+  }
+
+  // Build categories object: { prefix: label } for active categories
+  const categories = {};
+  for (const p of patches) {
+    if (!categories[p.prefix]) {
+      categories[p.prefix] = CATEGORY_MAP[p.prefix] ?? p.prefix;
+    }
+  }
+
+  return {
+    patches,
+    categories,
+    stats: {
+      total: patches.length,
+      categories: categorySet.size,
+    },
+  };
+}
+
+// CLI: `node lib/discover.mjs` prints JSON to stdout
+const thisFile = resolve(__dirname, 'discover.mjs');
+if (process.argv[1] && resolve(process.argv[1]) === thisFile) {
+  console.log(JSON.stringify(discover(), null, 2));
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@sparkleideas/claude-flow-patch",
+  "version": "3.1.0-alpha.44.patch.3",
+  "description": "Patch toolkit for @claude-flow/cli init/runtime defects with verify and post-init repair commands",
+  "scripts": {
+    "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",
+    "update-docs": "node scripts/update-docs.mjs",
+    "update-docs:check": "node scripts/update-docs.mjs --check",
+    "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