klaude-code 1.2.18__py3-none-any.whl → 1.2.20__py3-none-any.whl

klaude_code/ui/modes/repl/completers.py

@@ -158,7 +158,7 @@ class _AtFilesCompleter(Completer):
     def __init__(
         self,
         debounce_sec: float = 0.25,
-        cache_ttl_sec: float = 10.0,
+        cache_ttl_sec: float = 60.0,
         max_results: int = 20,
     ):
         self._debounce_sec = debounce_sec
@@ -170,13 +170,26 @@ class _AtFilesCompleter(Completer):
         self._last_query_key: str | None = None
         self._last_results: list[str] = []
         self._last_results_time: float = 0.0
+        self._last_results_truncated: bool = False
 
         # rg --files cache (used when fd is unavailable)
         self._rg_file_list: list[str] | None = None
         self._rg_file_list_time: float = 0.0
+        self._rg_file_list_cwd: Path | None = None
 
-        # Cache for ignored paths (gitignored files)
-        self._last_ignored_paths: set[str] = set()
+        # git ls-files cache (preferred when inside a git repo)
+        self._git_repo_root: Path | None = None
+        self._git_repo_root_time: float = 0.0
+        self._git_repo_root_cwd: Path | None = None
+
+        self._git_file_list: list[str] | None = None
+        self._git_file_list_lower: list[str] | None = None
+        self._git_file_list_time: float = 0.0
+        self._git_file_list_cwd: Path | None = None
+
+        # Command timeout is intentionally higher than a keypress cadence.
+        # We rely on caching/narrowing to avoid calling fd repeatedly.
+        self._cmd_timeout_sec: float = 3.0
 
     # ---- prompt_toolkit API ----
     def get_completions(self, document: Document, complete_event) -> Iterable[Completion]:  # type: ignore[override]
@@ -234,6 +247,8 @@ class _AtFilesCompleter(Completer):
         key_norm = keyword.lower()
         query_key = f"{cwd.resolve()}::search::{key_norm}"
 
+        max_scan_results = self._max_results * 3
+
         # Debounce: if called too soon again, filter last results
         if self._last_results and self._last_query_key is not None:
             prev = self._last_query_key
@@ -247,85 +262,120 @@ class _AtFilesCompleter(Completer):
                     and len(cur_kw) >= len(prev_kw)
                     and cur_kw.startswith(prev_kw)
                 )
+
+                # If the previous result set was not truncated, it is a complete
+                # superset for any narrower prefix. Reuse it even if the user
+                # pauses between keystrokes.
+                if (
+                    is_narrowing
+                    and not self._last_results_truncated
+                    and now - self._last_results_time < self._cache_ttl
+                ):
+                    return self._filter_and_format(self._last_results, cwd, key_norm)
+
                 if is_narrowing and (now - self._last_cmd_time) < self._debounce_sec:
-                    # For narrowing, fast-filter previous results to avoid expensive calls
-                    return self._filter_and_format(self._last_results, cwd, key_norm, self._last_ignored_paths)
+                    # For rapid narrowing, fast-filter previous results to avoid expensive calls
+                    # If the previous result set was truncated (e.g., for a 1-char query),
+                    # filtering it can legitimately produce an empty set even when matches
+                    # exist elsewhere. Fall back to a real search in that case.
+                    filtered = self._filter_and_format(self._last_results, cwd, key_norm)
+                    if filtered:
+                        return filtered
 
         # Cache TTL: reuse cached results for same query within TTL
         if self._last_results and self._last_query_key == query_key and now - self._last_results_time < self._cache_ttl:
-            return self._filter_and_format(self._last_results, cwd, key_norm, self._last_ignored_paths)
+            return self._filter_and_format(self._last_results, cwd, key_norm)
 
-        # Prefer fd; otherwise fallback to rg --files
+        # Prefer git index (fast in large repos), then fd, then rg --files.
         results: list[str] = []
-        ignored_paths: set[str] = set()
-        if self._has_cmd("fd"):
-            # Use fd to search anywhere in full path (files and directories), case-insensitive
-            results, ignored_paths = self._run_fd_search(cwd, key_norm)
-        elif self._has_cmd("rg"):
-            # Use rg to search only in current directory
-            if self._rg_file_list is None or now - self._rg_file_list_time > max(self._cache_ttl, 30.0):
-                cmd = ["rg", "--files", "--no-ignore", "--hidden"]
-                r = self._run_cmd(cmd, cwd=cwd)  # Search from current directory
-                if r.ok:
-                    self._rg_file_list = r.lines
-                    self._rg_file_list_time = now
-                else:
-                    self._rg_file_list = []
-                    self._rg_file_list_time = now
-            # Filter by keyword
-            all_files = self._rg_file_list or []
-            kn = key_norm
-            results = [p for p in all_files if kn in p.lower()]
-            # For rg fallback, we don't distinguish ignored files (no priority sorting)
-        else:
-            return []
+        truncated = False
+
+        # For very short keywords, prefer fd's early-exit behavior.
+        # For keywords >= 2 chars, using git's file list is typically faster
+        # than scanning the filesystem repeatedly.
+        if len(key_norm) >= 2:
+            results, truncated = self._git_paths_for_keyword(cwd, key_norm, max_results=max_scan_results)
+
+        if not results:
+            if self._has_cmd("fd"):
+                # 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)
+            elif self._has_cmd("rg"):
+                # Use rg to search only in current directory
+                rg_cache_ttl = max(self._cache_ttl, 30.0)
+                if (
+                    self._rg_file_list is None
+                    or self._rg_file_list_cwd != cwd
+                    or now - self._rg_file_list_time > rg_cache_ttl
+                ):
+                    cmd = [
+                        "rg",
+                        "--files",
+                        "--hidden",
+                        "--glob",
+                        "!**/.git/**",
+                        "--glob",
+                        "!**/.venv/**",
+                        "--glob",
+                        "!**/node_modules/**",
+                    ]
+                    r = self._run_cmd(cmd, cwd=cwd, timeout_sec=self._cmd_timeout_sec)  # Search from current directory
+                    if r.ok:
+                        self._rg_file_list = r.lines
+                        self._rg_file_list_time = now
+                        self._rg_file_list_cwd = cwd
+                    else:
+                        self._rg_file_list = []
+                        self._rg_file_list_time = now
+                        self._rg_file_list_cwd = cwd
+                # Filter by keyword
+                all_files = self._rg_file_list or []
+                kn = key_norm
+                results = [p for p in all_files if kn in p.lower()]
+                # For rg fallback, we don't implement any priority sorting.
+            else:
+                return []
 
         # Update caches
         self._last_cmd_time = now
         self._last_query_key = query_key
         self._last_results = results
         self._last_results_time = now
-        self._last_ignored_paths = ignored_paths
-        return self._filter_and_format(results, cwd, key_norm, ignored_paths)
+        self._last_results_truncated = truncated
+        return self._filter_and_format(results, cwd, key_norm)
 
     def _filter_and_format(
         self,
         paths_from_root: list[str],
         cwd: Path,
         keyword_norm: str,
-        ignored_paths: set[str] | None = None,
     ) -> list[str]:
         # Filter to keyword (case-insensitive) and rank by:
-        # 1. Non-gitignored files first (is_ignored: 0 or 1)
-        # 2. Basename hit first, then path hit position, then length
+        # 1. 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
-        ignored_paths = ignored_paths or set()
-        out: list[tuple[str, tuple[int, int, int, int, int]]] = []
+        out: list[tuple[str, tuple[int, int, int, int]]] = []
         for p in paths_from_root:
             pl = p.lower()
             if kn not in pl:
                 continue
 
-            # Use path directly since it's already relative to current directory
-            rel_to_cwd = p.lstrip("./")
-            base = os.path.basename(p).lower()
+            # Most tools return paths relative to cwd. Some include a leading
+            # './' prefix; strip that exact prefix only.
+            #
+            # Do not use lstrip('./') here: it would also remove the leading '.'
+            # from dotfiles/directories like '.claude/'.
+            rel_to_cwd = p.removeprefix("./").removeprefix(".\\")
+            base = os.path.basename(rel_to_cwd.rstrip("/")).lower()
             base_pos = base.find(kn)
             path_pos = pl.find(kn)
-            # Check if this path is in the ignored set (gitignored files)
-            is_ignored = 1 if rel_to_cwd in ignored_paths else 0
             score = (
-                is_ignored,
                 0 if base_pos != -1 else 1,
                 base_pos if base_pos != -1 else 10_000,
                 path_pos,
                 len(p),
             )
 
-            # Append trailing slash for directories
-            full_path = cwd / rel_to_cwd
-            if full_path.is_dir() and not rel_to_cwd.endswith("/"):
-                rel_to_cwd = rel_to_cwd + "/"
             out.append((rel_to_cwd, score))
         # Sort by score
         out.sort(key=lambda x: x[1])
@@ -336,6 +386,19 @@ class _AtFilesCompleter(Completer):
             if s not in seen:
                 seen.add(s)
                 uniq.append(s)
+
+        # Append trailing slash for directories, but avoid excessive stats.
+        # For large candidate lists, only stat the most relevant prefixes.
+        stat_limit = min(len(uniq), max(self._max_results * 3, 60))
+        for idx in range(stat_limit):
+            s = uniq[idx]
+            if s.endswith("/"):
+                continue
+            try:
+                if (cwd / s).is_dir():
+                    uniq[idx] = f"{s}/"
+            except Exception:
+                continue
         return uniq
 
     def _format_completion_text(self, suggestion: str, *, is_quoted: bool) -> str:
@@ -371,15 +434,13 @@ class _AtFilesCompleter(Completer):
             return None, None
 
     # ---- Utilities ----
-    def _run_fd_search(self, cwd: Path, keyword_norm: str) -> tuple[list[str], set[str]]:
-        """Run fd search and return (all_results, ignored_paths).
+    def _run_fd_search(self, cwd: Path, keyword_norm: str, *, max_results: int) -> tuple[list[str], bool]:
+        """Run fd search and return (results, truncated).
 
-        First runs fd without --no-ignore to get tracked files,
-        then runs with --no-ignore to get all files including gitignored ones.
-        Returns the combined results and a set of paths that are gitignored.
+        Note: This is called in the prompt_toolkit completion path, so avoid
+        doing extra background scans here.
         """
-        pattern = self._escape_regex(keyword_norm)
-        base_cmd = [
+        cmd = [
             "fd",
             "--color=never",
             "--type",
@@ -389,36 +450,115 @@ class _AtFilesCompleter(Completer):
             "--hidden",
             "--full-path",
             "-i",
+            "-F",
             "--max-results",
-            str(self._max_results * 3),
+            str(max_results),
             "--exclude",
             ".git",
             "--exclude",
             ".venv",
             "--exclude",
             "node_modules",
-            pattern,
+            keyword_norm,
             ".",
         ]
 
-        # First run: get tracked (non-ignored) files
-        r_tracked = self._run_cmd(base_cmd, cwd=cwd)
-        tracked_paths: set[str] = set(p.lstrip("./") for p in r_tracked.lines) if r_tracked.ok else set()
+        r = self._run_cmd(cmd, cwd=cwd, timeout_sec=self._cmd_timeout_sec)
+        lines = r.lines if r.ok else []
+        return lines, (len(lines) >= max_results)
+
+    def _git_paths_for_keyword(self, cwd: Path, keyword_norm: str, *, max_results: int) -> tuple[list[str], bool]:
+        """Get path suggestions from the git index (fast for large repos).
+
+        Returns (candidates, truncated). "truncated" is True when we
+        intentionally stop early to keep per-keystroke costs bounded.
+        """
+        repo_root = self._get_git_repo_root(cwd)
+        if repo_root is None:
+            return [], False
+
+        now = time.monotonic()
+        git_cache_ttl = max(self._cache_ttl, 30.0)
+        if (
+            self._git_file_list is None
+            or self._git_file_list_cwd != cwd
+            or now - self._git_file_list_time > git_cache_ttl
+        ):
+            cmd = ["git", "ls-files", "-co", "--exclude-standard"]
+            r = self._run_cmd(cmd, cwd=repo_root, timeout_sec=self._cmd_timeout_sec)
+            if not r.ok:
+                self._git_file_list = []
+                self._git_file_list_lower = []
+                self._git_file_list_time = now
+                self._git_file_list_cwd = cwd
+            else:
+                cwd_resolved = cwd.resolve()
+                root_resolved = repo_root.resolve()
+                files: list[str] = []
+                files_lower: list[str] = []
+                for rel in r.lines:
+                    abs_path = root_resolved / rel
+                    try:
+                        rel_to_cwd = abs_path.relative_to(cwd_resolved)
+                    except ValueError:
+                        continue
+                    rel_posix = rel_to_cwd.as_posix()
+                    files.append(rel_posix)
+                    files_lower.append(rel_posix.lower())
+                self._git_file_list = files
+                self._git_file_list_lower = files_lower
+                self._git_file_list_time = now
+                self._git_file_list_cwd = cwd
+
+        all_files = self._git_file_list or []
+        all_files_lower = self._git_file_list_lower or []
+        kn = keyword_norm
 
-        # Second run: get all files including ignored ones
-        cmd_all = base_cmd.copy()
-        cmd_all.insert(2, "--no-ignore")  # Insert after --color=never
-        r_all = self._run_cmd(cmd_all, cwd=cwd)
-        all_paths = r_all.lines if r_all.ok else []
+        # Bound per-keystroke work: stop scanning once enough matches are found.
+        matching_files: list[str] = []
+        scan_truncated = False
+        for p, pl in zip(all_files, all_files_lower, strict=False):
+            if kn in pl:
+                matching_files.append(p)
+                if len(matching_files) >= max_results:
+                    scan_truncated = True
+                    break
+
+        # Also include parent directories of matching files so users can
+        # complete into a folder, similar to fd's directory results.
+        dir_candidates: set[str] = set()
+        for p in matching_files[: max_results * 3]:
+            parent = os.path.dirname(p)
+            while parent and parent != ".":
+                dir_candidates.add(f"{parent}/")
+                parent = os.path.dirname(parent)
+
+        dir_list = sorted(dir_candidates)
+        dir_truncated = False
+        if len(dir_list) > max_results:
+            dir_list = dir_list[:max_results]
+            dir_truncated = True
+
+        candidates = matching_files + dir_list
+        truncated = scan_truncated or dir_truncated
+        return candidates, truncated
+
+    def _get_git_repo_root(self, cwd: Path) -> Path | None:
+        if not self._has_cmd("git"):
+            return None
 
-        # Calculate which paths are gitignored (in all but not in tracked)
-        ignored_paths = set(p.lstrip("./") for p in all_paths) - tracked_paths
+        now = time.monotonic()
+        ttl = max(self._cache_ttl, 30.0)
+        if self._git_repo_root_cwd == cwd and now - self._git_repo_root_time < ttl:
+            return self._git_repo_root
 
-        return all_paths, ignored_paths
+        r = self._run_cmd(["git", "rev-parse", "--show-toplevel"], cwd=cwd, timeout_sec=0.5)
+        root = Path(r.lines[0]) if r.ok and r.lines else None
 
-    def _escape_regex(self, s: str) -> str:
-        # Escape for fd (regex by default). Keep '/' as is for path boundaries.
-        return re.escape(s).replace("/", "/")
+        self._git_repo_root = root
+        self._git_repo_root_time = now
+        self._git_repo_root_cwd = cwd
+        return root
 
     def _has_cmd(self, name: str) -> bool:
         return shutil.which(name) is not None
@@ -444,7 +584,7 @@ class _AtFilesCompleter(Completer):
             return []
         return items[: min(self._max_results, 100)]
 
-    def _run_cmd(self, cmd: list[str], cwd: Path | None = None) -> _CmdResult:
+    def _run_cmd(self, cmd: list[str], cwd: Path | None = None, *, timeout_sec: float) -> _CmdResult:
         cmd_str = " ".join(cmd)
         start = time.monotonic()
         try:
@@ -454,7 +594,7 @@ class _AtFilesCompleter(Completer):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.DEVNULL,
                 text=True,
-                timeout=1.5,
+                timeout=timeout_sec,
             )
             elapsed_ms = (time.monotonic() - start) * 1000
             if p.returncode == 0:

klaude_code/ui/modes/repl/event_handler.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 
 from rich.text import Text
@@ -14,7 +13,6 @@ from klaude_code.ui.rich.markdown import MarkdownStream, ThinkingMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
 from klaude_code.ui.terminal.notifier import Notification, NotificationType, TerminalNotifier
 from klaude_code.ui.terminal.progress_bar import OSC94States, emit_osc94
-from klaude_code.ui.utils.debouncer import Debouncer
 
 
 @dataclass
@@ -43,13 +41,8 @@ class StreamState:
     This design ensures buffer and mdstream are always in sync.
     """
 
-    def __init__(self, interval: float, flush_handler: Callable[[StreamState], Awaitable[None]]):
+    def __init__(self) -> None:
         self._active: ActiveStream | None = None
-        self._flush_handler = flush_handler
-        self.debouncer = Debouncer(interval=interval, callback=self._debounced_flush)
-
-    async def _debounced_flush(self) -> None:
-        await self._flush_handler(self)
 
     @property
     def is_active(self) -> bool:
@@ -218,12 +211,8 @@ class DisplayEventHandler:
     def __init__(self, renderer: REPLRenderer, notifier: TerminalNotifier | None = None):
         self.renderer = renderer
         self.notifier = notifier
-        self.assistant_stream = StreamState(
-            interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_assistant_buffer
-        )
-        self.thinking_stream = StreamState(
-            interval=1 / const.UI_REFRESH_RATE_FPS, flush_handler=self._flush_thinking_buffer
-        )
+        self.assistant_stream = StreamState()
+        self.thinking_stream = StreamState()
         self.spinner_status = SpinnerStatusState()
 
         self.stage_manager = StageManager(
@@ -280,10 +269,8 @@ class DisplayEventHandler:
                 await self._on_end(e)
 
     async def stop(self) -> None:
-        await self.assistant_stream.debouncer.flush()
-        self.assistant_stream.debouncer.cancel()
-        await self.thinking_stream.debouncer.flush()
-        self.thinking_stream.debouncer.cancel()
+        await self._flush_assistant_buffer(self.assistant_stream)
+        await self._flush_thinking_buffer(self.thinking_stream)
 
     # ─────────────────────────────────────────────────────────────────────────────
     # Private event handlers
@@ -352,7 +339,7 @@ class DisplayEventHandler:
             self.thinking_stream.mdstream.update(normalize_thinking_content(self.thinking_stream.buffer))
 
         await self.stage_manager.enter_thinking_stage()
-        self.thinking_stream.debouncer.schedule()
+        await self._flush_thinking_buffer(self.thinking_stream)
 
     async def _on_assistant_delta(self, event: events.AssistantMessageDeltaEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
@@ -383,14 +370,13 @@ class DisplayEventHandler:
             self.renderer.spinner_stop()
             self.assistant_stream.mdstream.update(self.assistant_stream.buffer)
         await self.stage_manager.transition_to(Stage.ASSISTANT)
-        self.assistant_stream.debouncer.schedule()
+        await self._flush_assistant_buffer(self.assistant_stream)
 
     async def _on_assistant_message(self, event: events.AssistantMessageEvent) -> None:
         if self.renderer.is_sub_agent_session(event.session_id):
             return
         await self.stage_manager.transition_to(Stage.ASSISTANT)
         if self.assistant_stream.is_active:
-            self.assistant_stream.debouncer.cancel()
             mdstream = self.assistant_stream.mdstream
             assert mdstream is not None
             mdstream.update(event.content.strip(), final=True)
@@ -474,7 +460,6 @@ class DisplayEventHandler:
 
     async def _finish_assistant_stream(self) -> None:
         if self.assistant_stream.is_active:
-            self.assistant_stream.debouncer.cancel()
             mdstream = self.assistant_stream.mdstream
             assert mdstream is not None
             mdstream.update(self.assistant_stream.buffer, final=True)
@@ -504,7 +489,6 @@ class DisplayEventHandler:
 
     async def _finish_thinking_stream(self) -> None:
         if self.thinking_stream.is_active:
-            self.thinking_stream.debouncer.cancel()
             mdstream = self.thinking_stream.mdstream
             assert mdstream is not None
             mdstream.update(normalize_thinking_content(self.thinking_stream.buffer), final=True)

klaude_code/ui/modes/repl/input_prompt_toolkit.py

@@ -44,12 +44,10 @@ class PromptToolkitInput(InputProviderABC):
         self._status_provider = status_provider
 
         project = str(Path.cwd()).strip("/").replace("/", "-")
-        history_path = Path.home() / ".klaude" / "projects" / f"{project}" / "input_history.txt"
+        history_path = Path.home() / ".klaude" / "projects" / project / "input" / "input_history.txt"
 
-        if not history_path.parent.exists():
-            history_path.parent.mkdir(parents=True, exist_ok=True)
-        if not history_path.exists():
-            history_path.touch()
+        history_path.parent.mkdir(parents=True, exist_ok=True)
+        history_path.touch(exist_ok=True)
 
         # Create key bindings with injected dependencies
         kb = create_key_bindings(
@@ -60,7 +58,7 @@ class PromptToolkitInput(InputProviderABC):
 
         self._session: PromptSession[str] = PromptSession(
             [(INPUT_PROMPT_STYLE, prompt)],
-            history=FileHistory(history_path),
+            history=FileHistory(str(history_path)),
             multiline=True,
             prompt_continuation=[(INPUT_PROMPT_STYLE, "  ")],
             key_bindings=kb,
@@ -144,7 +142,7 @@ class PromptToolkitInput(InputProviderABC):
 
         # Build result with style
         toolbar_text = left_text + padding + right_text
-        return FormattedText([("#ansiblue", toolbar_text)])
+        return FormattedText([("#2c7eac", toolbar_text)])
 
     async def start(self) -> None:
         pass

klaude_code/ui/modes/repl/renderer.py

@@ -22,11 +22,11 @@ from klaude_code.ui.renderers import sub_agent as r_sub_agent
 from klaude_code.ui.renderers import thinking as r_thinking
 from klaude_code.ui.renderers import tools as r_tools
 from klaude_code.ui.renderers import user_input as r_user_input
+from klaude_code.ui.renderers.common import truncate_display
 from klaude_code.ui.rich import status as r_status
 from klaude_code.ui.rich.quote import Quote
 from klaude_code.ui.rich.status import ShimmerStatusText
 from klaude_code.ui.rich.theme import ThemeKey, get_theme
-from klaude_code.ui.utils.common import truncate_display
 
 
 @dataclass
@@ -244,7 +244,7 @@ class REPLRenderer:
     def display_error(self, event: events.ErrorEvent) -> None:
         self.print(
             r_errors.render_error(
-                self.console.render_str(truncate_display(event.error_message)),
+                truncate_display(event.error_message),
                 indent=0,
             )
         )

klaude_code/ui/renderers/common.py

@@ -1,4 +1,9 @@
+from rich.style import Style
 from rich.table import Table
+from rich.text import Text
+
+from klaude_code import const
+from klaude_code.ui.rich.theme import ThemeKey
 
 
 def create_grid() -> Table:
@@ -6,3 +11,52 @@ def create_grid() -> Table:
     grid.add_column(no_wrap=True)
     grid.add_column(overflow="fold")
     return grid
+
+
+def truncate_display(
+    text: str,
+    max_lines: int = const.TRUNCATE_DISPLAY_MAX_LINES,
+    max_line_length: int = const.TRUNCATE_DISPLAY_MAX_LINE_LENGTH,
+    *,
+    base_style: str | Style | None = None,
+) -> Text:
+    """Truncate long text for terminal display.
+
+    Applies `ThemeKey.TOOL_RESULT_TRUNCATED` style to truncation indicators.
+    """
+
+    if max_lines <= 0:
+        truncated_lines = text.split("\n")
+        remaining = max(0, len(truncated_lines))
+        return Text(f"… (more {remaining} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED)
+
+    lines = text.split("\n")
+    extra_lines = 0
+    if len(lines) > max_lines:
+        extra_lines = len(lines) - max_lines
+        lines = lines[:max_lines]
+
+    out = Text()
+    if base_style is not None:
+        out.style = base_style
+
+    for idx, line in enumerate(lines):
+        if len(line) > max_line_length:
+            extra_chars = len(line) - max_line_length
+            out.append(line[:max_line_length])
+            out.append_text(
+                Text(
+                    f" … (more {extra_chars} characters in this line)",
+                    style=ThemeKey.TOOL_RESULT_TRUNCATED,
+                )
+            )
+        else:
+            out.append(line)
+
+        if idx != len(lines) - 1 or extra_lines > 0:
+            out.append("\n")
+
+    if extra_lines > 0:
+        out.append_text(Text(f"… (more {extra_lines} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+
+    return out

klaude_code/ui/renderers/developer.py

@@ -5,11 +5,10 @@ from rich.text import Text
 
 from klaude_code.protocol import commands, events, model
 from klaude_code.ui.renderers import diffs as r_diffs
-from klaude_code.ui.renderers.common import create_grid
+from klaude_code.ui.renderers.common import create_grid, truncate_display
 from klaude_code.ui.renderers.tools import render_path
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
 from klaude_code.ui.rich.theme import ThemeKey
-from klaude_code.ui.utils.common import truncate_display
 
 
 def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
@@ -117,7 +116,7 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
         case _:
             content = e.item.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.item.command_output.is_error else ThemeKey.ERROR
-            return Padding.indent(Text(truncate_display(content), style=style), level=2)
+            return Padding.indent(truncate_display(content, base_style=style), level=2)
 
 
 def _format_tokens(tokens: int) -> str:

klaude_code/ui/renderers/errors.py

@@ -11,6 +11,6 @@ def render_error(error_msg: Text, indent: int = 2) -> RenderableType:
     Shows a two-column grid with an error mark and truncated message.
     """
     grid = create_grid()
-    error_msg.stylize(ThemeKey.ERROR)
+    error_msg.style = ThemeKey.ERROR
     grid.add_row(Text(" " * indent + "✘", style=ThemeKey.ERROR_BOLD), error_msg)
     return grid

klaude_code/ui/renderers/metadata.py

@@ -108,7 +108,16 @@ def _render_task_metadata_block(
             parts.append(
                 Text.assemble(
                     (f"{metadata.usage.throughput_tps:.1f} ", ThemeKey.METADATA),
-                    ("tps", ThemeKey.METADATA_DIM),
+                    ("avg-tps", ThemeKey.METADATA_DIM),
+                )
+            )
+
+        # First token latency
+        if metadata.usage.first_token_latency_ms is not None:
+            parts.append(
+                Text.assemble(
+                    (f"{metadata.usage.first_token_latency_ms:.0f}", ThemeKey.METADATA),
+                    ("ms avg-ftl", ThemeKey.METADATA_DIM),
                 )
             )