claude-flow 3.5.78 → 3.5.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.78",
+  "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/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/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.78",
+  "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",