@@ -52,7 +52,7 @@ jobs:
           uv run --frozen --no-build pytest --no-header -q
           test_bench_stats.py test_bench_measure.py test_bench_runner.py
           test_bench_arms.py test_bench_config.py test_bench_report.py
-          test_sdk_commands.py test_tdfs_units.py test_encryption_units.py
+          test_bench_installation.py test_sdk_commands.py test_tdfs_units.py test_encryption_units.py
           test_sizes_units.py test_zip64_units.py test_assertions_units.py
         working-directory: xtest
       - name: Lint and test otdf-local
 
@@ -257,9 +257,9 @@ def _add_benchmark_options(parser: pytest.Parser):
         "--bench-refs",
         help="2 to 4 builds of one sdk to compare, comma- or space-separated, "
         "e.g. 'go@v0.29.0,go@main,go@my-branch'. The first is the reference "
-        "every other build is compared against. Defaults to the newest "
-        "installed release against main. Supersedes "
-        "--bench-baseline/--bench-candidate",
+        "every other build is compared against. Defaults to the arms recorded "
+        "in $BENCH_INSTALLATION_MANIFEST when set, else the newest installed "
+        "release against main. Supersedes --bench-baseline/--bench-candidate",
     )
     group.addoption(
         "--bench-baseline",
@@ -456,8 +456,8 @@ def _parametrize_bench_cells(metafunc: pytest.Metafunc):
 def _bench_sdk_names(config: pytest.Config) -> list[str]:
     """SDKs the benchmark fans out over, in --sdks order."""
     # --sdks may be version-qualified (go@main); benchmark arms come from
-    # --bench-refs or --bench-baseline/--bench-candidate instead, so only the
-    # name matters.
+    # --bench-refs, --bench-baseline/--bench-candidate, or the installation
+    # manifest instead, so only the name matters.
     specs = config.getoption("--sdks") or " ".join(typing.get_args(tdfs.sdk_type))
     return list(dict.fromkeys(s.split("@", 1)[0] for s in str(specs).split()))
 
@@ -485,6 +485,7 @@ def pytest_configure(config: pytest.Config):
         arm_count,
         config_from_options,
         disk_shortfall,
+        installation_for,
         payloads_from_options,
     )
     from perf.cells import payloads_to_generate
@@ -495,6 +496,8 @@ def pytest_configure(config: pytest.Config):
         validate_sdk_name,
     )
 
+    # An unreadable manifest is a usage error now, not a fallback later.
+    installation_for(config)
     bench_config = config_from_options(config)
     payloads = payloads_from_options(config)
     refs = config.getoption("--bench-refs", default=None)
@@ -626,7 +629,7 @@ def pytest_sessionfinish(session: pytest.Session, exitstatus: int):
     reporter = config.pluginmanager.get_plugin("terminalreporter")
     if reporter is not None:
         reporter.write_sep("=", "benchmark results")
-        reporter.write_line(gate.summary)
+        reporter.write_line(report.headline(recorder, gate))
         reporter.write_line(f"raw samples and statistics: {json_path}")
 
     if config.getoption("--bench-no-gate", default=False):
@@ -636,7 +639,14 @@ def pytest_sessionfinish(session: pytest.Session, exitstatus: int):
     # it with a green tick and an empty table is the one outcome nobody
     # inspects, so a benchmark that has quietly stopped measuring can survive
     # indefinitely. Every reason a cell skips is already in the report.
-    if gate.should_fail or gate.nothing_measured:
+    #
+    # The one exception is a neutral preparation: every requested alias
+    # resolved to one commit, so there was deliberately nothing to compare.
+    # That is an answer, reported as such, and it reads the same locally and
+    # in CI.
+    if gate.should_fail:
+        session.exitstatus = pytest.ExitCode.TESTS_FAILED
+    elif gate.nothing_measured and not bench.preparation_is_neutral(config):
         session.exitstatus = pytest.ExitCode.TESTS_FAILED
 
 
 
@@ -3,8 +3,8 @@
 The experiment matrix, the payload files, the arm selection, and the shared
 time budget all live here. The measurement loop itself is in ``perf/runner.py``
 and the statistics in ``perf/stats.py``; this module is the glue that turns
-pytest's world (options, fixtures, SDK discovery) into the runner's world
-(2 to 4 arms and a config).
+pytest's world (options, fixtures, SDK discovery, the installation manifest)
+into the runner's world (2 to 4 arms and a config).
 """
 
 from __future__ import annotations
@@ -22,11 +22,14 @@
 
 import abac
 import tdfs
-from perf import report
+from perf import installation, report
 from perf.cells import BenchCell, Payload, parse_payloads, payloads_to_generate
 from perf.config import budget_seconds, requested_arms
 from perf.runner import Arm, BenchConfig, Budget, Invocation
 
+#: The run's installation manifest, read once in ``pytest_configure``.
+INSTALLATION_KEY: pytest.StashKey[installation.Installation | None] = pytest.StashKey()
+
 
 class ArmSelectionError(Exception):
     """The builds a comparison needs are not all installed."""
@@ -117,8 +120,30 @@ def resolve(spec: str, role: str) -> tdfs.SDK:
 # --- Session-scoped configuration -------------------------------------------
 
 
+def installation_for(config: pytest.Config) -> installation.Installation | None:
+    """The manifest this run was prepared with, or None if it was not.
+
+    Read once and kept on the config, so every fixture and the end-of-run
+    report see the same record even if the file changes mid-session.
+    """
+    if INSTALLATION_KEY not in config.stash:
+        try:
+            config.stash[INSTALLATION_KEY] = installation.from_env()
+        except installation.ManifestError as e:
+            raise pytest.UsageError(str(e)) from e
+    return config.stash[INSTALLATION_KEY]
+
+
 def arm_specs_from_options(config: pytest.Config) -> tuple[str, ...] | None:
-    """The run's ordered arm specs, reference first, or None for the defaults."""
+    """The run's ordered arm specs, reference first, or None for the defaults.
+
+    Explicit options win. Without them, a prepared run measures exactly what
+    preparation installed, in the order it was requested -- so a local run and
+    a CI run that prepared the same request measure the same arms without
+    anyone restating them. A manifest that cannot be measured (failed,
+    partial, or neutral) yields no specs here; :func:`preparation_problem`
+    says why, per SDK.
+    """
     refs = cast(str | None, config.getoption("--bench-refs"))
     baseline = cast(str | None, config.getoption("--bench-baseline"))
     candidate = cast(str | None, config.getoption("--bench-candidate"))
@@ -132,9 +157,44 @@ def arm_specs_from_options(config: pytest.Config) -> tuple[str, ...] | None:
         raise pytest.UsageError(f"invalid benchmark options: {e}") from e
     if arms:
         return tuple(str(a) for a in arms)
+    prepared = installation_for(config)
+    if prepared is not None and prepared.usable:
+        return prepared.arm_specs()
     return None
 
 
+def preparation_problem(config: pytest.Config, sdk: str) -> str | None:
+    """Why this SDK's prepared arms cannot be measured, or None.
+
+    Only consulted when no arms were named explicitly: an explicit request is
+    a statement that the manifest is not what this run should measure.
+    """
+    if any(
+        config.getoption(o) is not None
+        for o in ("--bench-refs", "--bench-baseline", "--bench-candidate")
+    ):
+        return None
+    prepared = installation_for(config)
+    if prepared is None or prepared.sdk != sdk or prepared.usable:
+        return None
+    if prepared.neutral:
+        return f"neutral preparation: {prepared.status_message}"
+    return (
+        f"preparation {prepared.status or 'incomplete'}: "
+        f"{prepared.status_message or 'fewer than two arms were installed'}"
+    )
+
+
+def preparation_is_neutral(config: pytest.Config) -> bool:
+    """True if this run's only prepared arms collapsed onto one commit."""
+    prepared = installation_for(config)
+    return (
+        prepared is not None
+        and prepared.neutral
+        and arm_specs_from_options(config) is None
+    )
+
+
 def arm_count(config: pytest.Config) -> int:
     """How many arms this run will measure per cell."""
     specs = arm_specs_from_options(config)
@@ -451,15 +511,20 @@ def __init__(
         *,
         baseline_spec: str | None = None,
         candidate_spec: str | None = None,
+        problem: dict[str, str | None] | None = None,
     ) -> None:
         self._specs = tuple(specs) if specs else None
         self._baseline_spec = baseline_spec
         self._candidate_spec = candidate_spec
+        self._problem = problem or {}
         self._cache: dict[str, BenchArms] = {}
 
     def __call__(self, sdk: str) -> BenchArms:
         cached = self._cache.get(sdk)
         if cached is None:
+            problem = self._problem.get(sdk)
+            if problem:
+                raise ArmSelectionError(problem)
             cached = self._cache[sdk] = BenchArms(
                 select_arms(
                     sdk,
@@ -476,10 +541,12 @@ def bench_arms(request: pytest.FixtureRequest) -> ArmResolver:
     """Resolver for the arms of any SDK in the run, reference first."""
     config = request.config
     specs = arm_specs_from_options(config)
+    cells = _selected_cells(config)
     return ArmResolver(
         specs,
         baseline_spec=None if specs else config.getoption("--bench-baseline"),
         candidate_spec=None if specs else config.getoption("--bench-candidate"),
+        problem={c.sdk: preparation_problem(config, c.sdk) for c in cells},
     )
 
 
@@ -688,6 +755,24 @@ def runner_metadata(config: pytest.Config) -> dict[str, object]:
         "github_run_id": os.environ.get("GITHUB_RUN_ID", ""),
         "platform_version": _platform_version(),
         "seed": config.getoption("--bench-seed"),
+        **_installation_metadata(config),
+    }
+
+
+def _installation_metadata(config: pytest.Config) -> dict[str, object]:
+    """Provenance from the installation manifest, when the run was prepared.
+
+    Carried into the artifact so a result names the commits it measured
+    rather than only their dist tags, which a moving branch reuses.
+    ``preparation`` is the explicit status a reader checks first: ``neutral``
+    means every requested alias named one commit and nothing was compared.
+    """
+    prepared = installation_for(config)
+    if prepared is None:
+        return {}
+    return {
+        "installation": prepared.to_dict(),
+        "preparation": "neutral" if preparation_is_neutral(config) else prepared.status,
     }
 
 
 
@@ -73,6 +73,10 @@ gate reads, and `p_value_faster` / `p_adjusted_faster` are the matching
 Benjamini–Hochberg values within that key's correction family and are `null`
 for controls and censored keys, which enter no family.
 
+When the run was prepared with `otdf-sdk-mgr install benchmark`,
+`metadata.installation` records each arm's requested alias, commit and dist
+tag, and `metadata.preparation` the preparation status.
+
 ### The table
 
 ```markdown
@@ -265,8 +269,9 @@ things; the noise floor will tell you whether you succeeded.
 | `stats.py` | Pure functions: log-ratios, bootstrap CI, Wilcoxon, BH, the decision rule |
 | `report.py` | Session recorder, JSON artifact (`SCHEMA_VERSION`), step-summary markdown |
 | `config.py` | Option parsing and validation shared by pytest and CI: `BenchConfig`, `--bench-refs`, the arm ceiling, the budget default. No pytest |
+| `installation.py` | Reads the installation manifest `otdf-sdk-mgr install benchmark` writes. No pytest |
 | `docs/` | The figures in this README, and the Monte Carlo behind them. Documentation only; imported by nothing in the harness |
-| `../fixtures/bench.py` | The pytest glue: arm selection (options or defaults), payloads, ciphertexts, budget |
+| `../fixtures/bench.py` | The pytest glue: arm selection (options, manifest, defaults), payloads, ciphertexts, budget |
 | `../test_benchmarks.py` | One test per cell. **Records; never asserts** |
 | `../conftest.py` | `--bench*` options, cell parametrization, the session-finish gate |