claude-flow 3.5.79 → 3.5.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.79",
+  "version": "3.5.80",
   "description": "Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/v3/@claude-flow/cli/dist/src/commands/index.d.ts

@@ -83,6 +83,13 @@ export declare function getCommandAsync(name: string): Promise<Command | undefin
  * Check if command exists (sync check for core commands)
  */
 export declare function hasCommand(name: string): boolean;
+/**
+ * Get the names of all lazy-loadable commands (the commandLoaders keys).
+ * Used by the CLI constructor to register these names with the parser so
+ * the two-pass argument walker can recognize them as commands before their
+ * modules have been imported. Fix for #1596.
+ */
+export declare function getLazyCommandNames(): string[];
 /**
  * Get all command names (including aliases and lazy-loadable)
  */

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

@@ -280,6 +280,15 @@ export async function getCommandAsync(name) {
 export function hasCommand(name) {
     return loadedCommands.has(name) || commandRegistry.has(name) || name in commandLoaders;
 }
+/**
+ * Get the names of all lazy-loadable commands (the commandLoaders keys).
+ * Used by the CLI constructor to register these names with the parser so
+ * the two-pass argument walker can recognize them as commands before their
+ * modules have been imported. Fix for #1596.
+ */
+export function getLazyCommandNames() {
+    return Object.keys(commandLoaders);
+}
 /**
  * Get all command names (including aliases and lazy-loadable)
  */

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

@@ -231,12 +231,8 @@ const initAction = async (ctx) => {
         }
         output.printBox(summary.join('\n'), 'Summary');
         output.writeln();
-        // Show what was created (honest about skip-claude — #1597)
-        if (skipClaude) {
-            output.printBox('Skipped (--skip-claude): no files written under .claude/ or ~/.claude/', 'Claude Code Integration');
-            output.writeln();
-        }
-        else if (options.components.claudeMd || options.components.settings || options.components.skills || options.components.commands || options.components.agents) {
+        // Show what was created
+        if (options.components.claudeMd || options.components.settings || options.components.skills || options.components.commands || options.components.agents) {
             output.printBox([
                 options.components.claudeMd ? `CLAUDE.md:   Swarm guidance & configuration` : '',
                 options.components.settings ? `Settings:    .claude/settings.json` : '',
@@ -913,7 +909,7 @@ export const initCommand = {
         },
         {
             name: 'skip-claude',
-            description: 'Skip all .claude/ writes including global ~/.claude/CLAUDE.md (runtime only)',
+            description: 'Skip .claude/ directory creation (runtime only)',
             type: 'boolean',
             default: false,
         },

package/v3/@claude-flow/cli/dist/src/index.js

@@ -9,7 +9,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { commandParser } from './parser.js';
 import { output } from './output.js';
-import { commands, getCommandsByCategory, getCommand, getCommandAsync, getCommandNames, hasCommand } from './commands/index.js';
+import { commands, getCommandsByCategory, getCommand, getCommandAsync, getCommandNames, getLazyCommandNames, hasCommand } from './commands/index.js';
 import { suggestCommand } from './suggest.js';
 import { runStartupUpdateCheck } from './update/index.js';
 // Read version from package.json at runtime
@@ -44,10 +44,16 @@ export class CLI {
         this.parser = commandParser;
         this.output = output;
         this.interactive = options.interactive ?? process.stdin.isTTY ?? false;
-        // Register all commands
+        // Register all core (synchronously loaded) commands with full definitions
         for (const cmd of commands) {
             this.parser.registerCommand(cmd);
         }
+        // Register lazy command names so the parser can recognize them during
+        // argument resolution without importing their modules. Fix for #1596:
+        // prevents `daemon start` from being mis-routed to the `start` command.
+        for (const name of getLazyCommandNames()) {
+            this.parser.registerLazyCommandName(name);
+        }
     }
     /**
      * Run the CLI with given arguments

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

@@ -1663,11 +1663,6 @@ async function writeClaudeMd(targetDir, options, result) {
         result.created.files.push('CLAUDE.md');
     }
     // Also write/append global ~/.claude/CLAUDE.md so ruflo tools are used automatically (#1497)
-    // Guarded to never overwrite user content and to respect opt-out env var (#1597).
-    // Opt out entirely with CLAUDE_FLOW_SKIP_GLOBAL_CLAUDE_MD=1.
-    if (process.env.CLAUDE_FLOW_SKIP_GLOBAL_CLAUDE_MD === '1') {
-        return;
-    }
     const homeDir = process.env.HOME || process.env.USERPROFILE || '';
     if (homeDir) {
         const globalClaudeDir = path.join(homeDir, '.claude');
@@ -1687,13 +1682,8 @@ async function writeClaudeMd(targetDir, options, result) {
             if (fs.existsSync(globalClaudeMd)) {
                 const existing = fs.readFileSync(globalClaudeMd, 'utf-8');
                 if (!existing.includes('Ruflo Integration')) {
-                    // Always back up existing user content before any modification (#1597).
-                    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-                    const backupPath = `${globalClaudeMd}.backup-${timestamp}`;
-                    fs.copyFileSync(globalClaudeMd, backupPath);
                     fs.appendFileSync(globalClaudeMd, rufloBlock);
                     result.created.files.push('~/.claude/CLAUDE.md (appended ruflo block)');
-                    result.created.files.push(`~/.claude/CLAUDE.md.backup-${timestamp} (backup of pre-existing content)`);
                 }
             }
             else {

package/v3/@claude-flow/cli/dist/src/mcp-tools/types.d.ts

@@ -18,28 +18,11 @@ export interface MCPToolResult {
     isError?: boolean;
 }
 /**
- * Returns the effective project working directory for storage path resolution.
- *
- * Resolution order (#1577):
- *   1. CLAUDE_FLOW_PROJECT_DIR — explicit ruflo project override
- *   2. CLAUDE_FLOW_CWD — legacy ruflo override set by install script
- *   3. CLAUDE_PROJECT_DIR — Claude Code's native project dir env var
- *   4. INIT_CWD — npm's original invocation dir
- *   5. process.cwd() — if it is not a system directory
- *   6. os.homedir() — safe fallback
- *
- * System directories (e.g. C:\Windows\System32 on Windows, where MCP servers
- * spawned by AI agents commonly inherit cwd) are rejected at every step.
- *
- * Only use this for storage path resolution. When the actual runtime working
- * directory matters (e.g. child process cwd, user-facing status), call
- * process.cwd() directly.
+ * Returns the effective project working directory.
+ * Prefers CLAUDE_FLOW_CWD (set by the install script for global/MCP installs
+ * where process.cwd() may resolve to '/') over the real process.cwd().
  */
 export declare function getProjectCwd(): string;
-/**
- * Reset cached value. Intended for tests only.
- */
-export declare function __resetProjectCwdCache(): void;
 export interface MCPTool {
     name: string;
     description: string;

package/v3/@claude-flow/cli/dist/src/mcp-tools/types.js

@@ -3,73 +3,12 @@
  *
  * Local type definitions to avoid external imports outside package boundary.
  */
-import { homedir } from 'node:os';
-// System directories that must not be used for project storage (#1577).
-// On Windows, MCP servers spawned by AI agents often inherit System32 as cwd
-// — writing there fails with EPERM.
-const SYSTEM_DIR_PREFIXES = [
-    'c:\\windows',
-    'c:/windows',
-    '/windows/system32',
-];
-function isSystemDir(dir) {
-    if (!dir)
-        return true;
-    const lower = dir.toLowerCase().replace(/\\/g, '/');
-    return SYSTEM_DIR_PREFIXES.some((p) => lower.startsWith(p.replace(/\\/g, '/')));
-}
-let _cachedProjectCwd;
 /**
- * Returns the effective project working directory for storage path resolution.
- *
- * Resolution order (#1577):
- *   1. CLAUDE_FLOW_PROJECT_DIR — explicit ruflo project override
- *   2. CLAUDE_FLOW_CWD — legacy ruflo override set by install script
- *   3. CLAUDE_PROJECT_DIR — Claude Code's native project dir env var
- *   4. INIT_CWD — npm's original invocation dir
- *   5. process.cwd() — if it is not a system directory
- *   6. os.homedir() — safe fallback
- *
- * System directories (e.g. C:\Windows\System32 on Windows, where MCP servers
- * spawned by AI agents commonly inherit cwd) are rejected at every step.
- *
- * Only use this for storage path resolution. When the actual runtime working
- * directory matters (e.g. child process cwd, user-facing status), call
- * process.cwd() directly.
+ * Returns the effective project working directory.
+ * Prefers CLAUDE_FLOW_CWD (set by the install script for global/MCP installs
+ * where process.cwd() may resolve to '/') over the real process.cwd().
  */
 export function getProjectCwd() {
-    if (_cachedProjectCwd !== undefined)
-        return _cachedProjectCwd;
-    const envKeys = [
-        'CLAUDE_FLOW_PROJECT_DIR',
-        'CLAUDE_FLOW_CWD',
-        'CLAUDE_PROJECT_DIR',
-        'INIT_CWD',
-    ];
-    for (const key of envKeys) {
-        const val = process.env[key];
-        if (val && !isSystemDir(val)) {
-            _cachedProjectCwd = val;
-            return _cachedProjectCwd;
-        }
-    }
-    try {
-        const cwd = process.cwd();
-        if (!isSystemDir(cwd)) {
-            _cachedProjectCwd = cwd;
-            return _cachedProjectCwd;
-        }
-    }
-    catch {
-        // process.cwd() can throw ENOENT if the cwd was deleted — fall through.
-    }
-    _cachedProjectCwd = homedir();
-    return _cachedProjectCwd;
-}
-/**
- * Reset cached value. Intended for tests only.
- */
-export function __resetProjectCwdCache() {
-    _cachedProjectCwd = undefined;
+    return process.env.CLAUDE_FLOW_CWD || process.cwd();
 }
 //# sourceMappingURL=types.js.map

package/v3/@claude-flow/cli/dist/src/mcp-tools/validate-input.js

@@ -113,18 +113,25 @@ export async function validateAgentSpawn(input) {
         if (!r.valid)
             errors.push(r.error);
     }
-    // Try enhanced Zod validation if available
+    // Try enhanced Zod validation if available.
+    // Fix for #1567: @claude-flow/security's SpawnAgentSchema expects `type` and
+    // `id` (not `agentType`/`name`), so the previous call always failed with
+    // "type: Required". Also swallow `invalid_enum_value` errors because the
+    // schema enumerates only 15 built-in agent types — we support custom types
+    // (the inline validator already checked the identifier is safe).
     const sec = await getSecurityModule();
     if (sec?.SpawnAgentSchema) {
         try {
             sec.SpawnAgentSchema.parse({
-                agentType: input.agentType,
-                name: input.agentId,
+                type: input.agentType,
+                id: input.agentId,
             });
         }
         catch (zodErr) {
             if (zodErr.issues) {
                 for (const issue of zodErr.issues) {
+                    if (issue.code === 'invalid_enum_value')
+                        continue;
                     errors.push(`${issue.path.join('.')}: ${issue.message}`);
                 }
             }

package/v3/@claude-flow/cli/dist/src/parser.d.ts

@@ -21,10 +21,19 @@ export interface ParserOptions {
 export declare class CommandParser {
     private options;
     private commands;
+    private lazyCommandNames;
     private globalOptions;
     constructor(options?: ParserOptions);
     private initializeGlobalOptions;
     registerCommand(command: Command): void;
+    /**
+     * Register a lazy-loaded command's name so Pass 1/Pass 2 can recognize it as
+     * a command position even though its full definition hasn't been loaded yet.
+     * Fix for #1596: without this, lazy commands like `daemon start` were
+     * mis-routed because Pass 1 walked past `daemon` and greedy-matched `start`.
+     */
+    registerLazyCommandName(name: string): void;
+    private isKnownCommandName;
     getCommand(name: string): Command | undefined;
     getAllCommands(): Command[];
     parse(args: string[]): ParseResult;

package/v3/@claude-flow/cli/dist/src/parser.js

@@ -5,6 +5,7 @@
 export class CommandParser {
     options;
     commands = new Map();
+    lazyCommandNames = new Set();
     globalOptions = [];
     constructor(options = {}) {
         this.options = {
@@ -83,6 +84,18 @@ export class CommandParser {
             }
         }
     }
+    /**
+     * Register a lazy-loaded command's name so Pass 1/Pass 2 can recognize it as
+     * a command position even though its full definition hasn't been loaded yet.
+     * Fix for #1596: without this, lazy commands like `daemon start` were
+     * mis-routed because Pass 1 walked past `daemon` and greedy-matched `start`.
+     */
+    registerLazyCommandName(name) {
+        this.lazyCommandNames.add(name);
+    }
+    isKnownCommandName(name) {
+        return this.commands.has(name) || this.lazyCommandNames.has(name);
+    }
     getCommand(name) {
         return this.commands.get(name);
     }
@@ -103,16 +116,33 @@ export class CommandParser {
             positional: [],
             raw: [...args]
         };
-        // Pass 1: Identify command and subcommand (skip flags)
+        // Pass 1: Identify command and subcommand (skip flags).
+        // Fix for #1596: the first non-flag positional is ALWAYS the command slot.
+        // If it's a known command (sync or lazy) we resolve it; otherwise we stop
+        // searching — we MUST NOT walk past it and greedy-match a later arg as the
+        // command, because that's what caused `daemon start` to resolve as `start`
+        // with `daemon` left as a positional.
         let resolvedCmd;
         let resolvedSub;
+        let sawFirstPositional = false;
         for (const arg of args) {
             if (arg.startsWith('-'))
                 continue;
-            if (!resolvedCmd && this.commands.has(arg)) {
-                resolvedCmd = this.commands.get(arg);
+            if (!sawFirstPositional) {
+                sawFirstPositional = true;
+                if (this.commands.has(arg)) {
+                    resolvedCmd = this.commands.get(arg);
+                    continue;
+                }
+                // Lazy command: we know its name but not its subcommands. Stop the
+                // walk here — we'll rely on Pass 2 to push it onto commandPath.
+                if (this.lazyCommandNames.has(arg)) {
+                    break;
+                }
+                // Unknown first positional — not a command. Stop walking.
+                break;
             }
-            else if (resolvedCmd && !resolvedSub && resolvedCmd.subcommands) {
+            if (resolvedCmd && !resolvedSub && resolvedCmd.subcommands) {
                 resolvedSub = resolvedCmd.subcommands.find(sc => sc.name === arg || sc.aliases?.includes(arg));
             }
         }
@@ -138,11 +168,15 @@ export class CommandParser {
                 i = parseResult.nextIndex;
                 continue;
             }
-            // Handle positional arguments
-            if (result.command.length === 0 && this.commands.has(arg)) {
+            // Handle positional arguments.
+            // Fix for #1596: treat lazy command names as commands here too so that
+            // downstream dispatch sees `commandPath = ['daemon', 'start']` instead of
+            // `commandPath = ['start'], positional = ['daemon']`.
+            if (result.command.length === 0 && this.isKnownCommandName(arg)) {
                 // This is a command
                 result.command.push(arg);
-                // Check for subcommand (level 1)
+                // Check for subcommand (level 1) — only possible for sync commands
+                // whose subcommand definitions are already loaded.
                 const cmd = this.commands.get(arg);
                 if (cmd?.subcommands && i + 1 < args.length) {
                     const nextArg = args[i + 1];

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.79",
+  "version": "3.5.80",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",
@@ -115,7 +115,8 @@
     "@ruvector/rvagent-wasm": "^0.1.0",
     "@ruvector/diskann": "^0.1.0",
     "@ruvector/sona": "^0.1.5",
-    "agentdb": "^3.0.0-alpha.11"
+    "agentdb": "^3.0.0-alpha.11",
+    "agentic-flow": "^3.0.0-alpha.1"
   },
   "publishConfig": {
     "access": "public",