klaude-code 2.7.0__py3-none-any.whl → 2.8.1__py3-none-any.whl

klaude_code/tui/command/__init__.py

@@ -30,6 +30,8 @@ def ensure_commands_loaded() -> None:
 
     # Import and register commands in display order
     from .clear_cmd import ClearCommand
+    from .compact_cmd import CompactCommand
+    from .continue_cmd import ContinueCommand
     from .copy_cmd import CopyCommand
     from .debug_cmd import DebugCommand
     from .export_cmd import ExportCommand
@@ -45,6 +47,8 @@ def ensure_commands_loaded() -> None:
     # Register in desired display order
     register(CopyCommand())
     register(ExportCommand())
+    register(CompactCommand())
+    register(ContinueCommand())
     register(RefreshTerminalCommand())
     register(ModelCommand())
     register(SubAgentModelCommand())
@@ -64,6 +68,8 @@ def ensure_commands_loaded() -> None:
 def __getattr__(name: str) -> object:
     _commands_map = {
         "ClearCommand": "clear_cmd",
+        "CompactCommand": "compact_cmd",
+        "ContinueCommand": "continue_cmd",
         "CopyCommand": "copy_cmd",
         "DebugCommand": "debug_cmd",
         "ExportCommand": "export_cmd",

klaude_code/tui/command/compact_cmd.py

@@ -0,0 +1,32 @@
+from klaude_code.protocol import commands, message, op
+from klaude_code.tui.command.command_abc import Agent, CommandABC, CommandResult
+
+
+class CompactCommand(CommandABC):
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.COMPACT
+
+    @property
+    def summary(self) -> str:
+        return "summarize older context to free up the model window"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "optional focus for the summary"
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        focus = user_input.text.strip() if user_input.text else None
+        return CommandResult(
+            operations=[
+                op.CompactSessionOperation(
+                    session_id=agent.session.id,
+                    reason="manual",
+                    focus=focus or None,
+                )
+            ]
+        )

klaude_code/tui/command/continue_cmd.py

@@ -0,0 +1,34 @@
+from klaude_code.protocol import commands, events, message, op
+
+from .command_abc import Agent, CommandABC, CommandResult
+
+
+class ContinueCommand(CommandABC):
+    """Continue agent execution without adding a new user message."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.CONTINUE
+
+    @property
+    def summary(self) -> str:
+        return "Continue agent execution (for recovery after interruptions)"
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        del user_input  # unused
+
+        if agent.session.messages_count == 0:
+            return CommandResult(
+                events=[
+                    events.CommandOutputEvent(
+                        session_id=agent.session.id,
+                        command_name=self.name,
+                        content="Cannot continue: no conversation history. Start a conversation first.",
+                        is_error=True,
+                    )
+                ]
+            )
+
+        return CommandResult(
+            operations=[op.ContinueAgentOperation(session_id=agent.session.id)],
+        )

klaude_code/tui/command/fork_session_cmd.py

@@ -28,10 +28,14 @@ FORK_SELECT_STYLE = merge_styles(
 class ForkPoint:
     """A fork point in conversation history."""
 
+    kind: Literal["user", "compaction", "end"]
     history_index: int  # -1 means fork entire conversation
-    user_message: str
     tool_call_stats: dict[str, int]  # tool_name -> count
-    last_assistant_summary: str
+    user_message: str = ""
+    last_assistant_summary: str = ""
+    compaction_summary_preview: str = ""
+    compaction_first_kept_index: int | None = None
+    compaction_tokens_before: int | None = None
 
 
 def _truncate(text: str, max_len: int = 60) -> str:
@@ -42,11 +46,61 @@ def _truncate(text: str, max_len: int = 60) -> str:
     return text[: max_len - 1] + "…"
 
 
+def _first_non_empty_line(text: str) -> str:
+    for line in text.splitlines():
+        stripped = line.strip()
+        if stripped:
+            return stripped
+    return ""
+
+
+def _preview_compaction_summary(summary: str) -> str:
+    """Return a human-friendly preview line for a CompactionEntry summary.
+
+    Compaction summaries may start with a fixed prefix line and may contain <summary> tags.
+    For UI previews we want something more informative than the prefix.
+    """
+
+    cleaned = summary.replace("<summary>", "\n").replace("</summary>", "\n")
+    lines = [line.strip() for line in cleaned.splitlines()]
+    prefix = "the conversation history before this point was compacted"
+
+    def _is_noise(line: str) -> bool:
+        if not line:
+            return True
+        if line.casefold().startswith(prefix):
+            return True
+        return line in {"---", "----", "-----"}
+
+    # Prefer the first non-empty line under the "## Goal" section.
+    for i, line in enumerate(lines):
+        if line == "## Goal":
+            for j in range(i + 1, len(lines)):
+                candidate = lines[j]
+                if _is_noise(candidate):
+                    continue
+                if candidate.startswith("## "):
+                    break
+                return candidate
+
+    # Otherwise, pick the first non-heading meaningful line.
+    for line in lines:
+        if _is_noise(line):
+            continue
+        if line.startswith("## "):
+            continue
+        return line
+
+    # Fallback: first non-empty line.
+    return _first_non_empty_line(cleaned)
+
+
 def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list[ForkPoint]:
     """Build list of fork points from conversation history.
 
     Fork points are:
     - Each UserMessage position (for UI display, including first which would be empty session)
+    - The latest CompactionEntry boundary (just after it)
     - The end of the conversation (fork entire conversation)
     """
     fork_points: list[ForkPoint] = []
@@ -80,24 +134,44 @@ def _build_fork_points(conversation_history: list[message.HistoryEvent]) -> list
         user_text = message.join_text_parts(user_item.parts)
         fork_points.append(
             ForkPoint(
+                kind="user",
                 history_index=user_idx,
-                user_message=user_text or "(empty)",
                 tool_call_stats=tool_stats,
+                user_message=user_text or "(empty)",
                 last_assistant_summary=_truncate(last_assistant_content) if last_assistant_content else "",
             )
         )
 
-    # Add the "fork entire conversation" option at the end
-    if user_indices:
+    # Add a fork point just after the latest compaction entry (if any).
+    last_compaction_idx = -1
+    last_compaction: message.CompactionEntry | None = None
+    for idx in range(len(conversation_history) - 1, -1, -1):
+        item = conversation_history[idx]
+        if isinstance(item, message.CompactionEntry):
+            last_compaction_idx = idx
+            last_compaction = item
+            break
+    if last_compaction is not None:
+        # `until_index` is exclusive; `idx + 1` means include the CompactionEntry itself.
+        boundary_index = min(len(conversation_history), last_compaction_idx + 1)
+        preview = _truncate(_preview_compaction_summary(last_compaction.summary), 70)
         fork_points.append(
             ForkPoint(
-                history_index=-1,  # None means fork entire conversation
-                user_message="",  # No specific message, this represents the end
+                kind="compaction",
+                history_index=boundary_index,
                 tool_call_stats={},
-                last_assistant_summary="",
+                compaction_summary_preview=preview,
+                compaction_first_kept_index=last_compaction.first_kept_index,
+                compaction_tokens_before=last_compaction.tokens_before,
             )
         )
 
+    fork_points.sort(key=lambda fp: fp.history_index)
+
+    # Add the "fork entire conversation" option at the end
+    if fork_points:
+        fork_points.append(ForkPoint(kind="end", history_index=-1, tool_call_stats={}))
+
     return fork_points
 
 
@@ -107,7 +181,6 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
 
     for i, fp in enumerate(fork_points):
         is_first = i == 0
-        is_last = i == len(fork_points) - 1
 
         # Build the title
         title_parts: list[tuple[str, str]] = []
@@ -115,12 +188,14 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
         # First line: separator (with special markers for first/last fork points)
         if is_first:
             pass
-        elif is_last:
+        elif fp.kind == "end":
             title_parts.append(("class:separator", "----- fork from here (entire session) -----\n\n"))
+        elif fp.kind == "compaction":
+            title_parts.append(("class:separator", "----- fork after compaction -----\n\n"))
         else:
             title_parts.append(("class:separator", "----- fork from here -----\n\n"))
 
-        if not is_last:
+        if fp.kind == "user":
             # Second line: user message
             title_parts.append(("class:msg", f"user:   {_truncate(fp.user_message, 70)}\n"))
 
@@ -133,6 +208,15 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
             if fp.last_assistant_summary:
                 title_parts.append(("class:assistant", f"ai:     {fp.last_assistant_summary}\n"))
 
+        elif fp.kind == "compaction":
+            kept_from = fp.compaction_first_kept_index
+            if kept_from is not None:
+                title_parts.append(("class:meta", f"kept:   from history index {kept_from}\n"))
+            if fp.compaction_tokens_before is not None:
+                title_parts.append(("class:meta", f"tokens: {fp.compaction_tokens_before}\n"))
+            if fp.compaction_summary_preview:
+                title_parts.append(("class:assistant", f"sum:    {fp.compaction_summary_preview}\n"))
+
         # Empty line at the end
         title_parts.append(("class:text", "\n"))
 
@@ -140,8 +224,16 @@ def _build_select_items(fork_points: list[ForkPoint]) -> list[SelectItem[int]]:
             SelectItem(
                 title=title_parts,
                 value=fp.history_index,
-                search_text=fp.user_message if not is_last else "fork entire conversation",
-                selectable=not is_first,
+                search_text=(
+                    fp.user_message
+                    if fp.kind == "user"
+                    else (
+                        f"compaction {fp.compaction_summary_preview}"
+                        if fp.kind == "compaction"
+                        else "fork entire conversation"
+                    )
+                ),
+                selectable=not (fp.kind == "user" and is_first),
             )
         )
 
@@ -247,7 +339,11 @@ class ForkSessionCommand(CommandABC):
         await new_session.wait_for_flush()
 
         # Build result message
-        fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
+        selected_point = next((fp for fp in fork_points if fp.history_index == selected), None)
+        if selected_point is not None and selected_point.kind == "compaction":
+            fork_description = "after compaction"
+        else:
+            fork_description = "entire conversation" if selected == -1 else f"up to message index {selected}"
 
         resume_cmd = f"klaude --resume {new_session.id}"
         copy_to_clipboard(resume_cmd)

klaude_code/tui/command/model_picker.py

@@ -79,7 +79,11 @@ def select_model_interactive(
     try:
         items = build_model_select_items(result.filtered_models)
 
-        message = f"Select a model (filtered by '{result.filter_hint}'):" if result.filter_hint else "Select a model:"
+        total_count = len(result.filtered_models)
+        if result.filter_hint:
+            message = f"Select a model ({total_count}, filtered by '{result.filter_hint}'):"
+        else:
+            message = f"Select a model ({total_count}):"
 
         initial_value = config.main_model
         if isinstance(initial_value, str) and initial_value and "@" not in initial_value:

klaude_code/tui/command/thinking_cmd.py

@@ -14,7 +14,7 @@ def _select_thinking_sync(config: llm_param.LLMConfigParameter) -> llm_param.Thi
         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
     ]
 

klaude_code/tui/commands.py

@@ -162,3 +162,9 @@ class TaskClockStart(RenderCommand):
 @dataclass(frozen=True, slots=True)
 class TaskClockClear(RenderCommand):
     pass
+
+
+@dataclass(frozen=True, slots=True)
+class RenderCompactionSummary(RenderCommand):
+    summary: str
+    kept_items_brief: tuple[tuple[str, int, str], ...] = ()  # (item_type, count, preview)

klaude_code/tui/components/rich/markdown.py

@@ -5,14 +5,17 @@ import io
 import re
 import time
 from collections.abc import Callable
+from pathlib import Path
 from typing import Any, ClassVar
 
 from markdown_it import MarkdownIt
 from markdown_it.token import Token
 from rich import box
+from rich._loop import loop_first
 from rich.console import Console, ConsoleOptions, RenderableType, RenderResult
-from rich.markdown import CodeBlock, Heading, Markdown, MarkdownElement, TableElement
+from rich.markdown import CodeBlock, Heading, ImageItem, ListItem, Markdown, MarkdownElement, TableElement
 from rich.rule import Rule
+from rich.segment import Segment
 from rich.style import Style, StyleType
 from rich.syntax import Syntax
 from rich.table import Table
@@ -34,6 +37,9 @@ _THINKING_HTML_BLOCK_RE = re.compile(
 
 _HTML_COMMENT_BLOCK_RE = re.compile(r"\A\s*<!--.*?-->\s*\Z", flags=re.DOTALL)
 
+_CHECKBOX_UNCHECKED_RE = re.compile(r"^\[ \]\s*")
+_CHECKBOX_CHECKED_RE = re.compile(r"^\[x\]\s*", re.IGNORECASE)
+
 
 class ThinkingHTMLBlock(MarkdownElement):
     """Render `<thinking>...</thinking>` HTML blocks as Rich Markdown.
@@ -153,6 +159,74 @@ class LeftHeading(Heading):
             yield text
 
 
+class CheckboxListItem(ListItem):
+    """A list item that renders checkbox syntax as Unicode symbols."""
+
+    def render_bullet(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        render_options = options.update(width=options.max_width - 3)
+        lines = console.render_lines(self.elements, render_options, style=self.style)
+        bullet_style = console.get_style("markdown.item.bullet", default="none")
+
+        first_line_text = ""
+        if lines:
+            first_line_text = "".join(seg.text for seg in lines[0] if seg.text)
+
+        unchecked_match = _CHECKBOX_UNCHECKED_RE.match(first_line_text)
+        checked_match = _CHECKBOX_CHECKED_RE.match(first_line_text)
+
+        if unchecked_match:
+            bullet = Segment(" \u2610 ", bullet_style)
+            skip_chars = len(unchecked_match.group(0))
+        elif checked_match:
+            checked_style = console.get_style("markdown.checkbox.checked", default="none")
+            bullet = Segment(" \u2713 ", checked_style)
+            skip_chars = len(checked_match.group(0))
+        else:
+            bullet = Segment(" \u2022 ", bullet_style)
+            skip_chars = 0
+
+        padding = Segment(" " * 3, bullet_style)
+        new_line = Segment("\n")
+
+        for first, line in loop_first(lines):
+            yield bullet if first else padding
+            if first and skip_chars > 0:
+                chars_skipped = 0
+                for seg in line:
+                    if seg.text and chars_skipped < skip_chars:
+                        remaining = skip_chars - chars_skipped
+                        if len(seg.text) <= remaining:
+                            chars_skipped += len(seg.text)
+                            continue
+                        else:
+                            yield Segment(seg.text[remaining:], seg.style)
+                            chars_skipped = skip_chars
+                    else:
+                        yield seg
+            else:
+                yield from line
+            yield new_line
+
+
+class LocalImageItem(ImageItem):
+    """Image element that collects local file paths for external rendering."""
+
+    @classmethod
+    def create(cls, markdown: Markdown, token: Token) -> MarkdownElement:
+        src = str(token.attrs.get("src", ""))
+        instance = cls(src, markdown.hyperlinks)
+        if src.startswith("/") and Path(src).exists():
+            collected = getattr(markdown, "collected_images", None)
+            if collected is not None:
+                collected.append(src)
+        return instance
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        if self.destination.startswith("/") and Path(self.destination).exists():
+            return
+        yield from super().__rich_console__(console, options)
+
+
 class NoInsetMarkdown(Markdown):
     """Markdown with code blocks that have no padding and left-justified headings."""
 
@@ -164,8 +238,14 @@ class NoInsetMarkdown(Markdown):
         "hr": Divider,
         "table_open": MarkdownTable,
         "html_block": ThinkingHTMLBlock,
+        "list_item_open": CheckboxListItem,
+        "image": LocalImageItem,
     }
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.collected_images: list[str] = []
+
 
 class ThinkingMarkdown(Markdown):
     """Markdown for thinking content with grey-styled code blocks and left-justified headings."""
@@ -178,8 +258,14 @@ class ThinkingMarkdown(Markdown):
         "hr": Divider,
         "table_open": MarkdownTable,
         "html_block": ThinkingHTMLBlock,
+        "list_item_open": CheckboxListItem,
+        "image": LocalImageItem,
     }
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.collected_images: list[str] = []
+
 
 class MarkdownStream:
     """Block-based streaming Markdown renderer.
@@ -204,6 +290,7 @@ class MarkdownStream:
         left_margin: int = 0,
         right_margin: int = MARKDOWN_RIGHT_MARGIN,
         markdown_class: Callable[..., Markdown] | None = None,
+        image_callback: Callable[[str], None] | None = None,
     ) -> None:
         """Initialize the markdown stream.
 
@@ -216,6 +303,7 @@ class MarkdownStream:
             left_margin (int, optional): Number of columns to reserve on the left side
             right_margin (int, optional): Number of columns to reserve on the right side
             markdown_class: Markdown class to use for rendering (defaults to NoInsetMarkdown)
+            image_callback: Callback to display local images (called with file path)
         """
         self._stable_rendered_lines: list[str] = []
         self._stable_source_line_count: int = 0
@@ -226,6 +314,8 @@ class MarkdownStream:
             self.mdargs = {}
 
         self._live_sink = live_sink
+        self._image_callback = image_callback
+        self._displayed_images: set[str] = set()
 
         # Streaming control
         self.when: float = 0.0  # Timestamp of last update
@@ -365,20 +455,24 @@ class MarkdownStream:
 
         This is primarily intended for internal debugging and tests.
         """
+        lines, _ = self._render_markdown_to_lines(text, apply_mark=apply_mark)
+        return "".join(lines)
 
-        return "".join(self._render_markdown_to_lines(text, apply_mark=apply_mark))
-
-    def render_stable_ansi(self, stable_source: str, *, has_live_suffix: bool, final: bool) -> str:
-        """Render stable prefix to ANSI, preserving inter-block spacing."""
+    def render_stable_ansi(self, stable_source: str, *, has_live_suffix: bool, final: bool) -> tuple[str, list[str]]:
+        """Render stable prefix to ANSI, preserving inter-block spacing.
 
+        Returns:
+            tuple: (ANSI string, collected local image paths)
+        """
         if not stable_source:
-            return ""
+            return "", []
 
         render_source = stable_source
         if not final and has_live_suffix:
             render_source = self._append_nonfinal_sentinel(stable_source)
 
-        return self.render_ansi(render_source, apply_mark=True)
+        lines, images = self._render_markdown_to_lines(render_source, apply_mark=True)
+        return "".join(lines), images
 
     @staticmethod
     def normalize_live_ansi_for_boundary(*, stable_ansi: str, live_ansi: str) -> str:
@@ -441,14 +535,14 @@ class MarkdownStream:
             return stable_source + "\n<!-- -->"
         return stable_source + "\n\n<!-- -->"
 
-    def _render_markdown_to_lines(self, text: str, *, apply_mark: bool) -> list[str]:
+    def _render_markdown_to_lines(self, text: str, *, apply_mark: bool) -> tuple[list[str], list[str]]:
         """Render markdown text to a list of lines.
 
         Args:
             text (str): Markdown text to render
 
         Returns:
-            list: List of rendered lines with line endings preserved
+            tuple: (lines with line endings preserved, collected local image paths)
         """
         # Render the markdown to a string buffer
         string_io = io.StringIO()
@@ -470,6 +564,8 @@ class MarkdownStream:
         temp_console.print(markdown)
         output = string_io.getvalue()
 
+        collected_images = getattr(markdown, "collected_images", [])
+
         # Split rendered output into lines, strip trailing spaces, and apply left margin.
         lines = output.splitlines(keepends=True)
         indent_prefix = " " * self.left_margin if self.left_margin > 0 else ""
@@ -503,7 +599,7 @@ class MarkdownStream:
                 stripped += "\n"
             processed_lines.append(stripped)
 
-        return processed_lines
+        return processed_lines, list(collected_images)
 
     def __del__(self) -> None:
         """Destructor to ensure Live display is properly cleaned up."""
@@ -531,15 +627,22 @@ class MarkdownStream:
         start = time.time()
 
         stable_chunk_to_print: str | None = None
+        new_images: list[str] = []
         stable_changed = final or stable_line > self._stable_source_line_count
         if stable_changed and stable_source:
-            stable_ansi = self.render_stable_ansi(stable_source, has_live_suffix=bool(live_source), final=final)
+            stable_ansi, collected_images = self.render_stable_ansi(
+                stable_source, has_live_suffix=bool(live_source), final=final
+            )
             stable_lines = stable_ansi.splitlines(keepends=True)
             new_lines = stable_lines[len(self._stable_rendered_lines) :]
             if new_lines:
                 stable_chunk_to_print = "".join(new_lines)
             self._stable_rendered_lines = stable_lines
             self._stable_source_line_count = stable_line
+            for img in collected_images:
+                if img not in self._displayed_images:
+                    new_images.append(img)
+                    self._displayed_images.add(img)
         elif final and not stable_source:
             self._stable_rendered_lines = []
             self._stable_source_line_count = stable_line
@@ -547,7 +650,7 @@ class MarkdownStream:
         live_text_to_set: Text | None = None
         if not final and MARKDOWN_STREAM_LIVE_REPAINT_ENABLED and self._live_sink is not None:
             apply_mark_live = self._stable_source_line_count == 0
-            live_lines = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
+            live_lines, _ = self._render_markdown_to_lines(live_source, apply_mark=apply_mark_live)
 
             if self._stable_rendered_lines:
                 stable_trailing_blank = 0
@@ -573,6 +676,10 @@ class MarkdownStream:
             if stable_chunk_to_print:
                 self.console.print(Text.from_ansi(stable_chunk_to_print), end="\n")
 
+            if new_images and self._image_callback:
+                for img_path in new_images:
+                    self._image_callback(img_path)
+
             if final:
                 if self._live_sink is not None:
                     self._live_sink(None)

klaude_code/tui/components/rich/theme.py

@@ -95,7 +95,7 @@ DARK_PALETTE = Palette(
     code_theme="ansi_dark",
     code_background="#1a1f2a",
     green_background="#23342c",
-    blue_grey_background="#313848",
+    blue_grey_background="#262d3a",
     cyan_background="#1a3333",
     green_sub_background="#1b3928",
     blue_sub_background="#1a2a3d",
@@ -116,6 +116,7 @@ class ThemeKey(str, Enum):
     # PANEL
     SUB_AGENT_RESULT_PANEL = "panel.sub_agent_result"
     WRITE_MARKDOWN_PANEL = "panel.write_markdown"
+    COMPACTION_SUMMARY_PANEL = "panel.compaction_summary"
     # DIFF
     DIFF_FILE_NAME = "diff.file_name"
     DIFF_REMOVE = "diff.remove"
@@ -178,6 +179,8 @@ class ThemeKey(str, Enum):
     # THINKING
     THINKING = "thinking"
     THINKING_BOLD = "thinking.bold"
+    # COMPACTION
+    COMPACTION_SUMMARY = "compaction.summary"
     # TODO_ITEM
     TODO_EXPLANATION = "todo.explanation"
     TODO_PENDING_MARK = "todo.pending.mark"
@@ -235,6 +238,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 # PANEL
                 ThemeKey.SUB_AGENT_RESULT_PANEL.value: f"on {palette.blue_grey_background}",
                 ThemeKey.WRITE_MARKDOWN_PANEL.value: f"on {palette.green_background}",
+                ThemeKey.COMPACTION_SUMMARY_PANEL.value: f"on {palette.blue_grey_background}",
                 # DIFF
                 ThemeKey.DIFF_FILE_NAME.value: palette.blue,
                 ThemeKey.DIFF_REMOVE.value: palette.diff_remove,
@@ -247,7 +251,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.ERROR.value: palette.red,
                 ThemeKey.ERROR_BOLD.value: "bold " + palette.red,
                 ThemeKey.ERROR_DIM.value: "dim " + palette.red,
-                ThemeKey.INTERRUPT.value: "reverse bold " + palette.red,
+                ThemeKey.INTERRUPT.value: palette.red,
                 # USER_INPUT
                 ThemeKey.USER_INPUT.value: palette.magenta,
                 ThemeKey.USER_INPUT_PROMPT.value: "bold " + palette.magenta,
@@ -296,6 +300,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 # THINKING
                 ThemeKey.THINKING.value: "italic " + palette.grey2,
                 ThemeKey.THINKING_BOLD.value: "bold italic " + palette.grey1,
+                # COMPACTION
+                ThemeKey.COMPACTION_SUMMARY.value: "italic " + palette.grey1,
                 # TODO_ITEM
                 ThemeKey.TODO_EXPLANATION.value: palette.grey1 + " italic",
                 ThemeKey.TODO_PENDING_MARK.value: "bold " + palette.grey1,
@@ -350,6 +356,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link": "underline " + palette.blue,
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.table.border": palette.grey2,
+                "markdown.checkbox.checked": palette.green,
             }
         ),
         thinking_markdown_theme=Theme(
@@ -372,6 +379,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.link_url": "underline " + palette.blue,
                 "markdown.strong": "bold italic " + palette.grey1,
                 "markdown.table.border": palette.grey2,
+                "markdown.checkbox.checked": palette.green,
             }
         ),
         code_theme=palette.code_theme,