kynjal-cli 4.0.0 → 4.0.2

package/dist/src/commands/issues.js

@@ -15,57 +15,12 @@
  * - issues rebalance  Rebalance swarm
  * - issues board      Visual board view
  */
-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 };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { output } from '../output.js';
 import { createClaimService } from '../services/claim-service.js';
 // ============================================================================
 // Subcommands
 // ============================================================================
-var listCommand = {
+const listCommand = {
     name: 'list',
     aliases: ['ls'],
     description: 'List all issue claims',
@@ -75,72 +30,56 @@ var listCommand = {
             short: 's',
             description: 'Filter by status',
             type: 'string',
-            choices: ['active', 'paused', 'blocked', 'stealable', 'completed', 'handoff-pending', 'review-requested']
+            choices: ['active', 'paused', 'blocked', 'stealable', 'completed', 'handoff-pending', 'review-requested'],
         },
         {
             name: 'mine',
             short: 'm',
             description: 'Show only my claims',
             type: 'boolean',
-            "default": false
+            default: false,
         },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var service, status, claims, _a, rows;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _b.sent();
-                    status = ctx.flags.status;
-                    if (!status) return [3 /*break*/, 3];
-                    return [4 /*yield*/, service.getByStatus(status)];
-                case 2:
-                    _a = _b.sent();
-                    return [3 /*break*/, 5];
-                case 3: return [4 /*yield*/, service.getAllClaims()];
-                case 4:
-                    _a = _b.sent();
-                    _b.label = 5;
-                case 5:
-                    claims = _a;
-                    if (claims.length === 0) {
-                        output.printInfo('No claims found');
-                        return [2 /*return*/, { success: true, data: { claims: [] } }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Issue Claims (ADR-016)'));
-                    output.writeln();
-                    rows = claims.map(function (c) { return ({
-                        issue: c.issueId,
-                        claimant: c.claimant.type === 'human'
-                            ? "\uD83D\uDC64 " + c.claimant.name
-                            : "\uD83E\uDD16 " + c.claimant.agentType,
-                        status: formatStatus(c.status),
-                        progress: c.progress + "%",
-                        since: formatDuration(Date.now() - c.claimedAt.getTime())
-                    }); });
-                    output.printTable({
-                        columns: [
-                            { key: 'issue', header: 'Issue', width: 12 },
-                            { key: 'claimant', header: 'Claimant', width: 18 },
-                            { key: 'status', header: 'Status', width: 20 },
-                            { key: 'progress', header: 'Progress', width: 10 },
-                            { key: 'since', header: 'Since', width: 10 },
-                        ],
-                        data: rows
-                    });
-                    if (ctx.flags.format === 'json') {
-                        output.printJson(claims);
-                    }
-                    return [2 /*return*/, { success: true, data: { claims: claims } }];
-            }
+    action: async (ctx) => {
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const status = ctx.flags.status;
+        const claims = status
+            ? await service.getByStatus(status)
+            : await service.getAllClaims();
+        if (claims.length === 0) {
+            output.printInfo('No claims found');
+            return { success: true, data: { claims: [] } };
+        }
+        output.writeln();
+        output.writeln(output.bold('Issue Claims (ADR-016)'));
+        output.writeln();
+        const rows = claims.map(c => ({
+            issue: c.issueId,
+            claimant: c.claimant.type === 'human'
+                ? `👤 ${c.claimant.name}`
+                : `🤖 ${c.claimant.agentType}`,
+            status: formatStatus(c.status),
+            progress: `${c.progress}%`,
+            since: formatDuration(Date.now() - c.claimedAt.getTime()),
+        }));
+        output.printTable({
+            columns: [
+                { key: 'issue', header: 'Issue', width: 12 },
+                { key: 'claimant', header: 'Claimant', width: 18 },
+                { key: 'status', header: 'Status', width: 20 },
+                { key: 'progress', header: 'Progress', width: 10 },
+                { key: 'since', header: 'Since', width: 10 },
+            ],
+            data: rows,
         });
-    }); }
+        if (ctx.flags.format === 'json') {
+            output.printJson(claims);
+        }
+        return { success: true, data: { claims } };
+    },
 };
-var claimCommand = {
+const claimCommand = {
     name: 'claim',
     description: 'Claim an issue',
     options: [
@@ -148,69 +87,58 @@ var claimCommand = {
             name: 'issue',
             short: 'i',
             description: 'Issue ID to claim',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'agent',
             short: 'a',
             description: 'Claim as agent (format: type:id)',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'user',
             short: 'u',
             description: 'Claim as user (format: id:name)',
-            type: 'string'
+            type: 'string',
         },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var issueId, agentStr, userStr, claimant, service, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    issueId = (ctx.flags.issue || ctx.args[0]);
-                    agentStr = ctx.flags.agent;
-                    userStr = ctx.flags.user;
-                    if (!issueId) {
-                        output.printError('Issue ID is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!agentStr && !userStr) {
-                        output.printError('Must specify --agent or --user');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    claimant = agentStr
-                        ? {
-                            type: 'agent',
-                            agentType: agentStr.split(':')[0],
-                            agentId: agentStr.split(':')[1] || agentStr.split(':')[0] + "-1"
-                        }
-                        : {
-                            type: 'human',
-                            userId: userStr.split(':')[0],
-                            name: userStr.split(':')[1] || userStr.split(':')[0]
-                        };
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, service.claim(issueId, claimant)];
-                case 2:
-                    result = _a.sent();
-                    if (result.success) {
-                        output.printSuccess("Claimed issue " + issueId);
-                        return [2 /*return*/, { success: true, data: result.claim }];
-                    }
-                    else {
-                        output.printError(result.error || 'Failed to claim issue');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    return [2 /*return*/];
+    action: async (ctx) => {
+        const issueId = (ctx.flags.issue || ctx.args[0]);
+        const agentStr = ctx.flags.agent;
+        const userStr = ctx.flags.user;
+        if (!issueId) {
+            output.printError('Issue ID is required');
+            return { success: false, exitCode: 1 };
+        }
+        if (!agentStr && !userStr) {
+            output.printError('Must specify --agent or --user');
+            return { success: false, exitCode: 1 };
+        }
+        const claimant = agentStr
+            ? {
+                type: 'agent',
+                agentType: agentStr.split(':')[0],
+                agentId: agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`,
             }
-        });
-    }); }
+            : {
+                type: 'human',
+                userId: userStr.split(':')[0],
+                name: userStr.split(':')[1] || userStr.split(':')[0],
+            };
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const result = await service.claim(issueId, claimant);
+        if (result.success) {
+            output.printSuccess(`Claimed issue ${issueId}`);
+            return { success: true, data: result.claim };
+        }
+        else {
+            output.printError(result.error || 'Failed to claim issue');
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
-var releaseCommand = {
+const releaseCommand = {
     name: 'release',
     description: 'Release a claim',
     options: [
@@ -218,130 +146,105 @@ var releaseCommand = {
             name: 'issue',
             short: 'i',
             description: 'Issue ID to release',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'agent',
             short: 'a',
             description: 'Release as agent',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'user',
             short: 'u',
             description: 'Release as user',
-            type: 'string'
+            type: 'string',
         },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var issueId, agentStr, userStr, claimant, service, error_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    issueId = (ctx.flags.issue || ctx.args[0]);
-                    agentStr = ctx.flags.agent;
-                    userStr = ctx.flags.user;
-                    if (!issueId) {
-                        output.printError('Issue ID is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (!agentStr && !userStr) {
-                        output.printError('Must specify --agent or --user');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    claimant = agentStr
-                        ? {
-                            type: 'agent',
-                            agentType: agentStr.split(':')[0],
-                            agentId: agentStr.split(':')[1] || agentStr.split(':')[0] + "-1"
-                        }
-                        : {
-                            type: 'human',
-                            userId: userStr.split(':')[0],
-                            name: userStr.split(':')[1] || userStr.split(':')[0]
-                        };
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, service.release(issueId, claimant)];
-                case 3:
-                    _a.sent();
-                    output.printSuccess("Released claim on issue " + issueId);
-                    return [2 /*return*/, { success: true }];
-                case 4:
-                    error_1 = _a.sent();
-                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5: return [2 /*return*/];
+    action: async (ctx) => {
+        const issueId = (ctx.flags.issue || ctx.args[0]);
+        const agentStr = ctx.flags.agent;
+        const userStr = ctx.flags.user;
+        if (!issueId) {
+            output.printError('Issue ID is required');
+            return { success: false, exitCode: 1 };
+        }
+        if (!agentStr && !userStr) {
+            output.printError('Must specify --agent or --user');
+            return { success: false, exitCode: 1 };
+        }
+        const claimant = agentStr
+            ? {
+                type: 'agent',
+                agentType: agentStr.split(':')[0],
+                agentId: agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`,
             }
-        });
-    }); }
+            : {
+                type: 'human',
+                userId: userStr.split(':')[0],
+                name: userStr.split(':')[1] || userStr.split(':')[0],
+            };
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        try {
+            await service.release(issueId, claimant);
+            output.printSuccess(`Released claim on issue ${issueId}`);
+            return { success: true };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
-var handoffCommand = {
+const handoffCommand = {
     name: 'handoff',
     description: 'Request handoff to another agent/user',
     options: [
         { name: 'issue', short: 'i', type: 'string', description: 'Issue ID' },
         { name: 'to', description: 'Target (agent:type:id or user:id:name)', type: 'string' },
         { name: 'from', description: 'Current owner', type: 'string' },
-        { name: 'reason', short: 'r', type: 'string', description: 'Handoff reason', "default": 'Handoff requested' },
+        { name: 'reason', short: 'r', type: 'string', description: 'Handoff reason', default: 'Handoff requested' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var issueId, toStr, fromStr, reason, to, service, claim, from, error_2;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    issueId = (ctx.flags.issue || ctx.args[0]);
-                    toStr = ctx.flags.to;
-                    fromStr = ctx.flags.from;
-                    reason = ctx.flags.reason;
-                    if (!issueId || !toStr) {
-                        output.printError('Issue ID and --to are required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    to = parseClaimant(toStr);
-                    if (!to) {
-                        output.printError('Invalid --to format. Use agent:type:id or user:id:name');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, service.getIssueStatus(issueId)];
-                case 2:
-                    claim = _a.sent();
-                    if (!claim) {
-                        output.printError("Issue " + issueId + " is not claimed");
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    from = fromStr ? parseClaimant(fromStr) : claim.claimant;
-                    if (!from) {
-                        output.printError('Could not determine current owner');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    _a.label = 3;
-                case 3:
-                    _a.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, service.requestHandoff(issueId, from, to, reason)];
-                case 4:
-                    _a.sent();
-                    output.printSuccess("Handoff requested for issue " + issueId);
-                    return [2 /*return*/, { success: true }];
-                case 5:
-                    error_2 = _a.sent();
-                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 6: return [2 /*return*/];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const issueId = (ctx.flags.issue || ctx.args[0]);
+        const toStr = ctx.flags.to;
+        const fromStr = ctx.flags.from;
+        const reason = ctx.flags.reason;
+        if (!issueId || !toStr) {
+            output.printError('Issue ID and --to are required');
+            return { success: false, exitCode: 1 };
+        }
+        const to = parseClaimant(toStr);
+        if (!to) {
+            output.printError('Invalid --to format. Use agent:type:id or user:id:name');
+            return { success: false, exitCode: 1 };
+        }
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        // Get current claim to find "from"
+        const claim = await service.getIssueStatus(issueId);
+        if (!claim) {
+            output.printError(`Issue ${issueId} is not claimed`);
+            return { success: false, exitCode: 1 };
+        }
+        const from = fromStr ? parseClaimant(fromStr) : claim.claimant;
+        if (!from) {
+            output.printError('Could not determine current owner');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            await service.requestHandoff(issueId, from, to, reason);
+            output.printSuccess(`Handoff requested for issue ${issueId}`);
+            return { success: true };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Update claim status',
     options: [
@@ -350,312 +253,236 @@ var statusCommand = {
         { name: 'progress', short: 'p', type: 'number', description: 'Progress (0-100)' },
         { name: 'note', short: 'n', type: 'string', description: 'Status note' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var issueId, service, newStatus, progress, note, claim, error_3;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    issueId = (ctx.flags.issue || ctx.args[0]);
-                    if (!issueId) {
-                        output.printError('Issue ID is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    newStatus = ctx.flags.set;
-                    progress = ctx.flags.progress;
-                    note = ctx.flags.note;
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 8, , 9]);
-                    if (!newStatus) return [3 /*break*/, 4];
-                    return [4 /*yield*/, service.updateStatus(issueId, newStatus, note)];
-                case 3:
-                    _a.sent();
-                    output.printSuccess("Updated status to " + newStatus);
-                    _a.label = 4;
-                case 4:
-                    if (!(progress !== undefined)) return [3 /*break*/, 6];
-                    return [4 /*yield*/, service.updateProgress(issueId, progress)];
-                case 5:
-                    _a.sent();
-                    output.printSuccess("Updated progress to " + progress + "%");
-                    _a.label = 6;
-                case 6: return [4 /*yield*/, service.getIssueStatus(issueId)];
-                case 7:
-                    claim = _a.sent();
-                    if (claim) {
-                        output.writeln();
-                        output.printBox([
-                            "Issue: " + claim.issueId,
-                            "Status: " + formatStatus(claim.status),
-                            "Progress: " + claim.progress + "%",
-                            "Claimant: " + formatClaimant(claim.claimant),
-                        ].join('\n'), 'Claim Status');
-                    }
-                    return [2 /*return*/, { success: true, data: claim }];
-                case 8:
-                    error_3 = _a.sent();
-                    output.printError(error_3 instanceof Error ? error_3.message : String(error_3));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 9: return [2 /*return*/];
+    action: async (ctx) => {
+        const issueId = (ctx.flags.issue || ctx.args[0]);
+        if (!issueId) {
+            output.printError('Issue ID is required');
+            return { success: false, exitCode: 1 };
+        }
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const newStatus = ctx.flags.set;
+        const progress = ctx.flags.progress;
+        const note = ctx.flags.note;
+        try {
+            if (newStatus) {
+                await service.updateStatus(issueId, newStatus, note);
+                output.printSuccess(`Updated status to ${newStatus}`);
             }
-        });
-    }); }
+            if (progress !== undefined) {
+                await service.updateProgress(issueId, progress);
+                output.printSuccess(`Updated progress to ${progress}%`);
+            }
+            const claim = await service.getIssueStatus(issueId);
+            if (claim) {
+                output.writeln();
+                output.printBox([
+                    `Issue: ${claim.issueId}`,
+                    `Status: ${formatStatus(claim.status)}`,
+                    `Progress: ${claim.progress}%`,
+                    `Claimant: ${formatClaimant(claim.claimant)}`,
+                ].join('\n'), 'Claim Status');
+            }
+            return { success: true, data: claim };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
-var stealableCommand = {
+const stealableCommand = {
     name: 'stealable',
     description: 'List stealable issues',
     options: [
         { name: 'type', short: 't', type: 'string', description: 'Filter by agent type' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var agentType, service, stealable, _i, stealable_1, c;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    agentType = ctx.flags.type;
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, service.getStealable(agentType)];
-                case 2:
-                    stealable = _a.sent();
-                    if (stealable.length === 0) {
-                        output.printInfo('No stealable issues found');
-                        return [2 /*return*/, { success: true, data: { stealable: [] } }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('🎯 Stealable Issues'));
-                    output.writeln();
-                    for (_i = 0, stealable_1 = stealable; _i < stealable_1.length; _i++) {
-                        c = stealable_1[_i];
-                        output.writeln("  " + output.highlight(c.issueId));
-                        output.writeln("    Owner: " + formatClaimant(c.claimant));
-                        output.writeln("    Progress: " + c.progress + "%");
-                        if (c.context)
-                            output.writeln("    Context: " + c.context.slice(0, 60) + "...");
-                        output.writeln();
-                    }
-                    return [2 /*return*/, { success: true, data: { stealable: stealable } }];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const agentType = ctx.flags.type;
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const stealable = await service.getStealable(agentType);
+        if (stealable.length === 0) {
+            output.printInfo('No stealable issues found');
+            return { success: true, data: { stealable: [] } };
+        }
+        output.writeln();
+        output.writeln(output.bold('🎯 Stealable Issues'));
+        output.writeln();
+        for (const c of stealable) {
+            output.writeln(`  ${output.highlight(c.issueId)}`);
+            output.writeln(`    Owner: ${formatClaimant(c.claimant)}`);
+            output.writeln(`    Progress: ${c.progress}%`);
+            if (c.context)
+                output.writeln(`    Context: ${c.context.slice(0, 60)}...`);
+            output.writeln();
+        }
+        return { success: true, data: { stealable } };
+    },
 };
-var stealCommand = {
+const stealCommand = {
     name: 'steal',
     description: 'Steal a stealable issue',
     options: [
         { name: 'issue', short: 'i', type: 'string', description: 'Issue ID' },
         { name: 'agent', short: 'a', type: 'string', description: 'Steal as agent', required: true },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var issueId, agentStr, stealer, service, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    issueId = (ctx.flags.issue || ctx.args[0]);
-                    agentStr = ctx.flags.agent;
-                    if (!issueId) {
-                        output.printError('Issue ID is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    stealer = {
-                        type: 'agent',
-                        agentType: agentStr.split(':')[0],
-                        agentId: agentStr.split(':')[1] || agentStr.split(':')[0] + "-1"
-                    };
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, service.steal(issueId, stealer)];
-                case 2:
-                    result = _a.sent();
-                    if (result.success) {
-                        output.printSuccess("\uD83C\uDFAF Stole issue " + issueId);
-                        if (result.previousOwner) {
-                            output.printInfo("Previous: " + formatClaimant(result.previousOwner));
-                        }
-                        if (result.context) {
-                            output.printInfo("Progress: " + result.context.progress + "%");
-                        }
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    else {
-                        output.printError(result.error || 'Failed to steal issue');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    return [2 /*return*/];
+    action: async (ctx) => {
+        const issueId = (ctx.flags.issue || ctx.args[0]);
+        const agentStr = ctx.flags.agent;
+        if (!issueId) {
+            output.printError('Issue ID is required');
+            return { success: false, exitCode: 1 };
+        }
+        const stealer = {
+            type: 'agent',
+            agentType: agentStr.split(':')[0],
+            agentId: agentStr.split(':')[1] || `${agentStr.split(':')[0]}-1`,
+        };
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const result = await service.steal(issueId, stealer);
+        if (result.success) {
+            output.printSuccess(`🎯 Stole issue ${issueId}`);
+            if (result.previousOwner) {
+                output.printInfo(`Previous: ${formatClaimant(result.previousOwner)}`);
             }
-        });
-    }); }
+            if (result.context) {
+                output.printInfo(`Progress: ${result.context.progress}%`);
+            }
+            return { success: true, data: result };
+        }
+        else {
+            output.printError(result.error || 'Failed to steal issue');
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
-var loadCommand = {
+const loadCommand = {
     name: 'load',
     description: 'View agent load distribution',
     options: [
         { name: 'agent', short: 'a', type: 'string', description: 'Specific agent ID' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var agentId, service, load, claims, agentLoads, _i, claims_1, claim, id, existing, _a, agentLoads_1, _b, id, data, bar;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    agentId = ctx.flags.agent;
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _c.sent();
-                    if (!agentId) return [3 /*break*/, 3];
-                    return [4 /*yield*/, service.getAgentLoad(agentId)];
-                case 2:
-                    load = _c.sent();
-                    output.writeln();
-                    output.writeln(output.bold("\uD83D\uDCCA Load: " + agentId));
-                    output.writeln();
-                    output.printList([
-                        "Claims: " + load.claimCount + "/" + load.maxClaims,
-                        "Utilization: " + (load.utilization * 100).toFixed(0) + "%",
-                        "Blocked: " + load.currentBlockedCount,
-                    ]);
-                    return [2 /*return*/, { success: true, data: load }];
-                case 3: return [4 /*yield*/, service.getAllClaims()];
-                case 4:
-                    claims = _c.sent();
-                    agentLoads = new Map();
-                    for (_i = 0, claims_1 = claims; _i < claims_1.length; _i++) {
-                        claim = claims_1[_i];
-                        if (claim.claimant.type === 'agent') {
-                            id = claim.claimant.agentId;
-                            existing = agentLoads.get(id);
-                            agentLoads.set(id, {
-                                count: ((existing === null || existing === void 0 ? void 0 : existing.count) || 0) + 1,
-                                type: claim.claimant.agentType
-                            });
-                        }
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('📊 Agent Load Distribution'));
-                    output.writeln();
-                    if (agentLoads.size === 0) {
-                        output.printInfo('No agent claims found');
-                    }
-                    else {
-                        for (_a = 0, agentLoads_1 = agentLoads; _a < agentLoads_1.length; _a++) {
-                            _b = agentLoads_1[_a], id = _b[0], data = _b[1];
-                            bar = '█'.repeat(data.count) + '░'.repeat(Math.max(0, 5 - data.count));
-                            output.writeln("  " + id + " (" + data.type + "): " + bar + " " + data.count);
-                        }
-                    }
-                    return [2 /*return*/, { success: true, data: Object.fromEntries(agentLoads) }];
+    action: async (ctx) => {
+        const agentId = ctx.flags.agent;
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        if (agentId) {
+            const load = await service.getAgentLoad(agentId);
+            output.writeln();
+            output.writeln(output.bold(`📊 Load: ${agentId}`));
+            output.writeln();
+            output.printList([
+                `Claims: ${load.claimCount}/${load.maxClaims}`,
+                `Utilization: ${(load.utilization * 100).toFixed(0)}%`,
+                `Blocked: ${load.currentBlockedCount}`,
+            ]);
+            return { success: true, data: load };
+        }
+        const claims = await service.getAllClaims();
+        const agentLoads = new Map();
+        for (const claim of claims) {
+            if (claim.claimant.type === 'agent') {
+                const id = claim.claimant.agentId;
+                const existing = agentLoads.get(id);
+                agentLoads.set(id, {
+                    count: (existing?.count || 0) + 1,
+                    type: claim.claimant.agentType,
+                });
             }
-        });
-    }); }
+        }
+        output.writeln();
+        output.writeln(output.bold('📊 Agent Load Distribution'));
+        output.writeln();
+        if (agentLoads.size === 0) {
+            output.printInfo('No agent claims found');
+        }
+        else {
+            for (const [id, data] of agentLoads) {
+                const bar = '█'.repeat(data.count) + '░'.repeat(Math.max(0, 5 - data.count));
+                output.writeln(`  ${id} (${data.type}): ${bar} ${data.count}`);
+            }
+        }
+        return { success: true, data: Object.fromEntries(agentLoads) };
+    },
 };
-var rebalanceCommand = {
+const rebalanceCommand = {
     name: 'rebalance',
     description: 'Rebalance work across swarm',
     options: [
-        { name: 'dry-run', type: 'boolean', "default": true, description: 'Preview only' },
-        { name: 'apply', type: 'boolean', "default": false, description: 'Apply changes' },
+        { name: 'dry-run', type: 'boolean', default: true, description: 'Preview only' },
+        { name: 'apply', type: 'boolean', default: false, description: 'Apply changes' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var apply, service, result, _i, _a, s, from, to;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    apply = ctx.flags.apply;
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _b.sent();
-                    return [4 /*yield*/, service.rebalance('default')];
-                case 2:
-                    result = _b.sent();
-                    if (result.suggested.length === 0) {
-                        output.printSuccess('⚖️ Swarm is balanced');
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold(apply ? '⚖️ Rebalancing' : '⚖️ Rebalance Preview'));
-                    output.writeln();
-                    for (_i = 0, _a = result.suggested; _i < _a.length; _i++) {
-                        s = _a[_i];
-                        from = s.currentOwner.type === 'agent' ? s.currentOwner.agentId : s.currentOwner.name;
-                        to = s.suggestedOwner.type === 'agent' ? s.suggestedOwner.agentId : s.suggestedOwner.name;
-                        output.writeln("  " + s.issueId + ": " + from + " \u2192 " + to);
-                    }
-                    if (!apply) {
-                        output.writeln();
-                        output.printInfo('Use --apply to execute');
-                    }
-                    return [2 /*return*/, { success: true, data: result }];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const apply = ctx.flags.apply;
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const result = await service.rebalance('default');
+        if (result.suggested.length === 0) {
+            output.printSuccess('⚖️ Swarm is balanced');
+            return { success: true, data: result };
+        }
+        output.writeln();
+        output.writeln(output.bold(apply ? '⚖️ Rebalancing' : '⚖️ Rebalance Preview'));
+        output.writeln();
+        for (const s of result.suggested) {
+            const from = s.currentOwner.type === 'agent' ? s.currentOwner.agentId : s.currentOwner.name;
+            const to = s.suggestedOwner.type === 'agent' ? s.suggestedOwner.agentId : s.suggestedOwner.name;
+            output.writeln(`  ${s.issueId}: ${from} → ${to}`);
+        }
+        if (!apply) {
+            output.writeln();
+            output.printInfo('Use --apply to execute');
+        }
+        return { success: true, data: result };
+    },
 };
-var boardCommand = {
+const boardCommand = {
     name: 'board',
     description: 'Visual board view of claims',
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var service, claims, byStatus, _i, claims_2, c, key, columns, headers, maxRows, _loop_1, i;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    service = createClaimService(ctx.cwd);
-                    return [4 /*yield*/, service.initialize()];
-                case 1:
-                    _a.sent();
-                    return [4 /*yield*/, service.getAllClaims()];
-                case 2:
-                    claims = _a.sent();
-                    byStatus = {
-                        active: [],
-                        blocked: [],
-                        'review-requested': [],
-                        stealable: [],
-                        completed: []
-                    };
-                    for (_i = 0, claims_2 = claims; _i < claims_2.length; _i++) {
-                        c = claims_2[_i];
-                        key = c.status in byStatus ? c.status : 'active';
-                        byStatus[key].push(c);
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('📋 Issue Board (ADR-016)'));
-                    output.writeln();
-                    columns = ['active', 'blocked', 'review-requested', 'stealable', 'completed'];
-                    headers = ['🔵 Active', '🔴 Blocked', '🟡 Review', '🟢 Stealable', '✅ Done'];
-                    // Print column headers
-                    output.writeln(headers.map(function (h) { return h.padEnd(18); }).join(''));
-                    output.writeln('─'.repeat(90));
-                    maxRows = Math.max.apply(Math, __spreadArray(__spreadArray([], Object.values(byStatus).map(function (arr) { return arr.length; }), false), [1], false));
-                    _loop_1 = function (i) {
-                        var row = columns.map(function (col) {
-                            var item = byStatus[col][i];
-                            if (!item)
-                                return ''.padEnd(18);
-                            var owner = item.claimant.type === 'agent' ? item.claimant.agentType.slice(0, 6) : item.claimant.name.slice(0, 6);
-                            return ("#" + item.issueId + " (" + owner + ")").padEnd(18);
-                        });
-                        output.writeln(row.join(''));
-                    };
-                    for (i = 0; i < maxRows; i++) {
-                        _loop_1(i);
-                    }
-                    return [2 /*return*/, { success: true }];
-            }
-        });
-    }); }
+    action: async (ctx) => {
+        const service = createClaimService(ctx.cwd);
+        await service.initialize();
+        const claims = await service.getAllClaims();
+        const byStatus = {
+            active: [],
+            blocked: [],
+            'review-requested': [],
+            stealable: [],
+            completed: [],
+        };
+        for (const c of claims) {
+            const key = c.status in byStatus ? c.status : 'active';
+            byStatus[key].push(c);
+        }
+        output.writeln();
+        output.writeln(output.bold('📋 Issue Board (ADR-016)'));
+        output.writeln();
+        const columns = ['active', 'blocked', 'review-requested', 'stealable', 'completed'];
+        const headers = ['🔵 Active', '🔴 Blocked', '🟡 Review', '🟢 Stealable', '✅ Done'];
+        // Print column headers
+        output.writeln(headers.map(h => h.padEnd(18)).join(''));
+        output.writeln('─'.repeat(90));
+        // Find max rows
+        const maxRows = Math.max(...Object.values(byStatus).map(arr => arr.length), 1);
+        for (let i = 0; i < maxRows; i++) {
+            const row = columns.map(col => {
+                const item = byStatus[col][i];
+                if (!item)
+                    return ''.padEnd(18);
+                const owner = item.claimant.type === 'agent' ? item.claimant.agentType.slice(0, 6) : item.claimant.name.slice(0, 6);
+                return `#${item.issueId} (${owner})`.padEnd(18);
+            });
+            output.writeln(row.join(''));
+        }
+        return { success: true };
+    },
 };
 // ============================================================================
 // Main Command
 // ============================================================================
-export var issuesCommand = {
+export const issuesCommand = {
     name: 'issues',
     description: 'Collaborative issue claims for human-agent workflows (ADR-016)',
     subcommands: [
@@ -678,36 +505,34 @@ export var issuesCommand = {
         { command: 'claude-flow issues steal 123 --agent coder:coder-2', description: 'Steal issue' },
         { command: 'claude-flow issues board', description: 'Visual board' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('📋 Issue Claims (ADR-016)'));
-            output.writeln(output.dim('Collaborative human-agent issue management'));
-            output.writeln();
-            output.writeln('Commands:');
-            output.printList([
-                'list       - List all claims',
-                'claim      - Claim an issue',
-                'release    - Release a claim',
-                'handoff    - Request handoff',
-                'status     - Update status/progress',
-                'stealable  - List stealable issues',
-                'steal      - Steal an issue',
-                'load       - View agent load',
-                'rebalance  - Rebalance swarm',
-                'board      - Visual board view',
-            ]);
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('📋 Issue Claims (ADR-016)'));
+        output.writeln(output.dim('Collaborative human-agent issue management'));
+        output.writeln();
+        output.writeln('Commands:');
+        output.printList([
+            'list       - List all claims',
+            'claim      - Claim an issue',
+            'release    - Release a claim',
+            'handoff    - Request handoff',
+            'status     - Update status/progress',
+            'stealable  - List stealable issues',
+            'steal      - Steal an issue',
+            'load       - View agent load',
+            'rebalance  - Rebalance swarm',
+            'board      - Visual board view',
+        ]);
+        return { success: true };
+    },
 };
 // ============================================================================
 // Helpers
 // ============================================================================
 function parseClaimant(str) {
-    var parts = str.split(':');
+    const parts = str.split(':');
     if (parts[0] === 'agent' && parts.length >= 2) {
-        return { type: 'agent', agentType: parts[1], agentId: parts[2] || parts[1] + "-1" };
+        return { type: 'agent', agentType: parts[1], agentId: parts[2] || `${parts[1]}-1` };
     }
     if (parts[0] === 'user' && parts.length >= 2) {
         return { type: 'human', userId: parts[1], name: parts[2] || parts[1] };
@@ -715,28 +540,28 @@ function parseClaimant(str) {
     return null;
 }
 function formatClaimant(c) {
-    return c.type === 'human' ? "\uD83D\uDC64 " + c.name : "\uD83E\uDD16 " + c.agentType + ":" + c.agentId;
+    return c.type === 'human' ? `👤 ${c.name}` : `🤖 ${c.agentType}:${c.agentId}`;
 }
 function formatStatus(status) {
-    var icons = {
+    const icons = {
         active: '🔵',
         paused: '⏸️',
         blocked: '🔴',
         stealable: '🟢',
         completed: '✅',
         'handoff-pending': '🔄',
-        'review-requested': '🟡'
+        'review-requested': '🟡',
     };
-    return (icons[status] || '❓') + " " + status;
+    return `${icons[status] || '❓'} ${status}`;
 }
 function formatDuration(ms) {
-    var minutes = Math.floor(ms / 60000);
+    const minutes = Math.floor(ms / 60000);
     if (minutes < 60)
-        return minutes + "m";
-    var hours = Math.floor(minutes / 60);
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
     if (hours < 24)
-        return hours + "h";
-    return Math.floor(hours / 24) + "d";
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
 }
 export default issuesCommand;
 //# sourceMappingURL=issues.js.map