moflo 4.7.3 → 4.7.6

package/.claude/skills/flo/SKILL.md

@@ -150,7 +150,102 @@ Use Task tool with Explore agent to find:
 
 ## Phase 2: Ticket (-t creates or updates a ticket)
 
-When given an issue number, `-t` enhances the existing ticket. When given a title (non-numeric argument), `-t` creates a new GitHub issue. Either way, the ticket MUST include all three of the following sections:
+When given an issue number, `-t` enhances the existing ticket. When given a title (non-numeric argument), `-t` creates a new GitHub issue. Either way, the ticket MUST include all three of the following sections.
+
+### 2.0 Complexity Assessment (MANDATORY before building ticket)
+
+After research, assess the complexity of the work. This determines whether the issue stays as a single ticket or gets promoted to an epic with sub-issues.
+
+**Complexity Signals — count how many apply:**
+
+| Signal | Weight | Example |
+|--------|--------|---------|
+| Multiple files changed (5+) | +2 | Touches models, API, tests, docs, config |
+| New module or package | +2 | Requires new directory structure |
+| Cross-cutting concern | +2 | Auth, logging, error handling across layers |
+| Database/schema changes | +2 | Migrations, new tables, index changes |
+| Multiple independent work streams | +3 | Frontend + backend + infra changes |
+| External API integration | +1 | Third-party service, webhook, OAuth |
+| Breaking change / migration | +2 | Requires deprecation, data migration |
+| Significant test surface | +1 | Needs 10+ new test cases across categories |
+| Security implications | +1 | Authentication, authorization, input validation |
+| UI + backend changes together | +2 | Full-stack feature spanning layers |
+
+**Complexity Thresholds:**
+
+| Score | Classification | Action |
+|-------|---------------|--------|
+| 0–3 | **Simple** | Single ticket — proceed normally |
+| 4–6 | **Moderate** | Single ticket — flag in description that it may benefit from splitting |
+| 7+ | **Complex** | **PROMOTE TO EPIC** — decompose into sub-issues |
+
+**When promoting to epic:**
+
+1. Decompose the work into 2–6 independent, shippable stories
+2. Each story should be completable in a single PR
+3. Stories should have clear boundaries (one concern per story)
+4. Order stories by dependency (independent ones first)
+5. Create each story as a GitHub issue with its own Description, Acceptance Criteria, and Test Cases
+6. Create or convert the parent issue into an epic with a `## Stories` checklist
+
+```javascript
+// Complexity assessment pseudocode
+function assessComplexity(research) {
+  let score = 0;
+  if (research.affectedFiles.length >= 5) score += 2;
+  if (research.requiresNewModule) score += 2;
+  if (research.crossCutting) score += 2;
+  if (research.schemaChanges) score += 2;
+  if (research.independentWorkStreams >= 2) score += 3;
+  if (research.externalAPIs) score += 1;
+  if (research.breakingChanges) score += 2;
+  if (research.estimatedTestCases >= 10) score += 1;
+  if (research.securityImplications) score += 1;
+  if (research.fullStack) score += 2;
+  return score;
+}
+```
+
+### 2.0.1 Epic Decomposition (when score >= 7)
+
+When complexity warrants an epic, decompose into stories:
+
+```bash
+# Step 1: Create each sub-issue
+gh issue create --title "Story: <story-title>" --body "<## Description + ## Acceptance Criteria + ## Suggested Test Cases>" --label "story"
+# Capture the new issue number from output
+
+# Step 2: Repeat for all stories (2-6 stories typically)
+
+# Step 3: Build the epic body with checklist referencing ALL story issue numbers
+# Step 4: If updating an existing issue, convert it to epic:
+gh issue edit <parent-number> --add-label "epic" --body "<epic body with ## Stories checklist>"
+
+# Step 5: If creating new, create the epic:
+gh issue create --title "Epic: <title>" --label "epic" --body "<epic body>"
+```
+
+**Epic body format (MANDATORY — this is how tracking works):**
+
+```markdown
+## Overview
+<High-level description of the epic goal>
+
+## Stories
+
+- [ ] #<story-1-number> <story-1-title>
+- [ ] #<story-2-number> <story-2-title>
+- [ ] #<story-3-number> <story-3-title>
+
+## Complexity Assessment
+Score: <N>/20 — <Simple|Moderate|Complex>
+Signals: <list of signals that triggered>
+```
+
+The `## Stories` checklist with `- [ ] #<number>` format is **mandatory** — this is what enables:
+- Epic detection by the `/flo` skill
+- Story extraction for sequential processing
+- Progress tracking via checked/unchecked items
 
 ### 2.1 Build Ticket Content
 Compile research into a well-structured ticket. The issue MUST include all three of the following sections:
@@ -279,12 +374,40 @@ An issue is an **epic** if:
 
 1. DETECT EPIC - Check labels, parse body for ## Stories / ## Tasks, extract issue references
 2. LIST ALL STORIES - Extract from checklist, order top-to-bottom as listed
-3. SEQUENTIAL PROCESSING - For each story: run full /flo workflow, wait for PR, update checklist
-4. COMPLETION - All stories have PRs, epic marked as ready-for-review
+3. SEQUENTIAL PROCESSING - For each story:
+   a. Run full /flo workflow (research -> ticket -> implement -> test -> PR)
+   b. After PR is created, **check off the story** in the epic body
+   c. Move to the next unchecked story
+4. COMPLETION - All stories checked off, epic marked as ready-for-review
 
 ONE STORY AT A TIME - NO PARALLEL STORY EXECUTION.
 Each story must complete (PR created) before starting next.
 
+### Epic Checklist Tracking (MANDATORY)
+
+After each story's PR is created, update the epic body to check off that story:
+
+```bash
+# 1. Fetch current epic body
+EPIC_BODY=$(gh issue view <epic-number> --json body -q '.body')
+
+# 2. Replace "- [ ] #<story-number>" with "- [x] #<story-number>"
+UPDATED_BODY=$(echo "$EPIC_BODY" | sed 's/- \[ \] #<story-number>/- [x] #<story-number>/')
+
+# 3. Update the epic
+gh issue edit <epic-number> --body "$UPDATED_BODY"
+
+# 4. Comment on the epic with progress
+gh issue comment <epic-number> --body "✅ Story #<story-number> completed — PR: <pr-url>"
+```
+
+This applies to ALL epics, regardless of how they were created:
+- Epics created by `/flo -t` complexity promotion
+- Epics created manually by users
+- Epics detected from existing issues
+
+The checklist state (`[ ]` vs `[x]`) is the **single source of truth** for epic progress.
+
 ### Epic Detection Code
 
 ```javascript

package/.claude/workflow-state.json

@@ -0,0 +1,9 @@
+{
+  "tasksCreated": false,
+  "taskCount": 0,
+  "memorySearched": false,
+  "memoryRequired": true,
+  "interactionCount": 10,
+  "sessionStart": null,
+  "lastBlockedAt": "2026-03-21T05:00:01.929Z"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.7.3",
+  "version": "4.7.6",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/index.js",
   "type": "module",
@@ -85,6 +85,7 @@
     "@types/bcrypt": "^5.0.2",
     "@types/node": "^20.0.0",
     "eslint": "^8.0.0",
+    "moflo": "^4.7.4",
     "tsx": "^4.21.0",
     "typescript": "^5.0.0",
     "vitest": "^1.0.0"

package/src/@claude-flow/cli/dist/src/commands/agent.js

@@ -229,7 +229,7 @@ const listCommand = {
             }
             // Format for display
             const displayAgents = result.agents.map(agent => ({
-                id: agent.id,
+                id: agent.agentId,
                 type: agent.agentType,
                 status: agent.status,
                 created: new Date(agent.createdAt).toLocaleTimeString(),
@@ -540,7 +540,11 @@ const poolCommand = {
                 `Auto-Scale: ${result.autoScale ? 'Yes' : 'No'}`,
                 `Utilization: ${(utilization * 100).toFixed(1)}%`
             ].join('\n'), 'Agent Pool');
-            const agents = result.agents ?? [];
+            const agents = (result.agents ?? []).map((a) => ({
+                id: a.agentId || a.id,
+                type: a.agentType || a.type,
+                status: a.status,
+            }));
             if (agents.length > 0) {
                 output.writeln();
                 output.writeln(output.bold('Pool Agents'));

package/src/@claude-flow/cli/dist/src/commands/completions.js

@@ -118,7 +118,7 @@ _claude_flow_completions() {
 }
 
 complete -F _claude_flow_completions claude-flow
-complete -F _claude_flow_completions npx\\ @claude-flow/cli@v3alpha
+complete -F _claude_flow_completions npx\\ moflo
 `;
 }
 // Generate zsh completion script

package/src/@claude-flow/cli/dist/src/commands/doctor.js

@@ -297,8 +297,8 @@ async function checkVersionFreshness() {
             (latest.major === current.major && latest.minor === current.minor && latest.patch === current.patch && latest.prerelease > current.prerelease));
         if (isOutdated) {
             const fix = isNpx
-                ? 'rm -rf ~/.npm/_npx/* && npx -y @claude-flow/cli@latest'
-                : 'npm update @claude-flow/cli';
+                ? 'rm -rf ~/.npm/_npx/* && npx -y moflo'
+                : 'npm update moflo';
             return {
                 name: 'Version Freshness',
                 status: 'warn',

package/src/@claude-flow/cli/dist/src/init/claudemd-generator.js

@@ -364,7 +364,7 @@ function setupAndBoundary() {
     return `## Quick Setup
 
 \`\`\`bash
-claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
+claude mcp add claude-flow -- npx -y moflo
 npx moflo daemon start
 npx moflo doctor --fix
 \`\`\`

package/src/@claude-flow/cli/dist/src/init/executor.js

@@ -14,7 +14,7 @@ import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
 import { generateMCPJson } from './mcp-generator.js';
 import { generateStatuslineScript } from './statusline-generator.js';
-import { generatePreCommitHook, generatePostCommitHook, generateAutoMemoryHook, } from './helpers-generator.js';
+import { generatePreCommitHook, generatePostCommitHook, generateAutoMemoryHook, generateGateScript, generateHookHandlerScript, } from './helpers-generator.js';
 import { generateClaudeMd } from './claudemd-generator.js';
 /**
  * Skills to copy based on configuration
@@ -284,14 +284,13 @@ function mergeSettingsForUpgrade(existing) {
     // Their configuration lives in claudeFlow.agentTeams.hooks instead.
     // 3. Fix statusLine config (remove invalid fields, ensure correct format)
     // Claude Code only supports: type, command, padding
+    // Always ensure statusLine is present — add it if missing (e.g. from older inits)
     const existingStatusLine = existing.statusLine;
-    if (existingStatusLine) {
-        merged.statusLine = {
-            type: 'command',
-            command: existingStatusLine.command || `node -e "var c=require('child_process'),p=require('path'),r;try{r=c.execSync('git rev-parse --show-toplevel',{encoding:'utf8'}).trim()}catch(e){r=process.cwd()}var s=p.join(r,'.claude/helpers/statusline.cjs');process.argv.splice(1,0,s);require(s)"`,
-            // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
-        };
-    }
+    merged.statusLine = {
+        type: 'command',
+        command: existingStatusLine?.command || `node "$CLAUDE_PROJECT_DIR/.claude/helpers/statusline.cjs"`,
+        // Remove invalid fields: refreshMs, enabled (not supported by Claude Code)
+    };
     // 4. Merge claudeFlow settings (preserve existing, add agentTeams + memory)
     const existingClaudeFlow = existing.claudeFlow || {};
     const existingMemory = existingClaudeFlow.memory || {};
@@ -356,7 +355,7 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         // 0. ALWAYS update critical helpers (force overwrite)
         const sourceHelpersForUpgrade = findSourceHelpersDir();
         if (sourceHelpersForUpgrade) {
-            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'intelligence.cjs'];
+            const criticalHelpers = ['auto-memory-hook.mjs', 'hook-handler.cjs', 'gate.cjs', 'intelligence.cjs'];
             for (const helperName of criticalHelpers) {
                 const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
                 const sourcePath = path.join(sourceHelpersForUpgrade, helperName);
@@ -379,6 +378,8 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             // Source not found (npx with broken paths) — use generated fallbacks
             const generatedCritical = {
                 'auto-memory-hook.mjs': generateAutoMemoryHook(),
+                'gate.cjs': generateGateScript(),
+                'hook-handler.cjs': generateHookHandlerScript(),
             };
             for (const [helperName, content] of Object.entries(generatedCritical)) {
                 const targetPath = path.join(targetDir, '.claude', 'helpers', helperName);
@@ -494,7 +495,22 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
         else {
             result.preserved.push('.claude-flow/security/audit-status.json');
         }
-        // 3. Merge settings if requested
+        // 3. Fix .mcp.json — replace stale @claude-flow/cli references with moflo
+        const mcpPath = path.join(targetDir, '.mcp.json');
+        if (fs.existsSync(mcpPath)) {
+            try {
+                const mcpRaw = fs.readFileSync(mcpPath, 'utf-8');
+                if (mcpRaw.includes('@claude-flow/cli')) {
+                    const mcpFixed = mcpRaw.replace(/@claude-flow\/cli(@latest)?/g, 'moflo');
+                    fs.writeFileSync(mcpPath, mcpFixed, 'utf-8');
+                    result.updated.push('.mcp.json (replaced @claude-flow/cli with moflo)');
+                }
+            }
+            catch {
+                // Non-fatal — .mcp.json may be malformed
+            }
+        }
+        // 4. Merge settings if requested
         if (upgradeSettings) {
             const settingsPath = path.join(targetDir, '.claude', 'settings.json');
             if (fs.existsSync(settingsPath)) {
@@ -853,7 +869,7 @@ function findSourceHelpersDir(sourceBaseDir) {
     // Strategy 1: require.resolve to find package root (most reliable for npx)
     try {
         const esmRequire = createRequire(import.meta.url);
-        const pkgJsonPath = esmRequire.resolve('@claude-flow/cli/package.json');
+        const pkgJsonPath = esmRequire.resolve('moflo/package.json');
         const pkgRoot = path.dirname(pkgJsonPath);
         possiblePaths.push(path.join(pkgRoot, '.claude', 'helpers'));
     }
@@ -924,13 +940,14 @@ async function writeHelpers(targetDir, options, result) {
         }
     }
     // Fall back to generating helpers if source not available.
-    // Only generate actively used helpers — hooks now go through npx flo CLI,
-    // so hook-handler.cjs, router.js, session.js, memory.js, intelligence.cjs
-    // are no longer needed.
+    // gate.cjs and hook-handler.cjs are required — hooks call them directly
+    // via `node` instead of `npx flo` to avoid CLI bootstrap overhead.
     const helpers = {
         'pre-commit': generatePreCommitHook(),
         'post-commit': generatePostCommitHook(),
         'auto-memory-hook.mjs': generateAutoMemoryHook(),
+        'gate.cjs': generateGateScript(),
+        'hook-handler.cjs': generateHookHandlerScript(),
     };
     for (const [name, content] of Object.entries(helpers)) {
         const filePath = path.join(helpersDir, name);
@@ -1571,7 +1588,7 @@ npx moflo hive-mind consensus --propose "task"
 ### MCP Server Setup
 \`\`\`bash
 # Add Claude Flow MCP
-claude mcp add claude-flow -- npx -y @claude-flow/cli@latest
+claude mcp add claude-flow -- npx -y moflo
 
 # Optional servers
 claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start
@@ -1653,7 +1670,7 @@ function findSourceDir(type, sourceBaseDir) {
     }
     // IMPORTANT: Check the package's own .claude directory first
     // This is the primary path when running as an npm package
-    // __dirname is typically /path/to/node_modules/@claude-flow/cli/dist/src/init
+    // __dirname is typically /path/to/node_modules/moflo/dist/src/init
     // We need to go up 3 levels to reach the package root (dist/src/init -> dist/src -> dist -> root)
     const packageRoot = path.resolve(__dirname, '..', '..', '..');
     const packageDotClaude = path.join(packageRoot, '.claude', type);

package/src/@claude-flow/cli/dist/src/init/helpers-generator.d.ts

@@ -21,4 +21,17 @@ export declare function generateAutoMemoryHook(): string;
  * Generate all helper files
  */
 export declare function generateHelpers(options: InitOptions): Record<string, string>;
+/**
+ * Generate lightweight gate.cjs — workflow gates without CLI bootstrap.
+ * Handles JSON state file read/write for memory-first and TaskCreate gates.
+ * This replaces `npx flo gate <command>` to avoid spawning a full CLI process
+ * on every tool call (~500ms npx overhead → ~20ms direct node).
+ */
+export declare function generateGateScript(): string;
+/**
+ * Generate lightweight hook-handler.cjs — hook dispatch without CLI bootstrap.
+ * Handles routing, edit/task tracking, session lifecycle, and notifications.
+ * This replaces `npx flo hooks <command>` to avoid spawning a full CLI process.
+ */
+export declare function generateHookHandlerScript(): string;
 //# sourceMappingURL=helpers-generator.d.ts.map

package/src/@claude-flow/cli/dist/src/init/helpers-generator.js

@@ -177,12 +177,253 @@ export function generateHelpers(options) {
     if (options.components.helpers) {
         helpers['pre-commit'] = generatePreCommitHook();
         helpers['post-commit'] = generatePostCommitHook();
-        // Hook dispatch now goes through npx flo CLI — no more hook-handler.cjs,
-        // router.js, session.js, memory.js, or intelligence.cjs stubs needed.
+        helpers['gate.cjs'] = generateGateScript();
+        helpers['hook-handler.cjs'] = generateHookHandlerScript();
     }
     if (options.components.statusline) {
         helpers['statusline.cjs'] = generateStatuslineScript(options);
     }
     return helpers;
 }
+/**
+ * Generate lightweight gate.cjs — workflow gates without CLI bootstrap.
+ * Handles JSON state file read/write for memory-first and TaskCreate gates.
+ * This replaces `npx flo gate <command>` to avoid spawning a full CLI process
+ * on every tool call (~500ms npx overhead → ~20ms direct node).
+ */
+export function generateGateScript() {
+    return `#!/usr/bin/env node
+'use strict';
+var fs = require('fs');
+var path = require('path');
+
+var PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
+
+function readState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) return JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8'));
+  } catch (e) { /* reset on corruption */ }
+  return { tasksCreated: false, taskCount: 0, memorySearched: false, memoryRequired: true, interactionCount: 0, sessionStart: null, lastBlockedAt: null };
+}
+
+function writeState(s) {
+  try {
+    var dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(STATE_FILE, JSON.stringify(s, null, 2));
+  } catch (e) { /* non-fatal */ }
+}
+
+// Load moflo.yaml gate config (defaults: all enabled)
+function loadGateConfig() {
+  var defaults = { memory_first: true, task_create_first: true, context_tracking: true };
+  try {
+    var yamlPath = path.join(PROJECT_DIR, 'moflo.yaml');
+    if (fs.existsSync(yamlPath)) {
+      var content = fs.readFileSync(yamlPath, 'utf-8');
+      if (/memory_first:\\s*false/i.test(content)) defaults.memory_first = false;
+      if (/task_create_first:\\s*false/i.test(content)) defaults.task_create_first = false;
+      if (/context_tracking:\\s*false/i.test(content)) defaults.context_tracking = false;
+    }
+  } catch (e) { /* use defaults */ }
+  return defaults;
+}
+
+var config = loadGateConfig();
+var command = process.argv[2];
+
+var EXEMPT = ['.claude/', '.claude\\\\', 'CLAUDE.md', 'MEMORY.md', 'workflow-state', 'node_modules'];
+var DANGEROUS = ['rm -rf /', 'format c:', 'del /s /q c:\\\\', ':(){:|:&};:', 'mkfs.', '> /dev/sda'];
+var DIRECTIVE_RE = /^(yes|no|yeah|yep|nope|sure|ok|okay|correct|right|exactly|perfect)\\b/i;
+var TASK_RE = /\\b(fix|bug|error|implement|add|create|build|write|refactor|debug|test|feature|issue|security|optimi)\\b/i;
+
+switch (command) {
+  case 'check-before-agent': {
+    var s = readState();
+    if (config.task_create_first && !s.tasksCreated) {
+      console.log('BLOCKED: Call TaskCreate before spawning agents.');
+      process.exit(1);
+    }
+    if (config.memory_first && !s.memorySearched) {
+      console.log('BLOCKED: Search memory before spawning agents.');
+      process.exit(1);
+    }
+    break;
+  }
+  case 'check-before-scan': {
+    if (!config.memory_first) break;
+    var s = readState();
+    if (s.memorySearched || !s.memoryRequired) break;
+    var target = (process.env.TOOL_INPUT_pattern || '') + ' ' + (process.env.TOOL_INPUT_path || '');
+    if (EXEMPT.some(function(p) { return target.indexOf(p) >= 0; })) break;
+    var now = Date.now();
+    var last = s.lastBlockedAt ? new Date(s.lastBlockedAt).getTime() : 0;
+    if (now - last > 2000) {
+      s.lastBlockedAt = new Date(now).toISOString();
+      writeState(s);
+      console.log('BLOCKED: Search memory before exploring files.');
+    }
+    process.exit(1);
+  }
+  case 'check-before-read': {
+    if (!config.memory_first) break;
+    var s = readState();
+    if (s.memorySearched || !s.memoryRequired) break;
+    var fp = process.env.TOOL_INPUT_file_path || '';
+    if (fp.indexOf('.claude/guidance/') < 0 && fp.indexOf('.claude\\\\guidance\\\\') < 0) break;
+    var now = Date.now();
+    var last = s.lastBlockedAt ? new Date(s.lastBlockedAt).getTime() : 0;
+    if (now - last > 2000) {
+      s.lastBlockedAt = new Date(now).toISOString();
+      writeState(s);
+      console.log('BLOCKED: Search memory before reading guidance files.');
+    }
+    process.exit(1);
+  }
+  case 'record-task-created': {
+    var s = readState();
+    s.tasksCreated = true;
+    s.taskCount = (s.taskCount || 0) + 1;
+    writeState(s);
+    break;
+  }
+  case 'record-memory-searched': {
+    var s = readState();
+    s.memorySearched = true;
+    writeState(s);
+    break;
+  }
+  case 'check-bash-memory': {
+    var cmd = process.env.TOOL_INPUT_command || '';
+    if (/semantic-search|memory search|memory retrieve|memory-search/.test(cmd)) {
+      var s = readState();
+      s.memorySearched = true;
+      writeState(s);
+    }
+    break;
+  }
+  case 'check-dangerous-command': {
+    var cmd = (process.env.TOOL_INPUT_command || '').toLowerCase();
+    for (var i = 0; i < DANGEROUS.length; i++) {
+      if (cmd.indexOf(DANGEROUS[i]) >= 0) {
+        console.log('[BLOCKED] Dangerous command: ' + DANGEROUS[i]);
+        process.exit(2);
+      }
+    }
+    break;
+  }
+  case 'prompt-reminder': {
+    var s = readState();
+    s.memorySearched = false;
+    var prompt = process.env.CLAUDE_USER_PROMPT || '';
+    s.memoryRequired = prompt.length >= 4 && !DIRECTIVE_RE.test(prompt) && (TASK_RE.test(prompt) || prompt.length > 80);
+    s.interactionCount = (s.interactionCount || 0) + 1;
+    writeState(s);
+    if (!s.tasksCreated) console.log('REMINDER: Use TaskCreate before spawning agents. Task tool is blocked until then.');
+    if (config.context_tracking) {
+      var ic = s.interactionCount;
+      if (ic > 30) console.log('Context: CRITICAL. Commit, store learnings, suggest new session.');
+      else if (ic > 20) console.log('Context: DEPLETED. Checkpoint progress. Recommend /compact or fresh session.');
+      else if (ic > 10) console.log('Context: MODERATE. Re-state goal before architectural decisions.');
+    }
+    break;
+  }
+  case 'compact-guidance': {
+    console.log('Pre-Compact: Check CLAUDE.md for rules. Use memory search to recover context after compact.');
+    break;
+  }
+  case 'session-reset': {
+    writeState({ tasksCreated: false, taskCount: 0, memorySearched: false, memoryRequired: true, interactionCount: 0, sessionStart: new Date().toISOString(), lastBlockedAt: null });
+    break;
+  }
+  default:
+    break;
+}
+`;
+}
+/**
+ * Generate lightweight hook-handler.cjs — hook dispatch without CLI bootstrap.
+ * Handles routing, edit/task tracking, session lifecycle, and notifications.
+ * This replaces `npx flo hooks <command>` to avoid spawning a full CLI process.
+ */
+export function generateHookHandlerScript() {
+    return `#!/usr/bin/env node
+'use strict';
+var fs = require('fs');
+var path = require('path');
+
+var PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+var METRICS_FILE = path.join(PROJECT_DIR, '.claude-flow', 'metrics', 'learning.json');
+var command = process.argv[2];
+
+// Read stdin (Claude Code sends hook data as JSON)
+function readStdin() {
+  if (process.stdin.isTTY) return Promise.resolve('');
+  return new Promise(function(resolve) {
+    var data = '';
+    var timer = setTimeout(function() {
+      process.stdin.removeAllListeners();
+      process.stdin.pause();
+      resolve(data);
+    }, 500);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', function(chunk) { data += chunk; });
+    process.stdin.on('end', function() { clearTimeout(timer); resolve(data); });
+    process.stdin.on('error', function() { clearTimeout(timer); resolve(data); });
+    process.stdin.resume();
+  });
+}
+
+function bumpMetric(key) {
+  try {
+    var metrics = {};
+    if (fs.existsSync(METRICS_FILE)) metrics = JSON.parse(fs.readFileSync(METRICS_FILE, 'utf-8'));
+    metrics[key] = (metrics[key] || 0) + 1;
+    metrics.lastUpdated = new Date().toISOString();
+    var dir = path.dirname(METRICS_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(METRICS_FILE, JSON.stringify(metrics, null, 2));
+  } catch (e) { /* non-fatal */ }
+}
+
+readStdin().then(function(stdinData) {
+  var hookInput = {};
+  if (stdinData && stdinData.trim()) {
+    try { hookInput = JSON.parse(stdinData); } catch (e) { /* ignore */ }
+  }
+
+  switch (command) {
+    case 'route': {
+      var prompt = hookInput.prompt || hookInput.command || process.env.PROMPT || '';
+      if (prompt) console.log('[INFO] Routing: ' + prompt.substring(0, 80));
+      else console.log('[INFO] Ready');
+      break;
+    }
+    case 'pre-edit':
+    case 'post-edit':
+      bumpMetric('edits');
+      console.log('[OK] Edit recorded');
+      break;
+    case 'pre-task':
+      bumpMetric('tasks');
+      console.log('[OK] Task started');
+      break;
+    case 'post-task':
+      bumpMetric('tasksCompleted');
+      console.log('[OK] Task completed');
+      break;
+    case 'session-end':
+      console.log('[OK] Session ended');
+      break;
+    case 'notification':
+      // Silent — just acknowledge
+      break;
+    default:
+      if (command) console.log('[OK] Hook: ' + command);
+      break;
+  }
+});
+`;
+}
 //# sourceMappingURL=helpers-generator.js.map

package/src/@claude-flow/cli/dist/src/init/mcp-generator.js

@@ -34,7 +34,7 @@ export function generateMCPConfig(options) {
     const deferProps = config.toolDefer ? { toolDefer: 'deferred' } : {};
     // Claude Flow MCP server (core)
     if (config.claudeFlow) {
-        mcpServers['claude-flow'] = createMCPServerEntry(['@claude-flow/cli@latest', 'mcp', 'start'], {
+        mcpServers['claude-flow'] = createMCPServerEntry(['moflo', 'mcp', 'start'], {
             ...npmEnv,
             CLAUDE_FLOW_MODE: 'v3',
             CLAUDE_FLOW_HOOKS_ENABLED: 'true',
@@ -67,7 +67,7 @@ export function generateMCPCommands(options) {
     const commands = [];
     const config = options.mcp;
     if (config.claudeFlow) {
-        commands.push('claude mcp add claude-flow -- npx -y @claude-flow/cli@latest mcp start');
+        commands.push('claude mcp add claude-flow -- npx -y moflo mcp start');
     }
     if (config.ruvSwarm) {
         commands.push('claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start');