moflo 4.7.7 → 4.8.0

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

@@ -7,129 +7,6 @@ import { confirm, select, multiSelect, input } from '../prompt.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
-// Codex initialization action
-async function initCodexAction(ctx, options) {
-    const { force, minimal, full, dualMode } = options;
-    output.writeln();
-    output.writeln(output.bold('Initializing MoFlo V4 for OpenAI Codex'));
-    output.writeln();
-    // Determine template
-    const template = minimal ? 'minimal' : full ? 'full' : 'default';
-    const spinner = output.createSpinner({ text: 'Initializing Codex project...' });
-    spinner.start();
-    try {
-        // Dynamic import of the Codex initializer with lazy loading fallback
-        let CodexInitializer;
-        // Try multiple resolution strategies for the @claude-flow/codex package
-        // Use a variable to prevent TypeScript from statically resolving the optional module
-        const codexModuleId = '@claude-flow/codex';
-        const resolutionStrategies = [
-            // Strategy 1: Direct import (works if installed as CLI dependency)
-            async () => (await import(codexModuleId)).CodexInitializer,
-            // Strategy 2: Project node_modules (works if installed in user's project)
-            async () => {
-                const projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(projectPath)) {
-                    const mod = await import(`file://${projectPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found in project');
-            },
-            // Strategy 3: Global node_modules
-            async () => {
-                const { execSync } = await import('child_process');
-                const globalPath = execSync('npm root -g', { encoding: 'utf-8', windowsHide: true }).trim();
-                const codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(codexPath)) {
-                    const mod = await import(`file://${codexPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found globally');
-            },
-        ];
-        for (const strategy of resolutionStrategies) {
-            try {
-                CodexInitializer = await strategy();
-                if (CodexInitializer)
-                    break;
-            }
-            catch {
-                // Try next strategy
-            }
-        }
-        if (!CodexInitializer) {
-            throw new Error('Cannot find module @claude-flow/codex');
-        }
-        const initializer = new CodexInitializer();
-        const result = await initializer.initialize({
-            projectPath: ctx.cwd,
-            template: template,
-            force,
-            dual: dualMode,
-        });
-        if (!result.success) {
-            spinner.fail('Codex initialization failed');
-            if (result.errors) {
-                for (const error of result.errors) {
-                    output.printError(error);
-                }
-            }
-            return { success: false, exitCode: 1 };
-        }
-        spinner.succeed('Codex project initialized successfully!');
-        output.writeln();
-        // Display summary
-        const summary = [];
-        summary.push(`Files: ${result.filesCreated.length} created`);
-        summary.push(`Skills: ${result.skillsGenerated.length} installed`);
-        output.printBox(summary.join('\n'), 'Summary');
-        output.writeln();
-        // Show what was created
-        output.printBox([
-            `AGENTS.md:     Main project instructions`,
-            `.agents/config.toml: Project configuration`,
-            `.agents/skills/: ${result.skillsGenerated.length} skills`,
-            `.codex/: Local overrides (gitignored)`,
-            dualMode ? `CLAUDE.md: Claude Code compatibility` : '',
-        ].filter(Boolean).join('\n'), 'OpenAI Codex Integration');
-        output.writeln();
-        // Warnings
-        if (result.warnings && result.warnings.length > 0) {
-            output.printWarning('Warnings:');
-            for (const warning of result.warnings.slice(0, 5)) {
-                output.printInfo(`  • ${warning}`);
-            }
-            if (result.warnings.length > 5) {
-                output.printInfo(`  ... and ${result.warnings.length - 5} more`);
-            }
-            output.writeln();
-        }
-        // Next steps
-        output.writeln(output.bold('Next steps:'));
-        output.printList([
-            `Review ${output.highlight('AGENTS.md')} for project instructions`,
-            `Add skills with ${output.highlight('$skill-name')} syntax`,
-            `Configure ${output.highlight('.agents/config.toml')} for your project`,
-            dualMode ? `Claude Code users can use ${output.highlight('CLAUDE.md')}` : '',
-        ].filter(Boolean));
-        return { success: true, data: result };
-    }
-    catch (error) {
-        spinner.fail('Codex initialization failed');
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Handle module not found error gracefully
-        if (errorMessage.includes('Cannot find module') || errorMessage.includes('@claude-flow/codex')) {
-            output.printError('The @claude-flow/codex package is not installed.');
-            output.printInfo('Install it with: npm install @claude-flow/codex');
-            output.writeln();
-            output.printInfo('Alternatively, copy skills manually from .claude/skills/ to .agents/skills/');
-        }
-        else {
-            output.printError(`Failed to initialize: ${errorMessage}`);
-        }
-        return { success: false, exitCode: 1 };
-    }
-}
 // Check if project is already initialized
 function isInitialized(cwd) {
     const claudePath = path.join(cwd, '.claude', 'settings.json');
@@ -146,13 +23,7 @@ const initAction = async (ctx) => {
     const full = ctx.flags.full;
     const skipClaude = ctx.flags['skip-claude'];
     const onlyClaude = ctx.flags['only-claude'];
-    const codexMode = ctx.flags.codex;
-    const dualMode = ctx.flags.dual;
     const cwd = ctx.cwd;
-    // If codex mode, use the Codex initializer
-    if (codexMode || dualMode) {
-        return initCodexAction(ctx, { codexMode, dualMode, force, minimal, full });
-    }
     // ── MoFlo Project Setup ────────────────────────────────────────────
     // Always run MoFlo init to ensure moflo.yaml, hooks, skill, and
     // CLAUDE.md are set up, regardless of other init options.
@@ -708,7 +579,6 @@ const skillsCommand = {
                 flowNexus: false,
                 browser: false,
                 v3: ctx.flags.v3,
-                dualMode: false,
             },
         };
         const spinner = output.createSpinner({ text: 'Installing skills...' });
@@ -971,18 +841,6 @@ export const initCommand = {
             default: 'all-MiniLM-L6-v2',
             choices: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
         },
-        {
-            name: 'codex',
-            description: 'Initialize for OpenAI Codex CLI (creates AGENTS.md, .agents/)',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'dual',
-            description: 'Initialize for both Claude Code and OpenAI Codex',
-            type: 'boolean',
-            default: false,
-        },
     ],
     examples: [
         { command: 'claude-flow init', description: 'Initialize with default configuration' },
@@ -1001,9 +859,6 @@ export const initCommand = {
         { command: 'claude-flow init upgrade', description: 'Update helpers while preserving data' },
         { command: 'claude-flow init upgrade --settings', description: 'Update helpers and merge new settings (Agent Teams)' },
         { command: 'claude-flow init upgrade --verbose', description: 'Show detailed upgrade info' },
-        { command: 'claude-flow init --codex', description: 'Initialize for OpenAI Codex (AGENTS.md)' },
-        { command: 'claude-flow init --codex --full', description: 'Codex init with all 137+ skills' },
-        { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
     ],
     action: initAction,
 };

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

@@ -50,6 +50,11 @@ export interface MofloConfig {
         circuit_breaker: boolean;
         agent_overrides: Record<string, string>;
     };
+    auto_update: {
+        enabled: boolean;
+        scripts: boolean;
+        helpers: boolean;
+    };
     status_line: {
         enabled: boolean;
         branding: string;

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

@@ -69,6 +69,11 @@ const DEFAULT_CONFIG = {
         circuit_breaker: true,
         agent_overrides: {},
     },
+    auto_update: {
+        enabled: true,
+        scripts: true,
+        helpers: true,
+    },
     status_line: {
         enabled: true,
         branding: 'Moflo V4',
@@ -159,6 +164,11 @@ function mergeConfig(raw, root) {
             circuit_breaker: raw.model_routing?.circuit_breaker ?? raw.modelRouting?.circuitBreaker ?? DEFAULT_CONFIG.model_routing.circuit_breaker,
             agent_overrides: raw.model_routing?.agent_overrides ?? raw.modelRouting?.agentOverrides ?? DEFAULT_CONFIG.model_routing.agent_overrides,
         },
+        auto_update: {
+            enabled: raw.auto_update?.enabled ?? raw.autoUpdate?.enabled ?? DEFAULT_CONFIG.auto_update.enabled,
+            scripts: raw.auto_update?.scripts ?? raw.autoUpdate?.scripts ?? DEFAULT_CONFIG.auto_update.scripts,
+            helpers: raw.auto_update?.helpers ?? raw.autoUpdate?.helpers ?? DEFAULT_CONFIG.auto_update.helpers,
+        },
         status_line: {
             enabled: raw.status_line?.enabled ?? raw.statusLine?.enabled ?? DEFAULT_CONFIG.status_line.enabled,
             branding: raw.status_line?.branding ?? raw.statusLine?.branding ?? DEFAULT_CONFIG.status_line.branding,
@@ -314,6 +324,12 @@ model_routing:
   #   security-architect: opus     # Always use opus for security
   #   researcher: sonnet           # Pin research to sonnet
 
+# Auto-update on session start (syncs scripts and helpers when moflo version changes)
+auto_update:
+  enabled: true                  # Master toggle for version-change auto-sync
+  scripts: true                  # Sync .claude/scripts/ from moflo bin/
+  helpers: true                  # Sync .claude/helpers/ from moflo source
+
 # Status line items (show/hide individual sections)
 status_line:
   enabled: true

package/src/@claude-flow/cli/dist/src/config-adapter.d.ts

@@ -2,7 +2,7 @@
  * Configuration Adapter
  * Converts between SystemConfig and V3Config types
  */
-import type { SystemConfig } from '@claude-flow/shared';
+import type { SystemConfig } from '../../shared/src/index.js';
 import type { V3Config } from './types.js';
 /**
  * Convert SystemConfig to V3Config (CLI-specific format)

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

@@ -31,7 +31,6 @@ const SKILLS_MAP = {
         'skill-builder',
     ],
     browser: ['browser'], // agent-browser integration
-    dualMode: ['dual-mode'], // Claude Code + Codex hybrid execution
     agentdb: [
         'agentdb-advanced',
         'agentdb-learning',
@@ -89,7 +88,6 @@ const AGENTS_MAP = {
     sparc: ['sparc'],
     swarm: ['swarm'],
     browser: ['browser'], // agent-browser integration
-    dualMode: ['dual-mode'], // Claude Code + Codex hybrid execution
     // V3-specific agents
     v3: ['v3'],
     optimization: ['optimization'],
@@ -425,6 +423,46 @@ export async function executeUpgrade(targetDir, upgradeSettings = false) {
             };
             fs.writeFileSync(statuslinePath, generateStatuslineScript(upgradeOptions), 'utf-8');
         }
+        // 1b. ALWAYS sync .claude/scripts/ from moflo bin/ (derived files, not user-edited)
+        // Scripts contain critical daemon guards, hook logic, etc. that must stay in sync.
+        const scriptsDir = path.join(targetDir, '.claude', 'scripts');
+        if (!fs.existsSync(scriptsDir)) {
+            fs.mkdirSync(scriptsDir, { recursive: true });
+        }
+        const UPGRADE_SCRIPT_MAP = {
+            'hooks.mjs': 'hooks.mjs',
+            'session-start-launcher.mjs': 'session-start-launcher.mjs',
+            'index-guidance.mjs': 'index-guidance.mjs',
+            'build-embeddings.mjs': 'build-embeddings.mjs',
+            'generate-code-map.mjs': 'generate-code-map.mjs',
+            'semantic-search.mjs': 'semantic-search.mjs',
+        };
+        const binDir = findMofloBinDir();
+        if (binDir) {
+            for (const [destName, srcName] of Object.entries(UPGRADE_SCRIPT_MAP)) {
+                const srcPath = path.join(binDir, srcName);
+                const destPath = path.join(scriptsDir, destName);
+                if (!fs.existsSync(srcPath))
+                    continue;
+                try {
+                    const srcStat = fs.statSync(srcPath);
+                    const destExists = fs.existsSync(destPath);
+                    // Always overwrite if source is newer or dest doesn't exist
+                    if (!destExists || srcStat.mtimeMs > fs.statSync(destPath).mtimeMs) {
+                        fs.copyFileSync(srcPath, destPath);
+                        if (destExists) {
+                            result.updated.push(`.claude/scripts/${destName}`);
+                        }
+                        else {
+                            result.created.push(`.claude/scripts/${destName}`);
+                        }
+                    }
+                }
+                catch {
+                    // Non-fatal — skip individual script on error
+                }
+            }
+        }
         // 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');
@@ -711,8 +749,6 @@ async function copySkills(targetDir, options, result) {
             skillsToCopy.push(...SKILLS_MAP.browser);
         if (skillsConfig.v3)
             skillsToCopy.push(...SKILLS_MAP.v3);
-        if (skillsConfig.dualMode)
-            skillsToCopy.push(...SKILLS_MAP.dualMode);
     }
     // Find source skills directory
     const sourceSkillsDir = findSourceDir('skills', options.sourceBaseDir);
@@ -825,9 +861,6 @@ async function copyAgents(targetDir, options, result) {
             agentsToCopy.push(...(AGENTS_MAP.optimization || []));
         if (agentsConfig.testing)
             agentsToCopy.push(...(AGENTS_MAP.testing || []));
-        // Dual-mode agents (Claude Code + Codex hybrid)
-        if (agentsConfig.dualMode)
-            agentsToCopy.push(...(AGENTS_MAP.dualMode || []));
     }
     // Find source agents directory
     const sourceAgentsDir = findSourceDir('agents', options.sourceBaseDir);
@@ -905,6 +938,40 @@ function findSourceHelpersDir(sourceBaseDir) {
     }
     return null;
 }
+/**
+ * Find the moflo bin/ directory (source of truth for .claude/scripts/).
+ * Uses the same resolution strategies as findSourceHelpersDir.
+ */
+function findMofloBinDir() {
+    const possiblePaths = [];
+    const SENTINEL_FILE = 'hooks.mjs'; // Must exist in valid bin/
+    // Strategy 1: require.resolve
+    try {
+        const esmRequire = createRequire(import.meta.url);
+        const pkgJsonPath = esmRequire.resolve('moflo/package.json');
+        possiblePaths.push(path.join(path.dirname(pkgJsonPath), 'bin'));
+    }
+    catch { /* not installed as package */ }
+    // Strategy 2: __dirname-based (dist/src/init -> package root -> bin)
+    possiblePaths.push(path.resolve(__dirname, '..', '..', '..', 'bin'));
+    // Strategy 3: Walk up from __dirname
+    let currentDir = __dirname;
+    for (let i = 0; i < 10; i++) {
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        possiblePaths.push(path.join(parentDir, 'bin'));
+        currentDir = parentDir;
+    }
+    // Strategy 4: cwd-relative (node_modules/moflo/bin)
+    possiblePaths.push(path.join(process.cwd(), 'node_modules', 'moflo', 'bin'));
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p) && fs.existsSync(path.join(p, SENTINEL_FILE))) {
+            return p;
+        }
+    }
+    return null;
+}
 /**
  * Write helper scripts
  */

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

@@ -2,10 +2,9 @@
  * MCP Configuration Generator
  * Creates .mcp.json for Claude Code MCP server integration
  *
- * Note: Claude Code spawns MCP servers as child processes using the
- * command/args from .mcp.json. On all platforms (including Windows),
- * using `npx` directly works correctly. The previous `cmd /c` wrapper
- * on Windows caused MCP servers to fail to start.
+ * Uses direct `node` invocation when moflo is locally installed to avoid
+ * npx overhead (package resolution, registry checks). Falls back to `npx`
+ * for external packages (ruv-swarm, flow-nexus) that may not be installed.
  */
 import type { InitOptions } from './types.js';
 /**

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

@@ -2,17 +2,16 @@
  * MCP Configuration Generator
  * Creates .mcp.json for Claude Code MCP server integration
  *
- * Note: Claude Code spawns MCP servers as child processes using the
- * command/args from .mcp.json. On all platforms (including Windows),
- * using `npx` directly works correctly. The previous `cmd /c` wrapper
- * on Windows caused MCP servers to fail to start.
+ * Uses direct `node` invocation when moflo is locally installed to avoid
+ * npx overhead (package resolution, registry checks). Falls back to `npx`
+ * for external packages (ruv-swarm, flow-nexus) that may not be installed.
  */
+import { existsSync } from 'fs';
+import { join } from 'path';
 /**
- * Generate MCP server entry
- * Uses `npx` directly on all platforms — Claude Code handles process
- * spawning correctly without needing a cmd.exe wrapper.
+ * Generate MCP server entry using npx (for external packages)
  */
-function createMCPServerEntry(npxArgs, env, additionalProps = {}) {
+function createNpxServerEntry(npxArgs, env, additionalProps = {}) {
     return {
         command: 'npx',
         args: ['-y', ...npxArgs],
@@ -20,6 +19,35 @@ function createMCPServerEntry(npxArgs, env, additionalProps = {}) {
         ...additionalProps,
     };
 }
+/**
+ * Generate MCP server entry using direct node invocation (for local moflo).
+ * Avoids npx overhead — faster startup, fewer intermediate processes.
+ */
+function createDirectServerEntry(cliPath, cliArgs, env, additionalProps = {}) {
+    return {
+        command: 'node',
+        args: [cliPath, ...cliArgs],
+        env,
+        ...additionalProps,
+    };
+}
+/**
+ * Find the moflo CLI entry point relative to the project root.
+ * Returns the path if found, null otherwise.
+ */
+function findMofloCli(projectRoot) {
+    const candidates = [
+        // Installed as dependency
+        join(projectRoot, 'node_modules', 'moflo', 'bin', 'cli.js'),
+        // Running from moflo repo itself
+        join(projectRoot, 'bin', 'cli.js'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
 /**
  * Generate MCP configuration
  */
@@ -32,24 +60,32 @@ export function generateMCPConfig(options) {
     // When toolDefer is true, emit "deferred" so Claude Code loads schemas on
     // demand via ToolSearch instead of putting 150+ schemas into context at startup.
     const deferProps = config.toolDefer ? { toolDefer: 'deferred' } : {};
-    // Claude Flow MCP server (core)
+    const mcpEnv = {
+        ...npmEnv,
+        CLAUDE_FLOW_MODE: 'v3',
+        CLAUDE_FLOW_HOOKS_ENABLED: 'true',
+        CLAUDE_FLOW_TOPOLOGY: options.runtime.topology,
+        CLAUDE_FLOW_MAX_AGENTS: String(options.runtime.maxAgents),
+        CLAUDE_FLOW_MEMORY_BACKEND: options.runtime.memoryBackend,
+    };
+    // Claude Flow MCP server (core) — use direct node when locally installed
     if (config.claudeFlow) {
-        mcpServers['claude-flow'] = createMCPServerEntry(['moflo', 'mcp', 'start'], {
-            ...npmEnv,
-            CLAUDE_FLOW_MODE: 'v3',
-            CLAUDE_FLOW_HOOKS_ENABLED: 'true',
-            CLAUDE_FLOW_TOPOLOGY: options.runtime.topology,
-            CLAUDE_FLOW_MAX_AGENTS: String(options.runtime.maxAgents),
-            CLAUDE_FLOW_MEMORY_BACKEND: options.runtime.memoryBackend,
-        }, { autoStart: config.autoStart, ...deferProps });
+        const projectRoot = options.targetDir ?? process.cwd();
+        const localCli = findMofloCli(projectRoot);
+        if (localCli) {
+            mcpServers['claude-flow'] = createDirectServerEntry(localCli, ['mcp', 'start'], mcpEnv, { autoStart: config.autoStart, ...deferProps });
+        }
+        else {
+            mcpServers['claude-flow'] = createNpxServerEntry(['moflo', 'mcp', 'start'], mcpEnv, { autoStart: config.autoStart, ...deferProps });
+        }
     }
-    // Ruv-Swarm MCP server (enhanced coordination)
+    // Ruv-Swarm MCP server (enhanced coordination) — always npx (external package)
     if (config.ruvSwarm) {
-        mcpServers['ruv-swarm'] = createMCPServerEntry(['ruv-swarm', 'mcp', 'start'], { ...npmEnv }, { optional: true, ...deferProps });
+        mcpServers['ruv-swarm'] = createNpxServerEntry(['ruv-swarm', 'mcp', 'start'], { ...npmEnv }, { optional: true, ...deferProps });
     }
-    // Flow Nexus MCP server (cloud features)
+    // Flow Nexus MCP server (cloud features) — always npx (external package)
     if (config.flowNexus) {
-        mcpServers['flow-nexus'] = createMCPServerEntry(['flow-nexus@latest', 'mcp', 'start'], { ...npmEnv }, { optional: true, requiresAuth: true, ...deferProps });
+        mcpServers['flow-nexus'] = createNpxServerEntry(['flow-nexus@latest', 'mcp', 'start'], { ...npmEnv }, { optional: true, requiresAuth: true, ...deferProps });
     }
     return { mcpServers };
 }
@@ -67,7 +103,14 @@ export function generateMCPCommands(options) {
     const commands = [];
     const config = options.mcp;
     if (config.claudeFlow) {
-        commands.push('claude mcp add claude-flow -- npx -y moflo mcp start');
+        const projectRoot = options.targetDir ?? process.cwd();
+        const localCli = findMofloCli(projectRoot);
+        if (localCli) {
+            commands.push(`claude mcp add claude-flow -- node ${localCli} mcp start`);
+        }
+        else {
+            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');

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

@@ -66,8 +66,6 @@ export interface SkillsConfig {
     browser: boolean;
     /** Include V3 implementation skills */
     v3: boolean;
-    /** Include dual-mode skills (Claude Code + Codex hybrid) */
-    dualMode: boolean;
     /** Include all available skills */
     all: boolean;
 }
@@ -118,8 +116,6 @@ export interface AgentsConfig {
     optimization: boolean;
     /** Include testing agents */
     testing: boolean;
-    /** Include dual-mode agents (Claude Code + Codex hybrid) */
-    dualMode: boolean;
     /** Include all agents */
     all: boolean;
 }

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

@@ -75,7 +75,6 @@ export const DEFAULT_INIT_OPTIONS = {
         flowNexus: false,
         browser: true,
         v3: true,
-        dualMode: false, // Optional: enable with --dual flag
         all: false,
     },
     commands: {
@@ -100,7 +99,6 @@ export const DEFAULT_INIT_OPTIONS = {
         v3: true,
         optimization: true,
         testing: true,
-        dualMode: false, // Optional: enable with --dual flag
         all: true,
     },
     statusline: {
@@ -169,7 +167,6 @@ export const MINIMAL_INIT_OPTIONS = {
         flowNexus: false,
         browser: false,
         v3: false,
-        dualMode: false,
         all: false,
     },
     agents: {
@@ -183,7 +180,6 @@ export const MINIMAL_INIT_OPTIONS = {
         v3: false,
         optimization: false,
         testing: false,
-        dualMode: false,
         all: false,
     },
     runtime: {
@@ -229,7 +225,6 @@ export const FULL_INIT_OPTIONS = {
         flowNexus: true,
         browser: true,
         v3: true,
-        dualMode: true, // Include in full init
         all: true,
     },
     commands: {

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

@@ -319,13 +319,49 @@ export class MCPServerManager extends EventEmitter {
             console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) stdin closed, shutting down...`);
             process.exit(0);
         });
+        process.stdin.on('error', () => {
+            // stdin pipe broken — parent disconnected
+            process.exit(0);
+        });
+        // Orphan watchdog: on Windows, stdin 'end' doesn't always fire when the
+        // parent process disconnects. Poll the parent PID to detect orphaning and
+        // self-terminate. Also tracks stdin inactivity as a secondary signal.
+        const parentPid = process.ppid;
+        let lastStdinActivity = Date.now();
+        const WATCHDOG_INTERVAL_MS = 10_000; // Check every 10s
+        const STDIN_IDLE_TIMEOUT_MS = 5 * 60_000; // 5 min with no stdin = likely orphaned
+        // Track stdin activity
+        process.stdin.on('data', () => { lastStdinActivity = Date.now(); });
+        const watchdog = setInterval(() => {
+            // Check 1: Is parent process still alive?
+            if (parentPid) {
+                try {
+                    process.kill(parentPid, 0); // signal 0 = existence check
+                }
+                catch {
+                    // Parent is gone — we're orphaned
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Parent (PID ${parentPid}) gone, shutting down...`);
+                    clearInterval(watchdog);
+                    process.exit(0);
+                }
+            }
+            // Check 2: Has stdin been idle too long?
+            if (Date.now() - lastStdinActivity > STDIN_IDLE_TIMEOUT_MS) {
+                console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) No stdin activity for ${STDIN_IDLE_TIMEOUT_MS / 1000}s, shutting down...`);
+                clearInterval(watchdog);
+                process.exit(0);
+            }
+        }, WATCHDOG_INTERVAL_MS);
+        watchdog.unref(); // Don't keep process alive just for watchdog
         // Handle process termination
         process.on('SIGINT', () => {
             console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Received SIGINT, shutting down...`);
+            clearInterval(watchdog);
             process.exit(0);
         });
         process.on('SIGTERM', () => {
             console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${sessionId}) Received SIGTERM, shutting down...`);
+            clearInterval(watchdog);
             process.exit(0);
         });
         // Mark as ready immediately for stdio

package/src/@claude-flow/cli/dist/src/memory/memory-bridge.d.ts

@@ -404,4 +404,10 @@ export declare function bridgeContextSynthesize(params: {
 export declare function bridgeSemanticRoute(params: {
     input: string;
 }): Promise<any>;
+/**
+ * Write vector-stats.json cache file used by the statusline.
+ * Synchronous — safe to call from short-lived CLI commands.
+ * Uses the already-initialized registry; no-ops if registry isn't loaded.
+ */
+export declare function refreshVectorStatsCache(dbPathOverride?: string): void;
 //# sourceMappingURL=memory-bridge.d.ts.map