kynjal-cli 4.0.0 → 4.0.1

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

@@ -12,68 +12,6 @@
  *
  * @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';
@@ -81,7 +19,7 @@ import { execFileSync } from 'child_process';
 // ============================================================================
 // Default Configuration
 // ============================================================================
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     staleThresholdMinutes: 30,
     blockedThresholdMinutes: 60,
     overloadThreshold: 5,
@@ -92,647 +30,435 @@ var DEFAULT_CONFIG = {
     allowCrossTypeSteal: [
         ['coder', 'debugger'],
         ['tester', 'reviewer'],
-    ]
+    ],
 };
 // ============================================================================
 // Claim Service Implementation
 // ============================================================================
-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;
+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 };
     }
     // ==========================================================================
     // Initialization
     // ==========================================================================
-    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*/];
-                }
-            });
-        });
-    };
-    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
-                    }
+    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);
                 }
-                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*/];
-            });
-        });
-    };
+            }
+            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));
+    }
     // ==========================================================================
     // Core Claiming
     // ==========================================================================
-    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 }];
-                }
-            });
+    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.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*/];
-                }
-            });
+        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,
         });
-    };
+    }
     // ==========================================================================
     // Handoffs
     // ==========================================================================
-    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 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.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 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.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*/];
-                }
-            });
+    }
+    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 },
         });
-    };
+    }
     // ==========================================================================
     // Status Updates
     // ==========================================================================
-    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*/];
-                }
-            });
-        });
-    };
-    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*/];
-                }
-            });
+    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.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*/];
-                }
-            });
+    }
+    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 },
         });
-    };
+    }
     // ==========================================================================
     // Work Stealing
     // ==========================================================================
-    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*/];
-                }
-            });
-        });
-    };
-    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 }];
-                }
-            });
+    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.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);
+    }
+    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` };
                 }
-                return [2 /*return*/, stealable];
-            });
+            }
+        }
+        // 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 },
         });
-    };
-    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*/];
-            });
+        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 },
         });
-    };
+        // Contest resolution would typically be handled by a coordinator or human
+    }
     // ==========================================================================
     // Load Balancing
     // ==========================================================================
-    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++;
+    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',
+                        });
                     }
                 }
-                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];
-                }
-            });
-        });
-    };
+            }
+        }
+        return result;
+    }
     // ==========================================================================
     // Queries
     // ==========================================================================
-    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; })];
-            });
-        });
-    };
+    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);
+    }
     // ==========================================================================
     // Auto-Management
     // ==========================================================================
-    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];
-                }
-            });
-        });
-    };
+    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;
+    }
     // ==========================================================================
     // Helpers
     // ==========================================================================
-    ClaimService.prototype.formatClaimant = function (claimant) {
+    formatClaimant(claimant) {
         return claimant.type === 'human'
-            ? "human:" + claimant.name
-            : "agent:" + claimant.agentType + ":" + claimant.agentId;
-    };
-    ClaimService.prototype.isSameClaimant = function (a, b) {
+            ? `human:${claimant.name}`
+            : `agent:${claimant.agentType}:${claimant.agentId}`;
+    }
+    isSameClaimant(a, b) {
         if (a.type !== b.type)
             return false;
         if (a.type === 'human' && b.type === 'human') {
@@ -742,31 +468,28 @@ var ClaimService = /** @class */ (function (_super) {
             return a.agentId === b.agentId;
         }
         return false;
-    };
-    ClaimService.prototype.emitEvent = function (event) {
+    }
+    emitEvent(event) {
         this.eventLog.push(event);
         if (this.eventLog.length > 1000) {
             this.eventLog = this.eventLog.slice(-500);
         }
         this.emit(event.type, event);
-    };
-    ClaimService.prototype.getEventLog = function (limit) {
-        if (limit === void 0) { limit = 100; }
+    }
+    getEventLog(limit = 100) {
         return this.eventLog.slice(-limit);
-    };
-    return ClaimService;
-}(EventEmitter));
-export { ClaimService };
+    }
+}
 // ============================================================================
 // GitHub Sync Implementation
 // ============================================================================
-var DEFAULT_GITHUB_CONFIG = {
+const DEFAULT_GITHUB_CONFIG = {
     enabled: false,
     syncLabels: true,
     claimLabel: 'claimed',
     autoAssign: true,
     commentOnClaim: true,
-    commentOnRelease: true
+    commentOnRelease: true,
 };
 // ============================================================================
 // Input Validation (Security)
@@ -805,331 +528,283 @@ function isValidLabel(label) {
  * Sanitize error messages to prevent information disclosure
  */
 function sanitizeError(error) {
-    var msg = error.message || 'Unknown error';
+    const msg = error.message || 'Unknown error';
     // Remove paths and sensitive details
     return msg.replace(/\/[\w./-]+/g, '[path]').substring(0, 200);
 }
-var GitHubSync = /** @class */ (function () {
-    function GitHubSync(claimService, config) {
+export class GitHubSync {
+    config;
+    claimService;
+    constructor(claimService, config) {
         this.claimService = claimService;
-        this.config = __assign(__assign({}, DEFAULT_GITHUB_CONFIG), config);
+        this.config = { ...DEFAULT_GITHUB_CONFIG, ...config };
     }
     /**
      * Check if GitHub CLI is available
      */
-    GitHubSync.prototype.isGhAvailable = function () {
+    isGhAvailable() {
         try {
             execFileSync('gh', ['--version'], { stdio: 'ignore' });
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
-    };
+    }
     /**
      * Get the current repository from git remote
      */
-    GitHubSync.prototype.getRepo = function () {
+    getRepo() {
         if (this.config.repo) {
             return isValidRepo(this.config.repo) ? this.config.repo : null;
         }
         try {
-            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;
+            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;
             return repo && isValidRepo(repo) ? repo : null;
         }
-        catch (_a) {
+        catch {
             return null;
         }
-    };
+    }
     /**
      * Sync issues from GitHub
      */
-    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*/];
-            });
-        });
-    };
+    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 };
+        }
+    }
     /**
      * Sync a local claim to GitHub (add label/assignee/comment)
      */
-    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'] }];
-                }
-                if (!this.isGhAvailable()) {
-                    return [2 /*return*/, { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] }];
-                }
-                // Validate issue number
-                if (!isValidIssueNumber(issueNumber)) {
-                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid issue number'] }];
+    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' });
                 }
-                repo = this.getRepo();
-                if (!repo) {
-                    return [2 /*return*/, { success: false, synced: 0, errors: ['Could not determine repository'] }];
+                catch {
+                    errors.push('Failed to add claim label (label may not exist)');
                 }
-                // Validate claim label
-                if (!isValidLabel(this.config.claimLabel)) {
-                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid claim label configuration'] }];
+            }
+            // Auto-assign if human claimant
+            if (this.config.autoAssign && claimant.type === 'human') {
+                if (!isValidClaimantName(claimant.name)) {
+                    errors.push('Invalid claimant name format');
                 }
-                try {
-                    // 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');
-                            }
-                        }
+                else {
+                    try {
+                        execFileSync('gh', [
+                            'issue', 'edit', String(issueNumber),
+                            '--repo', repo,
+                            '--add-assignee', claimant.name
+                        ], { stdio: 'ignore' });
                     }
-                    // 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');
-                        }
+                    catch {
+                        errors.push('Failed to assign issue');
                     }
-                    return [2 /*return*/, { success: errors.length === 0, synced: 1, errors: errors }];
                 }
-                catch (error) {
-                    errors.push("GitHub sync failed: " + sanitizeError(error));
-                    return [2 /*return*/, { success: false, synced: 0, errors: errors }];
+            }
+            // 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 RuFlo V3_`;
+                try {
+                    execFileSync('gh', [
+                        'issue', 'comment', String(issueNumber),
+                        '--repo', repo,
+                        '--body', comment
+                    ], { stdio: 'ignore' });
+                }
+                catch {
+                    errors.push('Failed to add comment');
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
+            }
+            return { success: errors.length === 0, synced: 1, errors };
+        }
+        catch (error) {
+            errors.push(`GitHub sync failed: ${sanitizeError(error)}`);
+            return { success: false, synced: 0, errors };
+        }
+    }
     /**
      * Release claim on GitHub (remove label/assignee/comment)
      */
-    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'] }];
-                }
-                if (!this.isGhAvailable()) {
-                    return [2 /*return*/, { success: false, synced: 0, errors: ['GitHub CLI (gh) not installed'] }];
-                }
-                // 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'] }];
+    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' });
                 }
-                // Validate claim label
-                if (!isValidLabel(this.config.claimLabel)) {
-                    return [2 /*return*/, { success: false, synced: 0, errors: ['Invalid claim label configuration'] }];
+                catch {
+                    // Label might not exist
                 }
-                try {
-                    // 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');
-                            }
-                        }
+            }
+            // 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' });
                     }
-                    // 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');
-                        }
+                    catch {
+                        errors.push('Failed to remove assignee');
                     }
-                    return [2 /*return*/, { success: errors.length === 0, synced: 1, errors: errors }];
                 }
-                catch (error) {
-                    errors.push("GitHub release sync failed: " + sanitizeError(error));
-                    return [2 /*return*/, { success: false, synced: 0, errors: errors }];
+            }
+            // 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' });
+                }
+                catch {
+                    errors.push('Failed to add release comment');
                 }
-                return [2 /*return*/];
-            });
-        });
-    };
+            }
+            return { success: errors.length === 0, synced: 1, errors };
+        }
+        catch (error) {
+            errors.push(`GitHub release sync failed: ${sanitizeError(error)}`);
+            return { success: false, synced: 0, errors };
+        }
+    }
     /**
      * Bulk sync all local claims to GitHub
      */
-    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 }];
-                }
-            });
-        });
-    };
+    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 };
+    }
     /**
      * Get GitHub issues that are claimed locally
      */
-    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 };
+    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));
+    }
+}
 // ============================================================================
 // Factory
 // ============================================================================