railmux 0.4.2.dev4__tar.gz → 0.4.2.dev5__tar.gz

{railmux-0.4.2.dev4/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.dev4
+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.dev4 → 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.dev4 → 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.dev4 → 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.dev4 → 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.dev4 → 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.dev4
+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.dev4 → 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

railmux-0.4.2.dev5/tests/test_claude_continuation.py

@@ -0,0 +1,177 @@
+"""Claude ``continued-in`` session files: listing, renames and live re-keying."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from railmux.session_cache import SessionCache
+from railmux.session_index import _scan_session
+from railmux.ui.app import App, _Running
+
+from tests.app_test_harness import (
+    _project,
+    isolate_tmux_identity_stamps as isolate_tmux_identity_stamps,
+)
+
+
+pytestmark = pytest.mark.usefixtures("isolate_tmux_identity_stamps")
+
+OLD = "02b59000-6bb4-4ec5-bdca-24f7a96b0467"
+MID = "47fca075-9cb8-44fb-a314-d57ef2256ad9"
+NEW = "96fd3642-6c17-4c9b-8129-08d3d9db3e8a"
+
+
+def _turn() -> list[dict]:
+    return [
+        {"type": "user", "message": {"role": "user", "content": "hello"}},
+        {"type": "assistant", "message": {
+            "role": "assistant", "id": "m1", "stop_reason": "end_turn",
+            "content": [{"type": "text", "text": "hi"}],
+        }},
+    ]
+
+
+def _continued(successor: str) -> dict:
+    return {
+        "type": "continued-in",
+        "sessionId": "previous",
+        "continuedInSessionId": successor,
+    }
+
+
+def _write(directory: Path, session_id: str, records: list[dict]) -> Path:
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / f"{session_id}.jsonl"
+    path.write_text("".join(json.dumps(record) + "\n" for record in records))
+    return path
+
+
+class _MemoryRenames:
+    def __init__(self, titles: dict[str, str] | None = None) -> None:
+        self.titles = dict(titles or {})
+
+    def get(self, session_id: str) -> str | None:
+        return self.titles.get(session_id)
+
+    def set(self, session_id: str, title: str) -> None:
+        self.titles[session_id] = title
+
+
+def test_scan_records_only_a_final_continued_in(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    final = _write(tmp_path, OLD, _turn() + [_continued(NEW)])
+    resumed = _write(tmp_path, MID, _turn() + [_continued(NEW)] + _turn())
+    invalid = _write(tmp_path, NEW, _turn() + [_continued("../escape")])
+
+    assert _scan_session(project, final).continued_in_id == NEW
+    assert _scan_session(project, resumed).continued_in_id is None
+    assert _scan_session(project, invalid).continued_in_id is None
+
+
+def test_listing_hides_continued_sessions_and_carries_rename(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    _write(tmp_path, OLD, _turn() + [_continued(MID)])
+    _write(tmp_path, MID, _turn() + [_continued(NEW)])
+    _write(tmp_path, NEW, _turn())
+    renames = _MemoryRenames({OLD: "Rubin bringup"})
+    cache = SessionCache(renames)
+
+    sessions = cache.list_sessions(project)
+
+    assert [session.session_id for session in sessions] == [NEW]
+    assert sessions[0].title == "Rubin bringup"
+    assert renames.titles[NEW] == "Rubin bringup"
+    assert cache.continuations == {OLD: MID, MID: NEW}
+
+
+def test_listing_keeps_session_whose_successor_is_missing(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    _write(tmp_path, OLD, _turn() + [_continued(NEW)])
+
+    sessions = SessionCache().list_sessions(project)
+
+    assert [session.session_id for session in sessions] == [OLD]
+
+
+def _app(project, running: dict[str, _Running]) -> App:
+    app = App.__new__(App)
+    app._running = running
+    app._session_cache = SessionCache()
+    app._session_cache.list_sessions(project)
+    app._favorites = MagicMock()
+    app._favorites.get_ids.return_value = {OLD}
+    app._stamp_running = MagicMock(return_value=True)
+    app._ensure_running_session_lease = MagicMock(return_value=True)
+    app._record_session_lease_result = MagicMock()
+    app._set_slot_active_target = MagicMock()
+    return app
+
+
+def test_running_claude_entry_follows_continuation_chain(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    _write(tmp_path, OLD, _turn() + [_continued(MID)])
+    _write(tmp_path, MID, _turn() + [_continued(NEW)])
+    _write(tmp_path, NEW, _turn())
+    running = _Running(
+        key=OLD, tmux_name="cc-new---b14c77-2", label="x", project=project)
+    app = _app(project, {OLD: running})
+    app._agent_workspace().target.agent_tmux_name = running.tmux_name
+
+    app._follow_claude_continuations()
+
+    assert app._running == {NEW: running}
+    assert running.key == NEW and running.tmux_name == "cc-new---b14c77-2"
+    app._stamp_running.assert_called_once_with(running)
+    lease_session = app._ensure_running_session_lease.call_args.args[1]
+    assert lease_session.session_id == NEW
+    app._set_slot_active_target.assert_called_once()
+    assert app._set_slot_active_target.call_args.args[1:] == (
+        NEW, running.tmux_name)
+    app._favorites.set_many.assert_called_once_with({NEW}, True)
+
+
+def test_running_entry_stays_when_successor_is_already_running(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    _write(tmp_path, OLD, _turn() + [_continued(NEW)])
+    _write(tmp_path, NEW, _turn())
+    old = _Running(key=OLD, tmux_name="cc-a", label="a", project=project)
+    new = _Running(key=NEW, tmux_name="cc-b", label="b", project=project)
+    app = _app(project, {OLD: old, NEW: new})
+
+    app._follow_claude_continuations()
+
+    assert app._running == {OLD: old, NEW: new}
+    app._stamp_running.assert_not_called()
+
+
+def _background(records: list[dict]) -> list[dict]:
+    return [{**record, "sessionKind": "bg"} for record in records]
+
+
+def test_background_successor_of_visible_session_stays_listed(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    _write(tmp_path, OLD, _turn() + [_continued(NEW)])
+    _write(tmp_path, NEW, _background(_turn()))
+    _write(tmp_path, MID, _background(_turn()))
+
+    sessions = SessionCache().list_sessions(project)
+
+    assert [session.session_id for session in sessions] == [NEW]
+    assert sessions[0].background
+    assert _scan_session(project, tmp_path / f"{NEW}.jsonl") is None
+
+
+def test_running_entry_follows_background_successor(tmp_path):
+    project = _project(claude_dir=tmp_path)
+    _write(tmp_path, OLD, _turn() + [_continued(NEW)])
+    _write(tmp_path, NEW, _background(_turn()))
+    running = _Running(key=OLD, tmux_name="cc-a", label="a", project=project)
+    app = _app(project, {OLD: running})
+
+    app._follow_claude_continuations()
+
+    assert app._running == {NEW: running}

railmux-0.4.2.dev4/src/railmux/__init__.py

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