kynjal-cli 3.1.3 → 4.0.0

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

@@ -6,28 +6,75 @@
  *
  * @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';
-const CLAIMS_DIR = '.claude-flow/claims';
-const CLAIMS_FILE = 'claims.json';
+var CLAIMS_DIR = '.claude-flow/claims';
+var CLAIMS_FILE = 'claims.json';
 function getClaimsPath() {
     return resolve(join(CLAIMS_DIR, CLAIMS_FILE));
 }
 function ensureClaimsDir() {
-    const dir = resolve(CLAIMS_DIR);
+    var dir = resolve(CLAIMS_DIR);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadClaims() {
     try {
-        const path = getClaimsPath();
+        var path = getClaimsPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (_a) {
         // Return empty store on error
     }
     return { claims: {}, stealable: {}, contests: {} };
@@ -38,11 +85,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) {
-    const parts = str.split(':');
+    var parts = str.split(':');
     if (parts[0] === 'human' && parts.length >= 3) {
         return { type: 'human', userId: parts[1], name: parts.slice(2).join(':') };
     }
@@ -51,7 +98,7 @@ function parseClaimant(str) {
     }
     return null;
 }
-export const claimsTools = [
+export var claimsTools = [
     {
         name: 'claims_claim',
         description: 'Claim an issue for work (human or agent)',
@@ -61,55 +108,58 @@ export const 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: 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,
+        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
                 };
-            }
-            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)}`,
-            };
-        },
+                store.claims[issueId] = claim;
+                saveClaims(store);
+                return [2 /*return*/, {
+                        success: true,
+                        claim: claim,
+                        message: "Issue " + issueId + " claimed by " + formatClaimant(claimant)
+                    }];
+            });
+        }); }
     },
     {
         name: 'claims_release',
@@ -120,46 +170,49 @@ export const 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'],
-        },
-        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,
-            };
+            required: ['issueId', 'claimant']
         },
+        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',
@@ -170,60 +223,63 @@ export const 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'],
-        },
-        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)}`,
-            };
+            required: ['issueId', 'from', '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',
@@ -234,49 +290,52 @@ export const 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'],
-        },
-        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}`,
-            };
+            required: ['issueId', 'claimant']
         },
+        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',
@@ -287,51 +346,54 @@ export const 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'],
-        },
-        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}`,
-            };
+            required: ['issueId', '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',
@@ -343,40 +405,45 @@ export const 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',
-                },
-            },
-        },
-        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);
+                    description: 'Filter by agent type'
+                }
             }
-            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',
@@ -387,54 +454,57 @@ export const 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'],
-        },
-        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})`,
-            };
+            required: ['issueId', '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',
@@ -445,57 +515,60 @@ export const 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: 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(', ')}`,
-                    };
+        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' }];
                 }
-            }
-            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)}`,
-            };
-        },
+                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(', ')
+                            }];
+                    }
+                }
+                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)
+                    }];
+            });
+        }); }
     },
     {
         name: 'claims_stealable',
@@ -506,27 +579,31 @@ export const claimsTools = [
             properties: {
                 agentType: {
                     type: 'string',
-                    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));
+                    description: 'Filter by preferred agent type'
+                }
             }
-            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',
@@ -537,69 +614,72 @@ export const claimsTools = [
             properties: {
                 agentId: {
                     type: 'string',
-                    description: 'Specific agent ID (optional)',
+                    description: 'Specific agent ID (optional)'
                 },
                 agentType: {
                     type: 'string',
-                    description: 'Filter by agent type',
-                },
-            },
-        },
-        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,
-                    });
-                }
-                const load = agentLoads.get(key);
-                load.claims.push(claim);
-                if (claim.status === 'blocked') {
-                    load.blockedCount++;
+                    description: 'Filter by agent type'
                 }
             }
-            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,
-            };
         },
+        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; });
+                }
+                if (agentType) {
+                    loads = loads.filter(function (l) { return l.agentType === agentType; });
+                }
+                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
+                    }];
+            });
+        }); }
     },
     {
         name: 'claims_board',
@@ -607,48 +687,52 @@ export const claimsTools = [
         category: 'claims',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {}
         },
-        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);
+        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);
+                    }
                 }
-            }
-            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,
-                },
-            };
-        },
+                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
+                        }
+                    }];
+            });
+        }); }
     },
     {
         name: 'claims_rebalance',
@@ -660,72 +744,80 @@ export const claimsTools = [
                 dryRun: {
                     type: 'boolean',
                     description: 'Preview rebalancing without applying',
-                    default: true,
+                    "default": true
                 },
                 targetUtilization: {
                     type: 'number',
                     description: 'Target utilization (0-1)',
-                    default: 0.7,
-                },
-            },
-        },
-        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',
-                        });
-                    }
+                    "default": 0.7
                 }
             }
-            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`,
-            };
         },
+        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'
+                            });
+                        }
+                    }
+                };
+                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"
+                    }];
+            });
+        }); }
     },
 ];
 export default claimsTools;