fix: exclude noisy micro-benchmarks from regression gate

Drop test_parse_session_small and test_search_full_corpus from gated
baselines; clarify ubuntu CI provenance in _note; detect duplicate
benchmark names; expand reduce_baselines tests.

Author: clean6378-max-it

benchmarks/README.md

@@ -36,7 +36,11 @@ The memory test (`test_parse_memory.py`) is intentionally **not** skipped by `--
 
 ## CI gate
 
-The `benchmarks` job on **ubuntu-latest** runs pytest-benchmark, then `scripts/check_benchmark_regression.py`. CI fails when any gated benchmark mean exceeds its baseline by more than **20%**. Benchmarks without a baseline entry (e.g. new `cache` group) print a warning and do not fail the gate.
+The `benchmarks` job on **ubuntu-latest** runs pytest-benchmark (`--benchmark-json=benchmark-results.json`), then `scripts/check_benchmark_regression.py benchmark-results.json benchmarks/baselines.json`. CI fails when any **gated** benchmark mean exceeds its baseline by more than **20%**.
+
+**Gated:** parse medium/large, export 10/50/100 sessions.
+
+**Not gated (informational only):** `test_parse_session_small`, `test_search_full_corpus` (sub-ms CI noise), and the `cache` group. Benchmarks without a baseline entry print a warning and do not fail the gate.
 
 ## Refresh baselines
 

benchmarks/baselines.json

@@ -1,10 +1,9 @@
 {
-  "_note": "Means captured from ubuntu-latest CI post-cache (PR #90). Refresh via make update-baselines on ubuntu.",
+  "_note": "Gated means from ubuntu-latest CI benchmark-results.json (post-cache PR #90). Excluded from gate: test_parse_session_small, test_search_full_corpus (sub-ms CI noise). Refresh via make update-baselines on ubuntu.",
   "updated": "2026-06-17T21:00:00Z",
   "machine": "Linux",
   "groups": {
     "parse": {
-      "test_parse_session_small": 0.000105,
       "test_parse_session_medium": 0.002956,
       "test_parse_session_large": 0.029678
     },
@@ -13,8 +12,6 @@
       "test_bulk_export_session_count[sessions-50]": 0.021144,
       "test_bulk_export_session_count[sessions-100]": 0.042003
     },
-    "search": {
-      "test_search_full_corpus": 0.001092
-    }
+    "search": {}
   }
 }

scripts/check_benchmark_regression.py

@@ -9,6 +9,14 @@
 
 THRESHOLD = 1.20
 
+# Sub-ms timings are too noisy for a fixed 20% gate on ubuntu CI.
+EXCLUDED_FROM_GATE = frozenset(
+    {
+        "test_parse_session_small",
+        "test_search_full_corpus",
+    }
+)
+
 
 class BenchmarkDataError(ValueError):
     """Raised when benchmark JSON input is malformed or missing required fields."""
@@ -38,7 +46,10 @@ def load_results(results_path: str | Path) -> dict[str, float]:
             raise BenchmarkDataError(
                 f"{path} benchmarks[{index}] missing 'name' or 'stats.mean'"
             ) from exc
-        results[str(name)] = mean
+        name = str(name)
+        if name in results:
+            raise BenchmarkDataError(f"{path} duplicate benchmark name {name!r}")
+        results[name] = mean
     return results
 
 
@@ -62,8 +73,13 @@ def load_baseline_means(baselines_path: str | Path) -> dict[str, float]:
         if not isinstance(value, dict):
             continue
         for name, mean in value.items():
+            name = str(name)
+            if name in means:
+                raise BenchmarkDataError(
+                    f"{path} duplicate benchmark name {name!r} across groups"
+                )
             try:
-                means[str(name)] = float(mean)
+                means[name] = float(mean)
             except (TypeError, ValueError) as exc:
                 raise BenchmarkDataError(
                     f"{path} groups[{group_name!r}][{name!r}] is not a numeric mean"

scripts/reduce_baselines.py

@@ -9,9 +9,9 @@
 from pathlib import Path
 
 try:
-    from scripts.check_benchmark_regression import BenchmarkDataError
+    from scripts.check_benchmark_regression import EXCLUDED_FROM_GATE, BenchmarkDataError
 except ModuleNotFoundError:
-    from check_benchmark_regression import BenchmarkDataError
+    from check_benchmark_regression import EXCLUDED_FROM_GATE, BenchmarkDataError
 
 GATED_GROUPS = ("parse", "export", "search")
 
@@ -58,12 +58,17 @@ def reduce_baselines(
         group = entry.get("group")
         if group not in GATED_GROUPS:
             continue
+        if str(name) in EXCLUDED_FROM_GATE:
+            continue
         groups[group][str(name)] = mean * slack
 
     machine_info = raw.get("machine_info")
     machine = machine_info.get("system") if isinstance(machine_info, dict) else None
     output: dict[str, object] = {
-        "_note": "CI gates the ubuntu benchmarks job when mean exceeds baseline by >20%.",
+        "_note": (
+            "Gated means from ubuntu-latest CI (post-cache). "
+            "Excluded from gate: test_parse_session_small, test_search_full_corpus (CI noise)."
+        ),
         "updated": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
         "machine": machine,
         "groups": groups,

tests/test_check_benchmark_regression.py

@@ -6,7 +6,12 @@
 
 import pytest
 
-from scripts.check_benchmark_regression import BenchmarkDataError, check_regression, load_results
+from scripts.check_benchmark_regression import (
+    BenchmarkDataError,
+    check_regression,
+    load_baseline_means,
+    load_results,
+)
 
 
 def _write_results(path, benchmarks: list[dict]) -> None:
@@ -147,3 +152,17 @@ def test_main_reports_benchmark_data_error(tmp_path, capsys: pytest.CaptureFixtu
 
     assert main([str(bad), str(baselines)]) == 2
     assert "ERROR:" in capsys.readouterr().err
+
+
+def test_duplicate_baseline_name_raises(tmp_path) -> None:
+    baselines = tmp_path / "baselines.json"
+    _write_baselines(
+        baselines,
+        {
+            "parse": {"test_parse_session_medium": 0.002},
+            "export": {"test_parse_session_medium": 0.003},
+        },
+    )
+
+    with pytest.raises(BenchmarkDataError, match="duplicate benchmark name"):
+        load_baseline_means(baselines)

tests/test_reduce_baselines.py

@@ -29,6 +29,7 @@ def test_reduce_baselines_writes_gated_groups_only(tmp_path) -> None:
     _write_raw(
         raw,
         [
+            {"group": "parse", "name": "test_parse_session_medium", "stats": {"mean": 0.002}},
             {"group": "parse", "name": "test_parse_session_small", "stats": {"mean": 0.0001}},
             {"group": "cache", "name": "test_cache_warm_hit", "stats": {"mean": 1e-05}},
         ],
@@ -37,24 +38,23 @@ def test_reduce_baselines_writes_gated_groups_only(tmp_path) -> None:
     output = reduce_baselines(raw, out)
 
     assert output["machine"] == "Linux"
-    assert "test_parse_session_small" in output["groups"]["parse"]
+    assert "test_parse_session_medium" in output["groups"]["parse"]
+    assert "test_parse_session_small" not in output["groups"]["parse"]
     assert "cache" not in output["groups"]
-    written = json.loads(out.read_text(encoding="utf-8"))
-    assert "test_cache_warm_hit" not in written["groups"]["parse"]
 
 
 def test_reduce_baselines_applies_slack(tmp_path) -> None:
     raw = tmp_path / "raw.json"
     out = tmp_path / "baselines.json"
     _write_raw(
         raw,
-        [{"group": "search", "name": "test_search_full_corpus", "stats": {"mean": 0.002}}],
+        [{"group": "parse", "name": "test_parse_session_medium", "stats": {"mean": 0.002}}],
     )
 
     reduce_baselines(raw, out, slack=1.5)
     data = json.loads(out.read_text(encoding="utf-8"))
 
-    assert data["groups"]["search"]["test_search_full_corpus"] == pytest.approx(0.003)
+    assert data["groups"]["parse"]["test_parse_session_medium"] == pytest.approx(0.003)
 
 
 def test_reduce_baselines_rejects_missing_benchmarks_key(tmp_path) -> None:
@@ -77,3 +77,26 @@ def test_reduce_baselines_cli_rejects_non_positive_slack(tmp_path) -> None:
     with pytest.raises(SystemExit) as exc_info:
         main([str(raw), str(tmp_path / "out.json"), "--slack", "0"])
     assert exc_info.value.code == 2
+
+
+def test_reduce_baselines_machine_info_non_dict(tmp_path) -> None:
+    raw = tmp_path / "raw.json"
+    raw.write_text(
+        json.dumps(
+            {
+                "machine_info": "not-a-dict",
+                "benchmarks": [
+                    {
+                        "group": "parse",
+                        "name": "test_parse_session_medium",
+                        "stats": {"mean": 0.002},
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    output = reduce_baselines(raw, tmp_path / "out.json")
+
+    assert output["machine"] is None