kynjal-cli 4.0.0 → 4.0.1

package/dist/src/mcp-tools/agent-tools.js

@@ -4,59 +4,12 @@
  * Tool definitions for agent lifecycle management with file persistence.
  * Includes model routing integration for intelligent model selection.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Storage paths
-var STORAGE_DIR = '.claude-flow';
-var AGENT_DIR = 'agents';
-var AGENT_FILE = 'store.json';
+const STORAGE_DIR = '.claude-flow';
+const AGENT_DIR = 'agents';
+const AGENT_FILE = 'store.json';
 function getAgentDir() {
     return join(process.cwd(), STORAGE_DIR, AGENT_DIR);
 }
@@ -64,20 +17,20 @@ function getAgentPath() {
     return join(getAgentDir(), AGENT_FILE);
 }
 function ensureAgentDir() {
-    var dir = getAgentDir();
+    const dir = getAgentDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadAgentStore() {
     try {
-        var path = getAgentPath();
+        const path = getAgentPath();
         if (existsSync(path)) {
-            var data = readFileSync(path, 'utf-8');
+            const data = readFileSync(path, 'utf-8');
             return JSON.parse(data);
         }
     }
-    catch (_a) {
+    catch {
         // Return empty store on error
     }
     return { agents: {}, version: '3.0.0' };
@@ -87,7 +40,7 @@ function saveAgentStore(store) {
     writeFileSync(getAgentPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
 // Default model mappings for agent types (can be overridden)
-var AGENT_TYPE_MODEL_DEFAULTS = {
+const AGENT_TYPE_MODEL_DEFAULTS = {
     // Complex agents → opus
     'architect': 'opus',
     'security-architect': 'opus',
@@ -102,34 +55,22 @@ var AGENT_TYPE_MODEL_DEFAULTS = {
     // Simple/fast agents → haiku
     'formatter': 'haiku',
     'linter': 'haiku',
-    'documenter': 'haiku'
+    'documenter': 'haiku',
 };
 // Lazy-loaded model router
-var modelRouterInstance = null;
-function getModelRouter() {
-    return __awaiter(this, void 0, void 0, function () {
-        var getModelRouter_1, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!modelRouterInstance) return [3 /*break*/, 4];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('../ruvector/model-router.js')];
-                case 2:
-                    getModelRouter_1 = (_a.sent()).getModelRouter;
-                    modelRouterInstance = getModelRouter_1();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    // Log but don't fail - model router is optional
-                    console.error('[agent-tools] Model router load failed:', e_1.message);
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/, modelRouterInstance];
-            }
-        });
-    });
+let modelRouterInstance = null;
+async function getModelRouter() {
+    if (!modelRouterInstance) {
+        try {
+            const { getModelRouter } = await import('../ruvector/model-router.js');
+            modelRouterInstance = getModelRouter();
+        }
+        catch (e) {
+            // Log but don't fail - model router is optional
+            console.error('[agent-tools] Model router load failed:', e.message);
+        }
+    }
+    return modelRouterInstance;
 }
 /**
  * Determine model for agent based on (ADR-026 3-tier routing):
@@ -138,72 +79,57 @@ function getModelRouter() {
  * 3. Agent type defaults
  * 4. Fallback to sonnet
  */
-function determineAgentModel(agentType, config, task) {
-    var _a;
-    return __awaiter(this, void 0, Promise, function () {
-        var getEnhancedModelRouter, enhancedRouter, routeResult, _b, router, result, _c, defaultModel;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    // 1. Explicit model in config
-                    if (config.model && ['haiku', 'sonnet', 'opus', 'inherit'].includes(config.model)) {
-                        return [2 /*return*/, { model: config.model, routedBy: 'explicit' }];
-                    }
-                    if (!task) return [3 /*break*/, 10];
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 4, , 10]);
-                    return [4 /*yield*/, import('../ruvector/enhanced-model-router.js')];
-                case 2:
-                    getEnhancedModelRouter = (_d.sent()).getEnhancedModelRouter;
-                    enhancedRouter = getEnhancedModelRouter();
-                    return [4 /*yield*/, enhancedRouter.route(task, { filePath: config.filePath })];
-                case 3:
-                    routeResult = _d.sent();
-                    if (routeResult.tier === 1 && routeResult.canSkipLLM) {
-                        // Agent Booster can handle this task
-                        return [2 /*return*/, {
-                                model: 'haiku',
-                                routedBy: 'agent-booster',
-                                canSkipLLM: true,
-                                agentBoosterIntent: (_a = routeResult.agentBoosterIntent) === null || _a === void 0 ? void 0 : _a.type,
-                                tier: 1
-                            }];
-                    }
-                    return [2 /*return*/, {
-                            model: routeResult.model,
-                            routedBy: 'router',
-                            tier: routeResult.tier
-                        }];
-                case 4:
-                    _b = _d.sent();
-                    return [4 /*yield*/, getModelRouter()];
-                case 5:
-                    router = _d.sent();
-                    if (!router) return [3 /*break*/, 9];
-                    _d.label = 6;
-                case 6:
-                    _d.trys.push([6, 8, , 9]);
-                    return [4 /*yield*/, router.route(task)];
-                case 7:
-                    result = _d.sent();
-                    return [2 /*return*/, { model: result.model, routedBy: 'router' }];
-                case 8:
-                    _c = _d.sent();
-                    return [3 /*break*/, 9];
-                case 9: return [3 /*break*/, 10];
-                case 10:
-                    defaultModel = AGENT_TYPE_MODEL_DEFAULTS[agentType];
-                    if (defaultModel) {
-                        return [2 /*return*/, { model: defaultModel, routedBy: 'default' }];
-                    }
-                    // 4. Fallback to sonnet (balanced)
-                    return [2 /*return*/, { model: 'sonnet', routedBy: 'default' }];
+async function determineAgentModel(agentType, config, task) {
+    // 1. Explicit model in config
+    if (config.model && ['haiku', 'sonnet', 'opus', 'inherit'].includes(config.model)) {
+        return { model: config.model, routedBy: 'explicit' };
+    }
+    // 2. Enhanced task-based routing with Agent Booster AST
+    if (task) {
+        try {
+            // Try enhanced router first (includes Agent Booster detection)
+            const { getEnhancedModelRouter } = await import('../ruvector/enhanced-model-router.js');
+            const enhancedRouter = getEnhancedModelRouter();
+            const routeResult = await enhancedRouter.route(task, { filePath: config.filePath });
+            if (routeResult.tier === 1 && routeResult.canSkipLLM) {
+                // Agent Booster can handle this task
+                return {
+                    model: 'haiku', // Use haiku as fallback if AB fails
+                    routedBy: 'agent-booster',
+                    canSkipLLM: true,
+                    agentBoosterIntent: routeResult.agentBoosterIntent?.type,
+                    tier: 1,
+                };
+            }
+            return {
+                model: routeResult.model,
+                routedBy: 'router',
+                tier: routeResult.tier,
+            };
+        }
+        catch {
+            // Enhanced router not available, try basic router
+            const router = await getModelRouter();
+            if (router) {
+                try {
+                    const result = await router.route(task);
+                    return { model: result.model, routedBy: 'router' };
+                }
+                catch {
+                    // Fall through to defaults on router error
+                }
             }
-        });
-    });
+        }
+    }
+    // 3. Agent type defaults
+    const defaultModel = AGENT_TYPE_MODEL_DEFAULTS[agentType];
+    if (defaultModel) {
+        return { model: defaultModel, routedBy: 'default' };
+    }
+    // 4. Fallback to sonnet (balanced)
+    return { model: 'sonnet', routedBy: 'default' };
 }
-export var agentTools = [
+export const agentTools = [
     {
         name: 'agent_spawn',
         description: 'Spawn a new agent with intelligent model selection',
@@ -217,67 +143,62 @@ export var agentTools = [
                 domain: { type: 'string', description: 'Agent domain' },
                 model: {
                     type: 'string',
-                    "enum": ['haiku', 'sonnet', 'opus', 'inherit'],
+                    enum: ['haiku', 'sonnet', 'opus', 'inherit'],
                     description: 'Claude model to use (haiku=fast/cheap, sonnet=balanced, opus=most capable)'
                 },
-                task: { type: 'string', description: 'Task description for intelligent model routing' }
+                task: { type: 'string', description: 'Task description for intelligent model routing' },
             },
-            required: ['agentType']
+            required: ['agentType'],
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agentId = input.agentId || `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const agentType = input.agentType;
+            const config = input.config || {};
+            // Add explicit model to config if provided
+            if (input.model) {
+                config.model = input.model;
+            }
+            // Get task from either top-level or config (CLI passes it in config.task)
+            const task = input.task || config.task || undefined;
+            // Determine model using ADR-026 3-tier routing logic
+            const routingResult = await determineAgentModel(agentType, config, task);
+            const agent = {
+                agentId,
+                agentType,
+                status: 'idle',
+                health: 1.0,
+                taskCount: 0,
+                config,
+                createdAt: new Date().toISOString(),
+                domain: input.domain,
+                model: routingResult.model,
+                modelRoutedBy: routingResult.routedBy,
+            };
+            store.agents[agentId] = agent;
+            saveAgentStore(store);
+            // Include Agent Booster routing info if applicable
+            const response = {
+                success: true,
+                agentId,
+                agentType: agent.agentType,
+                model: agent.model,
+                modelRoutedBy: routingResult.routedBy,
+                status: 'spawned',
+                createdAt: agent.createdAt,
+            };
+            // Add Agent Booster info if task can skip LLM
+            if (routingResult.canSkipLLM) {
+                response.canSkipLLM = true;
+                response.agentBoosterIntent = routingResult.agentBoosterIntent;
+                response.tier = routingResult.tier;
+                response.note = `Agent Booster can handle "${routingResult.agentBoosterIntent}" - use agent_booster_edit_file MCP tool`;
+            }
+            else if (routingResult.tier) {
+                response.tier = routingResult.tier;
+            }
+            return response;
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agentId, agentType, config, task, routingResult, agent, response;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        store = loadAgentStore();
-                        agentId = input.agentId || "agent-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                        agentType = input.agentType;
-                        config = input.config || {};
-                        // Add explicit model to config if provided
-                        if (input.model) {
-                            config.model = input.model;
-                        }
-                        task = input.task || config.task || undefined;
-                        return [4 /*yield*/, determineAgentModel(agentType, config, task)];
-                    case 1:
-                        routingResult = _a.sent();
-                        agent = {
-                            agentId: agentId,
-                            agentType: agentType,
-                            status: 'idle',
-                            health: 1.0,
-                            taskCount: 0,
-                            config: config,
-                            createdAt: new Date().toISOString(),
-                            domain: input.domain,
-                            model: routingResult.model,
-                            modelRoutedBy: routingResult.routedBy
-                        };
-                        store.agents[agentId] = agent;
-                        saveAgentStore(store);
-                        response = {
-                            success: true,
-                            agentId: agentId,
-                            agentType: agent.agentType,
-                            model: agent.model,
-                            modelRoutedBy: routingResult.routedBy,
-                            status: 'spawned',
-                            createdAt: agent.createdAt
-                        };
-                        // Add Agent Booster info if task can skip LLM
-                        if (routingResult.canSkipLLM) {
-                            response.canSkipLLM = true;
-                            response.agentBoosterIntent = routingResult.agentBoosterIntent;
-                            response.tier = routingResult.tier;
-                            response.note = "Agent Booster can handle \"" + routingResult.agentBoosterIntent + "\" - use agent_booster_edit_file MCP tool";
-                        }
-                        else if (routingResult.tier) {
-                            response.tier = routingResult.tier;
-                        }
-                        return [2 /*return*/, response];
-                }
-            });
-        }); }
     },
     {
         name: 'agent_terminate',
@@ -287,32 +208,29 @@ export var agentTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'ID of agent to terminate' },
-                force: { type: 'boolean', description: 'Force immediate termination' }
+                force: { type: 'boolean', description: 'Force immediate termination' },
             },
-            required: ['agentId']
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agentId = input.agentId;
+            if (store.agents[agentId]) {
+                store.agents[agentId].status = 'terminated';
+                saveAgentStore(store);
+                return {
+                    success: true,
+                    agentId,
+                    terminated: true,
+                    terminatedAt: new Date().toISOString(),
+                };
+            }
+            return {
+                success: false,
+                agentId,
+                error: 'Agent not found',
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agentId;
-            return __generator(this, function (_a) {
-                store = loadAgentStore();
-                agentId = input.agentId;
-                if (store.agents[agentId]) {
-                    store.agents[agentId].status = 'terminated';
-                    saveAgentStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            agentId: agentId,
-                            terminated: true,
-                            terminatedAt: new Date().toISOString()
-                        }];
-                }
-                return [2 /*return*/, {
-                        success: false,
-                        agentId: agentId,
-                        error: 'Agent not found'
-                    }];
-            });
-        }); }
     },
     {
         name: 'agent_status',
@@ -321,34 +239,31 @@ export var agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                agentId: { type: 'string', description: 'ID of agent' }
+                agentId: { type: 'string', description: 'ID of agent' },
             },
-            required: ['agentId']
+            required: ['agentId'],
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agentId = input.agentId;
+            const agent = store.agents[agentId];
+            if (agent) {
+                return {
+                    agentId: agent.agentId,
+                    agentType: agent.agentType,
+                    status: agent.status,
+                    health: agent.health,
+                    taskCount: agent.taskCount,
+                    createdAt: agent.createdAt,
+                    domain: agent.domain,
+                };
+            }
+            return {
+                agentId,
+                status: 'not_found',
+                error: 'Agent not found',
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agentId, agent;
-            return __generator(this, function (_a) {
-                store = loadAgentStore();
-                agentId = input.agentId;
-                agent = store.agents[agentId];
-                if (agent) {
-                    return [2 /*return*/, {
-                            agentId: agent.agentId,
-                            agentType: agent.agentType,
-                            status: agent.status,
-                            health: agent.health,
-                            taskCount: agent.taskCount,
-                            createdAt: agent.createdAt,
-                            domain: agent.domain
-                        }];
-                }
-                return [2 /*return*/, {
-                        agentId: agentId,
-                        status: 'not_found',
-                        error: 'Agent not found'
-                    }];
-            });
-        }); }
     },
     {
         name: 'agent_list',
@@ -359,44 +274,41 @@ export var agentTools = [
             properties: {
                 status: { type: 'string', description: 'Filter by status' },
                 domain: { type: 'string', description: 'Filter by domain' },
-                includeTerminated: { type: 'boolean', description: 'Include terminated agents' }
+                includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadAgentStore();
+            let agents = Object.values(store.agents);
+            // Filter by status
+            if (input.status) {
+                agents = agents.filter(a => a.status === input.status);
+            }
+            else if (!input.includeTerminated) {
+                agents = agents.filter(a => a.status !== 'terminated');
+            }
+            // Filter by domain
+            if (input.domain) {
+                agents = agents.filter(a => a.domain === input.domain);
             }
+            return {
+                agents: agents.map(a => ({
+                    agentId: a.agentId,
+                    agentType: a.agentType,
+                    status: a.status,
+                    health: a.health,
+                    taskCount: a.taskCount,
+                    createdAt: a.createdAt,
+                    domain: a.domain,
+                })),
+                total: agents.length,
+                filters: {
+                    status: input.status,
+                    domain: input.domain,
+                    includeTerminated: input.includeTerminated,
+                },
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agents;
-            return __generator(this, function (_a) {
-                store = loadAgentStore();
-                agents = Object.values(store.agents);
-                // Filter by status
-                if (input.status) {
-                    agents = agents.filter(function (a) { return a.status === input.status; });
-                }
-                else if (!input.includeTerminated) {
-                    agents = agents.filter(function (a) { return a.status !== 'terminated'; });
-                }
-                // Filter by domain
-                if (input.domain) {
-                    agents = agents.filter(function (a) { return a.domain === input.domain; });
-                }
-                return [2 /*return*/, {
-                        agents: agents.map(function (a) { return ({
-                            agentId: a.agentId,
-                            agentType: a.agentType,
-                            status: a.status,
-                            health: a.health,
-                            taskCount: a.taskCount,
-                            createdAt: a.createdAt,
-                            domain: a.domain
-                        }); }),
-                        total: agents.length,
-                        filters: {
-                            status: input.status,
-                            domain: input.domain,
-                            includeTerminated: input.includeTerminated
-                        }
-                    }];
-            });
-        }); }
     },
     {
         name: 'agent_pool',
@@ -405,117 +317,110 @@ export var agentTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['status', 'scale', 'drain', 'fill'], description: 'Pool action' },
+                action: { type: 'string', enum: ['status', 'scale', 'drain', 'fill'], description: 'Pool action' },
                 targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
-                agentType: { type: 'string', description: 'Agent type filter' }
+                agentType: { type: 'string', description: 'Agent type filter' },
             },
-            required: ['action']
+            required: ['action'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agents, action, byType, byStatus, _i, agents_1, agent, idleAgents, busyAgents, utilization, targetSize, agentType_1, currentSize, delta, added, removed, i, agentId, toRemove, _a, toRemove_1, agent, agentType, drained, _b, agents_2, agent;
-            var _c;
-            return __generator(this, function (_d) {
-                store = loadAgentStore();
-                agents = Object.values(store.agents).filter(function (a) { return a.status !== 'terminated'; });
-                action = input.action || 'status';
-                if (action === 'status') {
-                    byType = {};
-                    byStatus = {};
-                    for (_i = 0, agents_1 = agents; _i < agents_1.length; _i++) {
-                        agent = agents_1[_i];
-                        byType[agent.agentType] = (byType[agent.agentType] || 0) + 1;
-                        byStatus[agent.status] = (byStatus[agent.status] || 0) + 1;
-                    }
-                    idleAgents = agents.filter(function (a) { return a.status === 'idle'; }).length;
-                    busyAgents = agents.filter(function (a) { return a.status === 'busy'; }).length;
-                    utilization = agents.length > 0 ? busyAgents / agents.length : 0;
-                    return [2 /*return*/, {
-                            action: action,
-                            // CLI expected fields
-                            poolId: 'agent-pool-default',
-                            currentSize: agents.length,
-                            minSize: input.min || 0,
-                            maxSize: input.max || 100,
-                            autoScale: (_c = input.autoScale) !== null && _c !== void 0 ? _c : false,
-                            utilization: utilization,
-                            agents: agents.map(function (a) { return ({
-                                id: a.agentId,
-                                type: a.agentType,
-                                status: a.status
-                            }); }),
-                            // Additional fields
-                            id: 'agent-pool-default',
-                            size: agents.length,
-                            totalAgents: agents.length,
-                            byType: byType,
-                            byStatus: byStatus,
-                            avgHealth: agents.length > 0 ? agents.reduce(function (sum, a) { return sum + a.health; }, 0) / agents.length : 0
-                        }];
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
+            const action = input.action || 'status'; // Default to status
+            if (action === 'status') {
+                const byType = {};
+                const byStatus = {};
+                for (const agent of agents) {
+                    byType[agent.agentType] = (byType[agent.agentType] || 0) + 1;
+                    byStatus[agent.status] = (byStatus[agent.status] || 0) + 1;
                 }
-                if (action === 'scale') {
-                    targetSize = input.targetSize || 5;
-                    agentType_1 = input.agentType || 'worker';
-                    currentSize = agents.filter(function (a) { return a.agentType === agentType_1; }).length;
-                    delta = targetSize - currentSize;
-                    added = [];
-                    removed = [];
-                    if (delta > 0) {
-                        for (i = 0; i < delta; i++) {
-                            agentId = "agent-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                            store.agents[agentId] = {
-                                agentId: agentId,
-                                agentType: agentType_1,
-                                status: 'idle',
-                                health: 1.0,
-                                taskCount: 0,
-                                config: {},
-                                createdAt: new Date().toISOString()
-                            };
-                            added.push(agentId);
-                        }
+                const idleAgents = agents.filter(a => a.status === 'idle').length;
+                const busyAgents = agents.filter(a => a.status === 'busy').length;
+                const utilization = agents.length > 0 ? busyAgents / agents.length : 0;
+                return {
+                    action,
+                    // CLI expected fields
+                    poolId: 'agent-pool-default',
+                    currentSize: agents.length,
+                    minSize: input.min || 0,
+                    maxSize: input.max || 100,
+                    autoScale: input.autoScale ?? false,
+                    utilization,
+                    agents: agents.map(a => ({
+                        id: a.agentId,
+                        type: a.agentType,
+                        status: a.status,
+                    })),
+                    // Additional fields
+                    id: 'agent-pool-default',
+                    size: agents.length,
+                    totalAgents: agents.length,
+                    byType,
+                    byStatus,
+                    avgHealth: agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 0,
+                };
+            }
+            if (action === 'scale') {
+                const targetSize = input.targetSize || 5;
+                const agentType = input.agentType || 'worker';
+                const currentSize = agents.filter(a => a.agentType === agentType).length;
+                const delta = targetSize - currentSize;
+                const added = [];
+                const removed = [];
+                if (delta > 0) {
+                    for (let i = 0; i < delta; i++) {
+                        const agentId = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                        store.agents[agentId] = {
+                            agentId,
+                            agentType,
+                            status: 'idle',
+                            health: 1.0,
+                            taskCount: 0,
+                            config: {},
+                            createdAt: new Date().toISOString(),
+                        };
+                        added.push(agentId);
                     }
-                    else if (delta < 0) {
-                        toRemove = agents.filter(function (a) { return a.agentType === agentType_1 && a.status === 'idle'; }).slice(0, -delta);
-                        for (_a = 0, toRemove_1 = toRemove; _a < toRemove_1.length; _a++) {
-                            agent = toRemove_1[_a];
-                            store.agents[agent.agentId].status = 'terminated';
-                            removed.push(agent.agentId);
-                        }
+                }
+                else if (delta < 0) {
+                    const toRemove = agents.filter(a => a.agentType === agentType && a.status === 'idle').slice(0, -delta);
+                    for (const agent of toRemove) {
+                        store.agents[agent.agentId].status = 'terminated';
+                        removed.push(agent.agentId);
                     }
-                    saveAgentStore(store);
-                    return [2 /*return*/, {
-                            action: action,
-                            agentType: agentType_1,
-                            previousSize: currentSize,
-                            targetSize: targetSize,
-                            newSize: currentSize + delta,
-                            added: added,
-                            removed: removed
-                        }];
                 }
-                if (action === 'drain') {
-                    agentType = input.agentType;
-                    drained = 0;
-                    for (_b = 0, agents_2 = agents; _b < agents_2.length; _b++) {
-                        agent = agents_2[_b];
-                        if (!agentType || agent.agentType === agentType) {
-                            if (agent.status === 'idle') {
-                                store.agents[agent.agentId].status = 'terminated';
-                                drained++;
-                            }
+                saveAgentStore(store);
+                return {
+                    action,
+                    agentType,
+                    previousSize: currentSize,
+                    targetSize,
+                    newSize: currentSize + delta,
+                    added,
+                    removed,
+                };
+            }
+            if (action === 'drain') {
+                const agentType = input.agentType;
+                let drained = 0;
+                for (const agent of agents) {
+                    if (!agentType || agent.agentType === agentType) {
+                        if (agent.status === 'idle') {
+                            store.agents[agent.agentId].status = 'terminated';
+                            drained++;
                         }
                     }
-                    saveAgentStore(store);
-                    return [2 /*return*/, {
-                            action: action,
-                            agentType: agentType || 'all',
-                            drained: drained,
-                            remaining: agents.length - drained
-                        }];
                 }
-                return [2 /*return*/, { action: action, error: 'Unknown action' }];
-            });
-        }); }
+                saveAgentStore(store);
+                return {
+                    action,
+                    agentType: agentType || 'all',
+                    drained,
+                    remaining: agents.length - drained,
+                };
+            }
+            return { action, error: 'Unknown action' };
+        },
     },
     {
         name: 'agent_health',
@@ -525,74 +430,71 @@ export var agentTools = [
             type: 'object',
             properties: {
                 agentId: { type: 'string', description: 'Specific agent ID (optional)' },
-                threshold: { type: 'number', description: 'Health threshold (0-1)' }
-            }
+                threshold: { type: 'number', description: 'Health threshold (0-1)' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agents, threshold, agent, healthyAgents, degradedAgents, unhealthyAgents, avgHealth, avgCpu, avgMemory;
-            return __generator(this, function (_a) {
-                store = loadAgentStore();
-                agents = Object.values(store.agents).filter(function (a) { return a.status !== 'terminated'; });
-                threshold = input.threshold || 0.5;
-                if (input.agentId) {
-                    agent = store.agents[input.agentId];
-                    if (agent) {
-                        return [2 /*return*/, {
-                                agentId: agent.agentId,
-                                health: agent.health,
-                                status: agent.status,
-                                healthy: agent.health >= threshold,
-                                taskCount: agent.taskCount,
-                                uptime: Date.now() - new Date(agent.createdAt).getTime()
-                            }];
-                    }
-                    return [2 /*return*/, { agentId: input.agentId, error: 'Agent not found' }];
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
+            const threshold = input.threshold || 0.5;
+            if (input.agentId) {
+                const agent = store.agents[input.agentId];
+                if (agent) {
+                    return {
+                        agentId: agent.agentId,
+                        health: agent.health,
+                        status: agent.status,
+                        healthy: agent.health >= threshold,
+                        taskCount: agent.taskCount,
+                        uptime: Date.now() - new Date(agent.createdAt).getTime(),
+                    };
                 }
-                healthyAgents = agents.filter(function (a) { return a.health >= threshold; });
-                degradedAgents = agents.filter(function (a) { return a.health >= 0.3 && a.health < threshold; });
-                unhealthyAgents = agents.filter(function (a) { return a.health < 0.3; });
-                avgHealth = agents.length > 0 ? agents.reduce(function (sum, a) { return sum + a.health; }, 0) / agents.length : 1;
-                avgCpu = agents.length > 0 ? 35 + Math.random() * 30 : 0;
-                avgMemory = avgHealth * 0.6;
-                return [2 /*return*/, {
-                        // CLI expected fields
-                        agents: agents.map(function (a) {
-                            var uptime = Date.now() - new Date(a.createdAt).getTime();
-                            return {
-                                id: a.agentId,
-                                type: a.agentType,
-                                health: a.health >= threshold ? 'healthy' : (a.health >= 0.3 ? 'degraded' : 'unhealthy'),
-                                uptime: uptime,
-                                memory: { used: Math.floor(256 * (1 - a.health * 0.3)), limit: 512 },
-                                cpu: 20 + Math.floor(a.health * 40),
-                                tasks: { active: a.taskCount > 0 ? 1 : 0, queued: 0, completed: a.taskCount, failed: 0 },
-                                latency: { avg: 50 + Math.floor((1 - a.health) * 100), p99: 150 + Math.floor((1 - a.health) * 200) },
-                                errors: { count: a.health < threshold ? 1 : 0 }
-                            };
-                        }),
-                        overall: {
-                            healthy: healthyAgents.length,
-                            degraded: degradedAgents.length,
-                            unhealthy: unhealthyAgents.length,
-                            avgCpu: avgCpu,
-                            avgMemory: avgMemory,
-                            score: Math.round(avgHealth * 100),
-                            issues: unhealthyAgents.length
-                        },
-                        // Additional fields
-                        total: agents.length,
-                        healthyCount: healthyAgents.length,
-                        unhealthyCount: unhealthyAgents.length,
-                        threshold: threshold,
-                        avgHealth: avgHealth,
-                        unhealthyAgents: unhealthyAgents.map(function (a) { return ({
-                            agentId: a.agentId,
-                            health: a.health,
-                            status: a.status
-                        }); })
-                    }];
-            });
-        }); }
+                return { agentId: input.agentId, error: 'Agent not found' };
+            }
+            const healthyAgents = agents.filter(a => a.health >= threshold);
+            const degradedAgents = agents.filter(a => a.health >= 0.3 && a.health < threshold);
+            const unhealthyAgents = agents.filter(a => a.health < 0.3);
+            const avgHealth = agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 1;
+            const avgCpu = agents.length > 0 ? 35 + Math.random() * 30 : 0; // Simulated CPU
+            const avgMemory = avgHealth * 0.6; // Correlated with health
+            return {
+                // CLI expected fields
+                agents: agents.map(a => {
+                    const uptime = Date.now() - new Date(a.createdAt).getTime();
+                    return {
+                        id: a.agentId,
+                        type: a.agentType,
+                        health: a.health >= threshold ? 'healthy' : (a.health >= 0.3 ? 'degraded' : 'unhealthy'),
+                        uptime,
+                        memory: { used: Math.floor(256 * (1 - a.health * 0.3)), limit: 512 },
+                        cpu: 20 + Math.floor(a.health * 40),
+                        tasks: { active: a.taskCount > 0 ? 1 : 0, queued: 0, completed: a.taskCount, failed: 0 },
+                        latency: { avg: 50 + Math.floor((1 - a.health) * 100), p99: 150 + Math.floor((1 - a.health) * 200) },
+                        errors: { count: a.health < threshold ? 1 : 0 },
+                    };
+                }),
+                overall: {
+                    healthy: healthyAgents.length,
+                    degraded: degradedAgents.length,
+                    unhealthy: unhealthyAgents.length,
+                    avgCpu,
+                    avgMemory,
+                    score: Math.round(avgHealth * 100),
+                    issues: unhealthyAgents.length,
+                },
+                // Additional fields
+                total: agents.length,
+                healthyCount: healthyAgents.length,
+                unhealthyCount: unhealthyAgents.length,
+                threshold,
+                avgHealth,
+                unhealthyAgents: unhealthyAgents.map(a => ({
+                    agentId: a.agentId,
+                    health: a.health,
+                    status: a.status,
+                })),
+            };
+        },
     },
     {
         name: 'agent_update',
@@ -605,46 +507,43 @@ export var agentTools = [
                 status: { type: 'string', description: 'New status' },
                 health: { type: 'number', description: 'Health value (0-1)' },
                 taskCount: { type: 'number', description: 'Task count' },
-                config: { type: 'object', description: 'Config updates' }
+                config: { type: 'object', description: 'Config updates' },
             },
-            required: ['agentId']
+            required: ['agentId'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, agentId, agent;
-            return __generator(this, function (_a) {
-                store = loadAgentStore();
-                agentId = input.agentId;
-                agent = store.agents[agentId];
-                if (agent) {
-                    if (input.status)
-                        agent.status = input.status;
-                    if (typeof input.health === 'number')
-                        agent.health = input.health;
-                    if (typeof input.taskCount === 'number')
-                        agent.taskCount = input.taskCount;
-                    if (input.config) {
-                        agent.config = __assign(__assign({}, agent.config), input.config);
-                    }
-                    saveAgentStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            agentId: agentId,
-                            updated: true,
-                            agent: {
-                                agentId: agent.agentId,
-                                status: agent.status,
-                                health: agent.health,
-                                taskCount: agent.taskCount
-                            }
-                        }];
+        handler: async (input) => {
+            const store = loadAgentStore();
+            const agentId = input.agentId;
+            const agent = store.agents[agentId];
+            if (agent) {
+                if (input.status)
+                    agent.status = input.status;
+                if (typeof input.health === 'number')
+                    agent.health = input.health;
+                if (typeof input.taskCount === 'number')
+                    agent.taskCount = input.taskCount;
+                if (input.config) {
+                    agent.config = { ...agent.config, ...input.config };
                 }
-                return [2 /*return*/, {
-                        success: false,
-                        agentId: agentId,
-                        error: 'Agent not found'
-                    }];
-            });
-        }); }
+                saveAgentStore(store);
+                return {
+                    success: true,
+                    agentId,
+                    updated: true,
+                    agent: {
+                        agentId: agent.agentId,
+                        status: agent.status,
+                        health: agent.health,
+                        taskCount: agent.taskCount,
+                    },
+                };
+            }
+            return {
+                success: false,
+                agentId,
+                error: 'Agent not found',
+            };
+        },
     },
 ];
 //# sourceMappingURL=agent-tools.js.map