Remove directives for reimplementation

1 files changed, 0 insertions, 833 deletions

diff --git a/makima/src/orchestration/verifier.rs b/makima/src/orchestration/verifier.rs
deleted file mode 100644
index bc29e47..0000000
--- a/makima/src/orchestration/verifier.rs
+++ /dev/null
@@ -1,833 +0,0 @@
-//! Verification system for directive step evaluation.
-//!
-//! Provides tiered verification: programmatic verifiers run first,
-//! then LLM evaluation if programmatic checks pass. Composite scoring
-//! combines results with configurable weights.
-
-use async_trait::async_trait;
-use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
-use std::path::Path;
-use thiserror::Error;
-use uuid::Uuid;
-
-/// Confidence level based on composite score and thresholds.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ConfidenceLevel {
-    /// High confidence (score >= green threshold)
-    Green,
-    /// Medium confidence (score >= yellow threshold but < green)
-    Yellow,
-    /// Low confidence (score < yellow threshold)
-    Red,
-}
-
-impl ConfidenceLevel {
-    /// Compute confidence level from score and thresholds.
-    pub fn from_score(score: f64, green_threshold: f64, yellow_threshold: f64) -> Self {
-        if score >= green_threshold {
-            ConfidenceLevel::Green
-        } else if score >= yellow_threshold {
-            ConfidenceLevel::Yellow
-        } else {
-            ConfidenceLevel::Red
-        }
-    }
-
-    /// Convert to string for database storage.
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            ConfidenceLevel::Green => "green",
-            ConfidenceLevel::Yellow => "yellow",
-            ConfidenceLevel::Red => "red",
-        }
-    }
-}
-
-impl std::fmt::Display for ConfidenceLevel {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-/// Type of verifier for categorization.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum VerifierType {
-    /// Run test suite (npm test, cargo test, pytest, etc.)
-    TestRunner,
-    /// Run linter (eslint, clippy, ruff, etc.)
-    Linter,
-    /// Run type checker (tsc, mypy, etc.)
-    TypeChecker,
-    /// Run build command (npm build, cargo build, etc.)
-    Build,
-    /// Custom command verifier
-    Custom,
-    /// LLM-based semantic evaluation
-    Llm,
-}
-
-impl VerifierType {
-    pub fn as_str(&self) -> &'static str {
-        match self {
-            VerifierType::TestRunner => "test_runner",
-            VerifierType::Linter => "linter",
-            VerifierType::TypeChecker => "type_checker",
-            VerifierType::Build => "build",
-            VerifierType::Custom => "custom",
-            VerifierType::Llm => "llm",
-        }
-    }
-}
-
-/// Result of a single verifier run.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct VerifierResult {
-    /// Name of the verifier
-    pub name: String,
-    /// Type of verifier
-    pub verifier_type: VerifierType,
-    /// Whether the verification passed
-    pub passed: bool,
-    /// Score from 0.0 to 1.0 (1.0 = perfect, 0.0 = complete failure)
-    pub score: f64,
-    /// Weight for composite scoring (default 1.0 for programmatic, 2.0 for LLM)
-    pub weight: f64,
-    /// Whether this verifier is required (failure = automatic red confidence)
-    pub required: bool,
-    /// Human-readable output/feedback
-    pub output: String,
-    /// Structured details (test counts, lint errors, etc.)
-    pub details: Option<JsonValue>,
-    /// Execution time in milliseconds
-    pub duration_ms: u64,
-}
-
-impl VerifierResult {
-    /// Create a passed result with full score.
-    pub fn passed(name: String, verifier_type: VerifierType, output: String) -> Self {
-        Self {
-            name,
-            verifier_type,
-            passed: true,
-            score: 1.0,
-            weight: 1.0,
-            required: false,
-            output,
-            details: None,
-            duration_ms: 0,
-        }
-    }
-
-    /// Create a failed result with zero score.
-    pub fn failed(name: String, verifier_type: VerifierType, output: String) -> Self {
-        Self {
-            name,
-            verifier_type,
-            passed: false,
-            score: 0.0,
-            weight: 1.0,
-            required: false,
-            output,
-            details: None,
-            duration_ms: 0,
-        }
-    }
-
-    /// Set the weight for this result.
-    pub fn with_weight(mut self, weight: f64) -> Self {
-        self.weight = weight;
-        self
-    }
-
-    /// Mark this verifier as required.
-    pub fn as_required(mut self) -> Self {
-        self.required = true;
-        self
-    }
-
-    /// Set the score explicitly.
-    pub fn with_score(mut self, score: f64) -> Self {
-        self.score = score.clamp(0.0, 1.0);
-        self
-    }
-
-    /// Set structured details.
-    pub fn with_details(mut self, details: JsonValue) -> Self {
-        self.details = Some(details);
-        self
-    }
-
-    /// Set execution duration.
-    pub fn with_duration(mut self, duration_ms: u64) -> Self {
-        self.duration_ms = duration_ms;
-        self
-    }
-}
-
-/// Composite evaluation result combining multiple verifier results.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct EvaluationResult {
-    /// Unique ID for this evaluation
-    pub id: Uuid,
-    /// Step ID being evaluated
-    pub step_id: Uuid,
-    /// Whether all required verifiers passed
-    pub passed: bool,
-    /// Weighted composite score (0.0-1.0)
-    pub composite_score: f64,
-    /// Confidence level derived from score
-    pub confidence_level: ConfidenceLevel,
-    /// Individual verifier results
-    pub verifier_results: Vec<VerifierResult>,
-    /// Summary feedback for the step
-    pub summary: String,
-    /// Rework instructions if failed
-    pub rework_instructions: Option<String>,
-    /// Total evaluation duration in milliseconds
-    pub total_duration_ms: u64,
-}
-
-impl EvaluationResult {
-    /// Create a new evaluation result from verifier results.
-    pub fn from_verifiers(
-        step_id: Uuid,
-        results: Vec<VerifierResult>,
-        green_threshold: f64,
-        yellow_threshold: f64,
-    ) -> Self {
-        let id = Uuid::new_v4();
-
-        // Check if any required verifier failed
-        let any_required_failed = results.iter().any(|r| r.required && !r.passed);
-
-        // Calculate weighted composite score
-        let (total_weighted_score, total_weight) =
-            results
-                .iter()
-                .fold((0.0, 0.0), |(score_acc, weight_acc), r| {
-                    (score_acc + r.score * r.weight, weight_acc + r.weight)
-                });
-
-        let composite_score = if total_weight > 0.0 {
-            total_weighted_score / total_weight
-        } else {
-            0.0
-        };
-
-        // Override confidence to red if any required verifier failed
-        let confidence_level = if any_required_failed {
-            ConfidenceLevel::Red
-        } else {
-            ConfidenceLevel::from_score(composite_score, green_threshold, yellow_threshold)
-        };
-
-        let passed = !any_required_failed && confidence_level != ConfidenceLevel::Red;
-
-        // Generate summary
-        let passed_count = results.iter().filter(|r| r.passed).count();
-        let total_count = results.len();
-        let summary = format!(
-            "{}/{} verifiers passed, composite score: {:.2}, confidence: {}",
-            passed_count, total_count, composite_score, confidence_level
-        );
-
-        // Generate rework instructions if failed
-        let rework_instructions = if !passed {
-            let failed_verifiers: Vec<&str> = results
-                .iter()
-                .filter(|r| !r.passed)
-                .map(|r| r.name.as_str())
-                .collect();
-            Some(format!(
-                "Fix issues identified by: {}",
-                failed_verifiers.join(", ")
-            ))
-        } else {
-            None
-        };
-
-        let total_duration_ms = results.iter().map(|r| r.duration_ms).sum();
-
-        Self {
-            id,
-            step_id,
-            passed,
-            composite_score,
-            confidence_level,
-            verifier_results: results,
-            summary,
-            rework_instructions,
-            total_duration_ms,
-        }
-    }
-}
-
-/// Error type for verification operations.
-#[derive(Error, Debug)]
-pub enum VerifierError {
-    #[error("Command execution failed: {0}")]
-    CommandFailed(String),
-
-    #[error("Command timed out after {0}ms")]
-    Timeout(u64),
-
-    #[error("Working directory not found: {0}")]
-    WorkingDirectoryNotFound(String),
-
-    #[error("Verifier not configured: {0}")]
-    NotConfigured(String),
-
-    #[error("Parse error: {0}")]
-    ParseError(String),
-
-    #[error("LLM error: {0}")]
-    LlmError(String),
-
-    #[error("IO error: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-/// Information about a verifier for serialization and database storage.
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct VerifierInfo {
-    pub name: String,
-    pub verifier_type: String,
-    pub command: String,
-    pub working_directory: Option<String>,
-    pub detect_files: Vec<String>,
-    pub weight: f64,
-    pub required: bool,
-}
-
-/// Verifier trait for pluggable verification implementations.
-#[async_trait]
-pub trait Verifier: Send + Sync {
-    /// Get the name of this verifier.
-    fn name(&self) -> &str;
-
-    /// Get the type of this verifier.
-    fn verifier_type(&self) -> VerifierType;
-
-    /// Get serializable info about this verifier.
-    fn info(&self) -> VerifierInfo;
-
-    /// Check if this verifier is applicable to the given repository.
-    async fn is_applicable(&self, repo_path: &Path) -> bool;
-
-    /// Run verification and return result.
-    async fn verify(&self, repo_path: &Path, context: &VerificationContext)
-        -> Result<VerifierResult, VerifierError>;
-}
-
-/// Context provided to verifiers during execution.
-#[derive(Debug, Clone)]
-pub struct VerificationContext {
-    /// Step ID being verified
-    pub step_id: Uuid,
-    /// Contract ID if step has been instantiated
-    pub contract_id: Option<Uuid>,
-    /// Files that were modified in this step
-    pub modified_files: Vec<String>,
-    /// Step description for LLM context
-    pub step_description: String,
-    /// Acceptance criteria for LLM evaluation
-    pub acceptance_criteria: Vec<String>,
-    /// Additional context from directive
-    pub directive_context: String,
-}
-
-/// Command-based verifier for running shell commands.
-pub struct CommandVerifier {
-    name: String,
-    verifier_type: VerifierType,
-    command: String,
-    #[allow(dead_code)]
-    working_dir: Option<String>,
-    #[allow(dead_code)]
-    timeout_ms: u64,
-    required: bool,
-    /// Files/patterns that indicate this verifier is applicable
-    applicable_patterns: Vec<String>,
-}
-
-impl CommandVerifier {
-    /// Create a new command verifier.
-    pub fn new(
-        name: impl Into<String>,
-        verifier_type: VerifierType,
-        command: impl Into<String>,
-    ) -> Self {
-        Self {
-            name: name.into(),
-            verifier_type,
-            command: command.into(),
-            working_dir: None,
-            timeout_ms: 300_000, // 5 minute default
-            required: false,
-            applicable_patterns: Vec::new(),
-        }
-    }
-
-    /// Set the working directory.
-    #[allow(dead_code)]
-    pub fn with_working_dir(mut self, dir: impl Into<String>) -> Self {
-        self.working_dir = Some(dir.into());
-        self
-    }
-
-    /// Set the timeout in milliseconds.
-    #[allow(dead_code)]
-    pub fn with_timeout(mut self, timeout_ms: u64) -> Self {
-        self.timeout_ms = timeout_ms;
-        self
-    }
-
-    /// Mark as required verifier.
-    pub fn as_required(mut self) -> Self {
-        self.required = true;
-        self
-    }
-
-    /// Add applicability patterns (files that must exist).
-    pub fn with_patterns(mut self, patterns: Vec<String>) -> Self {
-        self.applicable_patterns = patterns;
-        self
-    }
-}
-
-#[async_trait]
-impl Verifier for CommandVerifier {
-    fn name(&self) -> &str {
-        &self.name
-    }
-
-    fn verifier_type(&self) -> VerifierType {
-        self.verifier_type.clone()
-    }
-
-    fn info(&self) -> VerifierInfo {
-        VerifierInfo {
-            name: self.name.clone(),
-            verifier_type: self.verifier_type.as_str().to_string(),
-            command: self.command.clone(),
-            working_directory: self.working_dir.clone(),
-            detect_files: self.applicable_patterns.clone(),
-            weight: 1.0,
-            required: self.required,
-        }
-    }
-
-    async fn is_applicable(&self, repo_path: &Path) -> bool {
-        if self.applicable_patterns.is_empty() {
-            return true;
-        }
-
-        for pattern in &self.applicable_patterns {
-            let check_path = repo_path.join(pattern);
-            if check_path.exists() {
-                return true;
-            }
-        }
-        false
-    }
-
-    async fn verify(
-        &self,
-        repo_path: &Path,
-        _context: &VerificationContext,
-    ) -> Result<VerifierResult, VerifierError> {
-        let start = std::time::Instant::now();
-
-        let work_dir = self
-            .working_dir
-            .as_ref()
-            .map(|d| repo_path.join(d))
-            .unwrap_or_else(|| repo_path.to_path_buf());
-
-        if !work_dir.exists() {
-            return Err(VerifierError::WorkingDirectoryNotFound(
-                work_dir.display().to_string(),
-            ));
-        }
-
-        // Parse command into program and args
-        let parts: Vec<&str> = self.command.split_whitespace().collect();
-        if parts.is_empty() {
-            return Err(VerifierError::CommandFailed(
-                "Empty command".to_string(),
-            ));
-        }
-
-        let program = parts[0];
-        let args = &parts[1..];
-
-        // Execute command
-        let output = tokio::process::Command::new(program)
-            .args(args)
-            .current_dir(&work_dir)
-            .output()
-            .await?;
-
-        let duration_ms = start.elapsed().as_millis() as u64;
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        let combined_output = format!("{}\n{}", stdout, stderr);
-
-        let passed = output.status.success();
-        let score = if passed { 1.0 } else { 0.0 };
-
-        let mut result = VerifierResult {
-            name: self.name.clone(),
-            verifier_type: self.verifier_type.clone(),
-            passed,
-            score,
-            weight: 1.0,
-            required: self.required,
-            output: combined_output,
-            details: Some(serde_json::json!({
-                "exit_code": output.status.code(),
-                "command": self.command,
-                "working_dir": work_dir.display().to_string(),
-            })),
-            duration_ms,
-        };
-
-        // Try to extract more detailed scoring from output
-        result = self.enhance_result(result, &stdout);
-
-        Ok(result)
-    }
-}
-
-impl CommandVerifier {
-    /// Enhance result with parsed details from output.
-    fn enhance_result(&self, mut result: VerifierResult, stdout: &str) -> VerifierResult {
-        match self.verifier_type {
-            VerifierType::TestRunner => {
-                // Try to parse test counts from common formats
-                if let Some((passed, failed, total)) = parse_test_output(stdout) {
-                    result.details = Some(serde_json::json!({
-                        "tests_passed": passed,
-                        "tests_failed": failed,
-                        "tests_total": total,
-                        "command": self.command,
-                    }));
-                    if total > 0 {
-                        result.score = passed as f64 / total as f64;
-                    }
-                }
-            }
-            VerifierType::Linter => {
-                // Try to parse lint error counts
-                if let Some(error_count) = parse_lint_output(stdout) {
-                    result.details = Some(serde_json::json!({
-                        "errors": error_count,
-                        "command": self.command,
-                    }));
-                    // Score decreases with more errors (up to 10 errors = 0)
-                    result.score = (1.0 - (error_count as f64 / 10.0)).max(0.0);
-                }
-            }
-            _ => {}
-        }
-        result
-    }
-}
-
-/// Parse test output for common formats (Jest, pytest, cargo test).
-fn parse_test_output(output: &str) -> Option<(u32, u32, u32)> {
-    // Jest format: "Tests: X passed, Y failed, Z total"
-    if let Some(caps) = regex::Regex::new(r"Tests:\s*(\d+)\s*passed,\s*(\d+)\s*failed,\s*(\d+)\s*total")
-        .ok()?
-        .captures(output)
-    {
-        let passed: u32 = caps.get(1)?.as_str().parse().ok()?;
-        let failed: u32 = caps.get(2)?.as_str().parse().ok()?;
-        let total: u32 = caps.get(3)?.as_str().parse().ok()?;
-        return Some((passed, failed, total));
-    }
-
-    // pytest format: "X passed, Y failed"
-    if let Some(caps) = regex::Regex::new(r"(\d+)\s*passed(?:,\s*(\d+)\s*failed)?")
-        .ok()?
-        .captures(output)
-    {
-        let passed: u32 = caps.get(1)?.as_str().parse().ok()?;
-        let failed: u32 = caps.get(2).map(|m| m.as_str().parse().ok()).flatten().unwrap_or(0);
-        let total = passed + failed;
-        return Some((passed, failed, total));
-    }
-
-    // cargo test format: "test result: ok. X passed; Y failed;"
-    if let Some(caps) = regex::Regex::new(r"test result:.*?(\d+)\s*passed;\s*(\d+)\s*failed")
-        .ok()?
-        .captures(output)
-    {
-        let passed: u32 = caps.get(1)?.as_str().parse().ok()?;
-        let failed: u32 = caps.get(2)?.as_str().parse().ok()?;
-        let total = passed + failed;
-        return Some((passed, failed, total));
-    }
-
-    None
-}
-
-/// Parse lint output for error counts.
-fn parse_lint_output(output: &str) -> Option<u32> {
-    // ESLint format: "X problems (Y errors, Z warnings)"
-    if let Some(caps) = regex::Regex::new(r"(\d+)\s*problems?\s*\((\d+)\s*errors?")
-        .ok()?
-        .captures(output)
-    {
-        return caps.get(2)?.as_str().parse().ok();
-    }
-
-    // Clippy format: "warning: X warnings emitted"
-    if let Some(caps) = regex::Regex::new(r"warning:\s*(\d+)\s*warnings?\s*emitted")
-        .ok()?
-        .captures(output)
-    {
-        return caps.get(1)?.as_str().parse().ok();
-    }
-
-    None
-}
-
-/// Auto-detect applicable verifiers for a repository.
-pub async fn auto_detect_verifiers(repo_path: &Path) -> Vec<Box<dyn Verifier>> {
-    let mut verifiers: Vec<Box<dyn Verifier>> = Vec::new();
-
-    // Check for package.json (Node.js)
-    let package_json = repo_path.join("package.json");
-    if package_json.exists() {
-        if let Ok(content) = tokio::fs::read_to_string(&package_json).await {
-            if let Ok(pkg) = serde_json::from_str::<serde_json::Value>(&content) {
-                if let Some(scripts) = pkg.get("scripts").and_then(|s| s.as_object()) {
-                    // Test runner
-                    if scripts.contains_key("test") {
-                        verifiers.push(Box::new(
-                            CommandVerifier::new("npm-test", VerifierType::TestRunner, "npm test")
-                                .with_patterns(vec!["package.json".to_string()])
-                                .as_required(),
-                        ));
-                    }
-
-                    // Linter
-                    if scripts.contains_key("lint") {
-                        verifiers.push(Box::new(
-                            CommandVerifier::new("npm-lint", VerifierType::Linter, "npm run lint")
-                                .with_patterns(vec!["package.json".to_string()]),
-                        ));
-                    }
-
-                    // Build
-                    if scripts.contains_key("build") {
-                        verifiers.push(Box::new(
-                            CommandVerifier::new("npm-build", VerifierType::Build, "npm run build")
-                                .with_patterns(vec!["package.json".to_string()])
-                                .as_required(),
-                        ));
-                    }
-
-                    // Type check (for TypeScript projects)
-                    if scripts.contains_key("typecheck") || scripts.contains_key("type-check") {
-                        let cmd = if scripts.contains_key("typecheck") {
-                            "npm run typecheck"
-                        } else {
-                            "npm run type-check"
-                        };
-                        verifiers.push(Box::new(
-                            CommandVerifier::new("npm-typecheck", VerifierType::TypeChecker, cmd)
-                                .with_patterns(vec!["tsconfig.json".to_string()]),
-                        ));
-                    }
-                }
-            }
-        }
-    }
-
-    // Check for Cargo.toml (Rust)
-    let cargo_toml = repo_path.join("Cargo.toml");
-    if cargo_toml.exists() {
-        verifiers.push(Box::new(
-            CommandVerifier::new("cargo-test", VerifierType::TestRunner, "cargo test")
-                .with_patterns(vec!["Cargo.toml".to_string()])
-                .as_required(),
-        ));
-
-        verifiers.push(Box::new(
-            CommandVerifier::new("cargo-clippy", VerifierType::Linter, "cargo clippy -- -D warnings")
-                .with_patterns(vec!["Cargo.toml".to_string()]),
-        ));
-
-        verifiers.push(Box::new(
-            CommandVerifier::new("cargo-build", VerifierType::Build, "cargo build")
-                .with_patterns(vec!["Cargo.toml".to_string()])
-                .as_required(),
-        ));
-    }
-
-    // Check for pyproject.toml or setup.py (Python)
-    let pyproject = repo_path.join("pyproject.toml");
-    let setup_py = repo_path.join("setup.py");
-    if pyproject.exists() || setup_py.exists() {
-        verifiers.push(Box::new(
-            CommandVerifier::new("pytest", VerifierType::TestRunner, "pytest")
-                .with_patterns(vec![
-                    "pyproject.toml".to_string(),
-                    "setup.py".to_string(),
-                ])
-                .as_required(),
-        ));
-
-        verifiers.push(Box::new(
-            CommandVerifier::new("ruff", VerifierType::Linter, "ruff check .")
-                .with_patterns(vec!["pyproject.toml".to_string()]),
-        ));
-    }
-
-    verifiers
-}
-
-/// Composite evaluator that runs multiple verifiers and combines results.
-pub struct CompositeEvaluator {
-    verifiers: Vec<Box<dyn Verifier>>,
-    green_threshold: f64,
-    yellow_threshold: f64,
-}
-
-impl CompositeEvaluator {
-    /// Create a new composite evaluator with default thresholds.
-    pub fn new(verifiers: Vec<Box<dyn Verifier>>) -> Self {
-        Self {
-            verifiers,
-            green_threshold: 0.8,
-            yellow_threshold: 0.5,
-        }
-    }
-
-    /// Set confidence thresholds.
-    pub fn with_thresholds(mut self, green: f64, yellow: f64) -> Self {
-        self.green_threshold = green;
-        self.yellow_threshold = yellow;
-        self
-    }
-
-    /// Add a verifier.
-    pub fn add_verifier(mut self, verifier: Box<dyn Verifier>) -> Self {
-        self.verifiers.push(verifier);
-        self
-    }
-
-    /// Run all applicable verifiers and return composite result.
-    pub async fn evaluate(
-        &self,
-        repo_path: &Path,
-        context: &VerificationContext,
-    ) -> EvaluationResult {
-        let mut results = Vec::new();
-
-        for verifier in &self.verifiers {
-            if !verifier.is_applicable(repo_path).await {
-                continue;
-            }
-
-            match verifier.verify(repo_path, context).await {
-                Ok(result) => results.push(result),
-                Err(e) => {
-                    // Convert error to failed result
-                    results.push(VerifierResult::failed(
-                        verifier.name().to_string(),
-                        verifier.verifier_type(),
-                        format!("Verifier error: {}", e),
-                    ));
-                }
-            }
-        }
-
-        EvaluationResult::from_verifiers(
-            context.step_id,
-            results,
-            self.green_threshold,
-            self.yellow_threshold,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_confidence_level_from_score() {
-        assert_eq!(
-            ConfidenceLevel::from_score(0.9, 0.8, 0.5),
-            ConfidenceLevel::Green
-        );
-        assert_eq!(
-            ConfidenceLevel::from_score(0.8, 0.8, 0.5),
-            ConfidenceLevel::Green
-        );
-        assert_eq!(
-            ConfidenceLevel::from_score(0.6, 0.8, 0.5),
-            ConfidenceLevel::Yellow
-        );
-        assert_eq!(
-            ConfidenceLevel::from_score(0.5, 0.8, 0.5),
-            ConfidenceLevel::Yellow
-        );
-        assert_eq!(
-            ConfidenceLevel::from_score(0.4, 0.8, 0.5),
-            ConfidenceLevel::Red
-        );
-    }
-
-    #[test]
-    fn test_evaluation_result_composite_score() {
-        let results = vec![
-            VerifierResult::passed("test1".into(), VerifierType::TestRunner, "OK".into())
-                .with_weight(1.0),
-            VerifierResult::failed("test2".into(), VerifierType::Linter, "Failed".into())
-                .with_weight(1.0),
-        ];
-
-        let eval = EvaluationResult::from_verifiers(Uuid::new_v4(), results, 0.8, 0.5);
-        assert!((eval.composite_score - 0.5).abs() < 0.001);
-        assert_eq!(eval.confidence_level, ConfidenceLevel::Yellow);
-    }
-
-    #[test]
-    fn test_required_verifier_override() {
-        let results = vec![
-            VerifierResult::passed("test1".into(), VerifierType::TestRunner, "OK".into()),
-            VerifierResult::failed("build".into(), VerifierType::Build, "Failed".into())
-                .as_required(),
-        ];
-
-        let eval = EvaluationResult::from_verifiers(Uuid::new_v4(), results, 0.8, 0.5);
-        // Even though composite score is 0.5, required failure overrides to red
-        assert_eq!(eval.confidence_level, ConfidenceLevel::Red);
-        assert!(!eval.passed);
-    }
-
-    #[test]
-    fn test_parse_test_output_jest() {
-        let output = "Tests: 10 passed, 2 failed, 12 total";
-        let (passed, failed, total) = parse_test_output(output).unwrap();
-        assert_eq!(passed, 10);
-        assert_eq!(failed, 2);
-        assert_eq!(total, 12);
-    }
-
-    #[test]
-    fn test_parse_test_output_cargo() {
-        let output = "test result: ok. 25 passed; 0 failed;";
-        let (passed, failed, total) = parse_test_output(output).unwrap();
-        assert_eq!(passed, 25);
-        assert_eq!(failed, 0);
-        assert_eq!(total, 25);
-    }
-}