agentic-flow 1.9.0 → 1.9.2

package/bench/lib/report-generator.ts

@@ -1,266 +0,0 @@
-/**
- * Report Generator
- *
- * Generates comprehensive benchmark reports in multiple formats:
- * - Markdown: Human-readable reports with charts and insights
- * - JSON: Machine-readable data for further analysis
- * - CSV: Tabular data for spreadsheet analysis
- */
-
-import type { BenchmarkReport, ScenarioResults } from './types.js';
-
-export function generateReport(report: BenchmarkReport): string {
-  return `# ReasoningBank Benchmark Report
-
-Generated: ${new Date(report.generatedAt).toLocaleString()}
-
-## Executive Summary
-
-- **Total Scenarios**: ${report.summary.totalScenarios}
-- **Total Tasks**: ${report.summary.totalTasks}
-- **Execution Time**: ${(report.summary.executionTime / 1000).toFixed(1)}s
-
-### Overall Improvement
-
-| Metric | Baseline → ReasoningBank |
-|--------|--------------------------|
-| **Success Rate** | ${report.summary.overallImprovement.successRateDelta} |
-| **Token Efficiency** | ${report.summary.overallImprovement.tokenEfficiency} |
-| **Latency Overhead** | ${report.summary.overallImprovement.latencyOverhead} |
-
-${generateRecommendationsSection(report.recommendations)}
-
----
-
-## Detailed Scenario Results
-
-${report.scenarios.map(scenario => generateScenarioSection(scenario)).join('\n\n---\n\n')}
-
----
-
-## Methodology
-
-### Baseline Agent (Control Group)
-- **Type**: Standard LLM without memory
-- **Capabilities**: Direct task execution with no learning
-- **Memory**: None (stateless)
-- **Model**: claude-sonnet-4-5-20250929
-
-### ReasoningBank Agent (Experimental Group)
-- **Type**: LLM with closed-loop learning
-- **Capabilities**: RETRIEVE → JUDGE → DISTILL → CONSOLIDATE
-- **Memory**: SQLite with vector embeddings and 4-factor scoring
-- **Model**: claude-sonnet-4-5-20250929
-
-### Metrics Explained
-
-1. **Success Rate**: Percentage of tasks that pass success criteria
-2. **Learning Velocity**: Number of iterations to achieve first success
-3. **Token Efficiency**: Average tokens per task (lower is better)
-4. **Latency Impact**: Average execution time per task
-5. **Memory Efficiency**: Number of memories created vs used
-6. **Confidence**: Agent's self-assessed confidence in results (0-1)
-
-### Scoring Formula
-
-ReasoningBank uses a 4-factor weighted scoring system:
-
-\`\`\`
-score = α·similarity + β·recency + γ·reliability + δ·diversity
-where α=0.65, β=0.15, γ=0.20, δ=0.10
-\`\`\`
-
-- **Similarity**: Cosine similarity between query and memory embeddings
-- **Recency**: Exponential decay with 30-day half-life
-- **Reliability**: Success rate of memory in past executions
-- **Diversity**: MMR-based diversity to avoid redundant memories
-
----
-
-## Interpretation Guide
-
-### Success Rate
-- **+50% or more**: Excellent improvement, ReasoningBank learning effectively
-- **+20% to +50%**: Good improvement, memory providing value
-- **+0% to +20%**: Modest improvement, may need tuning
-- **Negative**: Investigate memory quality and retrieval parameters
-
-### Token Efficiency
-- **+20% or more**: Excellent token savings from memory injection
-- **+10% to +20%**: Good efficiency gains
-- **0% to +10%**: Modest savings
-- **Negative**: Memory overhead exceeds benefits, tune k parameter
-
-### Latency Overhead
-- **<10%**: Acceptable overhead for memory operations
-- **10-25%**: Moderate overhead, consider optimizations
-- **>25%**: High overhead, investigate database performance
-
-### Learning Velocity
-- **2-3x faster**: Excellent learning acceleration
-- **1.5-2x faster**: Good learning improvement
-- **<1.5x**: Modest improvement, may need more diverse tasks
-
----
-
-## Appendix
-
-### Configuration
-- **Iterations**: ${report.summary.totalScenarios > 0 ? '3 per scenario (default)' : 'N/A'}
-- **Parallel Agents**: 1 (sequential execution)
-- **Memory Size**: 1000 max memories
-- **Warm Start**: Disabled (learning from scratch)
-
-### Environment
-- **Model**: claude-sonnet-4-5-20250929
-- **Database**: SQLite with WAL mode
-- **Embedding**: Hash-based (offline mode)
-- **PII Scrubbing**: Enabled (9 pattern types)
-
----
-
-**Generated with agentic-flow v1.4.11**
-**ReasoningBank Benchmark Suite**
-`;
-}
-
-function generateRecommendationsSection(recommendations: string[]): string {
-  if (recommendations.length === 0) {
-    return '';
-  }
-
-  return `### Recommendations
-
-${recommendations.map(rec => `- ${rec}`).join('\n')}`;
-}
-
-function generateScenarioSection(scenario: ScenarioResults): string {
-  const { scenarioName, baseline, reasoningbank, improvement } = scenario;
-
-  return `### ${scenarioName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase())}
-
-**Overview**
-- Total Tasks: ${baseline.totalTasks}
-- Difficulty Distribution: ${generateDifficultyDistribution(scenario)}
-
-#### Baseline Performance
-- Success Rate: ${(baseline.successRate * 100).toFixed(1)}%
-- Avg Tokens: ${baseline.avgTokens.toLocaleString()}
-- Avg Latency: ${baseline.avgLatency.toFixed(0)}ms
-- Successful Tasks: ${baseline.successfulTasks}/${baseline.totalTasks}
-
-#### ReasoningBank Performance
-- Success Rate: ${(reasoningbank.successRate * 100).toFixed(1)}%
-- Avg Tokens: ${reasoningbank.avgTokens.toLocaleString()}
-- Avg Latency: ${reasoningbank.avgLatency.toFixed(0)}ms
-- Successful Tasks: ${reasoningbank.successfulTasks}/${reasoningbank.totalTasks}
-- Memories Created: ${reasoningbank.memoriesCreated || 0}
-- Memories Used: ${reasoningbank.memoriesUsed || 0}
-- Avg Confidence: ${reasoningbank.avgConfidence ? (reasoningbank.avgConfidence * 100).toFixed(1) + '%' : 'N/A'}
-
-#### Improvement Metrics
-
-| Metric | Value | Status |
-|--------|-------|--------|
-| Success Rate | ${improvement.successRateDelta} (${improvement.successRatePercent > 0 ? '+' : ''}${improvement.successRatePercent.toFixed(1)}%) | ${getStatusEmoji(improvement.successRatePercent, 'success')} |
-| Token Efficiency | ${improvement.tokenEfficiency} (${improvement.tokenSavings > 0 ? '+' : ''}${improvement.tokenSavings.toFixed(1)}% savings) | ${getStatusEmoji(improvement.tokenSavings, 'token')} |
-| Latency Overhead | ${improvement.latencyOverhead} (${improvement.latencyDelta > 0 ? '+' : ''}${improvement.latencyDelta.toFixed(0)}ms) | ${getStatusEmoji(improvement.latencyDelta, 'latency')} |
-${improvement.learningVelocity ? `| Learning Velocity | ${improvement.learningVelocity.toFixed(1)}x faster | ${getStatusEmoji(improvement.learningVelocity, 'learning')} |` : ''}
-
-${generateLearningCurve(scenario)}
-`;
-}
-
-function generateDifficultyDistribution(scenario: ScenarioResults): string {
-  // This would need access to original tasks, simplified for now
-  return 'Easy: 3, Medium: 5, Hard: 2';
-}
-
-function getStatusEmoji(value: number, type: 'success' | 'token' | 'latency' | 'learning'): string {
-  switch (type) {
-    case 'success':
-      if (value >= 50) return '🎯 Excellent';
-      if (value >= 20) return '✅ Good';
-      if (value >= 0) return '📊 Modest';
-      return '⚠️ Investigate';
-
-    case 'token':
-      if (value >= 20) return '💰 Excellent';
-      if (value >= 10) return '✅ Good';
-      if (value >= 0) return '📊 Modest';
-      return '⚠️ Overhead';
-
-    case 'latency':
-      if (value <= 100) return '⚡ Excellent';
-      if (value <= 500) return '✅ Good';
-      if (value <= 1000) return '📊 Acceptable';
-      return '⚠️ High';
-
-    case 'learning':
-      if (value >= 2) return '🚀 Excellent';
-      if (value >= 1.5) return '✅ Good';
-      if (value >= 1) return '📊 Modest';
-      return '⚠️ Slow';
-  }
-}
-
-function generateLearningCurve(scenario: ScenarioResults): string {
-  if (!scenario.learningCurve || scenario.learningCurve.length === 0) {
-    return '';
-  }
-
-  return `#### Learning Curve
-
-| Iteration | Baseline Success | ReasoningBank Success | RB Tokens | Memories |
-|-----------|------------------|----------------------|-----------|----------|
-${scenario.learningCurve.map(point =>
-  `| ${point.iteration} | ${(point.baselineSuccess * 100).toFixed(1)}% | ${(point.reasoningbankSuccess * 100).toFixed(1)}% | ${Math.round(point.reasoningbankTokens).toLocaleString()} | ${point.memoriesAvailable} |`
-).join('\n')}
-
-**Key Observations:**
-${generateLearningInsights(scenario.learningCurve)}
-`;
-}
-
-function generateLearningInsights(learningCurve: any[]): string {
-  const insights: string[] = [];
-
-  // Check if ReasoningBank improves over iterations
-  const firstIteration = learningCurve[0];
-  const lastIteration = learningCurve[learningCurve.length - 1];
-
-  const successImprovement = lastIteration.reasoningbankSuccess - firstIteration.reasoningbankSuccess;
-  if (successImprovement > 0.1) {
-    insights.push(`- ReasoningBank success rate improved by ${(successImprovement * 100).toFixed(1)}% across iterations (learning effect)`);
-  }
-
-  // Check baseline consistency
-  const baselineVariance = learningCurve.reduce((sum, point) => sum + Math.abs(point.baselineSuccess - firstIteration.baselineSuccess), 0) / learningCurve.length;
-  if (baselineVariance < 0.05) {
-    insights.push('- Baseline performance remained consistent (no learning, as expected)');
-  }
-
-  // Check memory growth
-  if (lastIteration.memoriesAvailable > 0) {
-    insights.push(`- Memory bank grew to ${lastIteration.memoriesAvailable} memories by final iteration`);
-  }
-
-  // Check token efficiency over time
-  const tokenReduction = (firstIteration.reasoningbankTokens - lastIteration.reasoningbankTokens) / firstIteration.reasoningbankTokens;
-  if (tokenReduction > 0.1) {
-    insights.push(`- Token usage improved by ${(tokenReduction * 100).toFixed(1)}% as memory bank matured`);
-  }
-
-  return insights.length > 0 ? insights.join('\n') : '- Insufficient data for learning insights';
-}
-
-export function generateCSVReport(report: BenchmarkReport): string {
-  let csv = 'Scenario,Agent,Success Rate,Avg Tokens,Avg Latency,Total Tasks,Successful Tasks,Memories Created,Memories Used\n';
-
-  for (const scenario of report.scenarios) {
-    csv += `${scenario.scenarioName},Baseline,${scenario.baseline.successRate},${scenario.baseline.avgTokens},${scenario.baseline.avgLatency},${scenario.baseline.totalTasks},${scenario.baseline.successfulTasks},0,0\n`;
-    csv += `${scenario.scenarioName},ReasoningBank,${scenario.reasoningbank.successRate},${scenario.reasoningbank.avgTokens},${scenario.reasoningbank.avgLatency},${scenario.reasoningbank.totalTasks},${scenario.reasoningbank.successfulTasks},${scenario.reasoningbank.memoriesCreated || 0},${scenario.reasoningbank.memoriesUsed || 0}\n`;
-  }
-
-  return csv;
-}

package/bench/lib/types.js

@@ -1,4 +0,0 @@
-/**
- * Type definitions for ReasoningBank Benchmark Suite
- */
-export {};

package/bench/lib/types.ts

@@ -1,117 +0,0 @@
-/**
- * Type definitions for ReasoningBank Benchmark Suite
- */
-
-export interface BenchmarkConfig {
-  iterations: number;
-  parallelAgents: number;
-  scenarios: string[];
-  enableWarmStart: boolean;
-  memorySize: number;
-  outputFormats: ('json' | 'markdown' | 'csv')[];
-  anthropicApiKey?: string;
-}
-
-export interface Task {
-  id: string;
-  name: string;
-  description: string;
-  domain: string;
-  input: string;
-  expectedOutput?: string;
-  successCriteria: (result: TaskResult) => boolean;
-  difficulty: 'easy' | 'medium' | 'hard';
-}
-
-export interface TaskResult {
-  taskId: string;
-  agentType: 'baseline' | 'reasoningbank';
-  success: boolean;
-  output: string;
-  tokens: number;
-  latency: number;
-  memoriesUsed?: number;
-  memoriesCreated?: number;
-  confidence?: number;
-  error?: string;
-  trajectory?: any;
-}
-
-export interface BenchmarkScenario {
-  name: string;
-  description: string;
-  domain: string;
-  tasks: Task[];
-  warmStartMemories?: any[];
-  metrics: MetricType[];
-}
-
-export type MetricType =
-  | 'success_rate'
-  | 'token_efficiency'
-  | 'latency'
-  | 'memory_usage'
-  | 'learning_velocity'
-  | 'accuracy'
-  | 'generalization';
-
-export interface ScenarioResults {
-  scenarioName: string;
-  baseline: AgentMetrics;
-  reasoningbank: AgentMetrics;
-  improvement: ImprovementMetrics;
-  learningCurve: LearningPoint[];
-  timestamp: string;
-}
-
-export interface AgentMetrics {
-  successRate: number;
-  totalTasks: number;
-  successfulTasks: number;
-  avgTokens: number;
-  totalTokens: number;
-  avgLatency: number;
-  totalLatency: number;
-  memoriesUsed?: number;
-  memoriesCreated?: number;
-  avgConfidence?: number;
-  errors: string[];
-}
-
-export interface ImprovementMetrics {
-  successRateDelta: string;
-  successRatePercent: number;
-  tokenEfficiency: string;
-  tokenSavings: number;
-  latencyOverhead: string;
-  latencyDelta: number;
-  learningVelocity?: number;
-}
-
-export interface LearningPoint {
-  iteration: number;
-  baselineSuccess: number;
-  reasoningbankSuccess: number;
-  baselineTokens: number;
-  reasoningbankTokens: number;
-  memoriesAvailable: number;
-}
-
-export interface BenchmarkReport {
-  summary: {
-    totalScenarios: number;
-    totalTasks: number;
-    overallImprovement: ImprovementMetrics;
-    executionTime: number;
-  };
-  scenarios: ScenarioResults[];
-  recommendations: string[];
-  generatedAt: string;
-}
-
-export interface Agent {
-  type: 'baseline' | 'reasoningbank';
-  executeTask(task: Task): Promise<TaskResult>;
-  reset(): Promise<void>;
-  getMemoryStats?(): Promise<{ total: number; avgConfidence: number }>;
-}

package/bench/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "@agentic-flow/reasoningbank-benchmark",
-  "version": "1.0.0",
-  "description": "Comprehensive benchmark suite for ReasoningBank",
-  "type": "module",
-  "scripts": {
-    "bench": "node benchmark.js",
-    "bench:coding": "node benchmark.js --scenarios=coding-tasks",
-    "bench:debugging": "node benchmark.js --scenarios=debugging-tasks",
-    "bench:api": "node benchmark.js --scenarios=api-design-tasks",
-    "bench:problem-solving": "node benchmark.js --scenarios=problem-solving-tasks",
-    "bench:quick": "node benchmark.js --iterations=1",
-    "bench:full": "node benchmark.js --iterations=5",
-    "bench:report": "node scripts/generate-report.js",
-    "bench:clean": "rm -rf results/* reports/*"
-  },
-  "keywords": [
-    "benchmark",
-    "reasoningbank",
-    "ai",
-    "memory",
-    "learning"
-  ],
-  "author": "agentic-flow",
-  "license": "MIT",
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.32.1",
-    "better-sqlite3": "^11.7.0",
-    "ulid": "^2.3.0"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.11",
-    "@types/node": "^22.10.2",
-    "typescript": "^5.7.2"
-  }
-}

package/bench/run-benchmark.sh

@@ -1,67 +0,0 @@
-#!/bin/bash
-# ReasoningBank Benchmark Execution Script
-
-set -e
-
-echo "🧪 ReasoningBank Benchmark Suite"
-echo "=================================="
-echo ""
-
-# Check for API key
-if [ -z "$ANTHROPIC_API_KEY" ]; then
-  echo "❌ Error: ANTHROPIC_API_KEY environment variable not set"
-  echo "Please set it with: export ANTHROPIC_API_KEY='sk-ant-...'"
-  exit 1
-fi
-
-# Create output directories
-mkdir -p results reports
-
-# Parse arguments
-SCENARIOS="${1:-all}"
-ITERATIONS="${2:-3}"
-
-echo "Configuration:"
-echo "  Scenarios: $SCENARIOS"
-echo "  Iterations: $ITERATIONS"
-echo "  API Key: ${ANTHROPIC_API_KEY:0:10}..."
-echo ""
-
-# Check if TypeScript is compiled
-if [ ! -f "benchmark.js" ]; then
-  echo "📦 Compiling TypeScript..."
-  cd ..
-  npm run build
-  cd bench
-  echo "✅ Build complete"
-  echo ""
-fi
-
-# Initialize ReasoningBank database
-echo "🗄️  Initializing ReasoningBank database..."
-npx agentic-flow reasoningbank init
-echo ""
-
-# Run benchmark
-echo "🚀 Starting benchmark execution..."
-echo "This may take several minutes depending on the number of scenarios and iterations."
-echo ""
-
-if [ "$SCENARIOS" = "all" ]; then
-  node benchmark.js --iterations=$ITERATIONS
-elif [ "$SCENARIOS" = "quick" ]; then
-  node benchmark.js --scenarios=coding-tasks --iterations=1
-else
-  node benchmark.js --scenarios=$SCENARIOS --iterations=$ITERATIONS
-fi
-
-echo ""
-echo "✅ Benchmark complete!"
-echo ""
-echo "📊 Results saved to:"
-echo "  - JSON: ./results/"
-echo "  - Markdown: ./reports/"
-echo ""
-echo "💡 View results:"
-echo "  cat reports/benchmark-*.md | less"
-echo ""

package/bench/scenarios/api-design-tasks.js

@@ -1,175 +0,0 @@
-/**
- * API Design Tasks Benchmark Scenario
- *
- * Tests agent's ability to:
- * - Design RESTful APIs
- * - Apply API best practices
- * - Handle versioning and deprecation
- * - Design authentication systems
- * - Structure request/response schemas
- */
-const tasks = [
-    {
-        id: 'api-01',
-        name: 'Design User Authentication API',
-        description: 'Design a RESTful API for user authentication including signup, login, logout, and token refresh.',
-        domain: 'api-design',
-        input: `Design endpoints for user authentication system with JWT tokens.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return (output.includes('post') &&
-                output.includes('/auth/signup') ||
-                output.includes('/signup') &&
-                    output.includes('/login') &&
-                    output.includes('jwt') &&
-                    output.includes('refresh'));
-        },
-        difficulty: 'medium'
-    },
-    {
-        id: 'api-02',
-        name: 'Design RESTful CRUD API',
-        description: 'Design a RESTful API for managing blog posts with proper HTTP methods and status codes.',
-        domain: 'api-design',
-        input: `Design CRUD endpoints for blog posts including listing, creating, updating, and deleting.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return (output.includes('get') &&
-                output.includes('post') &&
-                output.includes('put') ||
-                output.includes('patch') &&
-                    output.includes('delete') &&
-                    (output.includes('/posts') || output.includes('/articles')));
-        },
-        difficulty: 'easy'
-    },
-    {
-        id: 'api-03',
-        name: 'Design Pagination API',
-        description: 'Design pagination for a large dataset with cursor-based or offset-based pagination.',
-        domain: 'api-design',
-        input: `Design API pagination for listing products with 10,000+ items.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return ((output.includes('cursor') || output.includes('offset')) &&
-                (output.includes('limit') || output.includes('page')) &&
-                (output.includes('next') || output.includes('has_more')));
-        },
-        difficulty: 'medium'
-    },
-    {
-        id: 'api-04',
-        name: 'Design Rate Limiting',
-        description: 'Design rate limiting strategy for API with appropriate headers and error responses.',
-        domain: 'api-design',
-        input: `Design rate limiting for API with 100 requests per minute per user.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return ((output.includes('x-ratelimit-limit') || output.includes('rate limit')) &&
-                (output.includes('429') || output.includes('too many requests')) &&
-                (output.includes('retry-after') || output.includes('reset')));
-        },
-        difficulty: 'medium'
-    },
-    {
-        id: 'api-05',
-        name: 'Design API Versioning',
-        description: 'Design API versioning strategy to maintain backward compatibility.',
-        domain: 'api-design',
-        input: `Design API versioning for evolving endpoints without breaking existing clients.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return ((output.includes('/v1') || output.includes('/v2')) ||
-                (output.includes('accept-version') || output.includes('api-version')) &&
-                    (output.includes('deprecat') || output.includes('backward compat')));
-        },
-        difficulty: 'hard'
-    },
-    {
-        id: 'api-06',
-        name: 'Design Error Response Schema',
-        description: 'Design consistent error response format with proper status codes and error details.',
-        domain: 'api-design',
-        input: `Design error response schema for API with validation errors, authorization errors, and server errors.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return (output.includes('error') &&
-                (output.includes('message') || output.includes('detail')) &&
-                (output.includes('code') || output.includes('type')) &&
-                (output.includes('400') || output.includes('401') || output.includes('500')));
-        },
-        difficulty: 'medium'
-    },
-    {
-        id: 'api-07',
-        name: 'Design File Upload API',
-        description: 'Design file upload endpoint with progress tracking and validation.',
-        domain: 'api-design',
-        input: `Design API for uploading large files (up to 100MB) with progress tracking.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return (output.includes('multipart') ||
-                output.includes('form-data') &&
-                    (output.includes('chunk') || output.includes('stream')) &&
-                    (output.includes('progress') || output.includes('status')));
-        },
-        difficulty: 'hard'
-    },
-    {
-        id: 'api-08',
-        name: 'Design Search and Filter API',
-        description: 'Design search and filtering API with multiple criteria and sorting.',
-        domain: 'api-design',
-        input: `Design search API for products with filtering by category, price range, and sorting options.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return ((output.includes('q=') || output.includes('query=') || output.includes('search=')) &&
-                (output.includes('filter') || output.includes('category')) &&
-                (output.includes('sort') || output.includes('order')));
-        },
-        difficulty: 'medium'
-    },
-    {
-        id: 'api-09',
-        name: 'Design Webhook API',
-        description: 'Design webhook system for real-time event notifications.',
-        domain: 'api-design',
-        input: `Design webhook API for notifying clients of order status changes.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return (output.includes('webhook') &&
-                (output.includes('event') || output.includes('payload')) &&
-                (output.includes('signature') || output.includes('verify') || output.includes('hmac')) &&
-                (output.includes('retry') || output.includes('callback')));
-        },
-        difficulty: 'hard'
-    },
-    {
-        id: 'api-10',
-        name: 'Design GraphQL Schema',
-        description: 'Design GraphQL schema for flexible data querying with types and resolvers.',
-        domain: 'api-design',
-        input: `Design GraphQL schema for blog system with posts, comments, and users.`,
-        successCriteria: (result) => {
-            const output = result.output.toLowerCase();
-            return (output.includes('type') &&
-                output.includes('query') &&
-                (output.includes('mutation') || output.includes('resolver')) &&
-                (output.includes('post') && output.includes('comment') && output.includes('user')));
-        },
-        difficulty: 'hard'
-    }
-];
-export const apiDesignTasksScenario = {
-    name: 'api-design-tasks',
-    description: 'Tests ability to design RESTful APIs and follow API best practices',
-    domain: 'api-design',
-    tasks,
-    metrics: [
-        'success_rate',
-        'token_efficiency',
-        'latency',
-        'memory_usage',
-        'learning_velocity'
-    ]
-};