fix(ci): seed ubuntu baselines and fix ruff/mypy benchmark regressions

Author: clean6378-max-it

benchmarks/baselines.json

@@ -1,23 +1,23 @@
 {
-  "_note": "Gated means from local reference run with 1.5x slack (Windows dev host). Excluded from gate: test_parse_session_small, test_search_full_corpus (CI noise). Memory benchmarks use peak_bytes; latency uses stats.mean. Refresh from ubuntu-latest CI artifact after first green job.",
-  "updated": "2026-06-25T00:00:00Z",
-  "machine": "Windows",
+  "_note": "Gated means from ubuntu-latest CI benchmark-results.json (PR memory-path benchmarks). Excluded from gate: test_parse_session_small, test_search_full_corpus (CI noise). Memory benchmarks use extra_info.peak_bytes (bytes); latency uses stats.mean (seconds).",
+  "updated": "2026-06-25T12:00:00Z",
+  "machine": "Linux",
   "groups": {
     "parse": {
-      "test_parse_session_medium": 0.0021930547314696017,
-      "test_parse_session_large": 0.022708179059622507,
-      "test_parse_large_peak_memory": 3175761.0
+      "test_parse_session_medium": 0.003037,
+      "test_parse_session_large": 0.030266,
+      "test_parse_large_peak_memory": 2032028.0
     },
     "export": {
-      "test_bulk_export_session_count[sessions-10]": 0.003750986296823886,
-      "test_bulk_export_session_count[sessions-50]": 0.018420866638835933,
-      "test_bulk_export_session_count[sessions-100]": 0.03871899230244498,
-      "test_bulk_export_zip_peak_memory[sessions-10]": 525699.0,
-      "test_bulk_export_zip_peak_memory[sessions-50]": 752907.0,
-      "test_bulk_export_zip_peak_memory[sessions-100]": 1029018.0
+      "test_bulk_export_session_count[sessions-10]": 0.004253,
+      "test_bulk_export_session_count[sessions-50]": 0.021039,
+      "test_bulk_export_session_count[sessions-100]": 0.041709,
+      "test_bulk_export_zip_peak_memory[sessions-10]": 350546.0,
+      "test_bulk_export_zip_peak_memory[sessions-50]": 503331.0,
+      "test_bulk_export_zip_peak_memory[sessions-100]": 686874.0
     },
     "search": {
-      "test_search_full_corpus": 0.0033342776477665584
+      "test_search_full_corpus": 0.001091
     }
   }
 }

scripts/check_benchmark_regression.py

@@ -22,10 +22,24 @@ class BenchmarkDataError(ValueError):
     """Raised when benchmark JSON input is malformed or missing required fields."""
 
 
+def entry_uses_peak_bytes(entry: dict[str, object]) -> bool:
+    """True when the gated metric for *entry* is extra_info.peak_bytes."""
+    extra = entry.get("extra_info")
+    return isinstance(extra, dict) and "peak_bytes" in extra
+
+
+def metric_is_bytes(name: str, entry: dict[str, object] | None = None) -> bool:
+    """Shared heuristic for metric kind (bytes vs seconds) in gate and display."""
+    if entry is not None and entry_uses_peak_bytes(entry):
+        return True
+    return "peak_memory" in name
+
+
 def benchmark_entry_mean(entry: dict[str, object]) -> float:
     """Return gated metric: peak_bytes from extra_info when present, else stats.mean."""
-    extra = entry.get("extra_info")
-    if isinstance(extra, dict) and "peak_bytes" in extra:
+    if entry_uses_peak_bytes(entry):
+        extra = entry["extra_info"]
+        assert isinstance(extra, dict)
         return float(extra["peak_bytes"])
     try:
         stats = entry["stats"]
@@ -36,11 +50,9 @@ def benchmark_entry_mean(entry: dict[str, object]) -> float:
         ) from exc
 
 
-def is_memory_metric(name: str) -> bool:
-    return "peak_memory" in name
-
-
-def load_results(results_path: str | Path) -> dict[str, float]:
+def load_results(
+    results_path: str | Path,
+) -> tuple[dict[str, float], dict[str, dict[str, object]]]:
     path = Path(results_path)
     try:
         data = json.loads(path.read_text(encoding="utf-8"))
@@ -56,6 +68,7 @@ def load_results(results_path: str | Path) -> dict[str, float]:
         raise BenchmarkDataError(f"{path} 'benchmarks' must be an array")
 
     results: dict[str, float] = {}
+    entries_by_name: dict[str, dict[str, object]] = {}
     for index, entry in enumerate(benchmarks):
         if not isinstance(entry, dict):
             raise BenchmarkDataError(f"{path} benchmarks[{index}] must be an object")
@@ -70,7 +83,8 @@ def load_results(results_path: str | Path) -> dict[str, float]:
         if name in results:
             raise BenchmarkDataError(f"{path} duplicate benchmark name {name!r}")
         results[name] = mean
-    return results
+        entries_by_name[name] = entry
+    return results, entries_by_name
 
 
 def load_baseline_means(baselines_path: str | Path) -> dict[str, float]:
@@ -114,7 +128,7 @@ def check_regression(
     threshold: float = THRESHOLD,
 ) -> int:
     """Return 0 when within threshold; 1 when any gated benchmark regresses."""
-    flat = load_results(results_path)
+    flat, entries_by_name = load_results(results_path)
     baseline_means = load_baseline_means(baselines_path)
 
     failures: list[str] = []
@@ -130,7 +144,8 @@ def check_regression(
             continue
         ratio = cur / base
         tag = "FAIL" if ratio > threshold else "ok"
-        if is_memory_metric(name):
+        entry = entries_by_name.get(name)
+        if metric_is_bytes(name, entry):
             print(f"[{tag}] {name}: {cur:.0f} bytes vs {base:.0f} bytes ({ratio:.2f}x)")
         else:
             print(f"[{tag}] {name}: {cur:.6f}s vs {base:.6f}s ({ratio:.2f}x)")

scripts/reduce_baselines.py

@@ -9,17 +9,9 @@
 from pathlib import Path
 
 try:
-    from scripts.check_benchmark_regression import (
-        EXCLUDED_FROM_GATE,
-        BenchmarkDataError,
-        benchmark_entry_mean,
-    )
+    from scripts.check_benchmark_regression import BenchmarkDataError, benchmark_entry_mean
 except ModuleNotFoundError:
-    from check_benchmark_regression import (
-        EXCLUDED_FROM_GATE,
-        BenchmarkDataError,
-        benchmark_entry_mean,
-    )
+    from check_benchmark_regression import BenchmarkDataError, benchmark_entry_mean
 
 GATED_GROUPS = ("parse", "export", "search")
 
@@ -72,9 +64,10 @@ def reduce_baselines(
     machine = machine_info.get("system") if isinstance(machine_info, dict) else None
     output: dict[str, object] = {
         "_note": (
-            "Gated means from ubuntu-latest CI (post-cache). "
+            "Gated means from ubuntu-latest CI benchmark-results.json. "
             "Excluded from gate: test_parse_session_small, test_search_full_corpus (CI noise). "
-            "Memory benchmarks use extra_info.peak_bytes (bytes); latency uses stats.mean (seconds)."
+            "Memory benchmarks use extra_info.peak_bytes (bytes); "
+            "latency uses stats.mean (seconds)."
         ),
         "updated": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
         "machine": machine,

tests/benchmarks/test_export_bench.py

@@ -9,7 +9,7 @@
 import pytest
 
 from tests.benchmarks.conftest import TracemallocPeak
-from utils.export_engine import NoopSink, ZipSink, run_bulk_export
+from utils.export_engine import BulkExportResult, NoopSink, ZipSink, run_bulk_export
 
 
 def _bench_projects(export_corpus: Path) -> list[dict[str, str]]:
@@ -62,7 +62,7 @@ def test_bulk_export_zip_peak_memory(
     peaks: list[int] = []
 
     def _run() -> None:
-        def _export() -> object:
+        def _export() -> BulkExportResult:
             buf = io.BytesIO()
             with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
                 sink = ZipSink(zf)

tests/benchmarks/test_parse_memory.py

@@ -46,4 +46,5 @@ def _run() -> None:
 
     benchmark(_run)
     assert peaks, "benchmark produced no peak memory samples"
+    # Gate uses extra_info.peak_bytes, not stats.mean (tracemalloc-inflated wall time).
     benchmark.extra_info["peak_bytes"] = int(sum(peaks) / len(peaks))

tests/test_check_benchmark_regression.py

@@ -192,7 +192,18 @@ def test_load_results_prefers_peak_bytes_extra_info(tmp_path) -> None:
         ],
     )
 
-    assert load_results(path)["test_parse_large_peak_memory"] == 12_345_678.0
+    assert load_results(path)[0]["test_parse_large_peak_memory"] == 12_345_678.0
+
+
+def test_metric_is_bytes_uses_extra_info_without_name_hint() -> None:
+    from scripts.check_benchmark_regression import metric_is_bytes
+
+    entry = {
+        "name": "test_custom_memory",
+        "stats": {"mean": 0.05},
+        "extra_info": {"peak_bytes": 1_000_000},
+    }
+    assert metric_is_bytes("test_custom_memory", entry)
 
 
 def test_memory_metric_regression_uses_bytes(tmp_path, capsys: pytest.CaptureFixture[str]) -> None: