feat: preserve Quant OS target-package vertical slice

tests/test_public_status.py

@@ -1,4 +1,5 @@
 import importlib.util
+import hashlib
 import json
 import os
 import re
@@ -112,10 +113,191 @@ class PublicStatusTests(unittest.TestCase):
 
         platforms = {platform["name"]: platform for platform in payload["platforms"]}
         self.assertEqual(platforms["JoinQuant hosted bundle"]["status"], "real_runtime")
+        self.assertIn(
+            "3",
+            platforms["JoinQuant hosted bundle"]["claim"],
+        )
+        self.assertIn(
+            "execution",
+            platforms["JoinQuant hosted bundle"]["limitations"][0],
+        )
         self.assertEqual(platforms["QMT built-in bundle"]["status"], "implemented")
         self.assertFalse(platforms["XtTrader read-only shadow"]["liveReady"])
         self.assertIn("fake", platforms["XtTrader read-only shadow"]["claim"].lower())
 
+    def test_candidate_records_only_real_joinquant_execution_observation(self):
+        payload = _read_payload()
+        candidate = payload["candidateBoundary"]
+        self.assertEqual(candidate["decisionMode"], "target_package")
+        self.assertEqual(candidate["localEvidenceClass"], "synthetic_research")
+        self.assertTrue(candidate["realJoinQuantObserved"])
+        self.assertFalse(candidate["realQmtObserved"])
+        self.assertEqual(
+            candidate["realPlatformObservedLayers"],
+            ["execution"],
+        )
+        self.assertFalse(candidate["allFiveLayersRealPlatformObserved"])
+        run = candidate["joinQuantTargetPackageRun"]
+        self.assertEqual(
+            run["runId"],
+            "2457a7c39a276e09e0fabf99e28978e1",
+        )
+        self.assertEqual(run["evidenceClass"], "synthetic-research")
+        self.assertEqual(run["observedLayers"], ["execution"])
+        self.assertEqual((run["orders"], run["fills"]), (3, 3))
+        self.assertFalse(run["allFiveLayersObserved"])
+        self.assertFalse(run["qmtPeerObserved"])
+        self.assertFalse(run["g9Passed"])
+        self.assertFalse(run["baseline60Passed"])
+        self.assertFalse(run["investmentValueClaim"])
+        self.assertFalse(candidate["joinQuantTargetPackageCountsAsBaseline"])
+        self.assertFalse(candidate["joinQuantTargetPackageCountsAsG9"])
+        self.assertEqual(
+            candidate["historicalJoinQuantMode"], "portable_momentum_smoke"
+        )
+        self.assertFalse(candidate["historicalJoinQuantCountsAsBaseline"])
+        self.assertTrue(payload["summary"]["candidateRealPlatformObserved"])
+        self.assertEqual(
+            payload["summary"]["candidateRealPlatformObservationScope"],
+            "target_package_execution_consumer_only",
+        )
+        self.assertFalse(
+            payload["summary"]["allFiveLayersRealPlatformObserved"]
+        )
+        reachability = candidate["reachability"]
+        self.assertEqual(
+            reachability["releaseId"], "quant60-research-candidate-v1"
+        )
+        self.assertTrue(
+            reachability["summary"]["all_layers_implemented"]
+        )
+        self.assertTrue(
+            reachability["summary"]["all_layers_local_entrypoint_reachable"]
+        )
+        self.assertFalse(
+            reachability["summary"]["all_layers_real_platform_observed"]
+        )
+        self.assertEqual(
+            reachability["realPlatformsObserved"],
+            ["joinquant"],
+        )
+        self.assertEqual(
+            reachability["realPlatformObservedLayers"],
+            ["execution"],
+        )
+        evidence = {item["id"]: item for item in payload["evidence"]}
+        self.assertEqual(
+            evidence["release-reachability"]["path"],
+            "releases/quant60-research-candidate-v1/reachability.json",
+        )
+        self.assertEqual(
+            evidence["joinquant-target-package-run"]["path"],
+            "evidence/joinquant/TP-20240311-795dcfba/"
+            "2457a7c39a276e09e0fabf99e28978e1/run.json",
+        )
+        self.assertEqual(
+            evidence["joinquant-target-package-evidence"]["path"],
+            "docs/JOINQUANT_TARGET_PACKAGE_EVIDENCE_2026-07-26.md",
+        )
+
+        gaps = payload["deliveryGaps"]
+        self.assertGreaterEqual(len(gaps["internal"]), 3)
+        self.assertGreaterEqual(len(gaps["externalEvidence"]), 5)
+        internal = " ".join(gaps["internal"])
+        self.assertIn("provider-data", internal)
+        self.assertIn("factor_risk.py", internal)
+        self.assertIn("CVXPY", internal)
+        self.assertIn("TWAP/POV", internal)
+        self.assertIn("synthetic-research", internal)
+        self.assertIn("TargetPackageV1", internal)
+        self.assertIn("real JoinQuant", internal)
+        self.assertIn("real QMT", internal)
+
+    def test_public_builder_rejects_wrong_reachability_evidence_class(self):
+        module = _load_builder()
+        path = (
+            PROJECT
+            / "releases"
+            / "quant60-research-candidate-v1"
+            / "reachability.json"
+        )
+        manifest = json.loads(path.read_text(encoding="utf-8"))
+        artifact = manifest["layers"]["alpha"]["jq_entrypoint_reachable"][
+            "artifacts"
+        ][0]
+        artifact["kind"] = "source"
+        body = {
+            key: value
+            for key, value in manifest.items()
+            if key != "manifest_sha256"
+        }
+        manifest["manifest_sha256"] = hashlib.sha256(
+            json.dumps(
+                body,
+                ensure_ascii=False,
+                sort_keys=True,
+                separators=(",", ":"),
+            ).encode("utf-8")
+        ).hexdigest()
+        with self.assertRaises(module.PublicStatusError):
+            module._validate_reachability_manifest(PROJECT, manifest)
+
+    def test_public_builder_rejects_upstream_real_platform_overclaim(self):
+        module = _load_builder()
+        path = (
+            PROJECT
+            / "releases"
+            / "quant60-research-candidate-v1"
+            / "reachability.json"
+        )
+        manifest = json.loads(path.read_text(encoding="utf-8"))
+        artifact = dict(
+            manifest["layers"]["execution"]["real_platform_observed"][
+                "artifacts"
+            ][0]
+        )
+        artifact["artifact_id"] = "alpha-real-platform-overclaim"
+        manifest["layers"]["alpha"]["real_platform_observed"] = {
+            "status": True,
+            "artifacts": [artifact],
+        }
+        body = {
+            key: value
+            for key, value in manifest.items()
+            if key != "manifest_sha256"
+        }
+        manifest["manifest_sha256"] = hashlib.sha256(
+            json.dumps(
+                body,
+                ensure_ascii=False,
+                sort_keys=True,
+                separators=(",", ":"),
+            ).encode("utf-8")
+        ).hexdigest()
+        with self.assertRaisesRegex(
+            module.PublicStatusError,
+            "only JoinQuant execution",
+        ):
+            module._validate_reachability_manifest(PROJECT, manifest)
+
+    def test_public_builder_rejects_target_package_performance_claim(self):
+        module = _load_builder()
+        path = (
+            PROJECT
+            / "evidence"
+            / "joinquant"
+            / "TP-20240311-795dcfba"
+            / "2457a7c39a276e09e0fabf99e28978e1"
+            / "run.json"
+        )
+        run = json.loads(path.read_text(encoding="utf-8"))
+        run["performance_claim"] = True
+        with self.assertRaisesRegex(
+            module.PublicStatusError,
+            "evidence classes are unsafe",
+        ):
+            module._validate_joinquant_target_package_run(PROJECT, run)
+
     def test_freshness_uses_daily_bars_not_the_later_trade_calendar(self):
         payload = _read_payload()
         freshness = {item["id"]: item for item in payload["freshness"]}
@@ -124,6 +306,19 @@ class PublicStatusTests(unittest.TestCase):
             freshness["joinquant-hosted-market-window"]["marketDataThrough"],
             "2024-12-31",
         )
+        target_package = freshness[
+            "joinquant-target-package-execution-smoke"
+        ]
+        self.assertEqual(target_package["marketDataFrom"], "2024-03-11")
+        self.assertEqual(target_package["marketDataThrough"], "2024-03-13")
+        self.assertEqual(
+            target_package["observedAt"],
+            "2026-07-26T08:50:15Z",
+        )
+        self.assertFalse(target_package["productionReady"])
+        self.assertFalse(target_package["investmentValueClaim"])
+        self.assertIn("execution", target_package["semantics"])
+        self.assertIn("G9", target_package["semantics"])
 
         tushare = freshness["tushare-daily-market-data"]
         self.assertEqual(tushare["completedPartitions"], 35)