railmux 0.4.2.dev3__tar.gz → 0.4.2.dev5__tar.gz

{railmux-0.4.2.dev3/src/railmux.egg-info → railmux-0.4.2.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev3
+Version: 0.4.2.dev5
 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.2.dev5/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.2.dev5"

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5}/src/railmux/fast_display_server.py

@@ -1747,6 +1747,83 @@ def _transcript_rows(
         os.close(fd)
 
 
+_OVERLAP_STYLE_RE = re.compile(rb"\x1b\[[0-9;]*m")
+_OVERLAP_SPACE_RE = re.compile(r"\s+")
+_OVERLAP_ANCHOR_CHARS = 12
+_OVERLAP_SINGLE_ANCHOR_CHARS = 24
+_OVERLAP_SEARCH_SCREENS = 4
+_OVERLAP_MIN_SEARCH_ROWS = 200
+
+
+def _overlap_text(row: bytes) -> str:
+    """Return a row's visible text without styling or any whitespace.
+
+    The transcript and the provider wrap and indent the same message
+    differently, so only the whitespace-free character stream is comparable.
+    """
+    text = _OVERLAP_STYLE_RE.sub(b"", row).decode("utf-8", errors="replace")
+    return _OVERLAP_SPACE_RE.sub("", text)
+
+
+def _transcript_rows_before_screen(
+    transcript_rows: Sequence[bytes],
+    screen_rows: Sequence[bytes],
+) -> int:
+    """Return how many transcript rows precede the live screen's content.
+
+    Transcript-backed history appends the live viewport after the transcript,
+    whose tail usually holds the same newest message. Locate the screen's
+    text in the transcript tail through distinctive anchor rows and cut the
+    transcript where the screen begins. Two anchors must agree on that start
+    unless one long anchor is the only candidate; without a credible match
+    every transcript row is kept.
+    """
+    total = len(transcript_rows)
+    window = max(
+        _OVERLAP_MIN_SEARCH_ROWS, _OVERLAP_SEARCH_SCREENS * len(screen_rows))
+    first = max(0, total - window)
+    row_starts: list[int] = []
+    parts: list[str] = []
+    offset = 0
+    for row in transcript_rows[first:]:
+        row_starts.append(offset)
+        text = _overlap_text(row)
+        parts.append(text)
+        offset += len(text)
+    haystack = "".join(parts)
+    screen_offset = 0
+    starts: list[tuple[int, int]] = []
+    for row in screen_rows:
+        text = _overlap_text(row)
+        if len(text) >= _OVERLAP_ANCHOR_CHARS and haystack.count(text) == 1:
+            starts.append((haystack.index(text) - screen_offset, len(text)))
+            if len(starts) == 2:
+                break
+        screen_offset += len(text)
+    if not starts:
+        return total
+    if len(starts) == 1:
+        if starts[0][1] < _OVERLAP_SINGLE_ANCHOR_CHARS:
+            return total
+    else:
+        # Allow small rendering differences (list numbering, bullets).
+        tolerance = 16 + abs(starts[0][0]) // 20
+        if abs(starts[0][0] - starts[1][0]) > tolerance:
+            return total
+    start = max(0, starts[0][0])
+    # Keep a row that begins before the screen: it may carry text the screen
+    # no longer shows, and a partial duplicate is better than a loss.
+    keep = len(row_starts)
+    for index, row_start in enumerate(row_starts):
+        if row_start >= start:
+            keep = index
+            break
+    # Drop trailing blank rows so the screen is not preceded by a gap.
+    while keep and not parts[keep - 1]:
+        keep -= 1
+    return first + keep
+
+
 def _capture_pane_history(
     pyte: object,
     pane: _PaneGeometry,
@@ -1852,14 +1929,18 @@ def _capture_pane_history(
     transcript_used = transcript_entry is not None and bool(transcript_entry.rows)
     if transcript_used:
         assert transcript_entry is not None
-        transcript_lines = transcript_entry.rows
+        kept = _transcript_rows_before_screen(transcript_entry.rows, current_raw)
+        trimmed = len(transcript_entry.rows) - kept
+        transcript_lines = transcript_entry.rows[:kept]
         history_count = max(0, max_lines - pane.height)
         source_lines = (
             transcript_lines[-history_count:] if history_count else ()
         ) + current_raw
         timeline_end = max(
             pane.height,
-            (transcript_entry.total_rows or len(transcript_entry.rows)) + pane.height,
+            (transcript_entry.total_rows or len(transcript_entry.rows))
+            - trimmed
+            + pane.height,
         )
     else:
         source_lines = rendered_raw
@@ -1910,7 +1991,7 @@ def _capture_pane_history(
             budget_truncated
             or (
                 transcript_entry.more_available
-                or len(transcript_entry.rows) + pane.height > len(lines)
+                or len(transcript_lines) + pane.height > len(lines)
                 if transcript_used and transcript_entry is not None
                 else pane.history_size + pane.height > len(lines)
             )

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5}/src/railmux/models.py

@@ -84,6 +84,12 @@ class SessionMeta:
     # 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
+    # Successor named by a final Claude ``continued-in`` record: the live
+    # conversation moved to that session file. Always None for Codex.
+    continued_in_id: str | None = None
+    # Claude Code background-job (``sessionKind: bg``) session. Listings hide
+    # these unless one is the ``continued-in`` successor of a visible session.
+    background: bool = False
 
     @property
     def display_title(self) -> str:

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5}/src/railmux/session_cache.py

@@ -33,6 +33,9 @@ class SessionCache:
         # User-assigned titles, overlaid at read time so they survive Claude
         # Code rewriting its own ai-title record every turn.
         self._renames = renames
+        # Claude ``continued-in`` links seen by listings: predecessor id ->
+        # successor id. The App uses them to move live bindings and favorites.
+        self.continuations: dict[str, str] = {}
 
     def list_sessions(
         self, project: Project, top_n: int = _DEFAULT_TOP_N
@@ -86,9 +89,60 @@ class SessionCache:
             if stale.parent == project.claude_dir and stale not in current_paths:
                 del self._entries[stale]
 
+        results = self._hide_continued(project, results)
         results.sort(key=lambda s: s.last_mtime, reverse=True)
         return results
 
+    def _hide_continued(
+        self, project: Project, results: list[SessionMeta]
+    ) -> list[SessionMeta]:
+        """Drop background sessions and sessions continued in a successor.
+
+        Claude Code copies the whole conversation into the successor, so the
+        predecessor is a stale duplicate. A user rename moves forward with it.
+        A background successor of a visible session is the same interactive
+        conversation now hosted by Claude's daemon, so it stays visible.
+        """
+        by_id = {meta.session_id: meta for meta in results}
+        visible = {meta.session_id for meta in results if not meta.background}
+        pending = list(visible)
+        while pending:
+            successor = by_id[pending.pop()].continued_in_id
+            if successor in by_id and successor not in visible:
+                visible.add(successor)
+                pending.append(successor)
+        results = [meta for meta in results if meta.session_id in visible]
+        hidden: dict[str, str] = {}
+        for meta in results:
+            successor = meta.continued_in_id
+            if (
+                successor is not None
+                and successor != meta.session_id
+                and (project.claude_dir / f"{successor}.jsonl").is_file()
+            ):
+                hidden[meta.session_id] = successor
+        if not hidden:
+            return results
+        self.continuations.update(hidden)
+        carried: set[str] = set()
+        if self._renames is not None:
+            # Walk each chain forward so A -> B -> C carries A's rename to C.
+            for _ in range(len(hidden)):
+                changed = False
+                for predecessor, successor in hidden.items():
+                    title = self._renames.get(predecessor)
+                    if title and not self._renames.get(successor):
+                        self._renames.set(successor, title)
+                        carried.add(successor)
+                        changed = True
+                if not changed:
+                    break
+        return [
+            self._with_override(meta) if meta.session_id in carried else meta
+            for meta in results
+            if meta.session_id not in hidden
+        ]
+
     def get(self, project: Project, session_id: str) -> SessionMeta | None:
         """Cache-backed lookup of a single session's metadata by id.
 

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5}/src/railmux/session_index.py

@@ -43,6 +43,7 @@ class _SessionScanState:
     last_rtype: str = ""
     last_stop_reason: str = ""
     background: bool = False
+    continued_in: str | None = None
 
     def clone(self) -> _SessionScanState:
         return _SessionScanState(
@@ -62,6 +63,7 @@ class _SessionScanState:
             last_rtype=self.last_rtype,
             last_stop_reason=self.last_stop_reason,
             background=self.background,
+            continued_in=self.continued_in,
         )
 
 
@@ -169,14 +171,25 @@ def _can_resume(fd: int, st: os.stat_result, state: _SessionScanState) -> bool:
 
 
 def _consume_record(state: _SessionScanState, rec: object) -> None:
-    if not isinstance(rec, dict) or state.background:
+    if not isinstance(rec, dict):
         return
     # Background-job sessions are not interactive — they can't be resumed in
-    # a terminal and shouldn't appear in the sidebar.
+    # a terminal and shouldn't appear in the sidebar. Their metadata is still
+    # collected because Claude Code also hosts a live conversation that was
+    # ``continued-in`` a daemon session this way; listings decide visibility.
     if rec.get("sessionKind") == "bg":
         state.background = True
-        return
     rtype = rec.get("type")
+    # Claude Code ends a session file with ``continued-in`` when the live
+    # conversation moves to a new session. Only a final record counts.
+    successor = rec.get("continuedInSessionId")
+    state.continued_in = (
+        successor
+        if rtype == "continued-in"
+        and isinstance(successor, str)
+        and _looks_like_uuid(successor)
+        else None
+    )
     if rtype == "ai-title":
         state.title = rec.get("aiTitle") or state.title
     # NOTE: "last-prompt" is deliberately NOT treated as a turn. Claude Code
@@ -235,8 +248,6 @@ def _meta_from_state(
     state: _SessionScanState,
     st: os.stat_result,
 ) -> SessionMeta | None:
-    if state.background:
-        return None
     assistant_count = len(state.assistant_token_totals)
     message_count = state.user_count + assistant_count
     if message_count == 0 or (state.user_count > 0 and assistant_count == 0):
@@ -277,6 +288,8 @@ def _meta_from_state(
         last_user_message=preview,
         status=status,
         pending_tool=pending_tool,
+        continued_in_id=state.continued_in,
+        background=state.background,
     )
 
 
@@ -352,7 +365,8 @@ def _scan_session_incremental(
 
 
 def _scan_session(project: Project, jsonl_path: Path) -> SessionMeta | None:
-    return _scan_session_incremental(project, jsonl_path).meta
+    meta = _scan_session_incremental(project, jsonl_path).meta
+    return None if meta is not None and meta.background else meta
 
 
 def _looks_like_uuid(s: str) -> bool:

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5}/src/railmux/tmux_server.py

@@ -22,6 +22,8 @@ _SESSION_ID_RE = re.compile(r"[A-Za-z0-9-]{1,256}\Z")
 _HISTORY_SOURCE_SCHEMA = 1
 _TRANSCRIPT_SOURCE_SCHEMA = 1
 _MAX_TRANSCRIPT_SOURCE_BYTES = 8192
+_CONTINUATION_TAIL_BYTES = 4096
+_MAX_CONTINUATION_HOPS = 8
 _DEFAULT_DISCOVERY_TIMEOUT = 2.0
 _WINDOWS_DISCOVERY_TIMEOUT = 5.0
 
@@ -415,11 +417,8 @@ def decode_transcript_source(raw: str) -> TranscriptSource | None:
     return TranscriptSource(provider, session_id, path)
 
 
-def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
-    """Open an exact same-user transcript without following the final symlink."""
-    source = decode_transcript_source(raw)
-    if source is None:
-        return None
+def _open_owned_regular_file(path: Path) -> int | None:
+    """Open a same-user regular file without following the final symlink."""
     flags = os.O_RDONLY
     if hasattr(os, "O_CLOEXEC"):
         flags |= os.O_CLOEXEC
@@ -427,7 +426,7 @@ def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
         flags |= os.O_NOFOLLOW
     fd = -1
     try:
-        fd = os.open(source.path, flags)
+        fd = os.open(path, flags)
         info = os.fstat(fd)
     except OSError:
         if fd >= 0:
@@ -443,6 +442,67 @@ def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
     ):
         os.close(fd)
         return None
+    return fd
+
+
+def _claude_continuation_id(fd: int) -> str | None:
+    """Return the successor session named by a final ``continued-in`` record.
+
+    Claude Code can move a live conversation to a new session file, copying
+    the full history and ending the old file with one ``continued-in``
+    record. Only that exact final record is trusted.
+    """
+    try:
+        size = os.fstat(fd).st_size
+        tail = os.pread(
+            fd,
+            min(size, _CONTINUATION_TAIL_BYTES),
+            max(0, size - _CONTINUATION_TAIL_BYTES),
+        )
+    except OSError:
+        return None
+    lines = tail.rstrip(b"\n").rsplit(b"\n", 1)
+    if b"continued-in" not in lines[-1]:
+        return None
+    try:
+        record = json.loads(lines[-1])
+    except (UnicodeDecodeError, ValueError):
+        return None
+    if not isinstance(record, dict) or record.get("type") != "continued-in":
+        return None
+    successor = record.get("continuedInSessionId")
+    if not isinstance(successor, str) or not _SESSION_ID_RE.fullmatch(successor):
+        return None
+    return successor
+
+
+def open_transcript_source(raw: str) -> tuple[TranscriptSource, int] | None:
+    """Open an exact same-user transcript without following the final symlink.
+
+    A Claude transcript that was continued in another session resolves to the
+    newest same-directory successor, so history keeps following the live pane.
+    """
+    source = decode_transcript_source(raw)
+    if source is None:
+        return None
+    fd = _open_owned_regular_file(source.path)
+    if fd is None:
+        return None
+    if source.provider != "claude":
+        return source, fd
+    seen = {source.session_id}
+    for _ in range(_MAX_CONTINUATION_HOPS):
+        successor = _claude_continuation_id(fd)
+        if successor is None or successor in seen:
+            break
+        path = source.path.with_name(f"{successor}.jsonl")
+        next_fd = _open_owned_regular_file(path)
+        if next_fd is None:
+            break
+        os.close(fd)
+        fd = next_fd
+        source = TranscriptSource(source.provider, successor, path)
+        seen.add(successor)
     return source, fd
 
 

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5}/src/railmux/ui/app.py

@@ -426,6 +426,7 @@ def _session_lease_failure_description(category: str | None) -> str:
 # Unlike the short-lived runtime state file, a session option lives exactly as
 # long as the tmux session and survives Railmux restarts without renaming it.
 _SESSION_BINDING_OPTION = "@railmux_binding_v1"
+_CLAUDE_CONTINUATION_MAX_HOPS = 8
 _HELP_SESSION_OPTION = "@railmux_help_v1"
 _HELP_POLICY_VERSION = "read-only-auto-v2"
 
@@ -9194,6 +9195,7 @@ class App:
         # stays stuck True, defeating the 3s project-scan cache. Codex
         # resolution must run too or neither ever clears.
         self._resolve_placeholders(projects, server)
+        self._follow_claude_continuations()
         running_ids = self._running_session_ids()
         if self._selected_project is not None:
             matched = next((p for p in projects if p.encoded_name == self._selected_project.encoded_name), None)
@@ -10228,6 +10230,83 @@ class App:
             # activity without enabling per-poll row movement.
             self._running_sort_ts = 0.0
 
+    def _follow_claude_continuations(self) -> None:
+        """Move live Claude bindings and favorites to ``continued-in`` successors.
+
+        Claude Code can continue a live conversation in a new session file and
+        end the old file with one ``continued-in`` record. The pane is the
+        same, so re-key its running entry to the newest successor: the binding,
+        Preview marker, lease and Sessions row then follow the live writer.
+        """
+        cache = getattr(self, "_session_cache", None)
+        if cache is None:
+            return
+        continuations = getattr(cache, "continuations", {})
+        if continuations and getattr(self, "_favorites", None) is not None:
+            favorites = self._favorites.get_ids()
+            carried: set[str] = set()
+            for predecessor in favorites & continuations.keys():
+                successor = continuations[predecessor]
+                for _ in range(_CLAUDE_CONTINUATION_MAX_HOPS):
+                    if successor not in continuations:
+                        break
+                    successor = continuations[successor]
+                if successor not in favorites:
+                    carried.add(successor)
+            if carried:
+                self._favorites.set_many(carried, True)
+        claimed = self._running_session_ids() | set(self._running)
+        for r in list(self._running.values()):
+            registered_mode = self._modes().for_tmux_name(r.tmux_name)
+            session_type = (
+                registered_mode.session_type if registered_mode else r.session_type)
+            if (
+                session_type != "claude"
+                or r.is_placeholder
+                or r.is_legacy
+                or r.project is None
+            ):
+                continue
+            meta = cache.get(r.project, r.key)
+            successor_meta = None
+            seen = {r.key}
+            while (
+                meta is not None
+                and meta.continued_in_id is not None
+                and meta.continued_in_id not in seen
+                and len(seen) <= _CLAUDE_CONTINUATION_MAX_HOPS
+            ):
+                seen.add(meta.continued_in_id)
+                meta = cache.get(r.project, meta.continued_in_id)
+                if meta is not None:
+                    successor_meta = meta
+            if successor_meta is None:
+                continue
+            successor = successor_meta.session_id
+            if successor in claimed:
+                continue
+            if r.orphan is not None:
+                resolved_marker = r.orphan.resolved(successor)
+                if not self._write_orphan_marker(resolved_marker):
+                    continue
+                r.orphan = resolved_marker
+            del self._running[r.key]
+            r.key = successor
+            r.provider_session_id = None
+            r.label = f"{r.project.display_name}/{successor_meta.display_title}"
+            r.status = successor_meta.status
+            r.last_mtime = successor_meta.last_mtime
+            r.attention = successor_meta.attention
+            self._running[successor] = r
+            self._stamp_running(r)
+            self._record_session_lease_result(
+                r, self._ensure_running_session_lease(r, successor_meta))
+            claimed.add(successor)
+            displayed_slot = self._agent_workspace().slot_for_agent(r.tmux_name)
+            if displayed_slot is not None:
+                self._set_slot_active_target(
+                    displayed_slot, successor, r.tmux_name)
+
     def _correlate_codex_rollout(self, r: "_Running") -> set[str] | None:
         """Exact child→rollout correlation for a Codex placeholder (#12).
 
@@ -10284,11 +10363,12 @@ class App:
             return self._codex_representative(session_id)
         if project is None:
             return None
-        from railmux.session_index import _scan_session
+        from railmux.session_index import _scan_session_incremental
         jsonl_path = project.claude_dir / f"{session_id}.jsonl"
         if not jsonl_path.exists():
             return None
-        return _scan_session(project, jsonl_path)
+        # An explicit id may name a background ``continued-in`` successor.
+        return _scan_session_incremental(project, jsonl_path).meta
 
     # --- kill / delete session ---
 

{railmux-0.4.2.dev3 → railmux-0.4.2.dev5/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.2.dev3
+Version: 0.4.2.dev5
 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.2.dev3 → railmux-0.4.2.dev5}/src/railmux.egg-info/SOURCES.txt

@@ -99,6 +99,7 @@ tests/test_app_restart_restore.py
 tests/test_app_running_recovery.py
 tests/test_atomic_file.py
 tests/test_background_index.py
+tests/test_claude_continuation.py
 tests/test_cli.py
 tests/test_code_map.py
 tests/test_codex_delete.py