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

package/patch/280-UI-001-intelligence-stats-crash/fix.py

@@ -0,0 +1,57 @@
+# UI-001: intelligence stats crashes on .toFixed() of undefined
+# Absorbed from old patch-17. Applied via sed to npx cache.
+
+# SONA component null checks
+patch("17a: SONA learningTimeMs null check",
+    HOOKS_CMD,
+    "{ metric: 'Learning Time', value: `${result.components.sona.learningTimeMs.toFixed(3)}ms` }",
+    "{ metric: 'Learning Time', value: result.components.sona.learningTimeMs != null ? `${result.components.sona.learningTimeMs.toFixed(3)}ms` : 'N/A' }")
+
+patch("17b: SONA adaptationTimeMs null check",
+    HOOKS_CMD,
+    "{ metric: 'Adaptation Time', value: `${result.components.sona.adaptationTimeMs.toFixed(3)}ms` }",
+    "{ metric: 'Adaptation Time', value: result.components.sona.adaptationTimeMs != null ? `${result.components.sona.adaptationTimeMs.toFixed(3)}ms` : 'N/A' }")
+
+patch("17c: SONA avgQuality null check",
+    HOOKS_CMD,
+    "{ metric: 'Avg Quality', value: `${(result.components.sona.avgQuality * 100).toFixed(1)}%` }",
+    "{ metric: 'Avg Quality', value: result.components.sona.avgQuality != null ? `${(result.components.sona.avgQuality * 100).toFixed(1)}%` : 'N/A' }")
+
+# MoE component null checks
+patch("17d: MoE routingAccuracy null check",
+    HOOKS_CMD,
+    "{ metric: 'Routing Accuracy', value: `${(result.components.moe.routingAccuracy * 100).toFixed(1)}%` }",
+    "{ metric: 'Routing Accuracy', value: result.components.moe.routingAccuracy != null ? `${(result.components.moe.routingAccuracy * 100).toFixed(1)}%` : 'N/A' }")
+
+patch("17e: MoE loadBalance null check",
+    HOOKS_CMD,
+    "{ metric: 'Load Balance', value: `${(result.components.moe.loadBalance * 100).toFixed(1)}%` }",
+    "{ metric: 'Load Balance', value: result.components.moe.loadBalance != null ? `${(result.components.moe.loadBalance * 100).toFixed(1)}%` : 'N/A' }")
+
+# Embeddings null check
+patch("17f: embeddings cacheHitRate null check",
+    HOOKS_CMD,
+    "{ metric: 'Cache Hit Rate', value: `${(result.components.embeddings.cacheHitRate * 100).toFixed(1)}%` }",
+    "{ metric: 'Cache Hit Rate', value: result.components.embeddings.cacheHitRate != null ? `${(result.components.embeddings.cacheHitRate * 100).toFixed(1)}%` : 'N/A' }")
+
+# Performance section null guard
+patch("17g: performance section null guard",
+    HOOKS_CMD,
+    """            output.printList([
+                `Flash Attention: ${output.success(result.performance.flashAttention)}`,
+                `Memory Reduction: ${output.success(result.performance.memoryReduction)}`,
+                `Search Improvement: ${output.success(result.performance.searchImprovement)}`,
+                `Token Reduction: ${output.success(result.performance.tokenReduction)}`,
+                `SWE-Bench Score: ${output.success(result.performance.sweBenchScore)}`
+            ]);""",
+    """            if (result.performance) {
+                output.printList([
+                    `Flash Attention: ${output.success(result.performance.flashAttention || 'N/A')}`,
+                    `Memory Reduction: ${output.success(result.performance.memoryReduction || 'N/A')}`,
+                    `Search Improvement: ${output.success(result.performance.searchImprovement || 'N/A')}`,
+                    `Token Reduction: ${output.success(result.performance.tokenReduction || 'N/A')}`,
+                    `SWE-Bench Score: ${output.success(result.performance.sweBenchScore || 'N/A')}`
+                ]);
+            } else {
+                output.writeln(output.dim('  No performance data available'));
+            }""")

package/patch/280-UI-001-intelligence-stats-crash/sentinel

@@ -0,0 +1 @@
+grep "learningTimeMs != null" commands/hooks.js

package/patch/290-UI-002-neural-status-not-loaded/README.md

@@ -0,0 +1,11 @@
+# UI-002: neural status shows "Not loaded"
+**Severity**: Low (cosmetic)
+**GitHub**: [#1146](https://github.com/ruvnet/claude-flow/issues/1146)
+## Root Cause
+`neural status` reads module-level flags (`initialized`, `sonaAvailable`, `hnswIndex`) without calling their init functions. RuVector WASM, SONA Engine, and HNSW Index always show "Not loaded" even when packages are installed and working.
+## Fix
+Add `initializeTraining()` and `getHNSWIndex()` calls before reading status. Update import to include `getHNSWIndex`.
+## Files Patched
+- commands/neural.js
+## Ops
+2 ops in fix.py

package/patch/290-UI-002-neural-status-not-loaded/fix.py

@@ -0,0 +1,19 @@
+# UI-002: neural status shows "Not loaded" for installed components
+# Absorbed from old patch-18. Applied manually to npx cache.
+
+# Update import to include getHNSWIndex
+patch("18a: neural.js import getHNSWIndex",
+    NEURAL,
+    "const { getHNSWStatus, loadEmbeddingModel } = await import('../memory/memory-initializer.js');",
+    "const { getHNSWIndex, getHNSWStatus, loadEmbeddingModel } = await import('../memory/memory-initializer.js');")
+
+# Add initialization calls before status reads
+patch("18b: neural.js init before status",
+    NEURAL,
+    "            const ruvectorStats = ruvector.getTrainingStats();",
+    """            // Patch 18: Initialize RuVector WASM + SONA + HNSW so status reflects reality
+            if (!ruvector.getTrainingStats().initialized) {
+                await ruvector.initializeTraining({ useSona: true }).catch(() => {});
+            }
+            await getHNSWIndex().catch(() => null);
+            const ruvectorStats = ruvector.getTrainingStats();""")

package/patch/290-UI-002-neural-status-not-loaded/sentinel

@@ -0,0 +1 @@
+grep "getHNSWIndex" commands/neural.js

package/patch/300-DM-006-log-rotation/README.md

@@ -0,0 +1,12 @@
+# DM-006: No log rotation — logs grow unbounded
+**Severity**: Medium
+**GitHub**: [#1114](https://github.com/ruvnet/claude-flow/issues/1114)
+## Root Cause
+(Headless) `logExecution()` in `headless-worker-executor.js` creates 2-3 log files per worker run (~75 KB each) but has zero cleanup. No rotation, no max file count, no TTL. At current daemon intervals this accumulates ~23 MB/day, ~702 MB/month. (Main) `startBackgroundDaemon()` in `daemon.js` opens `daemon.log` in append mode and never truncates. A single long-running daemon can grow daemon.log to 100+ GB.
+## Fix
+(A) Add `unlinkSync` and `statSync` to the headless executor ESM import. (B) Call `cleanupOldLogs()` from `ensureLogDir()` so cleanup runs on each headless execution cycle. (C) Add `cleanupOldLogs()` method: removes `.log` files older than 7 days or beyond a 500-file cap, keeping newest files. (D) In `daemon.js`, before opening `daemon.log` for append, check its size with `fs.statSync()` and rotate to `daemon.log.1` if > 50MB.
+## Files Patched
+- services/headless-worker-executor.js
+- commands/daemon.js
+## Ops
+4 ops in fix.py

package/patch/300-DM-006-log-rotation/fix.py

@@ -0,0 +1,72 @@
+# DM-006: No log rotation — headless execution logs grow unbounded
+# GitHub: #1114
+
+# A: Add unlinkSync and statSync to ESM import
+patch("DM-006a: add unlinkSync/statSync to fs import",
+    HWE,
+    "import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'fs';",
+    "import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, unlinkSync, statSync } from 'fs';")
+
+# B: Call cleanupOldLogs() from ensureLogDir()
+patch("DM-006b: call cleanup from ensureLogDir",
+    HWE,
+    """    ensureLogDir() {
+        try {
+            if (!existsSync(this.config.logDir)) {
+                mkdirSync(this.config.logDir, { recursive: true });
+            }
+        }
+        catch (error) {
+            this.emit('warning', { message: 'Failed to create log directory', error });
+        }
+    }""",
+    """    ensureLogDir() {
+        try {
+            if (!existsSync(this.config.logDir)) {
+                mkdirSync(this.config.logDir, { recursive: true });
+            }
+            this.cleanupOldLogs();
+        }
+        catch (error) {
+            this.emit('warning', { message: 'Failed to create log directory', error });
+        }
+    }""")
+
+# C: Add cleanupOldLogs() method before logExecution()
+patch("DM-006c: add cleanupOldLogs method",
+    HWE,
+    """    logExecution(executionId, type, content) {""",
+    """    cleanupOldLogs(maxAgeDays = 7, maxFiles = 500) {
+        try {
+            const files = readdirSync(this.config.logDir)
+                .filter(f => f.endsWith('.log'))
+                .map(f => {
+                    try { return { name: f, mtime: statSync(join(this.config.logDir, f)).mtimeMs }; }
+                    catch { return null; }
+                })
+                .filter(Boolean)
+                .sort((a, b) => b.mtime - a.mtime);
+            const cutoff = Date.now() - maxAgeDays * 86400000;
+            for (let i = 0; i < files.length; i++) {
+                if (files[i].mtime < cutoff || i >= maxFiles) {
+                    try { unlinkSync(join(this.config.logDir, files[i].name)); } catch {}
+                }
+            }
+        }
+        catch { /* ignore cleanup errors */ }
+    }
+    logExecution(executionId, type, content) {""")
+
+# DM-006 extension: Main daemon.log rotation in daemon.js
+# Before opening daemon.log for append, check size and rotate if > 50MB
+patch("DM-006d: main daemon.log rotation",
+    DJ,
+    "    const logFile = join(logsDir, 'daemon.log');",
+    """    const logFile = join(logsDir, 'daemon.log');
+    // Rotate main daemon.log if > 50MB
+    try {
+        const logStat = fs.statSync(logFile);
+        if (logStat.size > 50 * 1024 * 1024) {
+            fs.renameSync(logFile, logFile + '.1');
+        }
+    } catch { /* file doesn't exist yet or stat failed — ignore */ }""")

package/patch/300-DM-006-log-rotation/sentinel

@@ -0,0 +1,2 @@
+grep "cleanupOldLogs" services/headless-worker-executor.js
+grep "Rotate main daemon.log" commands/daemon.js

package/patch/310-HW-004-runwithtimeout-orphan/README.md

@@ -0,0 +1,11 @@
+# HW-004: runWithTimeout rejects but does not kill child process
+**Severity**: Medium
+**GitHub**: [#1117](https://github.com/ruvnet/claude-flow/issues/1117)
+## Root Cause
+`runWithTimeout()` in `worker-daemon.js` has `DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000` (5 min), but the headless executor's per-worker timeouts range from 5-15 minutes. When the daemon timeout fires first, the promise rejects but the underlying `claude --print` child process keeps running as an orphan until the executor's own timeout fires minutes later.
+## Fix
+Raise `DEFAULT_WORKER_TIMEOUT_MS` from 5 minutes to 16 minutes so the daemon timeout never fires before the executor's own per-worker timeout (max 15 min for audit/refactor workers). The executor handles its own child process cleanup on timeout.
+## Files Patched
+- services/worker-daemon.js
+## Ops
+1 op in fix.py

package/patch/310-HW-004-runwithtimeout-orphan/fix.py

@@ -0,0 +1,10 @@
+# HW-004: runWithTimeout rejects but does not kill child process
+# GitHub: #1117
+
+# A: Raise daemon worker timeout above max headless timeout (15 min)
+patch("HW-004a: raise worker timeout to 16 min",
+    WD,
+    """// Worker timeout (5 minutes max per worker)
+const DEFAULT_WORKER_TIMEOUT_MS = 5 * 60 * 1000;""",
+    """// Worker timeout — must exceed max headless timeout (15 min for audit/refactor)
+const DEFAULT_WORKER_TIMEOUT_MS = 16 * 60 * 1000;""")

package/patch/310-HW-004-runwithtimeout-orphan/sentinel

@@ -0,0 +1 @@
+grep "16 \* 60 \* 1000" services/worker-daemon.js

package/patch/320-SG-004-wizard-parity/README.md

@@ -0,0 +1,40 @@
+# SG-004: init wizard lacks parity with init
+
+**Severity**: High
+**GitHub**: [#1181](https://github.com/ruvnet/claude-flow/issues/1181)
+
+## Root Cause
+
+The `wizardCommand.action` in `commands/init.js` was implemented as a
+standalone code path that diverges from the parent `initAction`. It skips the
+already-initialized guard, ignores `--force`, `--start-all`, `--start-daemon`,
+`--codex`, and `--dual` flags, and never shows "Next steps" hints. The wizard
+is also only reachable as a subcommand of `init` with no `options` array, so
+the parser cannot validate flags for the wizard context.
+
+## Fix
+
+Ten ops bring the wizard to full parity with `init` and promote it to a
+top-level command (`claude-flow wizard`):
+
+| Op | What it does |
+|----|-------------|
+| SG-004a | Adds the already-initialized guard before prompts + passes `--force` to options |
+| SG-004b | Adds `--codex`/`--dual` handling after executeInit succeeds |
+| SG-004c | Adds `--start-all`/`--start-daemon` service startup + "Next steps" hints |
+| SG-004d | Fixes catch block — catches errors cleanly instead of re-throwing |
+| SG-004e | Exports `wizardCommand` from init.js, adds `options` + `examples` arrays |
+| SG-004f | Imports `wizardCommand` in the command registry (`commands/index.js`) |
+| SG-004g | Adds wizard to `commandLoaders` for lazy-loading |
+| SG-004h | Pre-populates wizard in the loaded commands cache |
+| SG-004i | Adds `wizardCommand` to the `commands` array (parser registration) |
+| SG-004j | Adds `wizardCommand` to `commandsByCategory.primary` for help display |
+
+## Files Patched
+
+- `commands/init.js`
+- `commands/index.js`
+
+## Ops
+
+10 ops in fix.py

package/patch/320-SG-004-wizard-parity/fix.py

@@ -0,0 +1,208 @@
+# SG-004: init wizard lacks parity with init
+# GitHub: #1181
+#
+# The wizard was implemented as a standalone code path that ignores
+# --force, --start-all, --start-daemon, --codex, --dual, and skips
+# the already-initialized guard and "Next steps" hints. It is also only
+# reachable as a subcommand of `init` with no options array, so the parser
+# cannot validate flags for the wizard context.
+#
+# 10 ops: init-guard + force (a), codex/dual (b), start-all + next-steps (c),
+#          catch-block error handling (d), export + options (e),
+#          import in registry (f), loaders (g), cache (h),
+#          commands array (i), category (j)
+
+# Op 1: Add already-initialized guard + pass --force to executeInit options
+patch("SG-004a: wizard init-guard + --force",
+    INIT_CMD,
+    """        try {
+            // Start with base options
+            const options = { ...DEFAULT_INIT_OPTIONS, targetDir: ctx.cwd };""",
+    """        try {
+            // SG-004: Check if already initialized (respects --force)
+            const force = ctx.flags.force;
+            const initialized = isInitialized(ctx.cwd);
+            const hasExisting = initialized.claude || initialized.claudeFlow;
+            if (hasExisting && !force) {
+                output.printWarning('Claude Flow appears to be already initialized');
+                if (initialized.claude) output.printInfo('  Found: .claude/settings.json');
+                if (initialized.claudeFlow) output.printInfo('  Found: .claude-flow/config.yaml');
+                output.printInfo('Use --force to reinitialize');
+                const proceed = await confirm({
+                    message: 'Do you want to reinitialize? This will overwrite existing configuration.',
+                    default: false,
+                });
+                if (!proceed) {
+                    return { success: true, message: 'Wizard cancelled' };
+                }
+            }
+            // Start with base options
+            const options = { ...DEFAULT_INIT_OPTIONS, targetDir: ctx.cwd, force: ctx.flags.force };""")
+
+# Op 2: Add --codex / --dual handling after executeInit succeeds
+patch("SG-004b: wizard --codex/--dual support",
+    INIT_CMD,
+    """            spinner.succeed('Setup complete!');
+            // Initialize embeddings if enabled
+            let embeddingsInitialized = false;""",
+    """            spinner.succeed('Setup complete!');
+            // SG-004: Respect --codex / --dual in wizard
+            const codexMode = ctx.flags.codex;
+            const dualMode = ctx.flags.dual;
+            if (codexMode || dualMode) {
+                try {
+                    output.writeln(output.dim('  Initializing Codex integration...'));
+                    await initCodexAction(ctx, { codexMode, dualMode, force: ctx.flags.force, minimal: false, full: false });
+                } catch (err) {
+                    output.printWarning(`Codex initialization: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Initialize embeddings if enabled
+            let embeddingsInitialized = false;""")
+
+# Op 3: Add --start-all / --start-daemon + "Next steps" hints before final return
+patch("SG-004c: wizard --start-all + next-steps",
+    INIT_CMD,
+    """            });
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'User cancelled') {""",
+    """            });
+            // SG-004: Respect --start-all / --start-daemon in wizard
+            const startAll = ctx.flags['start-all'] || ctx.flags.startAll;
+            const startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
+            if (startDaemon || startAll) {
+                output.writeln();
+                output.printInfo('Starting services...');
+                const { execSync } = await import('child_process');
+                if (startAll) {
+                    try {
+                        output.writeln(output.dim('  Initializing memory database...'));
+                        execSync('npx @claude-flow/cli@latest memory init 2>/dev/null', {
+                            stdio: 'pipe', cwd: ctx.cwd, timeout: 30000
+                        });
+                        output.writeln(output.success('  \\u2713 Memory initialized'));
+                    } catch { output.writeln(output.dim('  Memory database already exists')); }
+                }
+                if (startDaemon) {
+                    try {
+                        output.writeln(output.dim('  Starting daemon...'));
+                        execSync('npx @claude-flow/cli@latest daemon start 2>/dev/null &', {
+                            stdio: 'pipe', cwd: ctx.cwd, timeout: 10000
+                        });
+                        output.writeln(output.success('  \\u2713 Daemon started'));
+                    } catch { output.writeln(output.warning('  Daemon may already be running')); }
+                }
+                if (startAll) {
+                    try {
+                        output.writeln(output.dim('  Initializing swarm...'));
+                        execSync('npx @claude-flow/cli@latest swarm init --topology hierarchical 2>/dev/null', {
+                            stdio: 'pipe', cwd: ctx.cwd, timeout: 30000
+                        });
+                        output.writeln(output.success('  \\u2713 Swarm initialized'));
+                    } catch { output.writeln(output.dim('  Swarm initialization skipped')); }
+                }
+                output.writeln();
+                output.printSuccess('All services started');
+            }
+            else {
+                output.writeln(output.bold('Next steps:'));
+                output.printList([
+                    `Run ${output.highlight('claude-flow daemon start')} to start background workers`,
+                    `Run ${output.highlight('claude-flow memory init')} to initialize memory database`,
+                    `Run ${output.highlight('claude-flow swarm init')} to initialize a swarm`,
+                    `Or re-run with ${output.highlight('--start-all')} to do all of the above`,
+                ]);
+            }
+            return { success: true, data: result };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'User cancelled') {""")
+
+# Op 4: Fix wizard catch block — re-throws instead of clean error message
+# spinner is declared inside the try block so we can't call spinner.fail() here
+patch("SG-004d: wizard catch block handles errors cleanly",
+    INIT_CMD,
+    """            if (error instanceof Error && error.message === 'User cancelled') {
+                output.printInfo('Setup cancelled');
+                return { success: true };
+            }
+            throw error;""",
+    """            if (error instanceof Error && error.message === 'User cancelled') {
+                output.printInfo('Setup cancelled');
+                return { success: true };
+            }
+            output.printError(`Failed to initialize: ${error instanceof Error ? error.message : String(error)}`);
+            return { success: false, exitCode: 1 };""")
+
+# ── Promote wizard to top-level command ──
+# Ops e–j: export wizardCommand with options, register in command registry
+
+# Op 5: Export wizardCommand + add options/examples arrays
+patch("SG-004e: export wizardCommand with options",
+    INIT_CMD,
+    """// Wizard subcommand for interactive setup
+const wizardCommand = {
+    name: 'wizard',
+    description: 'Interactive setup wizard for comprehensive configuration',
+    action: async (ctx) => {""",
+    """// Wizard — top-level command + init subcommand — SG-004
+export const wizardCommand = {
+    name: 'wizard',
+    aliases: ['wiz'],
+    description: 'Interactive setup wizard for comprehensive configuration',
+    options: [
+        { name: 'force', short: 'f', description: 'Overwrite existing configuration', type: 'boolean', default: false },
+        { name: 'start-all', description: 'Auto-start daemon, memory, and swarm after init', type: 'boolean', default: false },
+        { name: 'start-daemon', description: 'Auto-start daemon after init', type: 'boolean', default: false },
+        { name: 'codex', description: 'Initialize for OpenAI Codex CLI', type: 'boolean', default: false },
+        { name: 'dual', description: 'Initialize for both Claude Code and Codex', type: 'boolean', default: false },
+        { name: 'with-embeddings', description: 'Initialize ONNX embedding subsystem', type: 'boolean', default: false },
+        { name: 'embedding-model', description: 'ONNX embedding model', type: 'string', default: 'all-MiniLM-L6-v2', choices: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'] },
+    ],
+    examples: [
+        { command: 'claude-flow wizard', description: 'Run interactive setup wizard' },
+        { command: 'claude-flow wizard --start-all', description: 'Wizard then start all services' },
+        { command: 'claude-flow wizard --force', description: 'Reinitialize with wizard' },
+        { command: 'claude-flow wizard --codex', description: 'Wizard with Codex integration' },
+    ],
+    action: async (ctx) => {""")
+
+# Op 6: Import wizardCommand in command registry
+patch("SG-004f: import wizardCommand in command registry",
+    CMDS_INDEX,
+    """import { initCommand } from './init.js';""",
+    """import { initCommand, wizardCommand } from './init.js';""")
+
+# Op 7: Add wizard to commandLoaders for lazy loading
+patch("SG-004g: add wizard to commandLoaders",
+    CMDS_INDEX,
+    """    init: () => import('./init.js'),""",
+    """    init: () => import('./init.js'),
+    wizard: () => import('./init.js'),""")
+
+# Op 8: Pre-populate wizard in loadedCommands cache
+patch("SG-004h: cache wizard command",
+    CMDS_INDEX,
+    """loadedCommands.set('init', initCommand);""",
+    """loadedCommands.set('init', initCommand);
+loadedCommands.set('wizard', wizardCommand);""")
+
+# Op 9: Add wizardCommand to commands array (triggers parser registration)
+patch("SG-004i: register wizard in commands array",
+    CMDS_INDEX,
+    """    initCommand,
+    startCommand,""",
+    """    initCommand,
+    wizardCommand,
+    startCommand,""")
+
+# Op 10: Add wizardCommand to commandsByCategory.primary for help display
+patch("SG-004j: add wizard to primary category",
+    CMDS_INDEX,
+    """    primary: [
+        initCommand,""",
+    """    primary: [
+        initCommand,
+        wizardCommand,""")

package/patch/320-SG-004-wizard-parity/sentinel

@@ -0,0 +1,3 @@
+grep "SG-004" commands/init.js
+grep "export const wizardCommand" commands/init.js
+grep "wizardCommand" commands/index.js

package/patch/330-SG-005-start-all-subcommand/README.md

@@ -0,0 +1,32 @@
+# SG-005: add 'start all' subcommand to start everything at once
+
+**Severity**: Enhancement
+**GitHub**: [#1177](https://github.com/ruvnet/claude-flow/issues/1177)
+
+## Root Cause
+
+There is no single command to start the full Claude Flow stack (memory +
+daemon + swarm + MCP) on an already-initialized project. `claude-flow start`
+only initializes the swarm and MCP server. Users must run `memory init`,
+`daemon start`, and `start` separately, or re-run `init --start-all` which
+also re-creates project files.
+
+## Fix
+
+Add an `allCommand` subcommand to the `start` command so that
+`claude-flow start all` initializes memory, starts the daemon, then runs the
+normal `startAction` (swarm + MCP + health checks).
+
+| Op | What it does |
+|----|-------------|
+| SG-005a | Adds `allCommand` subcommand definition before `quickCommand` |
+| SG-005b | Registers `allCommand` in the `subcommands` array |
+| SG-005c | Adds `start all` to the examples array for `--help` output |
+
+## Files Patched
+
+- `commands/start.js`
+
+## Ops
+
+3 ops in fix.py

package/patch/330-SG-005-start-all-subcommand/fix.py

@@ -0,0 +1,58 @@
+# SG-005: add 'start all' subcommand to start everything at once
+# GitHub: #1177
+
+patch("SG-005a: add allCommand subcommand definition",
+    START_CMD,
+    """// Quick start subcommand
+const quickCommand = {""",
+    """// Start-all subcommand — SG-005
+const allCommand = {
+    name: 'all',
+    aliases: ['everything'],
+    description: 'Start memory, daemon, swarm, and MCP server',
+    action: async (ctx) => {
+        // Check initialization
+        if (!isInitialized(ctx.cwd)) {
+            output.printError('Claude Flow is not initialized in this directory');
+            output.printInfo('Run "claude-flow init" first, or use "claude-flow start quick"');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Starting all Claude Flow services'));
+        output.writeln();
+        const { execSync } = await import('child_process');
+        // Step 1: Initialize memory
+        try {
+            output.writeln(output.dim('  Initializing memory database...'));
+            execSync('npx @claude-flow/cli@latest memory init 2>/dev/null', {
+                stdio: 'pipe', cwd: ctx.cwd, timeout: 30000
+            });
+            output.writeln('  \\u2713 Memory initialized');
+        } catch { output.writeln('  Memory database already exists'); }
+        // Step 2: Start daemon
+        try {
+            output.writeln(output.dim('  Starting daemon...'));
+            execSync('npx @claude-flow/cli@latest daemon start 2>/dev/null &', {
+                stdio: 'pipe', cwd: ctx.cwd, timeout: 10000
+            });
+            output.writeln('  \\u2713 Daemon started');
+        } catch { output.writeln('  Daemon may already be running'); }
+        // Step 3: Start swarm + MCP via normal startAction
+        return startAction(ctx);
+    }
+};
+// Quick start subcommand
+const quickCommand = {""")
+
+patch("SG-005b: register allCommand in subcommands array",
+    START_CMD,
+    """    subcommands: [stopCommand, restartCommand, quickCommand],""",
+    """    subcommands: [stopCommand, restartCommand, quickCommand, allCommand],""")
+
+patch("SG-005c: add 'start all' to examples array",
+    START_CMD,
+    """        { command: 'claude-flow start stop', description: 'Stop the running system' }
+    ],""",
+    """        { command: 'claude-flow start stop', description: 'Stop the running system' },
+        { command: 'claude-flow start all', description: 'Start memory, daemon, swarm, and MCP' }
+    ],""")

package/patch/330-SG-005-start-all-subcommand/sentinel

@@ -0,0 +1 @@
+grep "allCommand" commands/start.js