moflo 4.7.6 → 4.7.8

package/.claude/helpers/gate.cjs

@@ -0,0 +1,148 @@
+#!/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;
+}

package/.claude/helpers/statusline.cjs

@@ -330,25 +330,33 @@ function getSecurityStatus() {
 }
 
 // Swarm status (pure file reads, NO ps aux)
+// Metrics files older than 5 minutes are considered stale (swarm no longer running)
 function getSwarmStatus() {
+  const STALE_MS = 5 * 60_000;
+  const now = Date.now();
+
   const activityData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'swarm-activity.json'));
   if (activityData?.swarm) {
-    const count = activityData.swarm.agent_count || 0;
+    const ts = activityData.timestamp ? new Date(activityData.timestamp).getTime() : 0;
+    const stale = (now - ts) > STALE_MS;
+    const count = stale ? 0 : (activityData.swarm.agent_count || 0);
     return {
       activeAgents: Math.min(count, CONFIG.maxAgents),
       maxAgents: CONFIG.maxAgents,
-      coordinationActive: activityData.swarm.coordination_active || activityData.swarm.active || false,
+      coordinationActive: stale ? false : (activityData.swarm.coordination_active || activityData.swarm.active || false),
     };
   }
 
   const progressData = readJSON(path.join(CWD, '.claude-flow', 'metrics', 'v3-progress.json'));
   if (progressData?.swarm) {
-    const count = progressData.swarm.activeAgents || progressData.swarm.agent_count || 0;
+    const ts = progressData.timestamp ? new Date(progressData.timestamp).getTime() : 0;
+    const stale = (now - ts) > STALE_MS;
+    const count = stale ? 0 : (progressData.swarm.activeAgents || progressData.swarm.agent_count || 0);
     const max = progressData.swarm.totalAgents || CONFIG.maxAgents;
     return {
       activeAgents: Math.min(count, max),
       maxAgents: max,
-      coordinationActive: progressData.swarm.active || (count > 0),
+      coordinationActive: stale ? false : (progressData.swarm.active || (count > 0)),
     };
   }
 
@@ -461,44 +469,44 @@ function getHooksStatus() {
   return { enabled, total };
 }
 
-// AgentDB stats — queries real count from sqlite when possible, falls back to file size estimate
+// AgentDB stats — reads from cache file written by embedding/memory operations.
+// No subprocess spawning. Falls back to DB file size estimate if cache is missing.
 function getAgentDBStats() {
   let vectorCount = 0;
   let dbSizeKB = 0;
   let namespaces = 0;
   let hasHnsw = false;
-  let dbPath = null;
 
+  // Read cached stats (written by memory store/embed/rebuild commands)
+  const cachePaths = [
+    path.join(CWD, '.claude-flow', 'vector-stats.json'),
+    path.join(CWD, '.swarm', 'vector-stats.json'),
+  ];
+  for (const cp of cachePaths) {
+    const cached = readJSON(cp);
+    if (cached && typeof cached.vectorCount === 'number') {
+      vectorCount = cached.vectorCount;
+      dbSizeKB = cached.dbSizeKB || 0;
+      namespaces = cached.namespaces || 0;
+      hasHnsw = cached.hasHnsw || false;
+      return { vectorCount, dbSizeKB, namespaces, hasHnsw };
+    }
+  }
+
+  // Fallback: estimate from DB file size (no subprocess)
   const dbFiles = [
     path.join(CWD, '.swarm', 'memory.db'),
     path.join(CWD, '.claude-flow', 'memory.db'),
     path.join(CWD, '.claude', 'memory.db'),
     path.join(CWD, 'data', 'memory.db'),
   ];
-
   for (const f of dbFiles) {
     const stat = safeStat(f);
     if (stat) {
-      dbSizeKB = stat.size / 1024;
-      dbPath = f;
-      break;
-    }
-  }
-
-  // Try to get real count from sqlite (fast — single COUNT query)
-  if (dbPath) {
-    const countOutput = safeExec(`node -e "const S=require('sql.js');const f=require('fs');S().then(Q=>{const d=new Q.Database(f.readFileSync('${dbPath.replace(/\\/g, '/')}'));const s=d.prepare('SELECT COUNT(*) as c FROM memory_entries WHERE status=\\"active\\" AND embedding IS NOT NULL');s.step();console.log(JSON.stringify(s.getAsObject()));s.free();const n=d.prepare('SELECT COUNT(DISTINCT namespace) as n FROM memory_entries WHERE status=\\"active\\"');n.step();console.log(JSON.stringify(n.getAsObject()));n.free();d.close();})"`, 3000);
-    if (countOutput) {
-      try {
-        const lines = countOutput.trim().split('\n');
-        vectorCount = JSON.parse(lines[0]).c || 0;
-        namespaces = lines[1] ? JSON.parse(lines[1]).n || 0 : 0;
-      } catch { /* fall back to estimate */ }
-    }
-    // Fallback to file size estimate if query failed
-    if (vectorCount === 0) {
+      dbSizeKB = Math.floor(stat.size / 1024);
       vectorCount = Math.floor(dbSizeKB / 2);
       namespaces = 1;
+      break;
     }
   }
 
@@ -513,7 +521,7 @@ function getAgentDBStats() {
     }
   }
 
-  return { vectorCount, dbSizeKB: Math.floor(dbSizeKB), namespaces, hasHnsw };
+  return { vectorCount, dbSizeKB, namespaces, hasHnsw };
 }
 
 // Test stats (count files only — NO reading file contents)

package/.claude/settings.json

@@ -275,9 +275,9 @@
   },
   "mcpServers": {
     "claude-flow": {
-      "command": "npx",
+      "command": "node",
       "args": [
-        "moflo",
+        "bin/cli.js",
         "mcp",
         "start"
       ]

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=5" alt="MoFlo" />
+  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=6" alt="MoFlo" />
 </p>
 
 # MoFlo

package/bin/hooks.mjs

@@ -20,7 +20,7 @@
  */
 
 import { spawn } from 'child_process';
-import { existsSync, appendFileSync } from 'fs';
+import { existsSync, appendFileSync, readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
 
@@ -306,7 +306,11 @@ async function main() {
       }
 
       case 'daemon-start': {
-        await runClaudeFlow('daemon', ['start', '--quiet']);
+        if (!isDaemonRunning()) {
+          await runClaudeFlow('daemon', ['start', '--quiet']);
+        } else {
+          log('info', 'Daemon already running, skipping start');
+        }
         break;
       }
 
@@ -475,7 +479,25 @@ function runBackgroundTraining() {
   spawnWindowless('node', [localCli, 'neural', 'optimize'], 'neural optimize');
 }
 
-// Run daemon start in background (non-blocking)
+// Check if daemon is already running via PID file.
+// Returns true if a live daemon process exists, false otherwise.
+function isDaemonRunning() {
+  const pidFile = resolve(projectRoot, '.claude-flow', 'daemon.pid');
+  if (existsSync(pidFile)) {
+    try {
+      const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+      if (pid && !isNaN(pid)) {
+        process.kill(pid, 0); // signal 0 = check if process exists, doesn't kill
+        return true;
+      }
+    } catch {
+      // Process doesn't exist — stale PID file
+    }
+  }
+  return false;
+}
+
+// Run daemon start in background (non-blocking) — skip if already running
 function runDaemonStartBackground() {
   const localCli = getLocalCliPath();
   if (!localCli) {
@@ -483,6 +505,11 @@ function runDaemonStartBackground() {
     return;
   }
 
+  if (isDaemonRunning()) {
+    log('info', 'Daemon already running, skipping start');
+    return;
+  }
+
   spawnWindowless('node', [localCli, 'daemon', 'start', '--quiet'], 'daemon');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.7.6",
+  "version": "4.7.8",
   "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",
@@ -49,7 +49,7 @@
     "dev": "tsx watch src/index.ts",
     "build": "tsc",
     "build:ts": "cd src/@claude-flow/cli && npm run build || true",
-    "test": "vitest",
+    "test": "vitest run",
     "test:ui": "vitest --ui",
     "test:security": "vitest run src/__tests__/security/",
     "lint": "cd src/@claude-flow/cli && npm run lint || true",
@@ -67,7 +67,6 @@
     "zod": "^3.22.4"
   },
   "optionalDependencies": {
-    "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/plugin-gastown-bridge": "^0.1.3",
     "@ruvector/attention": "^0.1.3",
     "@ruvector/core": "^0.1.30",
@@ -81,14 +80,13 @@
     "hono": ">=4.11.4"
   },
   "devDependencies": {
-    "@openai/codex": "^0.98.0",
     "@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"
+    "vitest": "^4.0.0"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/@claude-flow/cli/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=5" alt="MoFlo" />
+  <img src="https://raw.githubusercontent.com/eric-cielo/moflo/main/docs/Moflo_md.png?v=6" alt="MoFlo" />
 </p>
 
 # MoFlo

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-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'],
@@ -711,8 +709,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 +821,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);
@@ -935,12 +928,10 @@ async function writeHelpers(targetDir, options, result) {
                 result.skipped.push(`.claude/helpers/${file}`);
             }
         }
-        if (copiedCount > 0) {
-            return; // Skip generating if we copied from source
-        }
+        // Don't return early — still need to generate any missing required helpers below
     }
-    // Fall back to generating helpers if source not available.
-    // gate.cjs and hook-handler.cjs are required — hooks call them directly
+    // Generate required helpers that weren't copied from source.
+    // gate.cjs and hook-handler.cjs are critical — hooks call them directly
     // via `node` instead of `npx flo` to avoid CLI bootstrap overhead.
     const helpers = {
         'pre-commit': generatePreCommitHook(),

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

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

@@ -388,6 +388,9 @@ export async function bridgeStoreEntry(options) {
         await cacheSet(registry, cacheKey, { id, key, namespace, content: value, embedding: embeddingJson });
         // Phase 4: AttestationLog write audit
         await logAttestation(registry, 'store', id, { key, namespace, hasEmbedding: !!embeddingJson });
+        // Update statusline vector stats cache (debounced)
+        if (embeddingJson)
+            refreshVectorStatsCache();
         return {
             success: true,
             id,
@@ -690,6 +693,9 @@ export async function bridgeDeleteEntry(options) {
         catch {
             // Non-fatal
         }
+        // Update statusline vector stats cache (debounced)
+        if (changes > 0)
+            refreshVectorStatsCache();
         return {
             success: true,
             deleted: changes > 0,
@@ -1547,4 +1553,64 @@ function cosineSim(a, b) {
     const mag = Math.sqrt(normA * normB);
     return mag === 0 ? 0 : dot / mag;
 }
+// ===== Vector stats cache for statusline =====
+// Written after memory mutations so the statusline can read stats without
+// spawning a subprocess. Debounced to avoid thrashing during batch operations.
+/**
+ * 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 function refreshVectorStatsCache(dbPathOverride) {
+    try {
+        const registry = registryInstance; // Use existing instance only, don't init
+        if (!registry)
+            return;
+        const ctx = getDb(registry);
+        if (!ctx?.db)
+            return;
+        let vectorCount = 0;
+        let namespaces = 0;
+        let dbSizeKB = 0;
+        let hasHnsw = false;
+        try {
+            const countRow = ctx.db.prepare('SELECT COUNT(*) as c FROM memory_entries WHERE status = ? AND embedding IS NOT NULL').get('active');
+            vectorCount = countRow?.c ?? 0;
+            const nsRow = ctx.db.prepare('SELECT COUNT(DISTINCT namespace) as n FROM memory_entries WHERE status = ?').get('active');
+            namespaces = nsRow?.n ?? 0;
+        }
+        catch {
+            // Table may not exist yet
+        }
+        // DB file size
+        const dbFile = dbPathOverride || getDbPath();
+        try {
+            const stat = fs.statSync(dbFile);
+            dbSizeKB = Math.floor(stat.size / 1024);
+        }
+        catch { /* file may not exist */ }
+        // HNSW index presence
+        const root = getProjectRoot();
+        const hnswPaths = [
+            path.join(root, '.swarm', 'hnsw.index'),
+            path.join(root, '.claude-flow', 'hnsw.index'),
+        ];
+        for (const p of hnswPaths) {
+            try {
+                fs.statSync(p);
+                hasHnsw = true;
+                break;
+            }
+            catch { /* nope */ }
+        }
+        // Write cache file
+        const cacheDir = path.join(root, '.claude-flow');
+        if (!fs.existsSync(cacheDir))
+            fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(path.join(cacheDir, 'vector-stats.json'), JSON.stringify({ vectorCount, dbSizeKB, namespaces, hasHnsw, updatedAt: Date.now() }));
+    }
+    catch {
+        // Non-fatal — statusline falls back to file size estimate
+    }
+}
 //# sourceMappingURL=memory-bridge.js.map

package/src/@claude-flow/cli/dist/src/memory/memory-initializer.js

@@ -10,6 +10,41 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+/**
+ * Write vector-stats.json cache for the statusline (no subprocess needed).
+ * Called after memory store/delete to keep the cache fresh.
+ * @param dbPath - path to the SQLite database file
+ * @param stats  - optional exact counts from a db query already in progress
+ */
+function writeVectorStatsCache(dbPath, stats) {
+    try {
+        const fileStat = fs.statSync(dbPath);
+        const dbSizeKB = Math.floor(fileStat.size / 1024);
+        const vectorCount = stats?.vectorCount ?? 0;
+        const namespaces = stats?.namespaces ?? 0;
+        // Check HNSW index presence
+        const dbDir = path.dirname(dbPath);
+        const projectDir = path.dirname(dbDir); // .swarm -> project root
+        let hasHnsw = false;
+        for (const p of [
+            path.join(dbDir, 'hnsw.index'),
+            path.join(projectDir, '.claude-flow', 'hnsw.index'),
+        ]) {
+            try {
+                fs.statSync(p);
+                hasHnsw = true;
+                break;
+            }
+            catch { /* nope */ }
+        }
+        // Write to .claude-flow dir next to the .swarm dir
+        const cacheDir = path.join(projectDir, '.claude-flow');
+        if (!fs.existsSync(cacheDir))
+            fs.mkdirSync(cacheDir, { recursive: true });
+        fs.writeFileSync(path.join(cacheDir, 'vector-stats.json'), JSON.stringify({ vectorCount, dbSizeKB, namespaces, hasHnsw, updatedAt: Date.now() }));
+    }
+    catch { /* Non-fatal */ }
+}
 // ADR-053: Lazy import of AgentDB v3 bridge
 let _bridge;
 async function getBridge() {
@@ -1747,8 +1782,13 @@ export async function storeEntry(options) {
     const bridge = await getBridge();
     if (bridge) {
         const bridgeResult = await bridge.bridgeStoreEntry(options);
-        if (bridgeResult)
+        if (bridgeResult) {
+            // Update statusline cache after successful bridge store
+            const swarmDir = path.join(process.cwd(), '.swarm');
+            const dbFile = options.dbPath || path.join(swarmDir, 'memory.db');
+            writeVectorStatsCache(dbFile);
             return bridgeResult;
+        }
     }
     // Fallback: raw sql.js
     const { key, value, namespace = 'default', generateEmbeddingFlag = true, tags = [], ttl, dbPath: customPath, upsert = false } = options;
@@ -1805,6 +1845,15 @@ export async function storeEntry(options) {
         // Save
         const data = db.export();
         fs.writeFileSync(dbPath, Buffer.from(data));
+        // Query exact stats while DB is still open
+        let vecCount = 0, nsCount = 0;
+        try {
+            const vc = db.exec("SELECT COUNT(*) FROM memory_entries WHERE status='active' AND embedding IS NOT NULL");
+            vecCount = vc[0]?.values?.[0]?.[0] ?? 0;
+            const nc = db.exec("SELECT COUNT(DISTINCT namespace) FROM memory_entries WHERE status='active'");
+            nsCount = nc[0]?.values?.[0]?.[0] ?? 0;
+        }
+        catch { /* table may not have status column in older DBs */ }
         db.close();
         // Add to HNSW index for faster future searches
         if (embeddingJson) {
@@ -1816,6 +1865,8 @@ export async function storeEntry(options) {
                 content: value
             });
         }
+        // Update statusline cache with exact counts
+        writeVectorStatsCache(dbPath, { vectorCount: vecCount, namespaces: nsCount });
         return {
             success: true,
             id,

package/src/@claude-flow/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moflo/cli",
-  "version": "4.7.6",
+  "version": "4.7.8",
   "type": "module",
   "description": "MoFlo CLI — AI agent orchestration with specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -81,18 +81,14 @@
     "publish:all": "./scripts/publish.sh"
   },
   "devDependencies": {
-    "typescript": "^5.3.0",
-    "vitest": "^4.0.16"
+    "typescript": "^5.3.0"
   },
   "dependencies": {
-    "@claude-flow/mcp": "^3.0.0-alpha.8",
-    "@claude-flow/shared": "^3.0.0-alpha.1",
     "@noble/ed25519": "^2.1.0",
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
     "@claude-flow/aidefence": "^3.0.2",
-    "@claude-flow/codex": "^3.0.0-alpha.8",
     "@claude-flow/embeddings": "^3.0.0-alpha.12",
     "@claude-flow/guidance": "^3.0.0-alpha.1",
     "@claude-flow/memory": "^3.0.0-alpha.11",