prizmkit 1.1.153 → 1.1.155

package/bundled/dev-pipeline/prizmkit_runtime/test_result.py

@@ -23,8 +23,6 @@ _RESULT_KEYS = {
     "independent_review",
     "repair_rounds",
     "production_changed",
-    "review_required",
-    "review_scope",
     "unresolved_items",
 }
 _INDEPENDENT_REVIEW_KEYS = {
@@ -33,14 +31,40 @@ _INDEPENDENT_REVIEW_KEYS = {
     "downgrade_reason",
     "final_state_rechecked",
 }
+_LEGACY_RESULT_KEYS = _RESULT_KEYS | {"review_required", "review_scope"}
 
 
 def load_test_result(path: str | Path) -> dict[str, Any] | None:
-    """Load one valid terminal projection, or return None."""
+    """Load one strict route-free terminal projection, or return None."""
     try:
         value = json.loads(Path(path).read_text(encoding="utf-8"))
     except (OSError, ValueError, TypeError):
         return None
+    return _validate_test_result_value(value)
+
+
+def load_legacy_test_result(path: str | Path) -> dict[str, Any] | None:
+    """Read a historical pass projection without permitting new legacy output."""
+    try:
+        value = json.loads(Path(path).read_text(encoding="utf-8"))
+    except (OSError, ValueError, TypeError):
+        return None
+    if not isinstance(value, dict):
+        return None
+    if set(value) == _RESULT_KEYS:
+        return _validate_test_result_value(value)
+    if set(value) != _LEGACY_RESULT_KEYS:
+        return None
+    if value.get("review_required") is not False or value.get("review_scope") is not None:
+        return None
+    normalized = {
+        key: item for key, item in value.items()
+        if key not in {"review_required", "review_scope"}
+    }
+    return _validate_test_result_value(normalized)
+
+
+def _validate_test_result_value(value: object) -> dict[str, Any] | None:
     if not isinstance(value, dict):
         return None
     if set(value) != _RESULT_KEYS or value.get("schema_version") != 1:
@@ -79,11 +103,6 @@ def load_test_result(path: str | Path) -> dict[str, Any] | None:
 
     if not isinstance(value.get("production_changed"), bool):
         return None
-    if not isinstance(value.get("review_required"), bool):
-        return None
-    expected_scope = "delta" if value["review_required"] else None
-    if value.get("review_scope") != expected_scope:
-        return None
     unresolved = value.get("unresolved_items")
     if not isinstance(unresolved, list) or any(
         not isinstance(item, str) or not item.strip() for item in unresolved
@@ -91,8 +110,10 @@ def load_test_result(path: str | Path) -> dict[str, Any] | None:
         return None
 
     if value["result"] == "TEST_PASS":
-        if value["review_required"] or unresolved or rounds < 1:
+        if unresolved or rounds < 1:
             return None
+    elif not unresolved:
+        return None
     return value
 
 
@@ -110,14 +131,46 @@ def valid_test_artifact_pair(
     *,
     required_result: str | None = None,
 ) -> bool:
-    """Validate one sibling report/result pair and their terminal result."""
+    """Validate one strict sibling report/result pair and terminal result."""
+    return _valid_test_artifact_pair(
+        report_path,
+        result_path,
+        required_result=required_result,
+        legacy=False,
+    )
+
+
+def valid_legacy_test_artifact_pair(
+    report_path: str | Path,
+    result_path: str | Path,
+    *,
+    required_result: str | None = None,
+) -> bool:
+    """Validate a historical completed pair for read-only recovery."""
+    return _valid_test_artifact_pair(
+        report_path,
+        result_path,
+        required_result=required_result,
+        legacy=True,
+    )
+
+
+def _valid_test_artifact_pair(
+    report_path: str | Path,
+    result_path: str | Path,
+    *,
+    required_result: str | None,
+    legacy: bool,
+) -> bool:
     report = Path(report_path)
     result = Path(result_path)
     if not report.is_file() or not result.is_file():
         return False
     if report.resolve().parent != result.resolve().parent:
         return False
-    projection = load_test_result(result)
+    projection = (
+        load_legacy_test_result(result) if legacy else load_test_result(result)
+    )
     if projection is None:
         return False
     if required_result is not None and projection.get("result") != required_result: