railmux 0.3.4.dev1__tar.gz → 0.3.5.dev1__tar.gz

{railmux-0.3.4.dev1/src/railmux.egg-info → railmux-0.3.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.4.dev1
+Version: 0.3.5.dev1
 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.3.5.dev1/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.5.dev1"

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1}/src/railmux/fast_display_client.py

@@ -202,6 +202,14 @@ def full_repaint(screen: AppliedScreen) -> AppliedScreen:
     )
 
 
+def selection_changed_rows(
+    before: tuple[SelectionSegment, ...],
+    after: tuple[SelectionSegment, ...],
+) -> set[int]:
+    """Rows that must be restored when one local highlight changes."""
+    return {row for row, _column, _text in (*before, *after)}
+
+
 def focus_in_frame_for_screen(screen: AppliedScreen | None) -> bytes | None:
     """Reassert focus only while the remote application requested events."""
     if screen is None or not screen.terminal_modes & TerminalMode.FOCUS_EVENTS:
@@ -637,6 +645,10 @@ class TerminalSurface:
         self.mouse_active = False
         self.mouse_suspended = False
         self.cursor_hidden = False
+        # Track the physical emulator cursor separately from the remote model.
+        # Re-sending DECSET/DECRST 25 on every 20 fps patch restarts the cursor
+        # animation in Windows Terminal and presents as a rapid flash.
+        self._painted_cursor_visible: bool | None = None
         self.terminal_modes = TerminalMode.NONE
         self.physical_size: os.terminal_size | None = None
         self._last_screen: AppliedScreen | None = None
@@ -694,6 +706,7 @@ class TerminalSurface:
         if interactive and not self.cursor_hidden:
             controls.append(b"\033[?25l")
             self.cursor_hidden = True
+            self._painted_cursor_visible = False
         if (
             interactive
             and self.mouse
@@ -793,6 +806,7 @@ class TerminalSurface:
         self.mouse_active = False
         self.mouse_suspended = False
         self.cursor_hidden = False
+        self._painted_cursor_visible = True
         self.interaction_active = True
 
     def show_local_status(
@@ -813,7 +827,8 @@ class TerminalSurface:
         self._local_status_level = level
         self._local_status_interruptible = interruptible
         self._local_status_expires_at = expires_at
-        rendered = [self._render_local_status()]
+        restore_cursor = self._last_screen is not None
+        rendered = [self._render_local_status(hide_cursor=not restore_cursor)]
         if self._last_screen is not None:
             projection_top, visible_height = self._projection(
                 self._last_screen.height
@@ -828,7 +843,7 @@ class TerminalSurface:
         self.stream.write(b"".join(rendered))
         self.stream.flush()
 
-    def _render_local_status(self) -> bytes:
+    def _render_local_status(self, *, hide_cursor: bool = True) -> bytes:
         """Render and locate the current local status-right replacement."""
         if self._local_status_text is None:
             self._local_status_bounds = None
@@ -841,10 +856,14 @@ class TerminalSurface:
             if self.physical_size is not None:
                 safe = safe[: self.physical_size.columns]
             self._local_status_bounds = (max(1, height), 1, max(1, len(safe)))
-            return (
+            rendered = (
                 f"\033[?7l\033[0m\033[{max(1, height)};1H\033[2K{safe}"
-                "\033[0m\033[?7h\033[?25l"
+                "\033[0m\033[?7h"
             ).encode("utf-8")
+            if hide_cursor:
+                rendered += b"\033[?25l"
+                self._painted_cursor_visible = False
+            return rendered
         width = screen.width
         if self.physical_size is not None:
             width = min(width, self.physical_size.columns)
@@ -862,8 +881,8 @@ class TerminalSurface:
             "warning": b"\033[1;38;5;220m",
             "error": b"\033[1;38;5;196m",
         }.get(level, b"\033[38;5;231m")
-        return b"".join(
-            (
+        rendered = b"".join(
+            [
                 b"\033[?7l\033[0m",
                 f"\033[{max(1, height)};{reserved + 1}H".encode(),
                 background,
@@ -871,9 +890,13 @@ class TerminalSurface:
                 b"\033[K",
                 f"\033[{max(1, height)};{column}H".encode(),
                 safe.encode("utf-8"),
-                b"\033[0m\033[?25l",
-            )
+                b"\033[0m",
+            ]
         )
+        if hide_cursor:
+            rendered += b"\033[?25l"
+            self._painted_cursor_visible = False
+        return rendered
 
     def clear_local_status(self) -> None:
         """Forget local feedback before restoring the authoritative screen."""
@@ -991,6 +1014,7 @@ class TerminalSurface:
             )
         self.stream.write(b"".join(rendered))
         self.stream.flush()
+        self._painted_cursor_visible = False
 
     def claude_history_prompt_choice(
         self,
@@ -1052,6 +1076,7 @@ class TerminalSurface:
             )
         self.stream.write(b"".join(rendered))
         self.stream.flush()
+        self._painted_cursor_visible = False
 
     def path_open_prompt_choice(
         self,
@@ -1108,6 +1133,7 @@ class TerminalSurface:
         # scroll the alternate screen.
         self.stream.write(b"\033[0m\033[?7h\033[?25l")
         self.stream.flush()
+        self._painted_cursor_visible = False
 
     @staticmethod
     def _cursor_is_covered(
@@ -1171,38 +1197,37 @@ class TerminalSurface:
                 )
             )
 
-    @classmethod
     def _append_cursor(
-        cls,
+        self,
         rendered: list[bytes],
         screen: AppliedScreen,
         overlays: tuple[tuple[HistorySnapshot, tuple[bytes, ...]], ...],
         *,
         projection_top: int = 0,
         visible_height: int | None = None,
+        force_visibility: bool = False,
     ) -> None:
         cursor_in_projection = (
             visible_height is None
             or projection_top <= screen.cursor_y < projection_top + visible_height
         )
-        rendered.extend(
-            (
-                b"\033[0m\033[?7h",
-                (
-                    f"\033[{screen.cursor_y - projection_top + 1};"
-                    f"{screen.cursor_x + 1}H"
-                ).encode()
-                if cursor_in_projection
-                else b"\033[1;1H",
-                (
-                    b"\033[?25h"
-                    if screen.cursor_visible
-                    and cursor_in_projection
-                    and not cls._cursor_is_covered(screen, overlays)
-                    else b"\033[?25l"
-                ),
-            )
+        visible = bool(
+            screen.cursor_visible
+            and cursor_in_projection
+            and not self._cursor_is_covered(screen, overlays)
         )
+        rendered.extend((
+            b"\033[0m\033[?7h",
+            (
+                f"\033[{screen.cursor_y - projection_top + 1};"
+                f"{screen.cursor_x + 1}H"
+            ).encode()
+            if cursor_in_projection
+            else b"\033[1;1H",
+        ))
+        if force_visibility or self._painted_cursor_visible is not visible:
+            rendered.append(b"\033[?25h" if visible else b"\033[?25l")
+            self._painted_cursor_visible = visible
 
     def paint(
         self,
@@ -1250,7 +1275,7 @@ class TerminalSurface:
             visible_height=visible_height,
         )
         if self._local_status_text is not None:
-            rendered.append(self._render_local_status())
+            rendered.append(self._render_local_status(hide_cursor=False))
         # Status and selection painting move and may temporarily hide the
         # terminal cursor.  Restoring the authoritative cursor must therefore
         # be the final operation in every complete paint.
@@ -1289,7 +1314,61 @@ class TerminalSurface:
             visible_height=visible_height,
         )
         if self._local_status_text is not None:
-            rendered.append(self._render_local_status())
+            rendered.append(self._render_local_status(hide_cursor=False))
+        self._append_cursor(
+            rendered,
+            screen,
+            overlays,
+            projection_top=projection_top,
+            visible_height=visible_height,
+        )
+        self.stream.write(b"".join(rendered))
+        self.stream.flush()
+
+    def paint_changed_rows(
+        self,
+        screen: AppliedScreen,
+        overlays: tuple[tuple[HistorySnapshot, tuple[bytes, ...]], ...],
+        selection: tuple[SelectionSegment, ...],
+        changed_rows: set[int] | frozenset[int],
+    ) -> None:
+        """Restore and repaint only rows touched by a local highlight.
+
+        Hover, drag selection, and click flash are local overlays. Clearing the
+        whole alternate screen for them is both unnecessary and visibly flashes
+        in Windows Terminal. Restore each affected row from the authoritative
+        live frame, then layer frozen history and the new highlight back on it.
+        """
+        self.start()
+        self._last_screen = screen
+        self._last_overlays = overlays
+        projection_top, visible_height = self._projection(screen.height)
+        rows = frozenset(
+            row for row in changed_rows
+            if projection_top <= row < projection_top + visible_height
+        )
+        rendered: list[bytes] = [b"\033[?7l"]
+        for row in sorted(rows):
+            rendered.extend((
+                f"\033[{row - projection_top + 1};1H".encode(),
+                b"\033[2K",
+                screen.rows[row],
+            ))
+        self._append_overlay_rows(
+            rendered,
+            overlays,
+            projection_top=projection_top,
+            visible_height=visible_height,
+            changed_rows=rows,
+        )
+        self._append_selection_segments(
+            rendered,
+            selection,
+            projection_top=projection_top,
+            visible_height=visible_height,
+        )
+        if self._local_status_text is not None and screen.height - 1 in rows:
+            rendered.append(self._render_local_status(hide_cursor=False))
         self._append_cursor(
             rendered,
             screen,
@@ -1312,6 +1391,7 @@ class TerminalSurface:
             self._last_overlays,
             projection_top=projection_top,
             visible_height=visible_height,
+            force_visibility=True,
         )
         self.stream.write(b"".join(rendered))
         self.stream.flush()
@@ -1333,6 +1413,7 @@ class TerminalSurface:
         self.mouse_active = False
         self.mouse_suspended = False
         self.cursor_hidden = False
+        self._painted_cursor_visible = None
         self.clear_local_status()
         self._last_screen = None
         self._reconnect_status_screen = None
@@ -2627,11 +2708,14 @@ def run(args: argparse.Namespace) -> int:
                     focused_pane_id=focused_pane_id,
                 )
             )
+            before = selection.segments()
             if selection.hover(hover_event, source) and latest_screen is not None:
-                surface.paint(
-                    full_repaint(latest_screen),
+                after = selection.segments()
+                surface.paint_changed_rows(
+                    latest_screen,
                     history.overlays(),
-                    selection.segments(),
+                    after,
+                    selection_changed_rows(before, after),
                 )
             return
         if path_open_prompt is not None:
@@ -2751,6 +2835,7 @@ def run(args: argparse.Namespace) -> int:
             # one persistent choice is still being confirmed.
             return
         if isinstance(part, SgrMouseEvent):
+            selection_before = selection.segments()
             displayed_height = (
                 latest_screen.height
                 if latest_screen is not None
@@ -2807,10 +2892,12 @@ def run(args: argparse.Namespace) -> int:
             if selection.capturing or not selection.active:
                 selection_clear_at = None
             if selection_action.repaint and latest_screen is not None:
-                surface.paint(
-                    full_repaint(latest_screen),
+                selection_after = selection.segments()
+                surface.paint_changed_rows(
+                    latest_screen,
                     history.overlays(),
-                    selection.segments(),
+                    selection_after,
+                    selection_changed_rows(selection_before, selection_after),
                 )
             for replay_event in selection_action.replay_events:
                 if not claim_batched_wheel(replay_event, handled_wheels):
@@ -2835,6 +2922,7 @@ def run(args: argparse.Namespace) -> int:
                 selection_clear_at = time.monotonic() + _SELECTION_HIGHLIGHT_SECONDS
             if selection_action.open_target is not None:
                 target = selection_action.open_target
+                flash_before = selection.segments()
                 if (
                     selection.flash(
                         target,
@@ -2843,10 +2931,12 @@ def run(args: argparse.Namespace) -> int:
                     )
                     and latest_screen is not None
                 ):
-                    surface.paint(
-                        full_repaint(latest_screen),
+                    flash_after = selection.segments()
+                    surface.paint_changed_rows(
+                        latest_screen,
                         history.overlays(),
-                        selection.segments(),
+                        flash_after,
+                        selection_changed_rows(flash_before, flash_after),
                     )
                 if target.kind == "url":
                     show_open_result(local_open.open_url(target.value))
@@ -3301,6 +3391,7 @@ def run(args: argparse.Namespace) -> int:
                 restore_local_status = surface.expire_local_status(now) or (
                     history_info_until is not None and now >= history_info_until
                 )
+                timed_selection_before = selection.segments()
                 clear_selection = (
                     selection_clear_at is not None and now >= selection_clear_at
                 )
@@ -3310,13 +3401,24 @@ def run(args: argparse.Namespace) -> int:
                         selection.cancel()
                     if restore_local_status:
                         surface.clear_local_status()
-                    if latest_screen is not None:
+                    timed_selection_after = selection.segments()
+                    if latest_screen is not None and restore_local_status:
                         surface.paint(
                             full_repaint(latest_screen),
                             history.overlays(),
-                            selection.segments(),
+                            timed_selection_after,
                         )
                         redraw_local_prompt()
+                    elif latest_screen is not None:
+                        surface.paint_changed_rows(
+                            latest_screen,
+                            history.overlays(),
+                            timed_selection_after,
+                            selection_changed_rows(
+                                timed_selection_before,
+                                timed_selection_after,
+                            ),
+                        )
                     if restore_local_status:
                         history_info_until = None
                     if clear_selection:

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1}/src/railmux/tmux_server.py

@@ -604,8 +604,22 @@ def launcher_argv(
     launch_prefix: Sequence[str],
     forwarded_args: Sequence[str],
 ) -> list[str]:
-    """Build the only supported entry into the dedicated Railmux workspace."""
+    """Build the only supported entry into the dedicated Railmux workspace.
+
+    The dedicated server's inherited status line stays off.  ``App.run`` turns
+    it on at session scope only after the managed UI is ready, so tmux cannot
+    expose its stock status line underneath the startup/restoration surface.
+    Keeping the baseline global also makes early failures and soft-quit shells
+    clean without requiring a child process to repair partially-started UI.
+    """
     return tmux_argv(
+        "start-server",
+        ";",
+        "set-option",
+        "-g",
+        "status",
+        "off",
+        ";",
         "new-session",
         "-A",
         "-s",

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1}/src/railmux/ui/app.py

@@ -10598,10 +10598,9 @@ class App:
         # - set-clipboard on: text selection in either pane is copied to the
         #   system clipboard.
         import subprocess as _sp
-        # Wrap the whole setup (not just loop.run) so `finally` reverts our tmux
-        # status-bar overrides even if Screen()/MainLoop() construction raises
-        # after we've mutated the outer session — otherwise the user's bar would
-        # keep railmux's `status on`, style, brand and blanked window-list.
+        # Wrap the whole setup (not just loop.run) so `finally` reverts any tmux
+        # state acquired before the UI loop exits or initialization fails.
+        sess: str | None = None
         try:
             if tmux_ctl.in_tmux():
                 sess = tmux_ctl.current_session_name() or "railmux"
@@ -10628,25 +10627,6 @@ class App:
                         "custom root wheel bindings.",
                         "warn",
                     )
-                # Shared binding ownership below scopes right-click forwarding
-                # to Railmux windows and preserves the user's original command
-                # everywhere else. Left-click keeps tmux's stock
-                # select-pane-and-forward behavior.
-                # The outer tmux status bar is now railmux's only status surface (the
-                # in-pane StatusBar was removed). Apply the static options (window
-                # list blanked, bar forced on, length cap) here; the bar background
-                # + brand are set by _apply_tmux_bar (green now, dark red on error).
-                # All session-scoped + reverted on teardown, so the user's global
-                # tmux config is untouched.
-                for opt, val in self._TMUX_BAR_OPTIONS:
-                    _sp.run(
-                        ["tmux", "set-option", "-t", sess, opt, val],
-                        stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
-                    )
-                self._tmux_status_session = sess
-                self._tmux_status_enabled = True
-                self._apply_tmux_bar(error=False)  # initial green bar
-
             self._railmux_pane_id = tmux_ctl.current_pane_id()
             if (self._railmux_pane_id is not None
                     and tmux_ctl.current_session_name() == "railmux"
@@ -10688,6 +10668,22 @@ class App:
                 self._loop.screen.set_terminal_properties(colors=_TERMINAL_COLORS)
             except Exception:
                 pass
+            if sess is not None:
+                # The dedicated server inherits ``status off`` while the
+                # terminal-native Restoring surface is visible.  Claim and
+                # reveal Railmux's sole status surface only after Screen and
+                # MainLoop are ready; an earlier initialization failure stays
+                # visually clean.  These overrides remain session-scoped and
+                # teardown reverts them to the dedicated server's hidden
+                # baseline.
+                for opt, val in self._TMUX_BAR_OPTIONS:
+                    _sp.run(
+                        ["tmux", "set-option", "-t", sess, opt, val],
+                        stdout=_sp.DEVNULL, stderr=_sp.DEVNULL,
+                    )
+                self._tmux_status_session = sess
+                self._tmux_status_enabled = True
+                self._apply_tmux_bar(error=False)  # initial green bar
             self._check_terminal_size()
             # If a saved agent workspace is valid, establish its final empty
             # tmux boundaries before Urwid emits the first sidebar frame. The

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1/src/railmux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.4.dev1
+Version: 0.3.5.dev1
 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.3.4.dev1 → railmux-0.3.5.dev1}/tests/test_cli.py

@@ -395,7 +395,9 @@ def test_foreign_tmux_launches_dedicated_server_with_clean_environment(
         "expected_session_id": None,
     }
     assert argv == [
-        "tmux", "-L", "railmux", "new-session", "-A", "-s", "railmux",
+        "tmux", "-L", "railmux",
+        "start-server", ";", "set-option", "-g", "status", "off", ";",
+        "new-session", "-A", "-s", "railmux",
         "/bin/railmux", "--inside-tmux", "--project", "/work",
     ]
     assert "TMUX" not in env

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1}/tests/test_fast_full_window.py

@@ -1718,7 +1718,9 @@ def test_terminal_surface_hides_cursor_covered_by_a_frozen_pane():
 
     TerminalSurface(stream).paint(screen, ((covering, (b"a", b"b")),))
 
-    assert stream.getvalue().endswith(b"\033[?25l")
+    rendered = stream.getvalue()
+    assert rendered.endswith(b"\033[1;2H")
+    assert rendered.count(b"\033[?25l") == 1
 
 
 def test_terminal_surface_reasserts_cached_cursor_without_repainting():
@@ -1739,6 +1741,55 @@ def test_terminal_surface_reasserts_cached_cursor_without_repainting():
     surface.reassert_cursor()
 
     assert stream.getvalue() == b"\033[0m\033[?7h\033[2;5H\033[?25h"
+
+
+def test_terminal_surface_local_highlight_repaints_only_changed_rows():
+    screen = ScreenModel().apply(
+        ClientScreenUpdateDecoder().feed(
+            encode_update(_keyframe(width=20, height=4))
+        )[0],
+        os.terminal_size((20, 4)),
+    )
+    assert screen is not None
+    stream = io.BytesIO()
+    surface = TerminalSurface(stream, mouse_hover=False)
+    surface.paint(screen)
+    stream.seek(0)
+    stream.truncate()
+
+    surface.paint_changed_rows(
+        screen,
+        (),
+        ((1, 4, b"https://example"),),
+        {1},
+    )
+
+    rendered = stream.getvalue()
+    assert b"\033[2J" not in rendered
+    assert b"\033[2;1H\033[2Krow-1" in rendered
+    assert b"\033[2;5H\033[0;7mhttps://example" in rendered
+
+
+def test_terminal_surface_stable_cursor_visibility_is_not_reasserted_per_patch():
+    screen = ScreenModel().apply(
+        ClientScreenUpdateDecoder().feed(
+            encode_update(_keyframe(width=12, height=3))
+        )[0],
+        os.terminal_size((12, 3)),
+    )
+    assert screen is not None
+    stream = io.BytesIO()
+    surface = TerminalSurface(stream, mouse_hover=False)
+    surface.paint(screen)
+    stream.seek(0)
+    stream.truncate()
+
+    surface.paint(replace(screen, changed_rows=(1,), clear=False))
+
+    rendered = stream.getvalue()
+    assert b"\033[?25h" not in rendered
+    assert b"\033[?25l" not in rendered
+    assert rendered.endswith(b"\033[1;2H")
     assert b"\033[2J" not in stream.getvalue()
 
 
@@ -1798,7 +1849,8 @@ def test_terminal_surface_clips_projected_patches_overlays_and_cursor():
     assert b"\033[4;1H\033[2Krow-14" in rendered
     assert b"hidden" not in rendered
     assert b"\033[1;4H\033[6Xone" in rendered
-    assert rendered.endswith(b"\033[1;1H\033[?25l")
+    assert rendered.endswith(b"\033[1;1H")
+    assert rendered.count(b"\033[?25l") == 1
 
 
 def test_terminal_surface_maps_projected_mouse_rows_to_logical_screen():
@@ -4869,6 +4921,8 @@ def test_local_status_preserves_painted_status_left_and_background():
     assert b"\033[4;21H" in painted
     assert b"\033[48;2;95;175;0m\033[1;38;5;17m\033[K" in painted
     assert b"Copied 12 chars." in painted
+    assert b"\033[?25h" not in painted
+    assert b"\033[?25l" not in painted
 
 
 def test_reconnect_status_uses_retained_status_right_without_stale_cursor():

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1}/tests/test_soft_quit.py

@@ -2661,7 +2661,7 @@ def test_teardown_reverts_every_bar_option(monkeypatch):
 
 def test_run_defers_saved_agent_focus_and_reverts_bar_if_setup_raises(
         monkeypatch):
-    """Startup hides a saved agent focus before drawing and always tears down."""
+    """A pre-loop failure leaves the startup status hidden and tears down."""
     import railmux.ui.app as app_mod
 
     app = _minimal_app()
@@ -2681,8 +2681,9 @@ def test_run_defers_saved_agent_focus_and_reverts_bar_if_setup_raises(
     monkeypatch.setattr(app_mod.tmux_ctl, "current_pane_id", lambda: "%0")
     monkeypatch.setattr(
         app_mod.tmux_ctl, "use_smallest_window_size", lambda _pane: True)
-    monkeypatch.setattr("subprocess.run", MagicMock())
-    # Screen construction blows up AFTER the status bar has been set up.
+    run = MagicMock()
+    monkeypatch.setattr("subprocess.run", run)
+    # Screen construction blows up before the managed status bar is revealed.
     monkeypatch.setattr("urwid.raw_display.Screen",
                         MagicMock(side_effect=RuntimeError("boom")))
 
@@ -2690,8 +2691,12 @@ def test_run_defers_saved_agent_focus_and_reverts_bar_if_setup_raises(
         app.run()
 
     app._frame.set_window_active.assert_called_once_with(False)
-    assert app._tmux_status_enabled is True  # setup ran (bar was mutated)...
-    teardown.assert_called_once_with()       # ...and teardown reverted it
+    assert app._tmux_status_enabled is False
+    assert not any(
+        call.args[0][-2:] == ["status", "on"]
+        for call in run.call_args_list
+    )
+    teardown.assert_called_once_with()
 
 
 # ── QuitConfirmModal ─────────────────────────────────────────────────────

{railmux-0.3.4.dev1 → railmux-0.3.5.dev1}/tests/test_tmux_server.py

@@ -29,7 +29,9 @@ def test_launcher_argv_preserves_multi_argument_python_module_prefix():
         ["/usr/bin/python3", "-m", "railmux"],
         ["--mode", "codex"],
     ) == [
-        "tmux", "-L", "railmux", "new-session", "-A", "-s", "railmux",
+        "tmux", "-L", "railmux",
+        "start-server", ";", "set-option", "-g", "status", "off", ";",
+        "new-session", "-A", "-s", "railmux",
         "/usr/bin/python3", "-m", "railmux", "--inside-tmux",
         "--mode", "codex",
     ]

railmux-0.3.4.dev1/src/railmux/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.4.dev1"