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

klaude_code/tui/command/fork_session_cmd.py

@@ -6,7 +6,7 @@ from typing import Literal
 from prompt_toolkit.styles import Style, merge_styles
 
 from klaude_code.protocol import commands, events, message, model
-from klaude_code.tui.input.clipboard import copy_to_clipboard
+from klaude_code.tui.input.key_bindings import copy_to_clipboard
 from klaude_code.tui.terminal.selector import DEFAULT_PICKER_STYLE, SelectItem, select_one
 
 from .command_abc import Agent, CommandABC, CommandResult
@@ -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),
             )
         )
 
@@ -194,7 +286,7 @@ class ForkSessionCommand(CommandABC):
 
     @property
     def summary(self) -> str:
-        return "Fork the current session and show a resume-by-id command"
+        return "Fork the current session and show a resume command"
 
     @property
     def is_interactive(self) -> bool:
@@ -220,7 +312,7 @@ class ForkSessionCommand(CommandABC):
             new_session = agent.session.fork()
             await new_session.wait_for_flush()
 
-            resume_cmd = f"klaude --resume-by-id {new_session.id}"
+            resume_cmd = f"klaude --resume {new_session.id}"
             copy_to_clipboard(resume_cmd)
 
             event = events.CommandOutputEvent(
@@ -247,9 +339,13 @@ 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-by-id {new_session.id}"
+        resume_cmd = f"klaude --resume {new_session.id}"
         copy_to_clipboard(resume_cmd)
 
         event = events.CommandOutputEvent(

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/command_output.py

@@ -50,7 +50,7 @@ def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
     grid.add_column(style=ThemeKey.TOOL_RESULT, overflow="fold")
 
     grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
-    grid.add_row(Text(f"  klaude --resume-by-id {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
+    grid.add_row(Text(f"  klaude --resume {session_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
     return Padding.indent(grid, level=2)
 

klaude_code/tui/components/rich/markdown.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import contextlib
 import io
+import re
 import time
 from collections.abc import Callable
 from typing import Any, ClassVar
@@ -9,9 +10,11 @@ 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, 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
@@ -26,6 +29,66 @@ from klaude_code.const import (
 )
 from klaude_code.tui.components.rich.code_panel import CodePanel
 
+_THINKING_HTML_BLOCK_RE = re.compile(
+    r"\A\s*<thinking>\s*\n?(?P<body>.*?)(?:\n\s*)?</thinking>\s*\Z",
+    flags=re.IGNORECASE | re.DOTALL,
+)
+
+_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.
+
+    markdown-it-py treats custom tags like `<thinking>` as HTML blocks, and Rich
+    Markdown ignores HTML blocks by default. This element restores visibility by
+    re-parsing the inner content as Markdown and applying a dedicated style.
+
+    Non-thinking HTML blocks (including comment sentinels like `<!-- -->`) render
+    no visible output, matching Rich's default behavior.
+    """
+
+    new_line: ClassVar[bool] = True
+
+    @classmethod
+    def create(cls, markdown: Markdown, token: Token) -> ThinkingHTMLBlock:
+        return cls(content=token.content or "", code_theme=markdown.code_theme)
+
+    def __init__(self, *, content: str, code_theme: str) -> None:
+        self._content = content
+        self._code_theme = code_theme
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        stripped = self._content.strip()
+
+        # Keep HTML comments invisible. MarkdownStream relies on a comment sentinel
+        # (`<!-- -->`) to preserve inter-block spacing in some streaming frames.
+        if _HTML_COMMENT_BLOCK_RE.match(stripped):
+            return
+
+        match = _THINKING_HTML_BLOCK_RE.match(stripped)
+        if match is None:
+            return
+
+        body = match.group("body").strip("\n")
+        if not body.strip():
+            return
+
+        # Render as a single line to avoid the extra blank lines produced by
+        # paragraph/block rendering.
+        collapsed = " ".join(body.split())
+        if not collapsed:
+            return
+
+        text = Text()
+        text.append("<thinking>", style="markdown.thinking.tag")
+        text.append(collapsed, style="markdown.thinking")
+        text.append("</thinking>", style="markdown.thinking.tag")
+        yield text
+
 
 class NoInsetCodeBlock(CodeBlock):
     """A code block with syntax highlighting and no padding."""
@@ -95,6 +158,55 @@ 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 NoInsetMarkdown(Markdown):
     """Markdown with code blocks that have no padding and left-justified headings."""
 
@@ -105,6 +217,8 @@ class NoInsetMarkdown(Markdown):
         "heading_open": LeftHeading,
         "hr": Divider,
         "table_open": MarkdownTable,
+        "html_block": ThinkingHTMLBlock,
+        "list_item_open": CheckboxListItem,
     }
 
 
@@ -118,6 +232,8 @@ class ThinkingMarkdown(Markdown):
         "heading_open": LeftHeading,
         "hr": Divider,
         "table_open": MarkdownTable,
+        "html_block": ThinkingHTMLBlock,
+        "list_item_open": CheckboxListItem,
     }
 
 

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,
@@ -331,7 +337,14 @@ def get_theme(theme: str | None = None) -> Themes:
         markdown_theme=Theme(
             styles={
                 "markdown.code": palette.purple,
+                # Render degraded `<thinking>...</thinking>` blocks inside assistant markdown.
+                # This must live in markdown_theme (not just thinking_markdown_theme) because
+                # it is used while rendering assistant output.
+                "markdown.thinking": "italic " + palette.grey2,
+                "markdown.thinking.tag": palette.grey2,
                 "markdown.code.border": palette.grey3,
+                # Used by ThinkingMarkdown when rendering `<thinking>` blocks.
+                "markdown.code.block": palette.grey1,
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h2": "bold underline",
@@ -343,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(
@@ -353,6 +367,7 @@ def get_theme(theme: str | None = None) -> Themes:
                 "markdown.code": palette.grey1 + " italic on " + palette.code_background,
                 "markdown.code.block": palette.grey1,
                 "markdown.code.border": palette.grey3,
+                "markdown.thinking.tag": palette.grey2 + " dim",
                 "markdown.h1": "bold reverse",
                 "markdown.h1.border": palette.grey3,
                 "markdown.h3": "bold " + palette.grey1,
@@ -364,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,

klaude_code/tui/components/tools.py

@@ -263,11 +263,7 @@ def render_write_tool_call(arguments: str) -> RenderableType:
     try:
         json_dict = json.loads(arguments)
         file_path = json_dict.get("file_path", "")
-        # Markdown files show path in result panel, skip here to avoid duplication
-        if file_path.endswith(".md"):
-            details: RenderableType | None = None
-        else:
-            details = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
+        details: RenderableType | None = render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
     except json.JSONDecodeError:
         details = Text(
             arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
@@ -292,24 +288,29 @@ def render_apply_patch_tool_call(arguments: str) -> RenderableType:
     details = Text("", ThemeKey.TOOL_PARAM)
 
     if isinstance(patch_content, str):
-        update_count = 0
-        add_count = 0
-        delete_count = 0
+        update_files: list[str] = []
+        add_files: list[str] = []
+        delete_files: list[str] = []
         for line in patch_content.splitlines():
             if line.startswith("*** Update File:"):
-                update_count += 1
+                update_files.append(line[len("*** Update File:") :].strip())
             elif line.startswith("*** Add File:"):
-                add_count += 1
+                add_files.append(line[len("*** Add File:") :].strip())
             elif line.startswith("*** Delete File:"):
-                delete_count += 1
+                delete_files.append(line[len("*** Delete File:") :].strip())
 
         parts: list[str] = []
-        if update_count > 0:
-            parts.append(f"Update File × {update_count}" if update_count > 1 else "Update File")
-        if add_count > 0:
-            parts.append(f"Add File × {add_count}" if add_count > 1 else "Add File")
-        if delete_count > 0:
-            parts.append(f"Delete File × {delete_count}" if delete_count > 1 else "Delete File")
+        if update_files:
+            parts.append(f"Update File × {len(update_files)}" if len(update_files) > 1 else "Update File")
+        if add_files:
+            # For single .md file addition, show filename in parentheses
+            if len(add_files) == 1 and add_files[0].endswith(".md"):
+                file_name = Path(add_files[0]).name
+                parts.append(f"Add File ({file_name})")
+            else:
+                parts.append(f"Add File × {len(add_files)}" if len(add_files) > 1 else "Add File")
+        if delete_files:
+            parts.append(f"Delete File × {len(delete_files)}" if len(delete_files) > 1 else "Delete File")
 
         if parts:
             details = Text(", ".join(parts), ThemeKey.TOOL_PARAM)
@@ -593,14 +594,24 @@ def _extract_markdown_doc(ui_extra: model.ToolResultUIExtra | None) -> model.Mar
 
 
 def render_markdown_doc(md_ui: model.MarkdownDocUIExtra, *, code_theme: str) -> RenderableType:
-    """Render markdown document content in a panel."""
-    header = render_path(md_ui.file_path, ThemeKey.TOOL_PARAM_FILE_PATH)
-    return Panel.fit(
-        Group(header, Text(""), NoInsetMarkdown(md_ui.content, code_theme=code_theme)),
+    """Render markdown document content in a panel with 2-char left indent and top margin."""
+    import shutil
+
+    from rich.padding import Padding
+
+    # 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
+
+    panel = Panel(
+        NoInsetMarkdown(md_ui.content, code_theme=code_theme),
         box=box.SIMPLE,
         border_style=ThemeKey.LINES,
         style=ThemeKey.WRITE_MARKDOWN_PANEL,
+        width=panel_width,
     )
+    # (top, right, bottom, left) - 1 line top margin, 2-char left indent
+    return Padding(panel, (1, 0, 0, 2))
 
 
 def render_tool_result(
@@ -628,11 +639,12 @@ def render_tool_result(
         rendered: list[RenderableType] = []
         for item in e.ui_extra.items:
             if isinstance(item, model.MarkdownDocUIExtra):
+                # Markdown docs render without TreeQuote wrap (already has 2-char indent)
                 rendered.append(render_markdown_doc(item, code_theme=code_theme))
             elif isinstance(item, model.DiffUIExtra):
                 show_file_name = e.tool_name == tools.APPLY_PATCH
-                rendered.append(r_diffs.render_structured_diff(item, show_file_name=show_file_name))
-        return wrap(Group(*rendered)) if rendered else None
+                rendered.append(wrap(r_diffs.render_structured_diff(item, show_file_name=show_file_name)))
+        return Group(*rendered) if rendered else None
 
     diff_ui = _extract_diff(e.ui_extra)
     md_ui = _extract_markdown_doc(e.ui_extra)
@@ -649,11 +661,13 @@ def render_tool_result(
             return wrap(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""))
         case tools.WRITE:
             if md_ui:
-                return wrap(render_markdown_doc(md_ui, code_theme=code_theme))
+                # Markdown docs render without TreeQuote wrap (already has 2-char indent)
+                return render_markdown_doc(md_ui, code_theme=code_theme)
             return wrap(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""))
         case tools.APPLY_PATCH:
             if md_ui:
-                return wrap(render_markdown_doc(md_ui, code_theme=code_theme))
+                # Markdown docs render without TreeQuote wrap (already has 2-char indent)
+                return render_markdown_doc(md_ui, code_theme=code_theme)
             if diff_ui:
                 return wrap(r_diffs.render_structured_diff(diff_ui, show_file_name=True))
             return _render_fallback()