test: current-checkout mode for the projected-pair TG runner and assessor

run_case --current-checkout records the clean checkout (HEAD, src
fingerprint, harness hashes, pinned build-capture helper) labelled
current_checkout instead of requiring the frozen a135252 tree; receipts
carry numerical_revision=None. assess --current-checkout applies the same
gates to such receipts. Frozen mode is unchanged and now rejects any
receipt with source_mode, so the two never cross-qualify. A missing a135252
object is reported as unavailable history instead of a source diff.
check_projected_pairs.py is untouched, so its pinned hash and existing
receipts keep their meaning.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/validation/taylor_green/test_projected_pairs.py

@@ -291,6 +291,48 @@ class ProjectedPairsTests(unittest.TestCase):
                 else:
                     self.assertEqual(run_case.verify_source(REPO, expected), source())
 
+    def test_frozen_mode_reports_missing_history_not_a_diff(self):
+        from tests.validation.multigrid import check_projected_pairs as gate
+        missing = SimpleNamespace(returncode=128)
+        with patch.object(run_case.subprocess, "run", return_value=missing), \
+             patch.object(gate, "preflight") as preflight:
+            with self.assertRaisesRegex(RuntimeError, "not available in this clone"):
+                run_case.verify_source(REPO, MOCK_REVISION)
+            preflight.assert_not_called()
+
+    def test_current_checkout_source_is_recorded_not_frozen(self):
+        from tests.validation.multigrid import check_projected_pairs as gate
+        current = dict(source(), source_tree_sha256="c" * 64)
+        with patch.object(run_case, "provenance", return_value=dict(current)), \
+             patch.object(gate, "preflight") as preflight:
+            result = run_case.verify_source(REPO, MOCK_REVISION, current=True)
+            preflight.assert_not_called()
+        self.assertEqual(result["source_mode"], "current_checkout")
+        self.assertEqual(result["source_capture"], run_case.CURRENT_CAPTURE)
+        for bad in (dict(current, dirty=True), dict(current, revision=OLD_REVISION)):
+            with self.subTest(bad=bad), patch.object(run_case, "provenance", return_value=bad):
+                with self.assertRaisesRegex(ValueError, "exact expected clean checkout"):
+                    run_case.verify_source(REPO, MOCK_REVISION, current=True)
+
+    def test_current_and_frozen_receipts_never_cross_assess(self):
+        frozen = records()
+        current = deepcopy(frozen)
+        for r in current:
+            r["source"] = dict(r["source"], source_tree_sha256="c" * 64,
+                               source_mode="current_checkout",
+                               source_capture=run_case.CURRENT_CAPTURE)
+            r["numerical_revision"], r["source_mode"] = None, "current_checkout"
+        ok = assess(current, MOCK_REVISION, current=True)
+        self.assertTrue(ok["checks"]["clean_current_checkout_source"])
+        self.assertTrue(all(v for k, v in ok["checks"].items() if k.endswith(" reference")))
+        self.assertEqual((ok["source_mode"], ok["numerical_revision"]), ("current_checkout", None))
+        self.assertEqual(ok["source_tree_sha256"], "c" * 64)
+        self.assertFalse(assess(current, MOCK_REVISION)["checks"]["clean_a135252_numerical_source"])
+        self.assertFalse(assess(current, MOCK_REVISION)["passed"])
+        self.assertFalse(assess(frozen, MOCK_REVISION, current=True)["checks"]["clean_current_checkout_source"])
+        self.assertFalse(assess(current, None, current=True)["checks"]["clean_current_checkout_source"])
+        self.assertTrue(assess(frozen, MOCK_REVISION)["checks"]["clean_a135252_numerical_source"])
+
     def test_explicit_opt_in_selector_and_dry_run_without_cuda(self):
         with tempfile.TemporaryDirectory() as tmp:
             output = Path(tmp) / "case.json"