railmux 0.4.0.dev6__tar.gz → 0.4.0.dev8__tar.gz

{railmux-0.4.0.dev6/src/railmux.egg-info → railmux-0.4.0.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev6
+Version: 0.4.0.dev8
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -374,7 +374,9 @@ messages, tool calls, and abbreviated tool output are colour-coded, while
 internal context and encrypted reasoning are hidden. Codex rewind lineages and
 Claude Code `parentUuid` branches are projected onto the provider's current
 conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden.
+the abandoned suffix is hidden. When Railmux observes a running Codex session
+advance to its rewind child, it also removes the abandoned terminal screen and
+tmux scrollback before Codex redraws the live pane.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/README.md

@@ -331,7 +331,9 @@ messages, tool calls, and abbreviated tool output are colour-coded, while
 internal context and encrypted reasoning are hidden. Codex rewind lineages and
 Claude Code `parentUuid` branches are projected onto the provider's current
 conversation: the retained prefix and replacement suffix remain visible, while
-the abandoned suffix is hidden.
+the abandoned suffix is hidden. When Railmux observes a running Codex session
+advance to its rewind child, it also removes the abandoned terminal screen and
+tmux scrollback before Codex redraws the live pane.
 
 Preview opens at the latest activity in `less`; large sessions are limited to
 their latest 2,000 saved records. Press `/` to search, `n`/`N` to move between

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

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

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/fast_display_client.py

@@ -1074,7 +1074,7 @@ class TerminalSurface:
         self,
         requested: TerminalMode,
     ) -> TerminalMode:
-        """Mirror only input-affecting modes explicitly carried by protocol v14."""
+        """Mirror only input-affecting modes explicitly carried by protocol v15."""
         disabled = self.terminal_modes & ~requested
         enabled = requested & ~self.terminal_modes
         controls: list[bytes] = []
@@ -2013,7 +2013,7 @@ def _finish_remote_attach(
         raise ProbeError("remote display helper failed before attaching")
 
     _stop_unstarted_remote(process)
-    # A current v14 helper holds the mutex only while registering its exact tmux
+    # A current v15 helper holds the mutex only while registering its exact tmux
     # child. Give that ordinary race one fresh SSH process before presenting
     # the explicit legacy-lock takeover choice.
     time.sleep(_REMOTE_ATTACH_RETRY_DELAY)

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/fast_display_history.py

@@ -207,7 +207,11 @@ class LocalHistoryView:
         restore_live = False
         for pane_id, viewport in tuple(self.viewports.items()):
             route = routes.get(pane_id)
-            if route is None or not self._same_geometry(viewport.snapshot, route):
+            if (
+                route is None
+                or not self._same_geometry(viewport.snapshot, route)
+                or not self._history_source_matches(viewport.snapshot, route)
+            ):
                 self.cancel_pane(pane_id)
                 restore_live = True
         return HistoryAction(restore_live=restore_live)
@@ -217,10 +221,11 @@ class LocalHistoryView:
         left: HistorySnapshot,
         right: HistorySnapshot,
     ) -> bool:
-        """Do not combine native, transcript, and undecided history."""
+        """Do not combine different providers or terminal generations."""
         return (
             left.transcript_backed == right.transcript_backed
             and left.history_choice_required == right.history_choice_required
+            and left.generation == right.generation
         )
 
     @staticmethod
@@ -813,7 +818,11 @@ class LocalHistoryView:
             ),
             None,
         )
-        if route is None or not self._same_geometry(route, snapshot):
+        if (
+            route is None
+            or not self._same_geometry(route, snapshot)
+            or not self._history_source_matches(route, snapshot)
+        ):
             return HistoryAction()
         viewport = self.viewports.get(pending.pane_id)
         if viewport is None:

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/fast_display_protocol.py

@@ -1,4 +1,4 @@
-"""Private v14 framing for the coalesced full-window SSH display."""
+"""Private v15 framing for the coalesced full-window SSH display."""
 
 from __future__ import annotations
 
@@ -8,9 +8,9 @@ from dataclasses import dataclass
 from enum import IntEnum, IntFlag
 
 
-DISPLAY_MAGIC = b"RMUXD14\x00"
-INPUT_MAGIC = b"RMUXK14\x00"
-PROTOCOL_VERSION = 14
+DISPLAY_MAGIC = b"RMUXD15\x00"
+INPUT_MAGIC = b"RMUXK15\x00"
+PROTOCOL_VERSION = 15
 REMOTE_CONFIG_PROTOCOL = 1
 LENGTH_BYTES = 4
 REMOTE_HELLO_PREFIX = b"RAILMUX-REMOTE/1 "
@@ -28,10 +28,10 @@ MAX_HISTORY_PANES = 8
 MAX_CLIPBOARD_BYTES = 64 * 1024
 MAX_PATH_BYTES = 4096
 _UPDATE_METADATA = struct.Struct(">BIHHHHBHI")
-_HISTORY_METADATA = struct.Struct(">IIHHHHBI")
+_HISTORY_METADATA = struct.Struct(">IIHHHHBQI")
 _HISTORY_REQUEST = struct.Struct(">IHHH")
 _HISTORY_BATCH_METADATA = struct.Struct(">II")
-_HISTORY_PANE_METADATA = struct.Struct(">IHHHHB")
+_HISTORY_PANE_METADATA = struct.Struct(">IHHHHBQ")
 _PREFETCH_HISTORY_REQUEST = struct.Struct(">IH")
 _PATH_REQUEST = struct.Struct(">IIH")
 _PATH_RESULT = struct.Struct(">IBBH")
@@ -143,6 +143,7 @@ class HistorySnapshot:
     more_available: bool = False
     transcript_available: bool = False
     history_choice_required: bool = False
+    generation: int = 0
 
 
 @dataclass(frozen=True)
@@ -302,6 +303,7 @@ def encode_history_snapshot(snapshot: HistorySnapshot) -> bytes:
             snapshot.more_available,
             snapshot.transcript_available,
             snapshot.history_choice_required,
+            snapshot.generation,
         )):
             raise ValueError("a rejected history response must be empty")
         pane_number = 0
@@ -317,6 +319,8 @@ def encode_history_snapshot(snapshot: HistorySnapshot) -> bytes:
             raise ValueError("invalid history position")
         if len(snapshot.lines) < snapshot.height:
             raise ValueError("history snapshot is shorter than its viewport")
+        if not 0 <= snapshot.generation <= 0xFFFFFFFFFFFFFFFF:
+            raise ValueError("invalid history generation")
     raw_lines = _pack_history_lines(snapshot.lines)
     compressed = zlib.compress(raw_lines, level=3)
     metadata = _HISTORY_METADATA.pack(
@@ -327,6 +331,7 @@ def encode_history_snapshot(snapshot: HistorySnapshot) -> bytes:
         snapshot.width,
         snapshot.height,
         _history_capabilities(snapshot),
+        snapshot.generation,
         len(raw_lines),
     )
     payload = bytes((int(OutputKind.HISTORY),)) + metadata + compressed
@@ -360,6 +365,8 @@ def encode_history_batch(batch: HistoryBatch) -> bytes:
             raise ValueError("invalid history position")
         if len(snapshot.lines) < snapshot.height:
             raise ValueError("history snapshot is shorter than its viewport")
+        if not 0 <= snapshot.generation <= 0xFFFFFFFFFFFFFFFF:
+            raise ValueError("invalid history generation")
         packed_lines = _pack_history_lines(snapshot.lines)
         pane_metadata = _HISTORY_PANE_METADATA.pack(
             pane_number,
@@ -368,6 +375,7 @@ def encode_history_batch(batch: HistoryBatch) -> bytes:
             snapshot.width,
             snapshot.height,
             _history_capabilities(snapshot),
+            snapshot.generation,
         )
         total += len(pane_metadata) + len(packed_lines)
         if total > MAX_SCREEN_BYTES:
@@ -611,6 +619,7 @@ class ServerMessageDecoder:
                         width,
                         height,
                         raw_capabilities,
+                        generation,
                         raw_size,
                     ) = (
                         _HISTORY_METADATA.unpack(body[:_HISTORY_METADATA.size])
@@ -628,6 +637,7 @@ class ServerMessageDecoder:
                             height,
                             lines,
                             raw_capabilities,
+                            generation,
                         )):
                             raise ValueError("invalid rejected history response")
                         pane_id = None
@@ -662,6 +672,7 @@ class ServerMessageDecoder:
                         history_choice_required=bool(
                             raw_capabilities & _HISTORY_CHOICE_REQUIRED
                         ),
+                        generation=generation,
                     ))
                     continue
                 if output_kind is OutputKind.HISTORY_BATCH:
@@ -691,6 +702,7 @@ class ServerMessageDecoder:
                             width,
                             height,
                             raw_capabilities,
+                            generation,
                         ) = _HISTORY_PANE_METADATA.unpack(
                             raw[offset:offset + _HISTORY_PANE_METADATA.size]
                         )
@@ -729,6 +741,7 @@ class ServerMessageDecoder:
                             history_choice_required=bool(
                                 raw_capabilities & _HISTORY_CHOICE_REQUIRED
                             ),
+                            generation=generation,
                         ))
                     if offset != len(raw):
                         raise ValueError("trailing history batch data")
@@ -843,7 +856,7 @@ class ServerMessageDecoder:
 
 
 class ScreenUpdateDecoder:
-    """Compatibility view which ignores v14 control-response messages."""
+    """Compatibility view which ignores v15 control-response messages."""
 
     def __init__(self) -> None:
         self._decoder = ServerMessageDecoder()

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/fast_display_server.py

@@ -45,6 +45,7 @@ from railmux import (
     __version__,
     local_open,
     restart_state,
+    tmux_ctl,
     tmux_health,
     tmux_server,
 )
@@ -403,6 +404,7 @@ class _PaneGeometry:
     transcript_source: str | None = None
     transcript_backed: bool = False
     claude_history_policy: str = "ask"
+    history_generation: int = 0
 
 
 @dataclass(frozen=True)
@@ -421,6 +423,24 @@ _INFERRED_TRANSCRIPT_LIMIT = 8
 _TRANSCRIPT_MAX_BYTES = 32 * 1024 * 1024
 _SESSION_BINDING_OPTION = "@railmux_binding_v1"
 _SWAP_OPTIONS = ("@railmux_swap_primary", "@railmux_swap_secondary")
+_HISTORY_GENERATION_RE = re.compile(
+    r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-"
+    r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+)
+
+
+def _history_generation(marker: str) -> int:
+    """Map one validated provider UUID to a bounded opaque wire epoch."""
+    if not _HISTORY_GENERATION_RE.fullmatch(marker):
+        return 0
+    return int.from_bytes(
+        hashlib.blake2b(
+            marker.lower().encode("ascii"),
+            digest_size=8,
+            person=b"railmux-history",
+        ).digest(),
+        "big",
+    )
 
 
 _ANSI_FG = {
@@ -834,6 +854,7 @@ def _list_agent_panes(
                 "#{history_size} #{alternate_on} #{mouse_any_flag} "
                 f"#{{{tmux_server.HISTORY_SOURCE_OPTION}}} "
                 f"#{{{tmux_server.TRANSCRIPT_SOURCE_OPTION}}} "
+                f"#{{{tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION}}} "
                 f"#{{{TOOL_PANE_OPTION}}}",
             ),
             stderr=subprocess.DEVNULL,
@@ -849,7 +870,7 @@ def _list_agent_panes(
     for raw_row in output.splitlines():
         fields = raw_row.split(" ")
         if (
-            len(fields) != 16
+            len(fields) != 17
             or fields[0] != session_id
             or fields[2] not in ("0", "1")
             or fields[3] not in ("0", "1")
@@ -880,7 +901,7 @@ def _list_agent_panes(
         ):
             return ()
         seen.add(pane_id)
-        if is_tool_pane_marker(fields[15], outer_session_id=session_id):
+        if is_tool_pane_marker(fields[16], outer_session_id=session_id):
             continue
         history_server = None
         history_pane_id = None
@@ -931,6 +952,7 @@ def _list_agent_panes(
                     transcript_source=transcript_marker,
                     transcript_backed=transcript_backed,
                     claude_history_policy=claude_history_policy,
+                    history_generation=_history_generation(fields[15]),
                 ),
             )
         )
@@ -1376,6 +1398,7 @@ def _capture_pane_history(
                 else pane.history_size + pane.height > len(lines)
             )
         ),
+        generation=pane.history_generation,
     )
 
 
@@ -1916,7 +1939,7 @@ def render_rows(screen: object) -> tuple[bytes, ...]:
 
 
 def terminal_modes_for_screen(screen: object) -> TerminalMode:
-    """Project pyte's private-mode set onto the bounded v14 wire allowlist."""
+    """Project pyte's private-mode set onto the bounded v15 wire allowlist."""
     terminal_modes = TerminalMode.NONE
     if 2004 << 5 in screen.mode:
         terminal_modes |= TerminalMode.BRACKETED_PASTE

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/tmux_ctl.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import os
 import re
+import signal
 import shlex
 import shutil
 import subprocess
@@ -302,6 +303,12 @@ _ROLLOUT_UUID_RE = re.compile(
 )
 
 
+def rollout_uuid_from_path(path: Path) -> str | None:
+    """Return the filename UUID for a canonical Codex rollout path."""
+    match = _ROLLOUT_UUID_RE.search(path.name)
+    return match.group(1) if match is not None else None
+
+
 def pane_pid_for_session(session_name: str) -> int | None:
     """Return the first pane's PID for *session_name*, or None.
 
@@ -1818,6 +1825,7 @@ _PREFIX_TARGET_MARKER = "railmux-target-toggle-v1"
 RAILMUX_CONTROLLER_OPTION = "@railmux_controller_pane"
 RAILMUX_TARGET_OPTION = "@railmux_target_pane"
 RAILMUX_HISTORY_PREVIEW_OPTION = "@railmux_history_preview_v1"
+RAILMUX_HISTORY_GENERATION_OPTION = "@railmux_history_generation_v1"
 # tmux names function keys only through F12. Private controller routes use
 # canonical xterm sequences in literal mode, so they cannot be confused with
 # user input forwarded to an agent pane.
@@ -3347,6 +3355,47 @@ def exact_pane_alive(identity: PaneIdentity) -> bool:
     )
 
 
+def reset_pane_history(identity: PaneIdentity) -> bool:
+    """Reset visible bytes and scrollback for the exact observed live pane.
+
+    Revalidate the immutable session, pane process, and window before issuing
+    one tmux command queue that resets the terminal model and clears history.
+    Then send the pane's foreground process group an ordinary same-size
+    ``SIGWINCH`` so its TUI repaints and reasserts terminal modes without a
+    geometry change or injected keyboard input.
+    """
+    current = pane_identity(identity.pane_id)
+    if (current is None or current.dead
+            or current.pane_pid != identity.pane_pid
+            or current.session_id != identity.session_id
+            or current.window_id != identity.window_id):
+        return False
+    try:
+        subprocess.check_call(
+            [
+                "tmux", "send-keys", "-R", "-t", identity.pane_id,
+                ";", "clear-history", "-t", identity.pane_id,
+            ],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        )
+    except (OSError, subprocess.CalledProcessError):
+        return False
+
+    current = pane_identity(identity.pane_id)
+    if (current is None or current.dead
+            or current.pane_pid != identity.pane_pid
+            or current.session_id != identity.session_id
+            or current.window_id != identity.window_id):
+        return True
+    try:
+        os.killpg(os.getpgid(current.pane_pid), signal.SIGWINCH)
+    except (OSError, ValueError):
+        # The presentation cache is already clean. A provider that exited or
+        # cannot be signalled will repaint on its next ordinary terminal write.
+        pass
+    return True
+
+
 def kill_session_identity(identity: PaneIdentity) -> bool:
     """Kill an exact immutable tmux session, never a reused session name."""
     current = pane_identity(identity.pane_id)

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/ui/app.py

@@ -365,6 +365,12 @@ class _Running:
     legacy_server: tmux_server.TmuxServerTarget | None = None
     legacy_session_id: str | None = None
     provider_session_id: str | None = None
+    # Last canonical Codex rollout observed for this live pane.  Rewind creates
+    # a child rollout while leaving tmux's byte scrollback intact; tracking the
+    # 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
+    codex_history_generation_stamped: bool = False
 
     @property
     def is_placeholder(self) -> bool:
@@ -8530,6 +8536,9 @@ class App:
                 meta = self._session_cache.get(
                     r.project, r.logical_session_id or r.key)
             if meta is not None:
+                if session_type == "codex":
+                    self._sync_codex_rewind_scrollback(
+                        r, meta, server, codex_rollout_probes)
                 if meta.title:
                     r.label = f"{meta.project.display_name}/{meta.display_title}"
                 r.status = self._effective_status(
@@ -8548,6 +8557,86 @@ class App:
         self._maybe_resort_running()
         self._render_running_pane()
 
+    def _sync_codex_rewind_scrollback(
+        self,
+        running: _Running,
+        meta: SessionMeta,
+        server: tmux_ctl.ServerSnapshot | None,
+        codex_rollout_probes: dict[str, set[str] | None] | None,
+    ) -> None:
+        """Drop stale tmux bytes after an exact live Codex rewind transition.
+
+        The provider rollout is the history authority, but Codex keeps using
+        the same terminal pane after a rewind.  Its abandoned suffix can
+        therefore survive in tmux scrollback even though the canonical JSONL
+        is already correct.  Baseline the first observed rollout, then clear
+        only when the next canonical rollout names that baseline as its parent.
+        On procfs systems the new rollout must also be open in this exact pane's
+        process tree; an unavailable probe degrades to the provider lineage
+        link, while a negative probe waits for a later refresh.
+        """
+        current_id = meta.session_id
+        previous_id = running.codex_canonical_session_id
+        if previous_id is None:
+            running.codex_canonical_session_id = current_id
+            self._stamp_codex_history_generation(running, current_id)
+            return
+        if current_id == previous_id:
+            if not running.codex_history_generation_stamped:
+                self._stamp_codex_history_generation(running, current_id)
+            return
+        if (running.is_legacy or meta.forked_from_id != previous_id
+                or current_id not in self._codex_lineage_ids(previous_id)):
+            return
+
+        rollout_id = tmux_ctl.rollout_uuid_from_path(meta.jsonl_path)
+        if rollout_id != current_id:
+            return
+        probes = codex_rollout_probes if codex_rollout_probes is not None else {}
+        if running.tmux_name in probes:
+            open_ids = probes[running.tmux_name]
+        else:
+            open_ids = self._codex_rollout_ids(running, server)
+            probes[running.tmux_name] = open_ids
+        if open_ids is not None and current_id not in open_ids:
+            return
+
+        identity = self._codex_real_pane_identity(running)
+        if identity is None or not tmux_ctl.reset_pane_history(identity):
+            return
+        running.codex_canonical_session_id = current_id
+        running.codex_history_generation_stamped = tmux_ctl.set_pane_user_option(
+            identity.pane_id,
+            tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION,
+            current_id,
+        )
+
+    def _codex_real_pane_identity(
+        self, running: _Running,
+    ) -> tmux_ctl.PaneIdentity | None:
+        """Resolve a Codex pane across its detached home or swap location."""
+        real_pane = self._display_transport().displayed_real_pane(
+            running.tmux_name)
+        if real_pane is not None:
+            return tmux_ctl.pane_identity(real_pane)
+        topology = tmux_ctl.session_topology(running.tmux_name)
+        return topology.single_live_pane if topology is not None else None
+
+    def _stamp_codex_history_generation(
+        self, running: _Running, session_id: str,
+    ) -> None:
+        """Publish a content-free epoch for full-window SSH history caches."""
+        if running.is_legacy:
+            return
+        identity = self._codex_real_pane_identity(running)
+        if identity is None:
+            return
+        running.codex_history_generation_stamped = tmux_ctl.set_pane_user_option(
+            identity.pane_id,
+            tmux_ctl.RAILMUX_HISTORY_GENERATION_OPTION,
+            session_id,
+        )
+
     def _maybe_resort_running(self) -> None:
         """Re-order the Running registry by recency, at most once per minute.
 

{railmux-0.4.0.dev6 → railmux-0.4.0.dev8}/src/railmux/windows_bootstrap.py

@@ -26,7 +26,7 @@ def _print_help() -> None:
         "       railmux ssh HOST [OPTIONS]\n"
         "       railmux config [--remote HOST] [OPTIONS]\n"
         "       railmux doctor [--remote HOST] [OPTIONS]\n"
-        "       railmux runtime {status,install} [--yes]\n\n"
+        "       railmux runtime {status,install} [--yes] [--verbose]\n\n"
         "Windows preview: Railmux runs in a private managed MSYS2/tmux "
         "runtime while Codex and Claude Code remain Windows-native and use "
         "the existing Windows user session directories."
@@ -55,8 +55,11 @@ def _runtime_status(
 def _confirm_install(*, input_fn: Callable[[str], str] = input) -> bool:
     try:
         answer = input_fn(
-            "Install the private MSYS2/tmux runtime now? "
-            "This downloads about 50 MB and uses about 300 MB [y/N] "
+            "Install the private MSYS2/tmux runtime now? On Windows, Railmux "
+            "depends on a complete private MSYS2 compatibility wrapper, "
+            "including tmux and Python. This downloads a 50 MB base plus "
+            "required updates and packages, "
+            "and uses about 700 MB or more of private disk space [y/N] "
         )
     except (EOFError, KeyboardInterrupt):
         print()
@@ -68,13 +71,18 @@ def _install(
     *,
     environ: Mapping[str, str],
     assume_yes: bool,
+    verbose: bool = False,
     input_fn: Callable[[str], str] = input,
 ) -> Msys2Runtime | None:
     if not assume_yes and not _confirm_install(input_fn=input_fn):
         print("MSYS2 runtime installation cancelled.", file=sys.stderr)
         return None
     try:
-        runtime = install_managed_runtime(version=__version__, environ=environ)
+        runtime = install_managed_runtime(
+            version=__version__,
+            environ=environ,
+            verbose=verbose,
+        )
     except RuntimeInstallError as exc:
         print(f"error: {exc}", file=sys.stderr)
         return None
@@ -135,12 +143,24 @@ def main(
     if arguments[:2] == ["runtime", "status"] and len(arguments) == 2:
         return _runtime_status(runtime, environ=environ)
     if arguments and arguments[0] == "runtime":
-        if arguments[1:] not in (["install"], ["install", "--yes"]):
-            print("error: usage: railmux runtime {status,install} [--yes]", file=sys.stderr)
+        install_arguments = arguments[1:]
+        install_flags = install_arguments[1:] if install_arguments[:1] == ["install"] else []
+        if (
+            not install_arguments
+            or install_arguments[0] != "install"
+            or len(install_flags) != len(set(install_flags))
+            or any(flag not in {"--yes", "--verbose"} for flag in install_flags)
+        ):
+            print(
+                "error: usage: railmux runtime {status,install} "
+                "[--yes] [--verbose]",
+                file=sys.stderr,
+            )
             return 2
         runtime = runtime or _install(
             environ=environ,
-            assume_yes=arguments[-1:] == ["--yes"],
+            assume_yes="--yes" in install_flags,
+            verbose="--verbose" in install_flags,
             input_fn=input_fn,
         )
         return 0 if runtime is not None else 2
@@ -162,7 +182,12 @@ def main(
                 file=sys.stderr,
             )
             return 2
-        runtime = _install(environ=environ, assume_yes=False, input_fn=input_fn)
+        runtime = _install(
+            environ=environ,
+            assume_yes=False,
+            verbose=False,
+            input_fn=input_fn,
+        )
         if runtime is None:
             return 2