klaude-code 1.4.3__py3-none-any.whl → 1.6.0__py3-none-any.whl

klaude_code/ui/modes/repl/key_bindings.py

@@ -12,6 +12,7 @@ from collections.abc import Callable
 from typing import cast
 
 from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.filters import Always, Filter
 from prompt_toolkit.filters.app import has_completions
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.key_binding.key_processor import KeyPressEvent
@@ -21,6 +22,10 @@ def create_key_bindings(
     capture_clipboard_tag: Callable[[], str | None],
     copy_to_clipboard: Callable[[str], None],
     at_token_pattern: re.Pattern[str],
+    *,
+    input_enabled: Filter | None = None,
+    open_model_picker: Callable[[], None] | None = None,
+    open_thinking_picker: Callable[[], None] | None = None,
 ) -> KeyBindings:
     """Create REPL key bindings with injected dependencies.
 
@@ -33,6 +38,7 @@ def create_key_bindings(
         KeyBindings instance with all REPL handlers configured
     """
     kb = KeyBindings()
+    enabled = input_enabled if input_enabled is not None else Always()
 
     def _should_submit_instead_of_accepting_completion(buf: Buffer) -> bool:
         """Return True when Enter should submit even if completions are visible.
@@ -111,7 +117,7 @@ def create_key_bindings(
         buf.apply_completion(completion)
         return True
 
-    @kb.add("c-v")
+    @kb.add("c-v", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         """Paste image from clipboard as [Image #N]."""
         tag = capture_clipboard_tag()
@@ -119,7 +125,7 @@ def create_key_bindings(
             with contextlib.suppress(Exception):
                 event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
 
-    @kb.add("enter")
+    @kb.add("enter", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         buf = event.current_buffer
         doc = buf.document  # type: ignore
@@ -150,29 +156,29 @@ def create_key_bindings(
         # No need to persist manifest anymore - iter_inputs will handle image extraction
         buf.validate_and_handle()  # type: ignore
 
-    @kb.add("tab", filter=has_completions)
+    @kb.add("tab", filter=enabled & has_completions)
     def _(event: KeyPressEvent) -> None:
         buf = event.current_buffer
         if _accept_current_completion(buf):
             event.app.invalidate()  # type: ignore[reportUnknownMemberType]
 
-    @kb.add("down", filter=has_completions)
+    @kb.add("down", filter=enabled & has_completions)
     def _(event: KeyPressEvent) -> None:
         buf = event.current_buffer
         _cycle_completion(buf, delta=1)
         event.app.invalidate()  # type: ignore[reportUnknownMemberType]
 
-    @kb.add("up", filter=has_completions)
+    @kb.add("up", filter=enabled & has_completions)
     def _(event: KeyPressEvent) -> None:
         buf = event.current_buffer
         _cycle_completion(buf, delta=-1)
         event.app.invalidate()  # type: ignore[reportUnknownMemberType]
 
-    @kb.add("c-j")
+    @kb.add("c-j", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         event.current_buffer.insert_text("\n")  # type: ignore
 
-    @kb.add("c")
+    @kb.add("c", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         """Copy selected text to system clipboard, or insert 'c' if no selection."""
         buf = event.current_buffer  # type: ignore
@@ -187,7 +193,7 @@ def create_key_bindings(
         else:
             buf.insert_text("c")  # type: ignore[reportUnknownMemberType]
 
-    @kb.add("backspace")
+    @kb.add("backspace", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         """Ensure completions refresh on backspace when editing an @token.
 
@@ -218,7 +224,7 @@ def create_key_bindings(
         except (AttributeError, TypeError):
             pass
 
-    @kb.add("left")
+    @kb.add("left", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         """Support wrapping to previous line when pressing left at column 0."""
         buf = event.current_buffer  # type: ignore
@@ -243,7 +249,7 @@ def create_key_bindings(
         except (AttributeError, IndexError, TypeError):
             pass
 
-    @kb.add("right")
+    @kb.add("right", filter=enabled)
     def _(event: KeyPressEvent) -> None:
         """Support wrapping to next line when pressing right at line end."""
         buf = event.current_buffer  # type: ignore
@@ -270,4 +276,18 @@ def create_key_bindings(
         except (AttributeError, IndexError, TypeError):
             pass
 
+    @kb.add("c-l", filter=enabled, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        del event
+        if open_model_picker is not None:
+            with contextlib.suppress(Exception):
+                open_model_picker()
+
+    @kb.add("c-t", filter=enabled, eager=True)
+    def _(event: KeyPressEvent) -> None:
+        del event
+        if open_thinking_picker is not None:
+            with contextlib.suppress(Exception):
+                open_thinking_picker()
+
     return kb

klaude_code/ui/modes/repl/renderer.py

@@ -283,7 +283,7 @@ class REPLRenderer:
         self._spinner_visible = False
         self._refresh_bottom_live()
 
-    def spinner_update(self, status_text: str | Text, right_text: Text | None = None) -> None:
+    def spinner_update(self, status_text: str | Text, right_text: RenderableType | None = None) -> None:
         """Update the spinner status text with optional right-aligned text."""
         self._status_text = ShimmerStatusText(status_text, right_text)
         self._status_spinner.update(text=SingleLine(self._status_text), style=ThemeKey.STATUS_SPINNER)

klaude_code/ui/renderers/developer.py

@@ -161,10 +161,10 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 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)
+        return Padding.indent(Text("(no session id)", style=ThemeKey.METADATA), level=2)
 
-    session_id = command_output.ui_extra.session_id
     grid = Table.grid(padding=(0, 1))
+    session_id = command_output.ui_extra.session_id
     grid.add_column(style=ThemeKey.METADATA, overflow="fold")
 
     grid.add_row(Text("Session forked. To continue in a new conversation:", style=ThemeKey.METADATA))

klaude_code/ui/renderers/metadata.py

@@ -6,6 +6,7 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.text import Text
 
+from klaude_code import const
 from klaude_code.protocol import events, model
 from klaude_code.trace import is_debug_enabled
 from klaude_code.ui.renderers.common import create_grid
@@ -95,10 +96,17 @@ def _render_task_metadata_block(
         # Context (only for main agent)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
             context_size = format_number(metadata.usage.context_size or 0)
+            # Calculate effective limit (same as Usage.context_usage_percent)
+            effective_limit = (metadata.usage.context_limit or 0) - (
+                metadata.usage.max_tokens or const.DEFAULT_MAX_TOKENS
+            )
+            effective_limit_str = format_number(effective_limit) if effective_limit > 0 else "?"
             parts.append(
                 Text.assemble(
                     ("context ", ThemeKey.METADATA_DIM),
                     (context_size, ThemeKey.METADATA),
+                    ("/", ThemeKey.METADATA_DIM),
+                    (effective_limit_str, ThemeKey.METADATA),
                     (f" ({metadata.usage.context_usage_percent:.1f}%)", ThemeKey.METADATA_DIM),
                 )
             )
@@ -148,18 +156,15 @@ def _render_task_metadata_block(
 
 
 def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
-    """Render task metadata including main agent and sub-agents, aggregated by model+provider."""
+    """Render task metadata including main agent and sub-agents."""
     renderables: list[RenderableType] = []
 
     renderables.append(
         _render_task_metadata_block(e.metadata.main_agent, is_sub_agent=False, show_context_and_time=True)
     )
 
-    # Aggregate by (model_name, provider), sorted by total_cost descending
-    sorted_items = model.TaskMetadata.aggregate_by_model(e.metadata.sub_agent_task_metadata)
-
-    # Render each aggregated model block
-    for meta in sorted_items:
+    # Render each sub-agent metadata block
+    for meta in e.metadata.sub_agent_task_metadata:
         renderables.append(_render_task_metadata_block(meta, is_sub_agent=True, show_context_and_time=False))
 
     return Group(*renderables)

klaude_code/ui/renderers/user_input.py

@@ -1,13 +1,30 @@
 import re
+from collections.abc import Callable
 
 from rich.console import Group, RenderableType
 from rich.text import Text
 
-from klaude_code.command import is_slash_command_name
 from klaude_code.skill import get_available_skills
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
+# Module-level command name checker. Set by cli/runtime.py on startup.
+_command_name_checker: Callable[[str], bool] | None = None
+
+
+def set_command_name_checker(checker: Callable[[str], bool]) -> None:
+    """Set the command name validation function (called from runtime layer)."""
+    global _command_name_checker
+    _command_name_checker = checker
+
+
+def is_slash_command_name(name: str) -> bool:
+    """Check if name is a valid slash command using the injected checker."""
+    if _command_name_checker is None:
+        return False
+    return _command_name_checker(name)
+
+
 # Match @-file patterns only when they appear at the beginning of the line
 # or immediately after whitespace, to avoid treating mid-word email-like
 # patterns such as foo@bar.com as file references.

klaude_code/ui/rich/markdown.py

@@ -254,18 +254,36 @@ class MarkdownStream:
         live suffix separately may introduce an extra blank line that wouldn't
         appear when rendering the full document.
 
-        This function removes leading blank lines from the live ANSI when the
-        stable ANSI already ends with a blank line.
+        This function removes *overlapping* blank lines from the live ANSI when
+        the stable ANSI already ends with one or more blank lines.
+
+        Important: don't remove *all* leading blank lines from the live suffix.
+        In some incomplete-block cases, the live render may begin with multiple
+        blank lines while the full-document render would keep one of them.
         """
 
         stable_lines = stable_ansi.splitlines(keepends=True)
-        stable_ends_blank = bool(stable_lines) and not stable_lines[-1].strip()
-        if not stable_ends_blank:
+        if not stable_lines:
+            return live_ansi
+
+        stable_trailing_blank = 0
+        for line in reversed(stable_lines):
+            if line.strip():
+                break
+            stable_trailing_blank += 1
+        if stable_trailing_blank <= 0:
             return live_ansi
 
         live_lines = live_ansi.splitlines(keepends=True)
-        while live_lines and not live_lines[0].strip():
-            live_lines.pop(0)
+        live_leading_blank = 0
+        for line in live_lines:
+            if line.strip():
+                break
+            live_leading_blank += 1
+
+        drop = min(stable_trailing_blank, live_leading_blank)
+        if drop > 0:
+            live_lines = live_lines[drop:]
         return "".join(live_lines)
 
     def _append_nonfinal_sentinel(self, stable_source: str) -> str:
@@ -400,9 +418,23 @@ class MarkdownStream:
             apply_mark_live = self._stable_source_line_count == 0
             live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
-            if self._stable_rendered_lines and not self._stable_rendered_lines[-1].strip():
-                while live_lines and not live_lines[0].strip():
-                    live_lines.pop(0)
+            if self._stable_rendered_lines:
+                stable_trailing_blank = 0
+                for line in reversed(self._stable_rendered_lines):
+                    if line.strip():
+                        break
+                    stable_trailing_blank += 1
+
+                if stable_trailing_blank > 0:
+                    live_leading_blank = 0
+                    for line in live_lines:
+                        if line.strip():
+                            break
+                        live_leading_blank += 1
+
+                    drop = min(stable_trailing_blank, live_leading_blank)
+                    if drop > 0:
+                        live_lines = live_lines[drop:]
 
             live_text = Text.from_ansi("".join(live_lines))
             self._live_sink(live_text)

klaude_code/ui/rich/status.py

@@ -4,10 +4,13 @@ import contextlib
 import math
 import random
 import time
+from collections.abc import Callable
 
 import rich.status as rich_status
+from rich.cells import cell_len
 from rich.color import Color
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
+from rich.measure import Measurement
 from rich.spinner import Spinner as RichSpinner
 from rich.style import Style
 from rich.table import Table
@@ -80,20 +83,63 @@ def _format_elapsed_compact(seconds: float) -> str:
 def current_hint_text(*, min_time_width: int = 0) -> str:
     """Return the full hint string shown on the status line.
 
-    Includes an optional elapsed time prefix (right-aligned, min width) and
-    the constant hint suffix.
+    The hint is the constant suffix shown after the main status text.
+
+    The elapsed task time is rendered on the right side of the status line
+    (near context usage), not inside the hint.
     """
 
+    # Keep the signature stable; min_time_width is intentionally ignored.
+    _ = min_time_width
+    return const.STATUS_HINT_TEXT
+
+
+def current_elapsed_text(*, min_time_width: int = 0) -> str | None:
+    """Return the current task elapsed time text (e.g. "11s", "1m02s")."""
+
     elapsed = _task_elapsed_seconds()
     if elapsed is None:
-        return const.STATUS_HINT_TEXT
+        return None
     time_text = _format_elapsed_compact(elapsed)
     if min_time_width > 0:
         time_text = time_text.rjust(min_time_width)
-    suffix = const.STATUS_HINT_TEXT.strip()
-    if suffix.startswith("(") and suffix.endswith(")"):
-        suffix = suffix[1:-1]
-    return f" ({time_text} · {suffix})"
+    return time_text
+
+
+class DynamicText:
+    """Renderable that materializes a Text instance at render time.
+
+    This is useful for status line elements that should refresh without
+    requiring explicit spinner_update calls (e.g. elapsed time).
+    """
+
+    def __init__(
+        self,
+        factory: Callable[[], Text],
+        *,
+        min_width_cells: int = 0,
+    ) -> None:
+        self._factory = factory
+        self.min_width_cells = min_width_cells
+
+    @property
+    def plain(self) -> str:
+        return self._factory().plain
+
+    def __rich_measure__(self, console: Console, options: ConsoleOptions) -> Measurement:
+        # Ensure Table/grid layout allocates a stable width for this renderable.
+        text = self._factory()
+        measured = Measurement.get(console, options, text)
+        min_width = max(measured.minimum, self.min_width_cells)
+        max_width = max(measured.maximum, self.min_width_cells)
+
+        limit = getattr(options, "max_width", options.size.width)
+        max_width = min(max_width, limit)
+        min_width = min(min_width, max_width)
+        return Measurement(min_width, max_width)
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        yield self._factory()
 
 
 def _shimmer_profile(main_text: str) -> list[tuple[str, float]]:
@@ -220,7 +266,7 @@ class ShimmerStatusText:
     def __init__(
         self,
         main_text: str | Text,
-        right_text: Text | None = None,
+        right_text: RenderableType | None = None,
         main_style: ThemeKey = ThemeKey.STATUS_TEXT,
     ) -> None:
         if isinstance(main_text, Text):
@@ -234,34 +280,49 @@ class ShimmerStatusText:
         self._right_text = right_text
 
     def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
-        left_text = self._render_left_text(console)
+        left_text = _StatusLeftText(main=self._main_text, hint_style=self._hint_style)
 
         if self._right_text is None:
             yield left_text
             return
 
-        # Use Table.grid to create left-right aligned layout
-        table = Table.grid(expand=True)
+        # Use Table.grid to create left-right aligned layout with a stable gap.
+        table = Table.grid(expand=True, padding=(0, 1, 0, 0), collapse_padding=True, pad_edge=False)
         table.add_column(justify="left", ratio=1)
         table.add_column(justify="right")
         table.add_row(left_text, self._right_text)
         yield table
 
-    def _render_left_text(self, console: Console) -> Text:
-        """Render the left part with shimmer effect on main text only."""
-        result = Text()
-        hint_style = console.get_style(str(self._hint_style))
 
-        # Apply shimmer only to main text
-        for index, (ch, intensity) in enumerate(_shimmer_profile(self._main_text.plain)):
-            base_style = self._main_text.get_style_at_offset(console, index)
+class _StatusLeftText:
+    def __init__(self, *, main: Text, hint_style: ThemeKey) -> None:
+        self._main = main
+        self._hint_style = hint_style
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        max_width = getattr(options, "max_width", options.size.width)
+
+        # Keep the hint visually attached to the status text, while truncating only
+        # the main status segment when space is tight.
+        hint_text = Text(current_hint_text().strip("\n"), style=console.get_style(str(self._hint_style)))
+        hint_cells = cell_len(hint_text.plain)
+
+        main_text = Text()
+        for index, (ch, intensity) in enumerate(_shimmer_profile(self._main.plain)):
+            base_style = self._main.get_style_at_offset(console, index)
             style = _shimmer_style(console, base_style, intensity)
-            result.append(ch, style=style)
+            main_text.append(ch, style=style)
 
-        # Append hint text without shimmer
-        result.append(current_hint_text().strip("\n"), style=hint_style)
+        # If the hint itself can't fit, fall back to truncating the combined text.
+        if max_width <= hint_cells:
+            combined = Text.assemble(main_text, hint_text)
+            combined.truncate(max(1, max_width), overflow="ellipsis", pad=False)
+            yield combined
+            return
 
-        return result
+        main_budget = max_width - hint_cells
+        main_text.truncate(max(1, main_budget), overflow="ellipsis", pad=False)
+        yield Text.assemble(main_text, hint_text)
 
 
 def spinner_name() -> str:

klaude_code/ui/rich/theme.py

@@ -44,7 +44,7 @@ LIGHT_PALETTE = Palette(
     red="red",
     yellow="yellow",
     green="#00875f",
-    grey_yellow="#a89a85",
+    grey_yellow="#5f9f7a",
     cyan="cyan",
     blue="#3078C5",
     orange="#d77757",
@@ -77,7 +77,7 @@ DARK_PALETTE = Palette(
     red="#d75f5f",
     yellow="yellow",
     green="#5fd787",
-    grey_yellow="#c0b095",
+    grey_yellow="#8ac89a",
     cyan="cyan",
     blue="#00afff",
     orange="#e6704e",

klaude_code/ui/terminal/notifier.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+import subprocess
 import sys
 from dataclasses import dataclass
 from enum import Enum
@@ -8,6 +9,9 @@ from typing import TextIO, cast
 
 from klaude_code.trace import DebugType, log_debug
 
+# Environment variable for tmux test signal channel
+TMUX_SIGNAL_ENV = "KLAUDE_TEST_SIGNAL"
+
 ST = "\033\\"
 BEL = "\a"
 
@@ -103,3 +107,41 @@ def _compact(text: str, limit: int = 160) -> str:
     if len(squashed) > limit:
         return squashed[: limit - 3] + "…"
     return squashed
+
+
+def emit_tmux_signal(channel: str | None = None) -> bool:
+    """Send a tmux wait-for signal when a task completes.
+
+    This enables synchronous testing by allowing external scripts to block
+    until a task finishes, eliminating the need for polling or sleep.
+
+    Usage:
+        KLAUDE_TEST_SIGNAL=done klaude  # In tmux session
+        tmux wait-for done              # Blocks until task completes
+
+    Args:
+        channel: Signal channel name. If None, reads from KLAUDE_TEST_SIGNAL env var.
+
+    Returns:
+        True if signal was sent successfully, False otherwise.
+    """
+    channel = channel or os.getenv(TMUX_SIGNAL_ENV)
+    if not channel:
+        return False
+
+    # Check if we're in a tmux session
+    if not os.getenv("TMUX"):
+        log_debug("tmux signal skipped: not in tmux session", debug_type=DebugType.TERMINAL)
+        return False
+
+    try:
+        subprocess.run(
+            ["tmux", "wait-for", "-S", channel],
+            check=True,
+            capture_output=True,
+        )
+        log_debug(f"tmux signal sent: {channel}", debug_type=DebugType.TERMINAL)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        log_debug(f"tmux signal failed: {e}", debug_type=DebugType.TERMINAL)
+        return False