kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/agent.js

@@ -2,42 +2,6 @@
  * 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';
@@ -48,13 +12,12 @@ import * as path from 'path';
  * 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 = {
+        const metricsDir = path.join(process.cwd(), '.claude-flow', 'metrics');
+        const activityPath = path.join(metricsDir, 'swarm-activity.json');
+        let data = {
             timestamp: new Date().toISOString(),
-            swarm: { active: false, agent_count: 0, coordination_active: false }
+            swarm: { active: false, agent_count: 0, coordination_active: false },
         };
         if (fs.existsSync(activityPath)) {
             data = JSON.parse(fs.readFileSync(activityPath, 'utf-8'));
@@ -62,9 +25,9 @@ function updateSwarmActivityMetrics(agentCountDelta) {
         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);
+        const swarm = data.swarm ?? {};
+        const currentCount = Math.max(0, swarm.agent_count || 0);
+        const newCount = Math.max(0, currentCount + agentCountDelta);
         swarm.agent_count = newCount;
         swarm.active = newCount > 0;
         swarm.coordination_active = newCount > 0;
@@ -72,12 +35,12 @@ function updateSwarmActivityMetrics(agentCountDelta) {
         data.timestamp = new Date().toISOString();
         fs.writeFileSync(activityPath, JSON.stringify(data, null, 2));
     }
-    catch (_b) {
+    catch {
         // Non-critical — don't fail the command if metrics update fails
     }
 }
 // Available agent types with descriptions
-var AGENT_TYPES = [
+const 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' },
@@ -95,7 +58,7 @@ var AGENT_TYPES = [
     { value: 'test-architect', label: 'Test Architect', hint: 'TDD London School methodology' }
 ];
 // Agent spawn subcommand
-var spawnCommand = {
+const spawnCommand = {
     name: 'spawn',
     description: 'Spawn a new agent',
     options: [
@@ -104,7 +67,7 @@ var spawnCommand = {
             short: 't',
             description: 'Agent type to spawn',
             type: 'string',
-            choices: AGENT_TYPES.map(function (a) { return a.value; })
+            choices: AGENT_TYPES.map(a => a.value)
         },
         {
             name: 'name',
@@ -117,7 +80,7 @@ var spawnCommand = {
             short: 'p',
             description: 'Provider to use (anthropic, openrouter, ollama)',
             type: 'string',
-            "default": 'anthropic'
+            default: 'anthropic'
         },
         {
             name: 'model',
@@ -134,104 +97,93 @@ var 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: 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*/];
+    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`);
+            // Update swarm-activity.json so statusline reflects the new agent count
+            updateSwarmActivityMetrics(1);
+            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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Agent list subcommand
-var listCommand = {
+const listCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List all active agents',
@@ -241,7 +193,7 @@ var listCommand = {
             short: 'a',
             description: 'Include inactive agents',
             type: 'boolean',
-            "default": false
+            default: false
         },
         {
             name: 'type',
@@ -256,68 +208,62 @@ var listCommand = {
             type: 'string'
         }
     ],
-    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*/];
+    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Agent status subcommand
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Show detailed status of an agent',
     options: [
@@ -327,83 +273,70 @@ var statusCommand = {
             type: 'string'
         }
     ],
-    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*/];
+    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Agent stop subcommand
-var stopCommand = {
+const stopCommand = {
     name: 'stop',
     aliases: ['kill'],
     description: 'Stop a running agent',
@@ -413,78 +346,66 @@ var 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: 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*/];
+    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`);
+            // Update swarm-activity.json so statusline reflects the reduced agent count
+            updateSwarmActivityMetrics(-1);
+            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}`);
+            }
+            else {
+                output.printError(`Unexpected error: ${String(error)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Agent metrics subcommand
-var metricsCommand = {
+const metricsCommand = {
     name: 'metrics',
     description: 'Show agent performance metrics',
     options: [
@@ -493,150 +414,140 @@ var metricsCommand = {
             short: 'p',
             description: 'Time period (1h, 24h, 7d, 30d)',
             type: 'string',
-            "default": '24h'
+            default: '24h'
         }
     ],
-    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'
+    action: async (ctx) => {
+        const agentId = ctx.args[0];
+        const period = ctx.flags.period;
+        // Collect real metrics from .swarm/ state
+        const { existsSync, readFileSync, readdirSync, statSync } = await import('fs');
+        const { join } = await import('path');
+        let totalAgents = 0;
+        let activeAgents = 0;
+        let tasksCompleted = 0;
+        const typeCounts = {};
+        // Read swarm agent state
+        const swarmDir = join(process.cwd(), '.swarm');
+        const agentsDir = join(swarmDir, 'agents');
+        if (existsSync(agentsDir)) {
+            try {
+                const files = readdirSync(agentsDir).filter(f => f.endsWith('.json'));
+                for (const file of files) {
+                    try {
+                        const data = JSON.parse(readFileSync(join(agentsDir, file), 'utf-8'));
+                        totalAgents++;
+                        const 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 (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));
+                        if (data.successCount)
+                            typeCounts[agType].success += data.successCount;
                     }
-                    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 }];
+                    catch { /* skip malformed */ }
+                }
+            }
+            catch { /* no agents dir */ }
+        }
+        // Read swarm activity for additional state
+        const activityFile = join(swarmDir, 'swarm-activity.json');
+        if (existsSync(activityFile)) {
+            try {
+                const 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 */ }
+        }
+        // Read memory.db stats
+        let vectorCount = 0;
+        const dbPath = join(swarmDir, 'memory.db');
+        if (existsSync(dbPath)) {
+            try {
+                const dbSize = statSync(dbPath).size;
+                vectorCount = Math.floor(dbSize / 2048);
+            }
+            catch { /* ignore */ }
+        }
+        const byType = Object.entries(typeCounts).map(([type, data]) => ({
+            type,
+            count: data.count,
+            tasks: data.tasks,
+            successRate: data.tasks > 0 ? `${Math.round((data.success / data.tasks) * 100)}%` : 'N/A'
+        }));
+        const avgSuccessRate = tasksCompleted > 0
+            ? `${Math.round(Object.values(typeCounts).reduce((a, d) => a + d.success, 0) / tasksCompleted * 100)}%`
+            : 'N/A';
+        const metrics = {
+            period,
+            summary: {
+                totalAgents,
+                activeAgents,
+                tasksCompleted,
+                avgSuccessRate,
+                vectorCount,
+                note: totalAgents === 0 ? 'No agents spawned yet. Use: agent spawn -t coder' : undefined
+            },
+            byType,
+            performance: {
+                memoryVectors: `${vectorCount} vectors`,
+                searchBackend: vectorCount > 0 ? 'HNSW-indexed' : 'none'
+            }
+        };
+        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: '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 { success: true, data: metrics };
+    }
 };
 // Agent pool subcommand
-var poolCommand = {
+const poolCommand = {
     name: 'pool',
     description: 'Manage agent pool for scaling',
     options: [
@@ -650,84 +561,75 @@ var 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: 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*/];
+    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Agent health subcommand
-var healthCommand = {
+const healthCommand = {
     name: 'health',
     description: 'Show agent health and metrics',
     options: [
@@ -742,114 +644,102 @@ var 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: 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.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 : [];
+    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) {
                     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*/];
+                    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Agent logs subcommand
-var logsCommand = {
+const logsCommand = {
     name: 'logs',
     description: 'Show agent activity logs',
     options: [
@@ -864,7 +754,7 @@ var logsCommand = {
             short: 'n',
             description: 'Number of recent entries',
             type: 'number',
-            "default": 50
+            default: 50
         },
         {
             name: 'level',
@@ -872,14 +762,14 @@ var 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',
@@ -892,63 +782,52 @@ var 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: 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*/];
+    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 function formatHealthStatus(health) {
-    var h = String(health);
+    const h = String(health);
     switch (h) {
         case 'healthy':
             return output.success(h);
@@ -971,11 +850,11 @@ function formatLogLevel(level) {
         case 'error':
             return output.error('[ERROR]');
         default:
-            return "[" + level.toUpperCase() + "]";
+            return `[${level.toUpperCase()}]`;
     }
 }
 // Main agent command
-export var agentCommand = {
+export const agentCommand = {
     name: 'agent',
     description: 'Agent management commands',
     subcommands: [spawnCommand, listCommand, statusCommand, stopCommand, metricsCommand, poolCommand, healthCommand, logsCommand],
@@ -985,31 +864,29 @@ export var agentCommand = {
         { command: 'claude-flow agent list', description: 'List all agents' },
         { command: 'claude-flow agent status agent-001', description: 'Show agent status' }
     ],
-    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 }];
-        });
-    }); }
+    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 };
+    }
 };
 // Helper functions
 function getAgentCapabilities(type) {
-    var capabilities = {
+    const capabilities = {
         coder: ['code-generation', 'refactoring', 'debugging', 'testing'],
         researcher: ['web-search', 'data-analysis', 'summarization', 'citation'],
         tester: ['unit-testing', 'integration-testing', 'coverage-analysis', 'automation'],
@@ -1023,7 +900,7 @@ function getAgentCapabilities(type) {
     return capabilities[type] || ['general'];
 }
 function formatStatus(status) {
-    var statusStr = String(status);
+    const statusStr = String(status);
     switch (statusStr) {
         case 'active':
             return output.success(statusStr);