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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/patch/130-HK-003-metrics-hardcoded/fix.py

@@ -0,0 +1,82 @@
+# HK-003: hooks_metrics MCP handler returns hardcoded fake data
+# GitHub: #1158
+
+patch("HK-003a: replace hardcoded metrics with real data reader",
+    MCP_HOOKS,
+    """        return {
+            period,
+            patterns: {
+                total: 15,
+                successful: 12,
+                failed: 3,
+                avgConfidence: 0.85,
+            },
+            agents: {
+                routingAccuracy: 0.87,
+                totalRoutes: 42,
+                topAgent: 'coder',
+            },
+            commands: {
+                totalExecuted: 128,
+                successRate: 0.94,
+                avgRiskScore: 0.15,
+            },
+            performance: {
+                flashAttention: '2.49x-7.47x speedup',
+                memoryReduction: '50-75% reduction',
+                searchImprovement: '150x-12,500x faster',
+                tokenReduction: '32.3% fewer tokens',
+            },
+            status: 'healthy',
+            lastUpdated: new Date().toISOString(),
+        };""",
+    """        // HK-003: read real metrics from persisted files instead of hardcoded values
+        const cwd = process.cwd();
+        let patterns = { total: 0, successful: 0, failed: 0, avgConfidence: 0 };
+        let agents = { routingAccuracy: 0, totalRoutes: 0, topAgent: 'none' };
+        let commands = { totalExecuted: 0, successRate: 0, avgRiskScore: 0 };
+        try {
+            const sonaPath = cwd + '/.swarm/sona-patterns.json';
+            if (existsSync(sonaPath)) {
+                const sona = JSON.parse(readFileSync(sonaPath, 'utf-8'));
+                const pats = Object.values(sona.patterns || {});
+                const successful = pats.filter(p => p.successCount > 0).length;
+                patterns = {
+                    total: pats.length,
+                    successful,
+                    failed: pats.filter(p => p.failureCount > 0).length,
+                    avgConfidence: pats.length > 0 ? pats.reduce((s, p) => s + (p.confidence || 0), 0) / pats.length : 0,
+                };
+                agents = {
+                    routingAccuracy: (sona.stats || {}).successfulRoutings > 0 ? sona.stats.successfulRoutings / ((sona.stats.successfulRoutings || 0) + (sona.stats.failedRoutings || 0)) : 0,
+                    totalRoutes: ((sona.stats || {}).successfulRoutings || 0) + ((sona.stats || {}).failedRoutings || 0),
+                    topAgent: pats.length > 0 ? pats.sort((a, b) => (b.successCount || 0) - (a.successCount || 0))[0].agent || 'none' : 'none',
+                };
+            }
+        } catch {}
+        try {
+            const rvPath = cwd + '/.ruvector/intelligence.json';
+            if (existsSync(rvPath)) {
+                const rv = JSON.parse(readFileSync(rvPath, 'utf-8'));
+                const s = rv.stats || {};
+                commands = {
+                    totalExecuted: (s.session_count || 0) + (rv.trajectories || []).length,
+                    successRate: (rv.trajectories || []).length > 0 ? (rv.trajectories || []).filter(t => t.success).length / (rv.trajectories || []).length : 0,
+                    avgRiskScore: 0.15,
+                };
+            }
+        } catch {}
+        return {
+            period,
+            patterns,
+            agents,
+            commands,
+            performance: {
+                flashAttention: '2.49x-7.47x speedup',
+                memoryReduction: '50-75% reduction',
+                searchImprovement: '150x-12,500x faster',
+                tokenReduction: '32.3% fewer tokens',
+            },
+            status: 'healthy',
+            lastUpdated: new Date().toISOString(),
+        };""")

package/patch/130-HK-003-metrics-hardcoded/sentinel

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

package/patch/135-HK-004-respect-daemon-autostart/README.md

@@ -0,0 +1,11 @@
+# HK-004: hooks_session-start ignores daemon.autoStart from settings.json
+**Severity**: High
+**GitHub**: [#1175](https://github.com/ruvnet/claude-flow/issues/1175)
+## Root Cause
+`hooks_session-start` handler in `hooks-tools.js` (line ~1216) determines daemon auto-start solely from the MCP call parameter: `const shouldStartDaemon = params.startDaemon !== false;`. It never reads `claudeFlow.daemon.autoStart` from `.claude/settings.json`. Setting `autoStart: false` in settings.json has no effect — the daemon always starts on session-start.
+## Fix
+Wrap the `shouldStartDaemon` assignment in an IIFE that first checks the MCP parameter, then reads settings.json. If `claudeFlow.daemon.autoStart === false`, returns false. Falls back to true on any read/parse error.
+## Files Patched
+- mcp-tools/hooks-tools.js
+## Ops
+1 op in fix.py

package/patch/135-HK-004-respect-daemon-autostart/fix.py

@@ -0,0 +1,14 @@
+# HK-004: hooks_session-start ignores daemon.autoStart from settings.json
+# GitHub: #1175
+patch("HK-004: respect daemon autoStart setting",
+    MCP_HOOKS,
+    "        const shouldStartDaemon = params.startDaemon !== false;",
+    """        const shouldStartDaemon = (() => {
+            if (params.startDaemon === false) return false;
+            try {
+                const sp = join(process.cwd(), '.claude', 'settings.json');
+                const s = JSON.parse(readFileSync(sp, 'utf-8'));
+                if (s?.claudeFlow?.daemon?.autoStart === false) return false;
+            } catch { /* no settings or unreadable — default to true */ }
+            return true;
+        })();""")

package/patch/135-HK-004-respect-daemon-autostart/sentinel

@@ -0,0 +1 @@
+grep "claudeFlow?.daemon?.autoStart" mcp-tools/hooks-tools.js

package/patch/137-HK-005-daemon-pid-guard/README.md

@@ -0,0 +1,11 @@
+# HK-005: Multiple MCP servers start independent in-process daemons
+**Severity**: Critical
+**GitHub**: [#1171](https://github.com/ruvnet/claude-flow/issues/1171)
+## Root Cause
+`hooks_session-start` calls `startDaemon()` (worker-daemon.js) which creates an in-process `WorkerDaemon` singleton per Node.js process. Each MCP server is a separate process with its own singleton — no cross-process coordination. The CLI background daemon path (`daemon.js`) has PID-file coordination but the MCP hook path bypasses it entirely. Result: N MCP servers per project = N daemon instances = N × 6 workers.
+## Fix
+Add PID-file guard to the MCP hook path using `.claude-flow/daemon.pid` (same file the CLI path uses). Before calling `startDaemon()`, check PID file: if a different process owns it and is alive, skip (reuse). If the PID is our own process or stale, proceed and overwrite. No cleanup on session-end — stale PIDs self-heal via `kill(pid, 0)` on next start. The PID file becomes a universal one-daemon-per-project lock across both MCP and CLI paths.
+## Files Patched
+- mcp-tools/hooks-tools.js
+## Ops
+2 ops in fix.py

package/patch/137-HK-005-daemon-pid-guard/fix.py

@@ -0,0 +1,53 @@
+# HK-005: Multiple MCP servers start independent in-process daemons
+# No cross-process coordination on the hooks_session-start path.
+# GitHub: #1171
+
+# Op 1: Add PID-file guard before startDaemon()
+patch("HK-005a: cross-process daemon PID guard",
+    MCP_HOOKS,
+    """        // Auto-start daemon if enabled
+        let daemonStatus = { started: false };
+        if (shouldStartDaemon) {
+            try {
+                // Dynamic import to avoid circular dependencies
+                const { startDaemon } = await import('../services/worker-daemon.js');
+                const daemon = await startDaemon(process.cwd());""",
+    """        // Auto-start daemon if enabled
+        let daemonStatus = { started: false };
+        if (shouldStartDaemon) {
+            try {
+                // HK-005: PID-file guard — one daemon per project across processes
+                const _pidDir = join(process.cwd(), '.claude-flow');
+                const _pidPath = join(_pidDir, 'daemon.pid');
+                let _skipDaemon = false;
+                try {
+                    const _xPid = parseInt(readFileSync(_pidPath, 'utf-8').trim(), 10);
+                    if (!isNaN(_xPid) && _xPid !== process.pid) {
+                        try { process.kill(_xPid, 0); _skipDaemon = true; daemonStatus = { started: true, pid: _xPid, reused: true }; }
+                        catch { /* stale PID from dead process — proceed */ }
+                    }
+                } catch { /* no PID file — proceed */ }
+                if (!_skipDaemon) {
+                // Dynamic import to avoid circular dependencies
+                const { startDaemon } = await import('../services/worker-daemon.js');
+                const daemon = await startDaemon(process.cwd());""")
+
+# Op 2: Write PID after successful start + close guard block
+patch("HK-005b: write PID after daemon start",
+    MCP_HOOKS,
+    """                const status = daemon.getStatus();
+                daemonStatus = {
+                    started: true,
+                    pid: status.pid,
+                };""",
+    """                const status = daemon.getStatus();
+                // HK-005: Write PID so other processes detect this daemon
+                try {
+                    if (!existsSync(_pidDir)) { mkdirSync(_pidDir, { recursive: true }); }
+                    writeFileSync(_pidPath, String(status.pid || process.pid));
+                } catch { /* best-effort */ }
+                daemonStatus = {
+                    started: true,
+                    pid: status.pid,
+                };
+                } // end HK-005 guard""")

package/patch/137-HK-005-daemon-pid-guard/sentinel

@@ -0,0 +1,2 @@
+grep "HK-005: PID-file guard" mcp-tools/hooks-tools.js
+grep "HK-005: Write PID" mcp-tools/hooks-tools.js

package/patch/140-HW-001-stdin-hang/README.md

@@ -0,0 +1,11 @@
+# HW-001: Headless workers hang — stdin pipe never closed
+**Severity**: Critical
+**GitHub**: [#1111](https://github.com/ruvnet/claude-flow/issues/1111)
+## Root Cause
+`claude --print` is spawned with `stdio: ['pipe', 'pipe', 'pipe']`. The prompt is passed as a CLI argument, so stdin is never written to or closed. The child process hangs waiting for stdin EOF.
+## Fix
+Change stdin to `'ignore'` since it's unused.
+## Files Patched
+- services/headless-worker-executor.js
+## Ops
+1 op in fix.py

package/patch/140-HW-001-stdin-hang/fix.py

@@ -0,0 +1,6 @@
+# HW-001: Headless workers hang — stdin pipe never closed
+# GitHub: #1111
+patch("1: stdin pipe",
+    HWE,
+    "stdio: ['pipe', 'pipe', 'pipe']",
+    "stdio: ['ignore', 'pipe', 'pipe']")

package/patch/140-HW-001-stdin-hang/sentinel

@@ -0,0 +1 @@
+grep "'ignore', 'pipe', 'pipe'" services/headless-worker-executor.js

package/patch/150-HW-002-failures-swallowed/README.md

@@ -0,0 +1,11 @@
+# HW-002: Headless failures silently swallowed as success
+**Severity**: High
+**GitHub**: [#1112](https://github.com/ruvnet/claude-flow/issues/1112)
+## Root Cause
+`executeWorker()` hardcodes `success: true` for any non-throwing return. When headless execution fails (returns `{success: false}`), `runWorkerLogic()` catches the error and falls through to local stubs that fabricate data. Failures are never surfaced.
+## Fix
+Check `result.success` after headless execution. If false, throw with the error message instead of falling through.
+## Files Patched
+- services/worker-daemon.js
+## Ops
+1 op in fix.py

package/patch/150-HW-002-failures-swallowed/fix.py

@@ -0,0 +1,42 @@
+# HW-002: Headless failures silently swallowed as success
+# GitHub: #1112
+patch("2: honest failures",
+    WD,
+    """        if (isHeadlessWorker(workerConfig.type) && this.headlessAvailable && this.headlessExecutor) {
+            try {
+                this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
+                const result = await this.headlessExecutor.execute(workerConfig.type);
+                return {
+                    mode: 'headless',
+                    ...result,
+                };
+            }
+            catch (error) {
+                this.log('warn', `Headless execution failed for ${workerConfig.type}, falling back to local mode`);
+                this.emit('headless:fallback', {
+                    type: workerConfig.type,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Fall through to local execution
+            }
+        }""",
+    """        if (isHeadlessWorker(workerConfig.type) && this.headlessAvailable && this.headlessExecutor) {
+            let result;
+            try {
+                this.log('info', `Running ${workerConfig.type} in headless mode (Claude Code AI)`);
+                result = await this.headlessExecutor.execute(workerConfig.type);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                this.log('warn', `Headless execution threw for ${workerConfig.type}: ${errorMsg}`);
+                this.emit('headless:fallback', { type: workerConfig.type, error: errorMsg });
+                throw error instanceof Error ? error : new Error(errorMsg);
+            }
+            if (result.success) {
+                return { mode: 'headless', ...result };
+            }
+            const errorMsg = result.error || 'Unknown headless failure';
+            this.log('warn', `Headless failed for ${workerConfig.type}: ${errorMsg}`);
+            this.emit('headless:fallback', { type: workerConfig.type, error: errorMsg });
+            throw new Error(`Headless execution failed for ${workerConfig.type}: ${errorMsg}`);
+        }""")

package/patch/150-HW-002-failures-swallowed/sentinel

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

package/patch/160-HW-003-aggressive-intervals/README.md

@@ -0,0 +1,11 @@
+# HW-003: Worker scheduling intervals too aggressive + settings ignored
+**Severity**: High
+**GitHub**: [#1113](https://github.com/ruvnet/claude-flow/issues/1113)
+## Root Cause
+`DEFAULT_WORKERS` uses pre-headless intervals (audit: 10m, optimize: 15m, testgaps: 20m). ADR-020 specifies longer intervals (30/60/60m) for headless workers that invoke Claude. Additionally, `daemon.schedules` from `.claude/settings.json` is never read — user-configured intervals are completely ignored.
+## Fix
+(A) Align hardcoded intervals to ADR-020: audit 30m, optimize 60m, testgaps 60m. (B) After setting default workers, read `claudeFlow.daemon.schedules` from `.claude/settings.json` and merge user-configured intervals/enabled flags into matching workers. Supports string formats ("1h", "30m", "10s") and raw milliseconds.
+## Files Patched
+- services/worker-daemon.js
+## Ops
+4 ops in fix.py