agenticreplay 0.1.0 → 0.1.2

package/python/tests/test_conformance.py

@@ -1,235 +0,0 @@
-"""Cross-implementation conformance against the checked-in trace.
-
-THIS IS THE MOST IMPORTANT TEST IN THE PACKAGE. It reads
-`examples/traces/run_9f2c14a03b71/` — a trace produced by the TypeScript writer — and asserts
-that this reader agrees with the TypeScript reader and graph about what that trace *means*.
-
-If it fails, do not adjust the expectations. A failure means Python and TypeScript disagree about
-a trace neither of them wrote today, and at that moment the "format" is not a format: it is a
-TypeScript library with a document next to it. The right response is to fix the spec, then fix
-whichever implementation the spec says is wrong.
-
-The golden values below were produced by `packages/core/src/graph.ts` (via its compiled
-`dist/graph.js`) over this same file, not by this package.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import json
-from pathlib import Path
-
-import pytest
-
-from agenticreplay_trace import (
-    ACTORS,
-    EVENT_TYPES,
-    INLINE_PAYLOAD_LIMIT,
-    RUN_ID_PATTERN,
-    SCHEMA_VERSION,
-    BlobRef,
-    TraceReader,
-    causal_chain,
-    derive_checkpoints,
-    snap_to_checkpoint,
-    turns_of,
-)
-
-# These are golden against the *TypeScript implementation*, not against arithmetic. When the example
-# trace changes, recompute them by running `deriveCheckpoints`, `turnsOf` and `chainTo` over the new
-# events rather than adjusting by hand — hand-adjusting makes the Python side agree with whoever did
-# the sums, which is the one thing these constants exist to prevent.
-#
-#: Every seq that satisfies spec §3 for this trace, per deriveCheckpoints() in TypeScript.
-GOLDEN_CHECKPOINT_SEQS = [1, 13, 14, 15, 16, 17, 20, 23, 24, 25, 26, 27, 28, 29, 30]
-
-#: (turn, startSeq, endSeq) per turnsOf() in TypeScript.
-GOLDEN_TURN_SPANS = [(0, 0, 1), (1, 2, 4), (2, 5, 8), (3, 9, 17), (4, 18, 20), (5, 21, 30)]
-
-#: causalChain(events, 17) in TypeScript — the failing test, traced back to its first request.
-GOLDEN_CHAIN_TO_17 = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 16, 17]
-
-GOLDEN_EVENT_COUNT = 31
-
-
-@pytest.fixture
-def reader(example_run: Path) -> TraceReader:
-    return TraceReader.open(example_run)
-
-
-class TestTheTraceItself:
-    def test_run_id_matches_the_directory_and_the_pattern(
-        self, reader: TraceReader, example_run: Path
-    ) -> None:
-        assert reader.manifest.run_id == example_run.name
-        assert RUN_ID_PATTERN.match(reader.manifest.run_id)
-
-    def test_the_sdk_implements_a_version_that_can_read_this_trace(
-        self, reader: TraceReader
-    ) -> None:
-        """Same MAJOR, and no newer than the SDK. Not equality.
-
-        The example is a trace, written once by whichever writer made it, and the format has
-        moved since — a MINOR bump only adds event types, so an older trace reads exactly as it
-        always did. Requiring the two to be equal meant every addition to the format broke a test
-        about a file that had not changed, and would have had a reader refuse traces it can read
-        perfectly well.
-        """
-        written = tuple(int(part) for part in reader.manifest.schema_version.split("."))
-        implemented = tuple(int(part) for part in SCHEMA_VERSION.split("."))
-        assert written[0] == implemented[0], "a MAJOR bump is a format this SDK does not read"
-        assert written <= implemented, "this trace was written by a newer format than the SDK"
-
-    def test_integrity_verifies(self, reader: TraceReader) -> None:
-        """Spec §6. A mismatch here means the checked-in example was edited by hand."""
-        ok, expected, actual = reader.verify_integrity()
-        assert ok, f"events.jsonl hashes to {actual}, manifest claims {expected}"
-
-    def test_reads_every_event_with_nothing_skipped(self, reader: TraceReader) -> None:
-        events = reader.events()
-        assert len(events) == GOLDEN_EVENT_COUNT
-        assert reader.problems() == [], "a valid trace must produce no problems"
-
-    def test_event_count_matches_the_manifest(self, reader: TraceReader) -> None:
-        assert reader.manifest.counts is not None
-        assert reader.manifest.counts["events"] == GOLDEN_EVENT_COUNT == len(reader.events())
-
-    def test_every_event_type_and_actor_is_known(self, reader: TraceReader) -> None:
-        """An unknown value here is either a spec change nobody told Python about, or drift."""
-        for event in reader.events():
-            assert event.type in EVENT_TYPES, f"seq {event.seq}: unknown type {event.type}"
-            assert event.actor in ACTORS, f"seq {event.seq}: unknown actor {event.actor}"
-
-    def test_seq_is_dense_and_starts_at_zero(self, reader: TraceReader) -> None:
-        assert [e.seq for e in reader.events()] == list(range(GOLDEN_EVENT_COUNT))
-
-    def test_the_run_is_bracketed_by_start_and_end(self, reader: TraceReader) -> None:
-        events = reader.events()
-        assert events[0].type == "run.start"
-        assert events[-1].type == "run.end"
-        assert [e.type for e in events].count("run.start") == 1
-        assert [e.type for e in events].count("run.end") == 1
-
-    def test_every_cause_precedes_its_event(self, reader: TraceReader) -> None:
-        for event in reader.events():
-            assert all(c < event.seq for c in event.causes), f"seq {event.seq}"
-
-    def test_mono_us_never_goes_backwards(self, reader: TraceReader) -> None:
-        """Spec §2.1: mono_us is authoritative for duration, so it must be monotonic."""
-        values = [e.mono_us for e in reader.events()]
-        assert values == sorted(values)
-
-
-class TestBlobs:
-    def test_every_referenced_blob_resolves_and_matches_its_digest(
-        self, reader: TraceReader
-    ) -> None:
-        refs = [e.blob for e in reader.events() if e.blob is not None]
-        assert refs, "the example trace is supposed to exercise the blob store"
-        for ref in refs:
-            data = reader.blob(ref, verify=True)
-            assert len(data) == ref.bytes, f"{ref.digest} declares {ref.bytes} bytes"
-
-    def test_blob_count_matches_the_manifest(self, reader: TraceReader, example_run: Path) -> None:
-        stored = [p for p in (example_run / "blobs").rglob("*") if p.is_file()]
-        assert reader.manifest.integrity is not None
-        assert len(stored) == reader.manifest.integrity["blob_count"]
-
-    def test_blobs_are_sharded_by_their_first_two_hex_characters(self, example_run: Path) -> None:
-        """Spec §2.2 fixes the layout, so a reader in any language can find a blob by digest."""
-        for path in (example_run / "blobs").rglob("*"):
-            if path.is_file():
-                assert path.parent.name == path.name[:2]
-
-    def test_no_payload_over_the_inline_limit_was_left_inline(self, reader: TraceReader) -> None:
-        """Spec §2.2: writers MUST spill anything over 4096 bytes so jq and rg still work."""
-        for event in reader.events():
-            if isinstance(event.payload, BlobRef) or event.payload is None:
-                continue
-            serialized = json.dumps(event.payload, separators=(",", ":"))
-            assert len(serialized.encode("utf-8")) <= INLINE_PAYLOAD_LIMIT, f"seq {event.seq}"
-
-    def test_a_json_payload_round_trips_to_a_python_value(self, reader: TraceReader) -> None:
-        request = next(e for e in reader.events() if e.type == "model.request" and e.blob)
-        assert isinstance(reader.payload(request), (dict, list))
-
-    def test_a_non_json_payload_comes_back_as_bytes(self, reader: TraceReader) -> None:
-        diff = next(
-            e
-            for e in reader.events()
-            if e.blob is not None and e.blob.media_type == "text/x-diff"
-        )
-        assert isinstance(reader.payload(diff), bytes)
-
-
-class TestCheckpointsAgreeWithTypeScript:
-    def test_checkpoint_sequence_numbers_match_exactly(self, reader: TraceReader) -> None:
-        """The one that matters: a fork of this run must land on the same seq in both languages."""
-        assert [c.seq for c in derive_checkpoints(reader.events())] == GOLDEN_CHECKPOINT_SEQS
-
-    def test_checkpoints_carry_the_governing_tree(self, reader: TraceReader) -> None:
-        checkpoints = derive_checkpoints(reader.events())
-        assert checkpoints[0].fs_tree == "3ab77f19c4e2a58d0b6f1e93c72d4a80b5e6f712"
-        assert {c.fs_tree for c in checkpoints[1:]} == {"9c1e4bd7f0a3821e5c94b6d2087fa31c4e5b9d63"}
-
-    def test_every_checkpoint_has_a_snapshot_at_or_before_it_in_its_turn(
-        self, reader: TraceReader
-    ) -> None:
-        """Re-derives condition 1 of spec §3 independently of derive_checkpoints itself."""
-        events = reader.events()
-        snapshots = [(e.seq, e.turn) for e in events if e.type == "fs.snapshot"]
-        for checkpoint in derive_checkpoints(events):
-            assert any(
-                seq <= checkpoint.seq and turn == checkpoint.turn for seq, turn in snapshots
-            ), f"checkpoint {checkpoint.seq} has no governing snapshot"
-
-    def test_a_checkpoint_is_never_recorded_only_derived(self, reader: TraceReader) -> None:
-        """Spec §3, from the other side.
-
-        This used to assert the opposite — that the fixture carried a live `checkpoint` event and
-        derivation agreed with it — which made a passing suite out of a fixture that taught every
-        implementer to emit the one event the format says not to.
-        """
-        assert [e.seq for e in reader.events() if e.type == "checkpoint"] == []
-        assert derive_checkpoints(reader.events()), "derivation still finds them without one"
-
-    def test_snapping_a_non_checkpoint_target_moves_back_and_says_so(
-        self, reader: TraceReader
-    ) -> None:
-        checkpoints = derive_checkpoints(reader.events())
-        # 19 is inside turn 4 with no checkpoint of its own, so it must move back to 17 and say so.
-        checkpoint, snapped = snap_to_checkpoint(checkpoints, 19)
-        assert (checkpoint.seq, snapped) == (17, True)
-        assert snap_to_checkpoint(checkpoints, 13) == (checkpoints[1], False)
-
-    def test_turn_spans_match(self, reader: TraceReader) -> None:
-        spans = [(t.turn, t.start_seq, t.end_seq) for t in turns_of(reader.events())]
-        assert spans == GOLDEN_TURN_SPANS
-
-    def test_causal_chain_matches(self, reader: TraceReader) -> None:
-        events = reader.events()
-        assert [e.seq for e in causal_chain(events, 17)] == GOLDEN_CHAIN_TO_17
-
-
-class TestReadingIsRepeatableAndReadOnly:
-    def test_streaming_and_bulk_reads_agree(self, reader: TraceReader) -> None:
-        assert list(reader.stream()) == reader.events()
-
-    def test_reading_the_example_trace_does_not_touch_it(self, example_run: Path) -> None:
-        before = {
-            str(p): (p.stat().st_mtime_ns, hashlib.sha256(p.read_bytes()).hexdigest())
-            for p in sorted(example_run.rglob("*"))
-            if p.is_file()
-        }
-        reader = TraceReader.open(example_run)
-        events = reader.events()
-        for event in events:
-            reader.payload(event)
-        derive_checkpoints(events)
-        reader.verify_integrity()
-        after = {
-            str(p): (p.stat().st_mtime_ns, hashlib.sha256(p.read_bytes()).hexdigest())
-            for p in sorted(example_run.rglob("*"))
-            if p.is_file()
-        }
-        assert after == before

package/python/tests/test_examples.py

@@ -1,60 +0,0 @@
-"""The worked example is documentation that runs, so it is tested like anything else."""
-
-from __future__ import annotations
-
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-from conftest import repo_root
-
-SCRIPT = Path(__file__).resolve().parents[1] / "examples" / "analyze.py"
-
-
-@pytest.fixture
-def analysis(example_run: Path) -> str:
-    result = subprocess.run(
-        [sys.executable, str(SCRIPT), str(example_run)],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    assert result.returncode == 0, result.stderr
-    assert result.stderr == "", "a clean trace must report no problems"
-    return result.stdout
-
-
-def test_reports_the_run_and_its_integrity(analysis: str) -> None:
-    assert "run_9f2c14a03b71" in analysis
-    assert "integrity: OK" in analysis
-
-
-def test_answers_the_token_question(analysis: str) -> None:
-    """Totals are paired back through `causes`, so this also exercises the causal DAG."""
-    assert "claude-opus-5" in analysis
-    assert "40350" in analysis and "934" in analysis
-
-
-def test_answers_the_churn_question(analysis: str) -> None:
-    assert "src/auth.ts" in analysis
-    assert "+18/-4" in analysis
-
-
-def test_shows_that_a_fork_target_moved(analysis: str) -> None:
-    """Both snapping outcomes, without pinning the seq the example happens to pick.
-
-    This asserted `snapped back from 20`, which tied the test to an arithmetic offset in the
-    example *and* to which seqs were checkpoints in the fixture. Editing the fixture broke it for
-    a reason that had nothing to do with snapping.
-    """
-    assert "snapped back from" in analysis, "no target demonstrated the snap"
-    assert "(exact)" in analysis, "no target demonstrated an exact hit"
-
-
-def test_runs_with_no_argument() -> None:
-    """The default path is the repo's example trace, so `python3 examples/analyze.py` just works."""
-    if repo_root() is None:
-        pytest.skip("not running inside an AgenticReplay checkout")
-    result = subprocess.run([sys.executable, str(SCRIPT)], capture_output=True, text=True, check=False)
-    assert result.returncode == 0, result.stderr

package/python/tests/test_graph.py

@@ -1,247 +0,0 @@
-"""Checkpoint derivation, ported case for case from packages/core/test/graph.test.ts.
-
-These cases are the behavioural contract of spec §3. They are duplicated rather than shared
-because the point of a second implementation is that it can disagree — and be caught.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import pytest
-
-from agenticreplay_trace import Checkpoint, TraceEvent, causal_chain, derive_checkpoints, snap_to_checkpoint, turns_of
-
-
-def ev(seq: int, type_: str, **over: Any) -> TraceEvent:
-    raw: dict[str, Any] = {
-        "seq": seq,
-        "ts": "2026-08-29T10:00:00.000Z",
-        "mono_us": seq * 1000,
-        "turn": 0,
-        "type": type_,
-        "actor": "agenticreplay",
-    }
-    raw.update(over)
-    return TraceEvent.from_json(raw)
-
-
-#: run.start, a snapshot, then a complete model exchange, then a note.
-SIMPLE = [
-    ev(0, "run.start"),
-    ev(1, "fs.snapshot", attrs={"tree": "tree-a"}),
-    ev(2, "model.request", actor="gateway"),
-    ev(3, "model.response", actor="model"),
-    ev(4, "note"),
-]
-
-
-class TestDeriveCheckpoints:
-    def test_finds_nothing_without_a_snapshot(self) -> None:
-        """No fs.snapshot means no state to fork from, whatever the conversation did."""
-        assert derive_checkpoints([ev(0, "run.start"), ev(1, "note")]) == []
-
-    def test_starts_at_the_snapshot_never_before_it(self) -> None:
-        assert [c.seq for c in derive_checkpoints(SIMPLE)] == [1, 2, 3, 4]
-
-    def test_carries_the_tree_id_from_the_governing_snapshot(self) -> None:
-        assert {c.fs_tree for c in derive_checkpoints(SIMPLE)} == {"tree-a"}
-
-    def test_uses_the_most_recent_snapshot_in_the_turn(self) -> None:
-        events = [
-            ev(0, "fs.snapshot", attrs={"tree": "old"}),
-            ev(1, "note"),
-            ev(2, "fs.snapshot", attrs={"tree": "new"}),
-            ev(3, "note"),
-        ]
-        by_seq = {c.seq: c for c in derive_checkpoints(events)}
-        assert by_seq[1].fs_tree == "old"
-        assert by_seq[3].fs_tree == "new"
-
-    def test_leaves_the_tree_unset_when_the_snapshot_recorded_none(self) -> None:
-        cps = derive_checkpoints([ev(0, "fs.snapshot"), ev(1, "note")])
-        assert [c.seq for c in cps] == [0, 1]
-        assert cps[0].fs_tree is None
-
-    def test_ignores_a_non_string_tree_attribute(self) -> None:
-        cps = derive_checkpoints([ev(0, "fs.snapshot", attrs={"tree": 7}), ev(1, "note")])
-        assert cps[0].fs_tree is None
-
-    def test_does_not_carry_a_snapshot_across_a_turn_boundary(self) -> None:
-        events = [
-            ev(0, "fs.snapshot", attrs={"tree": "tree-a"}),
-            ev(1, "note"),
-            ev(2, "note", turn=1),
-        ]
-        assert [c.seq for c in derive_checkpoints(events)] == [0, 1]
-
-    def test_records_the_turn_of_each_checkpoint(self) -> None:
-        events = [
-            ev(0, "fs.snapshot", attrs={"tree": "t0"}),
-            ev(1, "fs.snapshot", turn=1, attrs={"tree": "t1"}),
-            ev(2, "note", turn=1),
-        ]
-        assert derive_checkpoints(events) == [
-            Checkpoint(seq=0, turn=0, fs_tree="t0"),
-            Checkpoint(seq=1, turn=1, fs_tree="t1"),
-            Checkpoint(seq=2, turn=1, fs_tree="t1"),
-        ]
-
-    def test_stops_at_an_unanswered_model_request(self) -> None:
-        """State past a hung request is unknown — but the request itself is still forkable,
-        because retrying it is exactly what someone wants."""
-        events = [
-            ev(0, "fs.snapshot", attrs={"tree": "tree-a"}),
-            ev(1, "model.request", actor="gateway"),
-            ev(2, "note"),
-            ev(3, "note"),
-        ]
-        assert [c.seq for c in derive_checkpoints(events)] == [0, 1]
-
-    def test_resumes_across_turns_while_every_exchange_is_answered(self) -> None:
-        events = [
-            ev(0, "run.start"),
-            ev(1, "fs.snapshot", attrs={"tree": "t0"}),
-            ev(2, "model.request", actor="gateway"),
-            ev(3, "model.response", actor="model"),
-            ev(4, "fs.snapshot", turn=1, attrs={"tree": "t1"}),
-            ev(5, "model.request", turn=1, actor="gateway"),
-        ]
-        cps = derive_checkpoints(events)
-        assert [c.seq for c in cps] == [1, 2, 3, 4, 5]
-        assert cps[-1].fs_tree == "t1"
-
-    def test_pairs_requests_and_responses_in_order(self) -> None:
-        """One late reply does not unblock the next request: pairing is positional."""
-        events = [
-            ev(0, "fs.snapshot", attrs={"tree": "t0"}),
-            ev(1, "model.request", actor="gateway"),
-            ev(2, "model.response", actor="model"),
-            ev(3, "model.request", actor="gateway"),
-            ev(4, "note"),
-        ]
-        assert [c.seq for c in derive_checkpoints(events)] == [0, 1, 2, 3]
-
-    def test_reads_events_that_arrive_out_of_order(self) -> None:
-        shuffled = [SIMPLE[3], SIMPLE[0], SIMPLE[4], SIMPLE[2], SIMPLE[1]]
-        assert [c.seq for c in derive_checkpoints(shuffled)] == [1, 2, 3, 4]
-
-    def test_does_not_mutate_the_caller_s_list(self) -> None:
-        shuffled = [SIMPLE[3], SIMPLE[0], SIMPLE[4], SIMPLE[2], SIMPLE[1]]
-        before = list(shuffled)
-        derive_checkpoints(shuffled)
-        assert shuffled == before
-
-    def test_accepts_any_iterable_of_events(self) -> None:
-        assert [c.seq for c in derive_checkpoints(iter(SIMPLE))] == [1, 2, 3, 4]
-
-    def test_handles_an_empty_trace(self) -> None:
-        assert derive_checkpoints([]) == []
-
-
-class TestSnapToCheckpoint:
-    CPS = derive_checkpoints(
-        [
-            ev(0, "run.start"),
-            ev(1, "fs.snapshot", attrs={"tree": "t0"}),
-            ev(2, "note"),
-            ev(3, "fs.snapshot", turn=1, attrs={"tree": "t1"}),
-            ev(4, "note", turn=1),
-        ]
-    )
-
-    def test_does_not_move_when_the_target_is_already_a_checkpoint(self) -> None:
-        checkpoint, snapped = snap_to_checkpoint(self.CPS, 3)
-        assert checkpoint.seq == 3
-        assert snapped is False
-
-    def test_moves_back_to_the_nearest_preceding_checkpoint_and_says_so(self) -> None:
-        gapped = [Checkpoint(2, 0, "t0"), Checkpoint(7, 1, "t1")]
-        checkpoint, snapped = snap_to_checkpoint(gapped, 5)
-        assert checkpoint.seq == 2
-        assert snapped is True
-
-    def test_never_snaps_forward_at_any_target(self) -> None:
-        """Forking from state the run had not reached yet is silent corruption (spec §3)."""
-        gapped = [Checkpoint(2, 0), Checkpoint(5, 1), Checkpoint(9, 2)]
-        for target in range(2, 15):
-            checkpoint, snapped = snap_to_checkpoint(gapped, target)
-            expected = max(c.seq for c in gapped if c.seq <= target)
-            assert checkpoint.seq == expected, f"target {target}"
-            assert snapped == (checkpoint.seq != target)
-
-    def test_snaps_a_target_past_the_end_back_to_the_last_checkpoint(self) -> None:
-        checkpoint, snapped = snap_to_checkpoint(self.CPS, 9999)
-        assert checkpoint.seq == 4
-        assert snapped is True
-
-    def test_returns_the_checkpoint_whole_including_its_tree(self) -> None:
-        assert snap_to_checkpoint(self.CPS, 4)[0] == Checkpoint(seq=4, turn=1, fs_tree="t1")
-
-    def test_refuses_a_target_before_the_first_checkpoint(self) -> None:
-        with pytest.raises(ValueError, match="no checkpoint at or before 0"):
-            snap_to_checkpoint(self.CPS, 0)
-        with pytest.raises(ValueError, match="1"):
-            snap_to_checkpoint(self.CPS, 0)
-
-    def test_refuses_when_the_trace_has_no_checkpoints_at_all(self) -> None:
-        with pytest.raises(ValueError, match="(?i)no checkpoints"):
-            snap_to_checkpoint([], 4)
-
-    def test_tolerates_an_unsorted_checkpoint_list(self) -> None:
-        unsorted = [Checkpoint(9, 2), Checkpoint(2, 0), Checkpoint(5, 1)]
-        assert snap_to_checkpoint(unsorted, 8)[0].seq == 5
-
-
-class TestTurnsOf:
-    def test_groups_events_into_turns_with_their_span(self) -> None:
-        events = [ev(0, "run.start"), ev(1, "note"), ev(2, "note", turn=1), ev(3, "run.end", turn=1)]
-        turns = turns_of(events)
-        assert [(t.turn, t.start_seq, t.end_seq) for t in turns] == [(0, 0, 1), (1, 2, 3)]
-        assert [e.seq for e in turns[1].events] == [2, 3]
-
-    def test_orders_turns_numerically_even_when_the_log_interleaves_them(self) -> None:
-        events = [ev(0, "note", turn=2), ev(1, "note", turn=1), ev(2, "note", turn=2)]
-        assert [t.turn for t in turns_of(events)] == [1, 2]
-        assert len(turns_of(events)[1].events) == 2
-
-    def test_handles_an_empty_trace(self) -> None:
-        assert turns_of([]) == []
-
-
-class TestCausalChain:
-    EVENTS = [
-        ev(0, "run.start"),
-        ev(1, "model.request", causes=[0]),
-        ev(2, "model.response", causes=[1]),
-        ev(3, "tool.call", causes=[2]),
-        ev(4, "note"),
-    ]
-
-    def test_walks_causes_transitively_oldest_first(self) -> None:
-        assert [e.seq for e in causal_chain(self.EVENTS, 3)] == [0, 1, 2, 3]
-
-    def test_returns_just_the_event_when_nothing_caused_it(self) -> None:
-        assert [e.seq for e in causal_chain(self.EVENTS, 4)] == [4]
-
-    def test_visits_a_shared_ancestor_once(self) -> None:
-        diamond = [
-            ev(0, "run.start"),
-            ev(1, "tool.call", causes=[0]),
-            ev(2, "tool.call", causes=[0]),
-            ev(3, "note", causes=[1, 2]),
-        ]
-        assert [e.seq for e in causal_chain(diamond, 3)] == [0, 1, 2, 3]
-
-    def test_terminates_on_a_malformed_cycle_instead_of_hanging(self) -> None:
-        cyclic = [ev(0, "note", causes=[1]), ev(1, "note", causes=[0])]
-        assert [e.seq for e in causal_chain(cyclic, 1)] == [0, 1]
-
-    def test_skips_a_cause_that_is_not_in_the_trace(self) -> None:
-        """Readers drop unknown event types, so an ancestor may legitimately be missing."""
-        gapped = [ev(0, "run.start"), ev(2, "note", causes=[1, 0])]
-        assert [e.seq for e in causal_chain(gapped, 2)] == [0, 2]
-
-    def test_reports_a_seq_that_is_not_in_the_trace(self) -> None:
-        with pytest.raises(ValueError, match="42"):
-            causal_chain(self.EVENTS, 42)