kynjal-cli 4.0.0 → 4.0.1

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

@@ -6,75 +6,28 @@
  *
  * @module @claude-flow/cli/mcp-tools/claims
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 // File-based persistence
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
-var CLAIMS_DIR = '.claude-flow/claims';
-var CLAIMS_FILE = 'claims.json';
+const CLAIMS_DIR = '.claude-flow/claims';
+const CLAIMS_FILE = 'claims.json';
 function getClaimsPath() {
     return resolve(join(CLAIMS_DIR, CLAIMS_FILE));
 }
 function ensureClaimsDir() {
-    var dir = resolve(CLAIMS_DIR);
+    const dir = resolve(CLAIMS_DIR);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadClaims() {
     try {
-        var path = getClaimsPath();
+        const path = getClaimsPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch (_a) {
+    catch {
         // Return empty store on error
     }
     return { claims: {}, stealable: {}, contests: {} };
@@ -85,11 +38,11 @@ function saveClaims(store) {
 }
 function formatClaimant(claimant) {
     return claimant.type === 'human'
-        ? "human:" + claimant.userId + ":" + claimant.name
-        : "agent:" + claimant.agentId + ":" + claimant.agentType;
+        ? `human:${claimant.userId}:${claimant.name}`
+        : `agent:${claimant.agentId}:${claimant.agentType}`;
 }
 function parseClaimant(str) {
-    var parts = str.split(':');
+    const parts = str.split(':');
     if (parts[0] === 'human' && parts.length >= 3) {
         return { type: 'human', userId: parts[1], name: parts.slice(2).join(':') };
     }
@@ -98,7 +51,7 @@ function parseClaimant(str) {
     }
     return null;
 }
-export var claimsTools = [
+export const claimsTools = [
     {
         name: 'claims_claim',
         description: 'Claim an issue for work (human or agent)',
@@ -108,58 +61,55 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID or GitHub issue number'
+                    description: 'Issue ID or GitHub issue number',
                 },
                 claimant: {
                     type: 'string',
-                    description: 'Claimant identifier (e.g., "human:user-1:Alice" or "agent:coder-1:coder")'
+                    description: 'Claimant identifier (e.g., "human:user-1:Alice" or "agent:coder-1:coder")',
                 },
                 context: {
                     type: 'string',
-                    description: 'Optional context about the work approach'
-                }
+                    description: 'Optional context about the work approach',
+                },
             },
-            required: ['issueId', 'claimant']
+            required: ['issueId', 'claimant'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, claimantStr, context, claimant, store, existing, now, claim;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                claimantStr = input.claimant;
-                context = input.context;
-                claimant = parseClaimant(claimantStr);
-                if (!claimant) {
-                    return [2 /*return*/, { success: false, error: 'Invalid claimant format. Use "human:userId:name" or "agent:agentId:agentType"' }];
-                }
-                store = loadClaims();
-                // Check if already claimed
-                if (store.claims[issueId]) {
-                    existing = store.claims[issueId];
-                    return [2 /*return*/, {
-                            success: false,
-                            error: "Issue already claimed by " + formatClaimant(existing.claimant),
-                            existingClaim: existing
-                        }];
-                }
-                now = new Date().toISOString();
-                claim = {
-                    issueId: issueId,
-                    claimant: claimant,
-                    claimedAt: now,
-                    status: 'active',
-                    statusChangedAt: now,
-                    progress: 0,
-                    context: context
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const claimantStr = input.claimant;
+            const context = input.context;
+            const claimant = parseClaimant(claimantStr);
+            if (!claimant) {
+                return { success: false, error: 'Invalid claimant format. Use "human:userId:name" or "agent:agentId:agentType"' };
+            }
+            const store = loadClaims();
+            // Check if already claimed
+            if (store.claims[issueId]) {
+                const existing = store.claims[issueId];
+                return {
+                    success: false,
+                    error: `Issue already claimed by ${formatClaimant(existing.claimant)}`,
+                    existingClaim: existing,
                 };
-                store.claims[issueId] = claim;
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        claim: claim,
-                        message: "Issue " + issueId + " claimed by " + formatClaimant(claimant)
-                    }];
-            });
-        }); }
+            }
+            const now = new Date().toISOString();
+            const claim = {
+                issueId,
+                claimant,
+                claimedAt: now,
+                status: 'active',
+                statusChangedAt: now,
+                progress: 0,
+                context,
+            };
+            store.claims[issueId] = claim;
+            saveClaims(store);
+            return {
+                success: true,
+                claim,
+                message: `Issue ${issueId} claimed by ${formatClaimant(claimant)}`,
+            };
+        },
     },
     {
         name: 'claims_release',
@@ -170,49 +120,46 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID to release'
+                    description: 'Issue ID to release',
                 },
                 claimant: {
                     type: 'string',
-                    description: 'Claimant identifier (must match current owner)'
+                    description: 'Claimant identifier (must match current owner)',
                 },
                 reason: {
                     type: 'string',
-                    description: 'Reason for releasing'
-                }
+                    description: 'Reason for releasing',
+                },
             },
-            required: ['issueId', 'claimant']
+            required: ['issueId', 'claimant'],
+        },
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const claimantStr = input.claimant;
+            const reason = input.reason;
+            const claimant = parseClaimant(claimantStr);
+            if (!claimant) {
+                return { success: false, error: 'Invalid claimant format' };
+            }
+            const store = loadClaims();
+            const claim = store.claims[issueId];
+            if (!claim) {
+                return { success: false, error: 'Issue is not claimed' };
+            }
+            // Verify ownership
+            if (formatClaimant(claim.claimant) !== formatClaimant(claimant)) {
+                return { success: false, error: 'Only the current claimant can release' };
+            }
+            delete store.claims[issueId];
+            delete store.stealable[issueId];
+            saveClaims(store);
+            return {
+                success: true,
+                message: `Issue ${issueId} released`,
+                reason,
+                previousClaim: claim,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, claimantStr, reason, claimant, store, claim;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                claimantStr = input.claimant;
-                reason = input.reason;
-                claimant = parseClaimant(claimantStr);
-                if (!claimant) {
-                    return [2 /*return*/, { success: false, error: 'Invalid claimant format' }];
-                }
-                store = loadClaims();
-                claim = store.claims[issueId];
-                if (!claim) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not claimed' }];
-                }
-                // Verify ownership
-                if (formatClaimant(claim.claimant) !== formatClaimant(claimant)) {
-                    return [2 /*return*/, { success: false, error: 'Only the current claimant can release' }];
-                }
-                delete store.claims[issueId];
-                delete store.stealable[issueId];
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        message: "Issue " + issueId + " released",
-                        reason: reason,
-                        previousClaim: claim
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_handoff',
@@ -223,63 +170,60 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID to handoff'
+                    description: 'Issue ID to handoff',
                 },
                 from: {
                     type: 'string',
-                    description: 'Current claimant identifier'
+                    description: 'Current claimant identifier',
                 },
                 to: {
                     type: 'string',
-                    description: 'Target claimant identifier'
+                    description: 'Target claimant identifier',
                 },
                 reason: {
                     type: 'string',
-                    description: 'Reason for handoff'
+                    description: 'Reason for handoff',
                 },
                 progress: {
                     type: 'number',
-                    description: 'Current progress percentage (0-100)'
-                }
+                    description: 'Current progress percentage (0-100)',
+                },
             },
-            required: ['issueId', 'from', 'to']
+            required: ['issueId', 'from', 'to'],
+        },
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const fromStr = input.from;
+            const toStr = input.to;
+            const reason = input.reason;
+            const progress = input.progress || 0;
+            const from = parseClaimant(fromStr);
+            const to = parseClaimant(toStr);
+            if (!from || !to) {
+                return { success: false, error: 'Invalid claimant format' };
+            }
+            const store = loadClaims();
+            const claim = store.claims[issueId];
+            if (!claim) {
+                return { success: false, error: 'Issue is not claimed' };
+            }
+            if (formatClaimant(claim.claimant) !== formatClaimant(from)) {
+                return { success: false, error: 'Only the current claimant can request handoff' };
+            }
+            const now = new Date().toISOString();
+            claim.status = 'handoff-pending';
+            claim.statusChangedAt = now;
+            claim.handoffTo = to;
+            claim.handoffReason = reason;
+            claim.progress = progress;
+            store.claims[issueId] = claim;
+            saveClaims(store);
+            return {
+                success: true,
+                claim,
+                message: `Handoff requested from ${formatClaimant(from)} to ${formatClaimant(to)}`,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, fromStr, toStr, reason, progress, from, to, store, claim, now;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                fromStr = input.from;
-                toStr = input.to;
-                reason = input.reason;
-                progress = input.progress || 0;
-                from = parseClaimant(fromStr);
-                to = parseClaimant(toStr);
-                if (!from || !to) {
-                    return [2 /*return*/, { success: false, error: 'Invalid claimant format' }];
-                }
-                store = loadClaims();
-                claim = store.claims[issueId];
-                if (!claim) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not claimed' }];
-                }
-                if (formatClaimant(claim.claimant) !== formatClaimant(from)) {
-                    return [2 /*return*/, { success: false, error: 'Only the current claimant can request handoff' }];
-                }
-                now = new Date().toISOString();
-                claim.status = 'handoff-pending';
-                claim.statusChangedAt = now;
-                claim.handoffTo = to;
-                claim.handoffReason = reason;
-                claim.progress = progress;
-                store.claims[issueId] = claim;
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        claim: claim,
-                        message: "Handoff requested from " + formatClaimant(from) + " to " + formatClaimant(to)
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_accept-handoff',
@@ -290,52 +234,49 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID with pending handoff'
+                    description: 'Issue ID with pending handoff',
                 },
                 claimant: {
                     type: 'string',
-                    description: 'Claimant accepting the handoff'
-                }
+                    description: 'Claimant accepting the handoff',
+                },
             },
-            required: ['issueId', 'claimant']
+            required: ['issueId', 'claimant'],
+        },
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const claimantStr = input.claimant;
+            const claimant = parseClaimant(claimantStr);
+            if (!claimant) {
+                return { success: false, error: 'Invalid claimant format' };
+            }
+            const store = loadClaims();
+            const claim = store.claims[issueId];
+            if (!claim) {
+                return { success: false, error: 'Issue is not claimed' };
+            }
+            if (claim.status !== 'handoff-pending') {
+                return { success: false, error: 'No pending handoff for this issue' };
+            }
+            if (!claim.handoffTo || formatClaimant(claim.handoffTo) !== formatClaimant(claimant)) {
+                return { success: false, error: 'You are not the target of this handoff' };
+            }
+            const previousOwner = claim.claimant;
+            const now = new Date().toISOString();
+            claim.claimant = claimant;
+            claim.status = 'active';
+            claim.statusChangedAt = now;
+            claim.handoffTo = undefined;
+            claim.handoffReason = undefined;
+            store.claims[issueId] = claim;
+            saveClaims(store);
+            return {
+                success: true,
+                claim,
+                previousOwner,
+                message: `Handoff accepted. ${formatClaimant(claimant)} now owns issue ${issueId}`,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, claimantStr, claimant, store, claim, previousOwner, now;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                claimantStr = input.claimant;
-                claimant = parseClaimant(claimantStr);
-                if (!claimant) {
-                    return [2 /*return*/, { success: false, error: 'Invalid claimant format' }];
-                }
-                store = loadClaims();
-                claim = store.claims[issueId];
-                if (!claim) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not claimed' }];
-                }
-                if (claim.status !== 'handoff-pending') {
-                    return [2 /*return*/, { success: false, error: 'No pending handoff for this issue' }];
-                }
-                if (!claim.handoffTo || formatClaimant(claim.handoffTo) !== formatClaimant(claimant)) {
-                    return [2 /*return*/, { success: false, error: 'You are not the target of this handoff' }];
-                }
-                previousOwner = claim.claimant;
-                now = new Date().toISOString();
-                claim.claimant = claimant;
-                claim.status = 'active';
-                claim.statusChangedAt = now;
-                claim.handoffTo = undefined;
-                claim.handoffReason = undefined;
-                store.claims[issueId] = claim;
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        claim: claim,
-                        previousOwner: previousOwner,
-                        message: "Handoff accepted. " + formatClaimant(claimant) + " now owns issue " + issueId
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_status',
@@ -346,54 +287,51 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID'
+                    description: 'Issue ID',
                 },
                 status: {
                     type: 'string',
                     description: 'New status',
-                    "enum": ['active', 'paused', 'blocked', 'review-requested', 'completed']
+                    enum: ['active', 'paused', 'blocked', 'review-requested', 'completed'],
                 },
                 note: {
                     type: 'string',
-                    description: 'Status note or reason'
+                    description: 'Status note or reason',
                 },
                 progress: {
                     type: 'number',
-                    description: 'Current progress percentage'
-                }
+                    description: 'Current progress percentage',
+                },
             },
-            required: ['issueId', 'status']
+            required: ['issueId', 'status'],
+        },
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const status = input.status;
+            const note = input.note;
+            const progress = input.progress;
+            const store = loadClaims();
+            const claim = store.claims[issueId];
+            if (!claim) {
+                return { success: false, error: 'Issue is not claimed' };
+            }
+            const now = new Date().toISOString();
+            claim.status = status;
+            claim.statusChangedAt = now;
+            if (status === 'blocked') {
+                claim.blockReason = note;
+            }
+            if (progress !== undefined) {
+                claim.progress = Math.min(100, Math.max(0, progress));
+            }
+            store.claims[issueId] = claim;
+            saveClaims(store);
+            return {
+                success: true,
+                claim,
+                message: `Issue ${issueId} status updated to ${status}`,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, status, note, progress, store, claim, now;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                status = input.status;
-                note = input.note;
-                progress = input.progress;
-                store = loadClaims();
-                claim = store.claims[issueId];
-                if (!claim) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not claimed' }];
-                }
-                now = new Date().toISOString();
-                claim.status = status;
-                claim.statusChangedAt = now;
-                if (status === 'blocked') {
-                    claim.blockReason = note;
-                }
-                if (progress !== undefined) {
-                    claim.progress = Math.min(100, Math.max(0, progress));
-                }
-                store.claims[issueId] = claim;
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        claim: claim,
-                        message: "Issue " + issueId + " status updated to " + status
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_list',
@@ -405,45 +343,40 @@ export var claimsTools = [
                 status: {
                     type: 'string',
                     description: 'Filter by status',
-                    "enum": ['active', 'paused', 'blocked', 'stealable', 'completed', 'all']
+                    enum: ['active', 'paused', 'blocked', 'stealable', 'completed', 'all'],
                 },
                 claimant: {
                     type: 'string',
-                    description: 'Filter by claimant'
+                    description: 'Filter by claimant',
                 },
                 agentType: {
                     type: 'string',
-                    description: 'Filter by agent type'
-                }
+                    description: 'Filter by agent type',
+                },
+            },
+        },
+        handler: async (input) => {
+            const status = input.status;
+            const claimantFilter = input.claimant;
+            const agentType = input.agentType;
+            const store = loadClaims();
+            let claims = Object.values(store.claims);
+            if (status && status !== 'all') {
+                claims = claims.filter(c => c.status === status);
+            }
+            if (claimantFilter) {
+                claims = claims.filter(c => formatClaimant(c.claimant).includes(claimantFilter));
             }
+            if (agentType) {
+                claims = claims.filter(c => c.claimant.type === 'agent' && c.claimant.agentType === agentType);
+            }
+            return {
+                success: true,
+                claims,
+                count: claims.length,
+                stealableCount: Object.keys(store.stealable).length,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var status, claimantFilter, agentType, store, claims;
-            return __generator(this, function (_a) {
-                status = input.status;
-                claimantFilter = input.claimant;
-                agentType = input.agentType;
-                store = loadClaims();
-                claims = Object.values(store.claims);
-                if (status && status !== 'all') {
-                    claims = claims.filter(function (c) { return c.status === status; });
-                }
-                if (claimantFilter) {
-                    claims = claims.filter(function (c) { return formatClaimant(c.claimant).includes(claimantFilter); });
-                }
-                if (agentType) {
-                    claims = claims.filter(function (c) {
-                        return c.claimant.type === 'agent' && c.claimant.agentType === agentType;
-                    });
-                }
-                return [2 /*return*/, {
-                        success: true,
-                        claims: claims,
-                        count: claims.length,
-                        stealableCount: Object.keys(store.stealable).length
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_mark-stealable',
@@ -454,57 +387,54 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID to mark stealable'
+                    description: 'Issue ID to mark stealable',
                 },
                 reason: {
                     type: 'string',
                     description: 'Reason for marking stealable',
-                    "enum": ['overloaded', 'stale', 'blocked-timeout', 'voluntary']
+                    enum: ['overloaded', 'stale', 'blocked-timeout', 'voluntary'],
                 },
                 preferredTypes: {
                     type: 'array',
                     description: 'Preferred agent types to steal',
-                    items: { type: 'string' }
+                    items: { type: 'string' },
                 },
                 context: {
                     type: 'string',
-                    description: 'Handoff context for the stealer'
-                }
+                    description: 'Handoff context for the stealer',
+                },
             },
-            required: ['issueId', 'reason']
+            required: ['issueId', 'reason'],
+        },
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const reason = input.reason;
+            const preferredTypes = input.preferredTypes;
+            const context = input.context;
+            const store = loadClaims();
+            const claim = store.claims[issueId];
+            if (!claim) {
+                return { success: false, error: 'Issue is not claimed' };
+            }
+            const now = new Date().toISOString();
+            claim.status = 'stealable';
+            claim.statusChangedAt = now;
+            store.stealable[issueId] = {
+                reason,
+                stealableAt: now,
+                preferredTypes,
+                progress: claim.progress,
+                context,
+            };
+            store.claims[issueId] = claim;
+            saveClaims(store);
+            return {
+                success: true,
+                claim,
+                stealableInfo: store.stealable[issueId],
+                message: `Issue ${issueId} marked as stealable (${reason})`,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, reason, preferredTypes, context, store, claim, now;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                reason = input.reason;
-                preferredTypes = input.preferredTypes;
-                context = input.context;
-                store = loadClaims();
-                claim = store.claims[issueId];
-                if (!claim) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not claimed' }];
-                }
-                now = new Date().toISOString();
-                claim.status = 'stealable';
-                claim.statusChangedAt = now;
-                store.stealable[issueId] = {
-                    reason: reason,
-                    stealableAt: now,
-                    preferredTypes: preferredTypes,
-                    progress: claim.progress,
-                    context: context
-                };
-                store.claims[issueId] = claim;
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        claim: claim,
-                        stealableInfo: store.stealable[issueId],
-                        message: "Issue " + issueId + " marked as stealable (" + reason + ")"
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_steal',
@@ -515,60 +445,57 @@ export var claimsTools = [
             properties: {
                 issueId: {
                     type: 'string',
-                    description: 'Issue ID to steal'
+                    description: 'Issue ID to steal',
                 },
                 stealer: {
                     type: 'string',
-                    description: 'Claimant stealing the issue'
-                }
+                    description: 'Claimant stealing the issue',
+                },
             },
-            required: ['issueId', 'stealer']
+            required: ['issueId', 'stealer'],
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var issueId, stealerStr, stealer, store, claim, stealableInfo, previousOwner, now;
-            return __generator(this, function (_a) {
-                issueId = input.issueId;
-                stealerStr = input.stealer;
-                stealer = parseClaimant(stealerStr);
-                if (!stealer) {
-                    return [2 /*return*/, { success: false, error: 'Invalid claimant format' }];
-                }
-                store = loadClaims();
-                claim = store.claims[issueId];
-                stealableInfo = store.stealable[issueId];
-                if (!claim) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not claimed' }];
-                }
-                if (!stealableInfo) {
-                    return [2 /*return*/, { success: false, error: 'Issue is not stealable' }];
-                }
-                // Check preferred types
-                if (stealableInfo.preferredTypes && stealableInfo.preferredTypes.length > 0) {
-                    if (stealer.type === 'agent' && !stealableInfo.preferredTypes.includes(stealer.agentType)) {
-                        return [2 /*return*/, {
-                                success: false,
-                                error: "Issue prefers agent types: " + stealableInfo.preferredTypes.join(', ')
-                            }];
-                    }
+        handler: async (input) => {
+            const issueId = input.issueId;
+            const stealerStr = input.stealer;
+            const stealer = parseClaimant(stealerStr);
+            if (!stealer) {
+                return { success: false, error: 'Invalid claimant format' };
+            }
+            const store = loadClaims();
+            const claim = store.claims[issueId];
+            const stealableInfo = store.stealable[issueId];
+            if (!claim) {
+                return { success: false, error: 'Issue is not claimed' };
+            }
+            if (!stealableInfo) {
+                return { success: false, error: 'Issue is not stealable' };
+            }
+            // Check preferred types
+            if (stealableInfo.preferredTypes && stealableInfo.preferredTypes.length > 0) {
+                if (stealer.type === 'agent' && !stealableInfo.preferredTypes.includes(stealer.agentType)) {
+                    return {
+                        success: false,
+                        error: `Issue prefers agent types: ${stealableInfo.preferredTypes.join(', ')}`,
+                    };
                 }
-                previousOwner = claim.claimant;
-                now = new Date().toISOString();
-                claim.claimant = stealer;
-                claim.status = 'active';
-                claim.statusChangedAt = now;
-                claim.context = stealableInfo.context;
-                delete store.stealable[issueId];
-                store.claims[issueId] = claim;
-                saveClaims(store);
-                return [2 /*return*/, {
-                        success: true,
-                        claim: claim,
-                        previousOwner: previousOwner,
-                        stealableInfo: stealableInfo,
-                        message: "Issue " + issueId + " stolen by " + formatClaimant(stealer)
-                    }];
-            });
-        }); }
+            }
+            const previousOwner = claim.claimant;
+            const now = new Date().toISOString();
+            claim.claimant = stealer;
+            claim.status = 'active';
+            claim.statusChangedAt = now;
+            claim.context = stealableInfo.context;
+            delete store.stealable[issueId];
+            store.claims[issueId] = claim;
+            saveClaims(store);
+            return {
+                success: true,
+                claim,
+                previousOwner,
+                stealableInfo,
+                message: `Issue ${issueId} stolen by ${formatClaimant(stealer)}`,
+            };
+        },
     },
     {
         name: 'claims_stealable',
@@ -579,31 +506,27 @@ export var claimsTools = [
             properties: {
                 agentType: {
                     type: 'string',
-                    description: 'Filter by preferred agent type'
-                }
+                    description: 'Filter by preferred agent type',
+                },
+            },
+        },
+        handler: async (input) => {
+            const agentType = input.agentType;
+            const store = loadClaims();
+            let stealableIssues = Object.entries(store.stealable).map(([issueId, info]) => ({
+                issueId,
+                ...info,
+                claim: store.claims[issueId],
+            }));
+            if (agentType) {
+                stealableIssues = stealableIssues.filter(s => !s.preferredTypes || s.preferredTypes.length === 0 || s.preferredTypes.includes(agentType));
             }
+            return {
+                success: true,
+                stealable: stealableIssues,
+                count: stealableIssues.length,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var agentType, store, stealableIssues;
-            return __generator(this, function (_a) {
-                agentType = input.agentType;
-                store = loadClaims();
-                stealableIssues = Object.entries(store.stealable).map(function (_a) {
-                    var issueId = _a[0], info = _a[1];
-                    return (__assign(__assign({ issueId: issueId }, info), { claim: store.claims[issueId] }));
-                });
-                if (agentType) {
-                    stealableIssues = stealableIssues.filter(function (s) {
-                        return !s.preferredTypes || s.preferredTypes.length === 0 || s.preferredTypes.includes(agentType);
-                    });
-                }
-                return [2 /*return*/, {
-                        success: true,
-                        stealable: stealableIssues,
-                        count: stealableIssues.length
-                    }];
-            });
-        }); }
     },
     {
         name: 'claims_load',
@@ -614,72 +537,69 @@ export var claimsTools = [
             properties: {
                 agentId: {
                     type: 'string',
-                    description: 'Specific agent ID (optional)'
+                    description: 'Specific agent ID (optional)',
                 },
                 agentType: {
                     type: 'string',
-                    description: 'Filter by agent type'
-                }
-            }
+                    description: 'Filter by agent type',
+                },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var agentId, agentType, store, claims, agentLoads, _i, claims_1, claim, key, load, loads, result;
-            return __generator(this, function (_a) {
-                agentId = input.agentId;
-                agentType = input.agentType;
-                store = loadClaims();
-                claims = Object.values(store.claims);
-                agentLoads = new Map();
-                for (_i = 0, claims_1 = claims; _i < claims_1.length; _i++) {
-                    claim = claims_1[_i];
-                    if (claim.claimant.type !== 'agent')
-                        continue;
-                    key = claim.claimant.agentId;
-                    if (!agentLoads.has(key)) {
-                        agentLoads.set(key, {
-                            agentId: key,
-                            agentType: claim.claimant.agentType,
-                            claims: [],
-                            blockedCount: 0
-                        });
-                    }
-                    load = agentLoads.get(key);
-                    load.claims.push(claim);
-                    if (claim.status === 'blocked') {
-                        load.blockedCount++;
-                    }
-                }
-                loads = Array.from(agentLoads.values());
-                if (agentId) {
-                    loads = loads.filter(function (l) { return l.agentId === agentId; });
+        handler: async (input) => {
+            const agentId = input.agentId;
+            const agentType = input.agentType;
+            const store = loadClaims();
+            const claims = Object.values(store.claims);
+            // Group claims by agent
+            const agentLoads = new Map();
+            for (const claim of claims) {
+                if (claim.claimant.type !== 'agent')
+                    continue;
+                const key = claim.claimant.agentId;
+                if (!agentLoads.has(key)) {
+                    agentLoads.set(key, {
+                        agentId: key,
+                        agentType: claim.claimant.agentType,
+                        claims: [],
+                        blockedCount: 0,
+                    });
                 }
-                if (agentType) {
-                    loads = loads.filter(function (l) { return l.agentType === agentType; });
+                const load = agentLoads.get(key);
+                load.claims.push(claim);
+                if (claim.status === 'blocked') {
+                    load.blockedCount++;
                 }
-                result = loads.map(function (l) { return ({
-                    agentId: l.agentId,
-                    agentType: l.agentType,
-                    claimCount: l.claims.length,
-                    maxClaims: 5,
-                    utilization: l.claims.length / 5,
-                    blockedCount: l.blockedCount,
-                    claims: l.claims.map(function (c) { return ({
-                        issueId: c.issueId,
-                        status: c.status,
-                        progress: c.progress
-                    }); })
-                }); });
-                return [2 /*return*/, {
-                        success: true,
-                        loads: result,
-                        totalAgents: result.length,
-                        totalClaims: claims.filter(function (c) { return c.claimant.type === 'agent'; }).length,
-                        avgUtilization: result.length > 0
-                            ? result.reduce(function (sum, l) { return sum + l.utilization; }, 0) / result.length
-                            : 0
-                    }];
-            });
-        }); }
+            }
+            let loads = Array.from(agentLoads.values());
+            if (agentId) {
+                loads = loads.filter(l => l.agentId === agentId);
+            }
+            if (agentType) {
+                loads = loads.filter(l => l.agentType === agentType);
+            }
+            const result = loads.map(l => ({
+                agentId: l.agentId,
+                agentType: l.agentType,
+                claimCount: l.claims.length,
+                maxClaims: 5, // Default max
+                utilization: l.claims.length / 5,
+                blockedCount: l.blockedCount,
+                claims: l.claims.map(c => ({
+                    issueId: c.issueId,
+                    status: c.status,
+                    progress: c.progress,
+                })),
+            }));
+            return {
+                success: true,
+                loads: result,
+                totalAgents: result.length,
+                totalClaims: claims.filter(c => c.claimant.type === 'agent').length,
+                avgUtilization: result.length > 0
+                    ? result.reduce((sum, l) => sum + l.utilization, 0) / result.length
+                    : 0,
+            };
+        },
     },
     {
         name: 'claims_board',
@@ -687,52 +607,48 @@ export var claimsTools = [
         category: 'claims',
         inputSchema: {
             type: 'object',
-            properties: {}
+            properties: {},
         },
-        handler: function () { return __awaiter(void 0, void 0, void 0, function () {
-            var store, claims, byStatus, _i, claims_2, claim, humanClaims, agentClaims;
-            return __generator(this, function (_a) {
-                store = loadClaims();
-                claims = Object.values(store.claims);
-                byStatus = {
-                    active: [],
-                    paused: [],
-                    blocked: [],
-                    'handoff-pending': [],
-                    'review-requested': [],
-                    stealable: [],
-                    completed: []
-                };
-                for (_i = 0, claims_2 = claims; _i < claims_2.length; _i++) {
-                    claim = claims_2[_i];
-                    if (byStatus[claim.status]) {
-                        byStatus[claim.status].push(claim);
-                    }
+        handler: async () => {
+            const store = loadClaims();
+            const claims = Object.values(store.claims);
+            const byStatus = {
+                active: [],
+                paused: [],
+                blocked: [],
+                'handoff-pending': [],
+                'review-requested': [],
+                stealable: [],
+                completed: [],
+            };
+            for (const claim of claims) {
+                if (byStatus[claim.status]) {
+                    byStatus[claim.status].push(claim);
                 }
-                humanClaims = claims.filter(function (c) { return c.claimant.type === 'human'; });
-                agentClaims = claims.filter(function (c) { return c.claimant.type === 'agent'; });
-                return [2 /*return*/, {
-                        success: true,
-                        board: {
-                            active: byStatus.active.map(function (c) { return ({ issueId: c.issueId, claimant: formatClaimant(c.claimant), progress: c.progress }); }),
-                            paused: byStatus.paused.map(function (c) { return ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) }); }),
-                            blocked: byStatus.blocked.map(function (c) { return ({ issueId: c.issueId, claimant: formatClaimant(c.claimant), reason: c.blockReason }); }),
-                            'handoff-pending': byStatus['handoff-pending'].map(function (c) { return ({ issueId: c.issueId, from: formatClaimant(c.claimant), to: c.handoffTo ? formatClaimant(c.handoffTo) : null }); }),
-                            'review-requested': byStatus['review-requested'].map(function (c) { return ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) }); }),
-                            stealable: byStatus.stealable.map(function (c) { return ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) }); }),
-                            completed: byStatus.completed.map(function (c) { return ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) }); })
-                        },
-                        summary: {
-                            total: claims.length,
-                            active: byStatus.active.length,
-                            blocked: byStatus.blocked.length,
-                            stealable: byStatus.stealable.length,
-                            humanClaims: humanClaims.length,
-                            agentClaims: agentClaims.length
-                        }
-                    }];
-            });
-        }); }
+            }
+            const humanClaims = claims.filter(c => c.claimant.type === 'human');
+            const agentClaims = claims.filter(c => c.claimant.type === 'agent');
+            return {
+                success: true,
+                board: {
+                    active: byStatus.active.map(c => ({ issueId: c.issueId, claimant: formatClaimant(c.claimant), progress: c.progress })),
+                    paused: byStatus.paused.map(c => ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) })),
+                    blocked: byStatus.blocked.map(c => ({ issueId: c.issueId, claimant: formatClaimant(c.claimant), reason: c.blockReason })),
+                    'handoff-pending': byStatus['handoff-pending'].map(c => ({ issueId: c.issueId, from: formatClaimant(c.claimant), to: c.handoffTo ? formatClaimant(c.handoffTo) : null })),
+                    'review-requested': byStatus['review-requested'].map(c => ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) })),
+                    stealable: byStatus.stealable.map(c => ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) })),
+                    completed: byStatus.completed.map(c => ({ issueId: c.issueId, claimant: formatClaimant(c.claimant) })),
+                },
+                summary: {
+                    total: claims.length,
+                    active: byStatus.active.length,
+                    blocked: byStatus.blocked.length,
+                    stealable: byStatus.stealable.length,
+                    humanClaims: humanClaims.length,
+                    agentClaims: agentClaims.length,
+                },
+            };
+        },
     },
     {
         name: 'claims_rebalance',
@@ -744,80 +660,72 @@ export var claimsTools = [
                 dryRun: {
                     type: 'boolean',
                     description: 'Preview rebalancing without applying',
-                    "default": true
+                    default: true,
                 },
                 targetUtilization: {
                     type: 'number',
                     description: 'Target utilization (0-1)',
-                    "default": 0.7
-                }
-            }
+                    default: 0.7,
+                },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var dryRun, targetUtilization, store, claims, agentLoads, _i, claims_3, claim, key, loads, maxClaims, avgLoad, overloaded, underloaded, suggestions, _loop_1, _a, overloaded_1, over;
-            return __generator(this, function (_b) {
-                dryRun = input.dryRun !== false;
-                targetUtilization = input.targetUtilization || 0.7;
-                store = loadClaims();
-                claims = Object.values(store.claims);
-                agentLoads = new Map();
-                for (_i = 0, claims_3 = claims; _i < claims_3.length; _i++) {
-                    claim = claims_3[_i];
-                    if (claim.claimant.type !== 'agent')
-                        continue;
-                    key = claim.claimant.agentId;
-                    if (!agentLoads.has(key)) {
-                        agentLoads.set(key, { agentId: key, agentType: claim.claimant.agentType, claims: [] });
-                    }
-                    agentLoads.get(key).claims.push(claim);
-                }
-                loads = Array.from(agentLoads.values());
-                maxClaims = 5;
-                avgLoad = loads.length > 0
-                    ? loads.reduce(function (sum, l) { return sum + l.claims.length; }, 0) / loads.length
-                    : 0;
-                overloaded = loads.filter(function (l) { return l.claims.length > maxClaims * targetUtilization * 1.5; });
-                underloaded = loads.filter(function (l) { return l.claims.length < maxClaims * targetUtilization * 0.5; });
-                suggestions = [];
-                _loop_1 = function (over) {
-                    // Find low-progress claims to redistribute
-                    var movable = over.claims
-                        .filter(function (c) { return c.progress < 25 && c.status === 'active'; })
-                        .slice(0, over.claims.length - Math.ceil(maxClaims * targetUtilization));
-                    for (var _c = 0, movable_1 = movable; _c < movable_1.length; _c++) {
-                        var claim = movable_1[_c];
-                        var target = underloaded.find(function (u) { return u.agentType === over.agentType && u.claims.length < maxClaims; });
-                        if (target) {
-                            suggestions.push({
-                                issueId: claim.issueId,
-                                from: "agent:" + over.agentId + ":" + over.agentType,
-                                to: "agent:" + target.agentId + ":" + target.agentType,
-                                reason: 'Load balancing'
-                            });
-                        }
+        handler: async (input) => {
+            const dryRun = input.dryRun !== false;
+            const targetUtilization = input.targetUtilization || 0.7;
+            const store = loadClaims();
+            const claims = Object.values(store.claims);
+            // Group by agent
+            const agentLoads = new Map();
+            for (const claim of claims) {
+                if (claim.claimant.type !== 'agent')
+                    continue;
+                const key = claim.claimant.agentId;
+                if (!agentLoads.has(key)) {
+                    agentLoads.set(key, { agentId: key, agentType: claim.claimant.agentType, claims: [] });
+                }
+                agentLoads.get(key).claims.push(claim);
+            }
+            const loads = Array.from(agentLoads.values());
+            const maxClaims = 5;
+            const avgLoad = loads.length > 0
+                ? loads.reduce((sum, l) => sum + l.claims.length, 0) / loads.length
+                : 0;
+            const overloaded = loads.filter(l => l.claims.length > maxClaims * targetUtilization * 1.5);
+            const underloaded = loads.filter(l => l.claims.length < maxClaims * targetUtilization * 0.5);
+            const suggestions = [];
+            for (const over of overloaded) {
+                // Find low-progress claims to redistribute
+                const movable = over.claims
+                    .filter(c => c.progress < 25 && c.status === 'active')
+                    .slice(0, over.claims.length - Math.ceil(maxClaims * targetUtilization));
+                for (const claim of movable) {
+                    const target = underloaded.find(u => u.agentType === over.agentType && u.claims.length < maxClaims);
+                    if (target) {
+                        suggestions.push({
+                            issueId: claim.issueId,
+                            from: `agent:${over.agentId}:${over.agentType}`,
+                            to: `agent:${target.agentId}:${target.agentType}`,
+                            reason: 'Load balancing',
+                        });
                     }
-                };
-                for (_a = 0, overloaded_1 = overloaded; _a < overloaded_1.length; _a++) {
-                    over = overloaded_1[_a];
-                    _loop_1(over);
                 }
-                return [2 /*return*/, {
-                        success: true,
-                        dryRun: dryRun,
-                        suggestions: suggestions,
-                        metrics: {
-                            totalAgents: loads.length,
-                            avgLoad: avgLoad,
-                            overloadedCount: overloaded.length,
-                            underloadedCount: underloaded.length,
-                            targetUtilization: targetUtilization
-                        },
-                        message: dryRun
-                            ? "Found " + suggestions.length + " rebalancing opportunities (dry run)"
-                            : "Applied " + suggestions.length + " rebalancing moves"
-                    }];
-            });
-        }); }
+            }
+            return {
+                success: true,
+                dryRun,
+                suggestions,
+                metrics: {
+                    totalAgents: loads.length,
+                    avgLoad,
+                    overloadedCount: overloaded.length,
+                    underloadedCount: underloaded.length,
+                    targetUtilization,
+                },
+                message: dryRun
+                    ? `Found ${suggestions.length} rebalancing opportunities (dry run)`
+                    : `Applied ${suggestions.length} rebalancing moves`,
+            };
+        },
     },
 ];
 export default claimsTools;