durable-workflow 2.5.9__tar.gz → 2.5.11__tar.gz

{durable_workflow-2.5.9/src/durable_workflow.egg-info → durable_workflow-2.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.9
+Version: 2.5.11
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -175,6 +175,14 @@ for immutable context, operation policies, shielded cleanup and recovery.
 
 ## Development
 
+The installed `durable-workflow-replay-conformance` command runs an offline
+Python replay shard. Its `sdk-python` artifact pin must match the installed
+distribution version reported by `importlib.metadata.version("durable-workflow")`.
+The report records that installed identity separately from the declared platform
+tuple and fails if metadata is missing or the SDK pin differs. Replay success
+does not prove installation or execution of the other declared artifacts; the
+aggregate runner supplies its own verified installation receipts.
+
 ```bash
 pip install -e '.[dev]'
 ruff check src/ tests/

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/README.md

@@ -135,6 +135,14 @@ for immutable context, operation policies, shielded cleanup and recovery.
 
 ## Development
 
+The installed `durable-workflow-replay-conformance` command runs an offline
+Python replay shard. Its `sdk-python` artifact pin must match the installed
+distribution version reported by `importlib.metadata.version("durable-workflow")`.
+The report records that installed identity separately from the declared platform
+tuple and fails if metadata is missing or the SDK pin differs. Replay success
+does not prove installation or execution of the other declared artifacts; the
+aggregate runner supplies its own verified installation receipts.
+
 ```bash
 pip install -e '.[dev]'
 ruff check src/ tests/

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.5.9"
+version = "2.5.11"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,8 +71,8 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.5.9"
-registry-version = "2.5.9"
+product-train = "2.5.11"
+registry-version = "2.5.11"
 supported-server-versions = "2.5.16"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/src/durable_workflow/replay_conformance.py

@@ -15,6 +15,7 @@ import json
 import sys
 from collections.abc import Mapping, Sequence
 from datetime import datetime, timezone
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 
@@ -204,6 +205,17 @@ def compose_report(
     started_at = _timestamp()
     versions = _canonical_artifact_metadata(dict(artifact_versions or {}))
     sources = _canonical_artifact_metadata(dict(artifact_sources or {}))
+    try:
+        installed_version = metadata.version("durable-workflow")
+    except metadata.PackageNotFoundError:
+        installed_version = None
+    identity = {
+        "runtime": "sdk-python",
+        "package": "durable-workflow",
+        "version": installed_version,
+        "version_source": "installed_distribution_metadata" if installed_version else "unavailable",
+        "declared_version": _artifact_metadata(versions, "sdk-python"),
+    }
     scenario_results: dict[str, dict[str, Any]] = {}
     findings: list[dict[str, Any]] = []
     finding_links: dict[str, list[dict[str, Any]]] = {}
@@ -212,7 +224,7 @@ def compose_report(
         scenario_results,
         findings,
         finding_links,
-        _published_artifact_scenario(versions, sources),
+        _published_artifact_scenario(versions, sources, installed_version),
     )
 
     for family, scenario_id in COMPLETED_SCENARIOS.items():
@@ -242,6 +254,9 @@ def compose_report(
     has_failures = any(
         scenario.get("status") != "pass" for scenario in scenario_results.values()
     )
+    for scenario in scenario_results.values():
+        scenario["implementation_identity"] = dict(identity)
+        scenario["artifact_tuple_evidence"] = "declared"
 
     return {
         "schema": RESULT_SCHEMA,
@@ -252,6 +267,8 @@ def compose_report(
         "finished_at": _timestamp(),
         "artifact_versions": versions,
         "artifact_sources": sources,
+        "artifact_tuple_evidence": "declared",
+        "implementation_identity": identity,
         "runtime_matrix": {
             "runtimes": ["sdk-python"],
         },
@@ -307,6 +324,7 @@ def _append_scenario(
 def _published_artifact_scenario(
     artifact_versions: Mapping[str, str],
     artifact_sources: Mapping[str, str],
+    installed_version: str | None,
 ) -> dict[str, Any]:
     missing_versions: list[str] = []
     missing_sources: list[str] = []
@@ -338,14 +356,14 @@ def _published_artifact_scenario(
             untrusted_sources[artifact] = source
 
     missing = sorted(set(missing_versions + missing_sources))
-    status = (
-        "pass"
-        if not missing
-        and not rejected_versions
-        and not forbidden_sources
-        and not untrusted_sources
-        else "fail"
-    )
+    declarations_valid = not missing and not rejected_versions and not forbidden_sources and not untrusted_sources
+    declared_version = _artifact_metadata(artifact_versions, "sdk-python")
+    identity_error = None
+    if not installed_version:
+        identity_error = "installed_sdk_metadata_missing"
+    elif declared_version != installed_version:
+        identity_error = "installed_sdk_version_mismatch"
+    status = "pass" if declarations_valid and identity_error is None else "fail"
 
     return _scenario(
         "published_artifact_install_only",
@@ -361,8 +379,14 @@ def _published_artifact_scenario(
             "rejected_versions": rejected_versions,
             "forbidden_sources": forbidden_sources,
             "untrusted_sources": untrusted_sources,
-            "published_artifacts_only": status == "pass",
-            "published_install_tuple_proven": status == "pass",
+            "declared_artifacts_published_only": bool(declarations_valid),
+            "declared_sdk_version": declared_version,
+            "installed_sdk_version": installed_version,
+            "sdk_identity_error": identity_error,
+            "sdk_version_matches": bool(installed_version and declared_version == installed_version),
+            "artifact_tuple_evidence": "declared",
+            "published_artifacts_only": False,
+            "published_install_tuple_proven": False,
         },
     )
 
@@ -589,11 +613,6 @@ def _scenario(
         "scenario_id": scenario_id,
         "status": status,
         "published_artifact_versions": dict(artifact_versions),
-        "implementation_identity": {
-            "runtime": "sdk-python",
-            "package": "durable-workflow",
-            "version": _artifact_metadata(artifact_versions, "sdk-python"),
-        },
         "runtime_matrix": {
             "runtimes": ["sdk-python"],
         },

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/src/durable_workflow/workflow.py

@@ -5238,7 +5238,7 @@ def _replay_state(
     pending: list[Command] = []
     advanced_cmd: Any = None
     terminal_condition_reopen_cmd: WaitCondition | None = None
-    version_decisions: dict[str, tuple[int, str]] = {}
+    version_decisions: dict[str, int] = {}
 
     def _version_error(detail: str, step: _RecordedStep | None = None) -> NonDeterministicReplayError:
         return NonDeterministicReplayError(
@@ -5256,13 +5256,12 @@ def _replay_state(
         if type(version) is not int:
             raise _version_error("Version marker must contain an integer version.", step)
         change_id = payload.get("change_id")
-        if "change_id" in payload and (not isinstance(change_id, str) or not change_id.strip()):
+        if not isinstance(change_id, str) or not change_id.strip():
             raise _version_error("Version marker must retain a non-empty change ID.", step)
-        if "min_supported" in payload or "max_supported" in payload:
-            minimum, maximum = payload.get("min_supported"), payload.get("max_supported")
-            if (type(minimum) is not int or type(maximum) is not int
-                    or not minimum <= version <= maximum):
-                raise _version_error("Recorded version marker has an invalid supported range.", step)
+        minimum, maximum = payload.get("min_supported"), payload.get("max_supported")
+        if (type(minimum) is not int or type(maximum) is not int
+                or not minimum <= version <= maximum):
+            raise _version_error("Recorded version marker has an invalid supported range.", step)
         return version
 
     def _consume_duplicate_version_markers() -> None:
@@ -5277,7 +5276,7 @@ def _replay_state(
             if _next_unconsumed_recorded_step() is not step:
                 return
             version = _recorded_version(step)
-            if version != version_decisions[change_id][0]:
+            if version != version_decisions[change_id]:
                 raise _version_error(f"Conflicting recorded decisions for change ID {change_id!r}.", step)
             # Earlier SDKs emitted a marker for every invocation. Consume these
             # aliases while retaining their physical positions for cancellation
@@ -5293,13 +5292,10 @@ def _replay_state(
         if (type(command.min_supported) is not int or type(command.max_supported) is not int
                 or command.min_supported > command.max_supported):
             raise _version_error(f"Invalid supported range for change ID {change_id!r}.")
-        family = "version" if command.result_kind == "version" else "patch"
         decision = version_decisions.get(change_id)
         step = _next_unconsumed_recorded_step()
         if decision is not None:
-            version, original_family = decision
-            if original_family != family:
-                raise _version_error(f"Change ID {change_id!r} cannot switch between version and patch helpers.", step)
+            version = decision
         elif step is not None and step.shape == "version marker":
             _assert_step_matches(command, step)
             version = _recorded_version(step)
@@ -5326,7 +5322,7 @@ def _replay_state(
                 f"Recorded version {version} for change ID {change_id!r} is outside "
                 f"the supported range {command.min_supported}..{command.max_supported}.", step,
             )
-        version_decisions.setdefault(change_id, (version, family))
+        version_decisions.setdefault(change_id, version)
         return _version_marker_result(command, version)
 
     def _parallel_leaf_kind(command: Any) -> str:

{durable_workflow-2.5.9 → durable_workflow-2.5.11/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.5.9
+Version: 2.5.11
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT
@@ -175,6 +175,14 @@ for immutable context, operation policies, shielded cleanup and recovery.
 
 ## Development
 
+The installed `durable-workflow-replay-conformance` command runs an offline
+Python replay shard. Its `sdk-python` artifact pin must match the installed
+distribution version reported by `importlib.metadata.version("durable-workflow")`.
+The report records that installed identity separately from the declared platform
+tuple and fails if metadata is missing or the SDK pin differs. Replay success
+does not prove installation or execution of the other declared artifacts; the
+aggregate runner supplies its own verified installation receipts.
+
 ```bash
 pip install -e '.[dev]'
 ruff check src/ tests/

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/tests/test_patch_history.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from itertools import permutations
 from typing import Any
 
 import pytest
@@ -74,6 +75,43 @@ class PatchCancellationWorkflow:
             return [decisions, "cancelled"]
 
 
+@workflow.defn(name="tests.patch.helpers")
+class MixedPatchHelpersWorkflow:
+    def run(self, ctx, helpers):  # type: ignore[no-untyped-def]
+        decisions = []
+        for helper in helpers:
+            command = ctx.get_version("same", -1, 1) if helper == "get_version" else getattr(ctx, helper)("same")
+            decisions.append((yield command))
+        result = yield ctx.schedule_activity("old", [])
+        return [decisions, result]
+
+
+@pytest.mark.parametrize("helpers", list(permutations(["get_version", "patched", "deprecate_patch"])))
+@pytest.mark.parametrize("marker_count", [0, 1, 2])
+@pytest.mark.parametrize("completed", [False, True])
+def test_helpers_share_one_decision_on_old_history(
+    helpers: tuple[str, ...], marker_count: int, completed: bool,
+) -> None:
+    history = [version_marker(sequence) for sequence in range(1, marker_count + 1)]
+    history += old_activity(marker_count + 1, completed)
+    commands = replay(MixedPatchHelpersWorkflow, history, [helpers]).commands
+    if not completed:
+        assert commands == []
+    else:
+        assert len(commands) == 1
+        assert isinstance(commands[0], CompleteWorkflow)
+        version = 1 if marker_count else -1
+        values = {"get_version": version, "patched": version == 1, "deprecate_patch": None}
+        assert commands[0].result == [[values[helper] for helper in helpers], "recorded"]
+
+
+@pytest.mark.parametrize("helpers", list(permutations(["get_version", "patched", "deprecate_patch"])))
+def test_helpers_record_one_decision_on_fresh_history(helpers: tuple[str, ...]) -> None:
+    commands = replay(MixedPatchHelpersWorkflow, [], [helpers]).commands
+    assert [type(command) for command in commands] == [RecordVersionMarker, ScheduleActivity]
+    assert commands[0].version == 1
+
+
 @pytest.mark.parametrize("completed", [False, True])
 def test_inserted_patch_preserves_unmarked_activity(completed: bool) -> None:
     outcome = replay(PatchInsertionWorkflow, old_activity(1, completed), [])
@@ -122,7 +160,7 @@ def test_repeated_version_reuses_first_decision() -> None:
 
 
 @pytest.mark.parametrize("arguments", [[3], [1, True]])
-def test_repeated_version_rejects_incompatible_range_or_family(arguments: list[Any]) -> None:
+def test_repeated_version_rejects_incompatible_range(arguments: list[Any]) -> None:
     with pytest.raises(NonDeterministicReplayError):
         replay(VersionRangeWorkflow, [], arguments)
 
@@ -134,6 +172,41 @@ def test_conflicting_duplicate_marker_is_rejected(version: Any) -> None:
         replay(RepeatedPatchWorkflow, history, [])
 
 
+@pytest.mark.parametrize("sequence", [1, 2])
+@pytest.mark.parametrize("bounds", [
+    {}, {"min_supported": -1}, {"max_supported": 1},
+    {"min_supported": True, "max_supported": 1},
+    {"min_supported": -1, "max_supported": "1"},
+    {"min_supported": 2, "max_supported": 1},
+    {"min_supported": -1, "max_supported": 0},
+])
+def test_canonical_markers_require_valid_recorded_ranges(sequence: int, bounds: dict[str, Any]) -> None:
+    markers = [version_marker(1), version_marker(2)]
+    markers[sequence - 1]["payload"].pop("min_supported")
+    markers[sequence - 1]["payload"].pop("max_supported")
+    markers[sequence - 1]["payload"].update(bounds)
+    with pytest.raises(NonDeterministicReplayError, match="invalid supported range"):
+        replay(RepeatedPatchWorkflow, markers + old_activity(3), [])
+
+
+@pytest.mark.parametrize("identity", [{}, {"change_id": None}, {"change_id": ""}, {"change_id": True}])
+def test_canonical_marker_requires_a_change_id(identity: dict[str, Any]) -> None:
+    marker = version_marker(1)
+    marker["payload"].pop("change_id")
+    marker["payload"].update(identity)
+    with pytest.raises(NonDeterministicReplayError, match="non-empty change ID"):
+        replay(RepeatedPatchWorkflow, [marker] + old_activity(2), [])
+
+
+def test_duplicate_ranges_may_differ_around_the_same_version() -> None:
+    marker = version_marker(2)
+    marker["payload"].update(min_supported=0, max_supported=3)
+    commands = replay(RepeatedPatchWorkflow, [version_marker(1), marker] + old_activity(3), []).commands
+    assert len(commands) == 1
+    assert isinstance(commands[0], CompleteWorkflow)
+    assert commands[0].result == [True, True, "recorded"]
+
+
 @pytest.mark.parametrize("marker_count", [0, 1, 2])
 def test_patch_decisions_preserve_committed_cancellation_sequence(marker_count: int) -> None:
     history = [version_marker(sequence) for sequence in range(1, marker_count + 1)]

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/tests/test_replay.py

@@ -1949,7 +1949,9 @@ class TestVersionMarker:
 
     def test_version_from_history(self) -> None:
         history = [
-            {"event_type": "VersionMarkerRecorded", "payload": {"version": 2}},
+            {"event_type": "VersionMarkerRecorded", "payload": {
+                "sequence": 1, "change_id": "change-1", "version": 2, "min_supported": 1, "max_supported": 2,
+            }},
         ]
         outcome = replay(VersionWorkflow, history, [])
         assert len(outcome.commands) == 1
@@ -1959,7 +1961,9 @@ class TestVersionMarker:
 
     def test_old_version_from_history(self) -> None:
         history = [
-            {"event_type": "VersionMarkerRecorded", "payload": {"version": 1}},
+            {"event_type": "VersionMarkerRecorded", "payload": {
+                "sequence": 1, "change_id": "change-1", "version": 1, "min_supported": 1, "max_supported": 2,
+            }},
         ]
         outcome = replay(VersionWorkflow, history, [])
         assert len(outcome.commands) == 1
@@ -1969,7 +1973,9 @@ class TestVersionMarker:
 
     def test_full_replay(self) -> None:
         history = [
-            {"event_type": "VersionMarkerRecorded", "payload": {"version": 2}},
+            {"event_type": "VersionMarkerRecorded", "payload": {
+                "sequence": 1, "change_id": "change-1", "version": 2, "min_supported": 1, "max_supported": 2,
+            }},
             {"event_type": "ActivityCompleted", "payload": {"result": _avro("done")}},
         ]
         outcome = replay(VersionWorkflow, history, [])
@@ -2006,7 +2012,9 @@ class TestVersionMarker:
 
     def test_patched_uses_recorded_marker_for_existing_patched_runs(self) -> None:
         history = [
-            {"event_type": "VersionMarkerRecorded", "payload": {"version": 1}},
+            {"event_type": "VersionMarkerRecorded", "payload": {
+                "sequence": 1, "change_id": "patch-1", "version": 1, "min_supported": -1, "max_supported": 1,
+            }},
         ]
 
         outcome = replay(PatchedWorkflow, history, [])
@@ -2017,7 +2025,9 @@ class TestVersionMarker:
 
     def test_patched_uses_legacy_default_for_existing_unpatched_runs(self) -> None:
         history = [
-            {"event_type": "VersionMarkerRecorded", "payload": {"version": -1}},
+            {"event_type": "VersionMarkerRecorded", "payload": {
+                "sequence": 1, "change_id": "patch-1", "version": -1, "min_supported": -1, "max_supported": 1,
+            }},
         ]
 
         outcome = replay(PatchedWorkflow, history, [])
@@ -2040,7 +2050,9 @@ class TestVersionMarker:
 
         replayed = replay(
             DeprecatedPatchWorkflow,
-            [{"event_type": "VersionMarkerRecorded", "payload": {"version": 1}}],
+            [{"event_type": "VersionMarkerRecorded", "payload": {
+                "sequence": 1, "change_id": "patch-1", "version": 1, "min_supported": -1, "max_supported": 1,
+            }}],
             [],
         )
         assert len(replayed.commands) == 1

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/tests/test_replay_conformance.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import json
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 
+import pytest
+
 from durable_workflow.replay_conformance import (
     COVERAGE_SCOPE,
     RESULT_SCHEMA,
@@ -25,6 +28,11 @@ def artifact_versions() -> dict[str, str]:
     }
 
 
+@pytest.fixture(autouse=True)
+def installed_sdk_metadata(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(metadata, "version", lambda package: "0.4.73")
+
+
 def artifact_sources() -> dict[str, str]:
     return {
         "server": "docker_image",
@@ -81,7 +89,7 @@ def test_compose_report_emits_python_replay_conformance_shard() -> None:
         assert indexed[scenario_id]["status"] == "pass"
 
 
-def test_report_proves_published_artifact_install_policy() -> None:
+def test_report_validates_declared_tuple_without_claiming_installation_proof() -> None:
     report = compose_report(
         artifact_versions=artifact_versions(),
         artifact_sources=artifact_sources(),
@@ -90,13 +98,46 @@ def test_report_proves_published_artifact_install_policy() -> None:
     observed = published["observed_outputs"]
 
     assert published["status"] == "pass"
-    assert observed["published_artifacts_only"] is True
-    assert observed["published_install_tuple_proven"] is True
+    assert observed["published_artifacts_only"] is False
+    assert observed["published_install_tuple_proven"] is False
+    assert observed["declared_artifacts_published_only"] is True
+    assert observed["artifact_tuple_evidence"] == "declared"
+    assert observed["installed_sdk_version"] == "0.4.73"
+    assert observed["sdk_version_matches"] is True
+    assert observed["sdk_identity_error"] is None
+    assert report["implementation_identity"]["version"] == "0.4.73"
     assert observed["missing_artifacts"] == []
     assert observed["artifact_sources"]["server"] == "docker_image"
     assert observed["artifact_sources"]["sdk-python"] == "pypi_package"
 
 
+def test_report_rejects_declared_sdk_version_mismatch(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(metadata, "version", lambda package: "2.5.10")
+    report = compose_report(artifact_versions=artifact_versions(), artifact_sources=artifact_sources())
+    install = scenarios(report)["published_artifact_install_only"]
+    assert report["outcome"] == "fail"
+    assert install["status"] == "fail"
+    assert install["observed_outputs"]["installed_sdk_version"] == "2.5.10"
+    assert install["observed_outputs"]["declared_sdk_version"] == "0.4.73"
+    assert install["observed_outputs"]["sdk_identity_error"] == "installed_sdk_version_mismatch"
+    assert install["observed_outputs"]["published_install_tuple_proven"] is False
+    assert all(scenario["implementation_identity"]["version"] == "2.5.10" for scenario in report["scenario_results"])
+    assert report["finding_links"]["published_artifact_install_only"]
+
+
+def test_report_rejects_missing_installed_sdk_metadata(monkeypatch: pytest.MonkeyPatch) -> None:
+    def missing_metadata(package: str) -> str:
+        raise metadata.PackageNotFoundError(package)
+
+    monkeypatch.setattr(metadata, "version", missing_metadata)
+    report = compose_report(artifact_versions=artifact_versions(), artifact_sources=artifact_sources())
+    install = scenarios(report)["published_artifact_install_only"]
+    assert report["outcome"] == "fail"
+    assert install["observed_outputs"]["sdk_identity_error"] == "installed_sdk_metadata_missing"
+    assert install["implementation_identity"]["version"] is None
+    assert install["observed_outputs"]["published_install_tuple_proven"] is False
+
+
 def test_report_rejects_missing_versions_and_sources() -> None:
     report = compose_report(
         artifact_versions={"sdk-python": "0.4.73"},

{durable_workflow-2.5.9 → durable_workflow-2.5.11}/tests/test_replay_regression_corpus.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 from collections.abc import Mapping, Sequence
+from importlib import metadata
 from pathlib import Path
 from typing import Any
 from unittest.mock import AsyncMock
@@ -11,6 +12,7 @@ import pytest
 from durable_workflow import Replayer, Worker, serializer, workflow
 from durable_workflow.client import PROTOCOL_VERSION, Client, WorkflowExecution, WorkflowStreamAppendItem
 from durable_workflow.errors import NonDeterministicReplayError, WorkflowCancelled, WorkflowPayloadDecodeError
+from durable_workflow.replay_conformance import compose_report
 from durable_workflow.workflow import (
     LocalActivityExecutionAborted,
     WorkflowContext,
@@ -25,7 +27,12 @@ from tests.test_golden_history_replay import (
     GoldenTimeoutWaitWorkflow,
     GoldenVersionMarkerWorkflow,
 )
-from tests.test_patch_history import PatchCancellationWorkflow, PatchInsertionWorkflow, RepeatedPatchWorkflow
+from tests.test_patch_history import (
+    MixedPatchHelpersWorkflow,
+    PatchCancellationWorkflow,
+    PatchInsertionWorkflow,
+    RepeatedPatchWorkflow,
+)
 from tests.test_pending_operation_replay import PendingOperation
 from tests.test_update_signal_condition_replay import (
     PostConditionReceiversWorkflow,
@@ -290,6 +297,7 @@ WORKFLOWS = [
     ParallelResultBindingWorkflow,
     PatchCancellationWorkflow,
     PatchInsertionWorkflow,
+    MixedPatchHelpersWorkflow,
     RepeatedPatchWorkflow,
     PendingOperation,
     PagedRecordedSideEffectsWorkflow,
@@ -365,6 +373,27 @@ def _execute_fixture(fixture: dict[str, Any]) -> list[dict[str, Any]]:
     assert isinstance(workflow, dict)
     workflow_type = workflow.get("type")
     assert isinstance(workflow_type, str) and workflow_type
+    if workflow_type == "sdk.replay-conformance-report":
+        # This public command executes the SDK's offline replay scenarios. Its
+        # regression input is artifact declarations, not an invented history.
+        assert "history" not in fixture
+        inputs = workflow.get("input")
+        assert isinstance(inputs, list) and len(inputs) == 1 and isinstance(inputs[0], dict)
+        report = compose_report(**inputs[0])
+        install = next(scenario for scenario in report["scenario_results"]
+                       if scenario["scenario_id"] == "published_artifact_install_only")
+        observed = install["observed_outputs"]
+        commands = [{
+            "type": "replay_conformance_report",
+            "outcome": report["outcome"],
+            "sdk_identity_error": observed.get("sdk_identity_error"),
+            "declared_sdk_version": observed.get("declared_sdk_version"),
+            "published_install_tuple_proven": observed["published_install_tuple_proven"],
+        }]
+        _assert_matches(fixture["command_sequence"], commands, f"{fixture['id']}.command_sequence")
+        _assert_matches(fixture["expected"], {"command_sequence": commands}, f"{fixture['id']}.expected")
+        assert report["implementation_identity"]["version"] == metadata.version("durable-workflow")
+        return commands
     assert workflow_type in WORKFLOW_TYPES, (
         f"replay fixture workflow {workflow_type!r} has no Python implementation; "
         "register its reproducer workflow in WORKFLOWS"
@@ -456,6 +485,9 @@ def test_checked_in_replay_regression_corpus_uses_official_replayer(
     assert isinstance(workflow, dict)
     expected = fixture.get("expected")
     assert isinstance(expected, dict) and expected
+    if workflow.get("type") == "sdk.replay-conformance-report":
+        _execute_fixture(fixture)
+        return
     expected_error = expected.get("error")
     expected_replay_error = fixture.get("expected_replay_error")
     if isinstance(expected_replay_error, dict):