kynjal-cli 3.1.3 → 4.0.0

package/dist/src/services/claim-service.js

@@ -12,6 +12,68 @@
  *
  * @see /v3/implementation/adrs/ADR-016-collaborative-issue-claims.md
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { EventEmitter } from 'events';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -19,7 +81,7 @@ import { execFileSync } from 'child_process';
 // ============================================================================
 // Default Configuration
 // ============================================================================
-const DEFAULT_CONFIG = {
+var DEFAULT_CONFIG = {
     staleThresholdMinutes: 30,
     blockedThresholdMinutes: 60,
     overloadThreshold: 5,
@@ -30,435 +92,647 @@ const DEFAULT_CONFIG = {
     allowCrossTypeSteal: [
         ['coder', 'debugger'],
         ['tester', 'reviewer'],
-    ],
+    ]
 };
 // ============================================================================
 // Claim Service Implementation
 // ============================================================================
-export class ClaimService extends EventEmitter {
-    claims = new Map();
-    stealableInfo = new Map();
-    storagePath;
-    config;
-    eventLog = [];
-    constructor(projectRoot, config) {
-        super();
-        this.storagePath = path.join(projectRoot, '.claude-flow', 'claims');
-        this.config = { ...DEFAULT_CONFIG, ...config };
+var ClaimService = /** @class */ (function (_super) {
+    __extends(ClaimService, _super);
+    function ClaimService(projectRoot, config) {
+        var _this = _super.call(this) || this;
+        _this.claims = new Map();
+        _this.stealableInfo = new Map();
+        _this.eventLog = [];
+        _this.storagePath = path.join(projectRoot, '.claude-flow', 'claims');
+        _this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
+        return _this;
     }
     // ==========================================================================
     // Initialization
     // ==========================================================================
-    async initialize() {
-        // Ensure storage directory exists
-        if (!fs.existsSync(this.storagePath)) {
-            fs.mkdirSync(this.storagePath, { recursive: true });
-        }
-        // Load existing claims
-        await this.loadClaims();
-    }
-    async loadClaims() {
-        const claimsFile = path.join(this.storagePath, 'claims.json');
-        if (fs.existsSync(claimsFile)) {
-            try {
-                const data = JSON.parse(fs.readFileSync(claimsFile, 'utf-8'));
-                for (const claim of data.claims || []) {
-                    claim.claimedAt = new Date(claim.claimedAt);
-                    claim.statusChangedAt = new Date(claim.statusChangedAt);
-                    if (claim.expiresAt)
-                        claim.expiresAt = new Date(claim.expiresAt);
-                    this.claims.set(claim.issueId, claim);
+    ClaimService.prototype.initialize = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Ensure storage directory exists
+                        if (!fs.existsSync(this.storagePath)) {
+                            fs.mkdirSync(this.storagePath, { recursive: true });
+                        }
+                        // Load existing claims
+                        return [4 /*yield*/, this.loadClaims()];
+                    case 1:
+                        // Load existing claims
+                        _a.sent();
+                        return [2 /*return*/];
                 }
-            }
-            catch {
-                // Start fresh if file is corrupted
-            }
-        }
-    }
-    async saveClaims() {
-        const claimsFile = path.join(this.storagePath, 'claims.json');
-        const data = {
-            claims: Array.from(this.claims.values()),
-            savedAt: new Date().toISOString(),
-        };
-        fs.writeFileSync(claimsFile, JSON.stringify(data, null, 2));
-    }
+            });
+        });
+    };
+    ClaimService.prototype.loadClaims = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var claimsFile, data, _i, _a, claim;
+            return __generator(this, function (_b) {
+                claimsFile = path.join(this.storagePath, 'claims.json');
+                if (fs.existsSync(claimsFile)) {
+                    try {
+                        data = JSON.parse(fs.readFileSync(claimsFile, 'utf-8'));
+                        for (_i = 0, _a = data.claims || []; _i < _a.length; _i++) {
+                            claim = _a[_i];
+                            claim.claimedAt = new Date(claim.claimedAt);
+                            claim.statusChangedAt = new Date(claim.statusChangedAt);
+                            if (claim.expiresAt)
+                                claim.expiresAt = new Date(claim.expiresAt);
+                            this.claims.set(claim.issueId, claim);
+                        }
+                    }
+                    catch (_c) {
+                        // Start fresh if file is corrupted
+                    }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    ClaimService.prototype.saveClaims = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var claimsFile, data;
+            return __generator(this, function (_a) {
+                claimsFile = path.join(this.storagePath, 'claims.json');
+                data = {
+                    claims: Array.from(this.claims.values()),
+                    savedAt: new Date().toISOString()
+                };
+                fs.writeFileSync(claimsFile, JSON.stringify(data, null, 2));
+                return [2 /*return*/];
+            });
+        });
+    };
     // ==========================================================================
     // Core Claiming
     // ==========================================================================
-    async claim(issueId, claimant) {
-        // Check if already claimed
-        const existing = this.claims.get(issueId);
-        if (existing && existing.status !== 'stealable') {
-            return {
-                success: false,
-                error: `Issue ${issueId} is already claimed by ${this.formatClaimant(existing.claimant)}`,
-            };
-        }
-        const now = new Date();
-        const claim = {
-            issueId,
-            claimant,
-            claimedAt: now,
-            status: 'active',
-            statusChangedAt: now,
-            progress: 0,
-        };
-        this.claims.set(issueId, claim);
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:claimed',
-            timestamp: now,
-            issueId,
-            claimant,
-            previousClaimant: existing?.claimant,
+    ClaimService.prototype.claim = function (issueId, claimant) {
+        return __awaiter(this, void 0, Promise, function () {
+            var existing, now, claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        existing = this.claims.get(issueId);
+                        if (existing && existing.status !== 'stealable') {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: "Issue " + issueId + " is already claimed by " + this.formatClaimant(existing.claimant)
+                                }];
+                        }
+                        now = new Date();
+                        claim = {
+                            issueId: issueId,
+                            claimant: claimant,
+                            claimedAt: now,
+                            status: 'active',
+                            statusChangedAt: now,
+                            progress: 0
+                        };
+                        this.claims.set(issueId, claim);
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:claimed',
+                            timestamp: now,
+                            issueId: issueId,
+                            claimant: claimant,
+                            previousClaimant: existing === null || existing === void 0 ? void 0 : existing.claimant
+                        });
+                        return [2 /*return*/, { success: true, claim: claim }];
+                }
+            });
         });
-        return { success: true, claim };
-    }
-    async release(issueId, claimant) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        if (!this.isSameClaimant(claim.claimant, claimant)) {
-            throw new Error(`Issue ${issueId} is not claimed by ${this.formatClaimant(claimant)}`);
-        }
-        this.claims.delete(issueId);
-        this.stealableInfo.delete(issueId);
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:released',
-            timestamp: new Date(),
-            issueId,
-            claimant,
+    };
+    ClaimService.prototype.release = function (issueId, claimant) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            throw new Error("Issue " + issueId + " is not claimed");
+                        }
+                        if (!this.isSameClaimant(claim.claimant, claimant)) {
+                            throw new Error("Issue " + issueId + " is not claimed by " + this.formatClaimant(claimant));
+                        }
+                        this.claims["delete"](issueId);
+                        this.stealableInfo["delete"](issueId);
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:released',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: claimant
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
+    };
     // ==========================================================================
     // Handoffs
     // ==========================================================================
-    async requestHandoff(issueId, from, to, reason) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        if (!this.isSameClaimant(claim.claimant, from)) {
-            throw new Error(`Issue ${issueId} is not claimed by ${this.formatClaimant(from)}`);
-        }
-        claim.status = 'handoff-pending';
-        claim.statusChangedAt = new Date();
-        claim.handoffTo = to;
-        claim.handoffReason = reason;
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:handoff:requested',
-            timestamp: new Date(),
-            issueId,
-            claimant: from,
-            data: { to, reason },
+    ClaimService.prototype.requestHandoff = function (issueId, from, to, reason) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            throw new Error("Issue " + issueId + " is not claimed");
+                        }
+                        if (!this.isSameClaimant(claim.claimant, from)) {
+                            throw new Error("Issue " + issueId + " is not claimed by " + this.formatClaimant(from));
+                        }
+                        claim.status = 'handoff-pending';
+                        claim.statusChangedAt = new Date();
+                        claim.handoffTo = to;
+                        claim.handoffReason = reason;
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:handoff:requested',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: from,
+                            data: { to: to, reason: reason }
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
-    async acceptHandoff(issueId, claimant) {
-        const claim = this.claims.get(issueId);
-        if (!claim || claim.status !== 'handoff-pending') {
-            throw new Error(`No pending handoff for issue ${issueId}`);
-        }
-        if (!claim.handoffTo || !this.isSameClaimant(claim.handoffTo, claimant)) {
-            throw new Error(`Handoff not addressed to ${this.formatClaimant(claimant)}`);
-        }
-        const previousClaimant = claim.claimant;
-        claim.claimant = claimant;
-        claim.status = 'active';
-        claim.statusChangedAt = new Date();
-        delete claim.handoffTo;
-        delete claim.handoffReason;
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:handoff:accepted',
-            timestamp: new Date(),
-            issueId,
-            claimant,
-            previousClaimant,
+    };
+    ClaimService.prototype.acceptHandoff = function (issueId, claimant) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim, previousClaimant;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim || claim.status !== 'handoff-pending') {
+                            throw new Error("No pending handoff for issue " + issueId);
+                        }
+                        if (!claim.handoffTo || !this.isSameClaimant(claim.handoffTo, claimant)) {
+                            throw new Error("Handoff not addressed to " + this.formatClaimant(claimant));
+                        }
+                        previousClaimant = claim.claimant;
+                        claim.claimant = claimant;
+                        claim.status = 'active';
+                        claim.statusChangedAt = new Date();
+                        delete claim.handoffTo;
+                        delete claim.handoffReason;
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:handoff:accepted',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: claimant,
+                            previousClaimant: previousClaimant
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
-    async rejectHandoff(issueId, claimant, reason) {
-        const claim = this.claims.get(issueId);
-        if (!claim || claim.status !== 'handoff-pending') {
-            throw new Error(`No pending handoff for issue ${issueId}`);
-        }
-        if (!claim.handoffTo || !this.isSameClaimant(claim.handoffTo, claimant)) {
-            throw new Error(`Handoff not addressed to ${this.formatClaimant(claimant)}`);
-        }
-        claim.status = 'active';
-        claim.statusChangedAt = new Date();
-        delete claim.handoffTo;
-        delete claim.handoffReason;
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:handoff:rejected',
-            timestamp: new Date(),
-            issueId,
-            claimant,
-            data: { reason },
+    };
+    ClaimService.prototype.rejectHandoff = function (issueId, claimant, reason) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim || claim.status !== 'handoff-pending') {
+                            throw new Error("No pending handoff for issue " + issueId);
+                        }
+                        if (!claim.handoffTo || !this.isSameClaimant(claim.handoffTo, claimant)) {
+                            throw new Error("Handoff not addressed to " + this.formatClaimant(claimant));
+                        }
+                        claim.status = 'active';
+                        claim.statusChangedAt = new Date();
+                        delete claim.handoffTo;
+                        delete claim.handoffReason;
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:handoff:rejected',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: claimant,
+                            data: { reason: reason }
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
+    };
     // ==========================================================================
     // Status Updates
     // ==========================================================================
-    async updateStatus(issueId, status, note) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        const previousStatus = claim.status;
-        claim.status = status;
-        claim.statusChangedAt = new Date();
-        if (status === 'blocked' && note) {
-            claim.blockReason = note;
-        }
-        if (status === 'completed') {
-            claim.progress = 100;
-        }
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:status:changed',
-            timestamp: new Date(),
-            issueId,
-            data: { previousStatus, newStatus: status, note },
+    ClaimService.prototype.updateStatus = function (issueId, status, note) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim, previousStatus;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            throw new Error("Issue " + issueId + " is not claimed");
+                        }
+                        previousStatus = claim.status;
+                        claim.status = status;
+                        claim.statusChangedAt = new Date();
+                        if (status === 'blocked' && note) {
+                            claim.blockReason = note;
+                        }
+                        if (status === 'completed') {
+                            claim.progress = 100;
+                        }
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:status:changed',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            data: { previousStatus: previousStatus, newStatus: status, note: note }
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
-    async updateProgress(issueId, progress) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        claim.progress = Math.min(100, Math.max(0, progress));
-        await this.saveClaims();
-    }
-    async requestReview(issueId, reviewers) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        claim.status = 'review-requested';
-        claim.statusChangedAt = new Date();
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:review:requested',
-            timestamp: new Date(),
-            issueId,
-            claimant: claim.claimant,
-            data: { reviewers },
+    };
+    ClaimService.prototype.updateProgress = function (issueId, progress) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            throw new Error("Issue " + issueId + " is not claimed");
+                        }
+                        claim.progress = Math.min(100, Math.max(0, progress));
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
+    };
+    ClaimService.prototype.requestReview = function (issueId, reviewers) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            throw new Error("Issue " + issueId + " is not claimed");
+                        }
+                        claim.status = 'review-requested';
+                        claim.statusChangedAt = new Date();
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:review:requested',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: claim.claimant,
+                            data: { reviewers: reviewers }
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     // ==========================================================================
     // Work Stealing
     // ==========================================================================
-    async markStealable(issueId, info) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        claim.status = 'stealable';
-        claim.statusChangedAt = new Date();
-        claim.context = info.context;
-        claim.progress = info.progress;
-        this.stealableInfo.set(issueId, info);
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:stealable',
-            timestamp: new Date(),
-            issueId,
-            claimant: claim.claimant,
-            data: { info },
+    ClaimService.prototype.markStealable = function (issueId, info) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            throw new Error("Issue " + issueId + " is not claimed");
+                        }
+                        claim.status = 'stealable';
+                        claim.statusChangedAt = new Date();
+                        claim.context = info.context;
+                        claim.progress = info.progress;
+                        this.stealableInfo.set(issueId, info);
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:stealable',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: claim.claimant,
+                            data: { info: info }
+                        });
+                        return [2 /*return*/];
+                }
+            });
         });
-    }
-    async steal(issueId, stealer) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            return { success: false, error: `Issue ${issueId} is not claimed` };
-        }
-        if (claim.status !== 'stealable') {
-            return { success: false, error: `Issue ${issueId} is not stealable` };
-        }
-        const info = this.stealableInfo.get(issueId);
-        const previousOwner = claim.claimant;
-        // Check if steal is allowed
-        if (this.config.requireSameType && stealer.type === 'agent' && previousOwner.type === 'agent') {
-            if (stealer.agentType !== previousOwner.agentType) {
-                const allowed = this.config.allowCrossTypeSteal.some(pair => pair.includes(stealer.agentType) && pair.includes(previousOwner.agentType));
-                if (!allowed) {
-                    return { success: false, error: `Cross-type steal not allowed` };
+    };
+    ClaimService.prototype.steal = function (issueId, stealer) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim, info, previousOwner, allowed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        claim = this.claims.get(issueId);
+                        if (!claim) {
+                            return [2 /*return*/, { success: false, error: "Issue " + issueId + " is not claimed" }];
+                        }
+                        if (claim.status !== 'stealable') {
+                            return [2 /*return*/, { success: false, error: "Issue " + issueId + " is not stealable" }];
+                        }
+                        info = this.stealableInfo.get(issueId);
+                        previousOwner = claim.claimant;
+                        // Check if steal is allowed
+                        if (this.config.requireSameType && stealer.type === 'agent' && previousOwner.type === 'agent') {
+                            if (stealer.agentType !== previousOwner.agentType) {
+                                allowed = this.config.allowCrossTypeSteal.some(function (pair) { return pair.includes(stealer.agentType) && pair.includes(previousOwner.agentType); });
+                                if (!allowed) {
+                                    return [2 /*return*/, { success: false, error: "Cross-type steal not allowed" }];
+                                }
+                            }
+                        }
+                        // Execute steal
+                        claim.claimant = stealer;
+                        claim.status = 'active';
+                        claim.statusChangedAt = new Date();
+                        claim.claimedAt = new Date();
+                        this.stealableInfo["delete"](issueId);
+                        return [4 /*yield*/, this.saveClaims()];
+                    case 1:
+                        _a.sent();
+                        this.emitEvent({
+                            type: 'issue:stolen',
+                            timestamp: new Date(),
+                            issueId: issueId,
+                            claimant: stealer,
+                            previousClaimant: previousOwner,
+                            data: { context: info }
+                        });
+                        return [2 /*return*/, { success: true, claim: claim, previousOwner: previousOwner, context: info }];
                 }
-            }
-        }
-        // Execute steal
-        claim.claimant = stealer;
-        claim.status = 'active';
-        claim.statusChangedAt = new Date();
-        claim.claimedAt = new Date();
-        this.stealableInfo.delete(issueId);
-        await this.saveClaims();
-        this.emitEvent({
-            type: 'issue:stolen',
-            timestamp: new Date(),
-            issueId,
-            claimant: stealer,
-            previousClaimant: previousOwner,
-            data: { context: info },
+            });
         });
-        return { success: true, claim, previousOwner, context: info };
-    }
-    async getStealable(agentType) {
-        const stealable = [];
-        for (const claim of this.claims.values()) {
-            if (claim.status !== 'stealable')
-                continue;
-            const info = this.stealableInfo.get(claim.issueId);
-            if (agentType && info?.preferredTypes?.length) {
-                if (!info.preferredTypes.includes(agentType))
-                    continue;
-            }
-            stealable.push(claim);
-        }
-        return stealable;
-    }
-    async contestSteal(issueId, originalClaimant, reason) {
-        const claim = this.claims.get(issueId);
-        if (!claim) {
-            throw new Error(`Issue ${issueId} is not claimed`);
-        }
-        this.emitEvent({
-            type: 'issue:steal:contested',
-            timestamp: new Date(),
-            issueId,
-            claimant: originalClaimant,
-            data: { reason, currentOwner: claim.claimant },
+    };
+    ClaimService.prototype.getStealable = function (agentType) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var stealable, _i, _b, claim, info;
+            return __generator(this, function (_c) {
+                stealable = [];
+                for (_i = 0, _b = this.claims.values(); _i < _b.length; _i++) {
+                    claim = _b[_i];
+                    if (claim.status !== 'stealable')
+                        continue;
+                    info = this.stealableInfo.get(claim.issueId);
+                    if (agentType && ((_a = info === null || info === void 0 ? void 0 : info.preferredTypes) === null || _a === void 0 ? void 0 : _a.length)) {
+                        if (!info.preferredTypes.includes(agentType))
+                            continue;
+                    }
+                    stealable.push(claim);
+                }
+                return [2 /*return*/, stealable];
+            });
         });
-        // Contest resolution would typically be handled by a coordinator or human
-    }
+    };
+    ClaimService.prototype.contestSteal = function (issueId, originalClaimant, reason) {
+        return __awaiter(this, void 0, Promise, function () {
+            var claim;
+            return __generator(this, function (_a) {
+                claim = this.claims.get(issueId);
+                if (!claim) {
+                    throw new Error("Issue " + issueId + " is not claimed");
+                }
+                this.emitEvent({
+                    type: 'issue:steal:contested',
+                    timestamp: new Date(),
+                    issueId: issueId,
+                    claimant: originalClaimant,
+                    data: { reason: reason, currentOwner: claim.claimant }
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
     // ==========================================================================
     // Load Balancing
     // ==========================================================================
-    async getAgentLoad(agentId) {
-        const claims = [];
-        let blockedCount = 0;
-        for (const claim of this.claims.values()) {
-            if (claim.claimant.type === 'agent' && claim.claimant.agentId === agentId) {
-                claims.push(claim);
-                if (claim.status === 'blocked')
-                    blockedCount++;
-            }
-        }
-        const agentType = claims[0]?.claimant.type === 'agent' ? claims[0].claimant.agentType : 'unknown';
-        return {
-            agentId,
-            agentType,
-            claimCount: claims.length,
-            maxClaims: this.config.overloadThreshold,
-            utilization: claims.length / this.config.overloadThreshold,
-            claims,
-            avgCompletionTime: 0, // Would need historical data
-            currentBlockedCount: blockedCount,
-        };
-    }
-    async rebalance(swarmId) {
-        const result = { moved: [], suggested: [] };
-        // Get all agent loads
-        const agentLoads = new Map();
-        const agentTypes = new Set();
-        for (const claim of this.claims.values()) {
-            if (claim.claimant.type !== 'agent')
-                continue;
-            const agentId = claim.claimant.agentId;
-            if (!agentLoads.has(agentId)) {
-                const load = await this.getAgentLoad(agentId);
-                agentLoads.set(agentId, load);
-                agentTypes.add(load.agentType);
-            }
-        }
-        // For each agent type, calculate average load
-        for (const agentType of agentTypes) {
-            const typeLoads = Array.from(agentLoads.values()).filter(l => l.agentType === agentType);
-            const avgLoad = typeLoads.reduce((sum, l) => sum + l.utilization, 0) / typeLoads.length;
-            const overloaded = typeLoads.filter(l => l.utilization > avgLoad * 1.5);
-            const underloaded = typeLoads.filter(l => l.utilization < avgLoad * 0.5);
-            // Generate suggestions
-            for (const over of overloaded) {
-                const lowProgressClaims = over.claims
-                    .filter(c => c.progress < 25)
-                    .sort((a, b) => a.progress - b.progress);
-                for (const claim of lowProgressClaims) {
-                    const target = underloaded.find(u => u.claimCount < u.maxClaims);
-                    if (target) {
-                        result.suggested.push({
-                            issueId: claim.issueId,
-                            currentOwner: claim.claimant,
-                            suggestedOwner: {
-                                type: 'agent',
-                                agentId: target.agentId,
-                                agentType: target.agentType,
-                            },
-                            reason: 'Load balancing: redistributing work across swarm',
-                        });
+    ClaimService.prototype.getAgentLoad = function (agentId) {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var claims, blockedCount, _i, _b, claim, agentType;
+            return __generator(this, function (_c) {
+                claims = [];
+                blockedCount = 0;
+                for (_i = 0, _b = this.claims.values(); _i < _b.length; _i++) {
+                    claim = _b[_i];
+                    if (claim.claimant.type === 'agent' && claim.claimant.agentId === agentId) {
+                        claims.push(claim);
+                        if (claim.status === 'blocked')
+                            blockedCount++;
                     }
                 }
-            }
-        }
-        return result;
-    }
+                agentType = ((_a = claims[0]) === null || _a === void 0 ? void 0 : _a.claimant.type) === 'agent' ? claims[0].claimant.agentType : 'unknown';
+                return [2 /*return*/, {
+                        agentId: agentId,
+                        agentType: agentType,
+                        claimCount: claims.length,
+                        maxClaims: this.config.overloadThreshold,
+                        utilization: claims.length / this.config.overloadThreshold,
+                        claims: claims,
+                        avgCompletionTime: 0,
+                        currentBlockedCount: blockedCount
+                    }];
+            });
+        });
+    };
+    ClaimService.prototype.rebalance = function (swarmId) {
+        return __awaiter(this, void 0, Promise, function () {
+            var result, agentLoads, agentTypes, _i, _a, claim, agentId, load, _loop_1, _b, agentTypes_1, agentType;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        result = { moved: [], suggested: [] };
+                        agentLoads = new Map();
+                        agentTypes = new Set();
+                        _i = 0, _a = this.claims.values();
+                        _c.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        claim = _a[_i];
+                        if (claim.claimant.type !== 'agent')
+                            return [3 /*break*/, 3];
+                        agentId = claim.claimant.agentId;
+                        if (!!agentLoads.has(agentId)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.getAgentLoad(agentId)];
+                    case 2:
+                        load = _c.sent();
+                        agentLoads.set(agentId, load);
+                        agentTypes.add(load.agentType);
+                        _c.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        _loop_1 = function (agentType) {
+                            var typeLoads = Array.from(agentLoads.values()).filter(function (l) { return l.agentType === agentType; });
+                            var avgLoad = typeLoads.reduce(function (sum, l) { return sum + l.utilization; }, 0) / typeLoads.length;
+                            var overloaded = typeLoads.filter(function (l) { return l.utilization > avgLoad * 1.5; });
+                            var underloaded = typeLoads.filter(function (l) { return l.utilization < avgLoad * 0.5; });
+                            // Generate suggestions
+                            for (var _d = 0, overloaded_1 = overloaded; _d < overloaded_1.length; _d++) {
+                                var over = overloaded_1[_d];
+                                var lowProgressClaims = over.claims
+                                    .filter(function (c) { return c.progress < 25; })
+                                    .sort(function (a, b) { return a.progress - b.progress; });
+                                for (var _e = 0, lowProgressClaims_1 = lowProgressClaims; _e < lowProgressClaims_1.length; _e++) {
+                                    var claim = lowProgressClaims_1[_e];
+                                    var target = underloaded.find(function (u) { return u.claimCount < u.maxClaims; });
+                                    if (target) {
+                                        result.suggested.push({
+                                            issueId: claim.issueId,
+                                            currentOwner: claim.claimant,
+                                            suggestedOwner: {
+                                                type: 'agent',
+                                                agentId: target.agentId,
+                                                agentType: target.agentType
+                                            },
+                                            reason: 'Load balancing: redistributing work across swarm'
+                                        });
+                                    }
+                                }
+                            }
+                        };
+                        // For each agent type, calculate average load
+                        for (_b = 0, agentTypes_1 = agentTypes; _b < agentTypes_1.length; _b++) {
+                            agentType = agentTypes_1[_b];
+                            _loop_1(agentType);
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
     // ==========================================================================
     // Queries
     // ==========================================================================
-    async getClaimedBy(claimant) {
-        return Array.from(this.claims.values()).filter(c => this.isSameClaimant(c.claimant, claimant));
-    }
-    async getAvailableIssues(_filters) {
-        // This would integrate with GitHub API
-        // For now, return issues that are not claimed
-        return [];
-    }
-    async getIssueStatus(issueId) {
-        return this.claims.get(issueId) || null;
-    }
-    async getAllClaims() {
-        return Array.from(this.claims.values());
-    }
-    async getByStatus(status) {
-        return Array.from(this.claims.values()).filter(c => c.status === status);
-    }
+    ClaimService.prototype.getClaimedBy = function (claimant) {
+        return __awaiter(this, void 0, Promise, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Array.from(this.claims.values()).filter(function (c) {
+                        return _this.isSameClaimant(c.claimant, claimant);
+                    })];
+            });
+        });
+    };
+    ClaimService.prototype.getAvailableIssues = function (_filters) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                // This would integrate with GitHub API
+                // For now, return issues that are not claimed
+                return [2 /*return*/, []];
+            });
+        });
+    };
+    ClaimService.prototype.getIssueStatus = function (issueId) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.claims.get(issueId) || null];
+            });
+        });
+    };
+    ClaimService.prototype.getAllClaims = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Array.from(this.claims.values())];
+            });
+        });
+    };
+    ClaimService.prototype.getByStatus = function (status) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Array.from(this.claims.values()).filter(function (c) { return c.status === status; })];
+            });
+        });
+    };
     // ==========================================================================
     // Auto-Management
     // ==========================================================================
-    async expireStale(maxAgeMinutes) {
-        const threshold = maxAgeMinutes ?? this.config.staleThresholdMinutes;
-        const now = Date.now();
-        const expired = [];
-        for (const claim of this.claims.values()) {
-            if (claim.status === 'stealable' || claim.status === 'completed')
-                continue;
-            const age = (now - claim.statusChangedAt.getTime()) / 60000;
-            if (age > threshold) {
-                // Mark as stealable
-                await this.markStealable(claim.issueId, {
-                    reason: 'stale',
-                    stealableAt: new Date(),
-                    progress: claim.progress,
-                    context: `Stale: No activity for ${Math.round(age)} minutes`,
-                });
-                expired.push(claim);
-            }
-        }
-        return expired;
-    }
+    ClaimService.prototype.expireStale = function (maxAgeMinutes) {
+        return __awaiter(this, void 0, Promise, function () {
+            var threshold, now, expired, _i, _a, claim, age;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        threshold = maxAgeMinutes !== null && maxAgeMinutes !== void 0 ? maxAgeMinutes : this.config.staleThresholdMinutes;
+                        now = Date.now();
+                        expired = [];
+                        _i = 0, _a = this.claims.values();
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        claim = _a[_i];
+                        if (claim.status === 'stealable' || claim.status === 'completed')
+                            return [3 /*break*/, 3];
+                        age = (now - claim.statusChangedAt.getTime()) / 60000;
+                        if (!(age > threshold)) return [3 /*break*/, 3];
+                        // Mark as stealable
+                        return [4 /*yield*/, this.markStealable(claim.issueId, {
+                                reason: 'stale',
+                                stealableAt: new Date(),
+                                progress: claim.progress,
+                                context: "Stale: No activity for " + Math.round(age) + " minutes"
+                            })];
+                    case 2:
+                        // Mark as stealable
+                        _b.sent();
+                        expired.push(claim);
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, expired];
+                }
+            });
+        });
+    };
     // ==========================================================================
     // Helpers
     // ==========================================================================
-    formatClaimant(claimant) {
+    ClaimService.prototype.formatClaimant = function (claimant) {
         return claimant.type === 'human'
-            ? `human:${claimant.name}`
-            : `agent:${claimant.agentType}:${claimant.agentId}`;
-    }
-    isSameClaimant(a, b) {
+            ? "human:" + claimant.name
+            : "agent:" + claimant.agentType + ":" + claimant.agentId;
+    };
+    ClaimService.prototype.isSameClaimant = function (a, b) {
         if (a.type !== b.type)
             return false;
         if (a.type === 'human' && b.type === 'human') {
@@ -468,28 +742,31 @@ export class ClaimService extends EventEmitter {
             return a.agentId === b.agentId;
         }
         return false;
-    }
-    emitEvent(event) {
+    };
+    ClaimService.prototype.emitEvent = function (event) {
         this.eventLog.push(event);
         if (this.eventLog.length > 1000) {
             this.eventLog = this.eventLog.slice(-500);
         }
         this.emit(event.type, event);
-    }
-    getEventLog(limit = 100) {
+    };
+    ClaimService.prototype.getEventLog = function (limit) {
+        if (limit === void 0) { limit = 100; }
         return this.eventLog.slice(-limit);
-    }
-}
+    };
+    return ClaimService;
+}(EventEmitter));
+export { ClaimService };
 // ============================================================================
 // GitHub Sync Implementation
 // ============================================================================
-const DEFAULT_GITHUB_CONFIG = {
+var DEFAULT_GITHUB_CONFIG = {
     enabled: false,
     syncLabels: true,
     claimLabel: 'claimed',
     autoAssign: true,
     commentOnClaim: true,
-    commentOnRelease: true,
+    commentOnRelease: true
 };
 // ============================================================================
 // Input Validation (Security)
@@ -528,283 +805,331 @@ function isValidLabel(label) {
  * Sanitize error messages to prevent information disclosure
  */
 function sanitizeError(error) {
-    const msg = error.message || 'Unknown error';
+    var msg = error.message || 'Unknown error';
     // Remove paths and sensitive details
     return msg.replace(/\/[\w./-]+/g, '[path]').substring(0, 200);
 }
-export class GitHubSync {
-    config;
-    claimService;
-    constructor(claimService, config) {
+var GitHubSync = /** @class */ (function () {
+    function GitHubSync(claimService, config) {
         this.claimService = claimService;
-        this.config = { ...DEFAULT_GITHUB_CONFIG, ...config };
+        this.config = __assign(__assign({}, DEFAULT_GITHUB_CONFIG), config);
     }
     /**
      * Check if GitHub CLI is available
      */
-    isGhAvailable() {
+    GitHubSync.prototype.isGhAvailable = function () {
         try {
             execFileSync('gh', ['--version'], { stdio: 'ignore' });
             return true;
         }
-        catch {
+        catch (_a) {
             return false;
         }
-    }
+    };
     /**
      * Get the current repository from git remote
      */
-    getRepo() {
+    GitHubSync.prototype.getRepo = function () {
         if (this.config.repo) {
             return isValidRepo(this.config.repo) ? this.config.repo : null;
         }
         try {
-            const remote = execFileSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8' }).trim();
-            const match = remote.match(/github\.com[/:]([\w.-]+\/[\w.-]+)/);
-            const repo = match ? match[1].replace('.git', '') : null;
+            var remote = execFileSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8' }).trim();
+            var match = remote.match(/github\.com[/:]([\w.-]+\/[\w.-]+)/);
+            var repo = match ? match[1].replace('.git', '') : null;
             return repo && isValidRepo(repo) ? repo : null;
         }
-        catch {
+        catch (_a) {
             return null;
         }
-    }
+    };
     /**
      * Sync issues from GitHub
      */
-    async syncIssues(state = 'open') {
-        const errors = [];
-        const issues = [];
-        if (!this.isGhAvailable()) {
-            return { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] };
-        }
-        const repo = this.getRepo();
-        if (!repo) {
-            return { success: false, synced: 0, errors: ['Could not determine GitHub repository'] };
-        }
-        // Validate state parameter (whitelist)
-        const validStates = ['open', 'closed', 'all'];
-        if (!validStates.includes(state)) {
-            return { success: false, synced: 0, errors: ['Invalid state parameter'] };
-        }
-        try {
-            const issuesJson = execFileSync('gh', [
-                'issue', 'list',
-                '--repo', repo,
-                '--state', state,
-                '--json', 'number,title,body,state,labels,assignees,url,createdAt,updatedAt',
-                '--limit', '100'
-            ], { encoding: 'utf-8' });
-            const rawIssues = JSON.parse(issuesJson);
-            for (const raw of rawIssues) {
-                issues.push({
-                    number: raw.number,
-                    title: raw.title,
-                    body: raw.body || '',
-                    state: raw.state === 'OPEN' ? 'open' : 'closed',
-                    labels: raw.labels?.map((l) => l.name) || [],
-                    assignees: raw.assignees?.map((a) => a.login) || [],
-                    url: raw.url,
-                    createdAt: new Date(raw.createdAt),
-                    updatedAt: new Date(raw.updatedAt),
-                });
-            }
-            return { success: true, synced: issues.length, errors, issues };
-        }
-        catch (error) {
-            errors.push(`Failed to fetch issues: ${sanitizeError(error)}`);
-            return { success: false, synced: 0, errors };
-        }
-    }
+    GitHubSync.prototype.syncIssues = function (state) {
+        var _a, _b;
+        if (state === void 0) { state = 'open'; }
+        return __awaiter(this, void 0, Promise, function () {
+            var errors, issues, repo, validStates, issuesJson, rawIssues, _i, rawIssues_1, raw;
+            return __generator(this, function (_c) {
+                errors = [];
+                issues = [];
+                if (!this.isGhAvailable()) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] }];
+                }
+                repo = this.getRepo();
+                if (!repo) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Could not determine GitHub repository'] }];
+                }
+                validStates = ['open', 'closed', 'all'];
+                if (!validStates.includes(state)) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid state parameter'] }];
+                }
+                try {
+                    issuesJson = execFileSync('gh', [
+                        'issue', 'list',
+                        '--repo', repo,
+                        '--state', state,
+                        '--json', 'number,title,body,state,labels,assignees,url,createdAt,updatedAt',
+                        '--limit', '100'
+                    ], { encoding: 'utf-8' });
+                    rawIssues = JSON.parse(issuesJson);
+                    for (_i = 0, rawIssues_1 = rawIssues; _i < rawIssues_1.length; _i++) {
+                        raw = rawIssues_1[_i];
+                        issues.push({
+                            number: raw.number,
+                            title: raw.title,
+                            body: raw.body || '',
+                            state: raw.state === 'OPEN' ? 'open' : 'closed',
+                            labels: ((_a = raw.labels) === null || _a === void 0 ? void 0 : _a.map(function (l) { return l.name; })) || [],
+                            assignees: ((_b = raw.assignees) === null || _b === void 0 ? void 0 : _b.map(function (a) { return a.login; })) || [],
+                            url: raw.url,
+                            createdAt: new Date(raw.createdAt),
+                            updatedAt: new Date(raw.updatedAt)
+                        });
+                    }
+                    return [2 /*return*/, { success: true, synced: issues.length, errors: errors, issues: issues }];
+                }
+                catch (error) {
+                    errors.push("Failed to fetch issues: " + sanitizeError(error));
+                    return [2 /*return*/, { success: false, synced: 0, errors: errors }];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Sync a local claim to GitHub (add label/assignee/comment)
      */
-    async claimOnGitHub(issueNumber, claimant) {
-        const errors = [];
-        if (!this.config.enabled) {
-            return { success: true, synced: 0, errors: ['GitHub sync not enabled'] };
-        }
-        if (!this.isGhAvailable()) {
-            return { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] };
-        }
-        // Validate issue number
-        if (!isValidIssueNumber(issueNumber)) {
-            return { success: false, synced: 0, errors: ['Invalid issue number'] };
-        }
-        const repo = this.getRepo();
-        if (!repo) {
-            return { success: false, synced: 0, errors: ['Could not determine repository'] };
-        }
-        // Validate claim label
-        if (!isValidLabel(this.config.claimLabel)) {
-            return { success: false, synced: 0, errors: ['Invalid claim label configuration'] };
-        }
-        try {
-            // Add claim label
-            if (this.config.syncLabels) {
-                try {
-                    execFileSync('gh', [
-                        'issue', 'edit', String(issueNumber),
-                        '--repo', repo,
-                        '--add-label', this.config.claimLabel
-                    ], { stdio: 'ignore' });
+    GitHubSync.prototype.claimOnGitHub = function (issueNumber, claimant) {
+        return __awaiter(this, void 0, Promise, function () {
+            var errors, repo, claimantStr, comment;
+            return __generator(this, function (_a) {
+                errors = [];
+                if (!this.config.enabled) {
+                    return [2 /*return*/, { success: true, synced: 0, errors: ['GitHub sync not enabled'] }];
                 }
-                catch {
-                    errors.push('Failed to add claim label (label may not exist)');
+                if (!this.isGhAvailable()) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] }];
                 }
-            }
-            // Auto-assign if human claimant
-            if (this.config.autoAssign && claimant.type === 'human') {
-                if (!isValidClaimantName(claimant.name)) {
-                    errors.push('Invalid claimant name format');
+                // Validate issue number
+                if (!isValidIssueNumber(issueNumber)) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid issue number'] }];
                 }
-                else {
-                    try {
-                        execFileSync('gh', [
-                            'issue', 'edit', String(issueNumber),
-                            '--repo', repo,
-                            '--add-assignee', claimant.name
-                        ], { stdio: 'ignore' });
-                    }
-                    catch {
-                        errors.push('Failed to assign issue');
-                    }
+                repo = this.getRepo();
+                if (!repo) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Could not determine repository'] }];
+                }
+                // Validate claim label
+                if (!isValidLabel(this.config.claimLabel)) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid claim label configuration'] }];
                 }
-            }
-            // Add comment
-            if (this.config.commentOnClaim) {
-                const claimantStr = claimant.type === 'human'
-                    ? `@${claimant.name.replace(/[^a-zA-Z0-9_-]/g, '')}`
-                    : `Agent: ${(claimant.agentType || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '')}`;
-                const comment = `🤖 **Issue claimed** by ${claimantStr}\n\n_Coordinated by KynjalFlow V3_`;
                 try {
-                    execFileSync('gh', [
-                        'issue', 'comment', String(issueNumber),
-                        '--repo', repo,
-                        '--body', comment
-                    ], { stdio: 'ignore' });
+                    // Add claim label
+                    if (this.config.syncLabels) {
+                        try {
+                            execFileSync('gh', [
+                                'issue', 'edit', String(issueNumber),
+                                '--repo', repo,
+                                '--add-label', this.config.claimLabel
+                            ], { stdio: 'ignore' });
+                        }
+                        catch (_b) {
+                            errors.push('Failed to add claim label (label may not exist)');
+                        }
+                    }
+                    // Auto-assign if human claimant
+                    if (this.config.autoAssign && claimant.type === 'human') {
+                        if (!isValidClaimantName(claimant.name)) {
+                            errors.push('Invalid claimant name format');
+                        }
+                        else {
+                            try {
+                                execFileSync('gh', [
+                                    'issue', 'edit', String(issueNumber),
+                                    '--repo', repo,
+                                    '--add-assignee', claimant.name
+                                ], { stdio: 'ignore' });
+                            }
+                            catch (_c) {
+                                errors.push('Failed to assign issue');
+                            }
+                        }
+                    }
+                    // Add comment
+                    if (this.config.commentOnClaim) {
+                        claimantStr = claimant.type === 'human'
+                            ? "@" + claimant.name.replace(/[^a-zA-Z0-9_-]/g, '')
+                            : "Agent: " + (claimant.agentType || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '');
+                        comment = "\uD83E\uDD16 **Issue claimed** by " + claimantStr + "\n\n_Coordinated by RuFlo V3_";
+                        try {
+                            execFileSync('gh', [
+                                'issue', 'comment', String(issueNumber),
+                                '--repo', repo,
+                                '--body', comment
+                            ], { stdio: 'ignore' });
+                        }
+                        catch (_d) {
+                            errors.push('Failed to add comment');
+                        }
+                    }
+                    return [2 /*return*/, { success: errors.length === 0, synced: 1, errors: errors }];
                 }
-                catch {
-                    errors.push('Failed to add comment');
+                catch (error) {
+                    errors.push("GitHub sync failed: " + sanitizeError(error));
+                    return [2 /*return*/, { success: false, synced: 0, errors: errors }];
                 }
-            }
-            return { success: errors.length === 0, synced: 1, errors };
-        }
-        catch (error) {
-            errors.push(`GitHub sync failed: ${sanitizeError(error)}`);
-            return { success: false, synced: 0, errors };
-        }
-    }
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Release claim on GitHub (remove label/assignee/comment)
      */
-    async releaseOnGitHub(issueNumber, claimant) {
-        const errors = [];
-        if (!this.config.enabled) {
-            return { success: true, synced: 0, errors: ['GitHub sync not enabled'] };
-        }
-        if (!this.isGhAvailable()) {
-            return { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] };
-        }
-        // Validate issue number
-        if (!isValidIssueNumber(issueNumber)) {
-            return { success: false, synced: 0, errors: ['Invalid issue number'] };
-        }
-        const repo = this.getRepo();
-        if (!repo) {
-            return { success: false, synced: 0, errors: ['Could not determine repository'] };
-        }
-        // Validate claim label
-        if (!isValidLabel(this.config.claimLabel)) {
-            return { success: false, synced: 0, errors: ['Invalid claim label configuration'] };
-        }
-        try {
-            // Remove claim label
-            if (this.config.syncLabels) {
-                try {
-                    execFileSync('gh', [
-                        'issue', 'edit', String(issueNumber),
-                        '--repo', repo,
-                        '--remove-label', this.config.claimLabel
-                    ], { stdio: 'ignore' });
+    GitHubSync.prototype.releaseOnGitHub = function (issueNumber, claimant) {
+        return __awaiter(this, void 0, Promise, function () {
+            var errors, repo, claimantStr, comment;
+            return __generator(this, function (_a) {
+                errors = [];
+                if (!this.config.enabled) {
+                    return [2 /*return*/, { success: true, synced: 0, errors: ['GitHub sync not enabled'] }];
                 }
-                catch {
-                    // Label might not exist
+                if (!this.isGhAvailable()) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] }];
                 }
-            }
-            // Remove assignee if human claimant
-            if (this.config.autoAssign && claimant.type === 'human') {
-                if (isValidClaimantName(claimant.name)) {
-                    try {
-                        execFileSync('gh', [
-                            'issue', 'edit', String(issueNumber),
-                            '--repo', repo,
-                            '--remove-assignee', claimant.name
-                        ], { stdio: 'ignore' });
-                    }
-                    catch {
-                        errors.push('Failed to remove assignee');
-                    }
+                // Validate issue number
+                if (!isValidIssueNumber(issueNumber)) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid issue number'] }];
+                }
+                repo = this.getRepo();
+                if (!repo) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Could not determine repository'] }];
+                }
+                // Validate claim label
+                if (!isValidLabel(this.config.claimLabel)) {
+                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid claim label configuration'] }];
                 }
-            }
-            // Add release comment
-            if (this.config.commentOnRelease) {
-                const claimantStr = claimant.type === 'human'
-                    ? `@${claimant.name.replace(/[^a-zA-Z0-9_-]/g, '')}`
-                    : `Agent: ${(claimant.agentType || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '')}`;
-                const comment = `🔓 **Issue released** by ${claimantStr}\n\n_This issue is now available for others to claim._`;
                 try {
-                    execFileSync('gh', [
-                        'issue', 'comment', String(issueNumber),
-                        '--repo', repo,
-                        '--body', comment
-                    ], { stdio: 'ignore' });
+                    // Remove claim label
+                    if (this.config.syncLabels) {
+                        try {
+                            execFileSync('gh', [
+                                'issue', 'edit', String(issueNumber),
+                                '--repo', repo,
+                                '--remove-label', this.config.claimLabel
+                            ], { stdio: 'ignore' });
+                        }
+                        catch (_b) {
+                            // Label might not exist
+                        }
+                    }
+                    // Remove assignee if human claimant
+                    if (this.config.autoAssign && claimant.type === 'human') {
+                        if (isValidClaimantName(claimant.name)) {
+                            try {
+                                execFileSync('gh', [
+                                    'issue', 'edit', String(issueNumber),
+                                    '--repo', repo,
+                                    '--remove-assignee', claimant.name
+                                ], { stdio: 'ignore' });
+                            }
+                            catch (_c) {
+                                errors.push('Failed to remove assignee');
+                            }
+                        }
+                    }
+                    // Add release comment
+                    if (this.config.commentOnRelease) {
+                        claimantStr = claimant.type === 'human'
+                            ? "@" + claimant.name.replace(/[^a-zA-Z0-9_-]/g, '')
+                            : "Agent: " + (claimant.agentType || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '');
+                        comment = "\uD83D\uDD13 **Issue released** by " + claimantStr + "\n\n_This issue is now available for others to claim._";
+                        try {
+                            execFileSync('gh', [
+                                'issue', 'comment', String(issueNumber),
+                                '--repo', repo,
+                                '--body', comment
+                            ], { stdio: 'ignore' });
+                        }
+                        catch (_d) {
+                            errors.push('Failed to add release comment');
+                        }
+                    }
+                    return [2 /*return*/, { success: errors.length === 0, synced: 1, errors: errors }];
                 }
-                catch {
-                    errors.push('Failed to add release comment');
+                catch (error) {
+                    errors.push("GitHub release sync failed: " + sanitizeError(error));
+                    return [2 /*return*/, { success: false, synced: 0, errors: errors }];
                 }
-            }
-            return { success: errors.length === 0, synced: 1, errors };
-        }
-        catch (error) {
-            errors.push(`GitHub release sync failed: ${sanitizeError(error)}`);
-            return { success: false, synced: 0, errors };
-        }
-    }
+                return [2 /*return*/];
+            });
+        });
+    };
     /**
      * Bulk sync all local claims to GitHub
      */
-    async syncAllClaimsToGitHub() {
-        const errors = [];
-        let synced = 0;
-        const claims = await this.claimService.getAllClaims();
-        for (const claim of claims) {
-            // Extract issue number from issueId (assumes format like "123" or "issue-123")
-            const issueMatch = claim.issueId.match(/(\d+)/);
-            if (issueMatch) {
-                const result = await this.claimOnGitHub(parseInt(issueMatch[1], 10), claim.claimant);
-                if (result.success)
-                    synced++;
-                else
-                    errors.push(...result.errors);
-            }
-        }
-        return { success: errors.length === 0, synced, errors };
-    }
+    GitHubSync.prototype.syncAllClaimsToGitHub = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var errors, synced, claims, _i, claims_1, claim, issueMatch, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        errors = [];
+                        synced = 0;
+                        return [4 /*yield*/, this.claimService.getAllClaims()];
+                    case 1:
+                        claims = _a.sent();
+                        _i = 0, claims_1 = claims;
+                        _a.label = 2;
+                    case 2:
+                        if (!(_i < claims_1.length)) return [3 /*break*/, 5];
+                        claim = claims_1[_i];
+                        issueMatch = claim.issueId.match(/(\d+)/);
+                        if (!issueMatch) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.claimOnGitHub(parseInt(issueMatch[1], 10), claim.claimant)];
+                    case 3:
+                        result = _a.sent();
+                        if (result.success)
+                            synced++;
+                        else
+                            errors.push.apply(errors, result.errors);
+                        _a.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/, { success: errors.length === 0, synced: synced, errors: errors }];
+                }
+            });
+        });
+    };
     /**
      * Get GitHub issues that are claimed locally
      */
-    async getClaimedGitHubIssues() {
-        const syncResult = await this.syncIssues('open');
-        if (!syncResult.success || !syncResult.issues)
-            return [];
-        const localClaims = await this.claimService.getAllClaims();
-        const claimedIds = new Set(localClaims.map(c => {
-            const match = c.issueId.match(/(\d+)/);
-            return match ? parseInt(match[1], 10) : null;
-        }).filter(Boolean));
-        return syncResult.issues.filter(issue => claimedIds.has(issue.number));
-    }
-}
+    GitHubSync.prototype.getClaimedGitHubIssues = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var syncResult, localClaims, claimedIds;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.syncIssues('open')];
+                    case 1:
+                        syncResult = _a.sent();
+                        if (!syncResult.success || !syncResult.issues)
+                            return [2 /*return*/, []];
+                        return [4 /*yield*/, this.claimService.getAllClaims()];
+                    case 2:
+                        localClaims = _a.sent();
+                        claimedIds = new Set(localClaims.map(function (c) {
+                            var match = c.issueId.match(/(\d+)/);
+                            return match ? parseInt(match[1], 10) : null;
+                        }).filter(Boolean));
+                        return [2 /*return*/, syncResult.issues.filter(function (issue) { return claimedIds.has(issue.number); })];
+                }
+            });
+        });
+    };
+    return GitHubSync;
+}());
+export { GitHubSync };
 // ============================================================================
 // Factory
 // ============================================================================