feat(eval): complete eval harness with 38 fixtures and aggregate reporting

- 26 new fixtures (38 total) covering all 11 commit types, AST
  features, and edge cases across Rust, TypeScript, Python, Go
- EvalSummary with per-type accuracy breakdown and overall score
- Summary prints after CLI eval runs
- 348 tests passing with eval feature

Author: Sephyi

src/eval.rs

@@ -286,20 +286,23 @@ impl EvalRunner {
 
         self.print_results(&results);
 
-        let failed = results.iter().filter(|r| !r.passed()).count();
-        if failed > 0 {
+        // Print aggregate summary
+        let summary = EvalSummary::from_results(&results);
+        eprintln!("{}", summary.format_report());
+
+        if summary.total_failed > 0 {
             eprintln!(
-                "\n{} {} fixture(s) failed",
+                "{} {} fixture(s) failed",
                 style("FAIL").red().bold(),
-                failed,
+                summary.total_failed,
             );
             std::process::exit(1);
         }
 
         eprintln!(
-            "\n{} All {} fixture(s) passed",
+            "{} All {} fixture(s) passed",
             style("PASS").green().bold(),
-            results.len(),
+            summary.total_passed,
         );
 
         Ok(())
@@ -1015,6 +1018,89 @@ impl EvalRunner {
     }
 }
 
+/// Aggregate evaluation summary with per-type accuracy breakdown.
+#[derive(Debug)]
+pub struct EvalSummary {
+    pub total_fixtures: usize,
+    pub total_passed: usize,
+    pub total_failed: usize,
+    /// Per-type accuracy: (type_name, passed, total).
+    pub per_type: Vec<(String, usize, usize)>,
+}
+
+impl EvalSummary {
+    /// Build a summary from eval results.
+    #[must_use]
+    pub fn from_results(results: &[EvalResult]) -> Self {
+        let total_fixtures = results.len();
+        let total_passed = results.iter().filter(|r| r.passed()).count();
+        let total_failed = total_fixtures - total_passed;
+
+        // Group by expected_type
+        let mut type_map: std::collections::BTreeMap<String, (usize, usize)> =
+            std::collections::BTreeMap::new();
+
+        for result in results {
+            let key = result.expected_type.to_lowercase();
+            if key.is_empty() {
+                continue;
+            }
+            let entry = type_map.entry(key).or_insert((0, 0));
+            entry.1 += 1; // total
+            if result.passed() {
+                entry.0 += 1; // passed
+            }
+        }
+
+        let per_type: Vec<(String, usize, usize)> = type_map
+            .into_iter()
+            .map(|(k, (passed, total))| (k, passed, total))
+            .collect();
+
+        Self {
+            total_fixtures,
+            total_passed,
+            total_failed,
+            per_type,
+        }
+    }
+
+    /// Format the summary as a human-readable report.
+    #[must_use]
+    pub fn format_report(&self) -> String {
+        let mut report = String::new();
+
+        report.push_str("=== Eval Summary ===\n\n");
+
+        // Per-type breakdown
+        report.push_str("Per-type accuracy:\n");
+        for (type_name, passed, total) in &self.per_type {
+            let pct = if *total > 0 {
+                (*passed as f64 / *total as f64) * 100.0
+            } else {
+                0.0
+            };
+            report.push_str(&format!(
+                "  {}: {}/{} ({:.0}%)\n",
+                type_name, passed, total, pct
+            ));
+        }
+
+        // Overall score
+        let overall_pct = if self.total_fixtures > 0 {
+            (self.total_passed as f64 / self.total_fixtures as f64) * 100.0
+        } else {
+            0.0
+        };
+        report.push_str(&format!(
+            "\nOverall: {}/{} ({:.1}%)\n",
+            self.total_passed, self.total_fixtures, overall_pct
+        ));
+
+        report
+    }
+}
+
 /// Parse a symbol kind string from TOML into `SymbolKind`.
 fn parse_symbol_kind(kind: &str) -> SymbolKind {
     match kind.to_lowercase().as_str() {

tests/eval.rs

@@ -184,10 +184,35 @@ fn breaking_change_fixtures() {
 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
+    // 12 original + 26 new = 38
     assert!(
-        results.len() >= 12,
-        "Expected at least 12 fixtures, found {}",
+        results.len() >= 38,
+        "Expected at least 38 fixtures, found {}",
         results.len()
     );
 }
+
+/// Print aggregate per-type accuracy report after running all fixtures.
+#[test]
+fn aggregate_summary() {
+    let runner = EvalRunner::new(fixtures_dir(), None);
+    let results = runner.run_sync().expect("eval runner should not error");
+
+    let summary = commitbee::eval::EvalSummary::from_results(&results);
+    let report = summary.format_report();
+
+    // Print the report so it's visible with --nocapture
+    eprintln!("\n{}", report);
+
+    // Verify the summary math is consistent
+    assert_eq!(
+        summary.total_passed + summary.total_failed,
+        summary.total_fixtures,
+        "passed + failed should equal total"
+    );
+    assert_eq!(
+        summary.total_fixtures,
+        results.len(),
+        "summary total should match results count"
+    );
+}

tests/fixtures/eval/ast-breaking-public-removal/diff.patch

@@ -0,0 +1,25 @@
+diff --git a/src/services/api.rs b/src/services/api.rs
+index abc1234..def5678 100644
+--- a/src/services/api.rs
++++ b/src/services/api.rs
+@@ -5,20 +5,5 @@ use crate::error::Result;
+
+ pub struct ApiClient {
+     base_url: String,
+ }
+
+-/// Send a GET request to the given path.
+-pub fn api_get(client: &ApiClient, path: &str) -> Result<Response> {
+-    let url = format!("{}/{}", client.base_url, path);
+-    reqwest::blocking::get(&url).map_err(|e| Error::Network(e.to_string()))
+-}
+-
+-/// Send a POST request with a JSON body.
+-pub fn api_post(client: &ApiClient, path: &str, body: &str) -> Result<Response> {
+-    let url = format!("{}/{}", client.base_url, path);
+-    reqwest::blocking::Client::new()
+-        .post(&url)
+-        .body(body.to_string())
+-        .send()
+-        .map_err(|e| Error::Network(e.to_string()))
+-}

tests/fixtures/eval/ast-breaking-public-removal/metadata.toml

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+#
+# SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+name = "ast-breaking-public-removal"
+description = "Removing public API without replacement should signal breaking change"
+language = "rust"
+category = "ast"
+expected_type = "refactor"
+expected_scope = "optional"
+
+[evidence]
+has_new_public_api = false
+public_api_removed_count = 2
+
+[prompt]
+must_contain = ["SYMBOLS CHANGED", "Removed"]
+
+[breaking]
+expected = true

tests/fixtures/eval/ast-breaking-public-removal/symbols.toml

@@ -0,0 +1,19 @@
+[[symbols]]
+kind = "Function"
+name = "api_get"
+file = "src/services/api.rs"
+line = 10
+end_line = 13
+is_public = true
+is_added = false
+signature = "pub fn api_get(client: &ApiClient, path: &str) -> Result<Response>"
+
+[[symbols]]
+kind = "Function"
+name = "api_post"
+file = "src/services/api.rs"
+line = 16
+end_line = 22
+is_public = true
+is_added = false
+signature = "pub fn api_post(client: &ApiClient, path: &str, body: &str) -> Result<Response>"

tests/fixtures/eval/ast-mixed-ws-semantic/diff.patch

@@ -0,0 +1,24 @@
+diff --git a/src/services/validator.rs b/src/services/validator.rs
+index abc1234..def5678 100644
+--- a/src/services/validator.rs
++++ b/src/services/validator.rs
+@@ -5,8 +5,8 @@ use crate::error::Result;
+
+ impl Validator {
+-    pub fn check(&self,  input: &str) -> bool {
+-        !input.is_empty()  &&  input.len() < 1024
++    pub fn check(&self, input: &str) -> bool {
++        !input.is_empty() && input.len() < 1024
+     }
+ }
+
+@@ -15,0 +16,10 @@
++/// Validate a batch of inputs, returning the first error.
++pub fn validate_batch(inputs: &[&str]) -> Result<()> {
++    for input in inputs {
++        if input.is_empty() {
++            return Err(crate::error::Error::Config("empty input in batch".into()));
++        }
++    }
++    Ok(())
++}

tests/fixtures/eval/ast-mixed-ws-semantic/metadata.toml

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+#
+# SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+name = "ast-mixed-ws-semantic"
+description = "Mix of whitespace and semantic changes should produce feat, not style"
+language = "rust"
+category = "ast"
+expected_type = "feat"
+expected_scope = "optional"
+
+[evidence]
+has_new_public_api = true
+
+[prompt]
+must_contain = ["SYMBOLS CHANGED", "Added"]
+
+[breaking]
+expected = false

tests/fixtures/eval/ast-mixed-ws-semantic/symbols.toml

@@ -0,0 +1,9 @@
+[[symbols]]
+kind = "Function"
+name = "validate_batch"
+file = "src/services/validator.rs"
+line = 16
+end_line = 24
+is_public = true
+is_added = true
+signature = "pub fn validate_batch(inputs: &[&str]) -> Result<()>"

tests/fixtures/eval/ast-overloaded-symbols/diff.patch

@@ -0,0 +1,32 @@
+diff --git a/src/services/json_format.rs b/src/services/json_format.rs
+new file mode 100644
+index 0000000..abc1234
+--- /dev/null
++++ b/src/services/json_format.rs
+@@ -0,0 +1,10 @@
++use crate::error::Result;
++
++pub struct JsonFormatter;
++
++impl JsonFormatter {
++    pub fn format(&self, data: &str) -> Result<String> {
++        let parsed: serde_json::Value = serde_json::from_str(data)?;
++        Ok(serde_json::to_string_pretty(&parsed)?)
++    }
++}
+diff --git a/src/services/yaml_format.rs b/src/services/yaml_format.rs
+new file mode 100644
+index 0000000..def5678
+--- /dev/null
++++ b/src/services/yaml_format.rs
+@@ -0,0 +1,10 @@
++use crate::error::Result;
++
++pub struct YamlFormatter;
++
++impl YamlFormatter {
++    pub fn format(&self, data: &str) -> Result<String> {
++        let parsed: serde_yaml::Value = serde_yaml::from_str(data)?;
++        Ok(serde_yaml::to_string(&parsed)?)
++    }
++}

tests/fixtures/eval/ast-overloaded-symbols/metadata.toml

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2026 Sephyi <me@sephy.io>
+#
+# SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+name = "ast-overloaded-symbols"
+description = "Multiple symbols with same name across files should all appear"
+language = "rust"
+category = "ast"
+expected_type = "feat"
+expected_scope = "optional"
+
+[evidence]
+has_new_public_api = true
+
+[prompt]
+must_contain = ["SYMBOLS CHANGED", "Added"]
+
+[breaking]
+expected = false