claude-flow 3.10.3 → 3.10.5

package/.claude/worktrees/adr-120-impl/v3/@claude-flow/claims/src/api/cli-commands.ts

@@ -1,1459 +0,0 @@
-// @ts-nocheck - CLI integration requires the full @claude-flow/cli package
-/**
- * V3 CLI Claims Command
- * Issue claiming and work distribution management
- *
- * Implements:
- * - Core claiming commands (list, claim, release, handoff, status)
- * - Work stealing commands (stealable, steal, mark-stealable, contest)
- * - Load balancing commands (load, rebalance)
- */
-
-import type { Command, CommandContext, CommandResult } from './cli-types.js';
-import { output, select, confirm, input, callMCPTool, MCPClientError } from './cli-types.js';
-
-// ============================================
-// Types
-// ============================================
-
-export interface ClaimServices {
-  claimIssue: (issueId: string, claimantId: string, claimantType: ClaimantType) => Promise<Claim>;
-  releaseClaim: (issueId: string, claimantId: string) => Promise<void>;
-  requestHandoff: (issueId: string, targetId: string, targetType: ClaimantType) => Promise<HandoffRequest>;
-  updateStatus: (issueId: string, status: ClaimStatus, reason?: string) => Promise<Claim>;
-  listClaims: (filter?: ClaimFilter) => Promise<Claim[]>;
-  listStealable: () => Promise<Claim[]>;
-  stealIssue: (issueId: string, stealerId: string) => Promise<Claim>;
-  markStealable: (issueId: string, reason?: string) => Promise<Claim>;
-  contestSteal: (issueId: string, contesterId: string, reason: string) => Promise<ContestResult>;
-  getAgentLoad: (agentId?: string) => Promise<AgentLoad[]>;
-  rebalance: (dryRun?: boolean) => Promise<RebalanceResult>;
-}
-
-export type ClaimantType = 'agent' | 'human';
-export type ClaimStatus = 'active' | 'blocked' | 'review-requested' | 'stealable' | 'completed';
-
-export interface Claim {
-  issueId: string;
-  claimantId: string;
-  claimantType: ClaimantType;
-  status: ClaimStatus;
-  progress: number;
-  claimedAt: string;
-  expiresAt?: string;
-  blockedReason?: string;
-  stealableReason?: string;
-}
-
-export interface ClaimFilter {
-  claimantId?: string;
-  status?: ClaimStatus;
-  available?: boolean;
-}
-
-export interface HandoffRequest {
-  issueId: string;
-  fromId: string;
-  toId: string;
-  toType: ClaimantType;
-  requestedAt: string;
-  status: 'pending' | 'accepted' | 'rejected';
-}
-
-export interface ContestResult {
-  issueId: string;
-  contesterId: string;
-  originalClaimantId: string;
-  resolution: 'steal-reverted' | 'steal-upheld' | 'pending-review';
-  reason?: string;
-}
-
-export interface AgentLoad {
-  agentId: string;
-  agentType: string;
-  activeIssues: number;
-  totalCapacity: number;
-  utilizationPercent: number;
-  avgCompletionTime: string;
-  status: 'healthy' | 'overloaded' | 'idle';
-}
-
-export interface RebalanceResult {
-  moved: number;
-  reassignments: Array<{
-    issueId: string;
-    fromAgent: string;
-    toAgent: string;
-    reason: string;
-  }>;
-  skipped: number;
-  dryRun: boolean;
-}
-
-// ============================================
-// Formatting Helpers
-// ============================================
-
-function formatClaimStatus(status: ClaimStatus): string {
-  switch (status) {
-    case 'active':
-      return output.success(status);
-    case 'blocked':
-      return output.error(status);
-    case 'review-requested':
-      return output.warning(status);
-    case 'stealable':
-      return output.warning(status);
-    case 'completed':
-      return output.dim(status);
-    default:
-      return status;
-  }
-}
-
-function formatClaimantType(type: ClaimantType): string {
-  switch (type) {
-    case 'agent':
-      return output.info(type);
-    case 'human':
-      return output.highlight(type);
-    default:
-      return type;
-  }
-}
-
-function formatAgentStatus(status: 'healthy' | 'overloaded' | 'idle'): string {
-  switch (status) {
-    case 'healthy':
-      return output.success(status);
-    case 'overloaded':
-      return output.error(status);
-    case 'idle':
-      return output.dim(status);
-    default:
-      return status;
-  }
-}
-
-function formatProgress(progress: number): string {
-  if (progress >= 75) {
-    return output.success(`${progress}%`);
-  } else if (progress >= 25) {
-    return output.warning(`${progress}%`);
-  }
-  return output.dim(`${progress}%`);
-}
-
-function formatTimeRemaining(expiresAt?: string): string {
-  if (!expiresAt) return output.dim('N/A');
-
-  const expiry = new Date(expiresAt);
-  const now = new Date();
-  const diffMs = expiry.getTime() - now.getTime();
-
-  if (diffMs <= 0) {
-    return output.error('EXPIRED');
-  }
-
-  const hours = Math.floor(diffMs / (1000 * 60 * 60));
-  const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
-
-  if (hours < 1) {
-    return output.warning(`${minutes}m`);
-  } else if (hours < 4) {
-    return output.warning(`${hours}h ${minutes}m`);
-  }
-
-  return output.dim(`${hours}h ${minutes}m`);
-}
-
-function parseTarget(target: string): { id: string; type: ClaimantType } {
-  // Format: agent:coder-1 or human:alice
-  const [type, id] = target.split(':');
-  if (!type || !id || (type !== 'agent' && type !== 'human')) {
-    throw new Error(`Invalid target format: ${target}. Use agent:<id> or human:<id>`);
-  }
-  return { id, type: type as ClaimantType };
-}
-
-// ============================================
-// List Subcommand
-// ============================================
-
-const listCommand: Command = {
-  name: 'list',
-  aliases: ['ls'],
-  description: 'List issues',
-  options: [
-    {
-      name: 'available',
-      short: 'a',
-      description: 'Show only unclaimed issues',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'mine',
-      short: 'm',
-      description: 'Show only my claims',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'status',
-      short: 's',
-      description: 'Filter by status',
-      type: 'string',
-      choices: ['active', 'blocked', 'review-requested', 'stealable', 'completed']
-    },
-    {
-      name: 'limit',
-      short: 'l',
-      description: 'Maximum number of issues to show',
-      type: 'number',
-      default: 20
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const available = ctx.flags.available as boolean;
-    const mine = ctx.flags.mine as boolean;
-    const status = ctx.flags.status as ClaimStatus | undefined;
-    const limit = ctx.flags.limit as number;
-
-    try {
-      const result = await callMCPTool<{
-        claims: Claim[];
-        total: number;
-        available: number;
-      }>('claims/list', {
-        available,
-        mine,
-        status,
-        limit
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-
-      if (available) {
-        output.writeln(output.bold('Available Issues (Unclaimed)'));
-      } else if (mine) {
-        output.writeln(output.bold('My Claims'));
-      } else {
-        output.writeln(output.bold('All Claims'));
-      }
-
-      output.writeln();
-
-      if (result.claims.length === 0) {
-        if (available) {
-          output.printInfo('No unclaimed issues available');
-        } else if (mine) {
-          output.printInfo('You have no active claims');
-        } else {
-          output.printInfo('No claims found matching criteria');
-        }
-        return { success: true, data: result };
-      }
-
-      output.printTable({
-        columns: [
-          { key: 'issueId', header: 'Issue', width: 12 },
-          { key: 'claimant', header: 'Claimant', width: 15 },
-          { key: 'type', header: 'Type', width: 8 },
-          { key: 'status', header: 'Status', width: 16 },
-          { key: 'progress', header: 'Progress', width: 10 },
-          { key: 'time', header: 'Time Left', width: 12 }
-        ],
-        data: result.claims.map(c => ({
-          issueId: c.issueId,
-          claimant: c.claimantId || output.dim('unclaimed'),
-          type: c.claimantType ? formatClaimantType(c.claimantType) : '-',
-          status: formatClaimStatus(c.status),
-          progress: formatProgress(c.progress),
-          time: formatTimeRemaining(c.expiresAt)
-        }))
-      });
-
-      output.writeln();
-      output.printInfo(`Showing ${result.claims.length} of ${result.total} issues (${result.available} available)`);
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to list issues: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Claim Subcommand
-// ============================================
-
-const claimCommand: Command = {
-  name: 'claim',
-  description: 'Claim an issue to work on',
-  options: [
-    {
-      name: 'as',
-      description: 'Claim as specific identity (agent:id or human:id)',
-      type: 'string'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-    const asIdentity = ctx.flags.as as string | undefined;
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues claim <issueId>');
-      return { success: false, exitCode: 1 };
-    }
-
-    let claimantId = 'current-agent';
-    let claimantType: ClaimantType = 'agent';
-
-    if (asIdentity) {
-      const parsed = parseTarget(asIdentity);
-      claimantId = parsed.id;
-      claimantType = parsed.type;
-    }
-
-    output.writeln();
-    output.printInfo(`Claiming issue ${output.highlight(issueId)}...`);
-
-    try {
-      const result = await callMCPTool<Claim>('claims/claim', {
-        issueId,
-        claimantId,
-        claimantType
-      });
-
-      output.writeln();
-      output.printSuccess(`Issue ${issueId} claimed successfully`);
-      output.writeln();
-
-      output.printTable({
-        columns: [
-          { key: 'property', header: 'Property', width: 15 },
-          { key: 'value', header: 'Value', width: 35 }
-        ],
-        data: [
-          { property: 'Issue ID', value: result.issueId },
-          { property: 'Claimant', value: result.claimantId },
-          { property: 'Type', value: formatClaimantType(result.claimantType) },
-          { property: 'Status', value: formatClaimStatus(result.status) },
-          { property: 'Claimed At', value: new Date(result.claimedAt).toLocaleString() },
-          { property: 'Expires At', value: result.expiresAt ? new Date(result.expiresAt).toLocaleString() : 'N/A' }
-        ]
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to claim issue: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Release Subcommand
-// ============================================
-
-const releaseCommand: Command = {
-  name: 'release',
-  aliases: ['unclaim'],
-  description: 'Release a claim on an issue',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force release without confirmation',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'reason',
-      short: 'r',
-      description: 'Reason for releasing the claim',
-      type: 'string'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-    const force = ctx.flags.force as boolean;
-    const reason = ctx.flags.reason as string | undefined;
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues release <issueId>');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!force && ctx.interactive) {
-      const confirmed = await confirm({
-        message: `Release your claim on issue ${issueId}?`,
-        default: false
-      });
-
-      if (!confirmed) {
-        output.printInfo('Operation cancelled');
-        return { success: true };
-      }
-    }
-
-    output.writeln();
-    output.printInfo(`Releasing claim on issue ${output.highlight(issueId)}...`);
-
-    try {
-      await callMCPTool<void>('claims/release', {
-        issueId,
-        reason: reason || 'Released by user via CLI'
-      });
-
-      output.writeln();
-      output.printSuccess(`Claim on issue ${issueId} released`);
-
-      if (reason) {
-        output.printInfo(`Reason: ${reason}`);
-      }
-
-      return { success: true };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to release claim: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Handoff Subcommand
-// ============================================
-
-const handoffCommand: Command = {
-  name: 'handoff',
-  description: 'Request handoff of an issue to another agent or human',
-  options: [
-    {
-      name: 'to',
-      short: 't',
-      description: 'Target for handoff (agent:id or human:id)',
-      type: 'string',
-      required: true
-    },
-    {
-      name: 'reason',
-      short: 'r',
-      description: 'Reason for handoff',
-      type: 'string'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-    let target = ctx.flags.to as string;
-    const reason = ctx.flags.reason as string | undefined;
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues handoff <issueId> --to <target>');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!target && ctx.interactive) {
-      target = await input({
-        message: 'Handoff to (agent:id or human:id):',
-        validate: (v) => {
-          try {
-            parseTarget(v);
-            return true;
-          } catch {
-            return 'Invalid format. Use agent:<id> or human:<id>';
-          }
-        }
-      });
-    }
-
-    if (!target) {
-      output.printError('Target is required. Use --to flag (e.g., --to agent:coder-1)');
-      return { success: false, exitCode: 1 };
-    }
-
-    const parsedTarget = parseTarget(target);
-
-    output.writeln();
-    output.printInfo(`Requesting handoff of ${output.highlight(issueId)} to ${output.highlight(target)}...`);
-
-    try {
-      const result = await callMCPTool<HandoffRequest>('claims/handoff', {
-        issueId,
-        targetId: parsedTarget.id,
-        targetType: parsedTarget.type,
-        reason
-      });
-
-      output.writeln();
-      output.printSuccess(`Handoff requested for issue ${issueId}`);
-      output.writeln();
-
-      output.printTable({
-        columns: [
-          { key: 'property', header: 'Property', width: 15 },
-          { key: 'value', header: 'Value', width: 35 }
-        ],
-        data: [
-          { property: 'Issue ID', value: result.issueId },
-          { property: 'From', value: result.fromId },
-          { property: 'To', value: `${result.toType}:${result.toId}` },
-          { property: 'Status', value: output.warning(result.status) },
-          { property: 'Requested At', value: new Date(result.requestedAt).toLocaleString() }
-        ]
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to request handoff: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Status Subcommand
-// ============================================
-
-const statusCommand: Command = {
-  name: 'status',
-  description: 'Update or view issue claim status',
-  options: [
-    {
-      name: 'blocked',
-      short: 'b',
-      description: 'Mark issue as blocked with reason',
-      type: 'string'
-    },
-    {
-      name: 'review-requested',
-      short: 'r',
-      description: 'Request review for the issue',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'active',
-      short: 'a',
-      description: 'Mark issue as active (unblock)',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'progress',
-      short: 'p',
-      description: 'Update progress percentage (0-100)',
-      type: 'number'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues status <issueId> [options]');
-      return { success: false, exitCode: 1 };
-    }
-
-    const blocked = ctx.flags.blocked as string | undefined;
-    const reviewRequested = ctx.flags['review-requested'] as boolean;
-    const active = ctx.flags.active as boolean;
-    const progress = ctx.flags.progress as number | undefined;
-
-    // If no update flags, show current status
-    if (!blocked && !reviewRequested && !active && progress === undefined) {
-      try {
-        const result = await callMCPTool<Claim>('claims/status', { issueId });
-
-        if (ctx.flags.format === 'json') {
-          output.printJson(result);
-          return { success: true, data: result };
-        }
-
-        output.writeln();
-        output.printBox(
-          [
-            `Claimant:    ${result.claimantId || 'unclaimed'}`,
-            `Type:        ${formatClaimantType(result.claimantType)}`,
-            `Status:      ${formatClaimStatus(result.status)}`,
-            `Progress:    ${formatProgress(result.progress)}`,
-            '',
-            `Claimed At:  ${result.claimedAt ? new Date(result.claimedAt).toLocaleString() : 'N/A'}`,
-            `Expires At:  ${result.expiresAt ? new Date(result.expiresAt).toLocaleString() : 'N/A'}`,
-            '',
-            result.blockedReason ? `Blocked:     ${result.blockedReason}` : '',
-            result.stealableReason ? `Stealable:   ${result.stealableReason}` : ''
-          ].filter(Boolean).join('\n'),
-          `Issue: ${issueId}`
-        );
-
-        return { success: true, data: result };
-      } catch (error) {
-        if (error instanceof MCPClientError) {
-          output.printError(`Failed to get status: ${error.message}`);
-        } else {
-          output.printError(`Unexpected error: ${String(error)}`);
-        }
-        return { success: false, exitCode: 1 };
-      }
-    }
-
-    // Update status
-    let newStatus: ClaimStatus | undefined;
-    let reason: string | undefined;
-
-    if (blocked) {
-      newStatus = 'blocked';
-      reason = blocked;
-    } else if (reviewRequested) {
-      newStatus = 'review-requested';
-    } else if (active) {
-      newStatus = 'active';
-    }
-
-    output.writeln();
-    output.printInfo(`Updating issue ${output.highlight(issueId)}...`);
-
-    try {
-      const result = await callMCPTool<Claim>('claims/update', {
-        issueId,
-        status: newStatus,
-        reason,
-        progress
-      });
-
-      output.writeln();
-      output.printSuccess(`Issue ${issueId} updated`);
-      output.writeln();
-
-      const updates: Array<{ property: string; value: string }> = [];
-
-      if (newStatus) {
-        updates.push({ property: 'Status', value: formatClaimStatus(result.status) });
-      }
-
-      if (reason) {
-        updates.push({ property: 'Reason', value: reason });
-      }
-
-      if (progress !== undefined) {
-        updates.push({ property: 'Progress', value: formatProgress(result.progress) });
-      }
-
-      output.printTable({
-        columns: [
-          { key: 'property', header: 'Property', width: 15 },
-          { key: 'value', header: 'Value', width: 35 }
-        ],
-        data: updates
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to update status: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Board Subcommand
-// ============================================
-
-const boardCommand: Command = {
-  name: 'board',
-  description: 'View who is working on what',
-  options: [
-    {
-      name: 'all',
-      short: 'a',
-      description: 'Show all issues including completed',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'group',
-      short: 'g',
-      description: 'Group by claimant type',
-      type: 'boolean',
-      default: false
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const showAll = ctx.flags.all as boolean;
-    const groupBy = ctx.flags.group as boolean;
-
-    try {
-      const result = await callMCPTool<{
-        claims: Claim[];
-        stats: {
-          totalClaimed: number;
-          totalAvailable: number;
-          agentClaims: number;
-          humanClaims: number;
-        };
-      }>('claims/board', {
-        includeCompleted: showAll
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('Issue Claims Board'));
-      output.writeln();
-
-      // Stats summary
-      output.printList([
-        `Total Claimed: ${output.highlight(String(result.stats.totalClaimed))}`,
-        `Available: ${output.success(String(result.stats.totalAvailable))}`,
-        `By Agents: ${output.info(String(result.stats.agentClaims))}`,
-        `By Humans: ${output.highlight(String(result.stats.humanClaims))}`
-      ]);
-
-      output.writeln();
-
-      if (result.claims.length === 0) {
-        output.printInfo('No active claims');
-        return { success: true, data: result };
-      }
-
-      if (groupBy) {
-        // Group by claimant type
-        const agents = result.claims.filter(c => c.claimantType === 'agent');
-        const humans = result.claims.filter(c => c.claimantType === 'human');
-
-        if (agents.length > 0) {
-          output.writeln(output.bold('Agent Claims'));
-          printBoardTable(agents);
-          output.writeln();
-        }
-
-        if (humans.length > 0) {
-          output.writeln(output.bold('Human Claims'));
-          printBoardTable(humans);
-          output.writeln();
-        }
-      } else {
-        printBoardTable(result.claims);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to load board: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-function printBoardTable(claims: Claim[]): void {
-  output.printTable({
-    columns: [
-      { key: 'issue', header: 'Issue', width: 12 },
-      { key: 'claimant', header: 'Claimant', width: 15 },
-      { key: 'type', header: 'Type', width: 8 },
-      { key: 'status', header: 'Status', width: 16 },
-      { key: 'progress', header: 'Progress', width: 10 },
-      { key: 'time', header: 'Time', width: 12 }
-    ],
-    data: claims.map(c => ({
-      issue: c.issueId,
-      claimant: c.claimantId,
-      type: formatClaimantType(c.claimantType),
-      status: formatClaimStatus(c.status),
-      progress: formatProgress(c.progress),
-      time: formatTimeRemaining(c.expiresAt)
-    }))
-  });
-}
-
-// ============================================
-// Work Stealing Commands
-// ============================================
-
-const stealableCommand: Command = {
-  name: 'stealable',
-  description: 'List stealable issues',
-  options: [
-    {
-      name: 'limit',
-      short: 'l',
-      description: 'Maximum number of issues to show',
-      type: 'number',
-      default: 20
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const limit = ctx.flags.limit as number;
-
-    try {
-      const result = await callMCPTool<{
-        claims: Claim[];
-        total: number;
-      }>('claims/stealable', { limit });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('Stealable Issues'));
-      output.writeln();
-
-      if (result.claims.length === 0) {
-        output.printInfo('No stealable issues available');
-        return { success: true, data: result };
-      }
-
-      output.printTable({
-        columns: [
-          { key: 'issue', header: 'Issue', width: 12 },
-          { key: 'claimant', header: 'Current Owner', width: 15 },
-          { key: 'progress', header: 'Progress', width: 10 },
-          { key: 'reason', header: 'Stealable Reason', width: 30 }
-        ],
-        data: result.claims.map(c => ({
-          issue: c.issueId,
-          claimant: c.claimantId,
-          progress: formatProgress(c.progress),
-          reason: c.stealableReason || output.dim('No reason provided')
-        }))
-      });
-
-      output.writeln();
-      output.printInfo(`Showing ${result.claims.length} of ${result.total} stealable issues`);
-      output.writeln();
-      output.printInfo('Use "claude-flow issues steal <issueId>" to take over an issue');
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to list stealable issues: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-const stealCommand: Command = {
-  name: 'steal',
-  description: 'Steal an issue from another agent',
-  options: [
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force steal without confirmation',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'reason',
-      short: 'r',
-      description: 'Reason for stealing',
-      type: 'string'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-    const force = ctx.flags.force as boolean;
-    const reason = ctx.flags.reason as string | undefined;
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues steal <issueId>');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!force && ctx.interactive) {
-      output.writeln();
-      output.printWarning('Work stealing should be used responsibly.');
-      output.printInfo('This action will reassign the issue to you.');
-      output.writeln();
-
-      const confirmed = await confirm({
-        message: `Steal issue ${issueId}?`,
-        default: false
-      });
-
-      if (!confirmed) {
-        output.printInfo('Operation cancelled');
-        return { success: true };
-      }
-    }
-
-    output.writeln();
-    output.printInfo(`Stealing issue ${output.highlight(issueId)}...`);
-
-    try {
-      const result = await callMCPTool<Claim>('claims/steal', {
-        issueId,
-        reason
-      });
-
-      output.writeln();
-      output.printSuccess(`Issue ${issueId} stolen successfully`);
-      output.writeln();
-
-      output.printTable({
-        columns: [
-          { key: 'property', header: 'Property', width: 15 },
-          { key: 'value', header: 'Value', width: 35 }
-        ],
-        data: [
-          { property: 'Issue ID', value: result.issueId },
-          { property: 'New Claimant', value: result.claimantId },
-          { property: 'Status', value: formatClaimStatus(result.status) },
-          { property: 'Progress', value: formatProgress(result.progress) }
-        ]
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to steal issue: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-const markStealableCommand: Command = {
-  name: 'mark-stealable',
-  description: 'Mark my claim as stealable',
-  options: [
-    {
-      name: 'reason',
-      short: 'r',
-      description: 'Reason for marking as stealable',
-      type: 'string'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-    let reason = ctx.flags.reason as string | undefined;
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues mark-stealable <issueId>');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!reason && ctx.interactive) {
-      reason = await input({
-        message: 'Reason for marking as stealable (optional):',
-        default: ''
-      });
-    }
-
-    output.writeln();
-    output.printInfo(`Marking issue ${output.highlight(issueId)} as stealable...`);
-
-    try {
-      const result = await callMCPTool<Claim>('claims/mark-stealable', {
-        issueId,
-        reason: reason || undefined
-      });
-
-      output.writeln();
-      output.printSuccess(`Issue ${issueId} marked as stealable`);
-
-      if (reason) {
-        output.printInfo(`Reason: ${reason}`);
-      }
-
-      output.writeln();
-      output.printWarning('Other agents can now claim this issue');
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to mark as stealable: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-const contestCommand: Command = {
-  name: 'contest',
-  description: 'Contest a steal action',
-  options: [
-    {
-      name: 'reason',
-      short: 'r',
-      description: 'Reason for contesting (required)',
-      type: 'string',
-      required: true
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const issueId = ctx.args[0];
-    let reason = ctx.flags.reason as string;
-
-    if (!issueId) {
-      output.printError('Issue ID is required');
-      output.printInfo('Usage: claude-flow issues contest <issueId> --reason "..."');
-      return { success: false, exitCode: 1 };
-    }
-
-    if (!reason && ctx.interactive) {
-      reason = await input({
-        message: 'Reason for contesting (required):',
-        validate: (v) => v.length > 0 || 'Reason is required'
-      });
-    }
-
-    if (!reason) {
-      output.printError('Reason is required for contesting');
-      return { success: false, exitCode: 1 };
-    }
-
-    output.writeln();
-    output.printInfo(`Contesting steal on issue ${output.highlight(issueId)}...`);
-
-    try {
-      const result = await callMCPTool<ContestResult>('claims/contest', {
-        issueId,
-        reason
-      });
-
-      output.writeln();
-
-      switch (result.resolution) {
-        case 'steal-reverted':
-          output.printSuccess('Contest successful - steal reverted');
-          output.printInfo(`Issue ${issueId} returned to original claimant: ${result.originalClaimantId}`);
-          break;
-        case 'steal-upheld':
-          output.printWarning('Contest denied - steal upheld');
-          output.printInfo(`Issue ${issueId} remains with: ${result.contesterId}`);
-          break;
-        case 'pending-review':
-          output.printWarning('Contest submitted for review');
-          output.printInfo('A coordinator will review this contest');
-          break;
-      }
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to contest steal: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Load Balancing Commands
-// ============================================
-
-const loadCommand: Command = {
-  name: 'load',
-  description: 'View agent load distribution',
-  options: [
-    {
-      name: 'agent',
-      short: 'a',
-      description: 'View specific agent load',
-      type: 'string'
-    },
-    {
-      name: 'sort',
-      short: 's',
-      description: 'Sort by field',
-      type: 'string',
-      choices: ['utilization', 'issues', 'agent'],
-      default: 'utilization'
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const agentId = ctx.flags.agent as string | undefined;
-    const sortBy = ctx.flags.sort as string;
-
-    try {
-      const result = await callMCPTool<{
-        agents: AgentLoad[];
-        summary: {
-          totalAgents: number;
-          totalIssues: number;
-          avgUtilization: number;
-          overloadedCount: number;
-          idleCount: number;
-        };
-      }>('claims/load', {
-        agentId,
-        sortBy
-      });
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-        return { success: true, data: result };
-      }
-
-      output.writeln();
-      output.writeln(output.bold('Agent Load Distribution'));
-      output.writeln();
-
-      // Summary
-      output.printList([
-        `Total Agents: ${result.summary.totalAgents}`,
-        `Active Issues: ${result.summary.totalIssues}`,
-        `Avg Utilization: ${result.summary.avgUtilization.toFixed(1)}%`,
-        `Overloaded: ${output.error(String(result.summary.overloadedCount))}`,
-        `Idle: ${output.dim(String(result.summary.idleCount))}`
-      ]);
-
-      output.writeln();
-
-      if (agentId) {
-        // Single agent detail
-        const agent = result.agents[0];
-        if (!agent) {
-          output.printError(`Agent ${agentId} not found`);
-          return { success: false, exitCode: 1 };
-        }
-
-        output.printBox(
-          [
-            `Type:           ${agent.agentType}`,
-            `Status:         ${formatAgentStatus(agent.status)}`,
-            `Active Issues:  ${agent.activeIssues}`,
-            `Capacity:       ${agent.totalCapacity}`,
-            `Utilization:    ${output.progressBar(agent.utilizationPercent, 100, 30)}`,
-            `Avg Completion: ${agent.avgCompletionTime}`
-          ].join('\n'),
-          `Agent: ${agent.agentId}`
-        );
-      } else {
-        // All agents table
-        output.printTable({
-          columns: [
-            { key: 'agent', header: 'Agent', width: 15 },
-            { key: 'type', header: 'Type', width: 12 },
-            { key: 'issues', header: 'Issues', width: 8, align: 'right' },
-            { key: 'capacity', header: 'Cap', width: 6, align: 'right' },
-            { key: 'utilization', header: 'Utilization', width: 15 },
-            { key: 'status', header: 'Status', width: 12 }
-          ],
-          data: result.agents.map(a => ({
-            agent: a.agentId,
-            type: a.agentType,
-            issues: a.activeIssues,
-            capacity: a.totalCapacity,
-            utilization: `${a.utilizationPercent.toFixed(0)}%`,
-            status: formatAgentStatus(a.status)
-          }))
-        });
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to get load info: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-const rebalanceCommand: Command = {
-  name: 'rebalance',
-  description: 'Trigger swarm rebalancing',
-  options: [
-    {
-      name: 'dry-run',
-      short: 'd',
-      description: 'Preview rebalancing without making changes',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'force',
-      short: 'f',
-      description: 'Force rebalancing without confirmation',
-      type: 'boolean',
-      default: false
-    },
-    {
-      name: 'threshold',
-      short: 't',
-      description: 'Utilization threshold for rebalancing (0-100)',
-      type: 'number',
-      default: 80
-    }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    const dryRun = ctx.flags['dry-run'] as boolean;
-    const force = ctx.flags.force as boolean;
-    const threshold = ctx.flags.threshold as number;
-
-    if (!dryRun && !force && ctx.interactive) {
-      output.writeln();
-      output.printWarning('This will reassign issues between agents to balance load.');
-
-      const confirmed = await confirm({
-        message: 'Proceed with rebalancing?',
-        default: false
-      });
-
-      if (!confirmed) {
-        output.printInfo('Operation cancelled');
-        return { success: true };
-      }
-    }
-
-    output.writeln();
-
-    if (dryRun) {
-      output.printInfo('Analyzing rebalancing options (dry run)...');
-    } else {
-      output.printInfo('Rebalancing swarm workload...');
-    }
-
-    const spinner = output.createSpinner({ text: 'Calculating optimal distribution...', spinner: 'dots' });
-    spinner.start();
-
-    try {
-      const result = await callMCPTool<RebalanceResult>('claims/rebalance', {
-        dryRun,
-        threshold
-      });
-
-      spinner.stop();
-
-      output.writeln();
-
-      if (dryRun) {
-        output.printSuccess('Rebalancing Analysis Complete (Dry Run)');
-      } else {
-        output.printSuccess('Rebalancing Complete');
-      }
-
-      output.writeln();
-
-      // Summary stats
-      output.printList([
-        `Issues to move: ${output.highlight(String(result.moved))}`,
-        `Issues skipped: ${output.dim(String(result.skipped))}`,
-        `Mode: ${dryRun ? output.warning('DRY RUN') : output.success('APPLIED')}`
-      ]);
-
-      if (result.reassignments.length > 0) {
-        output.writeln();
-        output.writeln(output.bold('Reassignments'));
-
-        output.printTable({
-          columns: [
-            { key: 'issue', header: 'Issue', width: 12 },
-            { key: 'from', header: 'From', width: 15 },
-            { key: 'to', header: 'To', width: 15 },
-            { key: 'reason', header: 'Reason', width: 30 }
-          ],
-          data: result.reassignments.map(r => ({
-            issue: r.issueId,
-            from: r.fromAgent,
-            to: r.toAgent,
-            reason: r.reason
-          }))
-        });
-
-        if (dryRun) {
-          output.writeln();
-          output.printInfo('Run without --dry-run to apply these changes');
-        }
-      } else {
-        output.writeln();
-        output.printInfo('No reassignments needed - workload is balanced');
-      }
-
-      if (ctx.flags.format === 'json') {
-        output.printJson(result);
-      }
-
-      return { success: true, data: result };
-    } catch (error) {
-      spinner.fail('Rebalancing failed');
-
-      if (error instanceof MCPClientError) {
-        output.printError(`Failed to rebalance: ${error.message}`);
-      } else {
-        output.printError(`Unexpected error: ${String(error)}`);
-      }
-      return { success: false, exitCode: 1 };
-    }
-  }
-};
-
-// ============================================
-// Main Issues Command
-// ============================================
-
-export const issuesCommand: Command = {
-  name: 'issues',
-  description: 'Manage issue claims and work distribution',
-  subcommands: [
-    // Core claiming
-    listCommand,
-    claimCommand,
-    releaseCommand,
-    handoffCommand,
-    statusCommand,
-    boardCommand,
-    // Work stealing
-    stealableCommand,
-    stealCommand,
-    markStealableCommand,
-    contestCommand,
-    // Load balancing
-    loadCommand,
-    rebalanceCommand
-  ],
-  options: [],
-  examples: [
-    { command: 'claude-flow issues list --available', description: 'List unclaimed issues' },
-    { command: 'claude-flow issues list --mine', description: 'List my claims' },
-    { command: 'claude-flow issues claim GH-123', description: 'Claim an issue' },
-    { command: 'claude-flow issues release GH-123', description: 'Release a claim' },
-    { command: 'claude-flow issues handoff GH-123 --to agent:coder-1', description: 'Request handoff to agent' },
-    { command: 'claude-flow issues handoff GH-123 --to human:alice', description: 'Request handoff to human' },
-    { command: 'claude-flow issues status GH-123 --blocked "Waiting for API"', description: 'Mark as blocked' },
-    { command: 'claude-flow issues status GH-123 --review-requested', description: 'Request review' },
-    { command: 'claude-flow issues board', description: 'View who is working on what' },
-    { command: 'claude-flow issues stealable', description: 'List stealable issues' },
-    { command: 'claude-flow issues steal GH-123', description: 'Steal an issue' },
-    { command: 'claude-flow issues mark-stealable GH-123', description: 'Mark my claim as stealable' },
-    { command: 'claude-flow issues contest GH-123 -r "I was actively working on it"', description: 'Contest a steal' },
-    { command: 'claude-flow issues load', description: 'View agent load distribution' },
-    { command: 'claude-flow issues load --agent coder-1', description: 'View specific agent load' },
-    { command: 'claude-flow issues rebalance --dry-run', description: 'Preview rebalancing' },
-    { command: 'claude-flow issues rebalance', description: 'Trigger swarm rebalancing' }
-  ],
-  action: async (ctx: CommandContext): Promise<CommandResult> => {
-    // Show help if no subcommand
-    output.writeln();
-    output.writeln(output.bold('Issue Claims Management'));
-    output.writeln();
-    output.writeln('Usage: claude-flow issues <subcommand> [options]');
-    output.writeln();
-
-    output.writeln(output.bold('Core Commands'));
-    output.printList([
-      `${output.highlight('list')}           - List issues (--available, --mine)`,
-      `${output.highlight('claim')}          - Claim an issue to work on`,
-      `${output.highlight('release')}        - Release a claim on an issue`,
-      `${output.highlight('handoff')}        - Request handoff to another agent/human`,
-      `${output.highlight('status')}         - Update or view issue claim status`,
-      `${output.highlight('board')}          - View who is working on what`
-    ]);
-
-    output.writeln();
-    output.writeln(output.bold('Work Stealing Commands'));
-    output.printList([
-      `${output.highlight('stealable')}      - List stealable issues`,
-      `${output.highlight('steal')}          - Steal an issue from another agent`,
-      `${output.highlight('mark-stealable')} - Mark my claim as stealable`,
-      `${output.highlight('contest')}        - Contest a steal action`
-    ]);
-
-    output.writeln();
-    output.writeln(output.bold('Load Balancing Commands'));
-    output.printList([
-      `${output.highlight('load')}           - View agent load distribution`,
-      `${output.highlight('rebalance')}      - Trigger swarm rebalancing`
-    ]);
-
-    output.writeln();
-    output.writeln('Run "claude-flow issues <subcommand> --help" for subcommand help');
-
-    return { success: true };
-  }
-};
-
-// ============================================
-// Factory Function (for dependency injection)
-// ============================================
-
-/**
- * Create issues command with injected services
- * This allows for testing with mock services
- */
-export function createIssuesCommand(services: ClaimServices): Command {
-  // The command structure remains the same, but actions would use
-  // the injected services instead of callMCPTool
-  // For now, we return the default command which uses MCP tools
-  return issuesCommand;
-}
-
-export default issuesCommand;