fix: restore accuracy-first route admission

tests/test_submission_safety.py

@@ -21,6 +21,7 @@ from modelhub_client import (  # noqa: E402
     parse_model_submission_precheck,
 )
 from models import HFModelSummary, ModelInspection  # noqa: E402
+from outcome_tracker import OutcomeTracker  # noqa: E402
 from submission_exclusions import SubmissionExclusionStore  # noqa: E402
 from template_selector import TemplateSelector  # noqa: E402
 
@@ -286,9 +287,10 @@ class SubmissionSafetyTests(unittest.TestCase):
         }
         precheck = parse_model_submission_precheck(payload)
         self.assertEqual(
-            {"running", "success", "unknown", "failed_without_framework"},
+            {"failed", "running", "success", "unknown", "failed_without_framework"},
             precheck["processedGpus"],
         )
+        self.assertEqual({"success"}, precheck["successfulGpus"])
         self.assertEqual({"failed": {"vllm"}}, precheck["failedFrameworksByGpu"])
 
     def test_unverified_gpu_becomes_candidate_but_validating_gpu_does_not(self) -> None:
@@ -321,7 +323,7 @@ class SubmissionSafetyTests(unittest.TestCase):
         self.assertEqual([], active_candidates)
         self.assertEqual("already_processed_for_gpu", active_skips[0]["reason"])
 
-    def test_failed_gpu_requires_an_alternative_framework(self) -> None:
+    def test_failed_gpu_remains_closed_even_when_an_alternative_framework_exists(self) -> None:
         model = SafeDiscovery().model
         client = FailedFrameworkClient()
         candidates, skipped, failed = process_model_for_candidates(
@@ -334,23 +336,14 @@ class SubmissionSafetyTests(unittest.TestCase):
             market_intelligence=TwoFrameworkMarket(),  # type: ignore[arg-type]
             official_registry=AllGpuOfficialRegistry(),  # type: ignore[arg-type]
         )
-        self.assertEqual([], skipped)
+        self.assertEqual("prior_failed_gpu_closed_accuracy_first", skipped[-1]["reason"])
         self.assertEqual([], failed)
-        self.assertEqual(["vllm-mlu"], [item["framework"] for item in candidates])
-        self.assertEqual(["vllm"], candidates[0]["previousFailedFrameworks"])
+        self.assertEqual([], candidates)
 
-        blocked = submit_candidate({**candidates[0], "framework": "vllm"}, client)  # type: ignore[arg-type]
-        accepted = submit_candidate(candidates[0], client)  # type: ignore[arg-type]
+        blocked = submit_candidate(candidate("Cambricon_mlu-370-x4"), client)  # type: ignore[arg-type]
         self.assertEqual("duplicate", blocked["outcome"])
-        self.assertEqual("prior_failed_framework_for_gpu", blocked["reason"])
-        self.assertEqual("submitted", accepted["outcome"])
-        self.assertEqual(1, client.add_calls)
-
-        unvetted = submit_candidate(
-            {**candidates[0], "frameworkEvidenceQualified": False}, client  # type: ignore[arg-type]
-        )
-        self.assertEqual("framework_evidence_deferred", unvetted["outcome"])
-        self.assertEqual(1, client.add_calls)
+        self.assertEqual("prior_failed_gpu_closed_accuracy_first", blocked["reason"])
+        self.assertEqual(0, client.add_calls)
 
         no_routes, no_route_skips, _ = process_model_for_candidates(
             model=model,
@@ -363,7 +356,7 @@ class SubmissionSafetyTests(unittest.TestCase):
             official_registry=AllGpuOfficialRegistry(),  # type: ignore[arg-type]
         )
         self.assertEqual([], no_routes)
-        self.assertEqual("prior_failed_framework_no_alternative", no_route_skips[-1]["reason"])
+        self.assertEqual("prior_failed_gpu_closed_accuracy_first", no_route_skips[-1]["reason"])
 
         no_market_routes, no_market_skips, _ = process_model_for_candidates(
             model=model,
@@ -375,10 +368,65 @@ class SubmissionSafetyTests(unittest.TestCase):
         )
         self.assertEqual([], no_market_routes)
         self.assertEqual(
-            "prior_failed_gpu_requires_public_framework_evidence",
+            "prior_failed_gpu_closed_accuracy_first",
             no_market_skips[-1]["reason"],
         )
 
+    def test_model_route_limit_is_global_across_poll_cycles(self) -> None:
+        class SixRouteClient:
+            @staticmethod
+            def model_submission_precheck(_model_id: str) -> dict:
+                return {
+                    "processedGpus": {f"gpu-{index}" for index in range(1, 7)},
+                    "successfulGpus": {"gpu-1"},
+                    "failedFrameworksByGpu": {},
+                }
+
+        candidates, skipped, failed = process_model_for_candidates(
+            model=SafeDiscovery().model,
+            hf_discovery=SafeDiscovery(),  # type: ignore[arg-type]
+            modelhub_client=SixRouteClient(),  # type: ignore[arg-type]
+            template_selector=TemplateSelector(),
+            target_gpus=["gpu-7"],
+            allowed_task_types=["text-generation"],
+        )
+        self.assertEqual([], candidates)
+        self.assertEqual([], failed)
+        self.assertEqual("model_route_limit_reached", skipped[0]["reason"])
+        self.assertEqual(6, skipped[0]["processedGpuCount"])
+
+    def test_model_waits_for_feedback_after_two_pending_routes(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_dir:
+            root = Path(temporary_dir)
+            tracker = OutcomeTracker(
+                root / "outcomes.jsonl",
+                checkpoint_path=root / "checkpoint.json",
+                recent_path=root / "recent.jsonl",
+            )
+            tracker.record_submission(
+                "owner/model", "gpu-1", "vllm", "text-generation", "task-1",
+                "2026-09-22T00:00:00+00:00",
+            )
+            tracker.record_submission(
+                "owner/model", "gpu-2", "vllm", "text-generation", "task-2",
+                "2026-09-22T00:01:00+00:00",
+            )
+
+            candidates, skipped, failed = process_model_for_candidates(
+                model=SafeDiscovery().model,
+                hf_discovery=SafeDiscovery(),  # type: ignore[arg-type]
+                modelhub_client=OtherGpuProcessedClient(),  # type: ignore[arg-type]
+                template_selector=TemplateSelector(),
+                target_gpus=["gpu-3"],
+                allowed_task_types=["text-generation"],
+                outcome_tracker=tracker,
+            )
+
+            self.assertEqual([], candidates)
+            self.assertEqual([], failed)
+            self.assertEqual("model_pending_feedback_limit", skipped[0]["reason"])
+            self.assertEqual(2, skipped[0]["pendingRouteCount"])
+
     def test_published_size_avoids_official_calls_for_certain_oom(self) -> None:
         class CountingRegistry(AllGpuOfficialRegistry):
             calls = 0