klaude-code 2.6.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

klaude_code/tui/input/key_bindings.py

@@ -7,8 +7,13 @@ with dependencies injected to avoid circular imports.
 from __future__ import annotations
 
 import contextlib
+import os
 import re
+import shutil
+import subprocess
+import sys
 from collections.abc import Callable
+from pathlib import Path
 from typing import cast
 
 from prompt_toolkit.application.current import get_app
@@ -17,11 +22,39 @@ from prompt_toolkit.filters import Always, Condition, 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
+from prompt_toolkit.keys import Keys
+
+from klaude_code.tui.input.drag_drop import convert_dropped_text
+from klaude_code.tui.input.paste import expand_paste_markers, store_paste
+
+
+def copy_to_clipboard(text: str) -> None:
+    """Copy text to system clipboard using platform-specific commands."""
+    try:
+        if sys.platform == "darwin":
+            subprocess.run(["pbcopy"], input=text.encode("utf-8"), check=True)
+        elif sys.platform == "win32":
+            subprocess.run(["clip"], input=text.encode("utf-16"), check=True)
+        else:
+            # Linux: try xclip first, then xsel
+            if shutil.which("xclip"):
+                subprocess.run(
+                    ["xclip", "-selection", "clipboard"],
+                    input=text.encode("utf-8"),
+                    check=True,
+                )
+            elif shutil.which("xsel"):
+                subprocess.run(
+                    ["xsel", "--clipboard", "--input"],
+                    input=text.encode("utf-8"),
+                    check=True,
+                )
+    except (OSError, subprocess.SubprocessError):
+        pass
 
 
 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,
@@ -31,8 +64,7 @@ def create_key_bindings(
     """Create REPL key bindings with injected dependencies.
 
     Args:
-        capture_clipboard_tag: Callable to capture clipboard image and return tag
-        copy_to_clipboard: Callable to copy text to system clipboard
+        capture_clipboard_tag: Callable to capture clipboard image and return [image ...] marker
         at_token_pattern: Pattern to match @token for completion refresh
 
     Returns:
@@ -41,6 +73,51 @@ def create_key_bindings(
     kb = KeyBindings()
     enabled = input_enabled if input_enabled is not None else Always()
 
+    term_program = os.environ.get("TERM_PROGRAM", "").lower()
+    swallow_next_control_j = False
+
+    def _data_requests_newline(data: str) -> bool:
+        """Return True when incoming key data should insert a newline.
+
+        Different terminals and editor-integrated terminals can emit different
+        sequences for Shift+Enter/Alt+Enter. We treat these as "insert newline"
+        instead of "submit".
+        """
+
+        if not data:
+            return False
+
+        # Pure LF or LF-prefixed sequences (e.g. when modifiers are encoded).
+        if data == "\n" or (ord(data[0]) == 10 and len(data) > 1):
+            return True
+
+        # Known escape sequences observed in some terminals.
+        if data in {
+            "\x1b\r",  # Alt+Enter (ESC + CR)
+            "\x1b[13;2~",  # Shift+Enter (some terminals)
+            "\x1b[27;2;13~",  # Shift+Enter (xterm "CSI 27" modified keys)
+            "\\\r",  # Backslash+Enter sentinel (some editor terminals)
+        }:
+            return True
+
+        # Any payload that contains both ESC and CR.
+        return len(data) > 1 and "\x1b" in data and "\r" in data
+
+    def _insert_newline(event: KeyPressEvent, *, strip_trailing_backslash: bool = False) -> None:
+        buf = event.current_buffer
+        if strip_trailing_backslash:
+            try:
+                doc = buf.document  # type: ignore[reportUnknownMemberType]
+                if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
+                    buf.delete_before_cursor()  # type: ignore[reportUnknownMemberType]
+            except Exception:
+                pass
+
+        with contextlib.suppress(Exception):
+            buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
+        with contextlib.suppress(Exception):
+            event.app.invalidate()  # type: ignore[reportUnknownMemberType]
+
     def _can_move_cursor_visually_within_wrapped_line(delta_visible_y: int) -> bool:
         """Return True when Up/Down should move within a wrapped visual line.
 
@@ -233,28 +310,85 @@ def create_key_bindings(
 
     @kb.add("c-v", filter=enabled)
     def _(event: KeyPressEvent) -> None:
-        """Paste image from clipboard as [Image #N]."""
-        tag = capture_clipboard_tag()
-        if tag:
+        """Paste image from clipboard as an `[image ...]` marker."""
+        marker = capture_clipboard_tag()
+        if marker:
             with contextlib.suppress(Exception):
-                event.current_buffer.insert_text(tag)  # pyright: ignore[reportUnknownMemberType]
+                event.current_buffer.insert_text(marker)  # pyright: ignore[reportUnknownMemberType]
+
+    @kb.add(Keys.BracketedPaste, filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        """Handle bracketed paste.
+
+        - Large multi-line pastes are folded into a marker: `[paste #N ...]`.
+        - Otherwise, try to convert dropped file URLs/paths into @ tokens or `[image ...]` markers.
+        """
+
+        data = getattr(event, "data", "")
+        if not isinstance(data, str) or not data:
+            return
+
+        pasted_lines = data.splitlines()
+        line_count = max(1, len(pasted_lines))
+        total_chars = len(data)
+
+        should_fold = line_count > 10 or total_chars > 1000
+        if should_fold:
+            marker = store_paste(data)
+            if marker and not marker.endswith((" ", "\t", "\n")):
+                marker += " "
+            with contextlib.suppress(Exception):
+                event.current_buffer.insert_text(marker)  # pyright: ignore[reportUnknownMemberType]
+            return
+
+        converted = convert_dropped_text(data, cwd=Path.cwd())
+        if converted != data and converted and not converted.endswith((" ", "\t", "\n")):
+            converted += " "
+
+        buf = event.current_buffer
+        try:
+            if buf.selection_state:  # type: ignore[reportUnknownMemberType]
+                buf.cut_selection()  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            pass
+
+        with contextlib.suppress(Exception):
+            buf.insert_text(converted)  # type: ignore[reportUnknownMemberType]
+
+    @kb.add("escape", "enter", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        """Alt+Enter inserts a newline."""
+
+        _insert_newline(event)
+
+    @kb.add("escape", "[", "1", "3", ";", "2", "~", filter=enabled)
+    def _(event: KeyPressEvent) -> None:
+        """Shift+Enter sequence used by some terminals inserts a newline."""
+
+        _insert_newline(event)
 
     @kb.add("enter", filter=enabled)
     def _(event: KeyPressEvent) -> None:
+        nonlocal swallow_next_control_j
+
         buf = event.current_buffer
         doc = buf.document  # type: ignore
 
-        # If VS Code/Windsurf/Cursor sent a "\\" sentinel before Enter (Shift+Enter mapping),
-        # treat it as a request for a newline instead of submit.
-        # This allows Shift+Enter to insert a newline in our multiline prompt.
-        try:
-            if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
-                buf.delete_before_cursor()  # remove the sentinel backslash  # type: ignore[reportUnknownMemberType]
-                buf.insert_text("\n")  # type: ignore[reportUnknownMemberType]
-                return
-        except (AttributeError, TypeError):
-            # Fall through to default behavior if anything goes wrong
-            pass
+        data = getattr(event, "data", "")
+        if isinstance(data, str) and _data_requests_newline(data):
+            _insert_newline(event)
+            return
+
+        # VS Code-family terminals often implement Shift+Enter via a "\\" sentinel
+        # before Enter. Only enable this heuristic under TERM_PROGRAM=vscode.
+        if term_program == "vscode":
+            try:
+                if doc.text_before_cursor.endswith("\\"):  # type: ignore[reportUnknownMemberType]
+                    swallow_next_control_j = True
+                    _insert_newline(event, strip_trailing_backslash=True)
+                    return
+            except (AttributeError, TypeError):
+                pass
 
         # When completions are visible, Enter accepts the current selection.
         # This aligns with common TUI completion UX: navigation doesn't modify
@@ -262,6 +396,21 @@ def create_key_bindings(
         if not _should_submit_instead_of_accepting_completion(buf) and _accept_current_completion(buf):
             return
 
+        # Before submitting, expand any folded paste markers so that:
+        # - the actual request contains the full pasted content
+        # - prompt_toolkit history stores the expanded content
+        # Also convert any remaining file:// drops that bypassed bracketed paste.
+        try:
+            current_text = buf.text  # type: ignore[reportUnknownMemberType]
+        except Exception:
+            current_text = ""
+        prepared = expand_paste_markers(current_text)
+        prepared = convert_dropped_text(prepared, cwd=Path.cwd())
+        if prepared != current_text:
+            with contextlib.suppress(Exception):
+                buf.text = prepared  # type: ignore[reportUnknownMemberType]
+                buf.cursor_position = len(prepared)  # type: ignore[reportUnknownMemberType]
+
         # If the entire buffer is whitespace-only, insert a newline rather than submitting.
         if len(buf.text.strip()) == 0:  # type: ignore
             buf.insert_text("\n")  # type: ignore
@@ -310,6 +459,11 @@ def create_key_bindings(
 
     @kb.add("c-j", filter=enabled)
     def _(event: KeyPressEvent) -> None:
+        nonlocal swallow_next_control_j
+        if swallow_next_control_j:
+            swallow_next_control_j = False
+            return
+
         event.current_buffer.insert_text("\n")  # type: ignore
 
     @kb.add("c", filter=enabled)
@@ -322,7 +476,7 @@ def create_key_bindings(
             selected_text: str = doc.text[start:end]  # type: ignore[reportUnknownMemberType]
 
             if selected_text:
-                copy_to_clipboard(selected_text)  # type: ignore[reportUnknownArgumentType]
+                copy_to_clipboard(selected_text)
             buf.exit_selection()  # type: ignore[reportUnknownMemberType]
         else:
             buf.insert_text("c")  # type: ignore[reportUnknownMemberType]
@@ -424,4 +578,14 @@ def create_key_bindings(
             with contextlib.suppress(Exception):
                 open_thinking_picker()
 
+    @kb.add("escape", "up", filter=enabled & ~has_completions)
+    def _(event: KeyPressEvent) -> None:
+        """Option+Up switches to previous history entry."""
+        event.current_buffer.history_backward()
+
+    @kb.add("escape", "down", filter=enabled & ~has_completions)
+    def _(event: KeyPressEvent) -> None:
+        """Option+Down switches to next history entry."""
+        event.current_buffer.history_forward()
+
     return kb

klaude_code/tui/input/paste.py

@@ -0,0 +1,71 @@
+"""Fold large multi-line pastes into a short marker.
+
+prompt_toolkit already parses terminal bracketed paste mode and exposes the
+pasted payload via a `<bracketed-paste>` key event.
+
+We keep the editor buffer small by inserting a marker like:
+- `[paste #3 +42 lines]`  (when many lines)
+- `[paste #3 1205 chars]` (when very long)
+
+On submit, markers are expanded back to the original pasted content.
+"""
+
+from __future__ import annotations
+
+import re
+
+_PASTE_MARKER_RE = re.compile(r"\[paste #(?P<id>\d+)(?: (?P<meta>\+\d+ lines|\d+ chars))?\]")
+
+
+class PasteBufferState:
+    def __init__(self) -> None:
+        self._next_id = 1
+        self._pastes: dict[int, str] = {}
+
+    def store(self, text: str) -> str:
+        paste_id = self._next_id
+        self._next_id += 1
+
+        lines = text.splitlines()
+        line_count = max(1, len(lines))
+        total_chars = len(text)
+
+        if line_count > 10:
+            marker = f"[paste #{paste_id} +{line_count} lines]"
+        else:
+            marker = f"[paste #{paste_id} {total_chars} chars]"
+
+        self._pastes[paste_id] = text
+        return marker
+
+    def expand_markers(self, text: str) -> str:
+        used: set[int] = set()
+
+        def _replace(m: re.Match[str]) -> str:
+            try:
+                paste_id = int(m.group("id"))
+            except (TypeError, ValueError):
+                return m.group(0)
+
+            content = self._pastes.get(paste_id)
+            if content is None:
+                return m.group(0)
+
+            used.add(paste_id)
+            return content
+
+        out = _PASTE_MARKER_RE.sub(_replace, text)
+        for pid in used:
+            self._pastes.pop(pid, None)
+        return out
+
+
+paste_state = PasteBufferState()
+
+
+def store_paste(text: str) -> str:
+    return paste_state.store(text)
+
+
+def expand_paste_markers(text: str) -> str:
+    return paste_state.expand_markers(text)

klaude_code/tui/input/prompt_toolkit.py

@@ -36,9 +36,14 @@ from klaude_code.protocol import llm_param
 from klaude_code.protocol.commands import CommandInfo
 from klaude_code.protocol.message import UserInputPayload
 from klaude_code.tui.components.user_input import USER_MESSAGE_MARK
-from klaude_code.tui.input.clipboard import capture_clipboard_tag, copy_to_clipboard, extract_images_from_text
 from klaude_code.tui.input.completers import AT_TOKEN_PATTERN, create_repl_completer
+from klaude_code.tui.input.drag_drop import convert_dropped_text
+from klaude_code.tui.input.images import (
+    capture_clipboard_tag,
+    extract_images_from_text,
+)
 from klaude_code.tui.input.key_bindings import create_key_bindings
+from klaude_code.tui.input.paste import expand_paste_markers
 from klaude_code.tui.terminal.color import is_light_terminal_background
 from klaude_code.tui.terminal.selector import SelectItem, SelectOverlay, build_model_select_items
 from klaude_code.ui.core.input import InputProviderABC
@@ -48,6 +53,7 @@ class REPLStatusSnapshot(NamedTuple):
     """Snapshot of REPL status for bottom toolbar display."""
 
     update_message: str | None = None
+    debug_log_path: str | None = None
 
 
 COMPLETION_SELECTED_DARK_BG = "ansigreen"
@@ -271,7 +277,6 @@ class PromptToolkitInput(InputProviderABC):
 
         kb = create_key_bindings(
             capture_clipboard_tag=capture_clipboard_tag,
-            copy_to_clipboard=copy_to_clipboard,
             at_token_pattern=AT_TOKEN_PATTERN,
             input_enabled=input_enabled,
             open_model_picker=self._open_model_picker,
@@ -333,7 +338,7 @@ class PromptToolkitInput(InputProviderABC):
             pointer="→",
             use_search_filter=True,
             search_placeholder="type to search",
-            list_height=10,
+            list_height=20,
             on_select=self._handle_model_selected,
         )
         self._model_picker = model_picker
@@ -430,7 +435,7 @@ class PromptToolkitInput(InputProviderABC):
                 original_height_int = original_height_value if isinstance(original_height_value, int) else None
 
                 if picker_open or completion_open:
-                    target_rows = 20 if picker_open else 14
+                    target_rows = 24 if picker_open else 14
 
                     # Cap to the current terminal size.
                     # Leave a small buffer to avoid triggering "Window too small".
@@ -527,7 +532,7 @@ class PromptToolkitInput(InputProviderABC):
             return [], None
 
         items: list[SelectItem[str]] = [
-            SelectItem(title=[("class:text", opt.label + "\n")], value=opt.value, search_text=opt.label)
+            SelectItem(title=[("class:msg", opt.label + "\n")], value=opt.value, search_text=opt.label)
             for opt in data.options
         ]
         return items, data.current_value
@@ -569,24 +574,36 @@ class PromptToolkitInput(InputProviderABC):
         doing any blocking IO here.
         """
         update_message: str | None = None
+        debug_log_path: str | None = None
         if self._status_provider is not None:
             try:
                 status = self._status_provider()
                 update_message = status.update_message
+                debug_log_path = status.debug_log_path
             except (AttributeError, RuntimeError):
-                update_message = None
+                pass
+
+        # Priority: update_message > debug_log_path
+        display_text: str | None = None
+        text_style: str = ""
+        if update_message:
+            display_text = update_message
+            text_style = "#ansiyellow"
+        elif debug_log_path:
+            display_text = f"Debug log: {debug_log_path}"
+            text_style = "fg:ansibrightblack"
 
         # If nothing to show, return a blank line to actively clear any previously
         # rendered content. (When `bottom_toolbar` is a callable, prompt_toolkit
         # will still reserve the toolbar line.)
-        if not update_message:
+        if not display_text:
             try:
                 terminal_width = shutil.get_terminal_size().columns
             except (OSError, ValueError):
                 terminal_width = 0
             return FormattedText([("", " " * max(0, terminal_width))])
 
-        left_text = " " + update_message
+        left_text = " " + display_text
         try:
             terminal_width = shutil.get_terminal_size().columns
             padding = " " * max(0, terminal_width - len(left_text))
@@ -594,7 +611,7 @@ class PromptToolkitInput(InputProviderABC):
             padding = ""
 
         toolbar_text = left_text + padding
-        return FormattedText([("#ansiyellow", toolbar_text)])
+        return FormattedText([(text_style, toolbar_text)])
 
     # -------------------------------------------------------------------------
     # Placeholder
@@ -669,6 +686,12 @@ class PromptToolkitInput(InputProviderABC):
                 with contextlib.suppress(Exception):
                     self._post_prompt()
 
+            # Expand folded paste markers back into the original content.
+            line = expand_paste_markers(line)
+
+            # Convert drag-and-drop file:// URIs that may have bypassed bracketed paste.
+            line = convert_dropped_text(line, cwd=Path.cwd())
+
             # Extract images referenced in the input text
             images = extract_images_from_text(line)
 

klaude_code/tui/machine.py

@@ -6,6 +6,7 @@ from rich.text import Text
 
 from klaude_code.const import (
     SIGINT_DOUBLE_PRESS_EXIT_TEXT,
+    STATUS_COMPACTING_TEXT,
     STATUS_COMPOSING_TEXT,
     STATUS_DEFAULT_TEXT,
     STATUS_SHOW_BUFFER_LENGTH,
@@ -24,6 +25,7 @@ from klaude_code.tui.commands import (
     RenderAssistantImage,
     RenderCommand,
     RenderCommandOutput,
+    RenderCompactionSummary,
     RenderDeveloperMessage,
     RenderError,
     RenderInterrupt,
@@ -160,7 +162,7 @@ class ActivityState:
             if self._sub_agent_tool_calls:
                 _append_counts(self._sub_agent_tool_calls)
                 if self._tool_calls:
-                    activity_text.append(" , ")
+                    activity_text.append(", ")
 
             if self._tool_calls:
                 _append_counts(self._tool_calls)
@@ -311,6 +313,7 @@ class _SessionState:
     thinking_stream_active: bool = False
     assistant_char_count: int = 0
     thinking_tail: str = ""
+    task_active: bool = False
 
     @property
     def is_sub_agent(self) -> bool:
@@ -414,6 +417,7 @@ class DisplayStateMachine:
             case events.TaskStartEvent() as e:
                 s.sub_agent_state = e.sub_agent_state
                 s.model_id = e.model_id
+                s.task_active = True
                 if not s.is_sub_agent:
                     self._set_primary_if_needed(e.session_id)
                     if not is_replay:
@@ -428,6 +432,25 @@ class DisplayStateMachine:
                     cmds.extend(self._spinner_update_commands())
                 return cmds
 
+            case events.CompactionStartEvent():
+                if not is_replay:
+                    self._spinner.set_reasoning_status(STATUS_COMPACTING_TEXT)
+                    if not s.task_active:
+                        cmds.append(SpinnerStart())
+                    cmds.extend(self._spinner_update_commands())
+                return cmds
+
+            case events.CompactionEndEvent() as e:
+                if not is_replay:
+                    self._spinner.set_reasoning_status(None)
+                    if not s.task_active:
+                        cmds.append(SpinnerStop())
+                    cmds.extend(self._spinner_update_commands())
+                if e.summary and not e.aborted:
+                    kept_brief = tuple((item.item_type, item.count, item.preview) for item in e.kept_items_brief)
+                    cmds.append(RenderCompactionSummary(summary=e.summary, kept_items_brief=kept_brief))
+                return cmds
+
             case events.DeveloperMessageEvent() as e:
                 cmds.append(RenderDeveloperMessage(e))
                 return cmds
@@ -650,6 +673,7 @@ class DisplayStateMachine:
                 return []
 
             case events.TaskFinishEvent() as e:
+                s.task_active = False
                 cmds.append(RenderTaskFinish(e))
                 if not s.is_sub_agent:
                     if not is_replay:
@@ -666,6 +690,7 @@ class DisplayStateMachine:
                 if not is_replay:
                     self._spinner.reset()
                     cmds.append(SpinnerStop())
+                s.task_active = False
                 cmds.append(EndThinkingStream(session_id=e.session_id))
                 cmds.append(EndAssistantStream(session_id=e.session_id))
                 if not is_replay:

klaude_code/tui/renderer.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
 
 import contextlib
+import shutil
 from collections.abc import Callable, Iterator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Any
 
+from rich import box
 from rich.console import Console, Group, RenderableType
 from rich.padding import Padding
+from rich.panel import Panel
 from rich.rule import Rule
 from rich.spinner import Spinner
 from rich.style import Style, StyleType
@@ -32,6 +35,7 @@ from klaude_code.tui.commands import (
     RenderAssistantImage,
     RenderCommand,
     RenderCommandOutput,
+    RenderCompactionSummary,
     RenderDeveloperMessage,
     RenderError,
     RenderInterrupt,
@@ -66,7 +70,7 @@ from klaude_code.tui.components import welcome as c_welcome
 from klaude_code.tui.components.common import truncate_head
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.live import CropAboveLive, SingleLine
-from klaude_code.tui.components.rich.markdown import MarkdownStream, ThinkingMarkdown
+from klaude_code.tui.components.rich.markdown import MarkdownStream, NoInsetMarkdown, ThinkingMarkdown
 from klaude_code.tui.components.rich.quote import Quote
 from klaude_code.tui.components.rich.status import BreathingSpinner, ShimmerStatusText
 from klaude_code.tui.components.rich.theme import ThemeKey, get_theme
@@ -410,7 +414,7 @@ class TUICommandRenderer:
                 session_id=e.session_id,
             )
             if image_path is not None:
-                self.display_image(str(image_path), height=None)
+                self.display_image(str(image_path))
 
         renderable = c_tools.render_tool_result(e, code_theme=self.themes.code_theme, session_id=e.session_id)
         if renderable is not None:
@@ -472,7 +476,7 @@ class TUICommandRenderer:
         if not self.is_sub_agent_session(event.session_id):
             self.print()
 
-    def display_image(self, file_path: str, height: int | None = 40) -> None:
+    def display_image(self, file_path: str) -> None:
         # Suspend the Live status bar while emitting raw terminal output.
         had_live = self._bottom_live is not None
         was_spinner_visible = self._spinner_visible
@@ -485,7 +489,7 @@ class TUICommandRenderer:
             self._bottom_live = None
 
         try:
-            print_kitty_image(file_path, height=height, file=self.console.file)
+            print_kitty_image(file_path, file=self.console.file)
         finally:
             if resume_live:
                 if was_spinner_visible:
@@ -524,6 +528,63 @@ class TUICommandRenderer:
         else:
             self.print(c_errors.render_error(Text(event.error_message)))
 
+    def display_compaction_summary(self, summary: str, kept_items_brief: tuple[tuple[str, int, str], ...] = ()) -> None:
+        stripped = summary.strip()
+        if not stripped:
+            return
+        stripped = (
+            stripped.replace("<summary>", "")
+            .replace("</summary>", "")
+            .replace("<read_files>", "")
+            .replace("</read_files>", "")
+            .replace("<modified-files>", "")
+            .replace("</modified-files>", "")
+        )
+        self.console.print(
+            Rule(
+                Text("Context Compact", style=ThemeKey.COMPACTION_SUMMARY),
+                characters="=",
+                style=ThemeKey.COMPACTION_SUMMARY,
+            )
+        )
+        self.print()
+
+        # Limit panel width to min(100, terminal_width) minus left indent (2)
+        terminal_width = shutil.get_terminal_size().columns
+        panel_width = min(100, terminal_width) - 2
+
+        self.console.push_theme(self.themes.markdown_theme)
+        panel = Panel(
+            NoInsetMarkdown(stripped, code_theme=self.themes.code_theme, style=ThemeKey.COMPACTION_SUMMARY),
+            box=box.SIMPLE,
+            border_style=ThemeKey.LINES,
+            style=ThemeKey.COMPACTION_SUMMARY_PANEL,
+            width=panel_width,
+        )
+        self.print(Padding(panel, (0, 0, 0, MARKDOWN_LEFT_MARGIN)))
+        self.console.pop_theme()
+
+        if kept_items_brief:
+            # Collect tool call counts (skip User/Assistant entries)
+            tool_counts: dict[str, int] = {}
+            for item_type, count, _ in kept_items_brief:
+                if item_type not in ("User", "Assistant"):
+                    tool_counts[item_type] = tool_counts.get(item_type, 0) + count
+
+            if tool_counts:
+                parts: list[str] = []
+                for tool_type, tool_count in tool_counts.items():
+                    if tool_count > 1:
+                        parts.append(f"{tool_type} x {tool_count}")
+                    else:
+                        parts.append(tool_type)
+                line = Text()
+                line.append("\n  Kept uncompacted: ", style=ThemeKey.COMPACTION_SUMMARY)
+                line.append(", ".join(parts), style=ThemeKey.COMPACTION_SUMMARY)
+                self.print(line)
+
+        self.print()
+
     # ---------------------------------------------------------------------
     # Notifications
     # ---------------------------------------------------------------------
@@ -617,6 +678,8 @@ class TUICommandRenderer:
                     self.display_interrupt()
                 case RenderError(event=event):
                     self.display_error(event)
+                case RenderCompactionSummary(summary=summary, kept_items_brief=kept_items_brief):
+                    self.display_compaction_summary(summary, kept_items_brief)
                 case SpinnerStart():
                     self.spinner_start()
                 case SpinnerStop():