moflo 4.8.9 → 4.8.11

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

@@ -178,6 +178,8 @@ export function generateHelpers(options) {
         helpers['pre-commit'] = generatePreCommitHook();
         helpers['post-commit'] = generatePostCommitHook();
         helpers['gate.cjs'] = generateGateScript();
+        helpers['gate-hook.mjs'] = generateGateHookScript();
+        helpers['prompt-hook.mjs'] = generatePromptHookScript();
         helpers['hook-handler.cjs'] = generateHookHandlerScript();
     }
     if (options.components.statusline) {
@@ -197,7 +199,7 @@ export function generateGateScript() {
 var fs = require('fs');
 var path = require('path');
 
-var PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+var PROJECT_DIR = (process.env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\\/([a-z])\\//i, '$1:/');
 var STATE_FILE = path.join(PROJECT_DIR, '.claude', 'workflow-state.json');
 
 function readState() {
@@ -241,13 +243,15 @@ var TASK_RE = /\\b(fix|bug|error|implement|add|create|build|write|refactor|debug
 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);
+    // Hard gate: memory must be searched
+    if (config.memory_first && s.memoryRequired && !s.memorySearched) {
+      process.stderr.write('BLOCKED: Search memory (mcp__moflo__memory_search) before spawning agents.\\n');
+      process.exit(2);
     }
-    if (config.memory_first && !s.memorySearched) {
-      console.log('BLOCKED: Search memory before spawning agents.');
-      process.exit(1);
+    // Soft gate: TaskCreate recommended but not blocking
+    // (TaskCreate PostToolUse doesn't fire in Claude Code, so we can't track it reliably)
+    if (config.task_create_first && !s.tasksCreated) {
+      process.stdout.write('REMINDER: Use TaskCreate before spawning agents. Task tool is blocked until then.\\n');
     }
     break;
   }
@@ -257,14 +261,8 @@ switch (command) {
     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);
+    process.stderr.write('BLOCKED: Search memory before exploring files. Use mcp__moflo__memory_search.\\n');
+    process.exit(2);
   }
   case 'check-before-read': {
     if (!config.memory_first) break;
@@ -272,14 +270,8 @@ switch (command) {
     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);
+    process.stderr.write('BLOCKED: Search memory before reading guidance files. Use mcp__moflo__memory_search.\\n');
+    process.exit(2);
   }
   case 'record-task-created': {
     var s = readState();
@@ -325,7 +317,7 @@ switch (command) {
       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.');
+      else if (ic > 10) console.log('Context: MODERATE. Re-state goal before architectural decisions. Use agents for >300 LOC.');
     }
     break;
   }
@@ -342,6 +334,146 @@ switch (command) {
 }
 `;
 }
+/**
+ * Generate gate-hook.mjs — ESM wrapper that reads Claude Code stdin JSON
+ * and passes tool_name + tool_input to gate.cjs via environment variables.
+ *
+ * Claude Code hooks receive context as JSON on stdin but don't set env vars
+ * for tool input. This script bridges that gap. It also translates exit code 1
+ * from gate.cjs into exit code 2 (which Claude Code requires to block tools).
+ */
+export function generateGateHookScript() {
+    return `#!/usr/bin/env node
+import { execSync } from 'child_process';
+import { resolve } from 'path';
+
+var command = process.argv[2];
+if (!command) process.exit(0);
+
+// Read stdin JSON from Claude Code
+var stdinData = '';
+try {
+  stdinData = await new Promise(function(res) {
+    var data = '';
+    var timeout = setTimeout(function() { res(data); }, 500);
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', function(chunk) { data += chunk; });
+    process.stdin.on('end', function() { clearTimeout(timeout); res(data); });
+    process.stdin.on('error', function() { clearTimeout(timeout); res(''); });
+    if (process.stdin.isTTY) { clearTimeout(timeout); res(''); }
+  });
+} catch (e) { /* no stdin */ }
+
+var hookContext = {};
+try { if (stdinData.trim()) hookContext = JSON.parse(stdinData); } catch (e) {}
+
+// Pass tool info as env vars for gate.cjs
+var env = Object.assign({}, process.env);
+if (hookContext.tool_name) env.TOOL_NAME = hookContext.tool_name;
+if (hookContext.tool_input && typeof hookContext.tool_input === 'object') {
+  Object.keys(hookContext.tool_input).forEach(function(key) {
+    if (typeof hookContext.tool_input[key] === 'string') {
+      env['TOOL_INPUT_' + key] = hookContext.tool_input[key];
+    }
+  });
+}
+
+// Run gate.cjs with the enriched environment
+var projectDir = (env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\\/([a-z])\\//i, '$1:/');
+var gateScript = resolve(projectDir, '.claude/helpers/gate.cjs');
+try {
+  var output = execSync('node "' + gateScript + '" ' + command, {
+    env: env, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
+  });
+  if (output.trim()) process.stdout.write(output);
+  process.exit(0);
+} catch (err) {
+  // gate.cjs exit(2) = block, exit(1) = also block attempt — translate both to exit(2)
+  if (err.stderr) process.stderr.write(err.stderr);
+  if (err.stdout) process.stderr.write(err.stdout);
+  process.exit(err.status === 2 || err.status === 1 ? 2 : 0);
+}
+`;
+}
+/**
+ * Generate prompt-hook.mjs — reads user prompt from Claude Code stdin JSON,
+ * runs prompt classification via gate.cjs, and appends namespace hints.
+ */
+export function generatePromptHookScript() {
+    return `#!/usr/bin/env node
+import { execSync } from 'child_process';
+import { resolve } from 'path';
+
+// Read stdin JSON from Claude Code
+var stdinData = '';
+try {
+  stdinData = await new Promise(function(res) {
+    var data = '';
+    var timeout = setTimeout(function() { res(data); }, 500);
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', function(chunk) { data += chunk; });
+    process.stdin.on('end', function() { clearTimeout(timeout); res(data); });
+    process.stdin.on('error', function() { clearTimeout(timeout); res(''); });
+    if (process.stdin.isTTY) { clearTimeout(timeout); res(''); }
+  });
+} catch (e) { /* no stdin */ }
+
+var hookContext = {};
+try { if (stdinData.trim()) hookContext = JSON.parse(stdinData); } catch (e) {}
+
+var userPrompt = hookContext.user_prompt || hookContext.prompt || '';
+var env = Object.assign({}, process.env, { CLAUDE_USER_PROMPT: userPrompt });
+
+// Run prompt-reminder via gate.cjs
+var projectDir = (env.CLAUDE_PROJECT_DIR || process.cwd()).replace(/^\\/([a-z])\\//i, '$1:/');
+var gateScript = resolve(projectDir, '.claude/helpers/gate.cjs');
+var output = '';
+try {
+  output = execSync('node "' + gateScript + '" prompt-reminder', {
+    env: env, encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+  });
+} catch (err) { output = (err && err.stdout) || ''; }
+
+// Classify prompt for namespace hint
+var lower = userPrompt.toLowerCase();
+
+var KNOWLEDGE_ONLY = /\\b(knowledge|remember|recall)\\b|we (decid|agree|chose|said)/;
+var EXPLICIT_NS = [
+  { pattern: /\\b(pattern|convention|best practice|style|coding rule)\\b/, ns: 'patterns', label: 'code patterns and conventions' },
+  { pattern: /\\b(code.?map|file structure|project structure|directory)\\b/, ns: 'code-map', label: 'codebase navigation' },
+];
+var PATTERN_HINTS = [/\\b(template|example|similar to|how do we|how should)\\b/];
+var DOMAIN_HINTS = [
+  /\\b(guidance|guide|docs|documentation|rules|how-to)\\b/,
+  /\\b(architecture|design|domain|tenant|migrat|schema|deploy)/,
+  /\\b(rule|requirement|constraint|compliance)\\b/,
+];
+var NAV_PATTERNS = [
+  /\\b(find|where|which file|look up|locate|endpoint|route|url|path)\\b/,
+  /\\b(class|function|method|component|service|entity|module)\\b/,
+];
+
+var nsHint = '';
+if (KNOWLEDGE_ONLY.test(lower)) {
+  nsHint = 'Memory namespace hint: use "knowledge" for user-directed project decisions.';
+} else {
+  var found = EXPLICIT_NS.find(function(e) { return e.pattern.test(lower); });
+  if (found) {
+    nsHint = 'Memory namespace hint: use "' + found.ns + '" for ' + found.label + '.';
+  } else if (DOMAIN_HINTS.some(function(p) { return p.test(lower); })) {
+    nsHint = 'Memory namespace hint: search "guidance" and "knowledge" for domain rules and project decisions.';
+  } else if (PATTERN_HINTS.some(function(p) { return p.test(lower); })) {
+    nsHint = 'Memory namespace hint: use "patterns" for code patterns and conventions.';
+  } else if (NAV_PATTERNS.some(function(p) { return p.test(lower); })) {
+    nsHint = 'Memory namespace hint: use "code-map" for codebase navigation.';
+  }
+}
+
+var parts = [output.trim(), nsHint].filter(Boolean);
+if (parts.length) process.stdout.write(parts.join('\\n') + '\\n');
+process.exit(0);
+`;
+}
 /**
  * Generate lightweight hook-handler.cjs — hook dispatch without CLI bootstrap.
  * Handles routing, edit/task tracking, session lifecycle, and notifications.

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

@@ -8,28 +8,25 @@
  */
 import { existsSync } from 'fs';
 import { join } from 'path';
+const isWindows = process.platform === 'win32';
 /**
- * Generate MCP server entry using npx (for external packages)
+ * Generate MCP server entry using npx (for external packages).
+ * On Windows, wraps with `cmd /c` so Claude Code can spawn the process.
  */
 function createNpxServerEntry(npxArgs, env, additionalProps = {}) {
-    return {
-        command: 'npx',
-        args: ['-y', ...npxArgs],
-        env,
-        ...additionalProps,
-    };
+    return isWindows
+        ? { command: 'cmd', args: ['/c', 'npx', '-y', ...npxArgs], env, ...additionalProps }
+        : { command: 'npx', args: ['-y', ...npxArgs], env, ...additionalProps };
 }
 /**
  * Generate MCP server entry using direct node invocation (for local moflo).
  * Avoids npx overhead — faster startup, fewer intermediate processes.
+ * On Windows, wraps with `cmd /c` so Claude Code can spawn the process.
  */
 function createDirectServerEntry(cliPath, cliArgs, env, additionalProps = {}) {
-    return {
-        command: 'node',
-        args: [cliPath, ...cliArgs],
-        env,
-        ...additionalProps,
-    };
+    return isWindows
+        ? { command: 'cmd', args: ['/c', 'node', cliPath, ...cliArgs], env, ...additionalProps }
+        : { command: 'node', args: [cliPath, ...cliArgs], env, ...additionalProps };
 }
 /**
  * Find the moflo CLI entry point relative to the project root.
@@ -73,10 +70,10 @@ export function generateMCPConfig(options) {
         const projectRoot = options.targetDir ?? process.cwd();
         const localCli = findMofloCli(projectRoot);
         if (localCli) {
-            mcpServers['claude-flow'] = createDirectServerEntry(localCli, ['mcp', 'start'], mcpEnv, { autoStart: config.autoStart, ...deferProps });
+            mcpServers['moflo'] = createDirectServerEntry(localCli, ['mcp', 'start'], mcpEnv, { autoStart: config.autoStart, ...deferProps });
         }
         else {
-            mcpServers['claude-flow'] = createNpxServerEntry(['moflo', 'mcp', 'start'], mcpEnv, { autoStart: config.autoStart, ...deferProps });
+            mcpServers['moflo'] = createNpxServerEntry(['moflo', 'mcp', 'start'], mcpEnv, { autoStart: config.autoStart, ...deferProps });
         }
     }
     // Ruv-Swarm MCP server (enhanced coordination) — always npx (external package)
@@ -102,21 +99,22 @@ export function generateMCPJson(options) {
 export function generateMCPCommands(options) {
     const commands = [];
     const config = options.mcp;
+    const cmdPrefix = isWindows ? 'cmd /c ' : '';
     if (config.claudeFlow) {
         const projectRoot = options.targetDir ?? process.cwd();
         const localCli = findMofloCli(projectRoot);
         if (localCli) {
-            commands.push(`claude mcp add claude-flow -- node ${localCli} mcp start`);
+            commands.push(`claude mcp add moflo -- ${cmdPrefix}node ${localCli} mcp start`);
         }
         else {
-            commands.push('claude mcp add claude-flow -- npx -y moflo mcp start');
+            commands.push(`claude mcp add moflo -- ${cmdPrefix}npx -y moflo mcp start`);
         }
     }
     if (config.ruvSwarm) {
-        commands.push('claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start');
+        commands.push(`claude mcp add ruv-swarm -- ${cmdPrefix}npx -y ruv-swarm mcp start`);
     }
     if (config.flowNexus) {
-        commands.push('claude mcp add flow-nexus -- npx -y flow-nexus@latest mcp start');
+        commands.push(`claude mcp add flow-nexus -- ${cmdPrefix}npx -y flow-nexus@latest mcp start`);
     }
     return commands;
 }
@@ -129,7 +127,9 @@ export function getPlatformInstructions() {
         : process.platform === 'darwin' ? 'macOS' : 'Linux';
     return {
         platform,
-        note: 'MCP configuration uses npx directly.',
+        note: isWindows
+            ? 'MCP configuration uses cmd /c wrapper for Windows compatibility.'
+            : 'MCP configuration uses npx directly.',
     };
 }
 //# sourceMappingURL=mcp-generator.js.map

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

@@ -10,6 +10,8 @@ export interface MofloInitAnswers {
     guidanceDirs: string[];
     codeMap: boolean;
     srcDirs: string[];
+    tests: boolean;
+    testDirs: string[];
     gates: boolean;
     stopHook: boolean;
 }
@@ -20,5 +22,10 @@ export interface MofloInitResult {
         detail?: string;
     }[];
 }
+/**
+ * Discover test directories by checking common locations and walking for
+ * colocated __tests__ dirs. Returns relative paths.
+ */
+export declare function discoverTestDirs(root: string): string[];
 export declare function initMoflo(options: MofloInitOptions): Promise<MofloInitResult>;
 //# sourceMappingURL=moflo-init.d.ts.map

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

@@ -53,6 +53,37 @@ function discoverGuidanceDirs(root) {
     walk('', 0);
     return found;
 }
+/**
+ * Discover test directories by checking common locations and walking for
+ * colocated __tests__ dirs. Returns relative paths.
+ */
+export function discoverTestDirs(root) {
+    const TOP_LEVEL = ['tests', 'test', '__tests__', 'spec', 'e2e'];
+    const found = TOP_LEVEL.filter(d => fs.existsSync(path.join(root, d)));
+    // Walk up to 3 levels deep looking for __tests__ dirs inside src
+    const SKIP = new Set(['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.reports', '.swarm', '.claude-flow']);
+    function walk(dir, depth) {
+        if (depth > 3)
+            return;
+        try {
+            const entries = fs.readdirSync(path.join(root, dir), { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory() || SKIP.has(entry.name))
+                    continue;
+                const rel = dir ? `${dir}/${entry.name}` : entry.name;
+                if (entry.name === '__tests__') {
+                    found.push(rel);
+                }
+                else {
+                    walk(rel, depth + 1);
+                }
+            }
+        }
+        catch { /* skip unreadable directories */ }
+    }
+    walk('', 0);
+    return found;
+}
 /**
  * Discover source directories by walking the project tree.
  * Finds directories named 'src' (or top-level 'packages', 'lib', etc.)
@@ -140,6 +171,22 @@ async function runWizard(root) {
         });
         srcDirs = answer.split(',').map((d) => d.trim()).filter(Boolean);
     }
+    // Detect test directories
+    const detectedTests = discoverTestDirs(root);
+    const tests = await confirm({
+        message: detectedTests.length > 0
+            ? `Found tests in ${detectedTests.join(', ')}. Enable test file indexing?`
+            : 'Enable test file indexing?',
+        default: true,
+    });
+    let testDirs = detectedTests.length > 0 ? detectedTests : ['tests'];
+    if (tests) {
+        const answer = await input({
+            message: 'Test directories (comma-separated):',
+            default: testDirs.join(', '),
+        });
+        testDirs = answer.split(',').map((d) => d.trim()).filter(Boolean);
+    }
     const gates = await confirm({
         message: 'Enable workflow gates (memory-first, task-create-before-agents)?',
         default: true,
@@ -148,7 +195,7 @@ async function runWizard(root) {
         message: 'Enable session-end hook (saves session state)?',
         default: true,
     });
-    return { guidance, guidanceDirs, codeMap, srcDirs, gates, stopHook };
+    return { guidance, guidanceDirs, codeMap, srcDirs, tests, testDirs, gates, stopHook };
 }
 /**
  * Get default answers (--yes mode).
@@ -160,13 +207,16 @@ function defaultAnswers(root) {
     const srcDirs = discoverSrcDirs(root);
     if (srcDirs.length === 0)
         srcDirs.push('src');
-    return { guidance: true, guidanceDirs, codeMap: true, srcDirs, gates: true, stopHook: true };
+    const testDirs = discoverTestDirs(root);
+    if (testDirs.length === 0)
+        testDirs.push('tests');
+    return { guidance: true, guidanceDirs, codeMap: true, srcDirs, tests: true, testDirs, gates: true, stopHook: true };
 }
 /**
  * Get minimal answers (--minimal mode).
  */
 function minimalAnswers() {
-    return { guidance: false, guidanceDirs: [], codeMap: false, srcDirs: [], gates: false, stopHook: false };
+    return { guidance: false, guidanceDirs: [], codeMap: false, srcDirs: [], tests: false, testDirs: [], gates: false, stopHook: false };
 }
 export async function initMoflo(options) {
     const { projectRoot, force, interactive, minimal } = options;
@@ -204,6 +254,7 @@ function generateConfig(root, force, answers) {
     const projectName = path.basename(root);
     const guidanceDirs = answers?.guidanceDirs ?? ['.claude/guidance'];
     const srcDirs = answers?.srcDirs ?? ['src'];
+    const testDirs = answers?.testDirs ?? ['tests'];
     const gatesEnabled = answers?.gates ?? true;
     // Detect languages
     const extensions = new Set();
@@ -240,6 +291,15 @@ ${srcDirs.map(d => `    - ${d}`).join('\n')}
   exclude: [node_modules, dist, .next, coverage, build, __pycache__, target, .git]
   namespace: code-map
 
+# Test file discovery and indexing
+tests:
+  directories:
+${testDirs.map(d => `    - ${d}`).join('\n')}
+  patterns: ["*.test.*", "*.spec.*", "*.test-*"]
+  extensions: [".ts", ".tsx", ".js", ".jsx"]
+  exclude: [node_modules, coverage, dist]
+  namespace: tests
+
 # Workflow gates (enforced via Claude Code hooks)
 gates:
   memory_first: ${gatesEnabled}
@@ -250,6 +310,7 @@ gates:
 auto_index:
   guidance: ${answers?.guidance ?? true}
   code_map: ${answers?.codeMap ?? true}
+  tests: ${answers?.tests ?? true}
 
 # Memory backend
 memory:
@@ -432,7 +493,7 @@ function generateHooks(root, force, answers) {
                     }]
             },
             {
-                "matcher": "^mcp__claude-flow__memory_(search|retrieve)$",
+                "matcher": "^mcp__moflo__memory_(search|retrieve)$",
                 "hooks": [{
                         "type": "command",
                         "command": "npx flo gate record-memory-searched",
@@ -590,7 +651,7 @@ This project uses [MoFlo](https://github.com/eric-cielo/moflo) for AI-assisted d
 Your first tool call for every new user prompt MUST be a memory search. Do this BEFORE Glob, Grep, Read, or any file exploration.
 
 \`\`\`
-mcp__claude-flow__memory_search  — query: "<task description>", namespace: "guidance" or "patterns" or "knowledge" or "code-map"
+mcp__moflo__memory_search  — query: "<task description>", namespace: "guidance" or "patterns" or "knowledge" or "code-map"
 \`\`\`
 
 For codebase navigation, search the \`code-map\` namespace first. For patterns and domain knowledge, search \`patterns\`, \`knowledge\`, and \`guidance\`.
@@ -612,11 +673,11 @@ Research → Enhance → Implement → Test → Simplify → PR
 
 | Tool | Purpose |
 |------|---------|
-| \`mcp__claude-flow__memory_search\` | Semantic search across indexed knowledge |
-| \`mcp__claude-flow__memory_store\` | Store patterns and decisions |
-| \`mcp__claude-flow__hooks_route\` | Route task to optimal agent type |
-| \`mcp__claude-flow__hooks_pre-task\` | Record task start |
-| \`mcp__claude-flow__hooks_post-task\` | Record task completion for learning |
+| \`mcp__moflo__memory_search\` | Semantic search across indexed knowledge |
+| \`mcp__moflo__memory_store\` | Store patterns and decisions |
+| \`mcp__moflo__hooks_route\` | Route task to optimal agent type |
+| \`mcp__moflo__hooks_pre-task\` | Record task start |
+| \`mcp__moflo__hooks_post-task\` | Record task completion for learning |
 
 ### Agent Icon Mapping
 
@@ -659,6 +720,7 @@ const SCRIPT_MAP = {
     'build-embeddings.mjs': 'build-embeddings.mjs',
     'generate-code-map.mjs': 'generate-code-map.mjs',
     'semantic-search.mjs': 'semantic-search.mjs',
+    'index-tests.mjs': 'index-tests.mjs',
 };
 function syncScripts(root, force) {
     const scriptsDir = path.join(root, '.claude', 'scripts');

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

@@ -22,7 +22,7 @@ export function generateSettings(options) {
             'Bash(npx moflo*)',
             'Bash(npx flo*)',
             'Bash(node .claude/*)',
-            'mcp__claude-flow__:*',
+            'mcp__moflo__:*',
         ],
         deny: [
             'Read(./.env)',
@@ -176,6 +176,14 @@ function autoMemoryCmd(subcommand) {
 function gateCmd(subcommand) {
     return hookCmd('"$CLAUDE_PROJECT_DIR/.claude/helpers/gate.cjs"', subcommand);
 }
+/** Gate hook wrapper — reads stdin JSON for tool input, uses exit code 2 for blocking */
+function gateHookCmd(subcommand) {
+    return hookCmdEsm('"$CLAUDE_PROJECT_DIR/.claude/helpers/gate-hook.mjs"', subcommand);
+}
+/** Prompt hook — reads stdin JSON for user prompt, classifies namespace */
+function promptHookCmd() {
+    return `node "$CLAUDE_PROJECT_DIR/.claude/helpers/prompt-hook.mjs"`;
+}
 /**
  * Generate statusLine configuration for Claude Code
  * Uses local helper script for cross-platform compatibility (no npx cold-start)
@@ -194,7 +202,7 @@ function generateStatusLineConfig(_options) {
 /**
  * Generate hooks configuration
  * All hooks use direct node invocation via lightweight helper scripts
- * (gate.cjs, hook-handler.cjs) instead of `npx flo` to avoid spawning
+ * (gate.cjs, gate-hook.mjs, hook-handler.cjs) instead of `npx flo` to avoid spawning
  * a full CLI process on every tool call.
  */
 function generateHooksConfig(config) {
@@ -208,22 +216,21 @@ function generateHooksConfig(config) {
             },
             {
                 matcher: '^(Glob|Grep)$',
-                hooks: [{ type: 'command', command: gateCmd('check-before-scan'), timeout: 3000 }],
+                hooks: [{ type: 'command', command: gateHookCmd('check-before-scan'), timeout: 3000 }],
             },
             {
                 matcher: '^Read$',
-                hooks: [{ type: 'command', command: gateCmd('check-before-read'), timeout: 3000 }],
+                hooks: [{ type: 'command', command: gateHookCmd('check-before-read'), timeout: 3000 }],
             },
             {
-                matcher: '^Task$',
+                matcher: '^Agent$',
                 hooks: [
-                    { type: 'command', command: gateCmd('check-before-agent'), timeout: 3000 },
-                    { type: 'command', command: hookHandlerCmd('pre-task'), timeout: 5000 },
+                    { type: 'command', command: gateHookCmd('check-before-agent'), timeout: 3000 },
                 ],
             },
             {
                 matcher: '^Bash$',
-                hooks: [{ type: 'command', command: gateCmd('check-dangerous-command'), timeout: 2000 }],
+                hooks: [{ type: 'command', command: gateHookCmd('check-dangerous-command'), timeout: 2000 }],
             },
         ];
     }
@@ -235,20 +242,23 @@ function generateHooksConfig(config) {
                 hooks: [{ type: 'command', command: hookHandlerCmd('post-edit'), timeout: 5000 }],
             },
             {
-                matcher: '^Task$',
+                matcher: '^Agent$',
                 hooks: [{ type: 'command', command: hookHandlerCmd('post-task'), timeout: 5000 }],
             },
             {
+                // TaskCreate PostToolUse only fires in some Claude Code versions.
+                // The prompt-reminder and soft gate in check-before-agent handle the common case.
                 matcher: '^TaskCreate$',
                 hooks: [{ type: 'command', command: gateCmd('record-task-created'), timeout: 2000 }],
             },
             {
                 matcher: '^Bash$',
-                hooks: [{ type: 'command', command: gateCmd('check-bash-memory'), timeout: 2000 }],
+                hooks: [{ type: 'command', command: gateHookCmd('check-bash-memory'), timeout: 2000 }],
             },
             {
-                matcher: '^mcp__claude-flow__memory_(search|retrieve)$',
-                hooks: [{ type: 'command', command: gateCmd('record-memory-searched'), timeout: 2000 }],
+                // Simplified matcher — anchored regex with parens doesn't match MCP tool names reliably
+                matcher: 'mcp__moflo__memory_',
+                hooks: [{ type: 'command', command: gateCmd('record-memory-searched'), timeout: 3000 }],
             },
         ];
     }
@@ -257,8 +267,7 @@ function generateHooksConfig(config) {
         hooks.UserPromptSubmit = [
             {
                 hooks: [
-                    { type: 'command', command: gateCmd('prompt-reminder'), timeout: 2000 },
-                    { type: 'command', command: hookHandlerCmd('route'), timeout: 5000 },
+                    { type: 'command', command: promptHookCmd(), timeout: 3000 },
                 ],
             },
         ];

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

@@ -274,7 +274,7 @@ export class MCPServerManager extends EventEmitter {
             method: 'server.initialized',
             params: {
                 serverInfo: {
-                    name: 'claude-flow',
+                    name: 'moflo',
                     version: VERSION,
                     capabilities: {
                         tools: { listChanged: true },
@@ -388,7 +388,7 @@ export class MCPServerManager extends EventEmitter {
                         id: message.id,
                         result: {
                             protocolVersion: '2024-11-05',
-                            serverInfo: { name: 'claude-flow', version: '3.0.0' },
+                            serverInfo: { name: 'moflo', version: '3.0.0' },
                             capabilities: {
                                 tools: { listChanged: true },
                                 resources: { subscribe: true, listChanged: true },
@@ -480,7 +480,7 @@ export class MCPServerManager extends EventEmitter {
             error: (msg, data) => this.emit('log', { level: 'error', msg, data }),
         };
         const mcpServer = createMCPServer({
-            name: 'Claude-Flow MCP Server V3',
+            name: 'MoFlo MCP Server V3',
             version: '3.0.0',
             transport: this.options.transport,
             host: this.options.host,

package/src/@claude-flow/cli/dist/src/plugins/manager.js

@@ -114,10 +114,11 @@ export class PluginManager {
             if (fs.existsSync(packageJsonPath)) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 installedVersion = pkg.version;
-                // Check for claude-flow plugin metadata
-                if (pkg['claude-flow']) {
-                    commands = pkg['claude-flow'].commands || [];
-                    hooks = pkg['claude-flow'].hooks || [];
+                // Check for moflo/claude-flow plugin metadata (backward compat)
+                const pluginMeta = pkg['moflo'] || pkg['claude-flow'];
+                if (pluginMeta) {
+                    commands = pluginMeta.commands || [];
+                    hooks = pluginMeta.hooks || [];
                 }
             }
             // Create plugin entry
@@ -177,8 +178,8 @@ export class PluginManager {
                 enabled: true,
                 source: 'local',
                 path: absolutePath,
-                commands: pkg['claude-flow']?.commands || [],
-                hooks: pkg['claude-flow']?.hooks || [],
+                commands: (pkg['moflo'] || pkg['claude-flow'])?.commands || [],
+                hooks: (pkg['moflo'] || pkg['claude-flow'])?.hooks || [],
             };
             // Save to manifest
             this.manifest.plugins[packageName] = plugin;
@@ -338,8 +339,8 @@ export class PluginManager {
             if (fs.existsSync(packageJsonPath)) {
                 const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
                 existing.version = pkg.version;
-                existing.commands = pkg['claude-flow']?.commands || existing.commands;
-                existing.hooks = pkg['claude-flow']?.hooks || existing.hooks;
+                existing.commands = (pkg['moflo'] || pkg['claude-flow'])?.commands || existing.commands;
+                existing.hooks = (pkg['moflo'] || pkg['claude-flow'])?.hooks || existing.hooks;
             }
             await this.saveManifest();
             console.log(`[PluginManager] Upgraded ${packageName} to ${existing.version}`);