@@ -2522,3 +2522,91 @@ above: B1 tooling and this note land first; `T_B` and `R_B` remain "not
 this task" until their own evidence is terminal-green; the first semantic
 treatment remains named, scoped to `production_diff_gate.rust`'s mutable
 items, and unattempted.
+
+#### 10.8a Phase B / B1: completing the instrument's last gap before R_B
+
+§10.8's own text on `scripts/p037_evidence_b.py` already named an open
+mechanical question rather than papering over it: `p037_mos_snapshot.py`
+and `p037_verdict_snapshot.py`'s `take()`/`compare()`/`verify()` bodies
+call a module-global `ev` bound, at the top of each file, by a single
+hardcoded `import p037_evidence as ev` — meaning both tools would stamp
+epoch `"a2d"` no matter what a caller wanted, and taking R_B with them
+as written was not actually possible. `4e75abe` froze the classifier,
+the gate and the environment identity with that gap still open; this
+addendum closes it, on top of `4e75abe`, before R_B is taken.
+
+**REPOSITORY FACT.** Not every `ev.*` name these two tools use is
+epoch-specific. `p037_evidence_b.py`'s own docstring already listed the
+population/profile/artifact/environment/git/manifest mechanics it
+imports unchanged from `p037_evidence.py`, stating the intent plainly:
+"so `p037_mos_snapshot.py`/`p037_verdict_snapshot.py`'s existing `take()`
+bodies can build a record from either module by calling the same-named
+function." That sentence was aspirational until now — `p037_evidence_b`
+did not yet expose those pure names at its own top level (only reachable
+as `p037_evidence_b.ev.scratch_problems`, not `p037_evidence_b.
+scratch_problems`), so binding a caller's `ev` to it would have raised
+`AttributeError` on the first pure call. Fixed by sixteen one-line
+re-exports (`scratch_problems = ev.scratch_problems`, and so on for
+`execution_profile`, `build_rust_artifact`, `artifact_problems`,
+`acquire_population`, `release_population`, `materialization_root`,
+`new_take_dir`, `seal_artifact`, `materialize_population`,
+`external_ancestor_problems`, `analysis_paths`, `sanitized_env`,
+`clean_reference_profile`, `finalize_run`, `reference_contamination`) —
+each one the literal same function object as `p037_evidence`'s, checked
+directly (`p037_evidence_b.scratch_problems is p037_evidence.
+scratch_problems` → `True`), not merely asserted.
+
+**Design: explicit `--epoch`, no silent selection.** Both snapshot tools
+gain a required `--epoch {a2d,b}` argument on every subcommand that
+touches `ev` (`take`, `compare`, `verify`) — matching
+`p037_verdict_snapshot.py`'s own pre-existing "ENGINE is explicit and
+required" precedent for exactly the same reason, and satisfying the B1
+brief's explicit list of forbidden mechanisms: no implicit "current
+epoch", no branch-name inference, no silently-read environment variable.
+`main()` resolves `args.epoch` against a two-entry `EPOCH_MODULES` dict
+(`{"a2d": p037_evidence, "b": p037_evidence_b}`) and rebinds the
+module-global `ev` to the selected module *before* calling `take()`/
+`compare()`/`verify()` — whose bodies are otherwise byte-for-byte
+unchanged, because every `ev.NAME` reference inside them is an attribute
+lookup Python resolves at call time, not at function-definition time.
+The one place that was NOT already call-time-lazy was
+`p037_mos_snapshot.py`'s module-level `SOURCES` dict, which captured
+`ev.CORPUS_DIRS`/`ev.REPO_TREE_DIRS` as plain tuples at import time —
+before any `--epoch` argument exists to read. Replaced with a `_sources
+(epoch_mod)` function called inside `take()` itself, after `ev` is
+rebound, so `--epoch b` actually reaches the augmented `CORPUS_DIRS`
+(`p037_evidence_b`'s tuple, plus `corpus/p037-shapes`) instead of
+silently reusing a2d's.
+
+**MEASURED/AUDITED FACT.** The a2d path was proven unbroken by real
+execution against already-accepted evidence, not by code review alone:
+`p037_mos_snapshot.py verify --epoch a2d docs/evidence/p037-a2d-baseline-
+mos-repo.json --against 44b405c2003b1d68965fe6346c2506d51ed52def` still
+reports `OK: ... fresh evidence at 44b405c2003b ...; inputs=82,
+support=3`, identical to its pre-change behaviour. The same command
+against current `HEAD` correctly reports `FAIL[provenance]: the
+treatment changed between 44b405c2003b and HEAD` — the A2.2-D door
+treatment landing after `T_D`, exactly as A2.2-D's own design intends,
+and unrelated to this change. `p037_evidence_b.EPOCH_MODULES` (read via
+each snapshot tool's own dict of the same name) resolves `"a2d"` to
+`p037_evidence` and `"b"` to `p037_evidence_b`, with `CORPUS_DIRS`
+differing exactly as designed (`"corpus/p037-shapes" in ...` is `False`
+for a2d, `True` for b) and `REPO_TREE_DIRS` identical on both (b never
+had a different repo-tree population). `ruff check .`, the project-wide
+`mypy`, `tests/test_p037_a2d_epoch.py` (14/14) and `tests/
+test_p037_evidence.py` all stay green on a clean tree; the one transient
+`FAIL[fresh-record-valid]` seen while this addendum's own files were
+still uncommitted was `evidence was taken on a dirty tree` — the test's
+own real-`git`-backed fixture correctly reporting this checkout's actual
+dirty state at that moment, not a defect in the fix, and gone once
+committed.
+
+**Consequence for T_B.** `4e75abe`'s production-diff gate verdict
+(`IDENTICAL` against `5571ba4`) is untouched by this addendum — none of
+its three files lie under `rust/crates/own-bridge/`. But `4e75abe` could
+not actually take Phase-B evidence, so it is not offered as `T_B`: the
+commit landing this addendum is, once it is itself pushed and confirmed
+terminal-green (including fast Kani) the same way `4e75abe` was. `4e75abe`
+stays exactly as committed, an honest record of the instrument as it
+stood one step before the gap was found — the same discipline §10.7a and
+§10.6.14a both already apply to their own preceding heads.
@@ -68,6 +68,31 @@
 
 EvidenceRefused = ev.EvidenceRefused
 
+# Re-exported verbatim so this module is a full drop-in for `ev` wherever a
+# caller's code (unchanged) reaches for one of these names -- see
+# scripts/p037_mos_snapshot.py and scripts/p037_verdict_snapshot.py's
+# --epoch dispatch, which rebinds their module-global `ev` to this module or
+# to p037_evidence and calls the same, already-written take()/_measure()
+# bodies either way. None of these read EPOCH/EPOCH_RECORD_PATH/
+# INSTRUMENT_PATHS internally (see module docstring), so aliasing them here
+# moves zero bytes of logic and adds none.
+scratch_problems = ev.scratch_problems
+execution_profile = ev.execution_profile
+build_rust_artifact = ev.build_rust_artifact
+artifact_problems = ev.artifact_problems
+acquire_population = ev.acquire_population
+release_population = ev.release_population
+materialization_root = ev.materialization_root
+new_take_dir = ev.new_take_dir
+seal_artifact = ev.seal_artifact
+materialize_population = ev.materialize_population
+external_ancestor_problems = ev.external_ancestor_problems
+analysis_paths = ev.analysis_paths
+sanitized_env = ev.sanitized_env
+clean_reference_profile = ev.clean_reference_profile
+finalize_run = ev.finalize_run
+reference_contamination = ev.reference_contamination
+
 EPOCH = "b"
 EPOCH_RECORD_PATH = "docs/evidence/p037-b-epoch.json"
 
 
@@ -46,6 +46,7 @@
 sys.path.insert(0, str(ROOT))
 
 import p037_evidence as ev  # noqa: E402
+import p037_evidence_b  # noqa: E402
 from shadow_compare import (  # noqa: E402
     DEFAULT_TIMEOUT_SECONDS,
     ExecutionFailure,
@@ -57,10 +58,19 @@
 from ownlang.repro import ENGINE_PYTHON, ENGINE_RUST, hash_bytes  # noqa: E402
 
 SCHEMA = "p037-mos-snapshot/2"
-SOURCES: dict[str, tuple[str, ...]] = {
-    "corpus": ev.CORPUS_DIRS,
-    "repo": ev.REPO_TREE_DIRS,
-}
+SOURCE_NAMES: tuple[str, ...] = ("corpus", "repo")
+# Epoch is explicit and required, matching p037_verdict_snapshot.py's own
+# "ENGINE is explicit and required" precedent -- never an implicit "current
+# epoch", branch-name inference or a silently-read env var (P-037 Phase B
+# prompt, section on epoch-aware tooling). main() rebinds the module-global
+# `ev` to the selected module before calling take()/_measure()/compare()/
+# verify()/extract_facts() below; their bodies read `ev.*` at call time and
+# are otherwise UNCHANGED for either epoch.
+EPOCH_MODULES: dict[str, Any] = {"a2d": ev, "b": p037_evidence_b}
+
+
+def _sources(epoch_mod: Any) -> dict[str, tuple[str, ...]]:
+    return {"corpus": epoch_mod.CORPUS_DIRS, "repo": epoch_mod.REPO_TREE_DIRS}
 
 
 class ReferenceContamination(RuntimeError):
@@ -189,7 +199,7 @@ def _refuse(problems: list[str]) -> None:
 
 
 def take(source: str, out: Path, timeout: float, population_commit: str) -> int:
-    roots = SOURCES[source]
+    roots = _sources(ev)[source]
     try:
         _refuse(ev.scratch_problems(out))
         provenance = ev.evidence_fields(roots, population_commit=population_commit)
@@ -461,23 +471,29 @@ def main(argv: list[str]) -> int:
     ap.add_argument("--selftest", action="store_true")
     sub = ap.add_subparsers(dest="cmd")
     t = sub.add_parser("take")
-    t.add_argument("--source", required=True, choices=tuple(SOURCES))
+    t.add_argument("--epoch", required=True, choices=tuple(EPOCH_MODULES))
+    t.add_argument("--source", required=True, choices=SOURCE_NAMES)
     t.add_argument("--out", required=True, type=Path)
     t.add_argument("--population-commit", default="HEAD",
                    help="the commit whose blobs are analysed (default HEAD; the after "
                         "side of a pair names the baseline's commit)")
     t.add_argument("--timeout", type=float, default=DEFAULT_TIMEOUT_SECONDS)
     c = sub.add_parser("compare")
+    c.add_argument("--epoch", required=True, choices=tuple(EPOCH_MODULES))
     c.add_argument("--before", required=True, type=Path)
     c.add_argument("--after", required=True, type=Path)
     c.add_argument("--against", default="HEAD",
                    help="the commit the after side must be fresh at (default HEAD)")
     v = sub.add_parser("verify")
+    v.add_argument("--epoch", required=True, choices=tuple(EPOCH_MODULES))
     v.add_argument("snapshot", type=Path)
     v.add_argument("--against", default="HEAD")
     args = ap.parse_args(argv)
     if args.selftest:
         return selftest()
+    if args.cmd in ("take", "compare", "verify"):
+        global ev
+        ev = EPOCH_MODULES[args.epoch]
     if args.cmd == "take":
         return take(args.source, args.out, args.timeout, args.population_commit)
     if args.cmd == "compare":
 
@@ -56,10 +56,19 @@
 from typing import Any
 
 import p037_evidence as ev
+import p037_evidence_b
 
 ROOT = Path(__file__).resolve().parent.parent
 SCHEMA = "p037-verdict-snapshot/3"
 VERDICT_LEVELS = ("error", "warning")
+# Epoch is explicit and required -- same precedent this module's own
+# docstring already states for ENGINE, extended to epoch selection (P-037
+# Phase B: never an implicit "current epoch", branch-name inference or a
+# silently-read env var). main() rebinds the module-global `ev` to the
+# selected module before calling take()/_measure()/compare()/verify()/
+# run_one() below; their bodies read `ev.*` at call time and are otherwise
+# UNCHANGED for either epoch.
+EPOCH_MODULES: dict[str, Any] = {"a2d": ev, "b": p037_evidence_b}
 
 
 def run_one(path: Path, engine: str, env: dict[str, str]) -> dict[str, Any]:
@@ -313,23 +322,28 @@ def main(argv: list[str]) -> int:
                                  formatter_class=argparse.RawDescriptionHelpFormatter)
     sub = ap.add_subparsers(dest="cmd", required=True)
     t = sub.add_parser("take", help="record a snapshot")
+    t.add_argument("--epoch", required=True, choices=tuple(EPOCH_MODULES))
     t.add_argument("--engine", required=True, choices=("rust", "python"))
     t.add_argument("--out", required=True, type=Path)
     t.add_argument("--corpus", action="append", default=None, metavar="DIR")
     t.add_argument("--population-commit", default="HEAD",
                    help="the commit whose blobs are analysed (default HEAD; the after "
                         "side of a pair names the baseline's commit)")
     c = sub.add_parser("compare", help="diff two snapshots")
+    c.add_argument("--epoch", required=True, choices=tuple(EPOCH_MODULES))
     c.add_argument("--before", required=True, type=Path)
     c.add_argument("--after", required=True, type=Path)
     c.add_argument("--level", default="verdict", choices=("verdict", "all"),
                    help="verdict = error/warning only (default); all = advisories too")
     c.add_argument("--against", default="HEAD",
                    help="the commit the after side must be fresh at (default HEAD)")
     v = sub.add_parser("verify", help="prove a snapshot is still fresh evidence at a commit")
+    v.add_argument("--epoch", required=True, choices=tuple(EPOCH_MODULES))
     v.add_argument("snapshot", type=Path)
     v.add_argument("--against", default="HEAD")
     args = ap.parse_args(argv)
+    global ev
+    ev = EPOCH_MODULES[args.epoch]
     if args.cmd == "take":
         dirs = tuple(args.corpus) if args.corpus else ev.CORPUS_DIRS
         return take(args.engine, args.out, dirs, args.population_commit)