outcome-cli 1.0.0

package/src/utils/cost-guard.ts

@@ -0,0 +1,379 @@
+/**
+ * Cost Guard System - Prevents Surprise API Bills
+ * 
+ * Implements strict cost controls and monitoring to prevent unexpected charges.
+ * Extended for battle routing integration with platform vs user cost attribution.
+ * 
+ * @module utils/cost-guard
+ */
+
+export interface CostLimits {
+  dailyLimit: number;
+  monthlyLimit: number;
+  perRequestLimit: number;
+  emergencyStop: boolean;
+  /** Platform-specific limits for founder accounts */
+  platformDailyLimit?: number;
+  platformMonthlyLimit?: number;
+}
+
+export interface UsageTracker {
+  dailySpent: number;
+  monthlySpent: number;
+  requestCount: number;
+  lastReset: string;
+  /** Platform usage tracking for founder accounts */
+  platformDailySpent: number;
+  platformMonthlySpent: number;
+  platformRequestCount: number;
+  /** Mock battle tracking (always zero cost) */
+  mockBattleCount: number;
+  /** Real battle tracking */
+  realBattleCount: number;
+}
+
+/**
+ * Battle cost record for tracking and attribution
+ */
+export interface BattleCostRecord {
+  battleId: string;
+  userId: string;
+  cost: number;
+  battleMode: 'mock' | 'real';
+  costCategory: 'user' | 'platform' | 'mock';
+  timestamp: string;
+  tokenUsage?: { input: number; output: number };
+}
+
+/**
+ * Cost attribution result
+ */
+export interface CostAttribution {
+  category: 'user' | 'platform' | 'mock';
+  cost: number;
+  isFounderAccount: boolean;
+  userId: string;
+}
+
+
+const DEFAULT_LIMITS: CostLimits = {
+  dailyLimit: 10.00,      // $10/day max
+  monthlyLimit: 100.00,   // $100/month max
+  perRequestLimit: 2.00,  // $2 per request max
+  emergencyStop: false,
+  platformDailyLimit: 50.00,   // $50/day for platform/founder usage
+  platformMonthlyLimit: 500.00, // $500/month for platform/founder usage
+};
+
+class CostGuard {
+  private limits: CostLimits;
+  private usage: UsageTracker;
+  private battleCostHistory: BattleCostRecord[] = [];
+
+  constructor(limits: Partial<CostLimits> = {}) {
+    this.limits = { ...DEFAULT_LIMITS, ...limits };
+    this.usage = this.loadUsage();
+    this.resetIfNeeded();
+  }
+
+  /**
+   * Check if a request is allowed based on cost limits
+   */
+  canMakeRequest(estimatedCost: number): { allowed: boolean; reason?: string } {
+    if (this.limits.emergencyStop) {
+      return { allowed: false, reason: 'Emergency stop activated' };
+    }
+
+    if (estimatedCost > this.limits.perRequestLimit) {
+      return { 
+        allowed: false, 
+        reason: `Request cost ${estimatedCost} exceeds limit ${this.limits.perRequestLimit}` 
+      };
+    }
+
+    if (this.usage.dailySpent + estimatedCost > this.limits.dailyLimit) {
+      return { 
+        allowed: false, 
+        reason: `Would exceed daily limit: ${this.usage.dailySpent + estimatedCost} > ${this.limits.dailyLimit}` 
+      };
+    }
+
+    if (this.usage.monthlySpent + estimatedCost > this.limits.monthlyLimit) {
+      return { 
+        allowed: false, 
+        reason: `Would exceed monthly limit: ${this.usage.monthlySpent + estimatedCost} > ${this.limits.monthlyLimit}` 
+      };
+    }
+
+    return { allowed: true };
+  }
+
+  /**
+   * Check if a platform/founder request is allowed
+   */
+  canMakePlatformRequest(estimatedCost: number): { allowed: boolean; reason?: string } {
+    if (this.limits.emergencyStop) {
+      return { allowed: false, reason: 'Emergency stop activated' };
+    }
+
+    const platformDailyLimit = this.limits.platformDailyLimit || this.limits.dailyLimit * 5;
+    const platformMonthlyLimit = this.limits.platformMonthlyLimit || this.limits.monthlyLimit * 5;
+
+    if (this.usage.platformDailySpent + estimatedCost > platformDailyLimit) {
+      return { 
+        allowed: false, 
+        reason: `Would exceed platform daily limit: ${this.usage.platformDailySpent + estimatedCost} > ${platformDailyLimit}` 
+      };
+    }
+
+    if (this.usage.platformMonthlySpent + estimatedCost > platformMonthlyLimit) {
+      return { 
+        allowed: false, 
+        reason: `Would exceed platform monthly limit: ${this.usage.platformMonthlySpent + estimatedCost} > ${platformMonthlyLimit}` 
+      };
+    }
+
+    return { allowed: true };
+  }
+
+  /**
+   * Record actual cost after API call
+   */
+  recordCost(actualCost: number): void {
+    this.usage.dailySpent += actualCost;
+    this.usage.monthlySpent += actualCost;
+    this.usage.requestCount += 1;
+    this.saveUsage();
+
+    if (this.usage.dailySpent > this.limits.dailyLimit * 0.9) {
+      console.warn(`⚠️  Approaching daily limit: ${this.usage.dailySpent}/${this.limits.dailyLimit}`);
+    }
+
+    if (this.usage.monthlySpent > this.limits.monthlyLimit * 0.9) {
+      console.warn(`⚠️  Approaching monthly limit: ${this.usage.monthlySpent}/${this.limits.monthlyLimit}`);
+    }
+  }
+
+
+  /**
+   * Record battle cost with attribution
+   */
+  recordBattleCost(record: BattleCostRecord): void {
+    this.battleCostHistory.push(record);
+    
+    if (this.battleCostHistory.length > 1000) {
+      this.battleCostHistory = this.battleCostHistory.slice(-1000);
+    }
+
+    if (record.battleMode === 'mock') {
+      this.usage.mockBattleCount += 1;
+      console.log(`🎭 Mock Battle Recorded: ${record.battleId} (zero cost)`);
+    } else {
+      this.usage.realBattleCount += 1;
+      
+      if (record.costCategory === 'platform') {
+        this.usage.platformDailySpent += record.cost;
+        this.usage.platformMonthlySpent += record.cost;
+        this.usage.platformRequestCount += 1;
+        console.log(`🏢 Platform Battle Cost: $${record.cost.toFixed(4)} for ${record.battleId}`);
+      } else if (record.costCategory === 'user') {
+        this.usage.dailySpent += record.cost;
+        this.usage.monthlySpent += record.cost;
+        this.usage.requestCount += 1;
+        console.log(`👤 User Battle Cost: $${record.cost.toFixed(4)} for ${record.battleId} (user: ${record.userId})`);
+      }
+    }
+
+    this.saveUsage();
+    this.checkAlerts();
+  }
+
+  /**
+   * Record zero cost for mock battles
+   */
+  recordMockBattle(battleId: string, userId: string): void {
+    this.recordBattleCost({
+      battleId,
+      userId,
+      cost: 0,
+      battleMode: 'mock',
+      costCategory: 'mock',
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * Get cost attribution for a battle
+   */
+  getCostAttribution(userId: string, isFounderAccount: boolean, cost: number): CostAttribution {
+    if (cost === 0) {
+      return { category: 'mock', cost: 0, isFounderAccount, userId };
+    }
+    return {
+      category: isFounderAccount ? 'platform' : 'user',
+      cost,
+      isFounderAccount,
+      userId,
+    };
+  }
+
+  /**
+   * Get current usage status
+   */
+  getUsageStatus(): {
+    daily: { spent: number; limit: number; remaining: number };
+    monthly: { spent: number; limit: number; remaining: number };
+    platform: { dailySpent: number; monthlySpent: number; dailyLimit: number; monthlyLimit: number };
+    requests: number;
+    battles: { mock: number; real: number };
+    emergencyStop: boolean;
+  } {
+    const platformDailyLimit = this.limits.platformDailyLimit || this.limits.dailyLimit * 5;
+    const platformMonthlyLimit = this.limits.platformMonthlyLimit || this.limits.monthlyLimit * 5;
+
+    return {
+      daily: {
+        spent: this.usage.dailySpent,
+        limit: this.limits.dailyLimit,
+        remaining: Math.max(0, this.limits.dailyLimit - this.usage.dailySpent)
+      },
+      monthly: {
+        spent: this.usage.monthlySpent,
+        limit: this.limits.monthlyLimit,
+        remaining: Math.max(0, this.limits.monthlyLimit - this.usage.monthlySpent)
+      },
+      platform: {
+        dailySpent: this.usage.platformDailySpent,
+        monthlySpent: this.usage.platformMonthlySpent,
+        dailyLimit: platformDailyLimit,
+        monthlyLimit: platformMonthlyLimit,
+      },
+      requests: this.usage.requestCount,
+      battles: {
+        mock: this.usage.mockBattleCount,
+        real: this.usage.realBattleCount,
+      },
+      emergencyStop: this.limits.emergencyStop
+    };
+  }
+
+  getBattleCostHistory(limit: number = 100): BattleCostRecord[] {
+    return this.battleCostHistory.slice(-limit);
+  }
+
+  enableEmergencyStop(): void {
+    this.limits.emergencyStop = true;
+    console.log('🚨 EMERGENCY STOP ACTIVATED - All API calls blocked');
+  }
+
+  disableEmergencyStop(): void {
+    this.limits.emergencyStop = false;
+    console.log('✅ Emergency stop disabled - API calls resumed');
+  }
+
+  /**
+   * Check and trigger alerts for approaching limits
+   */
+  private checkAlerts(): void {
+    const platformDailyLimit = this.limits.platformDailyLimit || this.limits.dailyLimit * 5;
+    const platformMonthlyLimit = this.limits.platformMonthlyLimit || this.limits.monthlyLimit * 5;
+
+    // User limit alerts
+    if (this.usage.dailySpent > this.limits.dailyLimit * 0.9) {
+      console.warn(`⚠️  Approaching daily limit: ${this.usage.dailySpent.toFixed(2)}/${this.limits.dailyLimit}`);
+    }
+    if (this.usage.monthlySpent > this.limits.monthlyLimit * 0.9) {
+      console.warn(`⚠️  Approaching monthly limit: ${this.usage.monthlySpent.toFixed(2)}/${this.limits.monthlyLimit}`);
+    }
+
+    // Platform limit alerts
+    if (this.usage.platformDailySpent > platformDailyLimit * 0.9) {
+      console.warn(`🏢 ⚠️  Approaching platform daily limit: ${this.usage.platformDailySpent.toFixed(2)}/${platformDailyLimit}`);
+    }
+    if (this.usage.platformMonthlySpent > platformMonthlyLimit * 0.9) {
+      console.warn(`🏢 ⚠️  Approaching platform monthly limit: ${this.usage.platformMonthlySpent.toFixed(2)}/${platformMonthlyLimit}`);
+    }
+  }
+
+  /**
+   * Load usage from storage (in-memory for now)
+   */
+  private loadUsage(): UsageTracker {
+    return {
+      dailySpent: 0,
+      monthlySpent: 0,
+      requestCount: 0,
+      lastReset: new Date().toISOString(),
+      platformDailySpent: 0,
+      platformMonthlySpent: 0,
+      platformRequestCount: 0,
+      mockBattleCount: 0,
+      realBattleCount: 0,
+    };
+  }
+
+  /**
+   * Save usage to storage (in-memory for now)
+   */
+  private saveUsage(): void {
+    // In-memory storage - usage is already in this.usage
+    // Future: persist to database or file
+  }
+
+  /**
+   * Reset daily/monthly counters if needed
+   */
+  private resetIfNeeded(): void {
+    const now = new Date();
+    const lastReset = new Date(this.usage.lastReset);
+
+    // Reset daily counters if new day
+    if (now.toDateString() !== lastReset.toDateString()) {
+      this.usage.dailySpent = 0;
+      this.usage.platformDailySpent = 0;
+      console.log('📅 Daily usage counters reset');
+    }
+
+    // Reset monthly counters if new month
+    if (now.getMonth() !== lastReset.getMonth() || now.getFullYear() !== lastReset.getFullYear()) {
+      this.usage.monthlySpent = 0;
+      this.usage.platformMonthlySpent = 0;
+      console.log('📅 Monthly usage counters reset');
+    }
+
+    this.usage.lastReset = now.toISOString();
+  }
+}
+
+/**
+ * Estimated costs per 1K tokens for different models
+ */
+export const ESTIMATED_COSTS: Record<string, { input: number; output: number }> = {
+  'gpt-4-turbo': { input: 0.01, output: 0.03 },
+  'gpt-4o': { input: 0.005, output: 0.015 },
+  'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
+  'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
+  'claude-3-opus': { input: 0.015, output: 0.075 },
+  'claude-3-sonnet': { input: 0.003, output: 0.015 },
+  'claude-3-haiku': { input: 0.00025, output: 0.00125 },
+  'gemini-pro': { input: 0.00025, output: 0.0005 },
+  'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
+};
+
+/**
+ * Estimate request cost based on model and token counts
+ */
+export function estimateRequestCost(
+  model: string,
+  inputTokens: number,
+  outputTokens: number
+): number {
+  const costs = ESTIMATED_COSTS[model] || { input: 0.01, output: 0.03 }; // Default to GPT-4 pricing
+  return (inputTokens / 1000) * costs.input + (outputTokens / 1000) * costs.output;
+}
+
+// Singleton instance
+export const costGuard = new CostGuard();
+
+// Export class for testing
+export { CostGuard };

package/src/utils/errors.test.ts

@@ -0,0 +1,290 @@
+/**
+ * Error Types Tests
+ *
+ * Tests for custom error classes and error handling utilities.
+ *
+ * @module utils/errors.test
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  ErrorCode,
+  ValidationError,
+  ExecutionError,
+  LimitError,
+  SystemError,
+  isEarndError,
+  isValidationError,
+  isExecutionError,
+  isLimitError,
+  isSystemError,
+  toErrorResponse,
+  type ErrorResponse,
+} from './errors.js';
+
+describe('ValidationError', () => {
+  it('should create error with message and code', () => {
+    const error = new ValidationError('Test error');
+    
+    expect(error.message).toBe('Test error');
+    expect(error.code).toBe(ErrorCode.VALIDATION_SCHEMA_INVALID);
+    expect(error.recoverable).toBe(false);
+    expect(error.name).toBe('ValidationError');
+  });
+
+  it('should create error with custom code and details', () => {
+    const error = new ValidationError(
+      'Field error',
+      ErrorCode.VALIDATION_FIELD_INVALID,
+      { field: 'email' }
+    );
+    
+    expect(error.code).toBe(ErrorCode.VALIDATION_FIELD_INVALID);
+    expect(error.details).toEqual({ field: 'email' });
+  });
+
+  it('missingField should create proper error', () => {
+    const error = ValidationError.missingField('name', 'AgentConfig');
+    
+    expect(error.message).toContain('Missing required field: name');
+    expect(error.message).toContain('AgentConfig');
+    expect(error.code).toBe(ErrorCode.VALIDATION_FIELD_MISSING);
+    expect(error.details?.field).toBe('name');
+  });
+
+  it('invalidField should create proper error', () => {
+    const error = ValidationError.invalidField('age', 'must be positive', -5);
+    
+    expect(error.message).toContain('Invalid field "age"');
+    expect(error.message).toContain('must be positive');
+    expect(error.code).toBe(ErrorCode.VALIDATION_FIELD_INVALID);
+    expect(error.details?.value).toBe(-5);
+  });
+
+  it('malformedData should create proper error', () => {
+    const error = ValidationError.malformedData('Invalid JSON', { raw: '{bad' });
+    
+    expect(error.message).toBe('Invalid JSON');
+    expect(error.code).toBe(ErrorCode.VALIDATION_DATA_MALFORMED);
+  });
+
+  it('toResponse should return ErrorResponse', () => {
+    const error = new ValidationError('Test', ErrorCode.VALIDATION_FIELD_MISSING, { x: 1 });
+    const response = error.toResponse();
+    
+    expect(response.code).toBe(ErrorCode.VALIDATION_FIELD_MISSING);
+    expect(response.message).toBe('Test');
+    expect(response.recoverable).toBe(false);
+    expect(response.details).toEqual({ x: 1 });
+  });
+});
+
+describe('ExecutionError', () => {
+  it('should create error with default recoverable true', () => {
+    const error = new ExecutionError('API failed');
+    
+    expect(error.message).toBe('API failed');
+    expect(error.code).toBe(ErrorCode.EXECUTION_MODEL_FAILURE);
+    expect(error.recoverable).toBe(true);
+  });
+
+  it('modelFailure should create proper error', () => {
+    const error = ExecutionError.modelFailure('claude', 'Rate limited');
+    
+    expect(error.message).toContain('claude');
+    expect(error.message).toContain('Rate limited');
+    expect(error.code).toBe(ErrorCode.EXECUTION_MODEL_FAILURE);
+    expect(error.recoverable).toBe(true);
+  });
+
+  it('timeout should create proper error', () => {
+    const error = ExecutionError.timeout('model.complete', 30000);
+    
+    expect(error.message).toContain('timed out');
+    expect(error.message).toContain('30000ms');
+    expect(error.code).toBe(ErrorCode.EXECUTION_TIMEOUT);
+    expect(error.details?.durationMs).toBe(30000);
+  });
+
+  it('networkError should create proper error', () => {
+    const error = ExecutionError.networkError('Connection refused');
+    
+    expect(error.message).toContain('Network error');
+    expect(error.code).toBe(ErrorCode.EXECUTION_NETWORK_ERROR);
+    expect(error.recoverable).toBe(true);
+  });
+
+  it('retryExhausted should create non-recoverable error', () => {
+    const error = ExecutionError.retryExhausted('API call', 3, 'Connection reset');
+    
+    expect(error.message).toContain('Retries exhausted');
+    expect(error.message).toContain('3 attempts');
+    expect(error.code).toBe(ErrorCode.EXECUTION_RETRY_EXHAUSTED);
+    expect(error.recoverable).toBe(false);
+  });
+});
+
+describe('LimitError', () => {
+  it('should create error with recoverable false', () => {
+    const error = new LimitError('Limit exceeded');
+    
+    expect(error.recoverable).toBe(false);
+    expect(error.code).toBe(ErrorCode.LIMIT_COST_EXCEEDED);
+  });
+
+  it('costExceeded should create proper error', () => {
+    const error = LimitError.costExceeded('agent-1', 15000, 10000);
+    
+    expect(error.message).toContain('agent-1');
+    expect(error.message).toContain('15000');
+    expect(error.message).toContain('10000');
+    expect(error.code).toBe(ErrorCode.LIMIT_COST_EXCEEDED);
+    expect(error.details?.spent).toBe(15000);
+    expect(error.details?.ceiling).toBe(10000);
+  });
+
+  it('attemptsExceeded should create proper error', () => {
+    const error = LimitError.attemptsExceeded('agent-2', 5, 5);
+    
+    expect(error.message).toContain('attempt limit');
+    expect(error.code).toBe(ErrorCode.LIMIT_ATTEMPTS_EXCEEDED);
+    expect(error.details?.attempts).toBe(5);
+  });
+
+  it('timeExceeded should create proper error', () => {
+    const error = LimitError.timeExceeded('agent-3', 60000, 30000);
+    
+    expect(error.message).toContain('time limit');
+    expect(error.code).toBe(ErrorCode.LIMIT_TIME_EXCEEDED);
+    expect(error.details?.elapsedMs).toBe(60000);
+  });
+
+  it('globalSpendExceeded should create proper error', () => {
+    const error = LimitError.globalSpendExceeded(100000, 50000);
+    
+    expect(error.message).toContain('Global spend ceiling');
+    expect(error.code).toBe(ErrorCode.LIMIT_GLOBAL_SPEND_EXCEEDED);
+  });
+});
+
+describe('SystemError', () => {
+  it('should create error with recoverable false', () => {
+    const error = new SystemError('System failure');
+    
+    expect(error.recoverable).toBe(false);
+    expect(error.code).toBe(ErrorCode.SYSTEM_UNKNOWN_ERROR);
+  });
+
+  it('infrastructureFailure should create proper error', () => {
+    const error = SystemError.infrastructureFailure('DurableObject', 'Storage unavailable');
+    
+    expect(error.message).toContain('DurableObject');
+    expect(error.message).toContain('Storage unavailable');
+    expect(error.code).toBe(ErrorCode.SYSTEM_INFRASTRUCTURE_FAILURE);
+  });
+
+  it('stateCorruption should create proper error', () => {
+    const error = SystemError.stateCorruption('Agent state mismatch');
+    
+    expect(error.message).toContain('State corruption');
+    expect(error.code).toBe(ErrorCode.SYSTEM_STATE_CORRUPTION);
+  });
+
+  it('fromUnknown should handle Error objects', () => {
+    const originalError = new Error('Original message');
+    const error = SystemError.fromUnknown(originalError);
+    
+    expect(error.message).toContain('Original message');
+    expect(error.code).toBe(ErrorCode.SYSTEM_UNKNOWN_ERROR);
+    expect(error.details?.stack).toBeDefined();
+  });
+
+  it('fromUnknown should handle non-Error values', () => {
+    const error = SystemError.fromUnknown('String error');
+    
+    expect(error.message).toContain('String error');
+    expect(error.code).toBe(ErrorCode.SYSTEM_UNKNOWN_ERROR);
+  });
+});
+
+describe('Type Guards', () => {
+  it('isEarndError should identify EarndError subclasses', () => {
+    expect(isEarndError(new ValidationError('test'))).toBe(true);
+    expect(isEarndError(new ExecutionError('test'))).toBe(true);
+    expect(isEarndError(new LimitError('test'))).toBe(true);
+    expect(isEarndError(new SystemError('test'))).toBe(true);
+    expect(isEarndError(new Error('test'))).toBe(false);
+    expect(isEarndError('string')).toBe(false);
+  });
+
+  it('isValidationError should identify ValidationError', () => {
+    expect(isValidationError(new ValidationError('test'))).toBe(true);
+    expect(isValidationError(new ExecutionError('test'))).toBe(false);
+    expect(isValidationError(new Error('test'))).toBe(false);
+  });
+
+  it('isExecutionError should identify ExecutionError', () => {
+    expect(isExecutionError(new ExecutionError('test'))).toBe(true);
+    expect(isExecutionError(new ValidationError('test'))).toBe(false);
+  });
+
+  it('isLimitError should identify LimitError', () => {
+    expect(isLimitError(new LimitError('test'))).toBe(true);
+    expect(isLimitError(new ValidationError('test'))).toBe(false);
+  });
+
+  it('isSystemError should identify SystemError', () => {
+    expect(isSystemError(new SystemError('test'))).toBe(true);
+    expect(isSystemError(new ValidationError('test'))).toBe(false);
+  });
+});
+
+describe('toErrorResponse', () => {
+  it('should convert EarndError to ErrorResponse', () => {
+    const error = new ValidationError('Test', ErrorCode.VALIDATION_FIELD_INVALID, { x: 1 });
+    const response = toErrorResponse(error);
+    
+    expect(response.code).toBe(ErrorCode.VALIDATION_FIELD_INVALID);
+    expect(response.message).toBe('Test');
+    expect(response.recoverable).toBe(false);
+    expect(response.details).toEqual({ x: 1 });
+  });
+
+  it('should convert standard Error to ErrorResponse', () => {
+    const error = new Error('Standard error');
+    const response = toErrorResponse(error);
+    
+    expect(response.code).toBe(ErrorCode.SYSTEM_UNKNOWN_ERROR);
+    expect(response.message).toBe('Standard error');
+    expect(response.recoverable).toBe(false);
+    expect(response.details?.name).toBe('Error');
+  });
+
+  it('should convert non-Error to ErrorResponse', () => {
+    const response = toErrorResponse('String error');
+    
+    expect(response.code).toBe(ErrorCode.SYSTEM_UNKNOWN_ERROR);
+    expect(response.message).toBe('String error');
+    expect(response.recoverable).toBe(false);
+  });
+
+  it('should handle null/undefined', () => {
+    expect(toErrorResponse(null).message).toBe('null');
+    expect(toErrorResponse(undefined).message).toBe('undefined');
+  });
+});
+
+describe('Error Inheritance', () => {
+  it('all errors should be instances of Error', () => {
+    expect(new ValidationError('test') instanceof Error).toBe(true);
+    expect(new ExecutionError('test') instanceof Error).toBe(true);
+    expect(new LimitError('test') instanceof Error).toBe(true);
+    expect(new SystemError('test') instanceof Error).toBe(true);
+  });
+
+  it('errors should have proper stack traces', () => {
+    const error = new ValidationError('test');
+    expect(error.stack).toBeDefined();
+    expect(error.stack).toContain('ValidationError');
+  });
+});