moflo 4.8.10 → 4.8.12

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, generateGateScript, generateHookHandlerScript, } from './helpers-generator.js';
+import { generatePreCommitHook, generatePostCommitHook, generateAutoMemoryHook, generateGateScript, generateGateHookScript, generatePromptHookScript, generateHookHandlerScript, } from './helpers-generator.js';
 import { generateClaudeMd } from './claudemd-generator.js';
 /**
  * Skills to copy based on configuration
@@ -377,6 +377,8 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             const generatedCritical = {
                 'auto-memory-hook.mjs': generateAutoMemoryHook(),
                 'gate.cjs': generateGateScript(),
+                'gate-hook.mjs': generateGateHookScript(),
+                'prompt-hook.mjs': generatePromptHookScript(),
                 'hook-handler.cjs': generateHookHandlerScript(),
             };
             for (const [helperName, content] of Object.entries(generatedCritical)) {
@@ -463,6 +465,22 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 }
             }
         }
+        // 1c. Build manifest of files we're installing, clean up stale ones
+        const manifestPath = path.join(targetDir, '.claude-flow', 'installed-files.json');
+        let previousManifest = [];
+        try {
+            previousManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        }
+        catch { /* ok */ }
+        const currentManifest = [];
+        // Collect everything we just synced into the manifest
+        for (const entry of [...result.created, ...result.updated]) {
+            // Strip annotations like " (removed, obsolete)" — keep only clean paths
+            const clean = entry.replace(/\s*\(.*\)$/, '');
+            if (clean.startsWith('.claude/') || clean.startsWith('.claude-flow/')) {
+                currentManifest.push(clean);
+            }
+        }
         // 2. Create MISSING metrics files only (preserve existing data)
         const metricsDir = path.join(targetDir, '.claude-flow', 'metrics');
         const securityDir = path.join(targetDir, '.claude-flow', 'security');
@@ -579,6 +597,39 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
                 result.settingsUpdated = ['Created new settings.json with Agent Teams'];
             }
         }
+        // ── Final: collect any additional generated files into manifest, then clean up stale ──
+        // Re-scan result arrays since metrics/security files were added after initial collection
+        for (const entry of [...result.created, ...result.updated]) {
+            const clean = entry.replace(/\s*\(.*\)$/, '');
+            if ((clean.startsWith('.claude/') || clean.startsWith('.claude-flow/')) && !currentManifest.includes(clean)) {
+                currentManifest.push(clean);
+            }
+        }
+        // Remove files that were in the OLD manifest but NOT in the new one.
+        // This only deletes files moflo previously installed — never user or runtime files.
+        if (previousManifest.length > 0) {
+            const currentSet = new Set(currentManifest);
+            for (const rel of previousManifest) {
+                if (!currentSet.has(rel)) {
+                    const abs = path.join(targetDir, rel);
+                    try {
+                        if (fs.existsSync(abs)) {
+                            fs.unlinkSync(abs);
+                            result.updated.push(`${rel} (removed, no longer shipped)`);
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                }
+            }
+        }
+        // Write manifest for next upgrade
+        try {
+            const cfDir = path.join(targetDir, '.claude-flow');
+            if (!fs.existsSync(cfDir))
+                fs.mkdirSync(cfDir, { recursive: true });
+            fs.writeFileSync(manifestPath, JSON.stringify(currentManifest, null, 2), 'utf-8');
+        }
+        catch { /* non-fatal */ }
     }
     catch (error) {
         result.success = false;
@@ -713,12 +764,63 @@ async function writeSettings(targetDir, options, result) {
 }
 /**
  * Write .mcp.json
+ *
+ * If an existing config contains the legacy 'claude-flow' server key, prompt
+ * the user to migrate it to 'moflo', keep both side-by-side, or leave as-is.
  */
 async function writeMCPConfig(targetDir, options, result) {
     const mcpPath = path.join(targetDir, '.mcp.json');
-    if (fs.existsSync(mcpPath) && !options.force) {
-        result.skipped.push('.mcp.json');
-        return;
+    if (fs.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+        const servers = existing?.mcpServers ?? {};
+        const hasLegacy = 'claude-flow' in servers;
+        const hasMoflo = 'moflo' in servers;
+        if (hasLegacy && !hasMoflo) {
+            // Interactive mode: prompt the user
+            if (process.stdin.isTTY && !options.force) {
+                const { select } = await import('../prompt.js');
+                const action = await select({
+                    message: "Found existing 'claude-flow' MCP server. How should we handle it?",
+                    options: [
+                        { value: 'migrate', label: 'Migrate to moflo', hint: 'Rename claude-flow → moflo (recommended)' },
+                        { value: 'side-by-side', label: 'Keep both', hint: 'Add moflo alongside existing claude-flow' },
+                        { value: 'skip', label: 'Skip', hint: 'Leave .mcp.json unchanged' },
+                    ],
+                    default: 'migrate',
+                });
+                if (action === 'skip') {
+                    result.skipped.push('.mcp.json');
+                    return;
+                }
+                if (action === 'migrate') {
+                    servers['moflo'] = servers['claude-flow'];
+                    delete servers['claude-flow'];
+                    existing.mcpServers = servers;
+                    fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2), 'utf-8');
+                    result.created.files.push('.mcp.json (migrated claude-flow → moflo)');
+                    return;
+                }
+                // side-by-side: fall through to generate new config and merge
+                const newConfig = JSON.parse(generateMCPJson(options));
+                Object.assign(servers, newConfig.mcpServers ?? {});
+                existing.mcpServers = servers;
+                fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2), 'utf-8');
+                result.created.files.push('.mcp.json (added moflo alongside claude-flow)');
+                return;
+            }
+            // Non-interactive (CI/pipe): auto-migrate silently
+            servers['moflo'] = servers['claude-flow'];
+            delete servers['claude-flow'];
+            existing.mcpServers = servers;
+            fs.writeFileSync(mcpPath, JSON.stringify(existing, null, 2), 'utf-8');
+            result.created.files.push('.mcp.json (auto-migrated claude-flow → moflo)');
+            return;
+        }
+        // Already has moflo or no legacy key — skip unless forced
+        if (!options.force) {
+            result.skipped.push('.mcp.json');
+            return;
+        }
     }
     const content = generateMCPJson(options);
     fs.writeFileSync(mcpPath, content, 'utf-8');
@@ -1012,6 +1114,8 @@ async function writeHelpers(targetDir, options, result) {
         'post-commit': generatePostCommitHook(),
         'auto-memory-hook.mjs': generateAutoMemoryHook(),
         'gate.cjs': generateGateScript(),
+        'gate-hook.mjs': generateGateHookScript(),
+        'prompt-hook.mjs': generatePromptHookScript(),
         'hook-handler.cjs': generateHookHandlerScript(),
     };
     for (const [name, content] of Object.entries(helpers)) {
@@ -1653,7 +1757,7 @@ npx moflo hive-mind consensus --propose "task"
 ### MCP Server Setup
 \`\`\`bash
 # Add Claude Flow MCP
-claude mcp add claude-flow -- npx -y moflo
+claude mcp add moflo -- npx -y moflo
 
 # Optional servers
 claude mcp add ruv-swarm -- npx -y ruv-swarm mcp start

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

@@ -28,6 +28,20 @@ export declare function generateHelpers(options: InitOptions): Record<string, st
  * on every tool call (~500ms npx overhead → ~20ms direct node).
  */
 export declare function generateGateScript(): string;
+/**
+ * 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 declare function generateGateHookScript(): string;
+/**
+ * Generate prompt-hook.mjs — reads user prompt from Claude Code stdin JSON,
+ * runs prompt classification via gate.cjs, and appends namespace hints.
+ */
+export declare function generatePromptHookScript(): string;
 /**
  * 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/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

@@ -1,24 +1,31 @@
-export interface MofloInitOptions {
-    projectRoot: string;
-    force?: boolean;
-    skipIndex?: boolean;
-    interactive?: boolean;
-    minimal?: boolean;
-}
-export interface MofloInitAnswers {
-    guidance: boolean;
-    guidanceDirs: string[];
-    codeMap: boolean;
-    srcDirs: string[];
-    gates: boolean;
-    stopHook: boolean;
-}
-export interface MofloInitResult {
-    steps: {
-        name: string;
-        status: 'created' | 'updated' | 'skipped' | 'error';
-        detail?: string;
-    }[];
-}
-export declare function initMoflo(options: MofloInitOptions): Promise<MofloInitResult>;
+export interface MofloInitOptions {
+    projectRoot: string;
+    force?: boolean;
+    skipIndex?: boolean;
+    interactive?: boolean;
+    minimal?: boolean;
+}
+export interface MofloInitAnswers {
+    guidance: boolean;
+    guidanceDirs: string[];
+    codeMap: boolean;
+    srcDirs: string[];
+    tests: boolean;
+    testDirs: string[];
+    gates: boolean;
+    stopHook: boolean;
+}
+export interface MofloInitResult {
+    steps: {
+        name: string;
+        status: 'created' | 'updated' | 'skipped' | 'error';
+        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