Ask the repository that owns the path, and pin the wirings that had no test

Round four of the independent review found seven record and coverage
defects. The functional side it verified by running; these are the fixes.

- `_tracked` asked the current checkout's index, so a reviewer in a worktree
  pointing at the main checkout's committed report was told it was untracked.
  It now asks the repository that owns the path, and the guard no longer
  compares directories: any tracked file is committed evidence.
- `retrieval.py` claimed the dense index "catches up inside search". It does
  not: `_stale` is only used by `sync()` and `stats()`, so a store upgraded
  from v11 ranks an empty dense leg until `ely-eye build-dense-index` runs.
  The docstring now states that, and `doctor` already names it.
- Four wirings had no discriminating test, each proven by mutation:
  a stubbed `_tracked` (now a test uses the real git index), `copy_store`
  claiming the scratch (now a live holder blocks the copy before a byte is
  copied), `_stale` reading the atoms table (now a closed memory that loses
  its vector is owed one), and the v10/v11 to v12 `DROP VIEW` gate (now a
  hand-made v11 store is upgraded and its view body re-checked).
- The record corrected against the reviewer's measurements: the five
  mutations did not each turn one test red (M1 turned two, M3 turned two,
  `_stale` alone turned none), the pyright/mypy file set was wrong, and the
  round added seven tests rather than three.

Gates: 422 passed; ruff clean; filesize clean; audit clean; mypy 24 errors in
9 files repo-wide, equal to the 9cb46c1 baseline; pyright 0 on the nine
touched files; zero whole-line comment blocks over 157 tracked files.

bench/tests/test_scratch.py

@@ -29,3 +29,18 @@ def test_one_run_may_copy_more_than_once(tmp_path: Path) -> None:
     scratch.claim(tmp_path)
     scratch.claim(tmp_path)
     assert (tmp_path / scratch.HELD).read_text(encoding="utf-8") == str(os.getpid())
+
+
+def test_copy_store_claims_the_copy_it_makes(tmp_path: Path) -> None:
+    """The claim lives inside `copy_store`, so a harness cannot step on a live run by forgetting to call `claim`."""
+    if not Path("/proc/1").exists():
+        pytest.skip("liveness is read from /proc")
+    source = tmp_path / "source"
+    (source / "data").mkdir(parents=True)
+    (source / "data" / "ely_eye.sqlite").write_text("store", encoding="utf-8")
+    busy = tmp_path / "scratch"
+    busy.mkdir()
+    (busy / scratch.HELD).write_text("1", encoding="utf-8")
+    with pytest.raises(SystemExit, match="is held by pid 1"):
+        scratch.copy_store(source, busy)
+    assert not (busy / "data").exists(), "the refusal must come before a byte is copied"

bench/tests/test_video_audio_check.py

@@ -11,8 +11,7 @@ from bench import video_audio_check
 def test_a_frozen_report_is_not_overwritten_by_a_harness(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """A reviewer runs harnesses in a worktree of its own; the committed evidence stays put."""
-    monkeypatch.setattr(video_audio_check, "PAYLOAD", tmp_path / "video_audio.json")
+    """A reviewer runs harnesses in a worktree of its own; the committed evidence stays put, in any directory."""
     monkeypatch.setattr(video_audio_check, "_tracked", lambda path: True)
     frozen = tmp_path / "VIDEO_AUDIO.md"
     frozen.write_text("committed evidence", encoding="utf-8")
@@ -21,14 +20,14 @@ def test_a_frozen_report_is_not_overwritten_by_a_harness(
     elsewhere = tmp_path / "scratch" / "VIDEO_AUDIO.md"
     elsewhere.parent.mkdir()
     elsewhere.write_text("scratch", encoding="utf-8")
-    video_audio_check.refuse_frozen_overwrite(elsewhere)
+    with pytest.raises(SystemExit, match="is a frozen report"):
+        video_audio_check.refuse_frozen_overwrite(elsewhere)
 
 
 def test_a_harness_may_write_its_own_untracked_output(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
     """The default destination is the reports directory; refusing it would stop the shipped run."""
-    monkeypatch.setattr(video_audio_check, "PAYLOAD", tmp_path / "video_audio.json")
     monkeypatch.setattr(video_audio_check, "_tracked", lambda path: False)
     fresh = tmp_path / "VIDEO_AUDIO.md"
     fresh.write_text("not yet evidence", encoding="utf-8")
@@ -38,8 +37,7 @@ def test_a_harness_may_write_its_own_untracked_output(
 def test_an_absolute_path_to_the_frozen_directory_is_refused_too(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
-    """The guard compares where the file really lands, not how the path was spelled."""
-    monkeypatch.setattr(video_audio_check, "PAYLOAD", tmp_path / "video_audio.json")
+    """The guard asks about the file, not the spelling of its path."""
     monkeypatch.setattr(video_audio_check, "_tracked", lambda path: True)
     frozen = tmp_path / "VIDEO_AUDIO.md"
     frozen.write_text("committed evidence", encoding="utf-8")
@@ -47,11 +45,21 @@ def test_an_absolute_path_to_the_frozen_directory_is_refused_too(
         video_audio_check.refuse_frozen_overwrite(Path(frozen.resolve()))
 
 
+def test_a_committed_report_is_frozen_without_any_stub(tmp_path: Path) -> None:
+    """A stubbed `_tracked` proves the branch works, not that the guard does: this test uses the real git index."""
+    committed = Path("bench/reports/LEGS.md")
+    assert committed.exists(), "the acceptance needs a tracked report to refuse"
+    with pytest.raises(SystemExit, match="is a frozen report"):
+        video_audio_check.refuse_frozen_overwrite(committed)
+    elsewhere = tmp_path / "LEGS.md"
+    elsewhere.write_text("mine", encoding="utf-8")
+    video_audio_check.refuse_frozen_overwrite(elsewhere)
+
+
 def test_the_probe_arm_switches_off_rather_than_ranking_nothing() -> None:
     """--probes 0 means "skip that arm"; a small count with the smoke knob means "you measured nothing"."""
     assert video_audio_check.probe_sample(0, 0) == []
-    # The shipped sample keeps every modality; the smoke knob narrows it to video, where a
-    # small count can miss the modality entirely (the reviewer's --limit 1 --probes 1 crash).
+    # The shipped sample keeps every modality; the smoke knob narrows it to video, where a small count can miss one entirely.
     assert any(query.modality == video_audio_check.VIDEO_MODALITY for query in video_audio_check.probe_sample(300, 0))
     for probes in (1, 5):
         with pytest.raises(SystemExit, match=f"--probes {probes} picked no answerable video query"):

bench/video_audio_check.py

@@ -272,10 +272,17 @@ def write_markdown(report: dict[str, Any], destination: Path) -> None:
 
 
 def _tracked(path: Path) -> bool:
-    """Only committed evidence is frozen; a harness's own untracked output is fair game."""
+    """Only committed evidence is frozen; a harness's own untracked output is fair game.
+
+    The question goes to the repository that owns the path, so a reviewer working in a worktree
+    cannot point at another checkout's committed report and be told it is untracked.
+    """
+    owner = path.resolve().parent
     return (
         subprocess.run(
-            ["git", "ls-files", "--error-unmatch", str(path)], capture_output=True, check=False
+            ["git", "-C", str(owner), "ls-files", "--error-unmatch", path.resolve().name],
+            capture_output=True,
+            check=False,
         ).returncode
         == 0
     )
@@ -283,9 +290,7 @@ def _tracked(path: Path) -> bool:
 
 def refuse_frozen_overwrite(destination: Path) -> None:
     """A reviewer running this in a worktree of its own must not overwrite the committed evidence."""
-    if destination.exists() and destination.resolve().parent == PAYLOAD.resolve().parent and _tracked(
-        destination
-    ):
+    if destination.exists() and _tracked(destination):
         raise SystemExit(
             f"{destination} is a frozen report; point --report and --payload somewhere else, or "
             "delete the frozen copy on purpose rather than under a harness"