Close mp-300k gate review findings

Author: MaxGhenis

src/microplex_us/pipelines/mp300k_artifact_gates.py

@@ -464,14 +464,23 @@ def _runtime_gate(
     if runtime_smoke_payload is None:
         return _gate("unmeasured", "runtime smoke benchmark has not been attached")
     payload = dict(runtime_smoke_payload)
-    threshold = float(payload.get("runtime_ratio_threshold", runtime_ratio_threshold))
+    threshold = float(runtime_ratio_threshold)
     ratio = payload.get("runtime_ratio")
     candidate_seconds = payload.get("candidate_seconds")
     baseline_seconds = payload.get("baseline_seconds")
     if ratio is None and candidate_seconds is not None and baseline_seconds:
         ratio = float(candidate_seconds) / float(baseline_seconds)
     passes = payload.get("passes_runtime_gate")
     details: dict[str, Any] = {}
+    reported_threshold = payload.get("runtime_ratio_threshold")
+    reported_threshold_matches = False
+    try:
+        reported_threshold_matches = float(reported_threshold) == threshold
+    except (TypeError, ValueError):
+        pass
+    if reported_threshold is not None and not reported_threshold_matches:
+        details["reported_runtime_ratio_threshold"] = reported_threshold
+        details["enforced_runtime_ratio_threshold"] = threshold
     if ratio is None:
         return _gate(
             "unmeasured",

src/microplex_us/pipelines/mp300k_gate_inputs.py

@@ -165,6 +165,15 @@ def _resolve_baseline_dataset_path(
     return baseline_path
 
 
+def _safe_archive_relpath(candidate: Path, *, fallback: Path) -> Path:
+    if candidate.is_absolute() or ".." in candidate.parts:
+        return fallback
+    normalized_parts = [part for part in candidate.parts if part not in ("", ".")]
+    if not normalized_parts:
+        return fallback
+    return Path(*normalized_parts)
+
+
 def _candidate_archive_relpath(
     manifest: dict[str, Any],
     *,
@@ -175,9 +184,10 @@ def _candidate_archive_relpath(
         return Path(candidate_dataset.name)
     dataset_name = dict(manifest.get("artifacts", {})).get("policyengine_dataset")
     if isinstance(dataset_name, str) and dataset_name:
-        relpath = Path(dataset_name)
-        if not relpath.is_absolute():
-            return relpath
+        return _safe_archive_relpath(
+            Path(dataset_name),
+            fallback=Path(candidate_dataset.name),
+        )
     return Path(candidate_dataset.name)
 
 
@@ -191,9 +201,10 @@ def _baseline_archive_relpath(
         return Path("baseline") / baseline_dataset.name
     value = dict(manifest.get("config", {})).get("policyengine_baseline_dataset")
     if isinstance(value, str) and value:
-        relpath = Path(value)
-        if not relpath.is_absolute():
-            return relpath
+        return _safe_archive_relpath(
+            Path(value),
+            fallback=Path("baseline") / baseline_dataset.name,
+        )
     return Path("baseline") / baseline_dataset.name
 
 

tests/pipelines/test_mp300k_artifact_gates.py

@@ -280,10 +280,11 @@ def test_runtime_gate_ignores_contradictory_producer_verdict(tmp_path):
         },
         runtime_smoke_payload={
             "runtime_ratio": 10.0,
-            "runtime_ratio_threshold": 1.25,
+            "runtime_ratio_threshold": 100.0,
             "passes_runtime_gate": True,
         },
         benchmark_manifest_path=benchmark_manifest,
+        runtime_ratio_threshold=1.25,
         compute_native_scores=False,
         update_manifest=False,
     )
@@ -293,6 +294,9 @@ def test_runtime_gate_ignores_contradictory_producer_verdict(tmp_path):
 
     assert record["summary"]["status"] == "failed"
     assert runtime_gate["status"] == "fail"
+    assert runtime_gate["metrics"]["runtime_ratio_threshold"] == 1.25
+    assert runtime_gate["details"]["reported_runtime_ratio_threshold"] == 100.0
+    assert runtime_gate["details"]["enforced_runtime_ratio_threshold"] == 1.25
     assert runtime_gate["details"]["reported_passes_runtime_gate"] is True
     assert runtime_gate["details"]["computed_passes_runtime_gate"] is False
 

tests/pipelines/test_mp300k_gate_inputs.py

@@ -28,16 +28,21 @@ def _write_minimal_policyengine_dataset(path: Path, *, period: int = 2024) -> Pa
     return write_policyengine_us_time_period_dataset(arrays, path)
 
 
-def _write_manifest(artifact_dir: Path) -> None:
+def _write_manifest(
+    artifact_dir: Path,
+    *,
+    candidate_path: str = "policyengine_us.h5",
+    baseline_path: str = "baseline/enhanced_cps_2024.h5",
+) -> None:
     (artifact_dir / "manifest.json").write_text(
         json.dumps(
             {
                 "created_at": "2026-05-27T00:00:00+00:00",
                 "config": {
                     "policyengine_dataset_year": 2024,
-                    "policyengine_baseline_dataset": "baseline/enhanced_cps_2024.h5",
+                    "policyengine_baseline_dataset": baseline_path,
                 },
-                "artifacts": {"policyengine_dataset": "policyengine_us.h5"},
+                "artifacts": {"policyengine_dataset": candidate_path},
             }
         )
     )
@@ -129,21 +134,29 @@ def test_main_packages_gate_inputs(tmp_path, capsys):
 def test_packaged_inputs_run_gates_from_clean_extract(tmp_path):
     artifact_dir = tmp_path / "artifact"
     artifact_dir.mkdir()
-    _write_manifest(artifact_dir)
-    external_candidate = _write_minimal_policyengine_dataset(tmp_path / "candidate.h5")
-    external_baseline = _write_minimal_policyengine_dataset(tmp_path / "baseline.h5")
+    _write_manifest(
+        artifact_dir,
+        candidate_path="../candidate.h5",
+        baseline_path="../baseline.h5",
+    )
+    _write_minimal_policyengine_dataset(tmp_path / "candidate.h5")
+    _write_minimal_policyengine_dataset(tmp_path / "baseline.h5")
     benchmark_manifest = tmp_path / "benchmark.json"
     benchmark_manifest.write_text(json.dumps({"schema_version": 1}))
     output_dir = tmp_path / "gate-inputs"
 
     package_mp300k_gate_inputs(
         artifact_dir,
         output_dir,
-        candidate_dataset_path=external_candidate,
-        baseline_dataset_path=external_baseline,
         benchmark_manifest_path=benchmark_manifest,
     )
 
+    packaged_manifest = _archive_manifest(output_dir / "artifact.tar.gz")
+    assert packaged_manifest["artifacts"]["policyengine_dataset"] == "candidate.h5"
+    assert (
+        packaged_manifest["config"]["policyengine_baseline_dataset"]
+        == "baseline/baseline.h5"
+    )
     extract_root = tmp_path / "extract"
     with tarfile.open(output_dir / "artifact.tar.gz") as archive:
         archive.extractall(extract_root, filter="data")
@@ -168,5 +181,6 @@ def test_packaged_inputs_run_gates_from_clean_extract(tmp_path):
     report = json.loads(report_path.read_text())
 
     assert report["summary"]["status"] == "passed"
+    assert report["candidate_dataset"]["path"].startswith(str(packaged_artifact_dir))
     assert report["baseline_dataset"]["path"].startswith(str(packaged_artifact_dir))
     assert report["gates"]["artifact_size"]["status"] == "pass"