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

package/patch/220-RS-001-better-sqlite3-node24/fix.py

@@ -0,0 +1,27 @@
+# RS-001: ruv-swarm better-sqlite3 Node 24 compatibility
+# GitHub: ruvnet/ruv-FANN#185
+#
+# ruv-swarm@1.0.20 pins better-sqlite3@^11.6.0 which lacks Node 24
+# prebuilt binaries. Bump to ^12.0.0 which supports Node 24 (v137 ABI).
+#
+# This patch targets the ruv-swarm package.json, NOT @claude-flow/cli.
+# Uses RUV_SWARM_ROOT from discover.sh, with glob fallback for backward compat.
+
+import glob
+
+# Prefer RUV_SWARM_ROOT from discover.sh; fall back to glob for standalone use
+rs_pkg = ""
+if ruv_swarm_root:
+    _candidate = os.path.join(ruv_swarm_root, "package.json")
+    if os.path.isfile(_candidate):
+        rs_pkg = _candidate
+if not rs_pkg:
+    rs_pkg_candidates = glob.glob(os.path.expanduser(
+        "~/.npm/_npx/*/node_modules/ruv-swarm/package.json"
+    ))
+    rs_pkg = rs_pkg_candidates[0] if rs_pkg_candidates else ""
+
+patch("RS-001: better-sqlite3 ^11 -> ^12 (Node 24)",
+    rs_pkg,
+    '"better-sqlite3": "^11.6.0"',
+    '"better-sqlite3": "^12.0.0"')

package/patch/220-RS-001-better-sqlite3-node24/rebuild.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# RS-001: After patching package.json, reinstall better-sqlite3 with
+# correct prebuilt binaries for Node 24.
+#
+# Usage: bash rebuild.sh
+
+set -euo pipefail
+
+RS_DIR=$(find ~/.npm/_npx -path "*/node_modules/ruv-swarm" -type d 2>/dev/null | head -1)
+
+if [ -z "$RS_DIR" ]; then
+  echo "[RS-001] ruv-swarm not found in npx cache, skipping rebuild"
+  exit 0
+fi
+
+# Install at the npx cache root (where better-sqlite3 is hoisted),
+# not inside ruv-swarm's own node_modules
+NPX_ROOT=$(echo "$RS_DIR" | sed 's|/node_modules/ruv-swarm$||')
+
+echo "[RS-001] Reinstalling better-sqlite3@^12.0.0 in: $NPX_ROOT"
+
+cd "$NPX_ROOT"
+npm install better-sqlite3@"^12.0.0" --no-save 2>&1
+
+echo "[RS-001] Verifying..."
+if npx -y ruv-swarm --version 2>/dev/null; then
+  echo "[RS-001] OK: ruv-swarm starts successfully"
+else
+  echo "[RS-001] WARN: ruv-swarm still failing — may need full cache clear"
+  echo "  Try: rm -rf ~/.npm/_npx/$(basename $(dirname $RS_DIR)) && npx -y ruv-swarm --version"
+fi

package/patch/220-RS-001-better-sqlite3-node24/sentinel

@@ -0,0 +1,2 @@
+package: ruv-swarm
+grep "better-sqlite3.*\^12" package.json

package/patch/230-RV-001-force-learn-tick/README.md

@@ -0,0 +1,31 @@
+# RV-001: force-learn command calls intel.tick() which doesn't exist
+
+**Severity**: Medium
+**GitHub**: [#1156](https://github.com/ruvnet/claude-flow/issues/1156)
+
+## Root Cause
+
+The `hooks force-learn` command (line 4224) creates an Intelligence instance with
+`skipEngine: true` (fast mode), then calls `intel.tick()`. The `tick()` method
+exists on the engine object (`eng.tick()`), not on the Intelligence class itself.
+With `skipEngine: true`, no engine is created, so the call crashes.
+
+```javascript
+// Line 4224-4226
+const intel = new Intelligence({ skipEngine: true });  // Fast mode
+intel.tick();  // BUG: tick() doesn't exist on Intelligence
+```
+
+## Fix
+
+1. Remove `skipEngine: true` so the engine can initialize
+2. Call `intel.engine.tick()` instead of `intel.tick()`
+3. Add null check for when engine fails to load
+
+## Files Patched
+
+- `ruvector/bin/cli.js`
+
+## Ops
+
+2 ops in fix.py

package/patch/230-RV-001-force-learn-tick/fix.py

@@ -0,0 +1,14 @@
+# RV-001: force-learn calls intel.tick() which doesn't exist
+# The tick() method is on the engine, not the Intelligence class
+
+# Fix 1: Remove skipEngine: true so engine can initialize
+patch("RV-001a: remove skipEngine from force-learn",
+    ruvector_cli,
+    "const intel = new Intelligence({ skipEngine: true });  // Fast mode\n    intel.tick();",
+    "const intel = new Intelligence();  // Need engine for tick()\n    const eng = intel.engine;\n    if (eng) { eng.tick(); }")
+
+# Fix 2: Update the success message to handle no-engine case
+patch("RV-001b: handle no-engine case in force-learn",
+    ruvector_cli,
+    "if (eng) { eng.tick(); }\n    console.log(JSON.stringify({ success: true, result: 'Learning cycle triggered', stats: intel.stats() }));",
+    "if (eng) { eng.tick(); }\n    console.log(JSON.stringify({ success: true, result: eng ? 'Learning cycle triggered' : 'Engine not available', stats: intel.stats() }));")

package/patch/230-RV-001-force-learn-tick/sentinel

@@ -0,0 +1,2 @@
+package: ruvector
+grep "Need engine for tick" bin/cli.js

package/patch/240-RV-002-trajectory-load/README.md

@@ -0,0 +1,28 @@
+# RV-002: activeTrajectories not loaded from saved file
+
+**Severity**: High
+**GitHub**: [#1157](https://github.com/ruvnet/claude-flow/issues/1157)
+
+## Root Cause
+
+The `load()` method in the Intelligence class (line ~2721) doesn't include
+`activeTrajectories` in the returned object. When `trajectory-begin` saves an
+active trajectory, it's written to the file, but the next command
+(`trajectory-step`) creates a new Intelligence instance that doesn't load
+`activeTrajectories` back from the file.
+
+This causes `trajectory-step` and `trajectory-end` to fail with
+"No active trajectory" error.
+
+## Fix
+
+1. Add `activeTrajectories: {}` to the defaults object
+2. Add `activeTrajectories: data.activeTrajectories || {}` to the loaded data return
+
+## Files Patched
+
+- `ruvector/bin/cli.js`
+
+## Ops
+
+2 ops in fix.py

package/patch/240-RV-002-trajectory-load/fix.py

@@ -0,0 +1,14 @@
+# RV-002: activeTrajectories not loaded from saved file
+# The load() method doesn't include activeTrajectories in the return object
+
+# Fix 1: Add activeTrajectories to defaults
+patch("RV-002a: add activeTrajectories to defaults",
+    ruvector_cli,
+    "stats: { total_patterns: 0, total_memories: 0, total_trajectories: 0, total_errors: 0, session_count: 0, last_session: 0 }\n    };",
+    "stats: { total_patterns: 0, total_memories: 0, total_trajectories: 0, total_errors: 0, session_count: 0, last_session: 0 },\n      activeTrajectories: {}\n    };")
+
+# Fix 2: Add activeTrajectories to loaded data return
+patch("RV-002b: load activeTrajectories from file",
+    ruvector_cli,
+    "// Preserve learning data if present\n          learning: data.learning || undefined",
+    "// Preserve learning data if present\n          learning: data.learning || undefined,\n          // Preserve active trajectories for cross-command persistence\n          activeTrajectories: data.activeTrajectories || {}")

package/patch/240-RV-002-trajectory-load/sentinel

@@ -0,0 +1,2 @@
+package: ruvector
+grep "activeTrajectories: data.activeTrajectories" bin/cli.js

package/patch/250-RV-003-trajectory-stats-sync/README.md

@@ -0,0 +1,31 @@
+# RV-003: trajectory-end does not update stats counters
+
+**Severity**: Medium
+**GitHub**: [ruv-FANN#186](https://github.com/ruvnet/ruv-FANN/issues/186)
+
+## Root Cause
+
+The `hooks trajectory-end` command pushes completed trajectories to
+`data.trajectories[]` and calls `intel.save()`, but never syncs the
+`data.stats.total_trajectories` counter. The `hooks stats` command reads
+the stale counter and reports 0 trajectories even when the array has entries.
+
+Compare with `learn()` which correctly does:
+```javascript
+this.data.stats.total_trajectories = this.data.trajectories.length;
+```
+
+## Fix
+
+Add stats counter sync before `intel.save()` in the `trajectory-end` handler:
+- `total_trajectories` from `trajectories.length`
+- `total_patterns` from `Object.keys(patterns).length`
+- `total_memories` from `memories.length`
+
+## Files Patched
+
+- `bin/cli.js` (ruvector)
+
+## Ops
+
+1 op in fix.py

package/patch/250-RV-003-trajectory-stats-sync/fix.py

@@ -0,0 +1,18 @@
+# RV-003: trajectory-end does not update stats counters
+# GitHub: #186 (ruv-FANN)
+
+patch("RV-003a: sync stats counters before save in trajectory-end",
+    ruvector_cli,
+    """    if (!intel.data.trajectories) intel.data.trajectories = [];
+    intel.data.trajectories.push(traj);
+    delete trajectories[latestTrajId];
+    intel.save();""",
+    """    if (!intel.data.trajectories) intel.data.trajectories = [];
+    intel.data.trajectories.push(traj);
+    delete trajectories[latestTrajId];
+    // RV-003: sync stats counters from actual data before saving
+    if (!intel.data.stats) intel.data.stats = {};
+    intel.data.stats.total_trajectories = intel.data.trajectories.length;
+    intel.data.stats.total_patterns = Object.keys(intel.data.patterns || {}).length;
+    intel.data.stats.total_memories = (intel.data.memories || []).length;
+    intel.save();""")

package/patch/250-RV-003-trajectory-stats-sync/sentinel

@@ -0,0 +1,2 @@
+package: ruvector
+grep "RV-003: sync stats" bin/cli.js

package/patch/260-SG-001-init-settings/README.md

@@ -0,0 +1,29 @@
+# SG-001: Init generates invalid settings
+
+**Severity**: High
+**GitHub**: [#1150](https://github.com/ruvnet/claude-flow/issues/1150)
+
+## Root Cause
+
+1. **Invalid hook events**: `TeammateIdle` and `TaskCompleted` are not valid Claude Code hooks
+2. **Overly broad permissions**: Glob patterns like `Bash(npx @claude-flow*)` match unintended commands
+3. **Relative hook paths**: `node .claude/helpers/` breaks when running from subdirectories
+4. **Phantom statusLine config**: `--minimal` and `init hooks` emit `statusLine` config
+   referencing `statusline.cjs` but the file is never generated (`components.statusline: false`)
+5. **MINIMAL statusline inconsistency**: `MINIMAL_INIT_OPTIONS` inherits
+   `statusline.enabled: true` from DEFAULT but sets `components.statusline: false`
+
+## Fix
+
+Replace invalid hooks with `SubagentStop` (valid event), fix permission patterns, use
+`$CLAUDE_PROJECT_DIR` for all hook paths, gate statusLine config emission on
+`components.statusline`, and override `statusline.enabled` to `false` in MINIMAL preset.
+
+## Files Patched
+
+- `init/settings-generator.js`
+- `init/types.js`
+
+## Ops
+
+5 ops in fix.py (SG-001a: replace invalid hooks, SG-001b: fix permissions, SG-001c: CLAUDE_PROJECT_DIR paths, SG-001d: gate statusLine on component flag, SG-001e: MINIMAL statusline.enabled=false)

package/patch/260-SG-001-init-settings/fix.py

@@ -0,0 +1,143 @@
+# SG-001: Init generates invalid settings
+# GitHub: #1150
+#
+# Problems:
+# 1. TeammateIdle and TaskCompleted are not valid Claude Code hook events
+# 2. Permission patterns are too broad (glob wildcards)
+# 3. Hook paths use relative .claude/helpers/ which breaks from subdirectories
+#
+# Fix: Replace invalid hooks with SubagentStop, fix permissions, use $CLAUDE_PROJECT_DIR
+
+# SG-001a: Replace invalid hooks with SubagentStop (with correct $CLAUDE_PROJECT_DIR paths)
+patch("SG-001a: replace invalid hooks with SubagentStop",
+    SETTINGS_GEN,
+    """    // SubagentStart — status update
+    hooks.SubagentStart = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'node .claude/helpers/hook-handler.cjs status',
+                    timeout: 3000,
+                },
+            ],
+        },
+    ];
+    // TeammateIdle — auto-assign pending tasks to idle teammates
+    hooks.TeammateIdle = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'node .claude/helpers/hook-handler.cjs post-task',
+                    timeout: 5000,
+                },
+            ],
+        },
+    ];
+    // TaskCompleted — train patterns and record completion
+    hooks.TaskCompleted = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'node .claude/helpers/hook-handler.cjs post-task',
+                    timeout: 5000,
+                },
+            ],
+        },
+    ];
+    return hooks;""",
+    """    // SubagentStart — status update
+    hooks.SubagentStart = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'node "$CLAUDE_PROJECT_DIR"/.claude/helpers/hook-handler.cjs status',
+                    timeout: 3000,
+                },
+            ],
+        },
+    ];
+    // SubagentStop — task completion + teammate idle (replaces invalid TeammateIdle/TaskCompleted)
+    hooks.SubagentStop = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'node "$CLAUDE_PROJECT_DIR"/.claude/helpers/hook-handler.cjs post-task',
+                    timeout: 5000,
+                },
+                {
+                    type: 'command',
+                    command: 'npx @claude-flow/cli@latest hooks teammate-idle',
+                    timeout: 5000,
+                },
+            ],
+        },
+    ];
+    // TeammateIdle removed — not a valid Claude Code hook event (see #1150)
+    // TaskCompleted removed — not a valid Claude Code hook event (see #1150)
+    return hooks;""")
+
+# SG-001b: Fix permission patterns (too broad) and add $CLAUDE_PROJECT_DIR
+patch("SG-001b: fix permissions",
+    SETTINGS_GEN,
+    """    settings.permissions = {
+        allow: [
+            'Bash(npx @claude-flow*)',
+            'Bash(npx claude-flow*)',
+            'Bash(node .claude/*)',
+            'mcp__claude-flow__:*',
+        ],""",
+    """    settings.permissions = {
+        allow: [
+            'Bash(npx @claude-flow/cli:*)',
+            'Bash(npx claude-flow:*)',
+            'Bash(node "$CLAUDE_PROJECT_DIR"/.claude/*)',
+            'mcp__claude-flow__:*',
+        ],""")
+
+# SG-001c: Fix all other hook paths to use $CLAUDE_PROJECT_DIR
+# (catches statusline, pre-bash, post-edit, route, session hooks, etc.)
+patch_all("SG-001c: use CLAUDE_PROJECT_DIR for all hook paths",
+    SETTINGS_GEN,
+    "command: 'node .claude/helpers/",
+    'command: \'node "$CLAUDE_PROJECT_DIR"/.claude/helpers/')
+
+# SG-001d: statusLine config emitted even when statusline component is off
+# MINIMAL_INIT_OPTIONS has components.statusline=false but statusline.enabled=true.
+# Settings-generator checks statusline.enabled, emitting statusLine config for a
+# file that won't exist. Gate on components.statusline too.
+patch("SG-001d: only emit statusLine when statusline component is generated",
+    SETTINGS_GEN,
+    """    if (options.statusline.enabled) {""",
+    """    // SG-001: Only emit statusLine config if the component will actually be generated
+    if (options.components.statusline && options.statusline.enabled) {""")
+
+# SG-001e: MINIMAL_INIT_OPTIONS inherits statusline.enabled=true from DEFAULT
+# but sets components.statusline=false. Override to prevent inconsistency.
+# (SG-001d guards at the consumer; this fixes the producer for MINIMAL)
+patch("SG-001e: MINIMAL statusline.enabled matches components.statusline",
+    TYPES,
+    """    hooks: {
+        ...DEFAULT_INIT_OPTIONS.hooks,
+        userPromptSubmit: false,
+        stop: false,
+        notification: false,
+    },
+    skills: {""",
+    """    hooks: {
+        ...DEFAULT_INIT_OPTIONS.hooks,
+        userPromptSubmit: false,
+        stop: false,
+        notification: false,
+    },
+    // SG-001: statusline file not generated (components.statusline: false)
+    // so disable the feature flag to prevent dangling settings.json references
+    statusline: {
+        ...DEFAULT_INIT_OPTIONS.statusline,
+        enabled: false,
+    },
+    skills: {""")

package/patch/260-SG-001-init-settings/sentinel

@@ -0,0 +1,4 @@
+grep "hooks.SubagentStop" init/settings-generator.js
+grep "CLAUDE_PROJECT_DIR" init/settings-generator.js
+grep "components.statusline && options.statusline.enabled" init/settings-generator.js
+grep "SG-001" init/types.js

package/patch/270-SG-003-init-helpers-all-paths/README.md

@@ -0,0 +1,60 @@
+# SG-003: Init missing helpers for --dual, --minimal, hooks, and upgrade paths
+
+**Severity**: Critical
+**GitHub**: [#1169](https://github.com/ruvnet/claude-flow/issues/1169)
+
+## Root Cause
+
+Multiple `init` code paths generate `settings.json` (which references `hook-handler.cjs`,
+`auto-memory-hook.mjs`, `statusline.cjs`) without generating the helper files those hooks need.
+
+| Path | Generates settings? | Generates helpers? | Result |
+|------|--------------------|--------------------|--------|
+| `init` (default) | YES | YES | OK |
+| `init --dual` | NO (bypasses executeInit) | NO | Broken: no Claude infra despite CLAUDE.md |
+| `init --codex` | NO (bypasses executeInit) | NO | OK (no Claude Code expected) |
+| `init --minimal` | YES | NO (helpers: false) | Broken: dangling settings refs |
+| `init hooks` | YES | NO (helpers: false) | Broken: dangling settings refs |
+| `init upgrade` | Only with --settings | Partial (3 of 8) | Broken: missing router/session/memory |
+| `init wizard` | YES | YES (default) | OK |
+
+Additionally:
+- `helpers-generator.js` generates a `hook-handler.cjs` that hardcodes `require('router.js')`
+  instead of `require('router.cjs')`, failing when `package.json` has `"type": "module"`.
+- `executeUpgrade()` only upgrades 3 critical helpers but `hook-handler.cjs` needs 6.
+- `executeUpgrade()` fallback also only generates 3 in `generatedCritical`.
+
+## Fix
+
+7 ops across 4 files:
+
+1. **init.js** — After `--dual` codex init succeeds, call `executeInit()` with
+   all components so full Claude Code infrastructure is created.
+2. **executor.js** — When `settings` is generated but `helpers` is not, also generate
+   the critical helpers that `settings.json` references (fixes `--minimal` and `init hooks`).
+3. **executor.js** — Expand `executeUpgrade()` critical helpers list to include `router.cjs`,
+   `session.cjs`, `memory.cjs`.
+4. **helpers-generator.js** — Fix generated `hook-handler.cjs` to `require('router.cjs')`
+   instead of `require('router.js')` (same for session and memory).
+5. **hook-handler.cjs** (source template) — Fix source-shipped copy to use `.cjs` requires.
+6. **executor.js** — Expand `executeUpgrade()` fallback `generatedCritical` to include
+   `router.cjs`, `session.cjs`, `memory.cjs` when source helpers aren't found.
+7. **init.js** — Transition op: update `--dual` components from `skills: false` to `true`.
+
+## Files Patched
+
+- `commands/init.js`
+- `init/executor.js`
+- `init/helpers-generator.js`
+- `<pkg-root>/.claude/helpers/hook-handler.cjs` (source template)
+
+## Dependencies
+
+Depends on IN-001 (170) — SG-003's `old_string` contains code introduced by IN-001.
+
+## Ops
+
+7 ops (11 patch calls) in fix.py
+
+Note: .js copies of .cjs helpers are not needed. All require() paths use .cjs
+exclusively after ops d-i. The former SG-002 compat copy approach was retired.

package/patch/270-SG-003-init-helpers-all-paths/fix.py

@@ -0,0 +1,165 @@
+# SG-003: Init missing helpers for --dual, --minimal, hooks, and upgrade paths
+# GitHub: #1169
+#
+# Root cause:
+# 1. init --dual bypasses executeInit() entirely — no .claude/helpers/ created
+# 2. init --minimal and init hooks set components.helpers=false but settings=true
+#    so settings.json references helpers that don't exist
+# 3. executeUpgrade() only upgrades 3 of 8 helpers (missing router/session/memory)
+# 4. helpers-generator.js generates hook-handler.cjs with require('router.js')
+#    instead of require('router.cjs'), failing with "type":"module"
+#
+# 5 ops: dual path (init.js), settings guard (executor.js),
+#         upgrade helpers (executor.js), generated requires (helpers-generator.js),
+#         source-shipped hook-handler.cjs requires (SRC_HOOK_HANDLER)
+
+# Op 1: init --dual should also generate Claude Code infrastructure
+# After codex init succeeds, call executeInit() for helpers/settings/statusline
+patch("SG-003a: --dual also generates helpers + settings via executeInit",
+    INIT_CMD,
+    """    // If codex mode, use the Codex initializer
+    if (codexMode || dualMode) {
+        return initCodexAction(ctx, { codexMode, dualMode, force, minimal, full });
+    }""",
+    """    // If codex mode, use the Codex initializer
+    if (codexMode || dualMode) {
+        const codexResult = await initCodexAction(ctx, { codexMode, dualMode, force, minimal, full });
+        // SG-003: --dual must also create Claude Code infrastructure (.claude/helpers + settings)
+        if (dualMode) {
+            try {
+                await executeInit({
+                    ...DEFAULT_INIT_OPTIONS,
+                    targetDir: cwd,
+                    force,
+                    components: {
+                        settings: true,
+                        helpers: true,
+                        statusline: true,
+                        skills: true,
+                        commands: true,
+                        agents: true,
+                        mcp: true,
+                        runtime: false,
+                        claudeMd: false,
+                    },
+                });
+            } catch { /* non-fatal — codex init already succeeded */ }
+        }
+        return codexResult;
+    }""")
+
+# Op 2: When settings is generated but helpers component is off, still generate
+# the critical helpers that settings.json references
+patch("SG-003b: generate critical helpers when settings references them",
+    EXECUTOR,
+    """        // Generate helpers
+        if (options.components.helpers) {
+            await writeHelpers(targetDir, options, result);
+        }""",
+    """        // Generate helpers
+        if (options.components.helpers) {
+            await writeHelpers(targetDir, options, result);
+        }
+        // SG-003: If settings will be generated but helpers were skipped,
+        // generate the critical helpers that settings.json hooks reference
+        else if (options.components.settings) {
+            const hDir = path.join(targetDir, '.claude', 'helpers');
+            fs.mkdirSync(hDir, { recursive: true });
+            const criticalForSettings = {
+                'hook-handler.cjs': generateHookHandler(),
+                'auto-memory-hook.mjs': generateAutoMemoryHook(),
+            };
+            for (const [name, content] of Object.entries(criticalForSettings)) {
+                const fp = path.join(hDir, name);
+                if (!fs.existsSync(fp)) {
+                    fs.writeFileSync(fp, content, 'utf-8');
+                    try { fs.chmodSync(fp, '755'); } catch {}
+                    result.created.files.push(`.claude/helpers/${name}`);
+                }
+            }
+        }""")
+
+# Op 3: Expand executeUpgrade() critical helpers to include router/session/memory
+# and add compat-copy sweep after statusline
+patch("SG-003c: upgrade generates all helpers + compat sweep",
+    EXECUTOR,
+    """            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];""",
+    """            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs', 'router.cjs', 'session.cjs', 'memory.cjs'];""")
+
+# Op 4: Fix generated hook-handler.cjs to require .cjs instead of .js
+# This is the fallback generator used when source helpers aren't found
+patch_all("SG-003d: generated hook-handler requires .cjs not .js",
+    HELPERS_GEN,
+    """safeRequire(path.join(helpersDir, 'router.js'))""",
+    """safeRequire(path.join(helpersDir, 'router.cjs'))""")
+
+patch_all("SG-003e: generated hook-handler requires session.cjs",
+    HELPERS_GEN,
+    """safeRequire(path.join(helpersDir, 'session.js'))""",
+    """safeRequire(path.join(helpersDir, 'session.cjs'))""")
+
+patch_all("SG-003f: generated hook-handler requires memory.cjs",
+    HELPERS_GEN,
+    """safeRequire(path.join(helpersDir, 'memory.js'))""",
+    """safeRequire(path.join(helpersDir, 'memory.cjs'))""")
+
+# Op 5: Fix the source-shipped hook-handler.cjs (copied by writeHelpers when source found)
+# This file is at <pkg-root>/.claude/helpers/hook-handler.cjs and gets copied as-is
+patch_all("SG-003g: source hook-handler requires router.cjs",
+    SRC_HOOK_HANDLER,
+    """safeRequire(path.join(helpersDir, 'router.js'))""",
+    """safeRequire(path.join(helpersDir, 'router.cjs'))""")
+
+patch_all("SG-003h: source hook-handler requires session.cjs",
+    SRC_HOOK_HANDLER,
+    """safeRequire(path.join(helpersDir, 'session.js'))""",
+    """safeRequire(path.join(helpersDir, 'session.cjs'))""")
+
+patch_all("SG-003i: source hook-handler requires memory.cjs",
+    SRC_HOOK_HANDLER,
+    """safeRequire(path.join(helpersDir, 'memory.js'))""",
+    """safeRequire(path.join(helpersDir, 'memory.cjs'))""")
+
+# Op 6: Fix executeUpgrade() fallback — generatedCritical missing router/session/memory
+# When source helpers aren't found, only 3 files were generated but hook-handler.cjs needs 6
+# Also replaces generateIntelligenceStub() → intelligenceContent (set by IN-001a above)
+patch("SG-003j: upgrade fallback generates router/session/memory",
+    EXECUTOR,
+    """            const generatedCritical = {
+                'hook-handler.cjs': generateHookHandler(),
+                'intelligence.cjs': generateIntelligenceStub(),
+                'auto-memory-hook.mjs': generateAutoMemoryHook(),
+            };""",
+    """            const generatedCritical = {
+                'hook-handler.cjs': generateHookHandler(),
+                'intelligence.cjs': intelligenceContent,
+                'auto-memory-hook.mjs': generateAutoMemoryHook(),
+                // SG-003: hook-handler.cjs requires these — generate fallback versions
+                'router.cjs': generateAgentRouter(),
+                'session.cjs': generateSessionManager(),
+                'memory.cjs': generateMemoryHelper(),
+            };""")
+
+# Transition: update caches that already have old SG-003a (skills: false) to new (skills: true)
+# On fresh cache SG-003a applies directly; this skips (new already present).
+# On pre-patched cache SG-003a warns (upstream old_string gone); this catches the delta.
+patch("SG-003l: --dual enables skills/commands/agents (transition)",
+    INIT_CMD,
+    """                        skills: false,
+                        commands: false,
+                        agents: false,
+                        mcp: true,
+                        runtime: false,
+                        claudeMd: false,
+                    },
+                });
+            } catch { /* non-fatal — codex init already succeeded */ }""",
+    """                        skills: true,
+                        commands: true,
+                        agents: true,
+                        mcp: true,
+                        runtime: false,
+                        claudeMd: false,
+                    },
+                });
+            } catch { /* non-fatal — codex init already succeeded */ }""")

package/patch/270-SG-003-init-helpers-all-paths/sentinel

@@ -0,0 +1,3 @@
+grep "SG-003" commands/init.js
+grep "SG-003" init/executor.js
+grep "router.cjs" init/helpers-generator.js

package/patch/280-UI-001-intelligence-stats-crash/README.md

@@ -0,0 +1,11 @@
+# UI-001: intelligence stats crashes on .toFixed()
+**Severity**: Critical
+**GitHub**: [#1145](https://github.com/ruvnet/claude-flow/issues/1145)
+## Root Cause
+`hooks intelligence stats` calls `.toFixed()` on potentially undefined properties (learningTimeMs, adaptationTimeMs, avgQuality, routingAccuracy, loadBalance, cacheHitRate, performance.*) without null checks. Crashes when the intelligence system returns incomplete data.
+## Fix
+Add null checks with 'N/A' fallback for all numeric display values. Wrap performance section in an `if (result.performance)` guard.
+## Files Patched
+- commands/hooks.js
+## Ops
+7 ops in fix.py