claude-flow 3.5.2 → 3.5.4

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

@@ -56,7 +56,7 @@ export const daaTools = [
                 cognitivePattern: { type: 'string', enum: ['convergent', 'divergent', 'lateral', 'systems', 'critical', 'adaptive'], description: 'Cognitive pattern' },
                 learningRate: { type: 'number', description: 'Learning rate (0-1)' },
                 enableMemory: { type: 'boolean', description: 'Enable persistent memory' },
-                capabilities: { type: 'array', description: 'Agent capabilities' },
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'Agent capabilities' },
             },
             required: ['id'],
         },
@@ -106,7 +106,7 @@ export const daaTools = [
                 agentId: { type: 'string', description: 'Agent ID' },
                 feedback: { type: 'string', description: 'Feedback message' },
                 performanceScore: { type: 'number', description: 'Performance score (0-1)' },
-                suggestions: { type: 'array', description: 'Improvement suggestions' },
+                suggestions: { type: 'array', items: { type: 'string' }, description: 'Improvement suggestions' },
             },
             required: ['agentId'],
         },
@@ -149,7 +149,7 @@ export const daaTools = [
             properties: {
                 id: { type: 'string', description: 'Workflow ID' },
                 name: { type: 'string', description: 'Workflow name' },
-                steps: { type: 'array', description: 'Workflow steps' },
+                steps: { type: 'array', items: { type: 'object' }, description: 'Workflow steps' },
                 strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'], description: 'Execution strategy' },
                 dependencies: { type: 'object', description: 'Step dependencies' },
             },
@@ -189,7 +189,7 @@ export const daaTools = [
             type: 'object',
             properties: {
                 workflowId: { type: 'string', description: 'Workflow ID' },
-                agentIds: { type: 'array', description: 'Agent IDs to use' },
+                agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to use' },
                 parallelExecution: { type: 'boolean', description: 'Enable parallel execution' },
             },
             required: ['workflowId'],
@@ -229,7 +229,7 @@ export const daaTools = [
             type: 'object',
             properties: {
                 sourceAgentId: { type: 'string', description: 'Source agent ID' },
-                targetAgentIds: { type: 'array', description: 'Target agent IDs' },
+                targetAgentIds: { type: 'array', items: { type: 'string' }, description: 'Target agent IDs' },
                 knowledgeDomain: { type: 'string', description: 'Knowledge domain' },
                 knowledgeContent: { type: 'object', description: 'Knowledge to share' },
             },

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

@@ -200,8 +200,8 @@ export const githubTools = [
                 issueNumber: { type: 'number', description: 'Issue number' },
                 title: { type: 'string', description: 'Issue title' },
                 body: { type: 'string', description: 'Issue body' },
-                labels: { type: 'array', description: 'Issue labels' },
-                assignees: { type: 'array', description: 'Assignees' },
+                labels: { type: 'array', items: { type: 'string' }, description: 'Issue labels' },
+                assignees: { type: 'array', items: { type: 'string' }, description: 'Assignees' },
             },
         },
         handler: async (input) => {

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

@@ -512,12 +512,32 @@ export const hooksPostEdit = {
     handler: async (params) => {
         const filePath = params.filePath;
         const success = params.success !== false;
+        const agent = params.agent;
+        // Wire recordFeedback through bridge (issue #1209)
+        let feedbackResult = null;
+        try {
+            const bridge = await import('../memory/memory-bridge.js');
+            feedbackResult = await bridge.bridgeRecordFeedback({
+                taskId: `edit-${filePath}-${Date.now()}`,
+                success,
+                quality: success ? 0.85 : 0.3,
+                agent,
+            });
+        }
+        catch {
+            // Bridge not available — continue with basic response
+        }
         return {
             recorded: true,
             filePath,
             success,
             timestamp: new Date().toISOString(),
             learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
+            feedback: feedbackResult ? {
+                recorded: feedbackResult.success,
+                controller: feedbackResult.controller,
+                updates: feedbackResult.updated,
+            } : { recorded: false, controller: 'unavailable', updates: 0 },
         };
     },
 };
@@ -2124,7 +2144,7 @@ export const hooksIntelligenceLearn = {
     inputSchema: {
         type: 'object',
         properties: {
-            trajectoryIds: { type: 'array', description: 'Specific trajectories to learn from' },
+            trajectoryIds: { type: 'array', items: { type: 'string' }, description: 'Specific trajectories to learn from' },
             consolidate: { type: 'boolean', description: 'Run EWC++ consolidation' },
         },
     },

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

@@ -57,7 +57,7 @@ export const performanceTools = [
             properties: {
                 timeRange: { type: 'string', description: 'Time range (1h, 24h, 7d)' },
                 format: { type: 'string', enum: ['json', 'summary', 'detailed'], description: 'Report format' },
-                components: { type: 'array', description: 'Components to include' },
+                components: { type: 'array', items: { type: 'string' }, description: 'Components to include' },
             },
         },
         handler: async (input) => {

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

@@ -9,8 +9,23 @@
  * - os module for system information
  */
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import * as os from 'node:os';
+// Read version dynamically from package.json
+function getPackageVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const pkgPath = join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version || '3.0.0';
+    }
+    catch {
+        return '3.0.0';
+    }
+}
+const PKG_VERSION = getPackageVersion();
 // Storage paths
 const STORAGE_DIR = '.claude-flow';
 const SYSTEM_DIR = 'system';
@@ -63,7 +78,7 @@ export const systemTools = [
             type: 'object',
             properties: {
                 verbose: { type: 'boolean', description: 'Include detailed information' },
-                components: { type: 'array', description: 'Specific components to check' },
+                components: { type: 'array', items: { type: 'string' }, description: 'Specific components to check' },
             },
         },
         handler: async (input) => {
@@ -73,7 +88,7 @@ export const systemTools = [
                 status: metrics.health >= 0.8 ? 'healthy' : metrics.health >= 0.5 ? 'degraded' : 'unhealthy',
                 uptime,
                 uptimeFormatted: `${Math.floor(uptime / 3600000)}h ${Math.floor((uptime % 3600000) / 60000)}m`,
-                version: '3.0.0-alpha',
+                version: PKG_VERSION,
                 components: {
                     swarm: { status: 'running', health: metrics.health },
                     memory: { status: 'running', health: 0.95 },
@@ -171,7 +186,7 @@ export const systemTools = [
             type: 'object',
             properties: {
                 deep: { type: 'boolean', description: 'Perform deep health check' },
-                components: { type: 'array', description: 'Components to check' },
+                components: { type: 'array', items: { type: 'string' }, description: 'Components to check' },
                 fix: { type: 'boolean', description: 'Attempt to fix issues' },
             },
         },
@@ -244,12 +259,12 @@ export const systemTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                include: { type: 'array', description: 'Information to include' },
+                include: { type: 'array', items: { type: 'string' }, description: 'Information to include' },
             },
         },
         handler: async () => {
             return {
-                version: '3.0.0-alpha',
+                version: PKG_VERSION,
                 nodeVersion: process.version,
                 platform: process.platform,
                 arch: process.arch,
@@ -310,5 +325,93 @@ export const systemTools = [
             };
         },
     },
+    {
+        name: 'mcp_status',
+        description: 'Get MCP server status, including stdio mode detection',
+        category: 'system',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            // Detect if we are running inside an MCP stdio session.
+            // When Claude Code launches us via `claude mcp add`, stdin is piped (not a TTY)
+            // and the process IS the MCP server, so it is running.
+            const isStdio = !process.stdin.isTTY;
+            const transport = process.env.CLAUDE_FLOW_MCP_TRANSPORT || (isStdio ? 'stdio' : 'http');
+            const port = parseInt(process.env.CLAUDE_FLOW_MCP_PORT || '3000', 10);
+            if (transport === 'stdio' || isStdio) {
+                // In stdio mode the MCP server is this process itself
+                return {
+                    running: true,
+                    pid: process.pid,
+                    transport: 'stdio',
+                    port: null,
+                    host: null,
+                };
+            }
+            // For HTTP/WebSocket, try to check if the server is listening
+            const host = process.env.CLAUDE_FLOW_MCP_HOST || 'localhost';
+            try {
+                const { createConnection } = await import('node:net');
+                const connected = await new Promise((resolve) => {
+                    const socket = createConnection({ host, port }, () => {
+                        socket.destroy();
+                        resolve(true);
+                    });
+                    socket.on('error', () => resolve(false));
+                    socket.setTimeout(2000, () => {
+                        socket.destroy();
+                        resolve(false);
+                    });
+                });
+                return {
+                    running: connected,
+                    transport,
+                    port,
+                    host,
+                };
+            }
+            catch {
+                return {
+                    running: false,
+                    transport,
+                    port,
+                    host,
+                };
+            }
+        },
+    },
+    {
+        name: 'task_summary',
+        description: 'Get a summary of all tasks by status',
+        category: 'task',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+        handler: async () => {
+            // Read from the task store file
+            const storePath = join(process.cwd(), '.claude-flow', 'tasks', 'store.json');
+            let tasks = [];
+            try {
+                if (existsSync(storePath)) {
+                    const data = readFileSync(storePath, 'utf-8');
+                    const store = JSON.parse(data);
+                    tasks = Object.values(store.tasks || {});
+                }
+            }
+            catch {
+                // empty store
+            }
+            return {
+                total: tasks.length,
+                pending: tasks.filter(t => t.status === 'pending').length,
+                running: tasks.filter(t => t.status === 'in_progress').length,
+                completed: tasks.filter(t => t.status === 'completed').length,
+                failed: tasks.filter(t => t.status === 'failed').length,
+            };
+        },
+    },
 ];
 //# sourceMappingURL=system-tools.js.map

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

@@ -263,6 +263,42 @@ export const taskTools = [
             };
         },
     },
+    {
+        name: 'task_assign',
+        description: 'Assign a task to one or more agents',
+        category: 'task',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskId: { type: 'string', description: 'Task ID to assign' },
+                agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
+                unassign: { type: 'boolean', description: 'Unassign all agents from task' },
+            },
+            required: ['taskId'],
+        },
+        handler: async (input) => {
+            const store = loadTaskStore();
+            const taskId = input.taskId;
+            const task = store.tasks[taskId];
+            if (!task) {
+                return { taskId, error: 'Task not found' };
+            }
+            const previouslyAssigned = [...task.assignedTo];
+            if (input.unassign) {
+                task.assignedTo = [];
+            }
+            else {
+                const agentIds = input.agentIds || [];
+                task.assignedTo = agentIds;
+            }
+            saveTaskStore(store);
+            return {
+                taskId: task.taskId,
+                assignedTo: task.assignedTo,
+                previouslyAssigned,
+            };
+        },
+    },
     {
         name: 'task_cancel',
         description: 'Cancel a task',

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

@@ -39,6 +39,97 @@ function saveWorkflowStore(store) {
     writeFileSync(getWorkflowPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
 export const workflowTools = [
+    {
+        name: 'workflow_run',
+        description: 'Run a workflow from a template or file',
+        category: 'workflow',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                template: { type: 'string', description: 'Template name to run' },
+                file: { type: 'string', description: 'Workflow file path' },
+                task: { type: 'string', description: 'Task description' },
+                options: {
+                    type: 'object',
+                    description: 'Workflow options',
+                    properties: {
+                        parallel: { type: 'boolean', description: 'Run stages in parallel' },
+                        maxAgents: { type: 'number', description: 'Maximum agents to use' },
+                        timeout: { type: 'number', description: 'Timeout in seconds' },
+                        dryRun: { type: 'boolean', description: 'Validate without executing' },
+                    },
+                },
+            },
+        },
+        handler: async (input) => {
+            const store = loadWorkflowStore();
+            const template = input.template;
+            const task = input.task;
+            const options = input.options || {};
+            const dryRun = options.dryRun;
+            // Build workflow from template or inline
+            const workflowId = `workflow-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const stages = [];
+            // Generate stages based on template
+            const templateName = template || 'custom';
+            const stageNames = (() => {
+                switch (templateName) {
+                    case 'feature':
+                        return ['Research', 'Design', 'Implement', 'Test', 'Review'];
+                    case 'bugfix':
+                        return ['Investigate', 'Fix', 'Test', 'Review'];
+                    case 'refactor':
+                        return ['Analyze', 'Refactor', 'Test', 'Review'];
+                    case 'security':
+                        return ['Scan', 'Analyze', 'Report'];
+                    default:
+                        return ['Execute'];
+                }
+            })();
+            for (const name of stageNames) {
+                stages.push({
+                    name,
+                    status: dryRun ? 'validated' : 'pending',
+                    agents: [],
+                });
+            }
+            if (!dryRun) {
+                // Create and save the workflow
+                const steps = stageNames.map((name, i) => ({
+                    stepId: `step-${i + 1}`,
+                    name,
+                    type: 'task',
+                    config: { task: task || name },
+                    status: 'pending',
+                }));
+                const workflow = {
+                    workflowId,
+                    name: task || `${templateName} workflow`,
+                    description: task,
+                    steps,
+                    status: 'running',
+                    currentStep: 0,
+                    variables: { template: templateName, ...options },
+                    createdAt: new Date().toISOString(),
+                    startedAt: new Date().toISOString(),
+                };
+                store.workflows[workflowId] = workflow;
+                saveWorkflowStore(store);
+            }
+            return {
+                workflowId,
+                template: templateName,
+                status: dryRun ? 'validated' : 'running',
+                stages,
+                metrics: {
+                    totalStages: stages.length,
+                    completedStages: 0,
+                    agentsSpawned: 0,
+                    estimatedDuration: `${stages.length * 30}s`,
+                },
+            };
+        },
+    },
     {
         name: 'workflow_create',
         description: 'Create a new workflow',

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

@@ -83,6 +83,7 @@ async function getRegistry(dbPath) {
                             tieredCache: true,
                             hierarchicalMemory: true,
                             memoryConsolidation: true,
+                            memoryGraph: true, // issue #1214: enable MemoryGraph for graph-aware ranking
                         },
                     });
                 }

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

@@ -150,6 +150,12 @@ export interface MemoryInitResult {
         hnswIndexing: boolean;
         migrationTracking: boolean;
     };
+    /** ADR-053: Controllers activated via ControllerRegistry */
+    controllers?: {
+        activated: string[];
+        failed: string[];
+        initTimeMs: number;
+    };
     error?: string;
 }
 /**

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

@@ -914,6 +914,51 @@ export async function checkAndMigrateLegacy(options) {
     }
     return { needsMigration: false };
 }
+/**
+ * ADR-053: Activate ControllerRegistry so AgentDB v3 controllers
+ * (ReasoningBank, SkillLibrary, ExplainableRecall, etc.) are instantiated.
+ *
+ * Uses the memory-bridge's getControllerRegistry() which lazily creates
+ * a singleton ControllerRegistry and initializes it with the given dbPath.
+ * After this call, all enabled controllers are ready for immediate use.
+ *
+ * Failures are isolated: if @claude-flow/memory or agentdb is not installed,
+ * this returns an empty result without throwing.
+ */
+async function activateControllerRegistry(dbPath, verbose) {
+    const startTime = performance.now();
+    const activated = [];
+    const failed = [];
+    try {
+        const bridge = await getBridge();
+        if (!bridge) {
+            return { activated, failed, initTimeMs: performance.now() - startTime };
+        }
+        const registry = await bridge.getControllerRegistry(dbPath);
+        if (!registry) {
+            return { activated, failed, initTimeMs: performance.now() - startTime };
+        }
+        // Collect controller status from the registry
+        if (typeof registry.listControllers === 'function') {
+            const controllers = registry.listControllers();
+            for (const ctrl of controllers) {
+                if (ctrl.enabled) {
+                    activated.push(ctrl.name);
+                }
+                else {
+                    failed.push(ctrl.name);
+                }
+            }
+        }
+        if (verbose && activated.length > 0) {
+            console.log(`ControllerRegistry: ${activated.length} controllers activated`);
+        }
+    }
+    catch {
+        // ControllerRegistry activation is best-effort
+    }
+    return { activated, failed, initTimeMs: performance.now() - startTime };
+}
 /**
  * Initialize the memory database properly using sql.js
  */
@@ -987,6 +1032,9 @@ export async function initializeMemoryDatabase(options) {
             // Also create schema file for reference
             const schemaPath = path.join(dbDir, 'schema.sql');
             fs.writeFileSync(schemaPath, MEMORY_SCHEMA_V3 + '\n' + getInitialMetadata(backend));
+            // ADR-053: Activate ControllerRegistry so controllers (ReasoningBank,
+            // SkillLibrary, ExplainableRecall, etc.) are instantiated during init
+            const controllerResult = await activateControllerRegistry(dbPath, verbose);
             return {
                 success: true,
                 backend,
@@ -1024,7 +1072,8 @@ export async function initializeMemoryDatabase(options) {
                     temporalDecay: true,
                     hnswIndexing: true,
                     migrationTracking: true
-                }
+                },
+                controllers: controllerResult,
             };
         }
         else {
@@ -1044,6 +1093,8 @@ export async function initializeMemoryDatabase(options) {
             sqliteHeader[26] = 0x20; // min embedded payload
             sqliteHeader[27] = 0x20; // leaf payload
             fs.writeFileSync(dbPath, sqliteHeader);
+            // ADR-053: Activate ControllerRegistry even on fallback path
+            const controllerResult = await activateControllerRegistry(dbPath, verbose);
             return {
                 success: true,
                 backend,
@@ -1067,7 +1118,8 @@ export async function initializeMemoryDatabase(options) {
                     temporalDecay: true,
                     hnswIndexing: true,
                     migrationTracking: true
-                }
+                },
+                controllers: controllerResult,
             };
         }
     }

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

@@ -481,6 +481,7 @@ export class Spinner {
             this.render();
             this.frameIndex = (this.frameIndex + 1) % this.frames.length;
         }, 100);
+        this.interval.unref();
         this.render();
     }
     stop(message) {

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

@@ -63,7 +63,7 @@ function parseArgs() {
  */
 function showHelp() {
     console.log(`
-Headless Runtime for Claude Flow V3
+Headless Runtime for RuFlo V3
 
 Usage:
   headless --worker <type>    Run a specific worker
@@ -150,7 +150,7 @@ async function runDaemon() {
  * Run benchmarks
  */
 async function runBenchmarks() {
-    console.log('=== Claude Flow V3 Performance Benchmarks ===\n');
+    console.log('=== RuFlo V3 Performance Benchmarks ===\n');
     // Initialize intelligence
     await initializeIntelligence();
     // SONA Benchmark
@@ -216,7 +216,7 @@ async function runBenchmarks() {
  * Show system status
  */
 async function showStatus() {
-    console.log('=== Claude Flow V3 System Status ===\n');
+    console.log('=== RuFlo V3 System Status ===\n');
     // Check daemon
     const daemon = getDaemon();
     console.log('Daemon:');

package/v3/@claude-flow/cli/dist/src/services/claim-service.js

@@ -675,7 +675,7 @@ export class GitHubSync {
                 const claimantStr = claimant.type === 'human'
                     ? `@${claimant.name.replace(/[^a-zA-Z0-9_-]/g, '')}`
                     : `Agent: ${(claimant.agentType || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '')}`;
-                const comment = `🤖 **Issue claimed** by ${claimantStr}\n\n_Coordinated by Claude Flow V3_`;
+                const comment = `🤖 **Issue claimed** by ${claimantStr}\n\n_Coordinated by RuFlo V3_`;
                 try {
                     execFileSync('gh', [
                         'issue', 'comment', String(issueNumber),

package/v3/@claude-flow/cli/dist/src/services/container-worker-pool.js

@@ -481,6 +481,7 @@ export class ContainerWorkerPool extends EventEmitter {
         this.healthCheckTimer = setInterval(async () => {
             await this.runHealthChecks();
         }, this.config.healthCheckIntervalMs);
+        this.healthCheckTimer.unref();
     }
     /**
      * Run health checks on all containers
@@ -522,6 +523,7 @@ export class ContainerWorkerPool extends EventEmitter {
         this.idleCheckTimer = setInterval(async () => {
             await this.runIdleChecks();
         }, 60000); // Check every minute
+        this.idleCheckTimer.unref();
     }
     /**
      * Terminate idle containers above minimum

package/v3/@claude-flow/cli/dist/src/services/worker-queue.js

@@ -57,6 +57,7 @@ class InMemoryStore {
         if (this.cleanupTimer)
             return;
         this.cleanupTimer = setInterval(() => this.cleanupExpired(), 60000);
+        this.cleanupTimer.unref();
     }
     /**
      * Stop cleanup timer
@@ -495,6 +496,7 @@ export class WorkerQueue extends EventEmitter {
                 this.store.setWorker(this.workerId, registration);
             }
         }, this.config.heartbeatIntervalMs);
+        this.heartbeatTimer.unref();
     }
     /**
      * Stop heartbeat timer

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

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.5.2",
+  "version": "3.5.4",
   "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",