outcome-cli 1.0.0

package/src/league/league.test.ts

@@ -0,0 +1,1151 @@
+/**
+ * League Module Tests
+ *
+ * Tests for parallel agent competition including:
+ * - League runner
+ * - Agent termination
+ * - Agent scoring
+ * - Property tests for requirements
+ *
+ * @module league/league.test
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as fc from 'fast-check';
+import {
+  runLeagueMock,
+  type LeagueConfig,
+  type LeagueResult,
+} from './runLeague.js';
+import {
+  shouldKillAgent,
+  type RunningAgent,
+  type AgentLimits,
+  type KillReason,
+} from './killAgent.js';
+import {
+  scoreAgent,
+  determineWinner,
+  rankAgents,
+  calculateLeagueStats,
+  type AgentScore,
+  type AgentMetrics,
+} from './scoreAgent.js';
+import type { AgentConfig } from '../agents/agent.schema.js';
+import type { Outcome } from '../outcomes/outcome.schema.js';
+import type { Lead } from '../jobs/job.interface.js';
+import type { EvaluationResult } from '../eval/evaluateOutcome.js';
+import { createCostTracker } from '../runtime/costTracker.js';
+import { clearAllLogs } from '../utils/logger.js';
+
+/**
+ * Test fixtures
+ */
+const createTestAgent = (id: string, overrides?: Partial<AgentConfig>): AgentConfig => ({
+  id,
+  name: `Test Agent ${id}`,
+  prompt: 'You are a test agent.',
+  strategyDescription: 'Test strategy',
+  toolAccess: [],
+  costCeiling: 10000,
+  modelProvider: 'claude',
+  modelId: 'claude-3-sonnet-20240229',
+  ...overrides,
+});
+
+const createTestOutcome = (overrides?: Partial<Outcome>): Outcome => ({
+  name: 'test_outcome',
+  description: 'Test outcome',
+  payoutAmount: 100,
+  maxAttempts: 3,
+  timeLimitMs: 60000,
+  successCriteria: [
+    {
+      name: 'message_length',
+      validator: 'validateMessageLength',
+      params: { minWords: 5 },
+    },
+  ],
+  failureReasons: ['Test failure'],
+  ...overrides,
+});
+
+const createTestLead = (overrides?: Partial<Lead>): Lead => ({
+  email: 'test@example.com',
+  company: 'Test Corp',
+  companySize: 100,
+  role: 'Manager',
+  previousInteractions: [],
+  ...overrides,
+});
+
+describe('runLeagueMock', () => {
+  beforeEach(() => {
+    clearAllLogs();
+  });
+
+  it('should run league with specified number of agents', async () => {
+    const agentCount = 3;
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount,
+      globalSpendCeiling: 50000,
+      agentConfigs: [
+        createTestAgent('agent-1'),
+        createTestAgent('agent-2'),
+        createTestAgent('agent-3'),
+      ],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    const result = await runLeagueMock(config);
+
+    expect(result.agents).toHaveLength(agentCount);
+    expect(result.duration).toBeGreaterThan(0);
+    expect(result.totalCost).toBeGreaterThan(0);
+  });
+
+  it('should track total cost across all agents', async () => {
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount: 2,
+      globalSpendCeiling: 50000,
+      agentConfigs: [createTestAgent('agent-1'), createTestAgent('agent-2')],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    const result = await runLeagueMock(config);
+
+    const sumOfAgentCosts = result.agents.reduce((sum, a) => sum + a.tokensSpent, 0);
+    expect(result.totalCost).toBe(sumOfAgentCosts);
+  });
+
+  it('should throw error for invalid agent count', async () => {
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount: 0,
+      globalSpendCeiling: 50000,
+      agentConfigs: [],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    await expect(runLeagueMock(config)).rejects.toThrow('Agent count must be positive');
+  });
+
+  it('should throw error for insufficient agent configs', async () => {
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount: 3,
+      globalSpendCeiling: 50000,
+      agentConfigs: [createTestAgent('agent-1')], // Only 1 config for 3 agents
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    await expect(runLeagueMock(config)).rejects.toThrow('Not enough agent configs');
+  });
+});
+
+describe('shouldKillAgent', () => {
+  const createRunningAgent = (overrides?: Partial<RunningAgent>): RunningAgent => ({
+    agentId: 'test-agent',
+    attempts: 0,
+    costTracker: createCostTracker('test-agent', 10000),
+    startTime: Date.now(),
+    competitorWon: false,
+    ...overrides,
+  });
+
+  const defaultLimits: AgentLimits = {
+    maxTokens: 10000,
+    maxAttempts: 5,
+    maxRuntimeMs: 60000,
+  };
+
+  it('should return null for agent within limits', () => {
+    const agent = createRunningAgent();
+    const result = shouldKillAgent(agent, defaultLimits);
+    expect(result).toBeNull();
+  });
+
+  it('should return competitor_won when competitor has won', () => {
+    const agent = createRunningAgent({ competitorWon: true });
+    const result = shouldKillAgent(agent, defaultLimits);
+
+    expect(result).not.toBeNull();
+    expect(result?.type).toBe('competitor_won');
+  });
+
+  it('should return cost_exceeded when over token limit', () => {
+    const costTracker = createCostTracker('test-agent', 10000);
+    costTracker.tokensSpent = 15000; // Over limit
+    const agent = createRunningAgent({ costTracker });
+
+    const result = shouldKillAgent(agent, defaultLimits);
+
+    expect(result).not.toBeNull();
+    expect(result?.type).toBe('cost_exceeded');
+  });
+
+  it('should return attempts_exceeded when at max attempts', () => {
+    const agent = createRunningAgent({ attempts: 5 });
+    const result = shouldKillAgent(agent, defaultLimits);
+
+    expect(result).not.toBeNull();
+    expect(result?.type).toBe('attempts_exceeded');
+  });
+
+  it('should return timeout when over runtime limit', () => {
+    const agent = createRunningAgent({
+      startTime: Date.now() - 70000, // 70 seconds ago
+    });
+    const result = shouldKillAgent(agent, defaultLimits);
+
+    expect(result).not.toBeNull();
+    expect(result?.type).toBe('timeout');
+  });
+});
+
+describe('scoreAgent', () => {
+  it('should create score from successful evaluation', () => {
+    const evalResult: EvaluationResult = {
+      status: 'SUCCESS',
+      reason: 'All criteria passed',
+      criteriaResults: [],
+    };
+    const metrics: AgentMetrics = {
+      agentId: 'agent-1',
+      tokensSpent: 500,
+      attempts: 2,
+      durationMs: 5000,
+    };
+
+    const score = scoreAgent(evalResult, metrics);
+
+    expect(score.agentId).toBe('agent-1');
+    expect(score.success).toBe(true);
+    expect(score.cost).toBe(500);
+    expect(score.attempts).toBe(2);
+    expect(score.duration).toBe(5000);
+    expect(score.successTimestamp).toBeDefined();
+  });
+
+  it('should create score from failed evaluation', () => {
+    const evalResult: EvaluationResult = {
+      status: 'FAILURE',
+      reason: 'Company too small',
+      criteriaResults: [],
+    };
+    const metrics: AgentMetrics = {
+      agentId: 'agent-2',
+      tokensSpent: 300,
+      attempts: 1,
+      durationMs: 3000,
+    };
+
+    const score = scoreAgent(evalResult, metrics);
+
+    expect(score.success).toBe(false);
+    expect(score.successTimestamp).toBeUndefined();
+  });
+});
+
+describe('determineWinner', () => {
+  it('should return null for empty scores', () => {
+    expect(determineWinner([])).toBeNull();
+  });
+
+  it('should return null when no successful agents', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'a1', success: false, cost: 100, attempts: 1, duration: 1000 },
+      { agentId: 'a2', success: false, cost: 200, attempts: 2, duration: 2000 },
+    ];
+
+    expect(determineWinner(scores)).toBeNull();
+  });
+
+  it('should return the successful agent', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'a1', success: false, cost: 100, attempts: 1, duration: 1000 },
+      { agentId: 'a2', success: true, cost: 200, attempts: 2, duration: 2000, successTimestamp: 1000 },
+    ];
+
+    const winner = determineWinner(scores);
+    expect(winner?.agentId).toBe('a2');
+  });
+
+  it('should return earliest successful agent when multiple succeed', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'a1', success: true, cost: 100, attempts: 1, duration: 1000, successTimestamp: 2000 },
+      { agentId: 'a2', success: true, cost: 200, attempts: 2, duration: 2000, successTimestamp: 1000 },
+    ];
+
+    const winner = determineWinner(scores);
+    expect(winner?.agentId).toBe('a2'); // Earlier timestamp
+  });
+});
+
+describe('rankAgents', () => {
+  it('should rank successful agents before failed', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'failed', success: false, cost: 50, attempts: 1, duration: 500 },
+      { agentId: 'success', success: true, cost: 100, attempts: 2, duration: 1000, successTimestamp: 1000 },
+    ];
+
+    const ranked = rankAgents(scores);
+    expect(ranked[0].agentId).toBe('success');
+    expect(ranked[1].agentId).toBe('failed');
+  });
+
+  it('should rank by timestamp for successful agents', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'later', success: true, cost: 100, attempts: 1, duration: 1000, successTimestamp: 2000 },
+      { agentId: 'earlier', success: true, cost: 100, attempts: 1, duration: 1000, successTimestamp: 1000 },
+    ];
+
+    const ranked = rankAgents(scores);
+    expect(ranked[0].agentId).toBe('earlier');
+  });
+
+  it('should rank failed agents by attempts then cost', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'a3', success: false, cost: 100, attempts: 3, duration: 1000 },
+      { agentId: 'a1', success: false, cost: 200, attempts: 1, duration: 1000 },
+      { agentId: 'a2', success: false, cost: 100, attempts: 1, duration: 1000 },
+    ];
+
+    const ranked = rankAgents(scores);
+    expect(ranked[0].agentId).toBe('a2'); // 1 attempt, 100 cost
+    expect(ranked[1].agentId).toBe('a1'); // 1 attempt, 200 cost
+    expect(ranked[2].agentId).toBe('a3'); // 3 attempts
+  });
+});
+
+describe('calculateLeagueStats', () => {
+  it('should calculate stats correctly', () => {
+    const scores: AgentScore[] = [
+      { agentId: 'a1', success: true, cost: 100, attempts: 2, duration: 1000, successTimestamp: 1000 },
+      { agentId: 'a2', success: false, cost: 200, attempts: 3, duration: 2000 },
+      { agentId: 'a3', success: true, cost: 150, attempts: 1, duration: 1500, successTimestamp: 1500 },
+    ];
+
+    const stats = calculateLeagueStats(scores);
+
+    expect(stats.totalAgents).toBe(3);
+    expect(stats.successfulAgents).toBe(2);
+    expect(stats.failedAgents).toBe(1);
+    expect(stats.totalCost).toBe(450);
+    expect(stats.averageCost).toBe(150);
+    expect(stats.totalAttempts).toBe(6);
+    expect(stats.averageAttempts).toBe(2);
+  });
+
+  it('should handle empty scores', () => {
+    const stats = calculateLeagueStats([]);
+
+    expect(stats.totalAgents).toBe(0);
+    expect(stats.averageCost).toBe(0);
+    expect(stats.averageAttempts).toBe(0);
+  });
+});
+
+describe('League Property Tests', () => {
+  beforeEach(() => {
+    clearAllLogs();
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 5: League Agent Count**
+   * For any league configuration with agentCount N, starting the league
+   * SHALL instantiate exactly N agents.
+   * **Validates: Requirements 4.1**
+   */
+  it('Property 5: League Agent Count', async () => {
+    // Test with various agent counts
+    for (const agentCount of [1, 2, 3, 5]) {
+      clearAllLogs();
+
+      const agentConfigs = Array.from({ length: agentCount }, (_, i) =>
+        createTestAgent(`agent-${i}`)
+      );
+
+      const config: LeagueConfig = {
+        outcomeId: 'test_outcome',
+        agentCount,
+        globalSpendCeiling: 100000,
+        agentConfigs,
+        outcome: createTestOutcome(),
+        lead: createTestLead(),
+        mockMode: true,
+      };
+
+      const result = await runLeagueMock(config);
+
+      expect(result.agents).toHaveLength(agentCount);
+    }
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 9: Winner Promotion**
+   * For any agent that achieves SUCCESS evaluation, the league SHALL mark
+   * that agent as winner and signal termination to all other agents.
+   * **Validates: Requirements 4.5**
+   */
+  it('Property 9: Winner Promotion', async () => {
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount: 3,
+      globalSpendCeiling: 100000,
+      agentConfigs: [
+        createTestAgent('agent-1'),
+        createTestAgent('agent-2'),
+        createTestAgent('agent-3'),
+      ],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    const result = await runLeagueMock(config);
+
+    // In mock mode, agents should complete and be evaluated
+    // At most one winner should exist
+    const winners = result.agents.filter((a) => a.status === 'winner');
+    expect(winners.length).toBeLessThanOrEqual(1);
+
+    // If there's a winner, winnerId should match
+    if (winners.length === 1) {
+      expect(result.winnerId).toBe(winners[0].agentId);
+    }
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 21: Global Spend Ceiling**
+   * For any league run where total spend exceeds the global ceiling,
+   * the league SHALL halt all agents and return with no winner.
+   * **Validates: Requirements 10.3**
+   */
+  it('Property 21: Global Spend Ceiling tracking', async () => {
+    const globalSpendCeiling = 50000;
+
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount: 3,
+      globalSpendCeiling,
+      agentConfigs: [
+        createTestAgent('agent-1'),
+        createTestAgent('agent-2'),
+        createTestAgent('agent-3'),
+      ],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    const result = await runLeagueMock(config);
+
+    // Total cost should be tracked
+    expect(result.totalCost).toBeGreaterThan(0);
+
+    // globalCeilingHit should be true if ceiling was exceeded
+    if (result.totalCost >= globalSpendCeiling) {
+      expect(result.globalCeilingHit).toBe(true);
+    }
+  });
+
+  /**
+   * Property: Cost tracking isolation
+   * Each agent's cost should be tracked independently.
+   */
+  it('Property: Cost tracking isolation', async () => {
+    const config: LeagueConfig = {
+      outcomeId: 'test_outcome',
+      agentCount: 3,
+      globalSpendCeiling: 100000,
+      agentConfigs: [
+        createTestAgent('agent-1'),
+        createTestAgent('agent-2'),
+        createTestAgent('agent-3'),
+      ],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    const result = await runLeagueMock(config);
+
+    // Each agent should have independent cost tracking
+    for (const agent of result.agents) {
+      expect(agent.tokensSpent).toBeGreaterThanOrEqual(0);
+    }
+
+    // Sum should equal total
+    const sum = result.agents.reduce((s, a) => s + a.tokensSpent, 0);
+    expect(result.totalCost).toBe(sum);
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 7: Attempt Limit Termination**
+   * For any agent that exceeds the maxAttempts limit, the league SHALL
+   * terminate that agent with reason 'attempts_exceeded'.
+   * **Validates: Requirements 4.3**
+   */
+  it('Property 7: Attempt Limit Termination', () => {
+    const limits: AgentLimits = {
+      maxTokens: 10000,
+      maxAttempts: 3,
+      maxRuntimeMs: 60000,
+    };
+
+    // Agent at max attempts should be killed
+    const agent: RunningAgent = {
+      agentId: 'test-agent',
+      attempts: 3,
+      costTracker: createCostTracker('test-agent', 10000),
+      startTime: Date.now(),
+      competitorWon: false,
+    };
+
+    const reason = shouldKillAgent(agent, limits);
+    expect(reason).not.toBeNull();
+    expect(reason?.type).toBe('attempts_exceeded');
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 8: Cost Ceiling Termination**
+   * For any agent that exceeds its cost ceiling, the league SHALL
+   * terminate that agent with reason 'cost_exceeded'.
+   * **Validates: Requirements 4.4, 10.1**
+   */
+  it('Property 8: Cost Ceiling Termination', () => {
+    const limits: AgentLimits = {
+      maxTokens: 10000,
+      maxAttempts: 5,
+      maxRuntimeMs: 60000,
+    };
+
+    // Agent over cost should be killed
+    const costTracker = createCostTracker('test-agent', 10000);
+    costTracker.tokensSpent = 15000; // Over limit
+
+    const agent: RunningAgent = {
+      agentId: 'test-agent',
+      attempts: 1,
+      costTracker,
+      startTime: Date.now(),
+      competitorWon: false,
+    };
+
+    const reason = shouldKillAgent(agent, limits);
+    expect(reason).not.toBeNull();
+    expect(reason?.type).toBe('cost_exceeded');
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 20: Runtime Limit Termination**
+   * For any agent that exceeds the max runtime limit, the league SHALL
+   * terminate that agent with reason 'timeout'.
+   * **Validates: Requirements 10.2**
+   */
+  it('Property 20: Runtime Limit Termination', () => {
+    const limits: AgentLimits = {
+      maxTokens: 10000,
+      maxAttempts: 5,
+      maxRuntimeMs: 30000, // 30 seconds
+    };
+
+    // Agent over runtime should be killed
+    const agent: RunningAgent = {
+      agentId: 'test-agent',
+      attempts: 1,
+      costTracker: createCostTracker('test-agent', 10000),
+      startTime: Date.now() - 35000, // 35 seconds ago
+      competitorWon: false,
+    };
+
+    const reason = shouldKillAgent(agent, limits);
+    expect(reason).not.toBeNull();
+    expect(reason?.type).toBe('timeout');
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 22: Fail-Closed on Limit Exceeded**
+   * For any agent termination due to cost, attempt, or time limits,
+   * no payout SHALL be triggered for that agent.
+   * **Validates: Requirements 10.4**
+   */
+  it('Property 22: Fail-Closed on Limit Exceeded', () => {
+    const limits: AgentLimits = {
+      maxTokens: 10000,
+      maxAttempts: 5,
+      maxRuntimeMs: 60000,
+    };
+
+    // Test all limit types result in non-recoverable termination
+    const testCases = [
+      { attempts: 5, tokensSpent: 100, elapsed: 0, expectedType: 'attempts_exceeded' },
+      { attempts: 1, tokensSpent: 15000, elapsed: 0, expectedType: 'cost_exceeded' },
+      { attempts: 1, tokensSpent: 100, elapsed: 70000, expectedType: 'timeout' },
+    ];
+
+    for (const tc of testCases) {
+      const costTracker = createCostTracker('test-agent', 10000);
+      costTracker.tokensSpent = tc.tokensSpent;
+
+      const agent: RunningAgent = {
+        agentId: 'test-agent',
+        attempts: tc.attempts,
+        costTracker,
+        startTime: Date.now() - tc.elapsed,
+        competitorWon: false,
+      };
+
+      const reason = shouldKillAgent(agent, limits);
+      expect(reason).not.toBeNull();
+      expect(reason?.type).toBe(tc.expectedType);
+
+      // All limit-based kills mean no payout - verify by checking type is a limit type
+      const limitTypes = ['cost_exceeded', 'attempts_exceeded', 'timeout'];
+      expect(limitTypes).toContain(reason?.type);
+    }
+  });
+});
+
+/**
+ * Property-based tests for Tournament System Determinism
+ *
+ * **Feature: launch-readiness-checklist, Property 3: Tournament system determinism**
+ * **Validates: Requirements 1.5**
+ *
+ * Property 3: Tournament system determinism
+ * *For any* identical tournament input (same agents, same outcome, same data),
+ * running the tournament multiple times SHALL produce identical results.
+ */
+
+describe('Tournament System Determinism - Property Tests', () => {
+  beforeEach(() => {
+    clearAllLogs();
+  });
+
+  // **Feature: launch-readiness-checklist, Property 3: Tournament system determinism**
+  test('identical tournament inputs produce identical results', async () => {
+    // Create a deterministic tournament configuration
+    const createDeterministicConfig = (): LeagueConfig => ({
+      outcomeId: 'test_outcome',
+      agentCount: 3,
+      globalSpendCeiling: 50000,
+      agentConfigs: [
+        createTestAgent('agent-1', { costCeiling: 10000 }),
+        createTestAgent('agent-2', { costCeiling: 15000 }),
+        createTestAgent('agent-3', { costCeiling: 12000 }),
+      ],
+      outcome: createTestOutcome({ 
+        payoutAmount: 250,
+        maxAttempts: 5,
+        timeLimitMs: 30000,
+      }),
+      lead: createTestLead({
+        email: 'test@example.com',
+        company: 'Test Corp',
+        companySize: 100,
+        role: 'Manager',
+      }),
+      mockMode: true, // Use mock mode for deterministic behavior
+    });
+
+    // Run the same tournament configuration multiple times
+    const config1 = createDeterministicConfig();
+    const config2 = createDeterministicConfig();
+    const config3 = createDeterministicConfig();
+
+    const result1 = await runLeagueMock(config1);
+    const result2 = await runLeagueMock(config2);
+    const result3 = await runLeagueMock(config3);
+
+    // All results must have identical structure
+    expect(result1.agents).toHaveLength(result2.agents.length);
+    expect(result2.agents).toHaveLength(result3.agents.length);
+
+    // All results must have identical winner (or lack thereof)
+    expect(result1.winnerId).toBe(result2.winnerId);
+    expect(result2.winnerId).toBe(result3.winnerId);
+
+    // All results must have identical global ceiling hit status
+    expect(result1.globalCeilingHit).toBe(result2.globalCeilingHit);
+    expect(result2.globalCeilingHit).toBe(result3.globalCeilingHit);
+
+    // Tournament metrics must be identical
+    expect(result1.tournamentMetrics.netProfitability).toBe(result2.tournamentMetrics.netProfitability);
+    expect(result2.tournamentMetrics.netProfitability).toBe(result3.tournamentMetrics.netProfitability);
+    
+    expect(result1.tournamentMetrics.costPerSuccess).toBe(result2.tournamentMetrics.costPerSuccess);
+    expect(result2.tournamentMetrics.costPerSuccess).toBe(result3.tournamentMetrics.costPerSuccess);
+    
+    expect(result1.tournamentMetrics.successCount).toBe(result2.tournamentMetrics.successCount);
+    expect(result2.tournamentMetrics.successCount).toBe(result3.tournamentMetrics.successCount);
+
+    // Agent results must have identical structure and status
+    for (let i = 0; i < result1.agents.length; i++) {
+      const agent1 = result1.agents[i];
+      const agent2 = result2.agents[i];
+      const agent3 = result3.agents[i];
+
+      expect(agent1.agentId).toBe(agent2.agentId);
+      expect(agent2.agentId).toBe(agent3.agentId);
+
+      expect(agent1.status).toBe(agent2.status);
+      expect(agent2.status).toBe(agent3.status);
+
+      expect(agent1.attempts).toBe(agent2.attempts);
+      expect(agent2.attempts).toBe(agent3.attempts);
+
+      // In mock mode, token costs should be deterministic
+      expect(agent1.tokensSpent).toBe(agent2.tokensSpent);
+      expect(agent2.tokensSpent).toBe(agent3.tokensSpent);
+    }
+  });
+
+  // **Feature: launch-readiness-checklist, Property 3: Tournament system determinism**
+  test('tournament results are deterministic across different agent configurations', async () => {
+    // Test with a few specific configurations to avoid timeout
+    const testConfigurations = [
+      { agentCount: 1, globalSpendCeiling: 10000, payoutAmount: 50, maxAttempts: 1 },
+      { agentCount: 2, globalSpendCeiling: 50000, payoutAmount: 250, maxAttempts: 3 },
+      { agentCount: 3, globalSpendCeiling: 30000, payoutAmount: 100, maxAttempts: 2 },
+    ];
+
+    for (const config of testConfigurations) {
+      // Create identical configurations
+      const agentConfigs = Array.from({ length: config.agentCount }, (_, i) =>
+        createTestAgent(`agent-${i}`, { costCeiling: 10000 })
+      );
+
+      const baseConfig: LeagueConfig = {
+        outcomeId: 'determinism_test',
+        agentCount: config.agentCount,
+        globalSpendCeiling: config.globalSpendCeiling,
+        agentConfigs,
+        outcome: createTestOutcome({
+          payoutAmount: config.payoutAmount,
+          maxAttempts: config.maxAttempts,
+          timeLimitMs: 60000,
+        }),
+        lead: createTestLead(),
+        mockMode: true,
+      };
+
+      // Run tournament twice with identical inputs
+      const result1 = await runLeagueMock({ ...baseConfig });
+      const result2 = await runLeagueMock({ ...baseConfig });
+
+      // Results must be identical
+      expect(result1.winnerId).toBe(result2.winnerId);
+      expect(result1.agents.length).toBe(result2.agents.length);
+      expect(result1.globalCeilingHit).toBe(result2.globalCeilingHit);
+      
+      // Tournament metrics must be identical
+      expect(result1.tournamentMetrics.netProfitability).toBe(result2.tournamentMetrics.netProfitability);
+      expect(result1.tournamentMetrics.costPerSuccess).toBe(result2.tournamentMetrics.costPerSuccess);
+      expect(result1.tournamentMetrics.successCount).toBe(result2.tournamentMetrics.successCount);
+
+      // Agent results must be identical
+      for (let i = 0; i < result1.agents.length; i++) {
+        expect(result1.agents[i].status).toBe(result2.agents[i].status);
+        expect(result1.agents[i].attempts).toBe(result2.agents[i].attempts);
+        expect(result1.agents[i].tokensSpent).toBe(result2.agents[i].tokensSpent);
+      }
+    }
+  }, 10000); // Increase timeout to 10 seconds
+
+  // **Feature: launch-readiness-checklist, Property 3: Tournament system determinism**
+  test('tournament system produces consistent results structure', async () => {
+    const config: LeagueConfig = {
+      outcomeId: 'structure_test',
+      agentCount: 2,
+      globalSpendCeiling: 30000,
+      agentConfigs: [
+        createTestAgent('agent-1'),
+        createTestAgent('agent-2'),
+      ],
+      outcome: createTestOutcome(),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    // Run tournament multiple times
+    const results = await Promise.all([
+      runLeagueMock(config),
+      runLeagueMock(config),
+      runLeagueMock(config),
+    ]);
+
+    // All results must have consistent structure
+    for (const result of results) {
+      // Required fields must exist
+      expect(typeof result.winnerId).toBe('string' || result.winnerId === null);
+      expect(Array.isArray(result.agents)).toBe(true);
+      expect(typeof result.totalCost).toBe('number');
+      expect(typeof result.duration).toBe('number');
+      expect(typeof result.globalCeilingHit).toBe('boolean');
+      expect(typeof result.tournamentMetrics).toBe('object');
+
+      // Tournament metrics structure
+      expect(typeof result.tournamentMetrics.netProfitability).toBe('number');
+      expect(typeof result.tournamentMetrics.costPerSuccess).toBe('number');
+      expect(typeof result.tournamentMetrics.successCount).toBe('number');
+
+      // Agent results structure
+      for (const agent of result.agents) {
+        expect(typeof agent.agentId).toBe('string');
+        expect(['winner', 'killed', 'failed']).toContain(agent.status);
+        expect(typeof agent.attempts).toBe('number');
+        expect(typeof agent.tokensSpent).toBe('number');
+        expect(typeof agent.durationMs).toBe('number');
+        expect(agent.attempts).toBeGreaterThan(0);
+        expect(agent.tokensSpent).toBeGreaterThanOrEqual(0);
+        expect(agent.durationMs).toBeGreaterThan(0);
+      }
+    }
+
+    // All results must have identical structure
+    expect(results[0].agents.length).toBe(results[1].agents.length);
+    expect(results[1].agents.length).toBe(results[2].agents.length);
+  });
+
+  // **Feature: launch-readiness-checklist, Property 3: Tournament system determinism**
+  test('tournament determinism holds with different lead data', async () => {
+    // Test with a few specific lead data configurations
+    const leadConfigurations = [
+      { email: 'test@example.com', company: 'Test Corp', companySize: 100, role: 'Manager' },
+      { email: 'user@company.com', company: 'Big Company', companySize: 500, role: 'Director' },
+      { email: 'contact@startup.io', company: 'Startup Inc', companySize: 50, role: 'CEO' },
+    ];
+
+    for (const leadData of leadConfigurations) {
+      const config: LeagueConfig = {
+        outcomeId: 'lead_determinism_test',
+        agentCount: 2,
+        globalSpendCeiling: 40000,
+        agentConfigs: [
+          createTestAgent('agent-1'),
+          createTestAgent('agent-2'),
+        ],
+        outcome: createTestOutcome(),
+        lead: createTestLead(leadData),
+        mockMode: true,
+      };
+
+      // Run tournament twice with identical lead data
+      const result1 = await runLeagueMock(config);
+      const result2 = await runLeagueMock(config);
+
+      // Results must be deterministic regardless of lead data
+      expect(result1.winnerId).toBe(result2.winnerId);
+      expect(result1.agents.length).toBe(result2.agents.length);
+      expect(result1.tournamentMetrics.netProfitability).toBe(result2.tournamentMetrics.netProfitability);
+      expect(result1.tournamentMetrics.costPerSuccess).toBe(result2.tournamentMetrics.costPerSuccess);
+      expect(result1.tournamentMetrics.successCount).toBe(result2.tournamentMetrics.successCount);
+    }
+  });
+
+  // **Feature: launch-readiness-checklist, Property 3: Tournament system determinism**
+  test('tournament system maintains determinism under resource constraints', async () => {
+    // Test with very low global spend ceiling to trigger constraint behavior
+    const constrainedConfig: LeagueConfig = {
+      outcomeId: 'constraint_test',
+      agentCount: 3,
+      globalSpendCeiling: 1000, // Very low ceiling
+      agentConfigs: [
+        createTestAgent('agent-1', { costCeiling: 500 }),
+        createTestAgent('agent-2', { costCeiling: 600 }),
+        createTestAgent('agent-3', { costCeiling: 400 }),
+      ],
+      outcome: createTestOutcome({ maxAttempts: 2 }),
+      lead: createTestLead(),
+      mockMode: true,
+    };
+
+    // Run multiple times
+    const result1 = await runLeagueMock(constrainedConfig);
+    const result2 = await runLeagueMock(constrainedConfig);
+    const result3 = await runLeagueMock(constrainedConfig);
+
+    // Even under constraints, results must be deterministic
+    expect(result1.globalCeilingHit).toBe(result2.globalCeilingHit);
+    expect(result2.globalCeilingHit).toBe(result3.globalCeilingHit);
+
+    expect(result1.winnerId).toBe(result2.winnerId);
+    expect(result2.winnerId).toBe(result3.winnerId);
+
+    expect(result1.tournamentMetrics.successCount).toBe(result2.tournamentMetrics.successCount);
+    expect(result2.tournamentMetrics.successCount).toBe(result3.tournamentMetrics.successCount);
+
+    // Agent statuses must be consistent
+    for (let i = 0; i < result1.agents.length; i++) {
+      expect(result1.agents[i].status).toBe(result2.agents[i].status);
+      expect(result2.agents[i].status).toBe(result3.agents[i].status);
+    }
+  });
+});
+
+/**
+ * Property-based tests for Tournament Metrics Calculation
+ *
+ * **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+ * **Validates: Requirements 1.2**
+ *
+ * Property 2: Tournament metrics calculation accuracy
+ * *For any* tournament with payout amount, total cost, and success count,
+ * the tournament metrics SHALL calculate NetProfitability as (payout - cost) / cost
+ * and CostPerSuccess as totalSpend / successCount.
+ */
+
+import { calculateTournamentMetrics } from './runLeague.js';
+
+describe('Tournament Metrics Calculation - Property Tests', () => {
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('net profitability calculation is correct for positive costs', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 1, max: 10000, noNaN: true }), // totalCost
+        fc.integer({ min: 1, max: 100 }), // successCount
+        (payoutAmount, totalCost, successCount) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          
+          // Net profitability should be (payout - cost) / cost
+          const expectedNetProfitability = (payoutAmount - totalCost) / totalCost;
+          expect(metrics.netProfitability).toBeCloseTo(expectedNetProfitability, 10);
+          
+          // Success count should be preserved
+          expect(metrics.successCount).toBe(successCount);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('cost per success calculation is correct for positive success count', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 1, max: 10000, noNaN: true }), // totalCost
+        fc.integer({ min: 1, max: 100 }), // successCount
+        (payoutAmount, totalCost, successCount) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          
+          // Cost per success should be totalCost / successCount
+          const expectedCostPerSuccess = totalCost / successCount;
+          expect(metrics.costPerSuccess).toBeCloseTo(expectedCostPerSuccess, 10);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('zero cost edge case returns zero profitability', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 10000 }), // payoutAmount
+        fc.integer({ min: 0, max: 100 }), // successCount
+        (payoutAmount, successCount) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, 0, successCount);
+          
+          // Zero cost should result in zero profitability (edge case handling)
+          expect(metrics.netProfitability).toBe(0);
+          
+          // Cost per success should be 0 / successCount = 0 (if successCount > 0) or Infinity (if successCount = 0)
+          if (successCount === 0) {
+            expect(metrics.costPerSuccess).toBe(Infinity);
+          } else {
+            expect(metrics.costPerSuccess).toBe(0);
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('zero success count edge case returns infinity cost per success', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 1, max: 10000, noNaN: true }), // totalCost
+        (payoutAmount, totalCost) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, totalCost, 0);
+          
+          // Zero successes should result in Infinity cost per success
+          expect(metrics.costPerSuccess).toBe(Infinity);
+          expect(metrics.successCount).toBe(0);
+          
+          // Net profitability should still be calculated normally
+          const expectedNetProfitability = (payoutAmount - totalCost) / totalCost;
+          expect(metrics.netProfitability).toBeCloseTo(expectedNetProfitability, 10);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('profitability is positive when payout exceeds cost', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 100, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 1, max: 99, noNaN: true }), // totalCost (less than payout)
+        fc.integer({ min: 1, max: 100 }), // successCount
+        (payoutAmount, totalCost, successCount) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          
+          // When payout > cost, profitability should be positive
+          expect(metrics.netProfitability).toBeGreaterThan(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('profitability is negative when cost exceeds payout', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 99, noNaN: true }), // payoutAmount
+        fc.float({ min: 100, max: 10000, noNaN: true }), // totalCost (greater than payout)
+        fc.integer({ min: 1, max: 100 }), // successCount
+        (payoutAmount, totalCost, successCount) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          
+          // When cost > payout, profitability should be negative
+          expect(metrics.netProfitability).toBeLessThan(0);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('calculation is deterministic - same input produces same output', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 0, max: 10000 }), // payoutAmount
+        fc.float({ min: 0, max: 10000 }), // totalCost
+        fc.integer({ min: 0, max: 100 }), // successCount
+        (payoutAmount, totalCost, successCount) => {
+          const metrics1 = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          const metrics2 = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          
+          expect(metrics1.netProfitability).toBe(metrics2.netProfitability);
+          expect(metrics1.costPerSuccess).toBe(metrics2.costPerSuccess);
+          expect(metrics1.successCount).toBe(metrics2.successCount);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('metrics structure is correct', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 0, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 0, max: 10000, noNaN: true }), // totalCost
+        fc.integer({ min: 0, max: 100 }), // successCount
+        (payoutAmount, totalCost, successCount) => {
+          const metrics = calculateTournamentMetrics(payoutAmount, totalCost, successCount);
+          
+          // Metrics must have correct structure
+          expect(typeof metrics.netProfitability).toBe('number');
+          expect(typeof metrics.costPerSuccess).toBe('number');
+          expect(typeof metrics.successCount).toBe('number');
+          expect(metrics.successCount).toBe(successCount);
+          
+          // Values should be finite or Infinity (for zero success case)
+          expect(Number.isFinite(metrics.netProfitability) || metrics.netProfitability === 0).toBe(true);
+          expect(Number.isFinite(metrics.costPerSuccess) || metrics.costPerSuccess === Infinity).toBe(true);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('boundary values are handled correctly', () => {
+    // Test specific boundary cases
+    const boundaryTests = [
+      { payout: 0, cost: 0, success: 0, expectedProfit: 0, expectedCostPerSuccess: Infinity },
+      { payout: 0, cost: 0, success: 1, expectedProfit: 0, expectedCostPerSuccess: 0 },
+      { payout: 100, cost: 0, success: 1, expectedProfit: 0, expectedCostPerSuccess: 0 },
+      { payout: 100, cost: 100, success: 1, expectedProfit: 0, expectedCostPerSuccess: 100 },
+      { payout: 200, cost: 100, success: 1, expectedProfit: 1, expectedCostPerSuccess: 100 },
+      { payout: 50, cost: 100, success: 1, expectedProfit: -0.5, expectedCostPerSuccess: 100 },
+    ];
+
+    for (const test of boundaryTests) {
+      const metrics = calculateTournamentMetrics(test.payout, test.cost, test.success);
+      
+      if (Number.isFinite(test.expectedProfit)) {
+        expect(metrics.netProfitability).toBeCloseTo(test.expectedProfit, 10);
+      } else {
+        expect(metrics.netProfitability).toBe(test.expectedProfit);
+      }
+      
+      if (Number.isFinite(test.expectedCostPerSuccess)) {
+        expect(metrics.costPerSuccess).toBeCloseTo(test.expectedCostPerSuccess, 10);
+      } else {
+        expect(metrics.costPerSuccess).toBe(test.expectedCostPerSuccess);
+      }
+      
+      expect(metrics.successCount).toBe(test.success);
+    }
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('cost per success scales linearly with total cost', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 1, max: 1000, noNaN: true }), // baseCost
+        fc.integer({ min: 1, max: 100 }), // successCount
+        fc.float({ min: 2, max: 10, noNaN: true }), // multiplier
+        (payoutAmount, baseCost, successCount, multiplier) => {
+          const metrics1 = calculateTournamentMetrics(payoutAmount, baseCost, successCount);
+          const metrics2 = calculateTournamentMetrics(payoutAmount, baseCost * multiplier, successCount);
+          
+          // Cost per success should scale linearly with total cost
+          expect(metrics2.costPerSuccess).toBeCloseTo(metrics1.costPerSuccess * multiplier, 8);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  // **Feature: launch-readiness-checklist, Property 2: Tournament metrics calculation accuracy**
+  test('cost per success scales inversely with success count', () => {
+    fc.assert(
+      fc.property(
+        fc.float({ min: 1, max: 10000, noNaN: true }), // payoutAmount
+        fc.float({ min: 1, max: 10000, noNaN: true }), // totalCost
+        fc.integer({ min: 1, max: 50 }), // baseSuccessCount
+        fc.integer({ min: 2, max: 10 }), // multiplier
+        (payoutAmount, totalCost, baseSuccessCount, multiplier) => {
+          const metrics1 = calculateTournamentMetrics(payoutAmount, totalCost, baseSuccessCount);
+          const metrics2 = calculateTournamentMetrics(payoutAmount, totalCost, baseSuccessCount * multiplier);
+          
+          // Cost per success should scale inversely with success count
+          expect(metrics2.costPerSuccess).toBeCloseTo(metrics1.costPerSuccess / multiplier, 8);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});