outcome-cli 1.0.0

package/src/cli/commands/logs.ts

@@ -0,0 +1,83 @@
+/**
+ * Logs Command - Display logs for an outcome
+ *
+ * @module cli/commands/logs
+ * @see Requirements 7.2
+ */
+
+import { getLogs, getAgentLogs, formatLogsForCli, type LogEntry } from '../../utils/logger.js';
+
+/**
+ * Options for the logs command.
+ */
+interface LogsOptions {
+  agent?: string;
+  json: boolean;
+}
+
+/**
+ * Formats a log entry as JSON-friendly object.
+ */
+function formatLogAsJson(entry: LogEntry): object {
+  return {
+    timestamp: entry.timestamp,
+    agentId: entry.agentId,
+    outcomeId: entry.outcomeId,
+    promptVersion: entry.promptVersion,
+    tokensSpent: entry.tokensSpent,
+    result: entry.result,
+    ...(entry.failureReason && { failureReason: entry.failureReason }),
+    ...(entry.metadata && { metadata: entry.metadata }),
+  };
+}
+
+/**
+ * Handler for the `outcome logs` command.
+ *
+ * @param name - Outcome name to show logs for
+ * @param options - Command options
+ *
+ * @see Requirements 7.2
+ */
+export async function logsCommand(name: string, options: LogsOptions): Promise<void> {
+  // Get logs based on filters
+  let logs: LogEntry[];
+
+  if (options.agent) {
+    logs = getAgentLogs(name, options.agent);
+  } else {
+    logs = getLogs(name);
+  }
+
+  // Output in requested format
+  if (options.json) {
+    const jsonOutput = logs.map(formatLogAsJson);
+    console.log(JSON.stringify(jsonOutput, null, 2));
+  } else {
+    if (logs.length === 0) {
+      console.log(`\n📋 No logs found for outcome: ${name}`);
+      if (options.agent) {
+        console.log(`   (filtered by agent: ${options.agent})`);
+      }
+      console.log('\nTip: Run a league first with: earnd outcome run <name>');
+      return;
+    }
+
+    console.log(formatLogsForCli(name));
+
+    if (options.agent) {
+      console.log(`Filtered by agent: ${options.agent}`);
+    }
+
+    // Summary statistics
+    const successCount = logs.filter((l) => l.result === 'SUCCESS').length;
+    const failureCount = logs.filter((l) => l.result === 'FAILURE').length;
+    const pendingCount = logs.filter((l) => l.result === 'PENDING').length;
+    const totalTokens = logs.reduce((sum, l) => sum + l.tokensSpent, 0);
+
+    console.log('\n📊 Summary:');
+    console.log(`   Total Entries: ${logs.length}`);
+    console.log(`   Success: ${successCount}, Failure: ${failureCount}, Pending: ${pendingCount}`);
+    console.log(`   Total Tokens: ${totalTokens.toLocaleString()}`);
+  }
+}

package/src/cli/commands/run.ts

@@ -0,0 +1,416 @@
+/**
+ * Run Command - Start a league run with N agents
+ *
+ * @module cli/commands/run
+ * @see Requirements 7.1
+ */
+
+import { runLeague, runLeagueMock, type LeagueConfig } from '../../league/index.js';
+import { qualifiedSalesInterest } from '../../outcomes/qualified_sales_interest.js';
+import { codeReviewBattle } from '../../outcomes/code_review_battle.js';
+import { leadGenBattle } from '../../outcomes/lead_gen_battle.js';
+import { CODE_DELIVERY_OUTCOMES } from '../../outcomes/code-delivery-outcomes.js';
+import type { AgentConfig } from '../../agents/agent.schema.js';
+import type { Lead } from '../../jobs/job.interface.js';
+
+/**
+ * Options for the run command.
+ */
+interface RunOptions {
+  agents: string;
+  ceiling: string;
+  mock: boolean;
+  provider: 'claude' | 'openai';
+  model: string;
+  mode: 'league' | 'swarm' | 'pipeline';
+  goal?: string;
+  targetUrl?: string;
+  dryRun?: boolean;
+  json?: boolean;
+}
+
+/**
+ * Creates sample code delivery artifact for feature/refactor/test generation.
+ */
+function createSampleCodeArtifact(): any {
+  return {
+    repoPath: '/tmp/repo',
+    worktreePath: '/tmp/repo-worktree',
+    commitSha: 'HEAD',
+    testCommand: 'npm test',
+    buildCommand: 'npm run build',
+    lintCommand: 'npm run lint',
+    benchmarkCommand: 'npm run bench',
+    securityScanCommand: 'npm run scan',
+    testResult: { passed: true, failCount: 0, totalCount: 120 },
+    buildResult: { success: true },
+    lintResult: { errors: 0, warnings: 0 },
+    benchmarkResult: { p95Ms: 180, maxMs: 220 },
+    securityScanResult: { findings: [] },
+    code: '// feature implementation placeholder',
+    language: 'typescript',
+  };
+}
+
+/**
+ * Creates a default agent configuration.
+ *
+ * @param index Agent index
+ * @param provider Model provider
+ * @param modelId Model ID
+ * @param outcomeName Outcome name
+ * @returns Agent configuration
+ */
+function createDefaultAgent(
+  index: number,
+  provider: 'claude' | 'openai',
+  modelId: string,
+  outcomeName: string
+): AgentConfig {
+  // Use tournament-specific agents for tournament outcomes
+  if (outcomeName === 'code_review_battle' || outcomeName === 'lead_gen_battle') {
+    const tournamentAgents = [
+      'tournament-coderabbit',
+      'tournament-claude-sonnet', 
+      'tournament-gpt4o',
+      'tournament-llama3'
+    ];
+    
+    // Cycle through tournament agents
+    const agentId = tournamentAgents[index % tournamentAgents.length];
+    
+    return {
+      id: `${agentId}-${index}`,
+      name: `Tournament Agent ${index} (${agentId})`,
+      prompt: getTournamentPrompt(agentId, outcomeName),
+      strategyDescription: `Tournament-optimized for ${outcomeName}`,
+      toolAccess: getTournamentTools(agentId),
+      costCeiling: getTournamentCostCeiling(agentId),
+      modelProvider: getTournamentProvider(agentId),
+      modelId: getTournamentModelId(agentId),
+    };
+  }
+
+  // Default sales agent for qualified_sales_interest
+  return {
+    id: `agent-${index}`,
+    name: `Agent ${index}`,
+    prompt: `You are a professional sales qualification agent for a B2B SaaS company.
+Your goal is to engage with prospects and qualify them as potential customers.
+
+## Your Objective
+Generate a qualified sales lead by having a conversation that:
+1. Identifies buying intent (mentions of pricing, demo requests, or next steps)
+2. Confirms the prospect's company has at least 50 employees
+3. Verifies the prospect holds a decision-making role (not an intern or student)
+4. Produces a substantive response (at least 20 words)
+5. Obtains a valid email address for follow-up
+
+## Response Format
+When you have gathered all required information, structure your response as:
+- A summary of the prospect's needs and interest level
+- Key qualification details (company size, role, buying signals)
+- Proposed next steps (demo, pricing discussion, etc.)
+- Contact information for follow-up`,
+    strategyDescription: 'Consultative sales approach to qualify leads',
+    toolAccess: [],
+    costCeiling: 10000,
+    modelProvider: provider,
+    modelId,
+  };
+}
+
+/**
+ * Gets tournament-specific prompt for an agent.
+ */
+function getTournamentPrompt(agentId: string, outcomeName: string): string {
+  const basePrompts = {
+    'tournament-coderabbit': `You are CodeRabbit, an AI-powered code review specialist designed for tournament competition.
+Your expertise is in comprehensive code analysis, identifying security vulnerabilities, performance bottlenecks, and suggesting complexity-reducing refactors.`,
+    'tournament-claude-sonnet': `You are Claude Sonnet, a tournament-optimized generalist AI agent with exceptional reasoning capabilities across multiple domains.
+Your strength lies in balanced, methodical analysis that excels in both code review and lead generation challenges.`,
+    'tournament-gpt4o': `You are GPT-4o, the high-accuracy tournament elite designed for maximum precision in competitive AI challenges.
+Your competitive advantage is exceptional accuracy and attention to detail.`,
+    'tournament-llama3': `You are Llama3, the cost-efficient tournament competitor designed to deliver competitive performance while maintaining optimal cost-effectiveness.
+Your competitive strategy focuses on efficient resource utilization.`
+  };
+
+  const outcomeSpecific = outcomeName === 'code_review_battle' 
+    ? `Focus on identifying CRITICAL security vulnerabilities, performance bottlenecks, ensuring zero noise comments, and suggesting complexity-reducing refactors.`
+    : `Focus on precise lead qualification with valid email formats, company size validation, role verification, and LinkedIn URL validation.`;
+
+  return `${basePrompts[agentId as keyof typeof basePrompts]}
+
+${outcomeSpecific}
+
+Your goal is to achieve perfect scores in tournament ${outcomeName} by meeting all success criteria with surgical precision.`;
+}
+
+/**
+ * Gets tournament-specific tools for an agent.
+ */
+function getTournamentTools(agentId: string): string[] {
+  const toolMap = {
+    'tournament-coderabbit': ['code_analyzer', 'security_scanner', 'performance_profiler'],
+    'tournament-claude-sonnet': ['code_analyzer', 'email_validator', 'company_research', 'linkedin_lookup'],
+    'tournament-gpt4o': ['advanced_code_analyzer', 'security_vulnerability_scanner', 'email_validator', 'company_research', 'linkedin_validator'],
+    'tournament-llama3': ['basic_code_analyzer', 'email_validator', 'company_lookup']
+  };
+  
+  return toolMap[agentId as keyof typeof toolMap] || [];
+}
+
+/**
+ * Gets tournament-specific cost ceiling for an agent.
+ */
+function getTournamentCostCeiling(agentId: string): number {
+  const ceilingMap = {
+    'tournament-coderabbit': 10000,
+    'tournament-claude-sonnet': 8000,
+    'tournament-gpt4o': 12000,
+    'tournament-llama3': 3000
+  };
+  
+  return ceilingMap[agentId as keyof typeof ceilingMap] || 8000;
+}
+
+/**
+ * Gets tournament-specific model provider for an agent.
+ */
+function getTournamentProvider(agentId: string): 'claude' | 'openai' {
+  const providerMap = {
+    'tournament-coderabbit': 'claude' as const,
+    'tournament-claude-sonnet': 'claude' as const,
+    'tournament-gpt4o': 'openai' as const,
+    'tournament-llama3': 'claude' as const // Fallback to claude for CLI compatibility
+  };
+  
+  return providerMap[agentId as keyof typeof providerMap] || 'claude';
+}
+
+/**
+ * Gets tournament-specific model ID for an agent.
+ */
+function getTournamentModelId(agentId: string): string {
+  const modelMap = {
+    'tournament-coderabbit': 'claude-sonnet-4-20250514',
+    'tournament-claude-sonnet': 'claude-sonnet-4-20250514',
+    'tournament-gpt4o': 'gpt-4o',
+    'tournament-llama3': 'claude-sonnet-4-20250514' // Fallback for CLI compatibility
+  };
+  
+  return modelMap[agentId as keyof typeof modelMap] || 'claude-sonnet-4-20250514';
+}
+
+/**
+ * Creates a sample lead for testing.
+ */
+function createSampleLead(): Lead {
+  return {
+    email: 'sarah.chen@innovatetech.com',
+    company: 'InnovateTech Solutions',
+    companySize: 150,
+    role: 'VP of Engineering',
+    previousInteractions: ['Downloaded whitepaper', 'Attended webinar'],
+  };
+}
+
+/**
+ * Creates sample code review data for tournament testing.
+ */
+function createSampleCodeReview(): any {
+  return {
+    sourceCode: `
+// Vulnerable authentication function for code review
+function authenticateUser(username, password) {
+  const query = "SELECT * FROM users WHERE username = '" + username + "' AND password = '" + password + "'";
+  const result = db.query(query);
+  
+  if (result.length > 0) {
+    for (let i = 0; i < result.length; i++) {
+      const user = result[i];
+      const permissions = db.query("SELECT * FROM permissions WHERE user_id = " + user.id);
+      if (permissions.length > 0) {
+        return { success: true, user: user, permissions: permissions };
+      }
+    }
+  }
+  return { success: false };
+}
+    `,
+    requirements: [
+      'Identify CRITICAL security vulnerabilities (SQL injection, XSS)',
+      'Identify performance bottlenecks (N+1 queries)',
+      'Ensure all comments reference actual source lines (zero noise)',
+      'Suggest refactoring to reduce cyclomatic complexity by 2+ points'
+    ]
+  };
+}
+
+/**
+ * Creates sample lead generation challenge data for tournament testing.
+ */
+function createSampleLeadGenChallenge(): any {
+  return {
+    targetCriteria: {
+      emailFormat: 'Valid email format matching /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/',
+      companySize: 'Minimum 50 employees',
+      roleQualification: 'Not "intern" or "student" (case-insensitive)',
+      linkedInFormat: 'Must start with "https://www.linkedin.com/in/"'
+    },
+    requirements: [
+      'Generate valid email address',
+      'Verify company size >= 50 employees', 
+      'Ensure role is not intern/student',
+      'Provide valid LinkedIn URL format'
+    ]
+  };
+}
+
+/**
+ * Handler for the `outcome run` command.
+ *
+ * @param name - Outcome name to run
+ * @param options - Command options
+ *
+ * @see Requirements 7.1
+ */
+export async function runCommand(name: string, options: RunOptions): Promise<void> {
+  const agentCount = parseInt(options.agents, 10);
+  const globalSpendCeiling = parseInt(options.ceiling, 10);
+
+  console.log('\n🚀 Earnd Bounty Engine - League Run');
+  console.log('═'.repeat(50));
+  console.log(`📋 Outcome: ${name}`);
+  console.log(`👥 Agents: ${agentCount}`);
+  console.log(`💰 Global Ceiling: ${globalSpendCeiling.toLocaleString()} tokens`);
+  console.log(`🤖 Provider: ${options.provider}`);
+  console.log(`📦 Model: ${options.model}`);
+  console.log(`🧪 Mock Mode: ${options.mock ? 'Yes' : 'No'}`);
+  console.log('═'.repeat(50));
+
+  // Validate agent count
+  if (isNaN(agentCount) || agentCount < 1) {
+    console.error('❌ Error: Agent count must be a positive number');
+    process.exit(1);
+  }
+
+  // Get the outcome
+  let outcome;
+  if (name === 'qualified_sales_interest') {
+    outcome = qualifiedSalesInterest;
+  } else if (name === 'code_review_battle') {
+    outcome = codeReviewBattle;
+  } else if (name === 'lead_gen_battle') {
+    outcome = leadGenBattle;
+  } else if (CODE_DELIVERY_OUTCOMES[name]) {
+    outcome = CODE_DELIVERY_OUTCOMES[name];
+  } else {
+    console.error(`❌ Error: Unknown outcome "${name}"`);
+    console.error('Available outcomes: qualified_sales_interest, code_review_battle, lead_gen_battle, feature_implementation, refactor_task, test_generation');
+    process.exit(1);
+  }
+
+  // Create agent configurations
+  const agentConfigs: AgentConfig[] = [];
+  for (let i = 0; i < agentCount; i++) {
+    agentConfigs.push(createDefaultAgent(i, options.provider, options.model, name));
+  }
+
+  // Create sample data based on outcome type
+  let lead;
+  if (name === 'qualified_sales_interest') {
+    lead = createSampleLead();
+    console.log('\n📍 Lead Information:');
+    console.log(`   Email: ${lead.email}`);
+    console.log(`   Company: ${lead.company} (${lead.companySize} employees)`);
+    console.log(`   Role: ${lead.role}`);
+  } else if (name === 'code_review_battle') {
+    lead = createSampleCodeReview();
+    console.log('\n📍 Code Review Challenge:');
+    console.log(`   Target: Security vulnerabilities and performance bottlenecks`);
+    console.log(`   Requirements: CRITICAL security issues, performance bottlenecks, zero noise, complexity reduction`);
+  } else if (name === 'lead_gen_battle') {
+    lead = createSampleLeadGenChallenge();
+    console.log('\n📍 Lead Generation Challenge:');
+    console.log(`   Target: Generate qualified leads with precision validation`);
+    console.log(`   Requirements: Valid email, company size >= 50, qualified role, valid LinkedIn URL`);
+  } else {
+    lead = createSampleCodeArtifact();
+    console.log('\n📍 Code Delivery Challenge:');
+    console.log(`   Repo: ${lead.repoPath}`);
+    console.log(`   Test cmd: ${lead.testCommand}`);
+    console.log(`   Build cmd: ${lead.buildCommand}`);
+    console.log(`   Lint cmd: ${lead.lintCommand}`);
+    console.log(`   Benchmark cmd: ${lead.benchmarkCommand}`);
+  }
+  console.log('');
+
+  // Check for API key if not in mock mode
+  if (!options.mock) {
+    const apiKeyEnvVar = options.provider === 'claude' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY';
+    const apiKey = process.env[apiKeyEnvVar];
+
+    if (!apiKey) {
+      console.error(`❌ Error: ${apiKeyEnvVar} environment variable is required`);
+      console.error(`   Set it with: export ${apiKeyEnvVar}=your-api-key`);
+      console.error('   Or use --mock flag to run without real API calls');
+      process.exit(1);
+    }
+  }
+
+  // Build league configuration
+  const leagueConfig: LeagueConfig = {
+    outcomeId: name,
+    agentCount,
+    globalSpendCeiling,
+    agentConfigs,
+    outcome,
+    lead,
+    mockMode: options.mock,
+  };
+
+  console.log('🏃 Starting league run...\n');
+
+  try {
+    const startTime = Date.now();
+    const result = options.mock
+      ? await runLeagueMock(leagueConfig)
+      : await runLeague(leagueConfig);
+    const elapsed = Date.now() - startTime;
+
+    console.log('\n' + '═'.repeat(50));
+    console.log('📊 League Results');
+    console.log('═'.repeat(50));
+
+    if (result.winnerId) {
+      console.log(`\n🏆 Winner: ${result.winnerId}`);
+      console.log(`💵 Payout: $${outcome.payoutAmount}`);
+    } else {
+      console.log('\n❌ No winner - all agents failed');
+    }
+
+    console.log(`\n📈 Statistics:`);
+    console.log(`   Total Cost: ${result.totalCost.toLocaleString()} tokens`);
+    console.log(`   Duration: ${(elapsed / 1000).toFixed(2)}s`);
+    console.log(`   Global Ceiling Hit: ${result.globalCeilingHit ? 'Yes' : 'No'}`);
+
+    console.log(`\n👥 Agent Results:`);
+    for (const agent of result.agents) {
+      const statusIcon = agent.status === 'winner' ? '🏆' : agent.status === 'killed' ? '💀' : '❌';
+      console.log(`   ${statusIcon} ${agent.agentId}: ${agent.status}`);
+      console.log(`      Attempts: ${agent.attempts}, Tokens: ${agent.tokensSpent}`);
+      if (agent.killReason) {
+        console.log(`      Kill Reason: ${agent.killReason}`);
+      }
+    }
+
+    console.log('\n' + '═'.repeat(50));
+
+    // Exit with appropriate code
+    process.exit(result.winnerId ? 0 : 1);
+  } catch (error) {
+    console.error('\n❌ League run failed:', error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}

package/src/cli/commands/verify.ts

@@ -0,0 +1,110 @@
+/**
+ * Outcome Verify Command
+ *
+ * Verifies that a given artifact meets the success criteria for an outcome.
+ * Useful for testing outcomes and artifacts before running a full league.
+ */
+
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { evaluateOutcome } from '../../eval/evaluateOutcome.js';
+import { getOutcomeByName } from '../../outcomes/index.js';
+import { enrichCodeExecution } from '../../league/runLeague.js';
+import { CODE_DELIVERY_OUTCOMES } from '../../outcomes/code-delivery-outcomes.js';
+
+export function createVerifyCommand(): Command {
+  const verifyCmd = new Command('verify');
+
+  verifyCmd
+    .description('Verify an artifact against outcome success criteria')
+    .argument('<outcome>', 'Name of the outcome to verify against')
+    .argument('<artifact-file>', 'Path to JSON file containing the artifact')
+    .option('--execute-commands', 'Execute test/build/lint commands if present (default: false)', false)
+    .option('--json', 'Output results as JSON', false)
+    .action(async (outcomeName: string, artifactFile: string, options: { executeCommands?: boolean; json?: boolean }) => {
+      try {
+        // Load the outcome
+        const outcome = getOutcomeByName(outcomeName);
+        if (!outcome) {
+          console.error(`Error: Unknown outcome "${outcomeName}"`);
+          console.error('Use "outcome list" to see available outcomes');
+          process.exit(1);
+        }
+
+        // Load the artifact
+        const artifactPath = resolve(artifactFile);
+        const artifactData = JSON.parse(readFileSync(artifactPath, 'utf-8'));
+
+        // If it's a code outcome and execution is enabled, enrich with command results
+        let artifact = artifactData;
+        const isCodeOutcome = Boolean(CODE_DELIVERY_OUTCOMES[outcome.name]);
+        if (isCodeOutcome && options.executeCommands) {
+          console.log('Executing commands...');
+          artifact = await enrichCodeExecution(artifact);
+        }
+
+        // Evaluate the artifact
+        console.log(`Verifying artifact against "${outcomeName}"...`);
+        const result = await evaluateOutcome(outcome, artifact);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`\nVerification Result: ${result.status}`);
+          if (result.status === 'SUCCESS') {
+            console.log('✅ Artifact meets all success criteria');
+          } else {
+            console.log('❌ Artifact failed validation');
+            console.log(`Reason: ${result.reason}`);
+          }
+
+          if (result.criteriaResults && result.criteriaResults.length > 0) {
+            console.log('\nCriteria Results:');
+            result.criteriaResults.forEach((criteria, index) => {
+              const icon = criteria.passed ? '✅' : '❌';
+              console.log(`  ${index + 1}. ${icon} ${criteria.name}`);
+              if (!criteria.passed && criteria.errors.length > 0) {
+                criteria.errors.forEach(error => {
+                  console.log(`     ${error}`);
+                });
+              }
+            });
+          }
+
+          if (isCodeOutcome && options.executeCommands) {
+            console.log('\nCommand Execution Results:');
+            const content = artifact.content as any;
+            if (content.testResult) {
+              const test = content.testResult as any;
+              console.log(`  Tests: ${test.success ? '✅' : '❌'} (${test.passedTests}/${test.totalTests} passed)`);
+            }
+            if (content.buildResult) {
+              const build = content.buildResult as any;
+              console.log(`  Build: ${build.success ? '✅' : '❌'} (exit ${build.exitCode})`);
+            }
+            if (content.lintResult) {
+              const lint = content.lintResult as any;
+              console.log(`  Lint: ${lint.success ? '✅' : '❌'} (${lint.errorCount} errors, ${lint.warningCount} warnings)`);
+            }
+            if (content.benchmarkResult) {
+              const bench = content.benchmarkResult as any;
+              console.log(`  Benchmark: ${bench.success ? '✅' : '❌'} (${bench.totalBenchmarks} benchmarks)`);
+            }
+            if (content.securityScanResult) {
+              const sec = content.securityScanResult as any;
+              console.log(`  Security: ${sec.success ? '✅' : '❌'} (${sec.totalVulnerabilities} vulnerabilities)`);
+            }
+          }
+        }
+
+        process.exit(result.status === 'SUCCESS' ? 0 : 1);
+
+      } catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+      }
+    });
+
+  return verifyCmd;
+}

package/src/cli/index.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * CLI Entry Point - Command line interface for Earnd Bounty Engine
+ *
+ * Commands:
+ * - outcome run <name> --agents=N  - Start a league run with N agents
+ * - outcome logs <name>            - Display logs for an outcome
+ * - outcome payout <name> --agent=<id> - Trigger payout for winning agent
+ *
+ * @module cli
+ * @see Requirements 7.1, 7.2, 7.3, 7.4
+ */
+
+import { Command } from 'commander';
+import { runCommand } from './commands/run.js';
+import { logsCommand } from './commands/logs.js';
+import { payoutCommand } from './commands/payout.js';
+import { listCommand } from './commands/list.js';
+import { createVerifyCommand } from './commands/verify.js';
+import { createDefineCommand } from './commands/define.js';
+
+const program = new Command();
+
+program
+  .name('earnd')
+  .description('Earnd Bounty Engine - Outcome-based AI agent competition system')
+  .version('1.0.0');
+
+// Add the outcome command group
+const outcome = program
+  .command('outcome')
+  .description('Manage outcomes and run agent competitions');
+
+// outcome list
+outcome.addCommand(listCommand);
+
+// outcome verify
+outcome.addCommand(createVerifyCommand());
+
+// outcome define
+outcome.addCommand(createDefineCommand());
+
+// outcome run <name> --agents=N
+outcome
+  .command('run <name>')
+  .description('Start a league run with N agents competing for an outcome')
+  .option('-a, --agents <number>', 'Number of agents to run in parallel', '3')
+  .option('-c, --ceiling <number>', 'Global spend ceiling in tokens', '50000')
+  .option('--mock', 'Run in mock mode without real API calls', false)
+  .option('--provider <provider>', 'Model provider (claude or openai)', 'claude')
+  .option('--model <model>', 'Model ID to use', 'claude-sonnet-4-20250514')
+  .option('-m, --mode <mode>', 'Execution mode: league, swarm, or pipeline', 'league')
+  .option('-g, --goal <goal>', 'High-level goal for swarm and pipeline modes')
+  .option('-u, --target-url <url>', 'Target URL for OmniBridge extraction')
+  .option('--execute-commands', 'Execute test/build/lint commands for code outcomes (default: true)', true)
+  .option('--dry-run', 'Show execution plan without running', false)
+  .option('--json', 'Output results in JSON format', false)
+  .action(runCommand);
+
+// outcome logs <name>
+outcome
+  .command('logs <name>')
+  .description('Display all logs for the specified outcome')
+  .option('-a, --agent <id>', 'Filter logs by agent ID')
+  .option('--json', 'Output logs in JSON format', false)
+  .action(logsCommand);
+
+// outcome payout <name> --agent=<id>
+outcome
+  .command('payout <name>')
+  .description('Trigger payout for the winning agent')
+  .requiredOption('--agent <id>', 'Agent ID to trigger payout for')
+  .option('--method <method>', 'Payout method: auto, tremendous, or usdc', 'auto')
+  .option('--email <email>', 'Recipient email (for Tremendous payouts)')
+  .option('--wallet <address>', 'Recipient wallet address (for USDC payouts)')
+  .option('--name <name>', 'Recipient name')
+  .option('--dry-run', 'Show payout details without executing', false)
+  .action(payoutCommand);
+
+// Parse arguments
+program.parse();