@@ -3007,10 +3007,11 @@ jobs:
       # Windows leg of this job exists for own-check.ps1, which is a separate
       # launcher implementation and is the thing Windows actually tests.
       #
-      # NOT here: scripts/p037_verdict_snapshot.py. It is 137 files times two
-      # engines, roughly fourteen minutes, and it is the per-STEP gate each A1.1
-      # commit runs and records under docs/evidence/ — not a per-push check. Saying
-      # so out loud because an unstated omission looks identical to an oversight.
+      # NOT here: the full P-037 verdict/MOS snapshots. The verdict sweep is
+      # 137 files times two engines and the MOS gate additionally measures the
+      # independent repository C# tree. They are per-STEP evidence recorded under
+      # docs/evidence/, not per-push work. The cheap provenance and MOS-reader
+      # controls below ARE per-push so forgetting or hollowing the heavy gate is red.
       - name: P-037 conformance controls + fact-shape census
         if: matrix.os == 'ubuntu-latest'
         run: |
@@ -3024,6 +3025,13 @@ jobs:
           # turned six jobs in this very workflow red: verdict coverage is not
           # syntax/fact-shape coverage, and one fixture per shape fails by NAME.
           python scripts/p037_fact_shapes.py check --engine both
+          # A2.0: a recorded run remains evidence only while its measured
+          # implementation closure and exact input blob set stay unchanged.
+          python tests/test_p037_evidence.py
+          # Level 2 reads the whole MOS document through the existing common
+          # P-022 capture envelope. This cheap control pins that returns and
+          # unresolved fields cannot disappear behind a transfer-only projection.
+          python scripts/p037_mos_snapshot.py --selftest
       # The Windows launcher is a separate implementation, not a wrapper around
       # the shell one, so the Windows leg has to go through it to mean anything.
       - name: Own.NET's own tree, through own-check.ps1 on the Rust core
 
@@ -47,9 +47,14 @@
 from pathlib import Path
 from typing import Any
 
+from p037_evidence import (
+    CORPUS_DIRS,
+    EvidenceRefused,
+    evidence_fields,
+    provenance_problems,
+)
+
 ROOT = Path(__file__).resolve().parent.parent
-CORPUS_DIRS = ("corpus/real-world", "corpus/wpf", "corpus/di", "corpus/fixtures",
-               "corpus/p036-bakeoff")
 VERDICT_LEVELS = ("error", "warning")
 
 
@@ -102,16 +107,19 @@ def take(engine: str, out: Path, dirs: tuple[str, ...]) -> int:
     if not files:
         print("no corpus files found", file=sys.stderr)
         return 2
-    dirty = bool(git("status", "--porcelain"))
+    try:
+        provenance = evidence_fields(dirs)
+    except EvidenceRefused as exc:
+        print(f"REFUSED: {exc}", file=sys.stderr)
+        return 2
     snap: dict[str, Any] = {
-        "schema": "p037-verdict-snapshot/1",
+        "schema": "p037-verdict-snapshot/2",
         "engine": engine,
-        "source_commit": git("rev-parse", "HEAD"),
-        "dirty": dirty,
-        "is_evidence": not dirty,
+        **provenance,
         "corpus": list(dirs),
         "files": {},
     }
+    dirty = bool(snap["dirty"])
     for i, f in enumerate(files, 1):
         rel = f.relative_to(ROOT).as_posix()
         snap["files"][rel] = run_one(f, engine)
@@ -141,6 +149,34 @@ def take(engine: str, out: Path, dirs: tuple[str, ...]) -> int:
     return 0
 
 
+def verify(path: Path) -> int:
+    try:
+        snap: dict[str, Any] = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"REFUSED: {path}: {exc}", file=sys.stderr)
+        return 2
+    if snap.get("schema") != "p037-verdict-snapshot/2":
+        print(
+            f"REFUSED: {path}: schema {snap.get('schema')!r} has no A2.0 provenance closure",
+            file=sys.stderr,
+        )
+        return 2
+    try:
+        problems = provenance_problems(snap)
+    except EvidenceRefused as exc:
+        print(f"REFUSED: {exc}", file=sys.stderr)
+        return 2
+    if problems:
+        for problem in problems:
+            print(f"FAIL[provenance]: {problem}")
+        return 1
+    print(
+        f"OK: {path} is fresh evidence at HEAD; "
+        f"source={snap['source_commit'][:12]}, inputs={len(snap['input_manifest'])}"
+    )
+    return 0
+
+
 def key_set(rec: dict[str, Any], level: str) -> set[tuple[int, str, str]]:
     return {(f["line"], f["code"], f["level"]) for f in rec["findings"]
             if level == "all" or f["level"] in VERDICT_LEVELS}
@@ -205,10 +241,14 @@ def main(argv: list[str]) -> int:
     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")
+    v = sub.add_parser("verify", help="prove a snapshot is still fresh evidence at HEAD")
+    v.add_argument("snapshot", type=Path)
     args = ap.parse_args(argv)
     if args.cmd == "take":
         dirs = tuple(args.corpus) if args.corpus else CORPUS_DIRS
         return take(args.engine, args.out, dirs)
+    if args.cmd == "verify":
+        return verify(args.snapshot)
     return compare(args.before, args.after, args.level)
 
 
 
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Controls for P-037's A2.0 evidence freshness predicate.
+
+These are structure controls, not a second implementation of the predicate:
+the live repository supplies one real evidence record, then each control
+corrupts exactly one claim and requires the shared gate to refuse it.
+"""
+
+from __future__ import annotations
+
+import copy
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT / "scripts"))
+
+import p037_evidence as ev  # noqa: E402
+
+
+failures = 0
+
+
+def ok(name: str) -> None:
+    print(f"ok[{name}]")
+
+
+def fail(name: str, detail: str) -> None:
+    global failures
+    failures += 1
+    print(f"FAIL[{name}]: {detail}")
+
+
+def require_problem(name: str, record: dict[str, object], needle: str) -> None:
+    problems = ev.provenance_problems(record)
+    if any(needle in problem for problem in problems):
+        ok(name)
+    else:
+        fail(name, f"expected a problem containing {needle!r}, got {problems!r}")
+
+
+def main() -> int:
+    problems = ev.closure_problems()
+    if problems:
+        fail("runtime-closure-covered", "; ".join(problems))
+        return 1
+    ok("runtime-closure-covered")
+
+    record = ev.evidence_fields(("corpus/p037-shapes",))
+    live = ev.provenance_problems(record)
+    if live:
+        fail("fresh-record-valid", "; ".join(live))
+        return 1
+    ok("fresh-record-valid")
+
+    missing_subject = copy.deepcopy(record)
+    missing_subject["subject_paths"] = list(ev.SUBJECT_PATHS[:-1])
+    require_problem(
+        "closure-expansion-invalidates",
+        missing_subject,
+        "subject_paths differ",
+    )
+
+    tampered_manifest = copy.deepcopy(record)
+    manifest = tampered_manifest["input_manifest"]
+    assert isinstance(manifest, list) and manifest
+    first = manifest[0]
+    assert isinstance(first, dict)
+    first["blob"] = "0" * 40
+    require_problem(
+        "input-manifest-tamper-refused",
+        tampered_manifest,
+        "input_manifest",
+    )
+
+    non_evidence = copy.deepcopy(record)
+    non_evidence["is_evidence"] = False
+    require_problem(
+        "non-evidence-refused",
+        non_evidence,
+        "is_evidence=true",
+    )
+
+    if failures:
+        print(f"RESULT: {failures} provenance control(s) failed")
+        return 1
+    print("RESULT: all P-037 evidence provenance controls passed")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())