feat: make model age admission-only

modelhub_submmit_api/outcome_tracker.py

@@ -76,6 +76,28 @@ class OutcomeTracker:
             }
         return contexts
 
+    def get_strategy_history_records(self) -> list[dict[str, Any]]:
+        """Expose only successes and evidence-attributable failures for GPU ranking."""
+        records: list[dict[str, Any]] = []
+        for record in self._records:
+            outcome = record.get("outcome")
+            if outcome == "success":
+                verify_result = 1
+            elif _is_attributable_failure(record):
+                verify_result = -1
+            else:
+                continue
+            records.append(
+                {
+                    **record,
+                    "gpuType": record.get("targetGpu"),
+                    "status": "success",
+                    "verifyResult": verify_result,
+                    "updateTime": record.get("lastSyncTime") or record.get("submitTime"),
+                }
+            )
+        return records
+
     def _rebuild_indexes(self) -> None:
         self._by_task_id.clear()
         self._by_model_gpu.clear()
@@ -619,10 +641,13 @@ class OutcomeTracker:
         self._failed_model_gpus.clear()
         latest_by_combo: dict[tuple[str, str], tuple[datetime, dict[str, Any]]] = {}
         for record in self._records:
-            # Infrastructure failures and our own policy cancellations neither
-            # clear nor create a model/GPU cooldown. Look through them to the
-            # latest attributable outcome.
-            if _is_platform_failure(record) or _is_policy_cancelled(record):
+            # Platform, unresolved, and policy outcomes neither clear nor
+            # create a model/GPU cooldown. The full-history audit showed that
+            # more than half of failures lack enough evidence for attribution.
+            if _is_policy_cancelled(record) or (
+                record.get("outcome") == "failed"
+                and not _is_attributable_failure(record)
+            ):
                 continue
             model_id = record.get("modelId") or ""
             target_gpu = record.get("targetGpu") or ""
@@ -701,10 +726,13 @@ def _summarize(records: list[dict[str, Any]]) -> dict[str, Any]:
     failure_count = sum(1 for r in records if r.get("outcome") == "failed")
     pending_count = sum(1 for r in records if r.get("outcome") == "pending")
     attributable_failure_count = sum(
-        1 for record in records
-        if record.get("outcome") == "failed" and not _is_platform_failure(record)
+        1 for record in records if _is_attributable_failure(record)
+    )
+    platform_failure_count = sum(1 for record in records if _is_platform_failure(record))
+    unresolved_failure_count = max(
+        0,
+        failure_count - attributable_failure_count - platform_failure_count,
     )
-    platform_failure_count = failure_count - attributable_failure_count
     decision_total = success_count + attributable_failure_count
 
     failure_breakdown: dict[str, int] = defaultdict(int)
@@ -719,6 +747,7 @@ def _summarize(records: list[dict[str, Any]]) -> dict[str, Any]:
         "failureCount": failure_count,
         "attributableFailureCount": attributable_failure_count,
         "platformFailureCount": platform_failure_count,
+        "unresolvedFailureCount": unresolved_failure_count,
         "decisionTotal": decision_total,
         "pendingCount": pending_count,
         "successRate": round(success_count / total, 4) if total > 0 else 0.0,
@@ -892,6 +921,15 @@ def _is_platform_failure(record: dict[str, Any]) -> bool:
     return scope == "platform" or category.startswith("platform_")
 
 
+def _is_attributable_failure(record: dict[str, Any]) -> bool:
+    """Require classified, non-platform evidence before penalizing a strategy."""
+    if record.get("outcome") != "failed" or _is_platform_failure(record):
+        return False
+    category = str(record.get("failureCategory") or "").strip().lower()
+    scope = str(record.get("failureScope") or "").strip().lower()
+    return bool(category and scope not in {"", "unknown", "platform"})
+
+
 def _is_policy_cancelled(record: dict[str, Any]) -> bool:
     return bool(record.get("policyCancelled")) or record.get("outcome") == "policy_cancelled"
 
@@ -901,7 +939,7 @@ def _consecutive_attributable_failures(records: list[dict[str, Any]]) -> int:
     for record in records:
         if record.get("outcome") == "success":
             break
-        if record.get("outcome") == "failed" and not _is_platform_failure(record):
+        if _is_attributable_failure(record):
             count += 1
     return count