railmux 0.4.0.dev21__tar.gz → 0.4.0.dev22__tar.gz

{railmux-0.4.0.dev21/src/railmux.egg-info → railmux-0.4.0.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev21
+Version: 0.4.0.dev22
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

railmux-0.4.0.dev22/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev22"

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/src/railmux/codex_index.py

@@ -37,7 +37,7 @@ _TOOL_BLOCK_AGE_S = 120
 
 
 FileSignature = tuple[int, int]  # (mtime_ns, size)
-_PERSISTENT_CACHE_SCHEMA = 1
+_PERSISTENT_CACHE_SCHEMA = 2
 _PERSISTENT_CACHE_MAX_BYTES = 16 * 1024 * 1024
 _PERSISTENT_CACHE_MAX_RECORDS = 100_000
 
@@ -177,6 +177,7 @@ def _cache_session(meta: SessionMeta) -> dict:
         "pending_tool": meta.pending_tool,
         "attention": _cache_attention(meta.attention),
         "forked_from_id": meta.forked_from_id,
+        "codex_rollback_count": meta.codex_rollback_count,
     }
 
 
@@ -185,6 +186,7 @@ def _decode_cache_session(path: Path, raw: object) -> SessionMeta:
         "session_id", "cwd", "project_key", "title", "message_count", "token_total",
         "last_mtime", "size_bytes", "git_branch", "last_user_message",
         "status", "pending_tool", "attention", "forked_from_id",
+        "codex_rollback_count",
     })
     if not isinstance(raw, dict) or frozenset(raw) != keys:
         raise ValueError("invalid cached session")
@@ -213,7 +215,12 @@ def _decode_cache_session(path: Path, raw: object) -> SessionMeta:
         for value, limit, nullable in strings
     ):
         raise ValueError("invalid cached session string")
-    counts = (raw["message_count"], raw["token_total"], raw["size_bytes"])
+    counts = (
+        raw["message_count"],
+        raw["token_total"],
+        raw["size_bytes"],
+        raw["codex_rollback_count"],
+    )
     if any(
         not isinstance(value, int)
         or isinstance(value, bool)
@@ -262,6 +269,7 @@ def _decode_cache_session(path: Path, raw: object) -> SessionMeta:
         session_type="codex",
         attention=_decode_cache_attention(raw["attention"]),
         forked_from_id=forked_from_id,
+        codex_rollback_count=raw["codex_rollback_count"],
     )
 
 
@@ -1049,6 +1057,7 @@ def _parse_codex_session(
     # -- scan remaining lines for messages, events -------------------
     title: str | None = None
     message_count = 0
+    rollback_count = 0
     token_total = 0
     first_user_message: str | None = None
     last_user_message: str | None = None
@@ -1166,6 +1175,7 @@ def _parse_codex_session(
                     attention = _codex_abort_attention(rec, event_order)
                     current_turn_had_error = True
             elif et == "thread_rolled_back":
+                rollback_count += 1
                 # task_complete / turn_aborted / thread_rolled_back: the turn is
                 # over and any dangling tool calls are dead — clear them so an
                 # aborted/rolled-back session never reads as busy/blocked.
@@ -1243,6 +1253,7 @@ def _parse_codex_session(
         session_type="codex",
         attention=attention,
         forked_from_id=forked_from_id,
+        codex_rollback_count=rollback_count,
     )
     if hidden_subagent:
         return HiddenCodexStatus(

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/src/railmux/models.py

@@ -70,11 +70,17 @@ class SessionMeta:
     # intentionally independent from ``status`` (conversation activity) and
     # from tmux/process liveness, which is owned by App's running registry.
     attention: AttentionState | None = None
-    # Codex creates a new rollout UUID when a conversation is rewound/forked.
-    # The parent link lets the Codex index present that chain as one logical
-    # conversation without changing the provider-owned UUID used for resume.
+    # Codex creates a new rollout UUID when a conversation is rewound/forked,
+    # resumed, continued, or compacted. The parent link lets the Codex index
+    # present that chain as one logical conversation without treating the link
+    # itself as proof of why the provider created it.
     # Always None for Claude sessions and older Codex rollouts.
     forked_from_id: str | None = None
+    # Number of provider-emitted ``thread_rolled_back`` lifecycle records in
+    # this Codex rollout.  Child rollouts can be ordinary continuation or
+    # compaction checkpoints, so the parent link alone is not rewind evidence.
+    # Always zero for Claude sessions and Codex versions without this signal.
+    codex_rollback_count: int = 0
     # A Railmux lease observed in the same shared provider history root. This
     # is a read-time UI overlay, never provider transcript metadata.
     remote_owner: str | None = None

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/src/railmux/tmux_ctl.py

@@ -1848,13 +1848,16 @@ RAILMUX_HISTORY_GENERATION_OPTION = "@railmux_history_generation_v1"
 # A confirmed branch transition prefixes the opaque SSH history cache epoch.
 # Plain generations use native pane history; only this explicit marker permits
 # the canonical transcript fallback that removes an abandoned rewind suffix.
-# Only the evidence-gated v2 marker authorizes transcript-backed Codex
-# scrolling.  The released v1 marker treated every live direct child rollout
-# as a rewind, but Codex can also create that shape while bootstrapping an
-# ordinary resume.  Keeping the prefix versioned makes existing over-broad
-# markers fail back to raw pane history on upgrade.
-RAILMUX_CANONICAL_HISTORY_PREFIX = "canonical-v2:"
-RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIX = "canonical:"
+# Only the provider-rollback-gated v3 marker authorizes transcript-backed Codex
+# scrolling.  Released v1/v2 markers used rollout-shape heuristics, but Codex
+# also creates identical parent/child rollouts for ordinary continuation and
+# compaction.  Versioning makes both over-broad markers fail back to raw pane
+# history on upgrade without touching provider files.
+RAILMUX_CANONICAL_HISTORY_PREFIX = "canonical-v3:"
+RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIXES = (
+    "canonical:",
+    "canonical-v2:",
+)
 # tmux names function keys only through F12. Private restore routes use
 # canonical xterm sequences in literal mode, so they cannot be confused with
 # user input forwarded to an agent pane.

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/src/railmux/ui/app.py

@@ -389,11 +389,10 @@ class _Running:
     # provider generation lets the refresh path discard only that stale
     # presentation cache when the exact live writer advances to its child.
     codex_canonical_session_id: str | None = None
-    # A direct rollout child is a rewind only after its parent was proved to
-    # belong to this provider process generation.  An explicit Codex resume
-    # may create a child rollout during bootstrap without rewinding anything.
-    codex_rollout_proven_in_pane: bool = False
-    codex_baseline_message_count: int = 0
+    # Provider-emitted rollback count when the current rollout was adopted.
+    # Parent/child rollout shape is not sufficient: Codex also forks ordinary
+    # continuation and compaction checkpoints without a user rewind.
+    codex_baseline_rollback_count: int = 0
     codex_history_generation_stamped: bool = False
     lease_session_ids: frozenset[str] = frozenset()
     lease_warning: str | None = None
@@ -6855,8 +6854,7 @@ class App:
             )
 
         canonical_id = None
-        rollout_proven = False
-        baseline_count = 0
+        baseline_rollback_count = 0
         if session_type == "codex":
             canonical_id = (
                 raw.get("codex_canonical_session_id")
@@ -6875,24 +6873,19 @@ class App:
                     canonical_uuid = None
                 if canonical_uuid != canonical_id.lower():
                     canonical_id = None
-            rollout_proven = (
-                raw.get("codex_rollout_proven_in_pane", False)
-                if trust_codex_history_state else False
-            )
-            baseline_count = (
-                raw.get("codex_baseline_message_count", 0)
-                if trust_codex_history_state else 0
+            raw_rollback_count = (
+                raw.get("codex_baseline_rollback_count")
+                if trust_codex_history_state else None
             )
-            if (
-                not isinstance(rollout_proven, bool)
-                or not isinstance(baseline_count, int)
-                or isinstance(baseline_count, bool)
-                or baseline_count < 0
+            if raw_rollback_count is not None and (
+                not isinstance(raw_rollback_count, int)
+                or isinstance(raw_rollback_count, bool)
+                or raw_rollback_count < 0
             ):
                 return None
+            baseline_rollback_count = raw_rollback_count or 0
             if canonical_id is None:
-                rollout_proven = False
-                baseline_count = 0
+                baseline_rollback_count = 0
             meta = self._codex_index.get(key, refresh=False)
             if (
                 canonical_id is not None
@@ -6900,8 +6893,16 @@ class App:
                 and canonical_id not in self._codex_lineage_ids(key)
             ):
                 canonical_id = None
-                rollout_proven = False
-                baseline_count = 0
+                baseline_rollback_count = 0
+            if canonical_id is not None and raw_rollback_count is None:
+                # Released bindings predate the explicit rollback baseline.
+                # Seed it from that exact indexed generation so inherited old
+                # rollback records cannot authorize a later ordinary child.
+                canonical_meta = self._codex_index.get(
+                    canonical_id, refresh=False)
+                if canonical_meta is not None:
+                    baseline_rollback_count = (
+                        canonical_meta.codex_rollback_count)
             if (meta is not None
                     and self._path_key(meta.project.real_path)
                     != self._path_key(cwd)):
@@ -6958,8 +6959,7 @@ class App:
                     status="busy",
                     session_type=session_type,
                     codex_canonical_session_id=canonical_id,
-                    codex_rollout_proven_in_pane=rollout_proven,
-                    codex_baseline_message_count=baseline_count,
+                    codex_baseline_rollback_count=baseline_rollback_count,
                 )
             meta = self._codex_representative(key) or meta
         else:
@@ -6976,10 +6976,8 @@ class App:
             session_type=session_type,
             codex_canonical_session_id=(
                 canonical_id if session_type == "codex" else None),
-            codex_rollout_proven_in_pane=(
-                rollout_proven if session_type == "codex" else False),
-            codex_baseline_message_count=(
-                baseline_count if session_type == "codex" else 0),
+            codex_baseline_rollback_count=(
+                baseline_rollback_count if session_type == "codex" else 0),
         )
 
     def _running_binding_data(
@@ -7020,10 +7018,8 @@ class App:
             if running.codex_canonical_session_id is not None:
                 data["codex_canonical_session_id"] = (
                     running.codex_canonical_session_id)
-                data["codex_rollout_proven_in_pane"] = (
-                    running.codex_rollout_proven_in_pane)
-                data["codex_baseline_message_count"] = (
-                    running.codex_baseline_message_count)
+                data["codex_baseline_rollback_count"] = (
+                    running.codex_baseline_rollback_count)
         return data
 
     def _stamp_running(self, running: _Running) -> bool:
@@ -7502,9 +7498,8 @@ class App:
                 ):
                     exact = self._codex_exact_meta(marker.session_id)
                     running.codex_canonical_session_id = marker.session_id
-                    running.codex_rollout_proven_in_pane = True
-                    running.codex_baseline_message_count = (
-                        exact.message_count if exact is not None else 0)
+                    running.codex_baseline_rollback_count = (
+                        exact.codex_rollback_count if exact is not None else 0)
             if running is None:
                 pre_launch_ids: frozenset[str] = frozenset()
                 pre_launch_complete = False
@@ -9207,14 +9202,11 @@ class App:
         the same terminal pane after a rewind. Its abandoned suffix can remain
         in raw tmux scrollback even though the canonical JSONL is correct.
 
-        A direct child is not sufficient evidence: Codex may also create one
-        while bootstrapping an ordinary ``resume``. Explicit-resume generations
-        therefore begin unproved. A child becomes a confirmed rewind only when
-        its parent was born/adopted in this pane generation or gained real
-        conversation messages after Railmux baselined it. An unproved first
-        child is adopted as the resume bootstrap generation without resetting
-        the pane or changing raw history format; descendants of that exact open
-        child can subsequently be confirmed normally.
+        Parent/child shape is not rewind evidence: Codex uses the same shape
+        for ordinary continuation, context compaction, and resume bootstrap.
+        A child becomes canonical only when the provider's explicit
+        ``thread_rolled_back`` count advanced after Railmux baselined its
+        parent.  Missing or ambiguous evidence keeps raw pane history.
         """
         current_id = meta.session_id
         previous_id = running.codex_canonical_session_id
@@ -9227,25 +9219,17 @@ class App:
             ):
                 # The first coherent index generation may arrive after Codex
                 # has already published its ordinary resume-bootstrap child.
-                # Adopt that exact descendant directly; it is now the proved
-                # generation for any later branch transition.
+                # Adopt only that exact open descendant as a raw baseline.
                 if not self._codex_rollout_is_exact_open(
                     running, meta, server, codex_rollout_probes
                 ):
                     return
-                running.codex_rollout_proven_in_pane = True
             running.codex_canonical_session_id = current_id
-            running.codex_baseline_message_count = meta.message_count
+            running.codex_baseline_rollback_count = meta.codex_rollback_count
             self._stamp_codex_history_state(running, meta)
             self._stamp_running(running)
             return
         if current_id == previous_id:
-            if (
-                not running.codex_rollout_proven_in_pane
-                and meta.message_count > running.codex_baseline_message_count
-            ):
-                running.codex_rollout_proven_in_pane = True
-                self._stamp_running(running)
             if not running.codex_history_generation_stamped:
                 self._stamp_codex_history_state(running, meta)
             return
@@ -9259,22 +9243,19 @@ class App:
             return
 
         previous_meta = self._codex_exact_meta(previous_id)
-        parent_gained_conversation = bool(
-            previous_meta is not None
-            and previous_meta.message_count
-            > running.codex_baseline_message_count
-        )
-        if not (
-            running.codex_rollout_proven_in_pane
-            or parent_gained_conversation
-        ):
-            # Ordinary Codex resume bootstrap: the direct child is exact and
-            # open in this pane, but the dormant parent never participated in
-            # this process generation. Adopt it as the new raw-history baseline
-            # and deliberately overwrite any released v1 canonical marker.
+        rollback_count = max(
+            meta.codex_rollback_count,
+            (
+                previous_meta.codex_rollback_count
+                if previous_meta is not None else 0
+            ),
+        )
+        if rollback_count <= running.codex_baseline_rollback_count:
+            # Ordinary continuation/compaction/resume: adopt the exact open
+            # child as a new raw-history baseline. This also overwrites any
+            # released v1/v2 marker that could have misclassified the pane.
             running.codex_canonical_session_id = current_id
-            running.codex_baseline_message_count = meta.message_count
-            running.codex_rollout_proven_in_pane = True
+            running.codex_baseline_rollback_count = rollback_count
             self._stamp_codex_history_state(running, meta)
             self._stamp_running(running)
             return
@@ -9287,8 +9268,7 @@ class App:
         if self._codex_real_pane_identity(running) is None:
             return
         running.codex_canonical_session_id = current_id
-        running.codex_baseline_message_count = meta.message_count
-        running.codex_rollout_proven_in_pane = True
+        running.codex_baseline_rollback_count = rollback_count
         self._stamp_codex_history_state(running, meta, canonical=True)
         self._stamp_running(running)
 
@@ -9332,10 +9312,10 @@ class App:
         """Publish Preview source plus the SSH history-source cache epoch.
 
         A plain UUID keeps managed SSH history on raw pane capture. Only a
-        confirmed rewind transition writes ``canonical-v2:<uuid>`` and permits
-        a transcript projection. Preserve that exact v2 marker across app
-        restarts; the released over-broad ``canonical:<uuid>`` marker is
-        intentionally replaced with a plain UUID.
+        provider-confirmed rewind writes ``canonical-v3:<uuid>`` and permits a
+        transcript projection. Preserve only that v3 marker across app
+        restarts; released heuristic v1/v2 markers are intentionally replaced
+        with a plain UUID.
         """
         if running.is_legacy:
             return
@@ -9373,8 +9353,6 @@ class App:
             marker == canonical_generation
             for marker in existing_generations.values()
         )
-        if effective_canonical:
-            running.codex_rollout_proven_in_pane = True
         desired_generation = (
             canonical_generation if effective_canonical else meta.session_id)
         generation_results = [
@@ -9588,8 +9566,7 @@ class App:
                 # Placeholder exclusion plus exact rollout correlation proves
                 # this generation was born in the pane we launched.
                 r.codex_canonical_session_id = candidate.session_id
-                r.codex_rollout_proven_in_pane = True
-                r.codex_baseline_message_count = candidate.message_count
+                r.codex_baseline_rollback_count = candidate.codex_rollback_count
             self._running[candidate.session_id] = r
             self._stamp_running(r)
             # A new provider session has no UUID to reserve before launch.

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev21
+Version: 0.4.0.dev22
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/tests/test_codex_index.py

@@ -1056,6 +1056,7 @@ def test_scan_codex_thread_rolled_back_not_busy(tmp_path):
     assert meta is not None
     assert meta.status == "idle"
     assert meta.attention is None
+    assert meta.codex_rollback_count == 1
 
 
 def test_scan_codex_task_started_without_complete_is_busy(tmp_path):

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/tests/test_codex_lineage.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 from pathlib import Path
 from unittest.mock import MagicMock
 
+import pytest
+
 from railmux import tmux_ctl, tmux_server
 from railmux.favorites import Favorites
 from railmux.models import Project, SessionMeta
@@ -80,8 +82,7 @@ def test_live_rewind_preserves_view_and_stamps_canonical_transcript(
         project=project,
         session_type="codex",
         codex_canonical_session_id=root_id,
-        codex_rollout_proven_in_pane=True,
-        codex_baseline_message_count=1,
+        codex_baseline_rollback_count=0,
     )
     meta = SessionMeta(
         project=project,
@@ -94,6 +95,7 @@ def test_live_rewind_preserves_view_and_stamps_canonical_transcript(
         last_mtime=2.0,
         session_type="codex",
         forked_from_id=root_id,
+        codex_rollback_count=1,
     )
     identity = tmux_ctl.PaneIdentity(
         "%9", 123, "railmux", "$4", "@5", False, 80, 24)
@@ -168,7 +170,7 @@ def test_first_codex_generation_only_establishes_scrollback_baseline(
     app._stamp_running.assert_called_once_with(running)
 
 
-def test_codex_conversation_proof_is_persisted_only_once(tmp_path) -> None:
+def test_same_codex_generation_does_not_manufacture_rollback(tmp_path) -> None:
     session_id = "019fc605-5188-7212-bc48-ea023fe8b73c"
     project = Project(tmp_path, "-project", Path(), 1, 0.0)
     running = _Running(
@@ -178,7 +180,7 @@ def test_codex_conversation_proof_is_persisted_only_once(tmp_path) -> None:
         project=project,
         session_type="codex",
         codex_canonical_session_id=session_id,
-        codex_baseline_message_count=1,
+        codex_baseline_rollback_count=3,
         codex_history_generation_stamped=True,
     )
     meta = SessionMeta(
@@ -190,6 +192,7 @@ def test_codex_conversation_proof_is_persisted_only_once(tmp_path) -> None:
         token_total=0,
         last_mtime=2.0,
         session_type="codex",
+        codex_rollback_count=3,
     )
     app = App.__new__(App)
     app._stamp_running = MagicMock()
@@ -197,8 +200,8 @@ def test_codex_conversation_proof_is_persisted_only_once(tmp_path) -> None:
     app._sync_codex_rewind_scrollback(running, meta, None, {})
     app._sync_codex_rewind_scrollback(running, meta, None, {})
 
-    assert running.codex_rollout_proven_in_pane
-    app._stamp_running.assert_called_once_with(running)
+    assert running.codex_baseline_rollback_count == 3
+    app._stamp_running.assert_not_called()
 
 
 def test_codex_resume_bootstrap_child_keeps_raw_history(
@@ -214,7 +217,7 @@ def test_codex_resume_bootstrap_child_keeps_raw_history(
         project=project,
         session_type="codex",
         codex_canonical_session_id=parent_id,
-        codex_baseline_message_count=8,
+        codex_baseline_rollback_count=4,
     )
     parent = SessionMeta(
         project=project,
@@ -225,6 +228,7 @@ def test_codex_resume_bootstrap_child_keeps_raw_history(
         token_total=0,
         last_mtime=1.0,
         session_type="codex",
+        codex_rollback_count=4,
     )
     child = SessionMeta(
         project=project,
@@ -236,6 +240,7 @@ def test_codex_resume_bootstrap_child_keeps_raw_history(
         last_mtime=2.0,
         session_type="codex",
         forked_from_id=parent_id,
+        codex_rollback_count=4,
     )
     app = App.__new__(App)
     app._codex_lineage_ids = MagicMock(return_value={parent_id, child_id})
@@ -247,13 +252,12 @@ def test_codex_resume_bootstrap_child_keeps_raw_history(
     app._sync_codex_rewind_scrollback(running, child, None, {})
 
     assert running.codex_canonical_session_id == child_id
-    assert running.codex_rollout_proven_in_pane
-    assert running.codex_baseline_message_count == child.message_count
+    assert running.codex_baseline_rollback_count == 4
     app._stamp_codex_history_state.assert_called_once_with(running, child)
     app._stamp_running.assert_called_once_with(running)
 
 
-def test_first_observed_resume_child_is_adopted_as_proven_raw_generation(
+def test_first_observed_resume_child_is_adopted_as_raw_generation(
     tmp_path,
 ) -> None:
     parent_id = "019fc605-5188-7212-bc48-ea023fe8b73c"
@@ -286,8 +290,7 @@ def test_first_observed_resume_child_is_adopted_as_proven_raw_generation(
     app._sync_codex_rewind_scrollback(running, child, None, {})
 
     assert running.codex_canonical_session_id == child_id
-    assert running.codex_rollout_proven_in_pane
-    assert running.codex_baseline_message_count == child.message_count
+    assert running.codex_baseline_rollback_count == 0
     app._stamp_codex_history_state.assert_called_once_with(running, child)
 
 
@@ -324,12 +327,12 @@ def test_first_observed_resume_child_waits_for_exact_live_writer(
     app._sync_codex_rewind_scrollback(running, child, None, {})
 
     assert running.codex_canonical_session_id is None
-    assert not running.codex_rollout_proven_in_pane
+    assert running.codex_baseline_rollback_count == 0
     app._stamp_codex_history_state.assert_not_called()
     app._stamp_running.assert_not_called()
 
 
-def test_codex_parent_activity_confirms_same_poll_rewind(
+def test_codex_provider_rollback_confirms_same_poll_rewind(
     monkeypatch, tmp_path,
 ) -> None:
     parent_id = "019fc605-5188-7212-bc48-ea023fe8b73c"
@@ -342,7 +345,7 @@ def test_codex_parent_activity_confirms_same_poll_rewind(
         project=project,
         session_type="codex",
         codex_canonical_session_id=parent_id,
-        codex_baseline_message_count=8,
+        codex_baseline_rollback_count=7,
     )
     parent = SessionMeta(
         project=project,
@@ -353,6 +356,7 @@ def test_codex_parent_activity_confirms_same_poll_rewind(
         token_total=0,
         last_mtime=2.0,
         session_type="codex",
+        codex_rollback_count=8,
     )
     child = SessionMeta(
         project=project,
@@ -364,6 +368,7 @@ def test_codex_parent_activity_confirms_same_poll_rewind(
         last_mtime=3.0,
         session_type="codex",
         forked_from_id=parent_id,
+        codex_rollback_count=8,
     )
     identity = tmux_ctl.PaneIdentity(
         "%9", 123, "railmux", "$4", "@5", False, 80, 24)
@@ -466,8 +471,11 @@ def test_codex_history_state_preserves_confirmed_canonical_marker_on_restart(
         "%9", tmux_server.TRANSCRIPT_SOURCE_OPTION)
 
 
-def test_codex_history_state_downgrades_released_v1_marker_to_raw(
-    monkeypatch, tmp_path,
+@pytest.mark.parametrize(
+    "legacy_prefix", tmux_ctl.RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIXES
+)
+def test_codex_history_state_downgrades_released_marker_to_raw(
+    monkeypatch, tmp_path, legacy_prefix,
 ) -> None:
     session_id = "019fc7c1-a27c-7ae0-9937-7570552a112a"
     project = Project(tmp_path, "-project", Path(), 1, 0.0)
@@ -497,9 +505,7 @@ def test_codex_history_state_downgrades_released_v1_marker_to_raw(
     monkeypatch.setattr(
         tmux_ctl,
         "pane_user_option",
-        lambda *_args: (
-            f"{tmux_ctl.RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIX}{session_id}"
-        ),
+        lambda *_args: f"{legacy_prefix}{session_id}",
     )
 
     app._stamp_codex_history_state(running, meta)
@@ -507,7 +513,6 @@ def test_codex_history_state_downgrades_released_v1_marker_to_raw(
     assert stamped.call_count == 2
     assert stamped.call_args_list[-1].args == (
         "%9", tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION, session_id)
-    assert not running.codex_rollout_proven_in_pane
 
 
 def test_codex_history_state_unifies_wrapper_with_existing_canonical_real_pane(
@@ -557,5 +562,4 @@ def test_codex_history_state_unifies_wrapper_with_existing_canonical_real_pane(
     ]
     assert [call.args for call in generation_calls] == [(
         "%10", tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION, canonical)]
-    assert running.codex_rollout_proven_in_pane
     assert running.codex_history_generation_stamped

{railmux-0.4.0.dev21 → railmux-0.4.0.dev22}/tests/test_fast_full_window.py

@@ -6818,8 +6818,11 @@ def test_server_accepts_canonical_history_only_for_matching_transcript(
     assert not mismatched[0].canonical_history
 
 
-def test_server_released_v1_canonical_marker_fails_back_to_raw(
-    monkeypatch, tmp_path,
+@pytest.mark.parametrize(
+    "legacy_prefix", tmux_ctl.RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIXES
+)
+def test_server_released_canonical_marker_fails_back_to_raw(
+    monkeypatch, tmp_path, legacy_prefix,
 ):
     session_id = "019fc7c1-a27c-7ae0-9937-7570552a112a"
     path = tmp_path / f"rollout-2026-08-04T02-49-33-{session_id}.jsonl"
@@ -6827,9 +6830,7 @@ def test_server_released_v1_canonical_marker_fails_back_to_raw(
     transcript = fast_display_server.tmux_server.encode_transcript_source(
         "codex", session_id, path)
     assert transcript is not None
-    generation = (
-        f"{tmux_ctl.RAILMUX_LEGACY_CANONICAL_HISTORY_PREFIX}{session_id}"
-    )
+    generation = f"{legacy_prefix}{session_id}"
     monkeypatch.setattr(
         fast_display_server, "_live_controller", lambda _session: "%1")
     monkeypatch.setattr(