SERVICES DOCUMENTATION

async executeWorkflow(
  input: WorkflowBenchmarkInput,
  aiOptions: AIOptions,
  streamingOptions?: StreamingOptions
): Promise<WorkflowBenchmarkResult["output"]>

const benchmarkInput = {
  collectedResponses: {
    projectName: "benchmark-test",
    initMethod: "ai",
    projectDescription: "AI-powered task management application",
    prdMethod: "ai",
    prdDescription: "Task management with AI assistance and collaboration features",
    generateTasks: true,
    splitTasks: true
  },
  tempDirBase: "/tmp"
};

const result = await workflowBenchmarkService.executeWorkflow(
  benchmarkInput,
  {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet"
  },
  {
    onChunk: (chunk) => console.log(`[BENCHMARK] ${chunk}`)
  }
);

console.log(`\nBenchmark completed:`);
console.log(`- Project: ${result.projectDir}`);
console.log(`- PRD size: ${result.stats.prdSize} chars`);
console.log(`- Tasks created: ${result.stats.totalTasks}`);
console.log(`- Tasks split: ${result.stats.tasksWithSubtasks}`);
console.log(`- Avg complexity: ${result.stats.avgTaskComplexity.toFixed(2)}`);
console.log(`- Success rate: ${result.stats.successfulSteps}/${result.stats.totalSteps}`);

console.log(`\nTimings:`);
console.log(`- Init: ${result.stats.initDuration}ms`);
console.log(`- PRD gen: ${result.stats.prdGenerationDuration}ms`);
console.log(`- Task gen: ${result.stats.taskGenerationDuration}ms`);
console.log(`- Splitting: ${result.stats.taskSplittingDuration}ms`);

console.log(`\nTotal duration: ${
  result.stats.initDuration +
  result.stats.prdGenerationDuration +
  result.stats.taskGenerationDuration +
  result.stats.taskSplittingDuration
}ms`);

const models = [
  { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet", name: "Claude 3.5 Sonnet" },
  { aiProvider: "openai", aiModel: "gpt-4o", name: "GPT-4o" },
  { aiProvider: "openrouter", aiModel: "anthropic/claude-3-opus", name: "Claude 3 Opus" }
];

const benchmarkInput = {
  collectedResponses: {
    projectName: "model-comparison",
    initMethod: "quick",
    prdMethod: "ai",
    prdDescription: "Real-time collaboration platform",
    generateTasks: true,
    splitTasks: true
  }
};

console.log("Running multi-model comparison benchmark...");
const results = await Promise.all(
  models.map(model => ({
    model,
    promise: workflowBenchmarkService.executeWorkflow(
      benchmarkInput,
      { aiProvider: model.aiProvider, aiModel: model.aiModel }
    ).then(result => ({ result, model }))
  }))
).then(promises => promises.map(p => p));

console.log("\n=== BENCHMARK RESULTS ===\n");

results.forEach(({ result, model }) => {
  const { stats } = result;
  const totalTime = stats.initDuration + stats.prdGenerationDuration + stats.taskGenerationDuration;

  console.log(`${model.name} (${model.aiProvider}/${model.aiModel}):`);
  console.log(`  Tasks: ${stats.totalTasks}`);
  console.log(`  Tasks Split: ${stats.tasksWithSubtasks}`);
  console.log(`  PRD Size: ${stats.prdSize} chars`);
  console.log(`  Complexity: ${stats.avgTaskComplexity.toFixed(2)}`);
  console.log(`  Duration: ${totalTime}ms`);
  console.log(`  Success: ${stats.successfulSteps}/${stats.totalSteps}`);
  console.log(`  Breakdown:`);
  console.log(`    - Init: ${stats.initDuration}ms`);
  console.log(`    - PRD: ${stats.prdGenerationDuration}ms`);
  console.log(`    - Tasks: ${stats.taskGenerationDuration}ms`);
  console.log(`    - Split: ${stats.taskSplittingDuration}ms`);
  console.log('');
});

// Find best model
const bestResult = results.reduce((best, current) => {
  const bestScore = calculateScore(best.result.stats);
  const currentScore = calculateScore(current.result.stats);
  return currentScore > bestScore ? current : best;
});

console.log(`\n🏆 Best Model: ${bestResult.model.name}`);
console.log(`   Score: ${calculateScore(bestResult.result.stats).toFixed(2)}`);

function calculateScore(stats) {
  const taskScore = stats.totalTasks * 10;
  const speedScore = 10000 / (stats.initDuration + stats.prdGenerationDuration);
  const successRate = stats.successfulSteps / stats.totalSteps;
  return taskScore + speedScore + (successRate * 1000);
}

const minimalResult = await workflowBenchmarkService.executeWorkflow(
  {
    collectedResponses: {
      projectName: "minimal",
      initMethod: "quick",
      prdMethod: "ai",
      prdDescription: "Simple todo app",
      generateTasks: true
    }
  },
  { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" }
);

console.log(`Created ${minimalResult.stats.totalTasks} tasks`);
console.log(`PRD: ${minimalResult.stats.prdSize} chars`);

async applyBenchmarkResult(
  selectedResult: WorkflowBenchmarkResult,
  targetProjectDir: string,
  originalResponses: WorkflowBenchmarkInput["collectedResponses"]
): Promise<{ success: boolean; message: string }>

// Assume we have benchmark results from multiple models
const benchmarkResults = [
  {
    modelId: "anthropic:claude-3-5-sonnet",
    output: claudeResult
  },
  {
    modelId: "openai:gpt-4o",
    output: gpt4Result
  },
  {
    modelId: "openrouter:anthropic/claude-3-opus",
    output: opusResult
  }
];

// Select best result based on custom criteria
const bestResult = benchmarkResults.reduce((best, current) => {
  const bestScore = calculateScore(best.output.stats);
  const currentScore = calculateScore(current.output.stats);
  return currentScore > bestScore ? current : best;
});

console.log(`\nSelected best model: ${bestResult.modelId}`);
console.log(`Score: ${calculateScore(bestResult.output.stats).toFixed(2)}`);

// Apply to actual project
const application = await workflowBenchmarkService.applyBenchmarkResult(
  bestResult,
  "./my-real-project",
  {
    projectName: "my-real-project",
    initMethod: "ai",
    projectDescription: "AI-powered development platform with code review and collaboration"
  }
);

if (application.success) {
  console.log(`\n✅ Successfully applied ${bestResult.modelId} results`);
  console.log(application.message);
  console.log(`\nProject initialized at: ./my-real-project`);
  console.log(`PRD: ./.task-o-matic/prd/prd.md`);
  console.log(`Tasks: ${bestResult.output.tasks.length} tasks imported`);
} else {
  console.error(`\n❌ Application failed: ${application.message}`);
}

function calculateScore(stats) {
  const taskScore = stats.totalTasks * 10;
  const speedScore = 10000 / (stats.initDuration + stats.prdGenerationDuration);
  const successRate = stats.successfulSteps / stats.totalSteps;
  return taskScore + speedScore + (successRate * 1000);
}

// Apply only PRD from benchmark, skip initialization
const selectiveApplication = await workflowBenchmarkService.applyBenchmarkResult(
  {
    modelId: "anthropic:claude-3-5-sonnet",
    output: {
      projectDir: "/tmp/benchmark-123",
      prdContent: "# My Project\n\nThis is the PRD...",
      tasks: [], // Empty tasks array
      stats: { /* stats */ }
    }
  },
  "./existing-project",
  {
    projectName: "existing-project",
    initMethod: "skip", // Skip initialization
    prdMethod: "ai",
    generateTasks: false
  }
);

console.log(selectiveApplication.message);

// Apply benchmark results to existing project directory
const application = await workflowBenchmarkService.applyBenchmarkResult(
  {
    modelId: "openai:gpt-4o",
    output: {
      prdContent: "# Enhanced PRD\n\nGenerated by GPT-4o...",
      tasks: [
        { id: "1", title: "Setup project", description: "Initial setup", parentId: null },
        { id: "2", title: "Implement API", description: "REST API", parentId: null }
      ],
      stats: { totalTasks: 2, /* other stats */ }
    }
  },
  "/path/to/existing/project",
  {
    projectName: "existing-project",
    initMethod: "quick",
    projectDescription: "Existing project getting PRD and tasks"
  }
);

if (application.success) {
  console.log("Applied benchmark to existing project");
  console.log("- PRD updated");
  console.log("- Tasks imported");
} else {
  console.error("Failed to apply to existing project:", application.message);
}

validateInput(input: any): input is WorkflowBenchmarkInput

import { workflowBenchmarkService } from '@task-o-matic/core';

// Parse user input from CLI or file
const userInput = JSON.parse(process.argv[2] || "{}");

if (workflowBenchmarkService.validateInput(userInput)) {
  console.log("✅ Valid benchmark input");
  console.log(`Project: ${userInput.collectedResponses.projectName}`);
  console.log(`Method: ${userInput.collectedResponses.initMethod}`);

  // TypeScript now knows userInput is WorkflowBenchmarkInput
  const result = await workflowBenchmarkService.executeWorkflow(
    userInput,
    { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet" }
  );
} else {
  console.error("❌ Invalid benchmark input format");
  console.error("Required fields:");
  console.error("- collectedResponses.projectName (string, non-empty)");
  console.error("- collectedResponses.initMethod ('quick' | 'custom' | 'ai')");
  process.exit(1);
}

// Valid inputs
console.log(workflowBenchmarkService.validateInput({
  collectedResponses: {
    projectName: "test-project",
    initMethod: "ai",
    projectDescription: "Test project"
  }
})); // true

console.log(workflowBenchmarkService.validateInput({
  collectedResponses: {
    projectName: "my-app",
    initMethod: "custom",
    stackConfig: { frontend: "react", backend: "express" }
  }
})); // true

// Invalid inputs
console.log(workflowBenchmarkService.validateInput(null)); // false
console.log(workflowBenchmarkService.validateInput({})); // false
console.log(workflowBenchmarkService.validateInput({
  collectedResponses: {}
})); // false
console.log(workflowBenchmarkService.validateInput({
  collectedResponses: {
    projectName: "", // Empty
    initMethod: "ai"
  }
})); // false
console.log(workflowBenchmarkService.validateInput({
  collectedResponses: {
    projectName: "test",
    initMethod: "invalid" // Not one of quick/custom/ai
  }
})); // false

/tmp/task-o-matic-benchmark/
└── benchmark-{projectName}-{provider}-{sanitizedModel}-{timestamp}/
    ├── .task-o-matic/
    │   ├── config.json              # AI configuration
    │   ├── tasks/                  # Task storage
    │   ├── prd/
    │   │   └── prd.md             # Generated PRD
    │   └── logs/                   # Execution logs
    ├── package.json                # Bootstrapped project
    ├── src/                       # Bootstrapped project source
    ├── [additional bootstrapped files]
    └── [generated PRD and tasks]

interface BenchmarkStats {
  // Timing metrics (all in milliseconds)
  initDuration: number;           // Project setup time
  prdGenerationDuration: number;  // PRD creation time
  prdRefinementDuration: number; // PRD improvement time (0 if skipped)
  taskGenerationDuration: number; // Task extraction time
  taskSplittingDuration: number; // Task breakdown time (0 if skipped)

  // Quality metrics
  totalTasks: number;           // Tasks created
  tasksWithSubtasks: number;    // Tasks split further
  avgTaskComplexity: number;   // Complexity score (1-3)
  prdSize: number;             // PRD character count

  // Success metrics
  totalSteps: number;           // Workflow steps attempted
  successfulSteps: number;      // Steps completed successfully
}

// Calculated from task description length
const complexity = taskDescription.length > 200 ? 3
  : taskDescription.length > 100 ? 2
  : 1;

// Average across all tasks
stats.avgTaskComplexity = totalComplexity / tasks.length;

const models = [
  {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet",
    name: "Claude 3.5 Sonnet",
    cost: 3.0,
    speed: "fast"
  },
  {
    aiProvider: "openai",
    aiModel: "gpt-4o",
    name: "GPT-4o",
    cost: 2.5,
    speed: "very-fast"
  },
  {
    aiProvider: "openrouter",
    aiModel: "anthropic/claude-3-opus",
    name: "Claude 3 Opus",
    cost: 5.0,
    speed: "medium"
  }
];

const benchmarkInput = {
  collectedResponses: {
    projectName: "model-comparison",
    initMethod: "ai",
    projectDescription: "AI-powered code review and collaboration platform with real-time editing, automated analysis, and team management",
    prdMethod: "ai",
    prdDescription: "Real-time code review with AI assistance, team collaboration, automated analysis, and integration with Git providers",
    generateTasks: true,
    splitTasks: true
  }
};

console.log("🚀 Running model comparison benchmark...\n");

const results = await Promise.all(
  models.map(async (model) => {
    console.log(`Testing ${model.name}...`);
    const startTime = Date.now();

    const result = await workflowBenchmarkService.executeWorkflow(
      benchmarkInput,
      { aiProvider: model.aiProvider, aiModel: model.aiModel }
    );

    const duration = Date.now() - startTime;
    console.log(`✓ ${model.name} completed in ${duration}ms\n`);

    return {
      model,
      result,
      duration,
      stats: result.stats,
      performanceScore: calculatePerformanceScore(result.stats, model)
    };
  })
);

console.log("\n=== BENCHMARK RESULTS ===\n");

// Display detailed results
results.forEach(({ model, stats, duration, performanceScore }) => {
  const totalTime = stats.initDuration + stats.prdGenerationDuration + stats.taskGenerationDuration;

  console.log(`📊 ${model.name} (${model.aiProvider}/${model.aiModel}):`);
  console.log(`   Tasks: ${stats.totalTasks}`);
  console.log(`   Tasks Split: ${stats.tasksWithSubtasks}`);
  console.log(`   PRD Size: ${stats.prdSize} chars`);
  console.log(`   Complexity: ${stats.avgTaskComplexity.toFixed(2)}`);
  console.log(`   Success Rate: ${stats.successfulSteps}/${stats.totalSteps} (${Math.round(stats.successfulSteps/stats.totalSteps*100)}%)`);
  console.log(`   Timings:`);
  console.log(`     - Init: ${stats.initDuration}ms`);
  console.log(`     - PRD: ${stats.prdGenerationDuration}ms`);
  console.log(`     - Tasks: ${stats.taskGenerationDuration}ms`);
  console.log(`     - Split: ${stats.taskSplittingDuration}ms`);
  console.log(`     - Total: ${totalTime}ms`);
  console.log(`   Cost: $${model.cost}/1M tokens`);
  console.log(`   Speed: ${model.speed}`);
  console.log(`   Performance Score: ${performanceScore.toFixed(2)}\n`);
});

// Select best model
const bestModel = results.reduce((best, current) =>
  current.performanceScore > best.performanceScore ? current : best
);

console.log(`🏆 Best Model: ${bestModel.model.name}`);
console.log(`   Score: ${bestModel.performanceScore.toFixed(2)}`);
console.log(`   Details: ${bestModel.model.aiProvider}/${bestModel.model.aiModel}`);
console.log(`   Cost: $${bestModel.model.cost}/1M tokens\n`);

// Apply best results to production project
console.log("Applying best model results to production project...");
const application = await workflowBenchmarkService.applyBenchmarkResult(
  {
    modelId: `${bestModel.model.aiProvider}:${bestModel.model.aiModel}`,
    output: bestModel.result
  },
  "./production-project",
  benchmarkInput.collectedResponses
);

console.log(application.message);

function calculatePerformanceScore(stats, model) {
  const taskScore = stats.totalTasks * 20;                    // More tasks = better
  const qualityScore = stats.avgTaskComplexity * 10;           // Higher complexity = better analysis
  const speedScore = 100000 / (stats.initDuration + stats.prdGenerationDuration + stats.taskGenerationDuration);
  const successRate = stats.successfulSteps / stats.totalSteps;
  const speedBonus = model.speed === "very-fast" ? 500 : model.speed === "fast" ? 300 : 100;
  const costPenalty = model.cost * 50; // Lower cost is better

  return taskScore + qualityScore + speedScore + (successRate * 5000) + speedBonus - costPenalty;
}

const testScenarios = [
  {
    name: "Simple Todo App",
    description: "Basic todo list application with categories and due dates",
    complexity: "low",
    expectedTasks: 5-10
  },
  {
    name: "E-commerce Platform",
    description: "Full-stack e-commerce platform with payment processing, inventory management, user accounts, and admin dashboard",
    complexity: "high",
    expectedTasks: 20-30
  },
  {
    name: "RESTful API Service",
    description: "RESTful API service with authentication, documentation, rate limiting, and comprehensive testing",
    complexity: "medium",
    expectedTasks: 10-15
  }
];

const model = { aiProvider: "anthropic", aiModel: "claude-3-5-sonnet", name: "Claude 3.5 Sonnet" };
const allResults = [];

console.log("🧪 Running scenario-based benchmark testing...\n");

for (const scenario of testScenarios) {
  console.log(`\n=== Testing: ${scenario.name} (${scenario.complexity} complexity) ===`);

  const benchmarkInput = {
    collectedResponses: {
      projectName: `test-${scenario.name.toLowerCase().replace(/\s+/g, '-')}`,
      initMethod: "ai",
      projectDescription: scenario.description,
      prdMethod: "ai",
      prdDescription: scenario.description,
      generateTasks: true,
      splitTasks: true
    }
  };

  const result = await workflowBenchmarkService.executeWorkflow(
    benchmarkInput,
    { aiProvider: model.aiProvider, aiModel: model.aiModel }
  );

  const { stats } = result;
  const totalTime = stats.initDuration + stats.prdGenerationDuration + stats.taskGenerationDuration;

  console.log(`\nResults for ${scenario.name}:`);
  console.log(`  Tasks Created: ${stats.totalTasks}`);
  console.log(`  Expected: ${scenario.expectedTasks}`);
  console.log(`  Match: ${stats.totalTasks >= scenario.expectedTasks.min && stats.totalTasks <= scenario.expectedTasks.max ? '✓' : '✗'}`);
  console.log(`  PRD Size: ${stats.prdSize} chars`);
  console.log(`  Total Time: ${totalTime}ms`);
  console.log(`  Success Rate: ${Math.round(stats.successfulSteps/stats.totalSteps*100)}%`);
  console.log(`  Avg Complexity: ${stats.avgTaskComplexity.toFixed(2)}`);

  allResults.push({ scenario, model, stats, totalTime, result });

  // Save detailed results
  const filename = `./benchmark-results-${scenario.name.toLowerCase().replace(/\s+/g, '-')}.json`;
  await fs.writeFile(filename, JSON.stringify({
    scenario,
    model: model.name,
    stats,
    result: {
      prdContent: result.prdContent.substring(0, 500) + "...", // Truncate for storage
      tasks: result.tasks.map(t => ({ id: t.id, title: t.title }))
    }
  }, null, 2));
  console.log(`  Results saved: ${filename}`);
}

// Summary report
console.log("\n\n=== SUMMARY REPORT ===\n");
console.log(`Model Tested: ${model.name}`);
console.log(`Total Scenarios: ${testScenarios.length}`);

allResults.forEach(({ scenario, stats, totalTime }) => {
  const score = calculateScenarioScore(stats, totalTime);
  console.log(`\n${scenario.name}:`);
  console.log(`  Tasks: ${stats.totalTasks} (Score: ${stats.totalTasks * 10})`);
  console.log(`  Complexity: ${stats.avgTaskComplexity.toFixed(2)} (Score: ${stats.avgTaskComplexity * 10})`);
  console.log(`  Time: ${totalTime}ms (Score: ${Math.round(10000/totalTime)})`);
  console.log(`  Success: ${Math.round(stats.successfulSteps/stats.totalSteps*100)}%`);
  console.log(`  Total Score: ${score.toFixed(2)}`);
});

function calculateScenarioScore(stats, totalTime) {
  return (stats.totalTasks * 10) +
         (stats.avgTaskComplexity * 10) +
         (10000 / totalTime) +
         ((stats.successfulSteps / stats.totalSteps) * 500);
}

// Comprehensive benchmark before production deployment
const productionCandidates = [
  {
    aiProvider: "anthropic",
    aiModel: "claude-3-5-sonnet",
    name: "Claude 3.5 Sonnet",
    cost: 3.0,
    speed: "fast",
    reliability: "high"
  },
  {
    aiProvider: "openai",
    aiModel: "gpt-4o",
    name: "GPT-4o",
    cost: 2.5,
    speed: "very-fast",
    reliability: "high"
  },
  {
    aiProvider: "openrouter",
    aiModel: "anthropic/claude-3-haiku",
    name: "Claude 3 Haiku",
    cost: 0.25,
    speed: "very-fast",
    reliability: "medium"
  }
];

const productionScenario = {
  collectedResponses: {
    projectName: "production-app",
    initMethod: "ai",
    projectDescription: "Customer support chatbot with knowledge base integration, multi-channel support, and natural language processing",
    prdMethod: "ai",
    prdDescription: "AI-powered customer support with NLP, knowledge base search, live chat, email support, and analytics dashboard",
    generateTasks: true,
    splitTasks: true
  }
};

console.log("🏭 Running production model selection benchmark...\n");

const benchmarkResults = await Promise.all(
  productionCandidates.map(async (candidate) => {
    console.log(`Testing ${candidate.name} ($${candidate.cost}/1M tokens)...`);

    const result = await workflowBenchmarkService.executeWorkflow(
      productionScenario,
      { aiProvider: candidate.aiProvider, aiModel: candidate.aiModel }
    );

    const performanceScore = calculateProductionScore(result.stats, candidate);

    console.log(`✓ Completed - Score: ${performanceScore.toFixed(2)}\n`);

    return {
      ...candidate,
      result,
      stats: result.stats,
      performanceScore
    };
  })
);

// Production-optimized selection
const productionChoice = benchmarkResults.reduce((best, current) =>
  current.performanceScore > best.performanceScore ? current : best
);

console.log("\n=== PRODUCTION SELECTION ===");
console.log(`\n🎯 Selected Model: ${productionChoice.name}`);
console.log(`   Provider: ${productionChoice.aiProvider}`);
console.log(`   Model: ${productionChoice.aiModel}`);
console.log(`   Performance Score: ${productionChoice.performanceScore.toFixed(2)}`);
console.log(`   Cost: $${productionChoice.cost}/1M tokens`);
console.log(`   Speed: ${productionChoice.speed}`);
console.log(`   Reliability: ${productionChoice.reliability}`);

// Score breakdown
console.log(`\n📊 Score Breakdown:`);
console.log(`   Reliability: ${((productionChoice.stats.successfulSteps / productionChoice.stats.totalSteps) * 1000).toFixed(2)}`);
console.log(`   Productivity: ${(productionChoice.stats.totalTasks * 25).toFixed(2)}`);
console.log(`   Quality: ${(productionChoice.stats.avgTaskComplexity * 15).toFixed(2)}`);
console.log(`   Speed: ${(productionChoice.speed === "very-fast" ? 500 : productionChoice.speed === "fast" ? 300 : 100).toFixed(2)}`);
console.log(`   Cost Penalty: ${(productionChoice.cost * 100).toFixed(2)}`);

console.log("\n🚀 Applying to production project...\n");

const productionApplication = await workflowBenchmarkService.applyBenchmarkResult(
  {
    modelId: `${productionChoice.aiProvider}:${productionChoice.aiModel}`,
    output: productionChoice.result
  },
  "./production-customer-support",
  productionScenario.collectedResponses
);

if (productionApplication.success) {
  console.log("✅ Production project setup complete");
  console.log(productionApplication.message);
  console.log(`\nNext steps:`);
  console.log(`1. Review PRD at ./production-customer-support/.task-o-matic/prd/prd.md`);
  console.log(`2. Check task list: \`bun run task list\``);
  console.log(`3. Start development: \`bun run task execute\``);
} else {
  console.error("❌ Production setup failed:", productionApplication.message);
}

function calculateProductionScore(stats, candidate) {
  // Production-optimized scoring
  const reliabilityScore = (stats.successfulSteps / stats.totalSteps) * 1000;
  const productivityScore = stats.totalTasks * 25;
  const qualityScore = stats.avgTaskComplexity * 15;
  const speedScore = candidate.speed === "very-fast" ? 500 : candidate.speed === "fast" ? 300 : 100;
  const costPenalty = candidate.cost * 100; // Lower cost is better

  return reliabilityScore + productivityScore + qualityScore + speedScore - costPenalty;
}

// Temp directory creation
private createTempProjectDir(tempBase: string, projectName: string, provider: string, model: string): string {
  const sanitizedModel = model.replace(/[^a-zA-Z0-9-]/g, "-");
  const dirName = `benchmark-${projectName}-${provider}-${sanitizedModel}-${Date.now()}`;
  const tempDir = join(tempBase, "task-o-matic-benchmark", dirName);

  if (!existsSync(tempDir)) {
    mkdirSync(tempDir, { recursive: true });
  }

  return tempDir;
}

// High-resolution timing with Date.now()
const stepStart = Date.now();
await workflowService.someOperation();
stats.duration = Date.now() - stepStart;

// Step-by-step duration tracking
stats.initDuration = Date.now() - stepStart;
stats.prdGenerationDuration = Date.now() - prdStart;
stats.taskGenerationDuration = Date.now() - tasksStart;

// Calculate complexity based on description length
if (tasks.length > 0) {
  const totalComplexity = tasks.reduce((sum, task) => {
    const contentLength = (task.description || "").length;
    return sum + (contentLength > 200 ? 3 : contentLength > 100 ? 2 : 1);
  }, 0);
  stats.avgTaskComplexity = totalComplexity / tasks.length;
}

// Non-fatal error handling during cleanup
private cleanupTempProjectDir(projectDir: string): void {
  try {
    if (existsSync(projectDir) && projectDir.includes("task-o-matic-benchmark")) {
      rmSync(projectDir, { recursive: true, force: true });
    }
  } catch (error) {
    logger.warn(`Warning: Could not clean up temp directory ${projectDir}`);
  }
}

// Safe temp directory cleanup
// Only removes directories containing "task-o-matic-benchmark"
if (projectDir.includes("task-o-matic-benchmark")) {
  rmSync(projectDir, { recursive: true, force: true });
}

// Extract provider and model from modelId
const [provider, model] = selectedResult.modelId.split(":").slice(0, 2);
// Example: "anthropic:claude-3-5-sonnet:extended"
//   provider = "anthropic"
//   model = "claude-3-5-sonnet"

// Continue importing even if some tasks fail
for (const task of selectedResult.output.tasks) {
  try {
    await getStorage().createTask({ /* task data */ });
  } catch (error) {
    logger.warn(`Warning: Could not import task "${task.title}"`);
    // Continue with next task
  }
}