claude-flow 3.5.42 → 3.5.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "3.5.42",
+  "version": "3.5.43",
   "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/claims.js

@@ -18,29 +18,14 @@ const listCommand = {
         { command: 'claude-flow claims list', description: 'List all claims' },
         { command: 'claude-flow claims list -u user123', description: 'List user claims' },
     ],
-    action: async (ctx) => {
+    action: async (_ctx) => {
+        // #1425: This command is not yet implemented — was displaying hardcoded fake claims
         output.writeln();
-        output.writeln(output.bold('Claims & Permissions'));
-        output.writeln(output.dim('─'.repeat(70)));
-        output.printTable({
-            columns: [
-                { key: 'claim', header: 'Claim', width: 25 },
-                { key: 'type', header: 'Type', width: 12 },
-                { key: 'scope', header: 'Scope', width: 15 },
-                { key: 'value', header: 'Value', width: 20 },
-            ],
-            data: [
-                { claim: 'swarm:create', type: 'Permission', scope: 'Global', value: output.success('Allowed') },
-                { claim: 'swarm:delete', type: 'Permission', scope: 'Owned', value: output.success('Allowed') },
-                { claim: 'agent:spawn', type: 'Permission', scope: 'Global', value: output.success('Allowed') },
-                { claim: 'memory:read', type: 'Permission', scope: 'Namespace', value: output.success('Allowed') },
-                { claim: 'memory:write', type: 'Permission', scope: 'Namespace', value: output.success('Allowed') },
-                { claim: 'admin:*', type: 'Permission', scope: 'Global', value: output.error('Denied') },
-                { claim: 'role', type: 'Identity', scope: 'System', value: 'developer' },
-                { claim: 'tier', type: 'Identity', scope: 'System', value: 'pro' },
-            ],
-        });
-        return { success: true };
+        output.printError('claims list is not yet implemented');
+        output.writeln(output.dim('Claims listing requires reading from claims config file.'));
+        output.writeln(output.dim('Use "claims check -c <claim>" to evaluate a specific claim.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Check subcommand
@@ -201,19 +186,12 @@ const grantCommand = {
             output.printError('Either user or role is required');
             return { success: false, exitCode: 1 };
         }
+        // #1425: This command is not yet implemented — was faking claim grant
         output.writeln();
-        const spinner = output.createSpinner({ text: 'Granting claim...', spinner: 'dots' });
-        spinner.start();
-        await new Promise(r => setTimeout(r, 400));
-        spinner.succeed('Claim granted');
-        output.writeln();
-        output.printBox([
-            `Claim: ${claim}`,
-            `Target: ${user ? `User: ${user}` : `Role: ${role}`}`,
-            `Scope: ${scope}`,
-            `Status: ${output.success('Active')}`,
-        ].join('\n'), 'Grant Complete');
-        return { success: true };
+        output.printError('claims grant is not yet implemented');
+        output.writeln(output.dim(`Cannot grant "${claim}" — claims persistence not yet built.`));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Revoke subcommand
@@ -237,12 +215,12 @@ const revokeCommand = {
             output.printError('Claim is required');
             return { success: false, exitCode: 1 };
         }
+        // #1425: This command is not yet implemented — was faking claim revocation
         output.writeln();
-        const spinner = output.createSpinner({ text: 'Revoking claim...', spinner: 'dots' });
-        spinner.start();
-        await new Promise(r => setTimeout(r, 300));
-        spinner.succeed('Claim revoked');
-        return { success: true };
+        output.printError('claims revoke is not yet implemented');
+        output.writeln(output.dim(`Cannot revoke "${claim}" — claims persistence not yet built.`));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Roles subcommand
@@ -257,45 +235,13 @@ const rolesCommand = {
         { command: 'claude-flow claims roles', description: 'List all roles' },
         { command: 'claude-flow claims roles -a show -n admin', description: 'Show role details' },
     ],
-    action: async (ctx) => {
-        const action = ctx.flags.action || 'list';
-        const name = ctx.flags.name;
+    action: async (_ctx) => {
+        // #1425: This command is not yet implemented — was displaying hardcoded fake roles
         output.writeln();
-        output.writeln(output.bold('Roles'));
-        output.writeln(output.dim('─'.repeat(60)));
-        if (action === 'show' && name) {
-            output.printBox([
-                `Role: ${name}`,
-                `Description: Full system access`,
-                ``,
-                `Claims:`,
-                `  - swarm:* (all swarm operations)`,
-                `  - agent:* (all agent operations)`,
-                `  - memory:* (all memory operations)`,
-                `  - admin:* (administrative functions)`,
-                ``,
-                `Members: 2`,
-                `Created: 2024-01-01`,
-            ].join('\n'), 'Role Details');
-        }
-        else {
-            output.printTable({
-                columns: [
-                    { key: 'role', header: 'Role', width: 15 },
-                    { key: 'description', header: 'Description', width: 30 },
-                    { key: 'claims', header: 'Claims', width: 12 },
-                    { key: 'members', header: 'Members', width: 10 },
-                ],
-                data: [
-                    { role: output.highlight('admin'), description: 'Full system access', claims: '15', members: '2' },
-                    { role: output.highlight('developer'), description: 'Development operations', claims: '10', members: '12' },
-                    { role: output.highlight('operator'), description: 'Operational tasks', claims: '8', members: '5' },
-                    { role: output.highlight('viewer'), description: 'Read-only access', claims: '3', members: '25' },
-                    { role: output.highlight('guest'), description: 'Limited access', claims: '1', members: '100' },
-                ],
-            });
-        }
-        return { success: true };
+        output.printError('claims roles is not yet implemented');
+        output.writeln(output.dim('Role management requires claims config persistence not yet built.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Policies subcommand
@@ -310,26 +256,13 @@ const policiesCommand = {
         { command: 'claude-flow claims policies', description: 'List policies' },
         { command: 'claude-flow claims policies -a create -n rate-limit', description: 'Create policy' },
     ],
-    action: async (ctx) => {
+    action: async (_ctx) => {
+        // #1425: This command is not yet implemented — was displaying hardcoded fake policies
         output.writeln();
-        output.writeln(output.bold('Claim Policies'));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.printTable({
-            columns: [
-                { key: 'policy', header: 'Policy', width: 20 },
-                { key: 'type', header: 'Type', width: 15 },
-                { key: 'condition', header: 'Condition', width: 30 },
-                { key: 'status', header: 'Status', width: 12 },
-            ],
-            data: [
-                { policy: 'rate-limit', type: 'Throttle', condition: 'Max 100 req/min', status: output.success('Active') },
-                { policy: 'geo-restrict', type: 'Location', condition: 'US, EU only', status: output.success('Active') },
-                { policy: 'time-window', type: 'Temporal', condition: 'Business hours', status: output.dim('Inactive') },
-                { policy: 'ip-allowlist', type: 'Network', condition: '10.0.0.0/8', status: output.success('Active') },
-                { policy: 'mfa-required', type: 'Auth', condition: 'Admin operations', status: output.success('Active') },
-            ],
-        });
-        return { success: true };
+        output.printError('claims policies is not yet implemented');
+        output.writeln(output.dim('Policy management requires claims config persistence not yet built.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Main claims command

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

@@ -3,7 +3,6 @@
  * Configuration management
  */
 import { output } from '../output.js';
-import { confirm } from '../prompt.js';
 // Init configuration
 const initCommand = {
     name: 'init',
@@ -29,77 +28,14 @@ const initCommand = {
             default: true
         }
     ],
-    action: async (ctx) => {
-        const sparc = ctx.flags.sparc;
-        const v3 = ctx.flags.v3;
-        output.writeln();
-        output.printInfo('Initializing RuFlo configuration...');
-        output.writeln();
-        // Create default configuration
-        const config = {
-            version: '3.0.0',
-            v3Mode: v3,
-            sparc: sparc,
-            agents: {
-                defaultType: 'coder',
-                maxConcurrent: 15,
-                autoSpawn: true,
-                timeout: 300
-            },
-            swarm: {
-                topology: 'hybrid',
-                maxAgents: 15,
-                autoScale: true,
-                coordinationStrategy: 'consensus'
-            },
-            memory: {
-                backend: 'hybrid',
-                path: './data/memory',
-                cacheSize: 256,
-                enableHNSW: true
-            },
-            mcp: {
-                transport: 'stdio',
-                autoStart: true,
-                tools: 'all'
-            },
-            providers: [
-                { name: 'anthropic', priority: 1, enabled: true },
-                { name: 'openrouter', priority: 2, enabled: false },
-                { name: 'ollama', priority: 3, enabled: false }
-            ]
-        };
-        output.writeln(output.dim('  Creating claude-flow.config.json...'));
-        output.writeln(output.dim('  Creating .claude-flow/ directory...'));
-        if (sparc) {
-            output.writeln(output.dim('  Initializing SPARC methodology...'));
-            output.writeln(output.dim('  Creating SPARC workflow files...'));
-        }
-        if (v3) {
-            output.writeln(output.dim('  Enabling V3 15-agent coordination...'));
-            output.writeln(output.dim('  Configuring AgentDB integration...'));
-            output.writeln(output.dim('  Setting up Flash Attention optimization...'));
-        }
+    action: async (_ctx) => {
+        // #1425: This command is not yet implemented — was faking file creation
         output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'setting', header: 'Setting', width: 25 },
-                { key: 'value', header: 'Value', width: 30 }
-            ],
-            data: [
-                { setting: 'Version', value: config.version },
-                { setting: 'V3 Mode', value: config.v3Mode ? 'Enabled' : 'Disabled' },
-                { setting: 'SPARC Mode', value: config.sparc ? 'Enabled' : 'Disabled' },
-                { setting: 'Swarm Topology', value: config.swarm.topology },
-                { setting: 'Max Agents', value: config.swarm.maxAgents },
-                { setting: 'Memory Backend', value: config.memory.backend },
-                { setting: 'MCP Transport', value: config.mcp.transport }
-            ]
-        });
-        output.writeln();
-        output.printSuccess('Configuration initialized');
-        output.writeln(output.dim('  Config file: ./claude-flow.config.json'));
-        return { success: true, data: config };
+        output.printError('config init is not yet implemented');
+        output.writeln(output.dim('Configuration files are not actually created by this command yet.'));
+        output.writeln(output.dim('Use the project wizard instead: npx claude-flow@v3alpha init --wizard'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     }
 };
 // Get configuration
@@ -196,9 +132,12 @@ const setCommand = {
             output.printError('Both key and value are required');
             return { success: false, exitCode: 1 };
         }
-        output.printInfo(`Setting ${key} = ${value}`);
-        output.printSuccess('Configuration updated');
-        return { success: true, data: { key, value } };
+        // #1425: This command is not yet implemented — was faking config persistence
+        output.writeln();
+        output.printError('config set is not yet implemented');
+        output.writeln(output.dim(`Cannot persist ${key} = ${value} — config file write not implemented.`));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     }
 };
 // List providers
@@ -280,22 +219,13 @@ const resetCommand = {
             choices: ['agents', 'swarm', 'memory', 'mcp', 'providers', 'all']
         }
     ],
-    action: async (ctx) => {
-        const force = ctx.flags.force;
-        const section = ctx.flags.section || 'all';
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Reset ${section} configuration to defaults?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        output.printInfo(`Resetting ${section} configuration...`);
-        output.printSuccess('Configuration reset to defaults');
-        return { success: true, data: { section, reset: true } };
+    action: async (_ctx) => {
+        // #1425: This command is not yet implemented — was faking config reset
+        output.writeln();
+        output.printError('config reset is not yet implemented');
+        output.writeln(output.dim('Configuration reset requires config file read/write support.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     }
 };
 // Export configuration
@@ -318,21 +248,13 @@ const exportCommand = {
             choices: ['json', 'yaml']
         }
     ],
-    action: async (ctx) => {
-        const outputPath = ctx.flags.output || './claude-flow.config.export.json';
-        const config = {
-            version: '3.0.0',
-            exportedAt: new Date().toISOString(),
-            agents: { defaultType: 'coder', maxConcurrent: 15 },
-            swarm: { topology: 'hybrid', maxAgents: 15 },
-            memory: { backend: 'hybrid', cacheSize: 256 },
-            mcp: { transport: 'stdio', tools: 'all' }
-        };
-        output.printInfo(`Exporting configuration to ${outputPath}...`);
-        output.printJson(config);
+    action: async (_ctx) => {
+        // #1425: This command is not yet implemented — was faking config export
         output.writeln();
-        output.printSuccess('Configuration exported');
-        return { success: true, data: { path: outputPath, config } };
+        output.printError('config export is not yet implemented');
+        output.writeln(output.dim('Configuration export requires config file read support.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     }
 };
 // Import configuration
@@ -356,20 +278,16 @@ const importCommand = {
     ],
     action: async (ctx) => {
         const file = ctx.flags.file || ctx.args[0];
-        const merge = ctx.flags.merge;
         if (!file) {
             output.printError('File path is required');
             return { success: false, exitCode: 1 };
         }
-        output.printInfo(`Importing configuration from ${file}...`);
-        if (merge) {
-            output.writeln(output.dim('  Merging with existing configuration...'));
-        }
-        else {
-            output.writeln(output.dim('  Replacing existing configuration...'));
-        }
-        output.printSuccess('Configuration imported');
-        return { success: true, data: { file, merge, imported: true } };
+        // #1425: This command is not yet implemented — was faking config import
+        output.writeln();
+        output.printError('config import is not yet implemented');
+        output.writeln(output.dim(`Cannot import from ${file} — config file read/write not implemented.`));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     }
 };
 // Main config command

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

@@ -21,42 +21,12 @@ const deployCommand = {
         { command: 'claude-flow deployment deploy --dry-run', description: 'Simulate deployment' },
     ],
     action: async (ctx) => {
-        const env = ctx.flags.env || 'staging';
-        const version = ctx.flags.version || 'latest';
-        const dryRun = ctx.flags['dry-run'];
+        // #1425: This command is not yet implemented — was returning hardcoded fake responses
         output.writeln();
-        output.writeln(output.bold(`Deployment: ${env.toUpperCase()}`));
-        output.writeln(output.dim('─'.repeat(50)));
-        if (dryRun) {
-            output.printWarning('DRY RUN - No changes will be made');
-            output.writeln();
-        }
-        const steps = [
-            { name: 'Pre-flight checks', status: 'running' },
-            { name: 'Build artifacts', status: 'pending' },
-            { name: 'Run tests', status: 'pending' },
-            { name: 'Security scan', status: 'pending' },
-            { name: 'Deploy to target', status: 'pending' },
-            { name: 'Health checks', status: 'pending' },
-            { name: 'DNS update', status: 'pending' },
-        ];
-        for (const step of steps) {
-            const spinner = output.createSpinner({ text: step.name + '...', spinner: 'dots' });
-            spinner.start();
-            await new Promise(r => setTimeout(r, 400));
-            spinner.succeed(step.name);
-        }
-        output.writeln();
-        output.printBox([
-            `Environment: ${env}`,
-            `Version: ${version}`,
-            `Status: ${output.success('Deployed')}`,
-            ``,
-            `URL: https://${env === 'prod' ? 'api' : env}.claude-flow.io`,
-            `Deployed at: ${new Date().toISOString()}`,
-            `Duration: 12.4s`,
-        ].join('\n'), 'Deployment Complete');
-        return { success: true };
+        output.printError('deployment deploy is not yet implemented');
+        output.writeln(output.dim('This command will be implemented in a future release.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Status subcommand
@@ -72,25 +42,12 @@ const statusCommand = {
         { command: 'claude-flow deployment status -e prod', description: 'Check production' },
     ],
     action: async (ctx) => {
+        // #1425: This command is not yet implemented — was returning hardcoded fake data
         output.writeln();
-        output.writeln(output.bold('Deployment Status'));
-        output.writeln(output.dim('─'.repeat(70)));
-        output.printTable({
-            columns: [
-                { key: 'env', header: 'Environment', width: 12 },
-                { key: 'version', header: 'Version', width: 18 },
-                { key: 'status', header: 'Status', width: 12 },
-                { key: 'health', header: 'Health', width: 10 },
-                { key: 'deployed', header: 'Deployed', width: 20 },
-            ],
-            data: [
-                { env: 'Production', version: 'v3.0.0-alpha.10', status: output.success('Active'), health: output.success('100%'), deployed: '2h ago' },
-                { env: 'Staging', version: 'v3.0.0-alpha.11', status: output.success('Active'), health: output.success('100%'), deployed: '30m ago' },
-                { env: 'Development', version: 'v3.0.0-alpha.12', status: output.success('Active'), health: output.success('100%'), deployed: '5m ago' },
-                { env: 'Preview', version: 'pr-456', status: output.warning('Deploying'), health: output.dim('--'), deployed: 'In progress' },
-            ],
-        });
-        return { success: true };
+        output.printError('deployment status is not yet implemented');
+        output.writeln(output.dim('This command will be implemented in a future release.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Rollback subcommand
@@ -107,32 +64,12 @@ const rollbackCommand = {
         { command: 'claude-flow deployment rollback -e prod -v v3.0.0', description: 'Rollback to specific version' },
     ],
     action: async (ctx) => {
-        const env = ctx.flags.env;
-        const version = ctx.flags.version;
-        if (!env) {
-            output.printError('Environment is required for rollback');
-            return { success: false, exitCode: 1 };
-        }
-        output.writeln();
-        output.writeln(output.bold(`Rollback: ${env.toUpperCase()}`));
-        output.writeln(output.dim('─'.repeat(40)));
-        output.printWarning(`Rolling back ${env} to ${version || 'previous version'}`);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Initiating rollback...', spinner: 'dots' });
-        spinner.start();
-        const steps = ['Stopping current deployment', 'Restoring previous version', 'Running health checks', 'Updating DNS'];
-        for (const step of steps) {
-            spinner.setText(step + '...');
-            await new Promise(r => setTimeout(r, 400));
-        }
-        spinner.succeed('Rollback complete');
+        // #1425: This command is not yet implemented — was returning hardcoded fake responses
         output.writeln();
-        output.printBox([
-            `Environment: ${env}`,
-            `Rolled back to: ${version || 'v3.0.0-alpha.9'}`,
-            `Status: ${output.success('Active')}`,
-        ].join('\n'), 'Rollback Complete');
-        return { success: true };
+        output.printError('deployment rollback is not yet implemented');
+        output.writeln(output.dim('This command will be implemented in a future release.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // History subcommand
@@ -148,28 +85,12 @@ const historyCommand = {
         { command: 'claude-flow deployment history -e prod', description: 'Production history' },
     ],
     action: async (ctx) => {
-        const env = ctx.flags.env;
+        // #1425: This command is not yet implemented — was returning hardcoded fake data
         output.writeln();
-        output.writeln(output.bold(`Deployment History${env ? `: ${env}` : ''}`));
-        output.writeln(output.dim('─'.repeat(80)));
-        output.printTable({
-            columns: [
-                { key: 'id', header: 'ID', width: 10 },
-                { key: 'env', header: 'Env', width: 10 },
-                { key: 'version', header: 'Version', width: 18 },
-                { key: 'status', header: 'Status', width: 12 },
-                { key: 'deployer', header: 'Deployer', width: 12 },
-                { key: 'timestamp', header: 'Timestamp', width: 20 },
-            ],
-            data: [
-                { id: 'dep-123', env: 'prod', version: 'v3.0.0-alpha.10', status: output.success('Success'), deployer: 'ci-bot', timestamp: '2024-01-15 14:30' },
-                { id: 'dep-122', env: 'staging', version: 'v3.0.0-alpha.11', status: output.success('Success'), deployer: 'ci-bot', timestamp: '2024-01-15 14:00' },
-                { id: 'dep-121', env: 'prod', version: 'v3.0.0-alpha.9', status: output.dim('Rolled back'), deployer: 'ci-bot', timestamp: '2024-01-15 12:30' },
-                { id: 'dep-120', env: 'staging', version: 'v3.0.0-alpha.10', status: output.success('Success'), deployer: 'developer', timestamp: '2024-01-15 10:00' },
-                { id: 'dep-119', env: 'dev', version: 'v3.0.0-alpha.10', status: output.error('Failed'), deployer: 'developer', timestamp: '2024-01-15 09:30' },
-            ],
-        });
-        return { success: true };
+        output.printError('deployment history is not yet implemented');
+        output.writeln(output.dim('This command will be implemented in a future release.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Environments subcommand
@@ -186,24 +107,12 @@ const environmentsCommand = {
         { command: 'claude-flow deployment envs -a create -n preview', description: 'Create environment' },
     ],
     action: async (ctx) => {
+        // #1425: This command is not yet implemented — was returning hardcoded fake data
         output.writeln();
-        output.writeln(output.bold('Deployment Environments'));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.printTable({
-            columns: [
-                { key: 'name', header: 'Name', width: 15 },
-                { key: 'url', header: 'URL', width: 30 },
-                { key: 'auto', header: 'Auto Deploy', width: 12 },
-                { key: 'protected', header: 'Protected', width: 12 },
-            ],
-            data: [
-                { name: 'production', url: 'https://api.claude-flow.io', auto: output.error('No'), protected: output.success('Yes') },
-                { name: 'staging', url: 'https://staging.claude-flow.io', auto: output.success('Yes'), protected: output.error('No') },
-                { name: 'development', url: 'https://dev.claude-flow.io', auto: output.success('Yes'), protected: output.error('No') },
-                { name: 'preview/*', url: 'https://pr-*.claude-flow.io', auto: output.success('Yes'), protected: output.error('No') },
-            ],
-        });
-        return { success: true };
+        output.printError('deployment environments is not yet implemented');
+        output.writeln(output.dim('This command will be implemented in a future release.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Logs subcommand
@@ -221,30 +130,12 @@ const logsCommand = {
         { command: 'claude-flow deployment logs -d dep-123', description: 'View specific deployment' },
     ],
     action: async (ctx) => {
-        const env = ctx.flags.env || 'staging';
+        // #1425: This command is not yet implemented — was returning hardcoded fake logs
         output.writeln();
-        output.writeln(output.bold(`Deployment Logs: ${env}`));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.writeln();
-        const logs = [
-            { time: '14:30:01', level: 'INFO', msg: 'Starting deployment v3.0.0-alpha.10' },
-            { time: '14:30:02', level: 'INFO', msg: 'Building Docker image...' },
-            { time: '14:30:15', level: 'INFO', msg: 'Image built: sha256:abc123...' },
-            { time: '14:30:16', level: 'INFO', msg: 'Pushing to registry...' },
-            { time: '14:30:25', level: 'INFO', msg: 'Deploying to kubernetes...' },
-            { time: '14:30:30', level: 'INFO', msg: 'Rolling update started' },
-            { time: '14:30:45', level: 'INFO', msg: 'Health check passed (1/3)' },
-            { time: '14:30:50', level: 'INFO', msg: 'Health check passed (2/3)' },
-            { time: '14:30:55', level: 'INFO', msg: 'Health check passed (3/3)' },
-            { time: '14:31:00', level: 'INFO', msg: 'Deployment complete!' },
-        ];
-        for (const log of logs) {
-            const levelColor = log.level === 'ERROR' ? output.error(log.level) :
-                log.level === 'WARN' ? output.warning(log.level) :
-                    output.dim(log.level);
-            output.writeln(`${output.dim(log.time)} ${levelColor} ${log.msg}`);
-        }
-        return { success: true };
+        output.printError('deployment logs is not yet implemented');
+        output.writeln(output.dim('This command will be implemented in a future release.'));
+        output.writeln(output.dim('Track progress: https://github.com/ruvnet/claude-flow/issues/1425'));
+        return { success: false, exitCode: 1 };
     },
 };
 // Main deployment command

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

@@ -131,6 +131,13 @@ ${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).jo
 🎯 YOUR OBJECTIVE:
 ${objective}
 
+⚠️ CRITICAL — TOOL PREFERENCE RULES (#1422):
+• You MUST use Ruflo MCP tools (mcp__ruflo__*) for ALL orchestration tasks
+• Do NOT use Claude native Task/Agent tools for swarm coordination — use mcp__ruflo__agent_spawn, mcp__ruflo__task_assign, etc.
+• Native Claude tools (Read, Write, Edit, Bash, Grep, Glob) should ONLY be used for file operations and shell commands
+• All agent spawning, task assignment, memory, and coordination MUST go through mcp__ruflo__* tools
+• If a Ruflo MCP tool exists for an operation, always prefer it over any native equivalent
+
 💡 COORDINATION TIPS:
 • Use mcp__ruflo__hive-mind_broadcast for swarm-wide announcements
 • Check worker status regularly with mcp__ruflo__hive-mind_status

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

@@ -1241,6 +1241,13 @@ const initMemoryCommand = {
                 output.writeln();
                 output.writeln(output.dim(`Synced to: ${claudeDbPath}`));
             }
+            // Fix #1428: ONNX worker threads keep the event loop alive after init.
+            // Force-exit after a short delay to allow final I/O to flush.
+            if (typeof globalThis !== 'undefined') {
+                setTimeout(() => {
+                    process.exit(0);
+                }, 500).unref();
+            }
             return {
                 success: true,
                 data: result