phaseprobe 0.2.1__tar.gz → 0.3.0__tar.gz

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes are documented here. PhaseProbe follows semantic versioning.
 
+## Unreleased
+
+- Added bounded offline `verify-evidence` validation for generated pytest evidence, replay
+  decisions, artifact hashes, safe relative paths, and the fixed regression template.
+- The unreleased package identity is now `0.3.0` for the new generated-evidence contract.
+- `generate-test` now writes a path-portable claim/decision evidence record that binds the
+  validated replay verdict to SHA-256 hashes of the copied fixture and generated pytest, the
+  exact reproduction command, PhaseProbe attribution, and explicit scientific limitations.
+- Identical generated evidence is idempotent; conflicting evidence is rejected without overwrite.
+- Invariant-only fixtures now use the narrower `simulation-replay-regression` claim kind, and the
+  unsigned evidence-integrity boundary is explicit.
+
 ## 0.2.1 — 2026-08-31
 
 - Fixed Issue #4: all four SciPy quick-start configurations now ship inside the importable

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/CITATION.cff

@@ -4,8 +4,7 @@ title: "PhaseProbe"
 type: software
 authors:
   - name: "Ali"
-version: 0.2.1
-date-released: 2026-08-31
+version: 0.3.0
 url: "https://github.com/aliengineering-byte/phaseprobe"
 repository-code: "https://github.com/aliengineering-byte/phaseprobe"
 license: Apache-2.0

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: phaseprobe
-Version: 0.2.1
+Version: 0.3.0
 Summary: Find reproducible qualitative simulation transitions and turn them into regression tests.
 Project-URL: Documentation, https://github.com/aliengineering-byte/phaseprobe#readme
 Project-URL: Issues, https://github.com/aliengineering-byte/phaseprobe/issues
@@ -79,6 +79,7 @@ pip install phaseprobe pytest
 phaseprobe scan --example logistic
 phaseprobe replay .phaseprobe/runs/<run-id>/replay.json
 phaseprobe generate-test .phaseprobe/runs/<run-id>/replay.json
+phaseprobe verify-evidence tests/generated/logistic_map-pytest-evidence.json
 python -m pytest -q tests/generated
 phaseprobe report .phaseprobe/runs/<run-id>
 ```
@@ -172,6 +173,7 @@ does not import it. See [the audited contract](docs/SCIPY_SOLVE_IVP_AUDIT.md),
 | `check` | Execute a declared configuration policy for CI | Exit `1` only when policy fails |
 | `replay` | Validate fixture integrity and re-execute model, parameters, seed, initial state, tolerances, and retention | Declared `exact` or `tolerance` comparison passes |
 | `generate-test` | Validate and copy a fixture into a non-extensible pytest template without conflicting overwrites | Executable test under `tests/generated/` |
+| `verify-evidence` | Re-derive claims/replay decisions and validate bounded strict JSON, artifact hashes, paths, and the fixed template offline | Stable verified or invalid-input exit |
 | `report` | Regenerate terminal, versioned JSON, and self-contained offline HTML evidence | Local report files |
 
 Common options:
@@ -218,6 +220,22 @@ manifest.json  sizes and SHA-256 hashes
 
 Model names used for generated test paths are sanitized. The generated source comes from a fixed template; configuration strings never become executable Python.
 
+`generate-test` validates the replay before writing anything. Alongside the fixed pytest template
+and copied fixture, it writes `<model>-pytest-evidence.json`: a path-portable claim/decision record
+containing repository/version attribution, the declared replay comparisons, SHA-256 hashes for
+both executable artifacts, the exact pytest command, and explicit scientific limitations.
+Run `phaseprobe verify-evidence <evidence.json>` before pytest to validate the strict schema,
+recompute the hashes, re-execute the replay policy, derive the claim/decision fields, and confirm
+that the regression still matches PhaseProbe's fixed template. Validation is offline, bounded to a
+1 MiB evidence document and 32 MiB per generated artifact, rejects duplicate keys and unsafe paths,
+and exits `2` for invalid input.
+The record is unsigned: consumers must recompute the two artifact hashes to detect a recomputed or
+substituted record. It is portable integrity metadata, not an authentication signature.
+
+If `generate-test` reports a conflict, it has left the existing output untouched. An identical
+artifact can be generated again safely; for different content, inspect the existing files and
+choose a fresh output directory (or remove them only after deciding they are no longer needed).
+
 ## What PhaseProbe adds—and what it does not
 
 | existing category | established strength | PhaseProbe’s narrower job |
@@ -299,6 +317,7 @@ python scripts/hygiene.py
 ```
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) and the concrete good-first-issue templates in `.github/ISSUE_TEMPLATE/`.
+Report a reproducible defect with the [bug form](https://github.com/aliengineering-byte/phaseprobe/issues/new?template=bug_report.yml), or propose a bounded adapter or workflow with the [feature form](https://github.com/aliengineering-byte/phaseprobe/issues/new?template=feature_request.yml). Please do not include secrets or private model data.
 
 ## License and citation
 

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/README.md

@@ -41,6 +41,7 @@ pip install phaseprobe pytest
 phaseprobe scan --example logistic
 phaseprobe replay .phaseprobe/runs/<run-id>/replay.json
 phaseprobe generate-test .phaseprobe/runs/<run-id>/replay.json
+phaseprobe verify-evidence tests/generated/logistic_map-pytest-evidence.json
 python -m pytest -q tests/generated
 phaseprobe report .phaseprobe/runs/<run-id>
 ```
@@ -134,6 +135,7 @@ does not import it. See [the audited contract](docs/SCIPY_SOLVE_IVP_AUDIT.md),
 | `check` | Execute a declared configuration policy for CI | Exit `1` only when policy fails |
 | `replay` | Validate fixture integrity and re-execute model, parameters, seed, initial state, tolerances, and retention | Declared `exact` or `tolerance` comparison passes |
 | `generate-test` | Validate and copy a fixture into a non-extensible pytest template without conflicting overwrites | Executable test under `tests/generated/` |
+| `verify-evidence` | Re-derive claims/replay decisions and validate bounded strict JSON, artifact hashes, paths, and the fixed template offline | Stable verified or invalid-input exit |
 | `report` | Regenerate terminal, versioned JSON, and self-contained offline HTML evidence | Local report files |
 
 Common options:
@@ -180,6 +182,22 @@ manifest.json  sizes and SHA-256 hashes
 
 Model names used for generated test paths are sanitized. The generated source comes from a fixed template; configuration strings never become executable Python.
 
+`generate-test` validates the replay before writing anything. Alongside the fixed pytest template
+and copied fixture, it writes `<model>-pytest-evidence.json`: a path-portable claim/decision record
+containing repository/version attribution, the declared replay comparisons, SHA-256 hashes for
+both executable artifacts, the exact pytest command, and explicit scientific limitations.
+Run `phaseprobe verify-evidence <evidence.json>` before pytest to validate the strict schema,
+recompute the hashes, re-execute the replay policy, derive the claim/decision fields, and confirm
+that the regression still matches PhaseProbe's fixed template. Validation is offline, bounded to a
+1 MiB evidence document and 32 MiB per generated artifact, rejects duplicate keys and unsafe paths,
+and exits `2` for invalid input.
+The record is unsigned: consumers must recompute the two artifact hashes to detect a recomputed or
+substituted record. It is portable integrity metadata, not an authentication signature.
+
+If `generate-test` reports a conflict, it has left the existing output untouched. An identical
+artifact can be generated again safely; for different content, inspect the existing files and
+choose a fresh output directory (or remove them only after deciding they are no longer needed).
+
 ## What PhaseProbe adds—and what it does not
 
 | existing category | established strength | PhaseProbe’s narrower job |
@@ -261,6 +279,7 @@ python scripts/hygiene.py
 ```
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) and the concrete good-first-issue templates in `.github/ISSUE_TEMPLATE/`.
+Report a reproducible defect with the [bug form](https://github.com/aliengineering-byte/phaseprobe/issues/new?template=bug_report.yml), or propose a bounded adapter or workflow with the [feature form](https://github.com/aliengineering-byte/phaseprobe/issues/new?template=feature_request.yml). Please do not include secrets or private model data.
 
 ## License and citation
 

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "phaseprobe"
-version = "0.2.1"
+version = "0.3.0"
 description = "Find reproducible qualitative simulation transitions and turn them into regression tests."
 readme = "README.md"
 requires-python = ">=3.10"

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/src/phaseprobe/__init__.py

@@ -27,4 +27,4 @@ __all__ = [
     "run_simulation",
 ]
 
-__version__ = "0.2.1"
+__version__ = "0.3.0"

{phaseprobe-0.2.1 → phaseprobe-0.3.0}/src/phaseprobe/cli.py

@@ -19,7 +19,7 @@ from phaseprobe.errors import (
     NumericalFailure,
     PhaseProbeError,
 )
-from phaseprobe.generate import generate_regression_test
+from phaseprobe.generate import generate_regression_test, verify_generated_evidence
 from phaseprobe.replay import verify_replay
 from phaseprobe.reporting import json_report, regenerate_reports, terminal_report
 
@@ -81,6 +81,12 @@ def build_parser() -> argparse.ArgumentParser:
     generate.add_argument("--output-directory", type=Path, default=Path("tests") / "generated")
     generate.add_argument("--json", action="store_true")
 
+    verify_evidence = commands.add_parser(
+        "verify-evidence", help="verify generated pytest evidence and artifacts offline"
+    )
+    verify_evidence.add_argument("evidence", type=Path)
+    verify_evidence.add_argument("--json", action="store_true")
+
     report = commands.add_parser(
         "report", help="regenerate terminal, JSON, and offline HTML evidence"
     )
@@ -172,6 +178,7 @@ def _generate_command(args: argparse.Namespace) -> int:
         "status": "PYTEST REGRESSION GENERATED",
         "test": str(generated.test_path),
         "fixture": str(generated.fixture_path),
+        "evidence": str(generated.evidence_path),
     }
     if bool(getattr(args, "json", False)):
         sys.stdout.write(json_report(data))
@@ -180,6 +187,24 @@ def _generate_command(args: argparse.Namespace) -> int:
         print()
         print(f"Test: {generated.test_path}")
         print(f"Replay fixture: {generated.fixture_path}")
+        print(f"Execution evidence: {generated.evidence_path}")
+    return int(ExitCode.OK)
+
+
+def _verify_evidence_command(args: argparse.Namespace) -> int:
+    evidence = args.evidence
+    if not isinstance(evidence, Path):
+        raise ConfigurationError("evidence must be a path")
+    result = verify_generated_evidence(evidence)
+    data = result.as_dict()
+    if bool(getattr(args, "json", False)):
+        sys.stdout.write(json_report(data))
+    else:
+        print(data["status"])
+        print()
+        print(f"Evidence SHA-256: {result.evidence_sha256}")
+        print(f"Replay fixture: {result.fixture_path}")
+        print(f"Pytest regression: {result.test_path}")
     return int(ExitCode.OK)
 
 
@@ -221,6 +246,8 @@ def main(argv: Sequence[str] | None = None) -> int:
             return _replay_command(args)
         if args.command == "generate-test":
             return _generate_command(args)
+        if args.command == "verify-evidence":
+            return _verify_evidence_command(args)
         if args.command == "report":
             return _report_command(args)
         raise ConfigurationError(f"unknown command {args.command!r}")

phaseprobe-0.3.0/src/phaseprobe/generate.py

@@ -0,0 +1,377 @@
+"""Safe deterministic pytest generation from validated replay fixtures."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from phaseprobe import __version__
+from phaseprobe.errors import IntegrityError
+from phaseprobe.replay import validate_fixture, verify_replay
+
+MAX_EVIDENCE_BYTES = 1_048_576
+MAX_GENERATED_ARTIFACT_BYTES = 33_554_432
+MAX_JSON_DEPTH = 32
+MAX_JSON_NODES = 10_000
+
+_PRODUCER = {
+    "repository": "aliengineering-byte/phaseprobe",
+    "version": __version__,
+    "capability": "validated-replay-to-pytest",
+    "documentation": "https://github.com/aliengineering-byte/phaseprobe#five-minute-quick-start",
+}
+
+_LIMITATIONS = [
+    "Generation-time replay verifies only the fixture's declared exact or tolerance policy.",
+    "The generated pytest detects future mismatch; it does not prove an exact bifurcation point or global minimality.",
+    "Artifact hashes are unsigned and must be recomputed by a consumer; the evidence record does not authenticate itself.",
+]
+
+
+@dataclass(frozen=True, slots=True)
+class GeneratedTest:
+    """Generated test, copied fixture, and machine-readable execution evidence."""
+
+    test_path: Path
+    fixture_path: Path
+    evidence_path: Path
+
+
+@dataclass(frozen=True, slots=True)
+class GeneratedEvidenceVerification:
+    """Bounded offline validation result for generated regression evidence."""
+
+    evidence_path: Path
+    fixture_path: Path
+    test_path: Path
+    evidence_sha256: str
+
+    def as_dict(self) -> dict[str, object]:
+        return {
+            "schema_version": "1.0",
+            "status": "GENERATED EVIDENCE VERIFIED",
+            "integrity": "unsigned-recomputable",
+            "authentication": "none",
+            "evidence_sha256": self.evidence_sha256,
+            "artifacts": {
+                "replay_fixture": str(self.fixture_path),
+                "pytest_regression": str(self.test_path),
+            },
+        }
+
+
+def _safe_name(value: object) -> str:
+    candidate = re.sub(r"[^a-z0-9]+", "_", str(value).lower()).strip("_")
+    return candidate[:64] or "model"
+
+
+def _reject_conflict(path: Path, expected: bytes, description: str) -> bool:
+    if not path.exists():
+        return True
+    if not path.is_file() or path.read_bytes() != expected:
+        raise FileExistsError(
+            f"refusing to overwrite existing {description} {path}; "
+            "choose another --output-directory"
+        )
+    return False
+
+
+def _sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def _classification(payload: object) -> object:
+    return payload.get("classification") if isinstance(payload, dict) else None
+
+
+def _generated_source(model_name: str, scipy_backed: bool) -> bytes:
+    scipy_import = "import pytest\n" if scipy_backed else ""
+    scipy_guard = (
+        '\npytest.importorskip("scipy")\npytestmark = pytest.mark.scipy\n' if scipy_backed else ""
+    )
+    source = f'''"""Generated by PhaseProbe from a validated replay fixture."""
+
+from pathlib import Path
+
+{scipy_import}
+from phaseprobe.replay import verify_replay
+{scipy_guard}
+
+FIXTURE = Path(__file__).parent / "fixtures" / "{model_name}-replay.json"
+
+
+def test_{model_name}_transition_replays() -> None:
+    """Re-execute model/config/seed and verify the fixture's declared replay policy."""
+    result = verify_replay(FIXTURE)
+    assert result.ok, result.as_dict()
+'''
+    return source.encode("utf-8")
+
+
+def _strict_object(value: object, required: set[str], description: str) -> dict[str, Any]:
+    if not isinstance(value, dict) or set(value) != required:
+        raise IntegrityError(f"{description} must contain exactly: {', '.join(sorted(required))}")
+    return value
+
+
+def _reject_duplicate_keys(pairs: list[tuple[str, object]]) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in pairs:
+        if key in result:
+            raise IntegrityError(f"duplicate JSON key {key!r}")
+        result[key] = value
+    return result
+
+
+def _bounded_json(path: Path, maximum: int) -> tuple[bytes, dict[str, Any]]:
+    if not path.is_file():
+        raise IntegrityError(f"evidence must be a regular file: {path}")
+    if path.stat().st_size > maximum:
+        raise IntegrityError(f"evidence exceeds {maximum} bytes")
+    raw = path.read_bytes()
+    try:
+        text = raw.decode("utf-8")
+        parsed = json.loads(text, object_pairs_hook=_reject_duplicate_keys)
+    except (UnicodeError, json.JSONDecodeError, RecursionError) as exc:
+        raise IntegrityError(f"evidence is not strict UTF-8 JSON: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise IntegrityError("evidence root must be an object")
+    stack: list[tuple[object, int]] = [(parsed, 1)]
+    nodes = 0
+    while stack:
+        current, depth = stack.pop()
+        nodes += 1
+        if nodes > MAX_JSON_NODES:
+            raise IntegrityError(f"evidence exceeds {MAX_JSON_NODES} JSON nodes")
+        if depth > MAX_JSON_DEPTH:
+            raise IntegrityError(f"evidence exceeds JSON depth {MAX_JSON_DEPTH}")
+        if isinstance(current, dict):
+            stack.extend((item, depth + 1) for item in current.values())
+        elif isinstance(current, list):
+            stack.extend((item, depth + 1) for item in current)
+    return raw, parsed
+
+
+def _artifact_path(base: Path, value: object, description: str) -> Path:
+    if not isinstance(value, str) or not value or "\\" in value:
+        raise IntegrityError(f"{description} path must be a non-empty POSIX relative path")
+    path = Path(value)
+    if path.is_absolute() or any(part in {"", ".", ".."} for part in path.parts):
+        raise IntegrityError(f"unsafe {description} path {value!r}")
+    try:
+        resolved = (base / path).resolve(strict=True)
+        resolved.relative_to(base.resolve(strict=True))
+    except (OSError, ValueError) as exc:
+        raise IntegrityError(f"{description} escapes or is missing: {value!r}") from exc
+    if not resolved.is_file():
+        raise IntegrityError(f"{description} must resolve to a regular file")
+    if resolved.stat().st_size > MAX_GENERATED_ARTIFACT_BYTES:
+        raise IntegrityError(f"{description} exceeds {MAX_GENERATED_ARTIFACT_BYTES} bytes")
+    return resolved
+
+
+def _artifact_record(artifacts: dict[str, Any], name: str, base: Path) -> tuple[Path, bytes]:
+    record = _strict_object(artifacts.get(name), {"path", "sha256"}, name)
+    path = _artifact_path(base, record["path"], name)
+    raw = path.read_bytes()
+    expected_hash = record["sha256"]
+    if not isinstance(expected_hash, str) or not re.fullmatch(r"[0-9a-f]{64}", expected_hash):
+        raise IntegrityError(f"{name} sha256 must be 64 lowercase hex characters")
+    if _sha256(raw) != expected_hash:
+        raise IntegrityError(f"{name} sha256 mismatch")
+    return path, raw
+
+
+def verify_generated_evidence(evidence_path: Path) -> GeneratedEvidenceVerification:
+    """Verify bounded generated-test evidence and derive its important claims offline."""
+
+    evidence_raw, evidence = _bounded_json(evidence_path, MAX_EVIDENCE_BYTES)
+    evidence = _strict_object(
+        evidence,
+        {
+            "schema_version",
+            "producer",
+            "claim",
+            "decision",
+            "artifacts",
+            "reproduction",
+            "limitations",
+        },
+        "evidence",
+    )
+    if evidence["schema_version"] != "1.0":
+        raise IntegrityError("unsupported generated-evidence schema_version")
+    if _strict_object(evidence["producer"], set(_PRODUCER), "producer") != _PRODUCER:
+        raise IntegrityError("producer identity does not match this PhaseProbe release")
+    claim = _strict_object(
+        evidence["claim"],
+        {
+            "kind",
+            "model",
+            "baseline_classification",
+            "changed_classification",
+            "reproducible_at_generation",
+        },
+        "claim",
+    )
+    decision = _strict_object(
+        evidence["decision"], {"status", "comparison_mode", "comparisons"}, "decision"
+    )
+    artifacts = _strict_object(
+        evidence["artifacts"], {"replay_fixture", "pytest_regression"}, "artifacts"
+    )
+    reproduction = _strict_object(
+        evidence["reproduction"], {"working_directory", "command"}, "reproduction"
+    )
+    if evidence["limitations"] != _LIMITATIONS:
+        raise IntegrityError("limitations do not match the generated-evidence contract")
+
+    base = evidence_path.resolve(strict=True).parent
+    fixture_path, fixture_raw = _artifact_record(artifacts, "replay_fixture", base)
+    test_path, test_raw = _artifact_record(artifacts, "pytest_regression", base)
+    fixture = validate_fixture(fixture_path)
+    replay = verify_replay(fixture_path)
+    if not replay.ok:
+        raise IntegrityError("replay fixture no longer satisfies its declared policy")
+    model_name = _safe_name(fixture.get("model"))
+    if artifacts["replay_fixture"]["path"] != f"fixtures/{model_name}-replay.json":
+        raise IntegrityError("replay fixture path conflicts with the derived model name")
+    if artifacts["pytest_regression"]["path"] != f"test_{model_name}_transition.py":
+        raise IntegrityError("pytest path conflicts with the derived model name")
+    baseline = fixture.get("baseline")
+    metadata = baseline.get("execution_metadata") if isinstance(baseline, dict) else None
+    adapter_configuration = (
+        metadata.get("adapter_configuration") if isinstance(metadata, dict) else None
+    )
+    scipy_backed = (
+        isinstance(adapter_configuration, dict)
+        and adapter_configuration.get("adapter") == "scipy.solve_ivp"
+    )
+    if test_raw != _generated_source(model_name, scipy_backed):
+        raise IntegrityError("pytest regression is not the fixed template derived from the fixture")
+    baseline_classification = _classification(fixture.get("baseline"))
+    changed_classification = _classification(fixture.get("changed"))
+    expected_kind = (
+        "qualitative-simulation-regression"
+        if baseline_classification is not None
+        and changed_classification is not None
+        and baseline_classification != changed_classification
+        else "simulation-replay-regression"
+    )
+    if claim != {
+        "kind": expected_kind,
+        "model": fixture.get("model"),
+        "baseline_classification": baseline_classification,
+        "changed_classification": changed_classification,
+        "reproducible_at_generation": fixture.get("reproducible"),
+    }:
+        raise IntegrityError("claim conflicts with the replay fixture")
+    if decision != {
+        "status": "REPLAY_VERIFIED",
+        "comparison_mode": replay.mode,
+        "comparisons": [dict(item) for item in replay.comparisons],
+    }:
+        raise IntegrityError("decision conflicts with replay verification")
+    if reproduction != {
+        "working_directory": ".",
+        "command": f"python -m pytest -q {test_path.name}",
+    }:
+        raise IntegrityError("reproduction command conflicts with the generated artifact")
+    if _sha256(fixture_raw) != artifacts["replay_fixture"]["sha256"]:
+        raise IntegrityError("replay fixture changed during verification")
+    return GeneratedEvidenceVerification(
+        evidence_path=evidence_path.resolve(strict=True),
+        fixture_path=fixture_path,
+        test_path=test_path,
+        evidence_sha256=_sha256(evidence_raw),
+    )
+
+
+def generate_regression_test(fixture: Path, output_directory: Path) -> GeneratedTest:
+    """Validate evidence, copy its fixture, and emit a non-extensible pytest template."""
+
+    payload = validate_fixture(fixture)
+    verification = verify_replay(fixture)
+    if not verification.ok:
+        raise ValueError(
+            "replay fixture does not reproduce; refusing to generate a regression test"
+        )
+    model_name = _safe_name(payload.get("model"))
+    fixture_directory = output_directory / "fixtures"
+    copied_fixture = fixture_directory / f"{model_name}-replay.json"
+    test_path = output_directory / f"test_{model_name}_transition.py"
+    evidence_path = output_directory / f"{model_name}-pytest-evidence.json"
+    baseline = payload.get("baseline")
+    metadata = baseline.get("execution_metadata") if isinstance(baseline, dict) else None
+    adapter_configuration = (
+        metadata.get("adapter_configuration") if isinstance(metadata, dict) else None
+    )
+    scipy_backed = (
+        isinstance(adapter_configuration, dict)
+        and adapter_configuration.get("adapter") == "scipy.solve_ivp"
+    )
+    fixture_bytes = fixture.read_bytes()
+    source_bytes = _generated_source(model_name, scipy_backed)
+    baseline_classification = _classification(payload.get("baseline"))
+    changed_classification = _classification(payload.get("changed"))
+    claim_kind = (
+        "qualitative-simulation-regression"
+        if baseline_classification is not None
+        and changed_classification is not None
+        and baseline_classification != changed_classification
+        else "simulation-replay-regression"
+    )
+    evidence = {
+        "schema_version": "1.0",
+        "producer": _PRODUCER,
+        "claim": {
+            "kind": claim_kind,
+            "model": payload.get("model"),
+            "baseline_classification": baseline_classification,
+            "changed_classification": changed_classification,
+            "reproducible_at_generation": payload.get("reproducible"),
+        },
+        "decision": {
+            "status": "REPLAY_VERIFIED",
+            "comparison_mode": verification.mode,
+            "comparisons": [dict(item) for item in verification.comparisons],
+        },
+        "artifacts": {
+            "replay_fixture": {
+                "path": copied_fixture.relative_to(output_directory).as_posix(),
+                "sha256": _sha256(fixture_bytes),
+            },
+            "pytest_regression": {
+                "path": test_path.relative_to(output_directory).as_posix(),
+                "sha256": _sha256(source_bytes),
+            },
+        },
+        "reproduction": {
+            "working_directory": ".",
+            "command": f"python -m pytest -q {test_path.name}",
+        },
+        "limitations": _LIMITATIONS,
+    }
+    evidence_bytes = (
+        json.dumps(evidence, allow_nan=False, indent=2, sort_keys=True) + "\n"
+    ).encode("utf-8")
+    write_fixture = _reject_conflict(copied_fixture, fixture_bytes, "replay fixture")
+    write_test = _reject_conflict(test_path, source_bytes, "generated pytest")
+    write_evidence = _reject_conflict(evidence_path, evidence_bytes, "generated pytest evidence")
+    output_directory.mkdir(parents=True, exist_ok=True)
+    fixture_directory.mkdir(exist_ok=True)
+    if write_fixture:
+        copied_fixture.write_bytes(fixture_bytes)
+    if write_test:
+        test_path.write_bytes(source_bytes)
+    if write_evidence:
+        evidence_path.write_bytes(evidence_bytes)
+    return GeneratedTest(
+        test_path=test_path,
+        fixture_path=copied_fixture,
+        evidence_path=evidence_path,
+    )