feat(eval): add 10 fixtures and integration test suite

Create evaluation fixtures covering feat, fix, refactor, chore, docs,
style, test, AST signature extraction, cross-file connections, and
MSRV breaking change detection. Each fixture includes metadata.toml
with assertion sections (evidence, prompt, connections, breaking) and
realistic unified diffs. AST fixtures include symbols.toml for
injected CodeSymbol data.

Add tests/eval.rs integration test with 7 test functions: all_fixtures,
type_inference, evidence_flags, prompt_content, connections, breaking
changes, and fixture count validation. All gated behind eval feature.

Author: Sephyi

src/eval.rs

@@ -461,8 +461,7 @@ impl EvalRunner {
     fn load_metadata(&self, fixture_dir: &Path) -> Result<FixtureMetadata> {
         let content = std::fs::read_to_string(fixture_dir.join("metadata.toml"))
             .map_err(|e| Error::Config(format!("Cannot read metadata.toml: {}", e)))?;
-        toml::from_str(&content)
-            .map_err(|e| Error::Config(format!("Invalid metadata.toml: {}", e)))
+        toml::from_str(&content).map_err(|e| Error::Config(format!("Invalid metadata.toml: {}", e)))
     }
 
     fn load_config(&self, fixture_dir: &Path) -> Config {

tests/eval.rs

@@ -0,0 +1,193 @@
+// SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+//
+// SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+//! Integration tests for the evaluation harness.
+//!
+//! Runs all fixtures through the deterministic (no-LLM) pipeline and
+//! asserts type inference, evidence flags, prompt content, connections,
+//! and breaking change detection.
+
+#![cfg(feature = "eval")]
+
+use std::path::PathBuf;
+
+use commitbee::eval::EvalRunner;
+
+fn fixtures_dir() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/eval")
+}
+
+/// Run all fixtures and assert every one passes.
+#[test]
+fn all_fixtures_pass() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    assert!(!results.is_empty(), "should discover at least one fixture");
+
+    let mut failures = Vec::new();
+    for result in &results {
+        if !result.passed() {
+            let mut detail = format!("FIXTURE FAILED: {}\n", result.fixture_name);
+            if !result.type_passed {
+                detail.push_str(&format!(
+                    "  Type: expected={}, actual={}\n",
+                    result.expected_type, result.actual_type
+                ));
+            }
+            if !result.scope_passed {
+                detail.push_str(&format!(
+                    "  Scope: expected={:?}, actual={:?}\n",
+                    result.expected_scope, result.actual_scope
+                ));
+            }
+            if !result.prompt_assembled {
+                detail.push_str("  Prompt: failed to assemble\n");
+            }
+            for failure in &result.assertion_failures {
+                detail.push_str(&format!("  {}\n", failure));
+            }
+            if let Some(ref err) = result.error {
+                detail.push_str(&format!("  Error: {}\n", err));
+            }
+            failures.push(detail);
+        }
+    }
+
+    if !failures.is_empty() {
+        panic!(
+            "{} of {} fixtures failed:\n\n{}",
+            failures.len(),
+            results.len(),
+            failures.join("\n")
+        );
+    }
+}
+
+/// Each fixture category runs independently.
+#[test]
+fn type_inference_fixtures() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    for result in &results {
+        assert!(
+            result.type_passed,
+            "Type mismatch in {}: expected={}, actual={}",
+            result.fixture_name, result.expected_type, result.actual_type
+        );
+    }
+}
+
+#[test]
+fn evidence_flag_fixtures() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    for result in &results {
+        let evidence_failures: Vec<_> = result
+            .assertion_failures
+            .iter()
+            .filter(|f| f.category == "evidence")
+            .collect();
+
+        assert!(
+            evidence_failures.is_empty(),
+            "Evidence failures in {}: {:?}",
+            result.fixture_name,
+            evidence_failures
+                .iter()
+                .map(|f| &f.message)
+                .collect::<Vec<_>>()
+        );
+    }
+}
+
+#[test]
+fn prompt_content_fixtures() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    for result in &results {
+        assert!(
+            result.prompt_assembled,
+            "Prompt assembly failed for {}",
+            result.fixture_name
+        );
+
+        let prompt_failures: Vec<_> = result
+            .assertion_failures
+            .iter()
+            .filter(|f| f.category == "prompt")
+            .collect();
+
+        assert!(
+            prompt_failures.is_empty(),
+            "Prompt content failures in {}: {:?}",
+            result.fixture_name,
+            prompt_failures
+                .iter()
+                .map(|f| &f.message)
+                .collect::<Vec<_>>()
+        );
+    }
+}
+
+#[test]
+fn connection_detection_fixtures() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    for result in &results {
+        let conn_failures: Vec<_> = result
+            .assertion_failures
+            .iter()
+            .filter(|f| f.category == "connections")
+            .collect();
+
+        assert!(
+            conn_failures.is_empty(),
+            "Connection failures in {}: {:?}",
+            result.fixture_name,
+            conn_failures.iter().map(|f| &f.message).collect::<Vec<_>>()
+        );
+    }
+}
+
+#[test]
+fn breaking_change_fixtures() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    for result in &results {
+        let breaking_failures: Vec<_> = result
+            .assertion_failures
+            .iter()
+            .filter(|f| f.category == "breaking")
+            .collect();
+
+        assert!(
+            breaking_failures.is_empty(),
+            "Breaking change failures in {}: {:?}",
+            result.fixture_name,
+            breaking_failures
+                .iter()
+                .map(|f| &f.message)
+                .collect::<Vec<_>>()
+        );
+    }
+}
+
+/// Verify specific fixture count to catch accidental fixture deletion.
+#[test]
+fn fixture_count() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+    // 2 original (simple-feat, style-only) + 10 new = 12
+    assert!(
+        results.len() >= 12,
+        "Expected at least 12 fixtures, found {}",
+        results.len()
+    );
+}

tests/fixtures/eval/ast-cross-file-connection/diff.patch

@@ -0,0 +1,39 @@
+diff --git a/src/services/validator.rs b/src/services/validator.rs
+new file mode 100644
+index 0000000..abc1234
+--- /dev/null
++++ b/src/services/validator.rs
+@@ -0,0 +1,12 @@
++use crate::error::Result;
++
++/// Validate user input before processing.
++pub fn validate_input(input: &str) -> Result<()> {
++    if input.is_empty() {
++        return Err(crate::error::Error::Config("empty input".into()));
++    }
++    if input.len() > 1024 {
++        return Err(crate::error::Error::Config("input too long".into()));
++    }
++    Ok(())
++}
+diff --git a/src/services/handler.rs b/src/services/handler.rs
+new file mode 100644
+index 0000000..def5678
+--- /dev/null
++++ b/src/services/handler.rs
+@@ -0,0 +1,15 @@
++use crate::error::Result;
++use super::validator::validate_input;
++
++pub struct RequestHandler;
++
++impl RequestHandler {
++    pub fn handle(&self, request: &str) -> Result<String> {
++        // Validate first, then process
++        validate_input(request)?;
++
++        // Process the validated input
++        let result = request.to_uppercase();
++        Ok(result)
++    }
++}

tests/fixtures/eval/ast-cross-file-connection/metadata.toml

@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+#
+# SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+name = "ast-cross-file-connection"
+description = "Cross-file call should produce CONNECTIONS section in prompt"
+language = "rust"
+category = "feat"
+expected_type = "feat"
+expected_scope = "optional"
+
+[prompt]
+must_contain = ["CONNECTIONS", "calls validate_input"]
+
+[connections]
+min_count = 1
+must_contain = ["calls validate_input"]

tests/fixtures/eval/ast-cross-file-connection/symbols.toml

@@ -0,0 +1,29 @@
+[[symbols]]
+kind = "Function"
+name = "validate_input"
+file = "src/services/validator.rs"
+line = 4
+end_line = 11
+is_public = true
+is_added = true
+signature = "pub fn validate_input(input: &str) -> Result<()>"
+
+[[symbols]]
+kind = "Struct"
+name = "RequestHandler"
+file = "src/services/handler.rs"
+line = 4
+end_line = 4
+is_public = true
+is_added = true
+signature = "pub struct RequestHandler"
+
+[[symbols]]
+kind = "Function"
+name = "handle"
+file = "src/services/handler.rs"
+line = 7
+end_line = 14
+is_public = true
+is_added = true
+signature = "pub fn handle(&self, request: &str) -> Result<String>"

tests/fixtures/eval/ast-signature-extraction/diff.patch

@@ -0,0 +1,24 @@
+diff --git a/src/services/validator.rs b/src/services/validator.rs
+new file mode 100644
+index 0000000..abc1234
+--- /dev/null
++++ b/src/services/validator.rs
+@@ -0,0 +1,18 @@
++use crate::error::Result;
++
++pub struct InputValidator {
++    max_length: usize,
++}
++
++impl InputValidator {
++    pub fn new(max_length: usize) -> Self {
++        Self { max_length }
++    }
++
++    pub fn validate(&self, input: &str) -> Result<()> {
++        if input.len() > self.max_length {
++            return Err(crate::error::Error::Config("input too long".into()));
++        }
++        Ok(())
++    }
++}

tests/fixtures/eval/ast-signature-extraction/metadata.toml

@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+#
+# SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+name = "ast-signature-extraction"
+description = "Symbol with signature should appear in prompt SYMBOLS section"
+language = "rust"
+category = "feat"
+expected_type = "feat"
+expected_scope = "optional"
+
+[evidence]
+has_new_public_api = true
+
+[prompt]
+must_contain = ["SYMBOLS CHANGED", "pub fn validate"]
+must_not_contain = []

tests/fixtures/eval/ast-signature-extraction/symbols.toml

@@ -0,0 +1,29 @@
+[[symbols]]
+kind = "Struct"
+name = "InputValidator"
+file = "src/services/validator.rs"
+line = 3
+end_line = 5
+is_public = true
+is_added = true
+signature = "pub struct InputValidator"
+
+[[symbols]]
+kind = "Function"
+name = "new"
+file = "src/services/validator.rs"
+line = 8
+end_line = 10
+is_public = true
+is_added = true
+signature = "pub fn new(max_length: usize) -> Self"
+
+[[symbols]]
+kind = "Function"
+name = "validate"
+file = "src/services/validator.rs"
+line = 12
+end_line = 17
+is_public = true
+is_added = true
+signature = "pub fn validate(&self, input: &str) -> Result<()>"

tests/fixtures/eval/chore-cargo-toml-deps/diff.patch

@@ -0,0 +1,13 @@
+diff --git a/Cargo.toml b/Cargo.toml
+index abc1234..def5678 100644
+--- a/Cargo.toml
++++ b/Cargo.toml
+@@ -15,8 +15,8 @@ edition = "2024"
+
+ [dependencies]
+ serde = { version = "1.0", features = ["derive"] }
+-tokio = { version = "1.40", features = ["full"] }
+-reqwest = { version = "0.12", features = ["json"] }
++tokio = { version = "1.44", features = ["full"] }
++reqwest = { version = "0.13", features = ["json"] }
+ clap = { version = "4.5", features = ["derive"] }