devagent-physical-engine 0.10.0__py3-none-any.whl

devagent_physical_engine/physical_campaign.py

@@ -0,0 +1,413 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from hashlib import sha256
+import json
+from math import isfinite
+from time import perf_counter
+from typing import Any, Mapping, Sequence
+
+from .agent.coordinator import VerifiedPlanArtifact
+from .agent.evidence import task_graph_hash
+from .physical_motion import MotionExecutionMetrics, PhysicalMotionPlan
+from .robot_platform import QualificationState, RobotProfileRegistry, SimulationTier
+from .simulation_platform import RobotSimulationAdapter
+from .twin import TwinSpec, TwinValidator
+
+
+MAX_PHYSICAL_CASES = 2_000
+
+
+class PhysicalCampaignError(RuntimeError):
+    pass
+
+
+def _json_safe(payload: object, *, code: str) -> None:
+    try:
+        json.dumps(payload, sort_keys=True, allow_nan=False)
+    except (TypeError, ValueError) as exc:
+        raise PhysicalCampaignError(code) from exc
+
+
+def _stable_hash(payload: object) -> str:
+    _json_safe(payload, code="physical_evidence_not_json_safe")
+    text = json.dumps(payload, sort_keys=True, separators=(",", ":"), allow_nan=False)
+    return sha256(text.encode("utf-8")).hexdigest()
+
+
+def _verified_plan_hashes(
+    plans: Sequence[VerifiedPlanArtifact],
+) -> tuple[str, ...]:
+    if not plans:
+        raise PhysicalCampaignError("physical_campaign_verified_plan_required")
+    hashes: set[str] = set()
+    for artifact in plans:
+        if not artifact.planner_evidence or not artifact.critic_evidence:
+            raise PhysicalCampaignError("physical_campaign_plan_evidence_missing")
+        computed = task_graph_hash(artifact.graph)
+        if artifact.graph_hash != computed:
+            raise PhysicalCampaignError("physical_campaign_plan_hash_mismatch")
+        hashes.add(computed)
+    return tuple(sorted(hashes))
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalCase:
+    case_id: str
+    index: int
+    seed: int
+    motion: PhysicalMotionPlan
+    reset_state: Mapping[str, Any]
+    parameters: Mapping[str, float | int | str | bool] = field(default_factory=dict)
+    expected_success: bool | None = None
+    expected_failure_codes: tuple[str, ...] = ()
+    sweep_parameter: str | None = None
+    sweep_group: str | None = None
+
+    def __post_init__(self) -> None:
+        if not self.case_id.strip():
+            raise PhysicalCampaignError("physical_case_id_required")
+        if self.index < 0:
+            raise PhysicalCampaignError("physical_case_index_invalid")
+        if self.seed < 0:
+            raise PhysicalCampaignError("physical_case_seed_invalid")
+        if not isinstance(self.reset_state, Mapping) or not isinstance(self.parameters, Mapping):
+            raise PhysicalCampaignError("physical_case_mapping_invalid")
+        if any(not key.strip() for key in self.parameters):
+            raise PhysicalCampaignError("physical_case_parameter_name_invalid")
+        for key, value in self.parameters.items():
+            if isinstance(value, float) and not isfinite(value):
+                raise PhysicalCampaignError(f"physical_case_parameter_non_finite:{key}")
+        if any(not code.strip() for code in self.expected_failure_codes):
+            raise PhysicalCampaignError("physical_case_failure_code_empty")
+        if self.expected_success is True and self.expected_failure_codes:
+            raise PhysicalCampaignError("passing_case_cannot_expect_failure_codes")
+        if self.expected_success is None and self.expected_failure_codes:
+            raise PhysicalCampaignError("exploratory_case_cannot_expect_failure_codes")
+        if (self.sweep_parameter is None) != (self.sweep_group is None):
+            raise PhysicalCampaignError("physical_case_sweep_fields_must_pair")
+        if self.sweep_parameter is not None:
+            if not self.sweep_parameter.strip() or not self.sweep_group or not self.sweep_group.strip():
+                raise PhysicalCampaignError("physical_case_sweep_identity_invalid")
+            if self.sweep_parameter not in self.parameters:
+                raise PhysicalCampaignError("physical_case_sweep_parameter_missing")
+        _json_safe(self.reset_state, code="physical_case_reset_state_not_json_safe")
+        _json_safe(self.parameters, code="physical_case_parameters_not_json_safe")
+
+    @property
+    def oracle_backed(self) -> bool:
+        return self.expected_success is not None
+
+    def to_dict(self, *, include_motion: bool = False) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "case_id": self.case_id,
+            "index": self.index,
+            "seed": self.seed,
+            "motion_hash": self.motion.fingerprint,
+            "motion_id": self.motion.motion_id,
+            "robot_profile_key": self.motion.robot_profile_key,
+            "twin_hash": self.motion.twin_hash,
+            "reset_state": dict(self.reset_state),
+            "parameters": dict(self.parameters),
+            "expected_success": self.expected_success,
+            "expected_failure_codes": list(self.expected_failure_codes),
+            "sweep_parameter": self.sweep_parameter,
+            "sweep_group": self.sweep_group,
+        }
+        if include_motion:
+            payload["motion"] = self.motion.to_dict()
+        return payload
+
+    @property
+    def fingerprint(self) -> str:
+        return _stable_hash(self.to_dict(include_motion=True))
+
+
+def make_physical_case(
+    *,
+    index: int,
+    seed: int,
+    motion: PhysicalMotionPlan,
+    reset_state: Mapping[str, Any],
+    parameters: Mapping[str, float | int | str | bool] | None = None,
+    expected_success: bool | None = None,
+    expected_failure_codes: tuple[str, ...] = (),
+    sweep_parameter: str | None = None,
+    sweep_group: str | None = None,
+) -> PhysicalCase:
+    identity = {
+        "index": index,
+        "seed": seed,
+        "motion_hash": motion.fingerprint,
+        "reset_state": dict(reset_state),
+        "parameters": dict(parameters or {}),
+        "expected_success": expected_success,
+        "expected_failure_codes": list(expected_failure_codes),
+        "sweep_parameter": sweep_parameter,
+        "sweep_group": sweep_group,
+    }
+    digest = _stable_hash(identity)[:8]
+    return PhysicalCase(
+        case_id=f"PHY-{index:06d}-{digest}",
+        index=index,
+        seed=seed,
+        motion=motion,
+        reset_state=dict(reset_state),
+        parameters=dict(parameters or {}),
+        expected_success=expected_success,
+        expected_failure_codes=expected_failure_codes,
+        sweep_parameter=sweep_parameter,
+        sweep_group=sweep_group,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalCaseResult:
+    case: PhysicalCase
+    actual_success: bool
+    metrics: MotionExecutionMetrics
+    adapter_state: Mapping[str, Any]
+    duration_ms: float
+    runner_failure_code: str | None = None
+
+    @property
+    def verdict_correct(self) -> bool | None:
+        if self.case.expected_success is None:
+            return None
+        return self.actual_success is self.case.expected_success
+
+    @property
+    def reason_correct(self) -> bool | None:
+        if self.case.expected_success is None:
+            return None
+        if self.case.expected_success:
+            return self.actual_success and not self.metrics.failure_codes
+        if self.actual_success:
+            return False
+        if not self.case.expected_failure_codes:
+            return True
+        return set(self.case.expected_failure_codes).issubset(self.metrics.failure_codes)
+
+    @property
+    def unsafe_false_pass(self) -> bool:
+        return self.case.expected_success is False and self.actual_success
+
+    @property
+    def false_fail(self) -> bool:
+        return self.case.expected_success is True and not self.actual_success
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = {
+            "case": self.case.to_dict(),
+            "actual_success": self.actual_success,
+            "verdict_correct": self.verdict_correct,
+            "reason_correct": self.reason_correct,
+            "unsafe_false_pass": self.unsafe_false_pass,
+            "false_fail": self.false_fail,
+            "metrics": self.metrics.to_dict(),
+            "adapter_state": dict(self.adapter_state),
+            "runner_failure_code": self.runner_failure_code,
+            "duration_ms": round(self.duration_ms, 6),
+        }
+        payload["evidence_hash"] = _stable_hash(payload)
+        return payload
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalCampaignSummary:
+    run_id: str
+    robot_profile_key: str
+    twin_hash: str
+    verified_plan_hashes: tuple[str, ...]
+    adapter_id: str
+    adapter_qualification_at_start: str
+    profile_physics_qualification_at_start: str
+    physical_qualification: bool
+    qualification_candidate: bool
+    total_cases: int
+    oracle_backed_cases: int
+    exploratory_cases: int
+    correct_verdicts: int
+    correct_reasons: int
+    unsafe_false_passes: int
+    false_fails: int
+    execution_failures: int
+    corpus_hash: str
+    duration_ms: float
+
+    @property
+    def verdict_accuracy(self) -> float | None:
+        if self.oracle_backed_cases == 0:
+            return None
+        return self.correct_verdicts / self.oracle_backed_cases
+
+    @property
+    def reason_accuracy(self) -> float | None:
+        if self.oracle_backed_cases == 0:
+            return None
+        return self.correct_reasons / self.oracle_backed_cases
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **asdict(self),
+            "verdict_accuracy": (
+                None if self.verdict_accuracy is None else round(self.verdict_accuracy, 8)
+            ),
+            "reason_accuracy": (
+                None if self.reason_accuracy is None else round(self.reason_accuracy, 8)
+            ),
+            "sim_real_correlation": False,
+            "site_qualification": False,
+            "real_execution_allowed": False,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class PhysicalCampaignReport:
+    summary: PhysicalCampaignSummary
+    results: tuple[PhysicalCaseResult, ...]
+    session_id: str
+
+
+class PhysicalCampaignRunner:
+    """Run commissioning-grade simulation campaigns on verified plan authority.
+
+    Experimental adapter qualification belongs to scope-specific harnesses. This
+    runner additionally requires the motion source hashes to correspond to exact
+    ``VerifiedPlanArtifact`` objects whose graph hashes recompute correctly and
+    whose planner/critic evidence is present.
+    """
+
+    def __init__(self, robot_profiles: RobotProfileRegistry) -> None:
+        self.robot_profiles = robot_profiles
+        self.twin_validator = TwinValidator(robot_profiles)
+
+    def _preflight(
+        self,
+        twin: TwinSpec,
+        adapter: RobotSimulationAdapter,
+        cases: Sequence[PhysicalCase],
+        verified_plans: Sequence[VerifiedPlanArtifact],
+    ) -> tuple[str, QualificationState, QualificationState, tuple[str, ...]]:
+        if not cases:
+            raise PhysicalCampaignError("physical_campaign_empty")
+        if len(cases) > MAX_PHYSICAL_CASES:
+            raise PhysicalCampaignError("physical_campaign_case_limit_exceeded")
+        validation = self.twin_validator.validate(twin)
+        if not validation.ready_for_physics:
+            raise PhysicalCampaignError("physical_campaign_requires_level3_twin")
+
+        verified_hashes = _verified_plan_hashes(verified_plans)
+        verified_set = set(verified_hashes)
+        profile = self.robot_profiles.get(twin.robot_profile_key)
+        profile_state = profile.qualification.state_for(SimulationTier.PHYSICS)
+        descriptor = adapter.descriptor
+        if descriptor.tier is not SimulationTier.PHYSICS:
+            raise PhysicalCampaignError("physical_campaign_requires_physics_adapter")
+        if profile.key not in descriptor.robot_profile_keys:
+            raise PhysicalCampaignError("physical_campaign_adapter_robot_mismatch")
+        if profile_state is not QualificationState.QUALIFIED:
+            raise PhysicalCampaignError("robot_profile_physics_not_qualified")
+        if not descriptor.commissioning_scope_qualified:
+            raise PhysicalCampaignError("simulation_adapter_commissioning_scope_not_qualified")
+
+        for case in cases:
+            if case.motion.robot_profile_key != profile.key:
+                raise PhysicalCampaignError("physical_case_robot_mismatch")
+            if case.motion.twin_hash != twin.fingerprint:
+                raise PhysicalCampaignError("physical_case_twin_hash_mismatch")
+            if case.motion.source_graph_hash not in verified_set:
+                raise PhysicalCampaignError("physical_case_unverified_source_graph")
+        corpus_hash = _stable_hash([case.to_dict(include_motion=True) for case in cases])
+        return corpus_hash, descriptor.qualification, profile_state, verified_hashes
+
+    def run(
+        self,
+        *,
+        twin: TwinSpec,
+        adapter: RobotSimulationAdapter,
+        cases: Sequence[PhysicalCase],
+        verified_plans: Sequence[VerifiedPlanArtifact],
+    ) -> PhysicalCampaignReport:
+        started = perf_counter()
+        corpus_hash, adapter_state, profile_state, verified_hashes = self._preflight(
+            twin, adapter, cases, verified_plans
+        )
+        health = adapter.doctor(robot_profile_key=twin.robot_profile_key)
+        if not health.ready:
+            raise PhysicalCampaignError(f"physical_adapter_doctor_failed:{health.code}")
+
+        session_id = ""
+        results: list[PhysicalCaseResult] = []
+        try:
+            session_id = adapter.prepare(twin=twin)
+            for case in cases:
+                case_started = perf_counter()
+                runner_failure: str | None = None
+                try:
+                    adapter.reset(case_id=case.case_id, state=case.reset_state)
+                    metrics = adapter.execute_motion(motion=case.motion)
+                    state = dict(adapter.capture_state())
+                except Exception as exc:
+                    runner_failure = f"physical_runner_error:{type(exc).__name__}"
+                    metrics = MotionExecutionMetrics(
+                        success=False,
+                        observed_duration_s=None,
+                        planned_duration_s=case.motion.planned_duration_s,
+                        planned_joint_travel_rad=case.motion.joint_travel_rad,
+                        failure_codes=(runner_failure,),
+                        metrics_origin="physical_campaign_runner",
+                    )
+                    state = {"case_id": case.case_id, "runner_failure": runner_failure}
+                results.append(
+                    PhysicalCaseResult(
+                        case=case,
+                        actual_success=metrics.success,
+                        metrics=metrics,
+                        adapter_state=state,
+                        runner_failure_code=runner_failure,
+                        duration_ms=(perf_counter() - case_started) * 1000.0,
+                    )
+                )
+        finally:
+            adapter.stop()
+
+        oracle_results = [item for item in results if item.case.oracle_backed]
+        all_oracle = len(oracle_results) == len(results)
+        correct_verdicts = sum(item.verdict_correct is True for item in oracle_results)
+        correct_reasons = sum(item.reason_correct is True for item in oracle_results)
+        unsafe = sum(item.unsafe_false_pass for item in results)
+        false_fails = sum(item.false_fail for item in results)
+        execution_failures = sum(item.runner_failure_code is not None for item in results)
+        candidate = (
+            bool(results)
+            and all_oracle
+            and unsafe == 0
+            and correct_verdicts == len(oracle_results)
+            and correct_reasons == len(oracle_results)
+            and execution_failures == 0
+        )
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+        summary = PhysicalCampaignSummary(
+            run_id=f"physical-{timestamp}",
+            robot_profile_key=twin.robot_profile_key,
+            twin_hash=twin.fingerprint,
+            verified_plan_hashes=verified_hashes,
+            adapter_id=adapter.descriptor.adapter_id,
+            adapter_qualification_at_start=adapter_state.value,
+            profile_physics_qualification_at_start=profile_state.value,
+            physical_qualification=candidate,
+            qualification_candidate=candidate,
+            total_cases=len(results),
+            oracle_backed_cases=len(oracle_results),
+            exploratory_cases=len(results) - len(oracle_results),
+            correct_verdicts=correct_verdicts,
+            correct_reasons=correct_reasons,
+            unsafe_false_passes=unsafe,
+            false_fails=false_fails,
+            execution_failures=execution_failures,
+            corpus_hash=corpus_hash,
+            duration_ms=(perf_counter() - started) * 1000.0,
+        )
+        return PhysicalCampaignReport(summary, tuple(results), session_id)

devagent_physical_engine/physical_evidence.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+from enum import Enum
+import json
+from pathlib import Path
+import re
+from typing import Any, Mapping
+
+from .physical_campaign import PhysicalCampaignReport, PhysicalCase
+from .physical_motion import JointTrajectoryPoint, PhysicalMotionPlan
+from .twin import TwinSpec
+
+
+_CASE_ID_RE = re.compile(r"^PHY-\d{6}-[0-9a-f]{8}$")
+_RUN_ID_RE = re.compile(r"^physical-[0-9TZ]+$")
+
+
+class PhysicalEvidenceError(RuntimeError):
+    pass
+
+
+def _json_default(value: object) -> object:
+    if isinstance(value, Enum):
+        return value.value
+    raise TypeError(f"not_json_serializable:{type(value).__name__}")
+
+
+def _write_json(path: Path, payload: object) -> None:
+    path.write_text(
+        json.dumps(
+            payload,
+            indent=2,
+            sort_keys=True,
+            allow_nan=False,
+            default=_json_default,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+
+def motion_from_dict(payload: Mapping[str, Any]) -> PhysicalMotionPlan:
+    try:
+        raw_points = payload["points"]
+        if not isinstance(raw_points, list):
+            raise TypeError("points")
+        points = tuple(
+            JointTrajectoryPoint(
+                positions_rad=tuple(float(x) for x in item["positions_rad"]),
+                time_from_start_s=float(item["time_from_start_s"]),
+                velocities_rad_s=tuple(float(x) for x in item.get("velocities_rad_s", ())),
+                accelerations_rad_s2=tuple(
+                    float(x) for x in item.get("accelerations_rad_s2", ())
+                ),
+            )
+            for item in raw_points
+        )
+        return PhysicalMotionPlan(
+            motion_id=str(payload["motion_id"]),
+            robot_profile_key=str(payload["robot_profile_key"]),
+            joint_names=tuple(str(x) for x in payload["joint_names"]),
+            points=points,
+            source_graph_hash=str(payload["source_graph_hash"]),
+            planner_id=str(payload["planner_id"]),
+            twin_hash=str(payload["twin_hash"]),
+            constraints=tuple(str(x) for x in payload.get("constraints", ())),
+            metadata=dict(payload.get("metadata") or {}),
+        )
+    except Exception as exc:
+        raise PhysicalEvidenceError("physical_motion_record_invalid") from exc
+
+
+class PhysicalQualificationStore:
+    """Write replayable physical campaign evidence under a bounded local root."""
+
+    def __init__(self, root: Path | str = "~/.devagent/physical-qualification") -> None:
+        self.root = Path(root).expanduser().resolve()
+
+    def write_run(self, *, twin: TwinSpec, report: PhysicalCampaignReport) -> Path:
+        summary = report.summary
+        if twin.fingerprint != summary.twin_hash:
+            raise PhysicalEvidenceError("physical_evidence_twin_hash_mismatch")
+        if not _RUN_ID_RE.fullmatch(summary.run_id):
+            raise PhysicalEvidenceError("physical_evidence_run_id_invalid")
+        run_dir = (self.root / summary.run_id).resolve()
+        try:
+            run_dir.relative_to(self.root)
+        except ValueError as exc:
+            raise PhysicalEvidenceError("physical_evidence_path_escape") from exc
+        run_dir.mkdir(parents=True, exist_ok=False)
+        motions_dir = run_dir / "motions"
+        motions_dir.mkdir()
+
+        _write_json(run_dir / "twin.json", twin.to_dict())
+        _write_json(run_dir / "summary.json", summary.to_dict())
+        _write_json(
+            run_dir / "session.json",
+            {
+                "session_id": report.session_id,
+                "adapter_id": summary.adapter_id,
+                "twin_hash": summary.twin_hash,
+            },
+        )
+
+        motion_hashes: set[str] = set()
+        with (run_dir / "cases.jsonl").open("w", encoding="utf-8") as handle:
+            for result in report.results:
+                record = result.to_dict()
+                handle.write(
+                    json.dumps(
+                        record,
+                        sort_keys=True,
+                        allow_nan=False,
+                        default=_json_default,
+                    )
+                    + "\n"
+                )
+                motion = result.case.motion
+                motion_hash = motion.fingerprint
+                if motion_hash not in motion_hashes:
+                    _write_json(motions_dir / f"{motion_hash}.json", motion.to_dict())
+                    motion_hashes.add(motion_hash)
+
+        self.root.mkdir(parents=True, exist_ok=True)
+        _write_json(
+            self.root / "latest-run.json",
+            {"run_id": summary.run_id, "run_dir": str(run_dir)},
+        )
+        return run_dir
+
+    def resolve_run(self, run_ref: Path | str | None = None) -> Path:
+        if run_ref is None:
+            pointer = self.root / "latest-run.json"
+            if not pointer.is_file():
+                raise PhysicalEvidenceError("physical_latest_run_not_found")
+            try:
+                payload = json.loads(pointer.read_text(encoding="utf-8"))
+                run_dir = Path(str(payload["run_dir"])).expanduser().resolve()
+            except Exception as exc:
+                raise PhysicalEvidenceError("physical_latest_run_pointer_invalid") from exc
+        else:
+            raw = Path(run_ref).expanduser()
+            run_dir = (self.root / raw).resolve() if not raw.is_absolute() else raw.resolve()
+        try:
+            run_dir.relative_to(self.root)
+        except ValueError as exc:
+            raise PhysicalEvidenceError("physical_run_outside_store") from exc
+        if not run_dir.is_dir() or not (run_dir / "cases.jsonl").is_file():
+            raise PhysicalEvidenceError("physical_run_not_found")
+        return run_dir
+
+    def load_case_record(
+        self, case_id: str, *, run_ref: Path | str | None = None
+    ) -> dict[str, Any]:
+        if not _CASE_ID_RE.fullmatch(case_id):
+            raise PhysicalEvidenceError("physical_case_id_invalid")
+        run_dir = self.resolve_run(run_ref)
+        try:
+            with (run_dir / "cases.jsonl").open("r", encoding="utf-8") as handle:
+                for line in handle:
+                    payload = json.loads(line)
+                    case = payload.get("case") or {}
+                    if case.get("case_id") == case_id:
+                        return payload
+        except (OSError, json.JSONDecodeError) as exc:
+            raise PhysicalEvidenceError("physical_case_store_invalid") from exc
+        raise PhysicalEvidenceError("physical_case_not_found")
+
+    def load_motion(
+        self, motion_hash: str, *, run_ref: Path | str | None = None
+    ) -> PhysicalMotionPlan:
+        if not re.fullmatch(r"[0-9a-f]{64}", motion_hash):
+            raise PhysicalEvidenceError("physical_motion_hash_invalid")
+        run_dir = self.resolve_run(run_ref)
+        target = (run_dir / "motions" / f"{motion_hash}.json").resolve()
+        try:
+            target.relative_to(run_dir / "motions")
+        except ValueError as exc:
+            raise PhysicalEvidenceError("physical_motion_path_escape") from exc
+        if not target.is_file():
+            raise PhysicalEvidenceError("physical_motion_not_found")
+        try:
+            payload = json.loads(target.read_text(encoding="utf-8"))
+        except Exception as exc:
+            raise PhysicalEvidenceError("physical_motion_record_invalid") from exc
+        motion = motion_from_dict(payload)
+        if motion.fingerprint != motion_hash:
+            raise PhysicalEvidenceError("physical_motion_hash_mismatch")
+        return motion
+
+    def load_replay_case(
+        self, case_id: str, *, run_ref: Path | str | None = None
+    ) -> PhysicalCase:
+        record = self.load_case_record(case_id, run_ref=run_ref)
+        case = record.get("case")
+        if not isinstance(case, Mapping):
+            raise PhysicalEvidenceError("physical_case_record_invalid")
+        motion_hash = str(case.get("motion_hash", ""))
+        motion = self.load_motion(motion_hash, run_ref=run_ref)
+        try:
+            return PhysicalCase(
+                case_id=str(case["case_id"]),
+                index=int(case["index"]),
+                seed=int(case["seed"]),
+                motion=motion,
+                reset_state=dict(case["reset_state"]),
+                parameters=dict(case.get("parameters") or {}),
+                expected_success=case.get("expected_success"),
+                expected_failure_codes=tuple(case.get("expected_failure_codes") or ()),
+                sweep_parameter=case.get("sweep_parameter"),
+                sweep_group=case.get("sweep_group"),
+            )
+        except Exception as exc:
+            raise PhysicalEvidenceError("physical_case_record_invalid") from exc