kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/agent.js

@@ -2,11 +2,82 @@
  * V3 CLI Agent Command
  * Agent management commands for spawning, listing, and controlling agents
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Update swarm-activity.json metrics after agent count changes.
+ * The statusline reads this file to display the swarm agent count.
+ */
+function updateSwarmActivityMetrics(agentCountDelta) {
+    var _a;
+    try {
+        var metricsDir = path.join(process.cwd(), '.claude-flow', 'metrics');
+        var activityPath = path.join(metricsDir, 'swarm-activity.json');
+        var data = {
+            timestamp: new Date().toISOString(),
+            swarm: { active: false, agent_count: 0, coordination_active: false }
+        };
+        if (fs.existsSync(activityPath)) {
+            data = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
+        }
+        else {
+            fs.mkdirSync(metricsDir, { recursive: true });
+        }
+        var swarm = (_a = data.swarm) !== null && _a !== void 0 ? _a : {};
+        var currentCount = Math.max(0, swarm.agent_count || 0);
+        var newCount = Math.max(0, currentCount + agentCountDelta);
+        swarm.agent_count = newCount;
+        swarm.active = newCount > 0;
+        swarm.coordination_active = newCount > 0;
+        data.swarm = swarm;
+        data.timestamp = new Date().toISOString();
+        fs.writeFileSync(activityPath, JSON.stringify(data, null, 2));
+    }
+    catch (_b) {
+        // Non-critical — don't fail the command if metrics update fails
+    }
+}
 // Available agent types with descriptions
-const AGENT_TYPES = [
+var AGENT_TYPES = [
     { value: 'coder', label: 'Coder', hint: 'Code development with neural patterns' },
     { value: 'researcher', label: 'Researcher', hint: 'Research with web access and data analysis' },
     { value: 'tester', label: 'Tester', hint: 'Comprehensive testing with automation' },
@@ -24,7 +95,7 @@ const AGENT_TYPES = [
     { value: 'test-architect', label: 'Test Architect', hint: 'TDD London School methodology' }
 ];
 // Agent spawn subcommand
-const spawnCommand = {
+var spawnCommand = {
     name: 'spawn',
     description: 'Spawn a new agent',
     options: [
@@ -33,7 +104,7 @@ const spawnCommand = {
             short: 't',
             description: 'Agent type to spawn',
             type: 'string',
-            choices: AGENT_TYPES.map(a => a.value)
+            choices: AGENT_TYPES.map(function (a) { return a.value; })
         },
         {
             name: 'name',
@@ -46,7 +117,7 @@ const spawnCommand = {
             short: 'p',
             description: 'Provider to use (anthropic, openrouter, ollama)',
             type: 'string',
-            default: 'anthropic'
+            "default": 'anthropic'
         },
         {
             name: 'model',
@@ -63,91 +134,104 @@ const spawnCommand = {
             name: 'timeout',
             description: 'Agent timeout in seconds',
             type: 'number',
-            default: 300
+            "default": 300
         },
         {
             name: 'auto-tools',
             description: 'Enable automatic tool usage',
             type: 'boolean',
-            default: true
+            "default": true
         }
     ],
     examples: [
         { command: 'claude-flow agent spawn --type coder --name bot-1', description: 'Spawn a coder agent' },
         { command: 'claude-flow agent spawn -t researcher --task "Research React 19"', description: 'Spawn researcher with task' }
     ],
-    action: async (ctx) => {
-        let agentType = ctx.flags.type;
-        let agentName = ctx.flags.name;
-        // Interactive mode if type not specified
-        if (!agentType && ctx.interactive) {
-            agentType = await select({
-                message: 'Select agent type:',
-                options: AGENT_TYPES
-            });
-        }
-        if (!agentType) {
-            output.printError('Agent type is required. Use --type or -t flag.');
-            return { success: false, exitCode: 1 };
-        }
-        // Generate name if not provided
-        if (!agentName) {
-            agentName = `${agentType}-${Date.now().toString(36)}`;
-        }
-        output.printInfo(`Spawning ${agentType} agent: ${output.highlight(agentName)}`);
-        try {
-            // Call MCP tool to spawn agent
-            const result = await callMCPTool('agent_spawn', {
-                agentType,
-                id: agentName,
-                config: {
-                    provider: ctx.flags.provider || 'anthropic',
-                    model: ctx.flags.model,
-                    task: ctx.flags.task,
-                    timeout: ctx.flags.timeout,
-                    autoTools: ctx.flags.autoTools,
-                },
-                priority: 'normal',
-                metadata: {
-                    name: agentName,
-                    capabilities: getAgentCapabilities(agentType),
-                },
-            });
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'ID', value: result.agentId },
-                    { property: 'Type', value: result.agentType },
-                    { property: 'Name', value: agentName },
-                    { property: 'Status', value: result.status },
-                    { property: 'Created', value: result.createdAt },
-                    { property: 'Capabilities', value: getAgentCapabilities(agentType).join(', ') }
-                ]
-            });
-            output.writeln();
-            output.printSuccess(`Agent ${agentName} spawned successfully`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to spawn agent: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentType, agentName, result, error_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    agentType = ctx.flags.type;
+                    agentName = ctx.flags.name;
+                    if (!(!agentType && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, select({
+                            message: 'Select agent type:',
+                            options: AGENT_TYPES
+                        })];
+                case 1:
+                    agentType = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    if (!agentType) {
+                        output.printError('Agent type is required. Use --type or -t flag.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    // Generate name if not provided
+                    if (!agentName) {
+                        agentName = agentType + "-" + Date.now().toString(36);
+                    }
+                    output.printInfo("Spawning " + agentType + " agent: " + output.highlight(agentName));
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, callMCPTool('agent_spawn', {
+                            agentType: agentType,
+                            id: agentName,
+                            config: {
+                                provider: ctx.flags.provider || 'anthropic',
+                                model: ctx.flags.model,
+                                task: ctx.flags.task,
+                                timeout: ctx.flags.timeout,
+                                autoTools: ctx.flags.autoTools
+                            },
+                            priority: 'normal',
+                            metadata: {
+                                name: agentName,
+                                capabilities: getAgentCapabilities(agentType)
+                            }
+                        })];
+                case 4:
+                    result = _a.sent();
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 15 },
+                            { key: 'value', header: 'Value', width: 40 }
+                        ],
+                        data: [
+                            { property: 'ID', value: result.agentId },
+                            { property: 'Type', value: result.agentType },
+                            { property: 'Name', value: agentName },
+                            { property: 'Status', value: result.status },
+                            { property: 'Created', value: result.createdAt },
+                            { property: 'Capabilities', value: getAgentCapabilities(agentType).join(', ') }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess("Agent " + agentName + " spawned successfully");
+                    // Update swarm-activity.json so statusline reflects the new agent count
+                    updateSwarmActivityMetrics(1);
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 5:
+                    error_1 = _a.sent();
+                    if (error_1 instanceof MCPClientError) {
+                        output.printError("Failed to spawn agent: " + error_1.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_1));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 6: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Agent list subcommand
-const listCommand = {
+var listCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List all active agents',
@@ -157,7 +241,7 @@ const listCommand = {
             short: 'a',
             description: 'Include inactive agents',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'type',
@@ -172,62 +256,68 @@ const listCommand = {
             type: 'string'
         }
     ],
-    action: async (ctx) => {
-        try {
-            // Call MCP tool to list agents
-            const result = await callMCPTool('agent_list', {
-                status: ctx.flags.all ? 'all' : ctx.flags.status || undefined,
-                agentType: ctx.flags.type || undefined,
-                limit: 100,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Active Agents'));
-            output.writeln();
-            if (result.agents.length === 0) {
-                output.printInfo('No agents found matching criteria');
-                return { success: true, data: result };
-            }
-            // Format for display
-            const displayAgents = result.agents.map(agent => ({
-                id: agent.id,
-                type: agent.agentType,
-                status: agent.status,
-                created: new Date(agent.createdAt).toLocaleTimeString(),
-                lastActivity: agent.lastActivityAt
-                    ? new Date(agent.lastActivityAt).toLocaleTimeString()
-                    : 'N/A',
-            }));
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'ID', width: 20 },
-                    { key: 'type', header: 'Type', width: 15 },
-                    { key: 'status', header: 'Status', width: 12, format: formatStatus },
-                    { key: 'created', header: 'Created', width: 12 },
-                    { key: 'lastActivity', header: 'Last Activity', width: 12 }
-                ],
-                data: displayAgents
-            });
-            output.writeln();
-            output.printInfo(`Total: ${result.total} agents`);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to list agents: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var result, displayAgents, error_2;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, callMCPTool('agent_list', {
+                            status: ctx.flags.all ? 'all' : ctx.flags.status || undefined,
+                            agentType: ctx.flags.type || undefined,
+                            limit: 100
+                        })];
+                case 1:
+                    result = _a.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('Active Agents'));
+                    output.writeln();
+                    if (result.agents.length === 0) {
+                        output.printInfo('No agents found matching criteria');
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    displayAgents = result.agents.map(function (agent) { return ({
+                        id: agent.id,
+                        type: agent.agentType,
+                        status: agent.status,
+                        created: new Date(agent.createdAt).toLocaleTimeString(),
+                        lastActivity: agent.lastActivityAt
+                            ? new Date(agent.lastActivityAt).toLocaleTimeString()
+                            : 'N/A'
+                    }); });
+                    output.printTable({
+                        columns: [
+                            { key: 'id', header: 'ID', width: 20 },
+                            { key: 'type', header: 'Type', width: 15 },
+                            { key: 'status', header: 'Status', width: 12, format: formatStatus },
+                            { key: 'created', header: 'Created', width: 12 },
+                            { key: 'lastActivity', header: 'Last Activity', width: 12 }
+                        ],
+                        data: displayAgents
+                    });
+                    output.writeln();
+                    output.printInfo("Total: " + result.total + " agents");
+                    return [2 /*return*/, { success: true, data: result }];
+                case 2:
+                    error_2 = _a.sent();
+                    if (error_2 instanceof MCPClientError) {
+                        output.printError("Failed to list agents: " + error_2.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_2));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 3: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Agent status subcommand
-const statusCommand = {
+var statusCommand = {
     name: 'status',
     description: 'Show detailed status of an agent',
     options: [
@@ -237,70 +327,83 @@ const statusCommand = {
             type: 'string'
         }
     ],
-    action: async (ctx) => {
-        let agentId = ctx.args[0] || ctx.flags.id;
-        if (!agentId && ctx.interactive) {
-            agentId = await input({
-                message: 'Enter agent ID:',
-                validate: (v) => v.length > 0 || 'Agent ID is required'
-            });
-        }
-        if (!agentId) {
-            output.printError('Agent ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            // Call MCP tool to get agent status
-            const status = await callMCPTool('agent_status', {
-                agentId,
-                includeMetrics: true,
-                includeHistory: false,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(status);
-                return { success: true, data: status };
-            }
-            output.writeln();
-            output.printBox([
-                `Type: ${status.agentType}`,
-                `Status: ${formatStatus(status.status)}`,
-                `Created: ${new Date(status.createdAt).toLocaleString()}`,
-                `Last Activity: ${status.lastActivityAt ? new Date(status.lastActivityAt).toLocaleString() : 'N/A'}`
-            ].join('\n'), `Agent: ${status.id}`);
-            if (status.metrics) {
-                output.writeln();
-                output.writeln(output.bold('Metrics'));
-                const avgExecTime = status.metrics.averageExecutionTime ?? 0;
-                const uptime = status.metrics.uptime ?? 0;
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 15, align: 'right' }
-                    ],
-                    data: [
-                        { metric: 'Tasks Completed', value: status.metrics.tasksCompleted ?? 0 },
-                        { metric: 'Tasks In Progress', value: status.metrics.tasksInProgress ?? 0 },
-                        { metric: 'Tasks Failed', value: status.metrics.tasksFailed ?? 0 },
-                        { metric: 'Avg Execution Time', value: `${avgExecTime.toFixed(2)}ms` },
-                        { metric: 'Uptime', value: `${(uptime / 1000 / 60).toFixed(1)}m` }
-                    ]
-                });
-            }
-            return { success: true, data: status };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to get agent status: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentId, status, avgExecTime, uptime, error_3;
+        var _a, _b, _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    agentId = ctx.args[0] || ctx.flags.id;
+                    if (!(!agentId && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, input({
+                            message: 'Enter agent ID:',
+                            validate: function (v) { return v.length > 0 || 'Agent ID is required'; }
+                        })];
+                case 1:
+                    agentId = _f.sent();
+                    _f.label = 2;
+                case 2:
+                    if (!agentId) {
+                        output.printError('Agent ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    _f.label = 3;
+                case 3:
+                    _f.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, callMCPTool('agent_status', {
+                            agentId: agentId,
+                            includeMetrics: true,
+                            includeHistory: false
+                        })];
+                case 4:
+                    status = _f.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(status);
+                        return [2 /*return*/, { success: true, data: status }];
+                    }
+                    output.writeln();
+                    output.printBox([
+                        "Type: " + status.agentType,
+                        "Status: " + formatStatus(status.status),
+                        "Created: " + new Date(status.createdAt).toLocaleString(),
+                        "Last Activity: " + (status.lastActivityAt ? new Date(status.lastActivityAt).toLocaleString() : 'N/A')
+                    ].join('\n'), "Agent: " + status.id);
+                    if (status.metrics) {
+                        output.writeln();
+                        output.writeln(output.bold('Metrics'));
+                        avgExecTime = (_a = status.metrics.averageExecutionTime) !== null && _a !== void 0 ? _a : 0;
+                        uptime = (_b = status.metrics.uptime) !== null && _b !== void 0 ? _b : 0;
+                        output.printTable({
+                            columns: [
+                                { key: 'metric', header: 'Metric', width: 25 },
+                                { key: 'value', header: 'Value', width: 15, align: 'right' }
+                            ],
+                            data: [
+                                { metric: 'Tasks Completed', value: (_c = status.metrics.tasksCompleted) !== null && _c !== void 0 ? _c : 0 },
+                                { metric: 'Tasks In Progress', value: (_d = status.metrics.tasksInProgress) !== null && _d !== void 0 ? _d : 0 },
+                                { metric: 'Tasks Failed', value: (_e = status.metrics.tasksFailed) !== null && _e !== void 0 ? _e : 0 },
+                                { metric: 'Avg Execution Time', value: avgExecTime.toFixed(2) + "ms" },
+                                { metric: 'Uptime', value: (uptime / 1000 / 60).toFixed(1) + "m" }
+                            ]
+                        });
+                    }
+                    return [2 /*return*/, { success: true, data: status }];
+                case 5:
+                    error_3 = _f.sent();
+                    if (error_3 instanceof MCPClientError) {
+                        output.printError("Failed to get agent status: " + error_3.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_3));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 6: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Agent stop subcommand
-const stopCommand = {
+var stopCommand = {
     name: 'stop',
     aliases: ['kill'],
     description: 'Stop a running agent',
@@ -310,64 +413,78 @@ const stopCommand = {
             short: 'f',
             description: 'Force stop without graceful shutdown',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'timeout',
             description: 'Graceful shutdown timeout in seconds',
             type: 'number',
-            default: 30
+            "default": 30
         }
     ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0];
-        if (!agentId) {
-            output.printError('Agent ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        const force = ctx.flags.force;
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Are you sure you want to stop agent ${agentId}?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        output.printInfo(`Stopping agent ${agentId}...`);
-        try {
-            // Call MCP tool to terminate agent
-            const result = await callMCPTool('agent_terminate', {
-                agentId,
-                graceful: !force,
-                reason: 'Stopped by user via CLI',
-            });
-            if (!force) {
-                output.writeln(output.dim('  Completing current task...'));
-                output.writeln(output.dim('  Saving state...'));
-                output.writeln(output.dim('  Releasing resources...'));
-            }
-            output.printSuccess(`Agent ${agentId} stopped successfully`);
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to stop agent: ${error.message}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentId, force, confirmed, result, error_4;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    agentId = ctx.args[0];
+                    if (!agentId) {
+                        output.printError('Agent ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    force = ctx.flags.force;
+                    if (!(!force && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirm({
+                            message: "Are you sure you want to stop agent " + agentId + "?",
+                            "default": false
+                        })];
+                case 1:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 2;
+                case 2:
+                    output.printInfo("Stopping agent " + agentId + "...");
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, callMCPTool('agent_terminate', {
+                            agentId: agentId,
+                            graceful: !force,
+                            reason: 'Stopped by user via CLI'
+                        })];
+                case 4:
+                    result = _a.sent();
+                    if (!force) {
+                        output.writeln(output.dim('  Completing current task...'));
+                        output.writeln(output.dim('  Saving state...'));
+                        output.writeln(output.dim('  Releasing resources...'));
+                    }
+                    output.printSuccess("Agent " + agentId + " stopped successfully");
+                    // Update swarm-activity.json so statusline reflects the reduced agent count
+                    updateSwarmActivityMetrics(-1);
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 5:
+                    error_4 = _a.sent();
+                    if (error_4 instanceof MCPClientError) {
+                        output.printError("Failed to stop agent: " + error_4.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_4));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 6: return [2 /*return*/];
             }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Agent metrics subcommand
-const metricsCommand = {
+var metricsCommand = {
     name: 'metrics',
     description: 'Show agent performance metrics',
     options: [
@@ -376,78 +493,150 @@ const metricsCommand = {
             short: 'p',
             description: 'Time period (1h, 24h, 7d, 30d)',
             type: 'string',
-            default: '24h'
+            "default": '24h'
         }
     ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0];
-        const period = ctx.flags.period;
-        // Default metrics (updated by MCP agent/metrics when available)
-        const metrics = {
-            period,
-            summary: {
-                totalAgents: 4,
-                activeAgents: 3,
-                tasksCompleted: 127,
-                avgSuccessRate: '96.2%',
-                totalTokens: 1234567,
-                avgResponseTime: '1.45s'
-            },
-            byType: [
-                { type: 'coder', count: 2, tasks: 45, successRate: '97%' },
-                { type: 'researcher', count: 1, tasks: 32, successRate: '95%' },
-                { type: 'tester', count: 1, tasks: 50, successRate: '98%' }
-            ],
-            performance: {
-                flashAttention: '2.8x speedup',
-                memoryReduction: '52%',
-                searchImprovement: '150x faster'
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentId, period, _a, existsSync, readFileSync, readdirSync, statSync, join, totalAgents, activeAgents, tasksCompleted, typeCounts, swarmDir, agentsDir, files, _i, files_1, file, data, agType, activityFile, activity, vectorCount, dbPath, dbSize, byType, avgSuccessRate, metrics;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    agentId = ctx.args[0];
+                    period = ctx.flags.period;
+                    return [4 /*yield*/, import('fs')];
+                case 1:
+                    _a = _b.sent(), existsSync = _a.existsSync, readFileSync = _a.readFileSync, readdirSync = _a.readdirSync, statSync = _a.statSync;
+                    return [4 /*yield*/, import('path')];
+                case 2:
+                    join = (_b.sent()).join;
+                    totalAgents = 0;
+                    activeAgents = 0;
+                    tasksCompleted = 0;
+                    typeCounts = {};
+                    swarmDir = join(process.cwd(), '.swarm');
+                    agentsDir = join(swarmDir, 'agents');
+                    if (existsSync(agentsDir)) {
+                        try {
+                            files = readdirSync(agentsDir).filter(function (f) { return f.endsWith('.json'); });
+                            for (_i = 0, files_1 = files; _i < files_1.length; _i++) {
+                                file = files_1[_i];
+                                try {
+                                    data = JSON.parse(readFileSync(join(agentsDir, file), 'utf-8'));
+                                    totalAgents++;
+                                    agType = data.type || 'unknown';
+                                    if (!typeCounts[agType])
+                                        typeCounts[agType] = { count: 0, tasks: 0, success: 0 };
+                                    typeCounts[agType].count++;
+                                    if (data.status === 'active' || data.status === 'running')
+                                        activeAgents++;
+                                    if (data.tasksCompleted) {
+                                        typeCounts[agType].tasks += data.tasksCompleted;
+                                        tasksCompleted += data.tasksCompleted;
+                                    }
+                                    if (data.successCount)
+                                        typeCounts[agType].success += data.successCount;
+                                }
+                                catch ( /* skip malformed */_c) { /* skip malformed */ }
+                            }
+                        }
+                        catch ( /* no agents dir */_d) { /* no agents dir */ }
+                    }
+                    activityFile = join(swarmDir, 'swarm-activity.json');
+                    if (existsSync(activityFile)) {
+                        try {
+                            activity = JSON.parse(readFileSync(activityFile, 'utf-8'));
+                            if (activity.totalAgents && totalAgents === 0)
+                                totalAgents = activity.totalAgents;
+                            if (activity.activeAgents && activeAgents === 0)
+                                activeAgents = activity.activeAgents;
+                        }
+                        catch ( /* ignore */_e) { /* ignore */ }
+                    }
+                    vectorCount = 0;
+                    dbPath = join(swarmDir, 'memory.db');
+                    if (existsSync(dbPath)) {
+                        try {
+                            dbSize = statSync(dbPath).size;
+                            vectorCount = Math.floor(dbSize / 2048);
+                        }
+                        catch ( /* ignore */_f) { /* ignore */ }
+                    }
+                    byType = Object.entries(typeCounts).map(function (_a) {
+                        var type = _a[0], data = _a[1];
+                        return ({
+                            type: type,
+                            count: data.count,
+                            tasks: data.tasks,
+                            successRate: data.tasks > 0 ? Math.round((data.success / data.tasks) * 100) + "%" : 'N/A'
+                        });
+                    });
+                    avgSuccessRate = tasksCompleted > 0
+                        ? Math.round(Object.values(typeCounts).reduce(function (a, d) { return a + d.success; }, 0) / tasksCompleted * 100) + "%"
+                        : 'N/A';
+                    metrics = {
+                        period: period,
+                        summary: {
+                            totalAgents: totalAgents,
+                            activeAgents: activeAgents,
+                            tasksCompleted: tasksCompleted,
+                            avgSuccessRate: avgSuccessRate,
+                            vectorCount: vectorCount,
+                            note: totalAgents === 0 ? 'No agents spawned yet. Use: agent spawn -t coder' : undefined
+                        },
+                        byType: byType,
+                        performance: {
+                            memoryVectors: vectorCount + " vectors",
+                            searchBackend: vectorCount > 0 ? 'HNSW-indexed' : 'none'
+                        }
+                    };
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(metrics);
+                        return [2 /*return*/, { success: true, data: metrics }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold("Agent Metrics (" + period + ")"));
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'metric', header: 'Metric', width: 20 },
+                            { key: 'value', header: 'Value', width: 15, align: 'right' }
+                        ],
+                        data: [
+                            { metric: 'Total Agents', value: metrics.summary.totalAgents },
+                            { metric: 'Active Agents', value: metrics.summary.activeAgents },
+                            { metric: 'Tasks Completed', value: metrics.summary.tasksCompleted },
+                            { metric: 'Success Rate', value: metrics.summary.avgSuccessRate },
+                            { metric: 'Memory Vectors', value: metrics.summary.vectorCount }
+                        ]
+                    });
+                    output.writeln();
+                    output.writeln(output.bold('By Agent Type'));
+                    output.printTable({
+                        columns: [
+                            { key: 'type', header: 'Type', width: 12 },
+                            { key: 'count', header: 'Count', width: 8, align: 'right' },
+                            { key: 'tasks', header: 'Tasks', width: 8, align: 'right' },
+                            { key: 'successRate', header: 'Success', width: 10, align: 'right' }
+                        ],
+                        data: metrics.byType
+                    });
+                    if (metrics.summary.note) {
+                        output.writeln();
+                        output.writeln(output.dim(metrics.summary.note));
+                    }
+                    output.writeln();
+                    output.writeln(output.bold('Memory'));
+                    output.printList([
+                        "Vectors: " + output.success(metrics.performance.memoryVectors),
+                        "Backend: " + output.success(metrics.performance.searchBackend)
+                    ]);
+                    return [2 /*return*/, { success: true, data: metrics }];
             }
-        };
-        if (ctx.flags.format === 'json') {
-            output.printJson(metrics);
-            return { success: true, data: metrics };
-        }
-        output.writeln();
-        output.writeln(output.bold(`Agent Metrics (${period})`));
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'metric', header: 'Metric', width: 20 },
-                { key: 'value', header: 'Value', width: 15, align: 'right' }
-            ],
-            data: [
-                { metric: 'Total Agents', value: metrics.summary.totalAgents },
-                { metric: 'Active Agents', value: metrics.summary.activeAgents },
-                { metric: 'Tasks Completed', value: metrics.summary.tasksCompleted },
-                { metric: 'Success Rate', value: metrics.summary.avgSuccessRate },
-                { metric: 'Total Tokens', value: metrics.summary.totalTokens.toLocaleString() },
-                { metric: 'Avg Response Time', value: metrics.summary.avgResponseTime }
-            ]
-        });
-        output.writeln();
-        output.writeln(output.bold('By Agent Type'));
-        output.printTable({
-            columns: [
-                { key: 'type', header: 'Type', width: 12 },
-                { key: 'count', header: 'Count', width: 8, align: 'right' },
-                { key: 'tasks', header: 'Tasks', width: 8, align: 'right' },
-                { key: 'successRate', header: 'Success', width: 10, align: 'right' }
-            ],
-            data: metrics.byType
         });
-        output.writeln();
-        output.writeln(output.bold('V3 Performance Gains'));
-        output.printList([
-            `Flash Attention: ${output.success(metrics.performance.flashAttention)}`,
-            `Memory Reduction: ${output.success(metrics.performance.memoryReduction)}`,
-            `Search: ${output.success(metrics.performance.searchImprovement)}`
-        ]);
-        return { success: true, data: metrics };
-    }
+    }); }
 };
 // Agent pool subcommand
-const poolCommand = {
+var poolCommand = {
     name: 'pool',
     description: 'Manage agent pool for scaling',
     options: [
@@ -461,75 +650,84 @@ const poolCommand = {
             name: 'min',
             description: 'Minimum pool size',
             type: 'number',
-            default: 1
+            "default": 1
         },
         {
             name: 'max',
             description: 'Maximum pool size',
             type: 'number',
-            default: 10
+            "default": 10
         },
         {
             name: 'auto-scale',
             short: 'a',
             description: 'Enable auto-scaling',
             type: 'boolean',
-            default: true
+            "default": true
         }
     ],
     examples: [
         { command: 'claude-flow agent pool --size 5', description: 'Set pool size' },
         { command: 'claude-flow agent pool --min 2 --max 15', description: 'Configure auto-scaling' }
     ],
-    action: async (ctx) => {
-        try {
-            const result = await callMCPTool('agent_pool', {
-                size: ctx.flags.size,
-                min: ctx.flags.min,
-                max: ctx.flags.max,
-                autoScale: ctx.flags.autoScale ?? true,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            const utilization = result.utilization ?? 0;
-            output.printBox([
-                `Pool ID: ${result.poolId ?? 'default'}`,
-                `Current Size: ${result.currentSize ?? 0}`,
-                `Min/Max: ${result.minSize ?? 0}/${result.maxSize ?? 100}`,
-                `Auto-Scale: ${result.autoScale ? 'Yes' : 'No'}`,
-                `Utilization: ${(utilization * 100).toFixed(1)}%`
-            ].join('\n'), 'Agent Pool');
-            const agents = result.agents ?? [];
-            if (agents.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Pool Agents'));
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'ID', width: 20 },
-                        { key: 'type', header: 'Type', width: 15 },
-                        { key: 'status', header: 'Status', width: 12, format: formatStatus }
-                    ],
-                    data: agents
-                });
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Pool error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var result, utilization, agents, error_5;
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    _h.trys.push([0, 2, , 3]);
+                    return [4 /*yield*/, callMCPTool('agent_pool', {
+                            size: ctx.flags.size,
+                            min: ctx.flags.min,
+                            max: ctx.flags.max,
+                            autoScale: (_a = ctx.flags.autoScale) !== null && _a !== void 0 ? _a : true
+                        })];
+                case 1:
+                    result = _h.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    utilization = (_b = result.utilization) !== null && _b !== void 0 ? _b : 0;
+                    output.printBox([
+                        "Pool ID: " + ((_c = result.poolId) !== null && _c !== void 0 ? _c : 'default'),
+                        "Current Size: " + ((_d = result.currentSize) !== null && _d !== void 0 ? _d : 0),
+                        "Min/Max: " + ((_e = result.minSize) !== null && _e !== void 0 ? _e : 0) + "/" + ((_f = result.maxSize) !== null && _f !== void 0 ? _f : 100),
+                        "Auto-Scale: " + (result.autoScale ? 'Yes' : 'No'),
+                        "Utilization: " + (utilization * 100).toFixed(1) + "%"
+                    ].join('\n'), 'Agent Pool');
+                    agents = (_g = result.agents) !== null && _g !== void 0 ? _g : [];
+                    if (agents.length > 0) {
+                        output.writeln();
+                        output.writeln(output.bold('Pool Agents'));
+                        output.printTable({
+                            columns: [
+                                { key: 'id', header: 'ID', width: 20 },
+                                { key: 'type', header: 'Type', width: 15 },
+                                { key: 'status', header: 'Status', width: 12, format: formatStatus }
+                            ],
+                            data: agents
+                        });
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 2:
+                    error_5 = _h.sent();
+                    if (error_5 instanceof MCPClientError) {
+                        output.printError("Pool error: " + error_5.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_5));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 3: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Agent health subcommand
-const healthCommand = {
+var healthCommand = {
     name: 'health',
     description: 'Show agent health and metrics',
     options: [
@@ -544,102 +742,114 @@ const healthCommand = {
             short: 'd',
             description: 'Show detailed health metrics',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'watch',
             short: 'w',
             description: 'Watch mode (refresh every 5s)',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
     examples: [
         { command: 'claude-flow agent health', description: 'Show all agents health' },
         { command: 'claude-flow agent health -i agent-001 -d', description: 'Detailed health for specific agent' }
     ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags.id;
-        const detailed = ctx.flags.detailed;
-        try {
-            const result = await callMCPTool('agent_health', {
-                agentId,
-                detailed,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Agent Health'));
-            output.writeln();
-            // Overall summary with null checks
-            const overall = result.overall ?? { healthy: 0, degraded: 0, unhealthy: 0, avgCpu: 0, avgMemory: 0 };
-            const avgCpu = overall.avgCpu ?? 0;
-            const avgMemory = overall.avgMemory ?? 0;
-            output.printBox([
-                `Healthy: ${output.success(String(overall.healthy ?? 0))}`,
-                `Degraded: ${output.warning(String(overall.degraded ?? 0))}`,
-                `Unhealthy: ${output.error(String(overall.unhealthy ?? 0))}`,
-                `Avg CPU: ${avgCpu.toFixed(1)}%`,
-                `Avg Memory: ${(avgMemory * 100).toFixed(1)}%`
-            ].join('  |  '), 'Overall Status');
-            const healthAgents = result.agents ?? [];
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'Agent ID', width: 18 },
-                    { key: 'type', header: 'Type', width: 12 },
-                    { key: 'health', header: 'Health', width: 10, format: formatHealthStatus },
-                    { key: 'cpu', header: 'CPU %', width: 8, align: 'right', format: (v) => `${Number(v ?? 0).toFixed(1)}%` },
-                    { key: 'memory', header: 'Memory', width: 10, align: 'right', format: (v) => {
-                            const mem = v;
-                            if (!mem)
-                                return '0%';
-                            return `${(mem.used / mem.limit * 100).toFixed(0)}%`;
-                        } },
-                    { key: 'tasks', header: 'Tasks', width: 12, align: 'right', format: (v) => {
-                            const t = v;
-                            if (!t)
-                                return '0/0';
-                            return `${t.active ?? 0}/${t.completed ?? 0}`;
-                        } }
-                ],
-                data: healthAgents
-            });
-            if (detailed && healthAgents.length > 0) {
-                output.writeln();
-                output.writeln(output.bold('Detailed Metrics'));
-                for (const agent of healthAgents) {
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentId, detailed, result, overall, avgCpu, avgMemory, healthAgents, _i, healthAgents_1, agent, uptime, latency, tasks, errors, error_6;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        return __generator(this, function (_t) {
+            switch (_t.label) {
+                case 0:
+                    agentId = ctx.args[0] || ctx.flags.id;
+                    detailed = ctx.flags.detailed;
+                    _t.label = 1;
+                case 1:
+                    _t.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('agent_health', {
+                            agentId: agentId,
+                            detailed: detailed
+                        })];
+                case 2:
+                    result = _t.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
                     output.writeln();
-                    output.writeln(output.highlight(agent.id));
-                    const uptime = agent.uptime ?? 0;
-                    const latency = agent.latency ?? { avg: 0, p99: 0 };
-                    const tasks = agent.tasks ?? { completed: 0, failed: 0, queued: 0 };
-                    const errors = agent.errors ?? { count: 0 };
-                    output.printList([
-                        `Uptime: ${(uptime / 1000 / 60).toFixed(1)} min`,
-                        `Latency: avg ${(latency.avg ?? 0).toFixed(1)}ms, p99 ${(latency.p99 ?? 0).toFixed(1)}ms`,
-                        `Tasks: ${tasks.completed ?? 0} completed, ${tasks.failed ?? 0} failed, ${tasks.queued ?? 0} queued`,
-                        `Errors: ${errors.count ?? 0}${errors.lastError ? ` (${errors.lastError})` : ''}`
-                    ]);
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Health check error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+                    output.writeln(output.bold('Agent Health'));
+                    output.writeln();
+                    overall = (_a = result.overall) !== null && _a !== void 0 ? _a : { healthy: 0, degraded: 0, unhealthy: 0, avgCpu: 0, avgMemory: 0 };
+                    avgCpu = (_b = overall.avgCpu) !== null && _b !== void 0 ? _b : 0;
+                    avgMemory = (_c = overall.avgMemory) !== null && _c !== void 0 ? _c : 0;
+                    output.printBox([
+                        "Healthy: " + output.success(String((_d = overall.healthy) !== null && _d !== void 0 ? _d : 0)),
+                        "Degraded: " + output.warning(String((_e = overall.degraded) !== null && _e !== void 0 ? _e : 0)),
+                        "Unhealthy: " + output.error(String((_f = overall.unhealthy) !== null && _f !== void 0 ? _f : 0)),
+                        "Avg CPU: " + avgCpu.toFixed(1) + "%",
+                        "Avg Memory: " + (avgMemory * 100).toFixed(1) + "%"
+                    ].join('  |  '), 'Overall Status');
+                    healthAgents = (_g = result.agents) !== null && _g !== void 0 ? _g : [];
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'id', header: 'Agent ID', width: 18 },
+                            { key: 'type', header: 'Type', width: 12 },
+                            { key: 'health', header: 'Health', width: 10, format: formatHealthStatus },
+                            { key: 'cpu', header: 'CPU %', width: 8, align: 'right', format: function (v) { return Number(v !== null && v !== void 0 ? v : 0).toFixed(1) + "%"; } },
+                            { key: 'memory', header: 'Memory', width: 10, align: 'right', format: function (v) {
+                                    var mem = v;
+                                    if (!mem)
+                                        return '0%';
+                                    return (mem.used / mem.limit * 100).toFixed(0) + "%";
+                                } },
+                            { key: 'tasks', header: 'Tasks', width: 12, align: 'right', format: function (v) {
+                                    var _a, _b;
+                                    var t = v;
+                                    if (!t)
+                                        return '0/0';
+                                    return ((_a = t.active) !== null && _a !== void 0 ? _a : 0) + "/" + ((_b = t.completed) !== null && _b !== void 0 ? _b : 0);
+                                } }
+                        ],
+                        data: healthAgents
+                    });
+                    if (detailed && healthAgents.length > 0) {
+                        output.writeln();
+                        output.writeln(output.bold('Detailed Metrics'));
+                        for (_i = 0, healthAgents_1 = healthAgents; _i < healthAgents_1.length; _i++) {
+                            agent = healthAgents_1[_i];
+                            output.writeln();
+                            output.writeln(output.highlight(agent.id));
+                            uptime = (_h = agent.uptime) !== null && _h !== void 0 ? _h : 0;
+                            latency = (_j = agent.latency) !== null && _j !== void 0 ? _j : { avg: 0, p99: 0 };
+                            tasks = (_k = agent.tasks) !== null && _k !== void 0 ? _k : { completed: 0, failed: 0, queued: 0 };
+                            errors = (_l = agent.errors) !== null && _l !== void 0 ? _l : { count: 0 };
+                            output.printList([
+                                "Uptime: " + (uptime / 1000 / 60).toFixed(1) + " min",
+                                "Latency: avg " + ((_m = latency.avg) !== null && _m !== void 0 ? _m : 0).toFixed(1) + "ms, p99 " + ((_o = latency.p99) !== null && _o !== void 0 ? _o : 0).toFixed(1) + "ms",
+                                "Tasks: " + ((_p = tasks.completed) !== null && _p !== void 0 ? _p : 0) + " completed, " + ((_q = tasks.failed) !== null && _q !== void 0 ? _q : 0) + " failed, " + ((_r = tasks.queued) !== null && _r !== void 0 ? _r : 0) + " queued",
+                                "Errors: " + ((_s = errors.count) !== null && _s !== void 0 ? _s : 0) + (errors.lastError ? " (" + errors.lastError + ")" : '')
+                            ]);
+                        }
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_6 = _t.sent();
+                    if (error_6 instanceof MCPClientError) {
+                        output.printError("Health check error: " + error_6.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_6));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Agent logs subcommand
-const logsCommand = {
+var logsCommand = {
     name: 'logs',
     description: 'Show agent activity logs',
     options: [
@@ -654,7 +864,7 @@ const logsCommand = {
             short: 'n',
             description: 'Number of recent entries',
             type: 'number',
-            default: 50
+            "default": 50
         },
         {
             name: 'level',
@@ -662,14 +872,14 @@ const logsCommand = {
             description: 'Minimum log level',
             type: 'string',
             choices: ['debug', 'info', 'warn', 'error'],
-            default: 'info'
+            "default": 'info'
         },
         {
             name: 'follow',
             short: 'f',
             description: 'Follow log output',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'since',
@@ -682,52 +892,63 @@ const logsCommand = {
         { command: 'claude-flow agent logs -i agent-001 -f', description: 'Follow agent logs' },
         { command: 'claude-flow agent logs -l error --since 1h', description: 'Show errors from last hour' }
     ],
-    action: async (ctx) => {
-        const agentId = ctx.args[0] || ctx.flags.id;
-        const tail = ctx.flags.tail;
-        const level = ctx.flags.level;
-        if (!agentId) {
-            output.printError('Agent ID is required. Use --id or -i');
-            return { success: false, exitCode: 1 };
-        }
-        try {
-            const result = await callMCPTool('agent_logs', {
-                agentId,
-                tail,
-                level,
-                since: ctx.flags.since,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold(`Logs for ${agentId}`));
-            output.writeln(output.dim(`Showing ${result.entries.length} of ${result.total} entries`));
-            output.writeln();
-            for (const entry of result.entries) {
-                const time = new Date(entry.timestamp).toLocaleTimeString();
-                const levelStr = formatLogLevel(entry.level);
-                output.writeln(`${output.dim(time)} ${levelStr} ${entry.message}`);
-                if (entry.context && Object.keys(entry.context).length > 0) {
-                    output.writeln(output.dim(`  ${JSON.stringify(entry.context)}`));
-                }
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Logs error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentId, tail, level, result, _i, _a, entry, time, levelStr, error_7;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    agentId = ctx.args[0] || ctx.flags.id;
+                    tail = ctx.flags.tail;
+                    level = ctx.flags.level;
+                    if (!agentId) {
+                        output.printError('Agent ID is required. Use --id or -i');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, callMCPTool('agent_logs', {
+                            agentId: agentId,
+                            tail: tail,
+                            level: level,
+                            since: ctx.flags.since
+                        })];
+                case 2:
+                    result = _b.sent();
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                        return [2 /*return*/, { success: true, data: result }];
+                    }
+                    output.writeln();
+                    output.writeln(output.bold("Logs for " + agentId));
+                    output.writeln(output.dim("Showing " + result.entries.length + " of " + result.total + " entries"));
+                    output.writeln();
+                    for (_i = 0, _a = result.entries; _i < _a.length; _i++) {
+                        entry = _a[_i];
+                        time = new Date(entry.timestamp).toLocaleTimeString();
+                        levelStr = formatLogLevel(entry.level);
+                        output.writeln(output.dim(time) + " " + levelStr + " " + entry.message);
+                        if (entry.context && Object.keys(entry.context).length > 0) {
+                            output.writeln(output.dim("  " + JSON.stringify(entry.context)));
+                        }
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 3:
+                    error_7 = _b.sent();
+                    if (error_7 instanceof MCPClientError) {
+                        output.printError("Logs error: " + error_7.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_7));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 4: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 function formatHealthStatus(health) {
-    const h = String(health);
+    var h = String(health);
     switch (h) {
         case 'healthy':
             return output.success(h);
@@ -750,11 +971,11 @@ function formatLogLevel(level) {
         case 'error':
             return output.error('[ERROR]');
         default:
-            return `[${level.toUpperCase()}]`;
+            return "[" + level.toUpperCase() + "]";
     }
 }
 // Main agent command
-export const agentCommand = {
+export var agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
     subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
@@ -764,29 +985,31 @@ export const agentCommand = {
         { command: 'claude-flow agent list', description: 'List all agents' },
         { command: 'claude-flow agent status agent-001', description: 'Show agent status' }
     ],
-    action: async (ctx) => {
-        // Show help if no subcommand
-        output.writeln();
-        output.writeln(output.bold('Agent Management Commands'));
-        output.writeln();
-        output.writeln('Usage: claude-flow agent <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('spawn')}    - Spawn a new agent`,
-            `${output.highlight('list')}     - List all active agents`,
-            `${output.highlight('status')}   - Show detailed agent status`,
-            `${output.highlight('stop')}     - Stop a running agent`,
-            `${output.highlight('metrics')}  - Show agent metrics`
-        ]);
-        output.writeln();
-        output.writeln('Run "claude-flow agent <subcommand> --help" for subcommand help');
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            // Show help if no subcommand
+            output.writeln();
+            output.writeln(output.bold('Agent Management Commands'));
+            output.writeln();
+            output.writeln('Usage: claude-flow agent <subcommand> [options]');
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                output.highlight('spawn') + "    - Spawn a new agent",
+                output.highlight('list') + "     - List all active agents",
+                output.highlight('status') + "   - Show detailed agent status",
+                output.highlight('stop') + "     - Stop a running agent",
+                output.highlight('metrics') + "  - Show agent metrics"
+            ]);
+            output.writeln();
+            output.writeln('Run "claude-flow agent <subcommand> --help" for subcommand help');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 // Helper functions
 function getAgentCapabilities(type) {
-    const capabilities = {
+    var capabilities = {
         coder: ['code-generation', 'refactoring', 'debugging', 'testing'],
         researcher: ['web-search', 'data-analysis', 'summarization', 'citation'],
         tester: ['unit-testing', 'integration-testing', 'coverage-analysis', 'automation'],
@@ -800,7 +1023,7 @@ function getAgentCapabilities(type) {
     return capabilities[type] || ['general'];
 }
 function formatStatus(status) {
-    const statusStr = String(status);
+    var statusStr = String(status);
     switch (statusStr) {
         case 'active':
             return output.success(statusStr);