kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/route.js

@@ -10,48 +10,12 @@
  *
  * Created with love by ruv.io
  */
-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 { createQLearningRouter, isRuvectorAvailable, } from '../ruvector/index.js';
 /**
  * Available agent types for routing
  */
-var AGENT_TYPES = [
+const AGENT_TYPES = [
     { id: 'coder', name: 'Coder', description: 'Implements features and writes code', capabilities: ['coding', 'implementation', 'refactoring'], priority: 1 },
     { id: 'tester', name: 'Tester', description: 'Creates tests and validates functionality', capabilities: ['testing', 'validation', 'quality'], priority: 2 },
     { id: 'reviewer', name: 'Reviewer', description: 'Reviews code quality and security', capabilities: ['review', 'security', 'best-practices'], priority: 3 },
@@ -64,40 +28,31 @@ var AGENT_TYPES = [
 // ============================================================================
 // Router Singleton
 // ============================================================================
-var routerInstance = null;
-var routerInitialized = false;
+let routerInstance = null;
+let routerInitialized = false;
 /**
  * Get or create the router instance
  */
-function getRouter() {
-    return __awaiter(this, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!routerInstance) {
-                        routerInstance = createQLearningRouter();
-                    }
-                    if (!!routerInitialized) return [3 /*break*/, 2];
-                    return [4 /*yield*/, routerInstance.initialize()];
-                case 1:
-                    _a.sent();
-                    routerInitialized = true;
-                    _a.label = 2;
-                case 2: return [2 /*return*/, routerInstance];
-            }
-        });
-    });
+async function getRouter() {
+    if (!routerInstance) {
+        routerInstance = createQLearningRouter();
+    }
+    if (!routerInitialized) {
+        await routerInstance.initialize();
+        routerInitialized = true;
+    }
+    return routerInstance;
 }
 /**
  * Get agent type by route name
  */
 function getAgentType(route) {
-    return AGENT_TYPES.find(function (a) { return a.id === route; });
+    return AGENT_TYPES.find(a => a.id === route);
 }
 // ============================================================================
 // Route Subcommand
 // ============================================================================
-var routeTaskCommand = {
+const routeTaskCommand = {
     name: 'task',
     description: 'Route a task to the optimal agent using Q-Learning',
     options: [
@@ -106,27 +61,27 @@ var routeTaskCommand = {
             short: 'q',
             description: 'Use Q-Learning for agent selection (default: true)',
             type: 'boolean',
-            "default": true
+            default: true,
         },
         {
             name: 'agent',
             short: 'a',
             description: 'Force specific agent (bypasses Q-Learning)',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'explore',
             short: 'e',
             description: 'Enable exploration (random selection chance)',
             type: 'boolean',
-            "default": true
+            default: true,
         },
         {
             name: 'json',
             short: 'j',
             description: 'Output in JSON format',
             type: 'boolean',
-            "default": false
+            default: false,
         },
     ],
     examples: [
@@ -134,137 +89,123 @@ var routeTaskCommand = {
         { command: 'claude-flow route task "write unit tests" --q-learning', description: 'Use Q-Learning routing' },
         { command: 'claude-flow route task "review code" --agent reviewer', description: 'Force specific agent' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var taskDescription, forceAgent, useExploration, jsonOutput, spinner, agent_1, router, result, agent, confidence, confidenceColor, qValues, maxQValue, capabilities, alternatives, error_1;
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    taskDescription = ctx.args[0];
-                    forceAgent = ctx.flags.agent;
-                    useExploration = ctx.flags.explore;
-                    jsonOutput = ctx.flags.json;
-                    if (!taskDescription) {
-                        output.printError('Task description is required');
-                        output.writeln(output.dim('Usage: claude-flow route task "task description"'));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    spinner = output.createSpinner({ text: 'Analyzing task...', spinner: 'dots' });
-                    spinner.start();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    if (forceAgent) {
-                        agent_1 = getAgentType(forceAgent) ||
-                            AGENT_TYPES.find(function (a) { return a.name.toLowerCase() === forceAgent.toLowerCase(); });
-                        if (!agent_1) {
-                            spinner.fail("Agent \"" + forceAgent + "\" not found");
-                            output.writeln();
-                            output.writeln('Available agents:');
-                            output.printList(AGENT_TYPES.map(function (a) { return output.highlight(a.id) + " - " + a.description; }));
-                            return [2 /*return*/, { success: false, exitCode: 1 }];
-                        }
-                        spinner.succeed("Routed to " + agent_1.name);
-                        if (jsonOutput) {
-                            output.printJson({
-                                task: taskDescription,
-                                agentId: agent_1.id,
-                                agentName: agent_1.name,
-                                confidence: 1.0,
-                                method: 'forced'
-                            });
-                        }
-                        else {
-                            output.writeln();
-                            output.printBox([
-                                "Task: " + taskDescription,
-                                "Agent: " + output.highlight(agent_1.name) + " (" + agent_1.id + ")",
-                                "Confidence: " + output.success('100%') + " (forced)",
-                                "Description: " + agent_1.description,
-                            ].join('\n'), 'Routing Result');
-                        }
-                        return [2 /*return*/, { success: true, data: { agentId: agent_1.id, agentName: agent_1.name } }];
-                    }
-                    return [4 /*yield*/, getRouter()];
-                case 2:
-                    router = _b.sent();
-                    result = router.route(taskDescription, useExploration);
-                    agent = getAgentType(result.route) || AGENT_TYPES[0];
-                    spinner.succeed("Routed to " + agent.name);
-                    if (jsonOutput) {
-                        output.printJson({
-                            task: taskDescription,
-                            agentId: result.route,
-                            agentName: agent.name,
-                            confidence: result.confidence,
-                            qValues: result.qValues,
-                            explored: result.explored,
-                            alternatives: result.alternatives.map(function (a) {
-                                var _a;
-                                return ({
-                                    agentId: a.route,
-                                    agentName: ((_a = getAgentType(a.route)) === null || _a === void 0 ? void 0 : _a.name) || a.route,
-                                    score: a.score
-                                });
-                            })
-                        });
-                    }
-                    else {
-                        output.writeln();
-                        confidence = (_a = result.confidence) !== null && _a !== void 0 ? _a : 0;
-                        confidenceColor = confidence >= 0.7
-                            ? function (text) { return output.success(text); }
-                            : confidence >= 0.4
-                                ? function (text) { return output.warning(text); }
-                                : function (text) { return output.error(text); };
-                        qValues = result.qValues || [0];
-                        maxQValue = Math.max.apply(Math, qValues);
-                        capabilities = agent.capabilities || [];
-                        alternatives = result.alternatives || [];
-                        output.printBox([
-                            "Task: " + taskDescription,
-                            "",
-                            "Agent: " + output.highlight(agent.name) + " (" + result.route + ")",
-                            "Confidence: " + confidenceColor((confidence * 100).toFixed(1) + "%"),
-                            "Q-Value: " + maxQValue.toFixed(3),
-                            "Exploration: " + (result.explored ? output.warning('Yes') : 'No'),
-                            "",
-                            "Description: " + agent.description,
-                            "Capabilities: " + capabilities.join(', '),
-                        ].join('\n'), 'Q-Learning Routing');
-                        if (alternatives.length > 0) {
-                            output.writeln();
-                            output.writeln(output.bold('Alternatives:'));
-                            output.printTable({
-                                columns: [
-                                    { key: 'agent', header: 'Agent', width: 20 },
-                                    { key: 'score', header: 'Score', width: 12, align: 'right' },
-                                ],
-                                data: alternatives.map(function (a) {
-                                    var _a, _b;
-                                    return ({
-                                        agent: ((_a = getAgentType(a.route)) === null || _a === void 0 ? void 0 : _a.name) || a.route,
-                                        score: ((_b = a.score) !== null && _b !== void 0 ? _b : 0).toFixed(3)
-                                    });
-                                })
-                            });
-                        }
-                    }
-                    return [2 /*return*/, { success: true, data: { agentId: result.route, result: result } }];
-                case 3:
-                    error_1 = _b.sent();
-                    spinner.fail('Routing failed');
-                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
+    action: async (ctx) => {
+        const taskDescription = ctx.args[0];
+        const forceAgent = ctx.flags.agent;
+        const useExploration = ctx.flags.explore;
+        const jsonOutput = ctx.flags.json;
+        if (!taskDescription) {
+            output.printError('Task description is required');
+            output.writeln(output.dim('Usage: claude-flow route task "task description"'));
+            return { success: false, exitCode: 1 };
+        }
+        const spinner = output.createSpinner({ text: 'Analyzing task...', spinner: 'dots' });
+        spinner.start();
+        try {
+            if (forceAgent) {
+                // Bypass Q-Learning, use specified agent
+                const agent = getAgentType(forceAgent) ||
+                    AGENT_TYPES.find(a => a.name.toLowerCase() === forceAgent.toLowerCase());
+                if (!agent) {
+                    spinner.fail(`Agent "${forceAgent}" not found`);
+                    output.writeln();
+                    output.writeln('Available agents:');
+                    output.printList(AGENT_TYPES.map(a => `${output.highlight(a.id)} - ${a.description}`));
+                    return { success: false, exitCode: 1 };
+                }
+                spinner.succeed(`Routed to ${agent.name}`);
+                if (jsonOutput) {
+                    output.printJson({
+                        task: taskDescription,
+                        agentId: agent.id,
+                        agentName: agent.name,
+                        confidence: 1.0,
+                        method: 'forced',
+                    });
+                }
+                else {
+                    output.writeln();
+                    output.printBox([
+                        `Task: ${taskDescription}`,
+                        `Agent: ${output.highlight(agent.name)} (${agent.id})`,
+                        `Confidence: ${output.success('100%')} (forced)`,
+                        `Description: ${agent.description}`,
+                    ].join('\n'), 'Routing Result');
+                }
+                return { success: true, data: { agentId: agent.id, agentName: agent.name } };
+            }
+            // Use Q-Learning routing
+            const router = await getRouter();
+            const result = router.route(taskDescription, useExploration);
+            const agent = getAgentType(result.route) || AGENT_TYPES[0];
+            spinner.succeed(`Routed to ${agent.name}`);
+            if (jsonOutput) {
+                output.printJson({
+                    task: taskDescription,
+                    agentId: result.route,
+                    agentName: agent.name,
+                    confidence: result.confidence,
+                    qValues: result.qValues,
+                    explored: result.explored,
+                    alternatives: result.alternatives.map(a => ({
+                        agentId: a.route,
+                        agentName: getAgentType(a.route)?.name || a.route,
+                        score: a.score,
+                    })),
+                });
+            }
+            else {
+                output.writeln();
+                const confidence = result.confidence ?? 0;
+                // Use bound methods to preserve `this` context when calling output methods
+                const confidenceColor = confidence >= 0.7
+                    ? (text) => output.success(text)
+                    : confidence >= 0.4
+                        ? (text) => output.warning(text)
+                        : (text) => output.error(text);
+                const qValues = result.qValues || [0];
+                const maxQValue = Math.max(...qValues);
+                const capabilities = agent.capabilities || [];
+                const alternatives = result.alternatives || [];
+                output.printBox([
+                    `Task: ${taskDescription}`,
+                    ``,
+                    `Agent: ${output.highlight(agent.name)} (${result.route})`,
+                    `Confidence: ${confidenceColor(`${(confidence * 100).toFixed(1)}%`)}`,
+                    `Q-Value: ${maxQValue.toFixed(3)}`,
+                    `Exploration: ${result.explored ? output.warning('Yes') : 'No'}`,
+                    ``,
+                    `Description: ${agent.description}`,
+                    `Capabilities: ${capabilities.join(', ')}`,
+                ].join('\n'), 'Q-Learning Routing');
+                if (alternatives.length > 0) {
+                    output.writeln();
+                    output.writeln(output.bold('Alternatives:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'agent', header: 'Agent', width: 20 },
+                            { key: 'score', header: 'Score', width: 12, align: 'right' },
+                        ],
+                        data: alternatives.map(a => ({
+                            agent: getAgentType(a.route)?.name || a.route,
+                            score: (a.score ?? 0).toFixed(3),
+                        })),
+                    });
+                }
             }
-        });
-    }); }
+            return { success: true, data: { agentId: result.route, result } };
+        }
+        catch (error) {
+            spinner.fail('Routing failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // List Agents Subcommand
 // ============================================================================
-var listAgentsCommand = {
+const listAgentsCommand = {
     name: 'list-agents',
     aliases: ['agents', 'ls'],
     description: 'List all available agent types for routing',
@@ -274,57 +215,53 @@ var listAgentsCommand = {
             short: 'j',
             description: 'Output in JSON format',
             type: 'boolean',
-            "default": false
+            default: false,
         },
     ],
     examples: [
         { command: 'claude-flow route list-agents', description: 'List all agents' },
         { command: 'claude-flow route agents --json', description: 'List agents as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var jsonOutput;
-        return __generator(this, function (_a) {
-            jsonOutput = ctx.flags.json;
-            try {
-                if (jsonOutput) {
-                    output.printJson(AGENT_TYPES);
-                }
-                else {
-                    output.writeln();
-                    output.writeln(output.bold('Available Agent Types'));
-                    output.writeln(output.dim('Ordered by priority (highest first)'));
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'id', header: 'ID', width: 15 },
-                            { key: 'name', header: 'Name', width: 15 },
-                            { key: 'priority', header: 'Priority', width: 10, align: 'right' },
-                            { key: 'description', header: 'Description', width: 45 },
-                        ],
-                        data: AGENT_TYPES.map(function (a) { return ({
-                            id: output.highlight(a.id),
-                            name: a.name,
-                            priority: String(a.priority),
-                            description: a.description
-                        }); })
-                    });
-                    output.writeln();
-                    output.writeln(output.dim("Total: " + AGENT_TYPES.length + " agent types"));
-                }
-                return [2 /*return*/, { success: true, data: AGENT_TYPES }];
+    action: async (ctx) => {
+        const jsonOutput = ctx.flags.json;
+        try {
+            if (jsonOutput) {
+                output.printJson(AGENT_TYPES);
             }
-            catch (error) {
-                output.printError(error instanceof Error ? error.message : String(error));
-                return [2 /*return*/, { success: false, exitCode: 1 }];
+            else {
+                output.writeln();
+                output.writeln(output.bold('Available Agent Types'));
+                output.writeln(output.dim('Ordered by priority (highest first)'));
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'id', header: 'ID', width: 15 },
+                        { key: 'name', header: 'Name', width: 15 },
+                        { key: 'priority', header: 'Priority', width: 10, align: 'right' },
+                        { key: 'description', header: 'Description', width: 45 },
+                    ],
+                    data: AGENT_TYPES.map(a => ({
+                        id: output.highlight(a.id),
+                        name: a.name,
+                        priority: String(a.priority),
+                        description: a.description,
+                    })),
+                });
+                output.writeln();
+                output.writeln(output.dim(`Total: ${AGENT_TYPES.length} agent types`));
             }
-            return [2 /*return*/];
-        });
-    }); }
+            return { success: true, data: AGENT_TYPES };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // Stats Subcommand
 // ============================================================================
-var statsCommand = {
+const statsCommand = {
     name: 'stats',
     description: 'Show Q-Learning router statistics',
     options: [
@@ -333,76 +270,64 @@ var statsCommand = {
             short: 'j',
             description: 'Output in JSON format',
             type: 'boolean',
-            "default": false
+            default: false,
         },
     ],
     examples: [
         { command: 'claude-flow route stats', description: 'Show routing statistics' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var jsonOutput, router, stats, ruvectorAvailable, ruvectorStatus, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    jsonOutput = ctx.flags.json;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, getRouter()];
-                case 2:
-                    router = _a.sent();
-                    stats = router.getStats();
-                    return [4 /*yield*/, isRuvectorAvailable()];
-                case 3:
-                    ruvectorAvailable = _a.sent();
-                    ruvectorStatus = {
-                        available: ruvectorAvailable,
-                        wasmAccelerated: stats.useNative === 1,
-                        backend: stats.useNative === 1 ? 'ruvector-native' : 'fallback'
-                    };
-                    if (jsonOutput) {
-                        output.printJson({ stats: stats, ruvector: ruvectorStatus });
-                    }
-                    else {
-                        output.writeln();
-                        output.writeln(output.bold('Q-Learning Router Statistics'));
-                        output.writeln();
-                        output.printTable({
-                            columns: [
-                                { key: 'metric', header: 'Metric', width: 25 },
-                                { key: 'value', header: 'Value', width: 20, align: 'right' },
-                            ],
-                            data: [
-                                { metric: 'Update Count', value: String(stats.updateCount) },
-                                { metric: 'Q-Table Size', value: String(stats.qTableSize) },
-                                { metric: 'Step Count', value: String(stats.stepCount) },
-                                { metric: 'Epsilon', value: stats.epsilon.toFixed(4) },
-                                { metric: 'Avg TD Error', value: stats.avgTDError.toFixed(4) },
-                                { metric: 'Native Backend', value: stats.useNative === 1 ? 'Yes' : 'No' },
-                            ]
-                        });
-                        output.writeln();
-                        output.writeln(output.bold('RuVector Status'));
-                        output.printList([
-                            "Available: " + (ruvectorStatus.available ? output.success('Yes') : output.warning('No (using fallback)')),
-                            "WASM Accelerated: " + (ruvectorStatus.wasmAccelerated ? output.success('Yes') : 'No'),
-                            "Backend: " + ruvectorStatus.backend,
-                        ]);
-                    }
-                    return [2 /*return*/, { success: true, data: { stats: stats, ruvector: ruvectorStatus } }];
-                case 4:
-                    error_2 = _a.sent();
-                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5: return [2 /*return*/];
+    action: async (ctx) => {
+        const jsonOutput = ctx.flags.json;
+        try {
+            const router = await getRouter();
+            const stats = router.getStats();
+            const ruvectorAvailable = await isRuvectorAvailable();
+            const ruvectorStatus = {
+                available: ruvectorAvailable,
+                wasmAccelerated: stats.useNative === 1,
+                backend: stats.useNative === 1 ? 'ruvector-native' : 'fallback',
+            };
+            if (jsonOutput) {
+                output.printJson({ stats, ruvector: ruvectorStatus });
+            }
+            else {
+                output.writeln();
+                output.writeln(output.bold('Q-Learning Router Statistics'));
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'metric', header: 'Metric', width: 25 },
+                        { key: 'value', header: 'Value', width: 20, align: 'right' },
+                    ],
+                    data: [
+                        { metric: 'Update Count', value: String(stats.updateCount) },
+                        { metric: 'Q-Table Size', value: String(stats.qTableSize) },
+                        { metric: 'Step Count', value: String(stats.stepCount) },
+                        { metric: 'Epsilon', value: stats.epsilon.toFixed(4) },
+                        { metric: 'Avg TD Error', value: stats.avgTDError.toFixed(4) },
+                        { metric: 'Native Backend', value: stats.useNative === 1 ? 'Yes' : 'No' },
+                    ],
+                });
+                output.writeln();
+                output.writeln(output.bold('RuVector Status'));
+                output.printList([
+                    `Available: ${ruvectorStatus.available ? output.success('Yes') : output.warning('No (using fallback)')}`,
+                    `WASM Accelerated: ${ruvectorStatus.wasmAccelerated ? output.success('Yes') : 'No'}`,
+                    `Backend: ${ruvectorStatus.backend}`,
+                ]);
             }
-        });
-    }); }
+            return { success: true, data: { stats, ruvector: ruvectorStatus } };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // Feedback Subcommand
 // ============================================================================
-var feedbackCommand = {
+const feedbackCommand = {
     name: 'feedback',
     description: 'Provide feedback on a routing decision',
     options: [
@@ -411,84 +336,75 @@ var feedbackCommand = {
             short: 't',
             description: 'Task description (context for learning)',
             type: 'string',
-            required: true
+            required: true,
         },
         {
             name: 'agent',
             short: 'a',
             description: 'Agent that was used',
             type: 'string',
-            required: true
+            required: true,
         },
         {
             name: 'reward',
             short: 'r',
             description: 'Reward value (-1 to 1, where 1 is best)',
             type: 'number',
-            "default": 0.8
+            default: 0.8,
         },
         {
             name: 'next-task',
             short: 'n',
             description: 'Next task description (for multi-step learning)',
-            type: 'string'
+            type: 'string',
         },
     ],
     examples: [
         { command: 'claude-flow route feedback -t "implement auth" -a coder -r 0.9', description: 'Positive feedback' },
         { command: 'claude-flow route feedback -t "write tests" -a tester -r -0.5', description: 'Negative feedback' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var taskDescription, agentId, reward, nextTask, agent, router, clampedReward, tdError, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    taskDescription = ctx.flags.task;
-                    agentId = ctx.flags.agent;
-                    reward = ctx.flags.reward;
-                    nextTask = ctx.flags['next-task'];
-                    if (!taskDescription || !agentId) {
-                        output.printError('Task description and agent are required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    agent = getAgentType(agentId);
-                    if (!agent) {
-                        output.printError("Unknown agent: " + agentId);
-                        output.writeln('Available agents:');
-                        output.printList(AGENT_TYPES.map(function (a) { return a.id; }));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, getRouter()];
-                case 2:
-                    router = _a.sent();
-                    clampedReward = Math.max(-1, Math.min(1, reward));
-                    tdError = router.update(taskDescription, agentId, clampedReward, nextTask);
-                    output.printSuccess("Feedback recorded for agent \"" + agent.name + "\"");
-                    output.writeln();
-                    output.printBox([
-                        "Task: " + taskDescription,
-                        "Agent: " + agent.name + " (" + agentId + ")",
-                        "Reward: " + (clampedReward >= 0 ? output.success(clampedReward.toFixed(2)) : output.error(clampedReward.toFixed(2))),
-                        "TD Error: " + Math.abs(tdError).toFixed(4),
-                        nextTask ? "Next Task: " + nextTask : '',
-                    ].filter(Boolean).join('\n'), 'Feedback Recorded');
-                    return [2 /*return*/, { success: true, data: { tdError: tdError } }];
-                case 3:
-                    error_3 = _a.sent();
-                    output.printError(error_3 instanceof Error ? error_3.message : String(error_3));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const taskDescription = ctx.flags.task;
+        const agentId = ctx.flags.agent;
+        const reward = ctx.flags.reward;
+        const nextTask = ctx.flags['next-task'];
+        if (!taskDescription || !agentId) {
+            output.printError('Task description and agent are required');
+            return { success: false, exitCode: 1 };
+        }
+        // Validate agent
+        const agent = getAgentType(agentId);
+        if (!agent) {
+            output.printError(`Unknown agent: ${agentId}`);
+            output.writeln('Available agents:');
+            output.printList(AGENT_TYPES.map(a => a.id));
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const router = await getRouter();
+            const clampedReward = Math.max(-1, Math.min(1, reward));
+            const tdError = router.update(taskDescription, agentId, clampedReward, nextTask);
+            output.printSuccess(`Feedback recorded for agent "${agent.name}"`);
+            output.writeln();
+            output.printBox([
+                `Task: ${taskDescription}`,
+                `Agent: ${agent.name} (${agentId})`,
+                `Reward: ${clampedReward >= 0 ? output.success(clampedReward.toFixed(2)) : output.error(clampedReward.toFixed(2))}`,
+                `TD Error: ${Math.abs(tdError).toFixed(4)}`,
+                nextTask ? `Next Task: ${nextTask}` : '',
+            ].filter(Boolean).join('\n'), 'Feedback Recorded');
+            return { success: true, data: { tdError } };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // Reset Subcommand
 // ============================================================================
-var resetCommand = {
+const resetCommand = {
     name: 'reset',
     description: 'Reset the Q-Learning router state',
     options: [
@@ -497,46 +413,36 @@ var resetCommand = {
             short: 'f',
             description: 'Force reset without confirmation',
             type: 'boolean',
-            "default": false
+            default: false,
         },
     ],
     examples: [
         { command: 'claude-flow route reset', description: 'Reset router state' },
         { command: 'claude-flow route reset --force', description: 'Force reset' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var force, router, error_4;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    force = ctx.flags.force;
-                    if (!force && ctx.interactive) {
-                        output.printWarning('This will reset all learned Q-values and statistics.');
-                        output.writeln(output.dim('Use --force to skip this confirmation.'));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, getRouter()];
-                case 2:
-                    router = _a.sent();
-                    router.reset();
-                    output.printSuccess('Q-Learning router state has been reset');
-                    return [2 /*return*/, { success: true }];
-                case 3:
-                    error_4 = _a.sent();
-                    output.printError(error_4 instanceof Error ? error_4.message : String(error_4));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const force = ctx.flags.force;
+        if (!force && ctx.interactive) {
+            output.printWarning('This will reset all learned Q-values and statistics.');
+            output.writeln(output.dim('Use --force to skip this confirmation.'));
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const router = await getRouter();
+            router.reset();
+            output.printSuccess('Q-Learning router state has been reset');
+            return { success: true };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // Export/Import Subcommands
 // ============================================================================
-var exportCommand = {
+const exportCommand = {
     name: 'export',
     description: 'Export Q-table for persistence',
     options: [
@@ -544,49 +450,35 @@ var exportCommand = {
             name: 'file',
             short: 'f',
             description: 'Output file path (outputs to stdout if not specified)',
-            type: 'string'
+            type: 'string',
         },
     ],
     examples: [
         { command: 'claude-flow route export', description: 'Export Q-table to stdout' },
         { command: 'claude-flow route export -f qtable.json', description: 'Export to file' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var filePath, router, data, fs, error_5;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    filePath = ctx.flags.file;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 7, , 8]);
-                    return [4 /*yield*/, getRouter()];
-                case 2:
-                    router = _a.sent();
-                    data = router["export"]();
-                    if (!filePath) return [3 /*break*/, 5];
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 3:
-                    fs = _a.sent();
-                    return [4 /*yield*/, fs.writeFile(filePath, JSON.stringify(data, null, 2))];
-                case 4:
-                    _a.sent();
-                    output.printSuccess("Q-table exported to " + filePath);
-                    return [3 /*break*/, 6];
-                case 5:
-                    output.printJson(data);
-                    _a.label = 6;
-                case 6: return [2 /*return*/, { success: true, data: data }];
-                case 7:
-                    error_5 = _a.sent();
-                    output.printError(error_5 instanceof Error ? error_5.message : String(error_5));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 8: return [2 /*return*/];
+    action: async (ctx) => {
+        const filePath = ctx.flags.file;
+        try {
+            const router = await getRouter();
+            const data = router.export();
+            if (filePath) {
+                const fs = await import('node:fs/promises');
+                await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+                output.printSuccess(`Q-table exported to ${filePath}`);
+            }
+            else {
+                output.printJson(data);
             }
-        });
-    }); }
+            return { success: true, data };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
-var importCommand = {
+const importCommand = {
     name: 'import',
     description: 'Import Q-table from file',
     options: [
@@ -595,52 +487,38 @@ var importCommand = {
             short: 'f',
             description: 'Input file path',
             type: 'string',
-            required: true
+            required: true,
         },
     ],
     examples: [
         { command: 'claude-flow route import -f qtable.json', description: 'Import Q-table from file' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var filePath, fs, content, data, router, error_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    filePath = ctx.flags.file;
-                    if (!filePath) {
-                        output.printError('File path is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 5, , 6]);
-                    return [4 /*yield*/, import('node:fs/promises')];
-                case 2:
-                    fs = _a.sent();
-                    return [4 /*yield*/, fs.readFile(filePath, 'utf-8')];
-                case 3:
-                    content = _a.sent();
-                    data = JSON.parse(content);
-                    return [4 /*yield*/, getRouter()];
-                case 4:
-                    router = _a.sent();
-                    router["import"](data);
-                    output.printSuccess("Q-table imported from " + filePath);
-                    output.writeln(output.dim("Loaded " + Object.keys(data).length + " state entries"));
-                    return [2 /*return*/, { success: true }];
-                case 5:
-                    error_6 = _a.sent();
-                    output.printError(error_6 instanceof Error ? error_6.message : String(error_6));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 6: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const filePath = ctx.flags.file;
+        if (!filePath) {
+            output.printError('File path is required');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const fs = await import('node:fs/promises');
+            const content = await fs.readFile(filePath, 'utf-8');
+            const data = JSON.parse(content);
+            const router = await getRouter();
+            router.import(data);
+            output.printSuccess(`Q-table imported from ${filePath}`);
+            output.writeln(output.dim(`Loaded ${Object.keys(data).length} state entries`));
+            return { success: true };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // Coverage-Aware Routing Subcommand
 // ============================================================================
-var coverageRouteCommand = {
+const coverageRouteCommand = {
     name: 'coverage',
     aliases: ['cov'],
     description: 'Route tasks based on test coverage analysis (ADR-017)',
@@ -649,35 +527,35 @@ var coverageRouteCommand = {
             name: 'path',
             short: 'p',
             description: 'Path to analyze for coverage',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'threshold',
             short: 't',
             description: 'Coverage threshold percentage (default: 80)',
             type: 'number',
-            "default": 80
+            default: 80,
         },
         {
             name: 'suggest',
             short: 's',
             description: 'Get suggestions for improving coverage',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'gaps',
             short: 'g',
             description: 'List coverage gaps with agent assignments',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'json',
             short: 'j',
             description: 'Output in JSON format',
             type: 'boolean',
-            "default": false
+            default: false,
         },
     ],
     examples: [
@@ -686,185 +564,170 @@ var coverageRouteCommand = {
         { command: 'claude-flow route coverage --gaps', description: 'List coverage gaps by agent' },
         { command: 'claude-flow route coverage -p src/auth -t 90', description: 'Analyze specific path with threshold' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var path, threshold, suggestMode, gapsMode, jsonOutput, spinner, _a, coverageRoute, coverageSuggest, coverageGaps, result, _i, _b, _c, agent, files, _d, _e, file, result, routeResult, actionColors, colorFn, error_7;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    path = ctx.flags.path || '';
-                    threshold = ctx.flags.threshold || 80;
-                    suggestMode = ctx.flags.suggest;
-                    gapsMode = ctx.flags.gaps;
-                    jsonOutput = ctx.flags.json;
-                    spinner = output.createSpinner({ text: 'Analyzing coverage...', spinner: 'dots' });
-                    spinner.start();
-                    _f.label = 1;
-                case 1:
-                    _f.trys.push([1, 8, , 9]);
-                    return [4 /*yield*/, import('../ruvector/coverage-router.js')];
-                case 2:
-                    _a = _f.sent(), coverageRoute = _a.coverageRoute, coverageSuggest = _a.coverageSuggest, coverageGaps = _a.coverageGaps;
-                    if (!gapsMode) return [3 /*break*/, 4];
-                    return [4 /*yield*/, coverageGaps({ threshold: threshold, groupByAgent: true })];
-                case 3:
-                    result = _f.sent();
-                    spinner.succeed("Found " + result.totalGaps + " coverage gaps");
-                    if (jsonOutput) {
-                        output.printJson(result);
-                    }
-                    else {
-                        output.writeln();
-                        output.writeln(output.bold('Coverage Gaps by Agent'));
-                        output.writeln(output.dim(result.summary));
-                        output.writeln();
-                        if (Object.keys(result.byAgent).length > 0) {
-                            for (_i = 0, _b = Object.entries(result.byAgent); _i < _b.length; _i++) {
-                                _c = _b[_i], agent = _c[0], files = _c[1];
-                                output.writeln(output.highlight(agent) + " (" + files.length + " files)");
-                                for (_d = 0, _e = files.slice(0, 5); _d < _e.length; _d++) {
-                                    file = _e[_d];
-                                    output.writeln("  " + output.dim('•') + " " + file);
-                                }
-                                if (files.length > 5) {
-                                    output.writeln(output.dim("    ... and " + (files.length - 5) + " more"));
-                                }
-                                output.writeln();
+    action: async (ctx) => {
+        const path = ctx.flags.path || '';
+        const threshold = ctx.flags.threshold || 80;
+        const suggestMode = ctx.flags.suggest;
+        const gapsMode = ctx.flags.gaps;
+        const jsonOutput = ctx.flags.json;
+        const spinner = output.createSpinner({ text: 'Analyzing coverage...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Lazy load coverage router
+            const { coverageRoute, coverageSuggest, coverageGaps } = await import('../ruvector/coverage-router.js');
+            if (gapsMode) {
+                // List coverage gaps with agent assignments
+                const result = await coverageGaps({ threshold, groupByAgent: true });
+                spinner.succeed(`Found ${result.totalGaps} coverage gaps`);
+                if (jsonOutput) {
+                    output.printJson(result);
+                }
+                else {
+                    output.writeln();
+                    output.writeln(output.bold('Coverage Gaps by Agent'));
+                    output.writeln(output.dim(result.summary));
+                    output.writeln();
+                    if (Object.keys(result.byAgent).length > 0) {
+                        for (const [agent, files] of Object.entries(result.byAgent)) {
+                            output.writeln(`${output.highlight(agent)} (${files.length} files)`);
+                            for (const file of files.slice(0, 5)) {
+                                output.writeln(`  ${output.dim('•')} ${file}`);
                             }
+                            if (files.length > 5) {
+                                output.writeln(output.dim(`    ... and ${files.length - 5} more`));
+                            }
+                            output.writeln();
                         }
-                        else {
-                            output.printSuccess('No coverage gaps found!');
-                        }
-                        output.writeln();
-                        output.writeln(output.bold('Top Gaps:'));
-                        output.printTable({
-                            columns: [
-                                { key: 'file', header: 'File', width: 50 },
-                                { key: 'coverage', header: 'Coverage', width: 12, align: 'right' },
-                                { key: 'gap', header: 'Gap', width: 10, align: 'right' },
-                                { key: 'agent', header: 'Agent', width: 15 },
-                            ],
-                            data: result.gaps.slice(0, 10).map(function (g) { return ({
-                                file: g.file.length > 48 ? '...' + g.file.slice(-45) : g.file,
-                                coverage: g.currentCoverage.toFixed(1) + "%",
-                                gap: g.gap.toFixed(1) + "%",
-                                agent: g.suggestedAgent
-                            }); })
-                        });
-                    }
-                    return [2 /*return*/, { success: true, data: result }];
-                case 4:
-                    if (!(suggestMode || path)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, coverageSuggest(path || '.', { threshold: threshold, limit: 20 })];
-                case 5:
-                    result = _f.sent();
-                    spinner.succeed("Found " + result.suggestions.length + " coverage suggestions");
-                    if (jsonOutput) {
-                        output.printJson(result);
                     }
                     else {
-                        output.writeln();
-                        output.writeln(output.bold('Coverage Improvement Suggestions'));
-                        output.writeln(output.dim("Path: " + result.path + ", Threshold: " + threshold + "%"));
-                        output.writeln();
-                        if (result.suggestions.length === 0) {
-                            output.printSuccess('All files meet coverage threshold!');
-                        }
-                        else {
-                            output.writeln("Total Gap: " + output.warning(result.totalGap.toFixed(1) + "%"));
-                            output.writeln("Estimated Effort: " + output.dim(result.estimatedEffort.toFixed(1) + " hours"));
-                            output.writeln();
-                            output.printTable({
-                                columns: [
-                                    { key: 'file', header: 'File', width: 45 },
-                                    { key: 'current', header: 'Current', width: 10, align: 'right' },
-                                    { key: 'target', header: 'Target', width: 10, align: 'right' },
-                                    { key: 'priority', header: 'Priority', width: 10, align: 'right' },
-                                ],
-                                data: result.suggestions.slice(0, 15).map(function (s) { return ({
-                                    file: s.file.length > 43 ? '...' + s.file.slice(-40) : s.file,
-                                    current: s.currentCoverage.toFixed(1) + "%",
-                                    target: s.targetCoverage.toFixed(1) + "%",
-                                    priority: String(s.priority)
-                                }); })
-                            });
-                            // Show test suggestions for top file
-                            if (result.suggestions.length > 0 && result.suggestions[0].suggestedTests.length > 0) {
-                                output.writeln();
-                                output.writeln(output.bold('Suggested Tests for Top Priority File:'));
-                                output.printList(result.suggestions[0].suggestedTests);
-                            }
-                        }
+                        output.printSuccess('No coverage gaps found!');
                     }
-                    return [2 /*return*/, { success: true, data: result }];
-                case 6: return [4 /*yield*/, coverageRoute('', { threshold: threshold })];
-                case 7:
-                    routeResult = _f.sent();
-                    spinner.succeed('Coverage analysis complete');
-                    if (jsonOutput) {
-                        output.printJson(routeResult);
+                    output.writeln();
+                    output.writeln(output.bold('Top Gaps:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'file', header: 'File', width: 50 },
+                            { key: 'coverage', header: 'Coverage', width: 12, align: 'right' },
+                            { key: 'gap', header: 'Gap', width: 10, align: 'right' },
+                            { key: 'agent', header: 'Agent', width: 15 },
+                        ],
+                        data: result.gaps.slice(0, 10).map(g => ({
+                            file: g.file.length > 48 ? '...' + g.file.slice(-45) : g.file,
+                            coverage: `${g.currentCoverage.toFixed(1)}%`,
+                            gap: `${g.gap.toFixed(1)}%`,
+                            agent: g.suggestedAgent,
+                        })),
+                    });
+                }
+                return { success: true, data: result };
+            }
+            if (suggestMode || path) {
+                // Suggest improvements for path
+                const result = await coverageSuggest(path || '.', { threshold, limit: 20 });
+                spinner.succeed(`Found ${result.suggestions.length} coverage suggestions`);
+                if (jsonOutput) {
+                    output.printJson(result);
+                }
+                else {
+                    output.writeln();
+                    output.writeln(output.bold('Coverage Improvement Suggestions'));
+                    output.writeln(output.dim(`Path: ${result.path}, Threshold: ${threshold}%`));
+                    output.writeln();
+                    if (result.suggestions.length === 0) {
+                        output.printSuccess('All files meet coverage threshold!');
                     }
                     else {
+                        output.writeln(`Total Gap: ${output.warning(`${result.totalGap.toFixed(1)}%`)}`);
+                        output.writeln(`Estimated Effort: ${output.dim(`${result.estimatedEffort.toFixed(1)} hours`)}`);
                         output.writeln();
-                        output.writeln(output.bold('Coverage-Aware Routing'));
-                        output.writeln();
-                        actionColors = {
-                            'add-tests': function (s) { return output.error(s); },
-                            'review-coverage': function (s) { return output.warning(s); },
-                            'prioritize': function (s) { return output.error(s); },
-                            'skip': function (s) { return output.success(s); }
-                        };
-                        colorFn = actionColors[routeResult.action] || (function (s) { return s; });
-                        output.printBox([
-                            "Action: " + colorFn(routeResult.action.toUpperCase()),
-                            "Priority: " + routeResult.priority + "/10",
-                            "Impact Score: " + routeResult.impactScore + "%",
-                            "Estimated Effort: " + routeResult.estimatedEffort + " hours",
-                            "",
-                            "Test Types: " + routeResult.testTypes.join(', '),
-                            "Target Files: " + routeResult.targetFiles.length,
-                        ].join('\n'), 'Coverage Analysis');
-                        if (routeResult.targetFiles.length > 0) {
-                            output.writeln();
-                            output.writeln(output.bold('Target Files:'));
-                            output.printList(routeResult.targetFiles.slice(0, 5).map(function (f) {
-                                return f.length > 60 ? '...' + f.slice(-57) : f;
-                            }));
-                            if (routeResult.targetFiles.length > 5) {
-                                output.writeln(output.dim("  ... and " + (routeResult.targetFiles.length - 5) + " more"));
-                            }
-                        }
-                        if (routeResult.gaps.length > 0) {
+                        output.printTable({
+                            columns: [
+                                { key: 'file', header: 'File', width: 45 },
+                                { key: 'current', header: 'Current', width: 10, align: 'right' },
+                                { key: 'target', header: 'Target', width: 10, align: 'right' },
+                                { key: 'priority', header: 'Priority', width: 10, align: 'right' },
+                            ],
+                            data: result.suggestions.slice(0, 15).map(s => ({
+                                file: s.file.length > 43 ? '...' + s.file.slice(-40) : s.file,
+                                current: `${s.currentCoverage.toFixed(1)}%`,
+                                target: `${s.targetCoverage.toFixed(1)}%`,
+                                priority: String(s.priority),
+                            })),
+                        });
+                        // Show test suggestions for top file
+                        if (result.suggestions.length > 0 && result.suggestions[0].suggestedTests.length > 0) {
                             output.writeln();
-                            output.writeln(output.bold('Coverage Gaps:'));
-                            output.printTable({
-                                columns: [
-                                    { key: 'file', header: 'File', width: 40 },
-                                    { key: 'current', header: 'Current', width: 10, align: 'right' },
-                                    { key: 'gap', header: 'Gap', width: 10, align: 'right' },
-                                ],
-                                data: routeResult.gaps.slice(0, 5).map(function (g) { return ({
-                                    file: g.file.length > 38 ? '...' + g.file.slice(-35) : g.file,
-                                    current: g.currentCoverage.toFixed(1) + "%",
-                                    gap: g.gap.toFixed(1) + "%"
-                                }); })
-                            });
+                            output.writeln(output.bold('Suggested Tests for Top Priority File:'));
+                            output.printList(result.suggestions[0].suggestedTests);
                         }
                     }
-                    return [2 /*return*/, { success: true, data: routeResult }];
-                case 8:
-                    error_7 = _f.sent();
-                    spinner.fail('Coverage analysis failed');
-                    output.printError(error_7 instanceof Error ? error_7.message : String(error_7));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 9: return [2 /*return*/];
+                }
+                return { success: true, data: result };
+            }
+            // Default: Route based on coverage analysis
+            const routeResult = await coverageRoute('', { threshold });
+            spinner.succeed('Coverage analysis complete');
+            if (jsonOutput) {
+                output.printJson(routeResult);
+            }
+            else {
+                output.writeln();
+                output.writeln(output.bold('Coverage-Aware Routing'));
+                output.writeln();
+                const actionColors = {
+                    'add-tests': (s) => output.error(s),
+                    'review-coverage': (s) => output.warning(s),
+                    'prioritize': (s) => output.error(s),
+                    'skip': (s) => output.success(s),
+                };
+                const colorFn = actionColors[routeResult.action] || ((s) => s);
+                output.printBox([
+                    `Action: ${colorFn(routeResult.action.toUpperCase())}`,
+                    `Priority: ${routeResult.priority}/10`,
+                    `Impact Score: ${routeResult.impactScore}%`,
+                    `Estimated Effort: ${routeResult.estimatedEffort} hours`,
+                    ``,
+                    `Test Types: ${routeResult.testTypes.join(', ')}`,
+                    `Target Files: ${routeResult.targetFiles.length}`,
+                ].join('\n'), 'Coverage Analysis');
+                if (routeResult.targetFiles.length > 0) {
+                    output.writeln();
+                    output.writeln(output.bold('Target Files:'));
+                    output.printList(routeResult.targetFiles.slice(0, 5).map(f => f.length > 60 ? '...' + f.slice(-57) : f));
+                    if (routeResult.targetFiles.length > 5) {
+                        output.writeln(output.dim(`  ... and ${routeResult.targetFiles.length - 5} more`));
+                    }
+                }
+                if (routeResult.gaps.length > 0) {
+                    output.writeln();
+                    output.writeln(output.bold('Coverage Gaps:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'file', header: 'File', width: 40 },
+                            { key: 'current', header: 'Current', width: 10, align: 'right' },
+                            { key: 'gap', header: 'Gap', width: 10, align: 'right' },
+                        ],
+                        data: routeResult.gaps.slice(0, 5).map(g => ({
+                            file: g.file.length > 38 ? '...' + g.file.slice(-35) : g.file,
+                            current: `${g.currentCoverage.toFixed(1)}%`,
+                            gap: `${g.gap.toFixed(1)}%`,
+                        })),
+                    });
+                }
             }
-        });
-    }); }
+            return { success: true, data: routeResult };
+        }
+        catch (error) {
+            spinner.fail('Coverage analysis failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // ============================================================================
 // Main Route Command
 // ============================================================================
-export var routeCommand = {
+export const routeCommand = {
     name: 'route',
     description: 'Intelligent task-to-agent routing using Q-Learning',
     subcommands: [
@@ -883,13 +746,13 @@ export var routeCommand = {
             short: 'q',
             description: 'Use Q-Learning for agent selection',
             type: 'boolean',
-            "default": true
+            default: true,
         },
         {
             name: 'agent',
             short: 'a',
             description: 'Force specific agent',
-            type: 'string'
+            type: 'string',
         },
     ],
     examples: [
@@ -899,60 +762,52 @@ export var routeCommand = {
         { command: 'claude-flow route list-agents', description: 'List available agents' },
         { command: 'claude-flow route stats', description: 'Show routing statistics' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var result, ruvectorAvailable;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!(ctx.args.length > 0 && routeTaskCommand.action)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, routeTaskCommand.action(ctx)];
-                case 1:
-                    result = _a.sent();
-                    if (result)
-                        return [2 /*return*/, result];
-                    return [2 /*return*/, { success: true }];
-                case 2:
-                    // Show help
-                    output.writeln();
-                    output.writeln(output.bold('Q-Learning Agent Router'));
-                    output.writeln(output.dim('Intelligent task-to-agent routing using reinforcement learning'));
-                    output.writeln();
-                    output.writeln('Usage: claude-flow route <task> [options]');
-                    output.writeln('       claude-flow route <subcommand>');
-                    output.writeln();
-                    output.writeln(output.bold('Subcommands:'));
-                    output.printList([
-                        output.highlight('task') + "         - Route a task to optimal agent",
-                        output.highlight('list-agents') + "  - List available agent types",
-                        output.highlight('stats') + "        - Show router statistics",
-                        output.highlight('feedback') + "     - Provide routing feedback",
-                        output.highlight('reset') + "        - Reset router state",
-                        output.highlight('export') + "       - Export Q-table",
-                        output.highlight('import') + "       - Import Q-table",
-                    ]);
-                    output.writeln();
-                    output.writeln(output.bold('How It Works:'));
-                    output.printList([
-                        'Analyzes task description using hash-based state encoding',
-                        'Uses Q-Learning to learn from routing outcomes',
-                        'Epsilon-greedy exploration for continuous improvement',
-                        'Provides confidence scores and alternatives',
-                    ]);
-                    output.writeln();
-                    return [4 /*yield*/, isRuvectorAvailable()];
-                case 3:
-                    ruvectorAvailable = _a.sent();
-                    output.writeln(output.bold('Backend Status:'));
-                    output.printList([
-                        "RuVector: " + (ruvectorAvailable ? output.success('Available') : output.warning('Fallback mode')),
-                        "Backend: " + (ruvectorAvailable ? 'ruvector-native' : 'JavaScript fallback'),
-                    ]);
-                    output.writeln();
-                    output.writeln(output.dim('Run "claude-flow route <subcommand> --help" for more info'));
-                    return [2 /*return*/, { success: true }];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        // If task description provided directly, route it
+        if (ctx.args.length > 0 && routeTaskCommand.action) {
+            const result = await routeTaskCommand.action(ctx);
+            if (result)
+                return result;
+            return { success: true };
+        }
+        // Show help
+        output.writeln();
+        output.writeln(output.bold('Q-Learning Agent Router'));
+        output.writeln(output.dim('Intelligent task-to-agent routing using reinforcement learning'));
+        output.writeln();
+        output.writeln('Usage: claude-flow route <task> [options]');
+        output.writeln('       claude-flow route <subcommand>');
+        output.writeln();
+        output.writeln(output.bold('Subcommands:'));
+        output.printList([
+            `${output.highlight('task')}         - Route a task to optimal agent`,
+            `${output.highlight('list-agents')}  - List available agent types`,
+            `${output.highlight('stats')}        - Show router statistics`,
+            `${output.highlight('feedback')}     - Provide routing feedback`,
+            `${output.highlight('reset')}        - Reset router state`,
+            `${output.highlight('export')}       - Export Q-table`,
+            `${output.highlight('import')}       - Import Q-table`,
+        ]);
+        output.writeln();
+        output.writeln(output.bold('How It Works:'));
+        output.printList([
+            'Analyzes task description using hash-based state encoding',
+            'Uses Q-Learning to learn from routing outcomes',
+            'Epsilon-greedy exploration for continuous improvement',
+            'Provides confidence scores and alternatives',
+        ]);
+        output.writeln();
+        // Show quick status
+        const ruvectorAvailable = await isRuvectorAvailable();
+        output.writeln(output.bold('Backend Status:'));
+        output.printList([
+            `RuVector: ${ruvectorAvailable ? output.success('Available') : output.warning('Fallback mode')}`,
+            `Backend: ${ruvectorAvailable ? 'ruvector-native' : 'JavaScript fallback'}`,
+        ]);
+        output.writeln();
+        output.writeln(output.dim('Run "claude-flow route <subcommand> --help" for more info'));
+        return { success: true };
+    },
 };
 export default routeCommand;
 //# sourceMappingURL=route.js.map