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

klaude_code/protocol/model.py

@@ -70,9 +70,15 @@ class TodoItem(BaseModel):
 
 
 class FileStatus(BaseModel):
-    """Tracks file state including modification time and memory file flag."""
+    """Tracks file state including modification time and content hash.
+
+    Notes:
+    - `mtime` is a cheap heuristic and may miss changes on some filesystems.
+    - `content_sha256` provides an explicit content-based change detector.
+    """
 
     mtime: float
+    content_sha256: str | None = None
     is_memory: bool = False
 
 
@@ -86,9 +92,27 @@ class ToolSideEffect(str, Enum):
 
 
 # Discriminated union types for ToolResultUIExtra
-class DiffTextUIExtra(BaseModel):
-    type: Literal["diff_text"] = "diff_text"
-    diff_text: str
+class DiffSpan(BaseModel):
+    op: Literal["equal", "insert", "delete"]
+    text: str
+
+
+class DiffLine(BaseModel):
+    kind: Literal["ctx", "add", "remove", "gap"]
+    new_line_no: int | None = None
+    spans: list[DiffSpan]
+
+
+class DiffFileDiff(BaseModel):
+    file_path: str
+    lines: list[DiffLine]
+    stats_add: int = 0
+    stats_remove: int = 0
+
+
+class DiffUIExtra(BaseModel):
+    type: Literal["diff"] = "diff"
+    files: list[DiffFileDiff]
 
 
 class TodoListUIExtra(BaseModel):
@@ -122,12 +146,7 @@ class SessionStatusUIExtra(BaseModel):
 
 
 ToolResultUIExtra = Annotated[
-    DiffTextUIExtra
-    | TodoListUIExtra
-    | SessionIdUIExtra
-    | MermaidLinkUIExtra
-    | TruncationUIExtra
-    | SessionStatusUIExtra,
+    DiffUIExtra | TodoListUIExtra | SessionIdUIExtra | MermaidLinkUIExtra | TruncationUIExtra | SessionStatusUIExtra,
     Field(discriminator="type"),
 ]
 

klaude_code/protocol/tools.py

@@ -1,14 +1,13 @@
 BASH = "Bash"
 APPLY_PATCH = "apply_patch"
 EDIT = "Edit"
-MULTI_EDIT = "MultiEdit"
+
 READ = "Read"
 WRITE = "Write"
 TODO_WRITE = "TodoWrite"
 UPDATE_PLAN = "update_plan"
 SKILL = "Skill"
 MERMAID = "Mermaid"
-MEMORY = "Memory"
 WEB_FETCH = "WebFetch"
 WEB_SEARCH = "WebSearch"
 REPORT_BACK = "report_back"

klaude_code/session/export.py

@@ -362,33 +362,87 @@ def _should_collapse(text: str) -> bool:
     return text.count("\n") + 1 > _COLLAPSIBLE_LINE_THRESHOLD or len(text) > _COLLAPSIBLE_CHAR_THRESHOLD
 
 
-def _render_diff_block(diff: str) -> str:
-    lines = diff.splitlines()
+def _render_diff_block(diff: model.DiffUIExtra) -> str:
     rendered: list[str] = []
-    for line in lines:
-        escaped = _escape_html(line)
-        if line.startswith("+"):
-            rendered.append(f'<span class="diff-line diff-plus">{escaped}</span>')
-        elif line.startswith("-"):
-            rendered.append(f'<span class="diff-line diff-minus">{escaped}</span>')
-        else:
-            rendered.append(f'<span class="diff-line diff-ctx">{escaped}</span>')
+    line_count = 0
+
+    for file_diff in diff.files:
+        header = _render_diff_file_header(file_diff)
+        if header:
+            rendered.append(header)
+        for line in file_diff.lines:
+            rendered.append(_render_diff_line(line))
+            line_count += 1
+
+    if line_count == 0:
+        rendered.append('<span class="diff-line diff-ctx">&nbsp;</span>')
+
     diff_content = f'<div class="diff-view">{"".join(rendered)}</div>'
-    open_attr = "" if _should_collapse(diff) else " open"
+    open_attr = "" if _should_collapse("\n" * max(1, line_count)) else " open"
     return (
         f'<details class="diff-collapsible"{open_attr}>'
-        f"<summary>Diff ({len(lines)} lines)</summary>"
+        f"<summary>Diff ({line_count} lines)</summary>"
         f"{diff_content}"
         "</details>"
     )
 
 
-def _get_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if isinstance(ui_extra, model.DiffTextUIExtra):
-        return ui_extra.diff_text
+def _render_diff_file_header(file_diff: model.DiffFileDiff) -> str:
+    stats_parts: list[str] = []
+    if file_diff.stats_add > 0:
+        stats_parts.append(f'<span class="diff-stats-add">+{file_diff.stats_add}</span>')
+    if file_diff.stats_remove > 0:
+        stats_parts.append(f'<span class="diff-stats-remove">-{file_diff.stats_remove}</span>')
+    stats_html = f' <span class="diff-stats">{" ".join(stats_parts)}</span>' if stats_parts else ""
+    file_name = _escape_html(file_diff.file_path)
+    return f'<div class="diff-file">{file_name}{stats_html}</div>'
+
+
+def _render_diff_line(line: model.DiffLine) -> str:
+    if line.kind == "gap":
+        line_class = "diff-ctx"
+        prefix = "⋮"
+    else:
+        line_class = "diff-plus" if line.kind == "add" else "diff-minus" if line.kind == "remove" else "diff-ctx"
+        prefix = "+" if line.kind == "add" else "-" if line.kind == "remove" else " "
+    spans = [_render_diff_span(span, line.kind) for span in line.spans]
+    content = "".join(spans)
+    if not content:
+        content = "&nbsp;"
+    return f'<span class="diff-line {line_class}">{prefix} {content}</span>'
+
+
+def _render_diff_span(span: model.DiffSpan, line_kind: str) -> str:
+    text = _escape_html(span.text)
+    if line_kind == "add" and span.op == "insert":
+        return f'<span class="diff-span diff-char-add">{text}</span>'
+    if line_kind == "remove" and span.op == "delete":
+        return f'<span class="diff-span diff-char-remove">{text}</span>'
+    return f'<span class="diff-span">{text}</span>'
+
+
+def _get_diff_ui_extra(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
+    if isinstance(ui_extra, model.DiffUIExtra):
+        return ui_extra
     return None
 
 
+def _build_add_only_diff(text: str, file_path: str) -> model.DiffUIExtra:
+    lines: list[model.DiffLine] = []
+    new_line_no = 1
+    for line in text.splitlines():
+        lines.append(
+            model.DiffLine(
+                kind="add",
+                new_line_no=new_line_no,
+                spans=[model.DiffSpan(op="equal", text=line)],
+            )
+        )
+        new_line_no += 1
+    file_diff = model.DiffFileDiff(file_path=file_path, lines=lines, stats_add=len(lines), stats_remove=0)
+    return model.DiffUIExtra(files=[file_diff])
+
+
 def _get_mermaid_link_html(
     ui_extra: model.ToolResultUIExtra | None, tool_call: model.ToolCallItem | None = None
 ) -> str | None:
@@ -513,18 +567,19 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
     ]
 
     if result:
-        diff_text = _get_diff_text(result.ui_extra)
+        diff_ui = _get_diff_ui_extra(result.ui_extra)
         mermaid_html = _get_mermaid_link_html(result.ui_extra, tool_call)
 
         should_hide_text = tool_call.name in ("TodoWrite", "update_plan") and result.status != "error"
 
-        if tool_call.name == "Edit" and not diff_text and result.status != "error":
+        if tool_call.name == "Edit" and not diff_ui and result.status != "error":
             try:
                 args_data = json.loads(tool_call.arguments)
+                file_path = args_data.get("file_path", "Unknown file")
                 old_string = args_data.get("old_string", "")
                 new_string = args_data.get("new_string", "")
                 if old_string == "" and new_string:
-                    diff_text = "\n".join(f"+{line}" for line in new_string.splitlines())
+                    diff_ui = _build_add_only_diff(new_string, file_path)
             except (json.JSONDecodeError, TypeError):
                 pass
 
@@ -536,8 +591,8 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
             else:
                 items_to_render.append(_render_text_block(result.output))
 
-        if diff_text:
-            items_to_render.append(_render_diff_block(diff_text))
+        if diff_ui:
+            items_to_render.append(_render_diff_block(diff_ui))
 
         if mermaid_html:
             items_to_render.append(mermaid_html)

klaude_code/session/session.py

@@ -86,6 +86,13 @@ class Session(BaseModel):
     def paths(cls) -> ProjectPaths:
         return get_default_store().paths
 
+    @classmethod
+    def exists(cls, id: str) -> bool:
+        """Return True if a persisted session exists for the current project."""
+
+        paths = cls.paths()
+        return paths.meta_file(id).exists() or paths.events_file(id).exists()
+
     @classmethod
     def create(cls, id: str | None = None, *, work_dir: Path | None = None) -> Session:
         session = Session(id=id or uuid.uuid4().hex, work_dir=work_dir or Path.cwd())

klaude_code/session/templates/export_session.html

@@ -31,6 +31,8 @@
         --bg-overlay: rgba(248, 246, 240, 0.98);
         --bg-error: #fdecec;
         --bg-success: #eaf6ed;
+        --bg-error-strong: #f9d6d6;
+        --bg-success-strong: #d5efdd;
         --bg-code: #f7f7f4;
         --border: #ded8cf;
         --text: #151515;
@@ -815,6 +817,21 @@
         overflow-x: auto;
         border: 1px solid var(--border);
       }
+      .diff-file {
+        color: var(--accent);
+        font-weight: 700;
+        margin: 6px 0 4px 0;
+        font-size: var(--font-size-sm);
+      }
+      .diff-stats {
+        font-weight: 600;
+      }
+      .diff-stats-add {
+        color: var(--success);
+      }
+      .diff-stats-remove {
+        color: var(--error);
+      }
       .diff-line {
         white-space: pre;
       }
@@ -833,6 +850,17 @@
         opacity: 0.7;
         display: block;
       }
+      .diff-span {
+        white-space: pre;
+      }
+      .diff-char-add {
+        background: var(--bg-success-strong);
+        font-weight: 600;
+      }
+      .diff-char-remove {
+        background: var(--bg-error-strong);
+        font-weight: 600;
+      }
 
       /* Collapsible Diff View */
       details.diff-collapsible {

klaude_code/ui/renderers/common.py

@@ -31,16 +31,20 @@ def truncate_display(
         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]
+    truncated_lines = 0
+    head_lines: list[str] = []
+    tail_lines: list[str] = []
 
-    out = Text()
-    if base_style is not None:
-        out.style = base_style
+    if len(lines) > max_lines:
+        truncated_lines = len(lines) - max_lines
+        head_count = max_lines // 2
+        tail_count = max_lines - head_count
+        head_lines = lines[:head_count]
+        tail_lines = lines[-tail_count:]
+    else:
+        head_lines = lines
 
-    for idx, line in enumerate(lines):
+    def append_line(out: Text, line: str) -> None:
         if len(line) > max_line_length:
             extra_chars = len(line) - max_line_length
             out.append(line[:max_line_length])
@@ -53,10 +57,21 @@ def truncate_display(
         else:
             out.append(line)
 
-        if idx != len(lines) - 1 or extra_lines > 0:
+    out = Text()
+    if base_style is not None:
+        out.style = base_style
+
+    for idx, line in enumerate(head_lines):
+        append_line(out, line)
+        if idx < len(head_lines) - 1 or truncated_lines > 0 or tail_lines:
             out.append("\n")
 
-    if extra_lines > 0:
-        out.append_text(Text(f"… (more {extra_lines} lines)", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+    if truncated_lines > 0:
+        out.append_text(Text(f"⋮ (more {truncated_lines} lines)\n", style=ThemeKey.TOOL_RESULT_TRUNCATED))
+
+    for idx, line in enumerate(tail_lines):
+        append_line(out, line)
+        if idx < len(tail_lines) - 1:
+            out.append("\n")
 
     return out

klaude_code/ui/renderers/developer.py

@@ -4,7 +4,6 @@ from rich.table import Table
 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, truncate_display
 from klaude_code.ui.renderers.tools import render_path
 from klaude_code.ui.rich.markdown import NoInsetMarkdown
@@ -103,10 +102,6 @@ def render_command_output(e: events.DeveloperMessageEvent) -> RenderableType:
         return Text("")
 
     match e.item.command_output.command_name:
-        case commands.CommandName.DIFF:
-            if e.item.content is None or len(e.item.content) == 0:
-                return Padding.indent(Text("(no changes)", style=ThemeKey.TOOL_RESULT), level=2)
-            return r_diffs.render_diff_panel(e.item.content, show_file_name=True)
         case commands.CommandName.HELP:
             return Padding.indent(Text.from_markup(e.item.content or ""), level=2)
         case commands.CommandName.STATUS:

klaude_code/ui/renderers/diffs.py

@@ -5,6 +5,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from klaude_code import const
+from klaude_code.protocol import model
 from klaude_code.ui.renderers.common import create_grid
 from klaude_code.ui.rich.theme import ThemeKey
 
@@ -179,6 +180,30 @@ def render_diff(diff_text: str, show_file_name: bool = False) -> RenderableType:
     return grid
 
 
+def render_structured_diff(ui_extra: model.DiffUIExtra, show_file_name: bool = False) -> RenderableType:
+    files = ui_extra.files
+    if not files:
+        return Text("")
+
+    grid = create_grid()
+    grid.padding = (0, 0)
+    show_headers = show_file_name or len(files) > 1
+
+    for idx, file_diff in enumerate(files):
+        if idx > 0:
+            grid.add_row("", "")
+
+        if show_headers:
+            grid.add_row(*_render_file_header(file_diff))
+
+        for line in file_diff.lines:
+            prefix = _make_structured_prefix(line, const.DIFF_PREFIX_WIDTH)
+            text = _render_structured_line(line)
+            grid.add_row(Text(prefix, ThemeKey.TOOL_RESULT), text)
+
+    return grid
+
+
 def render_diff_panel(
     diff_text: str,
     *,
@@ -210,3 +235,62 @@ def render_diff_panel(
     if indent <= 0:
         return panel
     return Padding.indent(panel, level=indent)
+
+
+def _render_file_header(file_diff: model.DiffFileDiff) -> tuple[Text, Text]:
+    file_text = Text(file_diff.file_path, style=ThemeKey.DIFF_FILE_NAME)
+    stats_text = Text()
+    if file_diff.stats_add > 0:
+        stats_text.append(f"+{file_diff.stats_add}", style=ThemeKey.DIFF_STATS_ADD)
+    if file_diff.stats_remove > 0:
+        if stats_text.plain:
+            stats_text.append(" ")
+        stats_text.append(f"-{file_diff.stats_remove}", style=ThemeKey.DIFF_STATS_REMOVE)
+
+    file_line = Text(style=ThemeKey.DIFF_FILE_NAME)
+    file_line.append_text(file_text)
+    if stats_text.plain:
+        file_line.append(" (")
+        file_line.append_text(stats_text)
+        file_line.append(")")
+
+    if file_diff.stats_add > 0 and file_diff.stats_remove == 0:
+        file_mark = "+"
+    elif file_diff.stats_remove > 0 and file_diff.stats_add == 0:
+        file_mark = "-"
+    else:
+        file_mark = "±"
+
+    prefix = Text(f"{file_mark:>{const.DIFF_PREFIX_WIDTH}}  ", style=ThemeKey.DIFF_FILE_NAME)
+    return prefix, file_line
+
+
+def _make_structured_prefix(line: model.DiffLine, width: int) -> str:
+    if line.kind == "gap":
+        return f"{'⋮':>{width}}  "
+    number = " " * width
+    if line.kind in {"add", "ctx"} and line.new_line_no is not None:
+        number = f"{line.new_line_no:>{width}}"
+    marker = "+" if line.kind == "add" else "-" if line.kind == "remove" else " "
+    return f"{number} {marker}"
+
+
+def _render_structured_line(line: model.DiffLine) -> Text:
+    if line.kind == "gap":
+        return Text("")
+    text = Text()
+    for span in line.spans:
+        text.append(span.text, style=_span_style(line.kind, span.op))
+    return text
+
+
+def _span_style(line_kind: str, span_op: str) -> ThemeKey:
+    if line_kind == "add":
+        if span_op == "insert":
+            return ThemeKey.DIFF_ADD_CHAR
+        return ThemeKey.DIFF_ADD
+    if line_kind == "remove":
+        if span_op == "delete":
+            return ThemeKey.DIFF_REMOVE_CHAR
+        return ThemeKey.DIFF_REMOVE
+    return ThemeKey.TOOL_RESULT

klaude_code/ui/renderers/tools.py

@@ -197,28 +197,6 @@ def render_write_tool_call(arguments: str) -> RenderableType:
     return grid
 
 
-def render_multi_edit_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("MultiEdit", ThemeKey.TOOL_NAME))
-    try:
-        json_dict = json.loads(arguments)
-        file_path = json_dict.get("file_path")
-        edits = json_dict.get("edits", [])
-        arguments_column = Text.assemble(
-            render_path(file_path, ThemeKey.TOOL_PARAM_FILE_PATH),
-            Text(" - "),
-            Text(f"{len(edits)}", ThemeKey.TOOL_PARAM_BOLD),
-            Text(" updates", ThemeKey.TOOL_PARAM_FILE_PATH),
-        )
-    except json.JSONDecodeError:
-        arguments_column = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-        )
-    grid.add_row(tool_name_column, arguments_column)
-    return grid
-
-
 def render_apply_patch_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
     tool_name_column = Text.assemble(("→", ThemeKey.TOOL_MARK), " ", ("Apply Patch", ThemeKey.TOOL_NAME))
@@ -300,60 +278,6 @@ def _extract_mermaid_link(
     return None
 
 
-def render_memory_tool_call(arguments: str) -> RenderableType:
-    grid = create_grid()
-    command_display_names: dict[str, str] = {
-        "view": "View",
-        "create": "Create",
-        "str_replace": "Replace",
-        "insert": "Insert",
-        "delete": "Delete",
-        "rename": "Rename",
-    }
-
-    try:
-        payload: dict[str, str] = json.loads(arguments)
-    except json.JSONDecodeError:
-        tool_name_column = Text.assemble(("★", ThemeKey.TOOL_MARK), " ", ("Memory", ThemeKey.TOOL_NAME))
-        summary = Text(
-            arguments.strip()[: const.INVALID_TOOL_CALL_MAX_LENGTH],
-            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
-        )
-        grid.add_row(tool_name_column, summary)
-        return grid
-
-    command = payload.get("command", "")
-    display_name = command_display_names.get(command, command.title())
-    tool_name_column = Text.assemble(("★", ThemeKey.TOOL_MARK), " ", (f"{display_name} Memory", ThemeKey.TOOL_NAME))
-
-    summary = Text("", ThemeKey.TOOL_PARAM)
-    path = payload.get("path")
-    old_path = payload.get("old_path")
-    new_path = payload.get("new_path")
-
-    if command == "rename" and old_path and new_path:
-        summary = Text.assemble(
-            Text(old_path, ThemeKey.TOOL_PARAM_FILE_PATH),
-            Text(" -> ", ThemeKey.TOOL_PARAM),
-            Text(new_path, ThemeKey.TOOL_PARAM_FILE_PATH),
-        )
-    elif command == "insert" and path:
-        insert_line = payload.get("insert_line")
-        summary = Text(path, ThemeKey.TOOL_PARAM_FILE_PATH)
-        if insert_line is not None:
-            summary.append(f" line {insert_line}", ThemeKey.TOOL_PARAM)
-    elif command == "view" and path:
-        view_range = payload.get("view_range")
-        summary = Text(path, ThemeKey.TOOL_PARAM_FILE_PATH)
-        if view_range and isinstance(view_range, list) and len(view_range) >= 2:
-            summary.append(f" {view_range[0]}:{view_range[1]}", ThemeKey.TOOL_PARAM)
-    elif path:
-        summary = Text(path, ThemeKey.TOOL_PARAM_FILE_PATH)
-
-    grid.add_row(tool_name_column, summary)
-    return grid
-
-
 def render_mermaid_tool_call(arguments: str) -> RenderableType:
     grid = create_grid()
     tool_name_column = Text.assemble(("⧉", ThemeKey.TOOL_MARK), " ", ("Mermaid", ThemeKey.TOOL_NAME))
@@ -504,14 +428,12 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.BASH: "Bashing",
     tools.APPLY_PATCH: "Patching",
     tools.EDIT: "Editing",
-    tools.MULTI_EDIT: "Editing",
     tools.READ: "Reading",
     tools.WRITE: "Writing",
     tools.TODO_WRITE: "Planning",
     tools.UPDATE_PLAN: "Planning",
     tools.SKILL: "Skilling",
     tools.MERMAID: "Diagramming",
-    tools.MEMORY: "Memorizing",
     tools.WEB_FETCH: "Fetching Web",
     tools.WEB_SEARCH: "Searching Web",
     tools.REPORT_BACK: "Reporting",
@@ -552,8 +474,7 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_edit_tool_call(e.arguments)
         case tools.WRITE:
             return render_write_tool_call(e.arguments)
-        case tools.MULTI_EDIT:
-            return render_multi_edit_tool_call(e.arguments)
+
         case tools.BASH:
             return render_bash_tool_call(e.arguments)
         case tools.APPLY_PATCH:
@@ -564,8 +485,6 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_update_plan_tool_call(e.arguments)
         case tools.MERMAID:
             return render_mermaid_tool_call(e.arguments)
-        case tools.MEMORY:
-            return render_memory_tool_call(e.arguments)
         case tools.SKILL:
             return render_generic_tool_call(e.tool_name, e.arguments, "◈")
         case tools.REPORT_BACK:
@@ -578,9 +497,9 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_generic_tool_call(e.tool_name, e.arguments)
 
 
-def _extract_diff_text(ui_extra: model.ToolResultUIExtra | None) -> str | None:
-    if isinstance(ui_extra, model.DiffTextUIExtra):
-        return ui_extra.diff_text
+def _extract_diff(ui_extra: model.ToolResultUIExtra | None) -> model.DiffUIExtra | None:
+    if isinstance(ui_extra, model.DiffUIExtra):
+        return ui_extra
     return None
 
 
@@ -604,28 +523,30 @@ def render_tool_result(e: events.ToolResultEvent) -> RenderableType | None:
     if truncation_info:
         return Group(render_truncation_info(truncation_info), render_generic_tool_result(e.result))
 
-    diff_text = _extract_diff_text(e.ui_extra)
+    diff_ui = _extract_diff(e.ui_extra)
 
     match e.tool_name:
         case tools.READ:
             return None
-        case tools.EDIT | tools.MULTI_EDIT | tools.WRITE:
-            return Padding.indent(r_diffs.render_diff(diff_text or ""), level=2)
-        case tools.MEMORY:
-            if diff_text:
-                return Padding.indent(r_diffs.render_diff(diff_text), level=2)
-            elif len(e.result.strip()) > 0:
-                return render_generic_tool_result(e.result)
-            return None
+        case tools.EDIT | tools.WRITE:
+            return Padding.indent(r_diffs.render_structured_diff(diff_ui) if diff_ui else Text(""), level=2)
+        case tools.APPLY_PATCH:
+            if diff_ui:
+                return Padding.indent(r_diffs.render_structured_diff(diff_ui, show_file_name=True), level=2)
+            if len(e.result.strip()) == 0:
+                return render_generic_tool_result("(no content)")
+            return render_generic_tool_result(e.result)
         case tools.TODO_WRITE | tools.UPDATE_PLAN:
             return render_todo(e)
         case tools.MERMAID:
             return render_mermaid_tool_result(e)
-        case _:
-            if e.tool_name in (tools.BASH, tools.APPLY_PATCH) and e.result.startswith("diff --git"):
+        case tools.BASH:
+            if e.result.startswith("diff --git"):
                 return r_diffs.render_diff_panel(e.result, show_file_name=True)
-            if e.tool_name == tools.APPLY_PATCH and diff_text:
-                return Padding.indent(r_diffs.render_diff(diff_text, show_file_name=True), level=2)
+            if len(e.result.strip()) == 0:
+                return render_generic_tool_result("(no content)")
+            return render_generic_tool_result(e.result)
+        case _:
             if len(e.result.strip()) == 0:
                 return render_generic_tool_result("(no content)")
             return render_generic_tool_result(e.result)

klaude_code/ui/rich/markdown.py

@@ -9,7 +9,7 @@ from typing import Any, ClassVar
 
 from rich.console import Console, ConsoleOptions, Group, RenderableType, RenderResult
 from rich.live import Live
-from rich.markdown import CodeBlock, Heading, Markdown
+from rich.markdown import CodeBlock, Heading, HorizontalRule, Markdown
 from rich.rule import Rule
 from rich.spinner import Spinner
 from rich.style import Style
@@ -45,6 +45,14 @@ class ThinkingCodeBlock(CodeBlock):
         yield CodePanel(text, border_style="markdown.code.border")
 
 
+class SpacedHorizontalRule(HorizontalRule):
+    """A horizontal rule with an extra blank line below."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        yield from super().__rich_console__(console, options)
+        yield Text()
+
+
 class LeftHeading(Heading):
     """A heading class that renders left-justified."""
 
@@ -69,6 +77,7 @@ class NoInsetMarkdown(Markdown):
         "fence": NoInsetCodeBlock,
         "code_block": NoInsetCodeBlock,
         "heading_open": LeftHeading,
+        "hr": SpacedHorizontalRule,
     }
 
 
@@ -80,6 +89,7 @@ class ThinkingMarkdown(Markdown):
         "fence": ThinkingCodeBlock,
         "code_block": ThinkingCodeBlock,
         "heading_open": LeftHeading,
+        "hr": SpacedHorizontalRule,
     }