railmux 0.4.2.dev4__tar.gz → 0.4.2.dev6__tar.gz

{railmux-0.4.2.dev4/src/railmux.egg-info → railmux-0.4.2.dev6}/PKG-INFO

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

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

{railmux-0.4.2.dev4 → railmux-0.4.2.dev6}/src/railmux/fast_display_server.py

@@ -374,7 +374,7 @@ class _TranscriptFormatCacheEntry:
 _TRANSCRIPT_CACHE: OrderedDict[tuple[str, int], _TranscriptCacheEntry] = OrderedDict()
 _TRANSCRIPT_CACHE_LIMIT = 4
 _TRANSCRIPT_FORMAT_CACHE: OrderedDict[
-    tuple[str, str], _TranscriptFormatCacheEntry
+    tuple[str, str, int | None], _TranscriptFormatCacheEntry
 ] = OrderedDict()
 _TRANSCRIPT_FORMAT_CACHE_LIMIT = 2
 _TRANSCRIPT_FORMAT_CACHE_MAX_CHARS = 4 * 1024 * 1024
@@ -1699,7 +1699,9 @@ def _transcript_rows(
         ):
             _TRANSCRIPT_CACHE.move_to_end(key)
             return cached
-        format_key = (str(source.path), source.provider)
+        # Claude history is pre-wrapped to the pane; Codex text is not.
+        format_width = width if source.provider == "claude" else None
+        format_key = (str(source.path), source.provider, format_width)
         formatted_entry = _TRANSCRIPT_FORMAT_CACHE.get(format_key)
         if formatted_entry is not None and formatted_entry.identity == identity:
             _TRANSCRIPT_FORMAT_CACHE.move_to_end(format_key)
@@ -1715,6 +1717,7 @@ def _transcript_rows(
                     io.StringIO(raw),
                     source.provider,
                     claude_native=source.provider == "claude",
+                    width=format_width,
                 )
             )
             if len(formatted) <= _TRANSCRIPT_FORMAT_CACHE_MAX_CHARS:
@@ -1773,10 +1776,12 @@ def _transcript_rows_before_screen(
 
     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.
+    text in the transcript tail through distinctive anchor rows: the largest
+    group of anchors that agree on where the screen starts wins, so screen
+    regions the transcript renders differently (such as a diff) cannot veto
+    the match. A lone anchor must be long and unopposed. From the earliest agreeing anchor
+    the cut walks back over screen rows that also precede it in the
+    transcript; without a credible match every transcript row is kept.
     """
     total = len(transcript_rows)
     window = max(
@@ -1791,26 +1796,42 @@ def _transcript_rows_before_screen(
         parts.append(text)
         offset += len(text)
     haystack = "".join(parts)
+    screen_texts = [_overlap_text(row) for row in screen_rows]
     screen_offset = 0
-    starts: list[tuple[int, int]] = []
-    for row in screen_rows:
-        text = _overlap_text(row)
+    # (screen row, transcript position, anchor length, implied screen start)
+    anchors: list[tuple[int, int, int, int]] = []
+    for index, text in enumerate(screen_texts):
         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
+            position = haystack.index(text)
+            anchors.append(
+                (index, position, len(text), position - screen_offset))
         screen_offset += len(text)
-    if not starts:
+    if not anchors:
         return total
-    if len(starts) == 1:
-        if starts[0][1] < _OVERLAP_SINGLE_ANCHOR_CHARS:
-            return total
-    else:
+
+    def agreeing(anchor: tuple[int, int, int, int]) -> list:
         # 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])
+        tolerance = 16 + abs(anchor[3]) // 20
+        return [
+            other for other in anchors
+            if abs(other[3] - anchor[3]) <= tolerance
+        ]
+
+    group = max(
+        (agreeing(anchor) for anchor in anchors),
+        key=lambda members: (len(members), max(m[3] for m in members)),
+    )
+    if len(group) == 1 and (
+        len(anchors) > 1 or group[0][2] < _OVERLAP_SINGLE_ANCHOR_CHARS
+    ):
+        return total
+    index, start, _length, _implied = min(group)
+    for text in reversed(screen_texts[:index]):
+        if not text:
+            continue
+        if start < len(text) or haystack[start - len(text):start] != text:
+            break
+        start -= len(text)
     # 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)

{railmux-0.4.2.dev4 → railmux-0.4.2.dev6}/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.dev4 → railmux-0.4.2.dev6}/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.dev4 → railmux-0.4.2.dev6}/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: