klaude-code 1.2.26__py3-none-any.whl → 1.2.28__py3-none-any.whl

klaude_code/ui/modes/repl/completers.py

@@ -204,7 +204,7 @@ class _SkillCompleter(Completer):
             from klaude_code.skill import get_available_skills
 
             return get_available_skills()
-        except Exception:
+        except (ImportError, RuntimeError):
             return []
 
     def is_skill_context(self, document: Document) -> bool:
@@ -398,8 +398,14 @@ class _AtFilesCompleter(Completer):
 
         if not results:
             if self._has_cmd("fd"):
+                # First, get immediate children matching the keyword (depth=0).
+                # fd's traversal order is not depth-first, so --max-results may
+                # truncate shallow matches. We ensure depth=0 items are always included.
+                immediate = self._get_immediate_matches(cwd, key_norm)
                 # Use fd to search anywhere in full path (files and directories), case-insensitive
-                results, truncated = self._run_fd_search(cwd, key_norm, max_results=max_scan_results)
+                fd_results, truncated = self._run_fd_search(cwd, key_norm, max_results=max_scan_results)
+                # Merge: immediate matches first, then fd results (deduped in _filter_and_format)
+                results = immediate + fd_results
             elif self._has_cmd("rg"):
                 # Use rg to search only in current directory
                 rg_cache_ttl = max(self._cache_ttl, 30.0)
@@ -451,10 +457,11 @@ class _AtFilesCompleter(Completer):
         keyword_norm: str,
     ) -> list[str]:
         # Filter to keyword (case-insensitive) and rank by:
-        # 1. Basename hit first, then path hit position, then length
+        # 1. Directory depth (shallower first)
+        # 2. Basename hit first, then path hit position, then length
         # Since both fd and rg now search from current directory, all paths are relative to cwd
         kn = keyword_norm
-        out: list[tuple[str, tuple[int, int, int, int]]] = []
+        out: list[tuple[str, tuple[int, int, int, int, int]]] = []
         for p in paths_from_root:
             pl = p.lower()
             if kn not in pl:
@@ -469,7 +476,9 @@ class _AtFilesCompleter(Completer):
             base = os.path.basename(rel_to_cwd.rstrip("/")).lower()
             base_pos = base.find(kn)
             path_pos = pl.find(kn)
+            depth = rel_to_cwd.rstrip("/").count("/")
             score = (
+                depth,
                 0 if base_pos != -1 else 1,
                 base_pos if base_pos != -1 else 10_000,
                 path_pos,
@@ -497,7 +506,7 @@ class _AtFilesCompleter(Completer):
             try:
                 if (cwd / s).is_dir():
                     uniq[idx] = f"{s}/"
-            except Exception:
+            except OSError:
                 continue
         return uniq
 
@@ -530,7 +539,7 @@ class _AtFilesCompleter(Completer):
             if tag != "search":
                 return root, None
             return root, kw
-        except Exception:
+        except ValueError:
             return None, None
 
     # ---- Utilities ----
@@ -680,10 +689,32 @@ class _AtFilesCompleter(Completer):
                 if p.is_dir() and not rel.endswith("/"):
                     rel += "/"
                 items.append(rel)
-        except Exception:
+        except OSError:
             return []
         return items[: min(self._max_results, 100)]
 
+    def _get_immediate_matches(self, cwd: Path, keyword_norm: str) -> list[str]:
+        """Get immediate children of cwd that match the keyword (case-insensitive).
+
+        This ensures depth=0 matches are always included, even when fd's
+        --max-results truncates before reaching them.
+        """
+        excluded = {".git", ".venv", "node_modules"}
+        items: list[str] = []
+        try:
+            for p in cwd.iterdir():
+                name = p.name
+                if name in excluded:
+                    continue
+                if keyword_norm in name.lower():
+                    rel = name
+                    if p.is_dir():
+                        rel += "/"
+                    items.append(rel)
+        except OSError:
+            return []
+        return items
+
     def _run_cmd(self, cmd: list[str], cwd: Path | None = None, *, timeout_sec: float) -> _CmdResult:
         cmd_str = " ".join(cmd)
         start = time.monotonic()
@@ -691,6 +722,7 @@ class _AtFilesCompleter(Completer):
             p = subprocess.run(
                 cmd,
                 cwd=str(cwd) if cwd else None,
+                stdin=subprocess.DEVNULL,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.DEVNULL,
                 text=True,

klaude_code/ui/modes/repl/event_handler.py

@@ -167,10 +167,9 @@ class ActivityState:
             return activity_text
         if self._composing:
             # Main status text with creative verb
-            text = Text.assemble(
-                ("Composing ", ThemeKey.STATUS_TEXT_BOLD),
-                (f"({self._buffer_length:,})", ThemeKey.STATUS_TEXT),
-            )
+            text = Text("Composing", style=ThemeKey.STATUS_TEXT_BOLD)
+            if self._buffer_length > 0:
+                text.append(f" ({self._buffer_length:,})", style=ThemeKey.STATUS_TEXT)
             return text
         return None
 
@@ -246,13 +245,16 @@ class SpinnerStatusState:
         """Get current spinner status as rich Text (without context)."""
         activity_text = self._activity.get_activity_text()
 
-        base_status = self._todo_status or self._reasoning_status
+        base_status = self._reasoning_status or self._todo_status
 
         if base_status:
-            result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD)
             if activity_text:
+                result = Text()
+                result.append(base_status, style=ThemeKey.STATUS_TEXT_BOLD_ITALIC)
                 result.append(" | ")
                 result.append_text(activity_text)
+            else:
+                result = Text(base_status, style=ThemeKey.STATUS_TEXT_BOLD_ITALIC)
         elif activity_text:
             activity_text.append(" …")
             result = activity_text

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -21,16 +21,11 @@ from klaude_code.ui.modes.repl.completers import AT_TOKEN_PATTERN, create_repl_c
 from klaude_code.ui.modes.repl.key_bindings import create_key_bindings
 from klaude_code.ui.renderers.user_input import USER_MESSAGE_MARK
 from klaude_code.ui.terminal.color import is_light_terminal_background
-from klaude_code.ui.utils.common import get_current_git_branch, show_path_with_tilde
 
 
 class REPLStatusSnapshot(NamedTuple):
     """Snapshot of REPL status for bottom toolbar display."""
 
-    model_name: str
-    context_usage_percent: float | None
-    llm_calls: int
-    tool_calls: int
     update_message: str | None = None
 
 
@@ -54,11 +49,16 @@ class PromptToolkitInput(InputProviderABC):
         status_provider: Callable[[], REPLStatusSnapshot] | None = None,
         pre_prompt: Callable[[], None] | None = None,
         post_prompt: Callable[[], None] | None = None,
+        is_light_background: bool | None = None,
     ):  # ▌
         self._status_provider = status_provider
         self._pre_prompt = pre_prompt
         self._post_prompt = post_prompt
-        self._is_light_terminal_background = is_light_terminal_background(timeout=0.2)
+        # Use provided value if available to avoid redundant TTY queries that may interfere
+        # with prompt_toolkit's terminal state after questionary has been used.
+        self._is_light_terminal_background = (
+            is_light_background if is_light_background is not None else is_light_terminal_background(timeout=0.2)
+        )
 
         project = str(Path.cwd()).strip("/").replace("/", "-")
         history_path = Path.home() / ".klaude" / "projects" / project / "input" / "input_history.txt"
@@ -91,7 +91,6 @@ class PromptToolkitInput(InputProviderABC):
             completer=ThreadedCompleter(create_repl_completer()),
             complete_while_typing=True,
             erase_when_done=True,
-            bottom_toolbar=self._render_bottom_toolbar,
             mouse_support=False,
             style=Style.from_dict(
                 {
@@ -107,68 +106,29 @@ class PromptToolkitInput(InputProviderABC):
             ),
         )
 
-    def _render_bottom_toolbar(self) -> FormattedText:
-        """Render bottom toolbar with working directory, git branch on left, model name and context usage on right.
-
-        If an update is available, only show the update message on the left side.
-        """
-        # Check for update message first
-        update_message: str | None = None
-        if self._status_provider:
-            try:
-                status = self._status_provider()
-                update_message = status.update_message
-            except Exception:
-                pass
-
-        # If update available, show only the update message
-        if update_message:
-            left_text = " " + update_message
-            try:
-                terminal_width = shutil.get_terminal_size().columns
-                padding = " " * max(0, terminal_width - len(left_text))
-            except Exception:
-                padding = ""
-            toolbar_text = left_text + padding
-            return FormattedText([("#ansiyellow", toolbar_text)])
-
-        # Normal mode: Left side: path and git branch
-        left_parts: list[str] = []
-        left_parts.append(show_path_with_tilde())
-
-        git_branch = get_current_git_branch()
-        if git_branch:
-            left_parts.append(git_branch)
-
-        # Right side: status info
-        right_parts: list[str] = []
-        if self._status_provider:
-            try:
-                status = self._status_provider()
-                model_name = status.model_name or "N/A"
-                right_parts.append(model_name)
-
-                # Add context if available
-                if status.context_usage_percent is not None:
-                    right_parts.append(f"context {status.context_usage_percent:.1f}%")
-            except Exception:
-                pass
-
-        # Build left and right text with borders
-        left_text = " " + " · ".join(left_parts)
-        right_text = (" · ".join(right_parts) + " ") if right_parts else " "
-
-        # Calculate padding
+    def _get_bottom_toolbar(self) -> FormattedText | None:
+        """Return bottom toolbar content only when there's an update message available."""
+        if not self._status_provider:
+            return None
+
+        try:
+            status = self._status_provider()
+            update_message = status.update_message
+        except (AttributeError, RuntimeError):
+            return None
+
+        if not update_message:
+            return None
+
+        left_text = " " + update_message
         try:
             terminal_width = shutil.get_terminal_size().columns
-            used_width = len(left_text) + len(right_text)
-            padding = " " * max(0, terminal_width - used_width)
-        except Exception:
+            padding = " " * max(0, terminal_width - len(left_text))
+        except (OSError, ValueError):
             padding = ""
 
-        # Build result with style
-        toolbar_text = left_text + padding + right_text
-        return FormattedText([("#2c7eac", toolbar_text)])
+        toolbar_text = left_text + padding
+        return FormattedText([("#ansiyellow", toolbar_text)])
 
     def _render_input_placeholder(self) -> FormattedText:
         if self._is_light_terminal_background is True:
@@ -210,8 +170,15 @@ class PromptToolkitInput(InputProviderABC):
             if self._pre_prompt is not None:
                 with contextlib.suppress(Exception):
                     self._pre_prompt()
+
+            # Only show bottom toolbar if there's an update message
+            bottom_toolbar = self._get_bottom_toolbar()
+
             with patch_stdout():
-                line: str = await self._session.prompt_async(placeholder=self._render_input_placeholder())
+                line: str = await self._session.prompt_async(
+                    placeholder=self._render_input_placeholder(),
+                    bottom_toolbar=bottom_toolbar,
+                )
             if self._post_prompt is not None:
                 with contextlib.suppress(Exception):
                     self._post_prompt()

klaude_code/ui/modes/repl/key_bindings.py

@@ -52,7 +52,7 @@ def create_key_bindings(
                 buf.delete_before_cursor()  # remove the sentinel backslash  # type: ignore[reportUnknownMemberType]
                 buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
                 return
-        except Exception:
+        except (AttributeError, TypeError):
             # Fall through to default behavior if anything goes wrong
             pass
 
@@ -111,7 +111,7 @@ def create_key_bindings(
 
             if should_refresh:
                 buf.start_completion(select_first=False)  # type: ignore[reportUnknownMemberType]
-        except Exception:
+        except (AttributeError, TypeError):
             pass
 
     @kb.add("left")
@@ -136,7 +136,7 @@ def create_key_bindings(
             # Default behavior: move one character left when possible.
             if doc.cursor_position > 0:  # type: ignore[reportUnknownMemberType]
                 buf.cursor_left()  # type: ignore[reportUnknownMemberType]
-        except Exception:
+        except (AttributeError, IndexError, TypeError):
             pass
 
     @kb.add("right")
@@ -163,7 +163,7 @@ def create_key_bindings(
             # Default behavior: move one character right when possible.
             if doc.cursor_position < len(doc.text):  # type: ignore[reportUnknownMemberType]
                 buf.cursor_right()  # type: ignore[reportUnknownMemberType]
-        except Exception:
+        except (AttributeError, IndexError, TypeError):
             pass
 
     return kb

klaude_code/ui/modes/repl/renderer.py

@@ -266,12 +266,7 @@ class REPLRenderer:
         self.print(r_user_input.render_interrupt())
 
     def display_error(self, event: events.ErrorEvent) -> None:
-        self.print(
-            r_errors.render_error(
-                truncate_display(event.error_message),
-                indent=0,
-            )
-        )
+        self.print(r_errors.render_error(truncate_display(event.error_message)))
 
     # -------------------------------------------------------------------------
     # Spinner control methods

klaude_code/ui/renderers/common.py

@@ -37,10 +37,17 @@ def truncate_display(
 
     if len(lines) > max_lines:
         truncated_lines = len(lines) - max_lines
-        head_count = max_lines // 2
-        tail_count = max_lines - head_count
-        head_lines = lines[:head_count]
-        tail_lines = lines[-tail_count:]
+
+        # If the hidden section is too small, show everything instead of inserting
+        # the "(more N lines)" indicator.
+        if truncated_lines < 5:
+            truncated_lines = 0
+            head_lines = lines
+        else:
+            head_count = max_lines // 2
+            tail_count = max_lines - head_count
+            head_lines = lines[:head_count]
+            tail_lines = lines[-tail_count:]
     else:
         head_lines = lines
 

klaude_code/ui/renderers/developer.py

@@ -120,6 +120,8 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
             return _render_status_output(e.item.command_output)
         case commands.CommandName.RELEASE_NOTES:
             return Padding.indent(NoInsetMarkdown(e.item.content or ""), level=2)
+        case commands.CommandName.FORK_SESSION:
+            return _render_fork_session_output(e.item.command_output)
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
@@ -145,6 +147,21 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
     return f"{symbol}{cost:.2f}"
 
 
+def _render_fork_session_output(command_output: model.CommandOutput) -> RenderableType:
+    """Render fork session output with usage instructions."""
+    if not isinstance(command_output.ui_extra, model.SessionIdUIExtra):
+        return Text("(no session id)", style=ThemeKey.METADATA)
+
+    session_id = command_output.ui_extra.session_id
+    grid = Table.grid(padding=(0, 1))
+    grid.add_column(style=ThemeKey.METADATA, overflow="fold")
+
+    grid.add_row(Text("Session forked. To continue in a new conversation:", style=ThemeKey.METADATA))
+    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.METADATA_BOLD))
+
+    return Padding.indent(grid, level=2)
+
+
 def _render_status_output(command_output: model.CommandOutput) -> RenderableType:
     """Render session status with total cost and per-model breakdown."""
     if not isinstance(command_output.ui_extra, model.SessionStatusUIExtra):

klaude_code/ui/renderers/diffs.py

@@ -148,7 +148,7 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
                 plus = parts[2]  # like '+12,4'
                 new_start = int(plus[1:].split(",")[0])
                 new_ln = new_start
-            except Exception:
+            except (IndexError, ValueError):
                 new_ln = None
             if has_rendered_diff_content:
                 grid.add_row(Text(f"{'⋮':>{const.DIFF_PREFIX_WIDTH}}", style=ThemeKey.TOOL_RESULT), "")

klaude_code/ui/renderers/errors.py

@@ -5,12 +5,17 @@ from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
 
-def render_error(error_msg: Text, indent: int = 2) -> RenderableType:
-    """Stateless error renderer.
+def render_error(error_msg: Text) -> RenderableType:
+    """Render error with X mark for error events."""
+    grid = create_grid()
+    error_msg.style = ThemeKey.ERROR
+    grid.add_row(Text("✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    return grid
+
 
-    Shows a two-column grid with an error mark and truncated message.
-    """
+def render_tool_error(error_msg: Text) -> RenderableType:
+    """Render error with indent for tool results."""
     grid = create_grid()
     error_msg.style = ThemeKey.ERROR
-    grid.add_row(Text(" " * indent + "✘", style=ThemeKey.ERROR_BOLD), error_msg)
+    grid.add_row(Text("  "), error_msg)
     return grid

klaude_code/ui/renderers/metadata.py

@@ -1,4 +1,4 @@
-from importlib.metadata import version
+from importlib.metadata import PackageNotFoundError, version
 
 from rich import box
 from rich.console import Group, RenderableType
@@ -17,7 +17,7 @@ def _get_version() -> str:
     """Get the current version of klaude-code."""
     try:
         return version("klaude-code")
-    except Exception:
+    except PackageNotFoundError:
         return "unknown"
 
 

klaude_code/ui/renderers/tools.py

@@ -18,7 +18,7 @@ from klaude_code.ui.rich.theme import ThemeKey
 
 # Tool markers (Unicode symbols for UI display)
 MARK_GENERIC = "⚒"
-MARK_BASH = "→"
+MARK_BASH = "$"
 MARK_PLAN = "Ξ"
 MARK_READ = "←"
 MARK_EDIT = "±"
@@ -205,9 +205,13 @@ def render_write_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
     try:
         json_dict = json.loads(arguments)
-        file_path = json_dict.get("file_path")
+        file_path = json_dict.get("file_path", "")
         tool_name_column = Text.assemble((MARK_WRITE, ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
-        arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
+        # Markdown files show path in result panel, skip here to avoid duplication
+        if file_path.endswith(".md"):
+            arguments_column = Text("")
+        else:
+            arguments_column = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
         tool_name_column = Text.assemble((MARK_WRITE, ThemeKey.TOOL_MARK), " ", ("Write", ThemeKey.TOOL_NAME))
         arguments_column = Text(
@@ -569,7 +573,7 @@ def render_tool_result(e: events.ToolResultEvent, *, code_theme: str = "monokai"
     # Handle error case
     if e.status == "error" and e.ui_extra is None:
         error_msg = truncate_display(e.result)
-        return r_errors.render_error(error_msg)
+        return r_errors.render_tool_error(error_msg)
 
     # Render multiple ui blocks if present
     if isinstance(e.ui_extra, model.MultiUIExtra) and e.ui_extra.items:

klaude_code/ui/rich/markdown.py

@@ -54,11 +54,11 @@ class Divider(MarkdownElement):
         yield Rule(style=style, characters="-")
 
 
-class MinimalHeavyHeadTable(TableElement):
+class MarkdownTable(TableElement):
     """A table element with MINIMAL_HEAVY_HEAD box style."""
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        table = Table(box=box.MARKDOWN)
+        table = Table(box=box.MARKDOWN, border_style=console.get_style("markdown.table.border"))
 
         if self.header is not None and self.header.row is not None:
             for column in self.header.row.cells:
@@ -97,7 +97,7 @@ class NoInsetMarkdown(Markdown):
         "code_block": NoInsetCodeBlock,
         "heading_open": LeftHeading,
         "hr": Divider,
-        "table_open": MinimalHeavyHeadTable,
+        "table_open": MarkdownTable,
     }
 
 
@@ -110,7 +110,7 @@ class ThinkingMarkdown(Markdown):
         "code_block": ThinkingCodeBlock,
         "heading_open": LeftHeading,
         "hr": Divider,
-        "table_open": MinimalHeavyHeadTable,
+        "table_open": MarkdownTable,
     }
 
 
@@ -192,7 +192,7 @@ class MarkdownStream:
 
         try:
             tokens = self._parser.parse(text)
-        except Exception:
+        except Exception:  # markdown-it-py may raise various internal errors during parsing
             return 0
 
         top_level: list[Token] = [token for token in tokens if token.level == 0 and token.map is not None]

klaude_code/ui/rich/theme.py

@@ -130,6 +130,7 @@ class ThemeKey(str, Enum):
     STATUS_SPINNER = "spinner.status"
     STATUS_TEXT = "spinner.status.text"
     STATUS_TEXT_BOLD = "spinner.status.text.bold"
+    STATUS_TEXT_BOLD_ITALIC = "spinner.status.text.bold_italic"
     # STATUS
     STATUS_HINT = "status.hint"
     # USER_INPUT
@@ -222,7 +223,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.ERROR_BOLD.value: "bold " + palette.red,
                 ThemeKey.INTERRUPT.value: "reverse bold " + palette.red,
                 # USER_INPUT
-                ThemeKey.USER_INPUT.value: "bold " + palette.magenta,
+                ThemeKey.USER_INPUT.value: palette.magenta,
                 ThemeKey.USER_INPUT_PROMPT.value: "bold " + palette.magenta,
                 ThemeKey.USER_INPUT_AT_PATTERN.value: palette.purple,
                 ThemeKey.USER_INPUT_SLASH_COMMAND.value: "bold reverse " + palette.blue,
@@ -234,7 +235,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 # STATUS
                 ThemeKey.STATUS_SPINNER.value: palette.blue,
                 ThemeKey.STATUS_TEXT.value: palette.blue,
-                ThemeKey.STATUS_TEXT_BOLD.value: "bold italic " + palette.blue,
+                ThemeKey.STATUS_TEXT_BOLD.value: "bold " + palette.blue,
+                ThemeKey.STATUS_TEXT_BOLD_ITALIC.value: "bold italic " + palette.blue,
                 ThemeKey.STATUS_HINT.value: palette.grey2,
                 # REMINDER
                 ThemeKey.REMINDER.value: palette.grey1,
@@ -276,7 +278,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.RESUME_FLAG.value: "bold reverse " + palette.green,
                 ThemeKey.RESUME_INFO.value: palette.green,
                 # CONFIGURATION DISPLAY
-                ThemeKey.CONFIG_TABLE_HEADER.value: palette.green,
+                ThemeKey.CONFIG_TABLE_HEADER.value: palette.grey1,
                 ThemeKey.CONFIG_STATUS_OK.value: palette.green,
                 ThemeKey.CONFIG_STATUS_PRIMARY.value: palette.yellow,
                 ThemeKey.CONFIG_STATUS_ERROR.value: palette.red,
@@ -299,6 +301,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.item.number": palette.grey2,
                 "markdown.link": "underline " + palette.blue,
                 "markdown.link_url": "underline " + palette.blue,
+                "markdown.table.border": palette.grey2,
             }
         ),
         thinking_markdown_theme=Theme(
@@ -319,6 +322,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link": "underline " + palette.blue,
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.strong": "bold italic " + palette.grey1,
+                "markdown.table.border": palette.grey2,
             }
         ),
         code_theme=palette.code_theme,

klaude_code/ui/terminal/color.py

@@ -182,7 +182,7 @@ def _parse_osc_color_response(data: bytes) -> tuple[int, int, int] | None:
 
     try:
         text = data.decode("ascii", errors="ignore")
-    except Exception:
+    except LookupError:  # encoding lookup failure (should not happen with "ascii")
         return None
 
     match = _OSC_BG_REGEX.search(text)

klaude_code/ui/terminal/control.py

@@ -48,7 +48,7 @@ def start_esc_interrupt_monitor(
         try:
             fd = sys.stdin.fileno()
             old = termios.tcgetattr(fd)
-        except Exception as exc:  # pragma: no cover - environment dependent
+        except OSError as exc:  # pragma: no cover - environment dependent
             log((f"esc monitor init error: {exc}", "r red"))
             return
 
@@ -60,7 +60,7 @@ def start_esc_interrupt_monitor(
                     continue
                 try:
                     ch = os.read(fd, 1).decode(errors="ignore")
-                except Exception:
+                except OSError:
                     continue
                 if ch != "\x1b":
                     continue
@@ -71,7 +71,7 @@ def start_esc_interrupt_monitor(
                 while r2:
                     try:
                         seq += os.read(fd, 1).decode(errors="ignore")
-                    except Exception:
+                    except OSError:
                         break
                     r2, _, _ = select.select([sys.stdin], [], [], 0.0)
 
@@ -127,7 +127,7 @@ def install_sigint_double_press_exit(
 
     try:
         signal.signal(signal.SIGINT, _handler)
-    except Exception:  # pragma: no cover - platform dependent
+    except (OSError, ValueError):  # pragma: no cover - platform dependent
         # If installing the handler fails, restore() will be a no-op.
         return lambda: None