klaude-code 2.9.1__py3-none-any.whl → 2.10.1__py3-none-any.whl

klaude_code/core/memory.py

@@ -0,0 +1,140 @@
+"""Memory file loading and management.
+
+This module handles CLAUDE.md and AGENTS.md memory files - discovery, loading,
+and providing summaries for UI display.
+"""
+
+from collections.abc import Callable
+from pathlib import Path
+
+from pydantic import BaseModel
+
+MEMORY_FILE_NAMES = ["CLAUDE.md", "AGENTS.md", "AGENT.md"]
+
+
+class Memory(BaseModel):
+    """Represents a loaded memory file."""
+
+    path: str
+    instruction: str
+    content: str
+
+
+def get_memory_paths(*, work_dir: Path) -> list[tuple[Path, str]]:
+    """Return all possible memory file paths with their descriptions."""
+    user_dirs = [Path.home() / ".claude", Path.home() / ".codex"]
+    project_dirs = [work_dir, work_dir / ".claude"]
+
+    paths: list[tuple[Path, str]] = []
+    for d in user_dirs:
+        for fname in MEMORY_FILE_NAMES:
+            paths.append((d / fname, "user's private global instructions for all projects"))
+    for d in project_dirs:
+        for fname in MEMORY_FILE_NAMES:
+            paths.append((d / fname, "project instructions, checked into the codebase"))
+    return paths
+
+
+def get_existing_memory_files(*, work_dir: Path) -> dict[str, list[str]]:
+    """Return existing memory file paths grouped by location (user/project)."""
+    result: dict[str, list[str]] = {"user": [], "project": []}
+    work_dir = work_dir.resolve()
+
+    for memory_path, _instruction in get_memory_paths(work_dir=work_dir):
+        if memory_path.exists() and memory_path.is_file():
+            path_str = str(memory_path)
+            resolved = memory_path.resolve()
+            try:
+                resolved.relative_to(work_dir)
+                result["project"].append(path_str)
+            except ValueError:
+                result["user"].append(path_str)
+
+    return result
+
+
+def get_existing_memory_paths_by_location(*, work_dir: Path) -> dict[str, list[str]]:
+    """Return existing memory file paths grouped by location for WelcomeEvent."""
+    result = get_existing_memory_files(work_dir=work_dir)
+    if not result.get("user") and not result.get("project"):
+        return {}
+    return result
+
+
+def format_memory_content(memory: Memory) -> str:
+    """Format a single memory file content for display."""
+    return f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}"
+
+
+def format_memories_reminder(memories: list[Memory], include_header: bool = True) -> str:
+    """Format memory files into a system reminder string."""
+    memories_str = "\n\n".join(format_memory_content(m) for m in memories)
+    if include_header:
+        return f"""<system-reminder>
+Loaded memory files. Follow these instructions. Do not mention them to the user unless explicitly asked.
+
+{memories_str}
+</system-reminder>"""
+    return f"<system-reminder>{memories_str}\n</system-reminder>"
+
+
+def discover_memory_files_near_paths(
+    paths: list[str],
+    *,
+    work_dir: Path,
+    is_memory_loaded: Callable[[str], bool],
+    mark_memory_loaded: Callable[[str], None],
+) -> list[Memory]:
+    """Discover and load CLAUDE.md/AGENTS.md from directories containing accessed files.
+
+    Args:
+        paths: List of file paths that have been accessed.
+        is_memory_loaded: Callback to check if a memory file is already loaded.
+        mark_memory_loaded: Callback to mark a memory file as loaded.
+
+    Returns:
+        List of newly discovered Memory objects.
+    """
+    memories: list[Memory] = []
+    work_dir = work_dir.resolve()
+    seen_memory_files: set[str] = set()
+
+    for p_str in paths:
+        p = Path(p_str)
+        full = (work_dir / p).resolve() if not p.is_absolute() else p.resolve()
+        try:
+            _ = full.relative_to(work_dir)
+        except ValueError:
+            continue
+
+        deepest_dir = full if full.is_dir() else full.parent
+
+        try:
+            rel_parts = deepest_dir.relative_to(work_dir).parts
+        except ValueError:
+            continue
+
+        current_dir = work_dir
+        for part in rel_parts:
+            current_dir = current_dir / part
+            for fname in MEMORY_FILE_NAMES:
+                mem_path = current_dir / fname
+                mem_path_str = str(mem_path)
+                if mem_path_str in seen_memory_files or is_memory_loaded(mem_path_str):
+                    continue
+                if mem_path.exists() and mem_path.is_file():
+                    try:
+                        text = mem_path.read_text(encoding="utf-8", errors="replace")
+                    except (PermissionError, UnicodeDecodeError, OSError):
+                        continue
+                    mark_memory_loaded(mem_path_str)
+                    seen_memory_files.add(mem_path_str)
+                    memories.append(
+                        Memory(
+                            path=mem_path_str,
+                            instruction="project instructions, discovered near last accessed path",
+                            content=text,
+                        )
+                    )
+
+    return memories

klaude_code/core/prompts/prompt-sub-agent-web.md

@@ -17,7 +17,7 @@ You are a web research subagent that searches and fetches web content to provide
 - HTML pages are automatically converted to Markdown
 - JSON responses are auto-formatted with indentation
 - Other text content returned as-is
-- **Content is always saved to a local file** - path shown in `[Web content saved to ...]` at output start
+- **Content is always saved to a local file** - path shown in `[Full content saved to ...]` at output start
 
 ## Tool Usage Strategy
 
@@ -54,7 +54,7 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 ## Response Guidelines
 
 - Only your last message is returned to the main agent
-- Include the file path from `[Web content saved to ...]` so the main agent can access full content
+- Include the file path from `[Full content saved to ...]` so the main agent can access full content
 - **DO NOT copy full web page content** - the main agent can read the saved files directly
 - Provide a concise summary/analysis of key findings
 - Lead with the most recent info for evolving topics

klaude_code/core/reminders.py

@@ -4,9 +4,13 @@ import shlex
 from dataclasses import dataclass
 from pathlib import Path
 
-from pydantic import BaseModel
-
-from klaude_code.const import MEMORY_FILE_NAMES, REMINDER_COOLDOWN_TURNS, TODO_REMINDER_TOOL_CALL_THRESHOLD
+from klaude_code.const import REMINDER_COOLDOWN_TURNS, TODO_REMINDER_TOOL_CALL_THRESHOLD
+from klaude_code.core.memory import (
+    Memory,
+    discover_memory_files_near_paths,
+    format_memories_reminder,
+    get_memory_paths,
+)
 from klaude_code.core.tool import BashTool, ReadTool, build_todo_context
 from klaude_code.core.tool.context import ToolContext
 from klaude_code.core.tool.file._utils import hash_text_sha256
@@ -382,28 +386,6 @@ def _compute_file_content_sha256(path: str) -> str | None:
         return None
 
 
-def get_memory_paths() -> list[tuple[Path, str]]:
-    return [
-        (
-            Path.home() / ".claude" / "CLAUDE.md",
-            "user's private global instructions for all projects",
-        ),
-        (
-            Path.home() / ".codex" / "AGENTS.md",
-            "user's private global instructions for all projects",
-        ),
-        (Path.cwd() / "AGENTS.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / "CLAUDE.md", "project instructions, checked into the codebase"),
-        (Path.cwd() / ".claude" / "CLAUDE.md", "project instructions, checked into the codebase"),
-    ]
-
-
-class Memory(BaseModel):
-    path: str
-    instruction: str
-    content: str
-
-
 def get_last_user_message_image_paths(session: Session) -> list[str]:
     """Get image file paths from the last user message in conversation history."""
     for item in reversed(session.conversation_history):
@@ -502,7 +484,7 @@ def _mark_memory_loaded(session: Session, path: str) -> None:
 
 async def memory_reminder(session: Session) -> message.DeveloperMessage | None:
     """CLAUDE.md AGENTS.md"""
-    memory_paths = get_memory_paths()
+    memory_paths = get_memory_paths(work_dir=session.work_dir)
     memories: list[Memory] = []
     for memory_path, instruction in memory_paths:
         path_str = str(memory_path)
@@ -514,21 +496,12 @@ async def memory_reminder(session: Session) -> message.DeveloperMessage | None:
             except (PermissionError, UnicodeDecodeError, OSError):
                 continue
     if len(memories) > 0:
-        memories_str = "\n\n".join(
-            [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
-        )
         loaded_files = [
             model.MemoryFileLoaded(path=memory.path, mentioned_patterns=_extract_at_patterns(memory.content))
             for memory in memories
         ]
         return message.DeveloperMessage(
-            parts=message.text_parts_from_str(
-                f"""<system-reminder>
-Loaded memory files. Follow these instructions. Do not mention them to the user unless explicitly asked.
-
-{memories_str}
-</system-reminder>"""
-            ),
+            parts=message.text_parts_from_str(format_memories_reminder(memories, include_header=True)),
             ui_extra=model.DeveloperUIExtra(items=[model.MemoryLoadedUIItem(files=loaded_files)]),
         )
     return None
@@ -546,68 +519,23 @@ async def last_path_memory_reminder(
         return None
 
     paths = list(session.file_tracker.keys())
-    memories: list[Memory] = []
-
-    cwd = Path.cwd().resolve()
-    seen_memory_files: set[str] = set()
-
-    for p_str in paths:
-        p = Path(p_str)
-        full = (cwd / p).resolve() if not p.is_absolute() else p.resolve()
-        try:
-            _ = full.relative_to(cwd)
-        except ValueError:
-            # Not under cwd; skip
-            continue
-
-        # Determine the deepest directory to scan (file parent or directory itself)
-        deepest_dir = full if full.is_dir() else full.parent
-
-        # Iterate each directory level from cwd to deepest_dir
-        try:
-            rel_parts = deepest_dir.relative_to(cwd).parts
-        except ValueError:
-            # Shouldn't happen due to check above, but guard anyway
-            continue
-
-        current_dir = cwd
-        for part in rel_parts:
-            current_dir = current_dir / part
-            for fname in MEMORY_FILE_NAMES:
-                mem_path = current_dir / fname
-                mem_path_str = str(mem_path)
-                if mem_path_str in seen_memory_files or _is_memory_loaded(session, mem_path_str):
-                    continue
-                if mem_path.exists() and mem_path.is_file():
-                    try:
-                        text = mem_path.read_text(encoding="utf-8", errors="replace")
-                    except (PermissionError, UnicodeDecodeError, OSError):
-                        continue
-                    _mark_memory_loaded(session, mem_path_str)
-                    seen_memory_files.add(mem_path_str)
-                    memories.append(
-                        Memory(
-                            path=mem_path_str,
-                            instruction="project instructions, discovered near last accessed path",
-                            content=text,
-                        )
-                    )
+    memories = discover_memory_files_near_paths(
+        paths,
+        work_dir=session.work_dir,
+        is_memory_loaded=lambda p: _is_memory_loaded(session, p),
+        mark_memory_loaded=lambda p: _mark_memory_loaded(session, p),
+    )
 
     if len(memories) > 0:
-        memories_str = "\n\n".join(
-            [f"Contents of {memory.path} ({memory.instruction}):\n\n{memory.content}" for memory in memories]
-        )
         loaded_files = [
             model.MemoryFileLoaded(path=memory.path, mentioned_patterns=_extract_at_patterns(memory.content))
             for memory in memories
         ]
         return message.DeveloperMessage(
-            parts=message.text_parts_from_str(
-                f"""<system-reminder>{memories_str}
-</system-reminder>"""
-            ),
+            parts=message.text_parts_from_str(format_memories_reminder(memories, include_header=False)),
             ui_extra=model.DeveloperUIExtra(items=[model.MemoryLoadedUIItem(files=loaded_files)]),
         )
+    return None
 
 
 ALL_REMINDERS = [

klaude_code/core/tool/offload.py

@@ -227,11 +227,11 @@ class HeadTailOffloadStrategy(OffloadStrategy):
         if self._should_offload(needs_truncation):
             offloaded_path = self._save_to_file(output, tool_call)
 
-        # Prefer line-based truncation if line limit exceeded
-        if needs_line_truncation:
-            truncated_output, hidden = self._truncate_by_lines(output, lines, offloaded_path)
-        else:
+        # Prefer char-based truncation if char limit exceeded (stricter limit)
+        if needs_char_truncation:
             truncated_output, hidden = self._truncate_by_chars(output, offloaded_path)
+        else:
+            truncated_output, hidden = self._truncate_by_lines(output, lines, offloaded_path)
 
         return OffloadResult(
             output=truncated_output,

klaude_code/core/tool/web/web_fetch_tool.md

@@ -1,8 +1,9 @@
 Fetch content from a URL and return it in a readable format.
 
 The tool automatically processes the response based on Content-Type:
+
 - HTML pages are converted to Markdown for easier reading
 - JSON responses are formatted with indentation
 - Markdown and other text content is returned as-is
 
-Content is always saved to a local file. The file path is shown at the start of the output in `[Web content saved to ...]` format. For large content that gets truncated, you can read the saved file directly.
+Content is always saved to a local file. The file path is shown at the start of the output in `[Full content saved to ...]` format. For large content that gets truncated, you can read the saved file directly.

klaude_code/core/tool/web/web_fetch_tool.py

@@ -235,7 +235,7 @@ class WebFetchTool(ToolABC):
             text = _decode_content(data, charset)
             processed = _process_content(content_type, text)
             saved_path = _save_text_content(url, processed)
-            output = f"[Web content saved to {saved_path}]\n\n{processed}" if saved_path else processed
+            output = f"[Full content saved to {saved_path}]\n\n{processed}" if saved_path else processed
 
             return message.ToolResultMessage(
                 status="success",

klaude_code/core/turn.py

@@ -194,11 +194,16 @@ class TurnExecutor:
                 and self._turn_result.assistant_message is not None
                 and self._turn_result.assistant_message.parts
             ):
-                session_ctx.append_history([self._turn_result.assistant_message])
-                # Add continuation prompt to avoid Anthropic thinking block requirement
-                session_ctx.append_history(
-                    [message.UserMessage(parts=[message.TextPart(text="<system>continue</system>")])]
+                # Discard partial message if it only contains thinking parts
+                has_non_thinking = any(
+                    not isinstance(part, message.ThinkingTextPart) for part in self._turn_result.assistant_message.parts
                 )
+                if has_non_thinking:
+                    session_ctx.append_history([self._turn_result.assistant_message])
+                    # Add continuation prompt to avoid Anthropic thinking block requirement
+                    session_ctx.append_history(
+                        [message.UserMessage(parts=[message.TextPart(text="<system>continue</system>")])]
+                    )
             yield events.TurnEndEvent(session_id=session_ctx.session_id)
             raise TurnError(self._turn_result.stream_error.error)
 

klaude_code/protocol/events.py

@@ -14,6 +14,9 @@ __all__ = [
     "AssistantTextDeltaEvent",
     "AssistantTextEndEvent",
     "AssistantTextStartEvent",
+    "BashCommandEndEvent",
+    "BashCommandOutputDeltaEvent",
+    "BashCommandStartEvent",
     "CommandOutputEvent",
     "CompactionEndEvent",
     "CompactionStartEvent",
@@ -81,6 +84,19 @@ class CommandOutputEvent(Event):
     is_error: bool = False
 
 
+class BashCommandStartEvent(Event):
+    command: str
+
+
+class BashCommandOutputDeltaEvent(Event):
+    content: str
+
+
+class BashCommandEndEvent(Event):
+    exit_code: int | None = None
+    cancelled: bool = False
+
+
 class TaskStartEvent(Event):
     sub_agent_state: model.SubAgentState | None = None
     model_id: str | None = None
@@ -166,6 +182,7 @@ class WelcomeEvent(Event):
     llm_config: llm_param.LLMConfigParameter
     show_klaude_code_info: bool = True
     loaded_skills: dict[str, list[str]] = Field(default_factory=dict)
+    loaded_memories: dict[str, list[str]] = Field(default_factory=dict)
 
 
 class ErrorEvent(Event):

klaude_code/protocol/op.py

@@ -24,6 +24,7 @@ class OperationType(Enum):
     """Enumeration of supported operation types."""
 
     RUN_AGENT = "run_agent"
+    RUN_BASH = "run_bash"
     CONTINUE_AGENT = "continue_agent"
     COMPACT_SESSION = "compact_session"
     CHANGE_MODEL = "change_model"
@@ -60,6 +61,17 @@ class RunAgentOperation(Operation):
         await handler.handle_run_agent(self)
 
 
+class RunBashOperation(Operation):
+    """Operation for running a user-entered bash-mode command."""
+
+    type: OperationType = OperationType.RUN_BASH
+    session_id: str
+    command: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_run_bash(self)
+
+
 class ContinueAgentOperation(Operation):
     """Operation for continuing an agent task without adding a new user message.
 

klaude_code/protocol/op_handler.py

@@ -22,6 +22,7 @@ if TYPE_CHECKING:
         InterruptOperation,
         ResumeSessionOperation,
         RunAgentOperation,
+        RunBashOperation,
     )
 
 
@@ -32,6 +33,10 @@ class OperationHandler(Protocol):
         """Handle a run agent operation."""
         ...
 
+    async def handle_run_bash(self, operation: RunBashOperation) -> None:
+        """Handle a bash-mode command execution operation."""
+        ...
+
     async def handle_continue_agent(self, operation: ContinueAgentOperation) -> None:
         """Handle a continue agent operation (resume without adding user message)."""
         ...

klaude_code/session/templates/mermaid_viewer.html

@@ -539,6 +539,21 @@ __KLAUDE_CODE__</textarea
           </svg>
           <span>SVG</span>
         </button>
+        <button class="tool-btn" id="btn-download-png" title="Download PNG">
+          <svg
+            width="16"
+            height="16"
+            viewBox="0 0 24 24"
+            fill="none"
+            stroke="currentColor"
+            stroke-width="2"
+          >
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"></path>
+            <polyline points="7 10 12 15 17 10"></polyline>
+            <line x1="12" y1="15" x2="12" y2="3"></line>
+          </svg>
+          <span>PNG</span>
+        </button>
       </div>
     </div>
 
@@ -570,6 +585,7 @@ __KLAUDE_CODE__</textarea
           zoomOut: document.getElementById("btn-zoom-out"),
           reset: document.getElementById("btn-reset"),
           download: document.getElementById("btn-download"),
+          downloadPng: document.getElementById("btn-download-png"),
           copy: document.getElementById("btn-copy-code"),
           collapse: document.getElementById("btn-collapse"),
           expand: document.getElementById("btn-expand"),
@@ -894,6 +910,75 @@ __KLAUDE_CODE__</textarea
         URL.revokeObjectURL(url);
       };
 
+      els.btns.downloadPng.onclick = async () => {
+        const svg = els.canvas.querySelector("svg");
+        if (!svg) return;
+
+        const clone = svg.cloneNode(true);
+
+        const bbox = svg.getBBox();
+        const width = bbox.width + 40;
+        const height = bbox.height + 40;
+
+        clone.setAttribute("width", width);
+        clone.setAttribute("height", height);
+        clone.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+        clone.setAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
+
+        // Remove foreignObject elements (they cause tainted canvas)
+        clone.querySelectorAll("foreignObject").forEach((fo) => {
+          const text = fo.textContent || "";
+          const parent = fo.parentNode;
+          if (parent) {
+            const textEl = document.createElementNS("http://www.w3.org/2000/svg", "text");
+            textEl.textContent = text;
+            textEl.setAttribute("font-family", "sans-serif");
+            textEl.setAttribute("font-size", "14");
+            parent.replaceChild(textEl, fo);
+          }
+        });
+
+        // Add white background rect
+        const bgRect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+        bgRect.setAttribute("width", "100%");
+        bgRect.setAttribute("height", "100%");
+        bgRect.setAttribute("fill", "white");
+        clone.insertBefore(bgRect, clone.firstChild);
+
+        const svgData = new XMLSerializer().serializeToString(clone);
+        const svgBase64 = btoa(unescape(encodeURIComponent(svgData)));
+        const dataUrl = "data:image/svg+xml;base64," + svgBase64;
+
+        const img = new Image();
+        img.onload = () => {
+          const scale = 2;
+          const canvas = document.createElement("canvas");
+          canvas.width = width * scale;
+          canvas.height = height * scale;
+
+          const ctx = canvas.getContext("2d");
+          ctx.fillStyle = "white";
+          ctx.fillRect(0, 0, canvas.width, canvas.height);
+          ctx.scale(scale, scale);
+          ctx.drawImage(img, 0, 0);
+
+          canvas.toBlob((blob) => {
+            const pngUrl = URL.createObjectURL(blob);
+            const a = document.createElement("a");
+            a.href = pngUrl;
+            a.download = "diagram.png";
+            document.body.appendChild(a);
+            a.click();
+            a.remove();
+            URL.revokeObjectURL(pngUrl);
+          }, "image/png");
+        };
+        img.onerror = (e) => {
+          console.error("PNG export failed:", e);
+        };
+        img.src = dataUrl;
+      };
+
       els.btns.copy.onclick = async () => {
         try {
           await navigator.clipboard.writeText(els.textarea.value);

klaude_code/tui/command/resume_cmd.py

@@ -34,7 +34,7 @@ def select_session_sync(session_ids: list[str] | None = None) -> str | None:
             if msg == "⋮":
                 title.append(("class:msg", f"    {msg}\n"))
             else:
-                prefix = "└─" if is_last else "├─"
+                prefix = "╰─" if is_last else "├─"
                 title.append(("fg:ansibrightblack dim", f"    {prefix} "))
                 title.append(("class:msg", f"{msg}\n"))
         title.append(("", "\n"))

klaude_code/tui/commands.py

@@ -38,6 +38,21 @@ class RenderCommandOutput(RenderCommand):
     event: events.CommandOutputEvent
 
 
+@dataclass(frozen=True, slots=True)
+class RenderBashCommandStart(RenderCommand):
+    event: events.BashCommandStartEvent
+
+
+@dataclass(frozen=True, slots=True)
+class AppendBashCommandOutput(RenderCommand):
+    event: events.BashCommandOutputDeltaEvent
+
+
+@dataclass(frozen=True, slots=True)
+class RenderBashCommandEnd(RenderCommand):
+    event: events.BashCommandEndEvent
+
+
 @dataclass(frozen=True, slots=True)
 class RenderTurnStart(RenderCommand):
     event: events.TurnStartEvent

klaude_code/tui/components/command_output.py

@@ -1,5 +1,4 @@
 from rich.console import RenderableType
-from rich.padding import Padding
 from rich.table import Table
 from rich.text import Text
 
@@ -19,7 +18,7 @@ def render_command_output(e: events.CommandOutputEvent) -> RenderableType:
         case _:
             content = e.content or "(no content)"
             style = ThemeKey.TOOL_RESULT if not e.is_error else ThemeKey.ERROR
-            return Padding.indent(truncate_middle(content, base_style=style), level=2)
+            return truncate_middle(content, base_style=style)
 
 
 def _format_tokens(tokens: int) -> str:
@@ -44,7 +43,7 @@ def _format_cost(cost: float | None, currency: str = "USD") -> str:
 def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
     """Render fork session output with usage instructions."""
     if not isinstance(e.ui_extra, model.SessionIdUIExtra):
-        return Padding.indent(Text(e.content, style=ThemeKey.TOOL_RESULT), level=2)
+        return Text(e.content, style=ThemeKey.TOOL_RESULT)
 
     grid = Table.grid(padding=(0, 1))
     session_id = e.ui_extra.session_id
@@ -54,7 +53,7 @@ def _render_fork_session_output(e: events.CommandOutputEvent) -> RenderableType:
     grid.add_row(Text("Session forked. Resume command copied to clipboard:", style=ThemeKey.TOOL_RESULT))
     grid.add_row(Text(f"  klaude -r {short_id}", style=ThemeKey.TOOL_RESULT_BOLD))
 
-    return Padding.indent(grid, level=2)
+    return grid
 
 
 def _render_status_output(e: events.CommandOutputEvent) -> RenderableType:
@@ -95,4 +94,4 @@ def _render_status_output(e: events.CommandOutputEvent) -> RenderableType:
                 usage_detail = "(no usage data)"
             table.add_row(f"{model_label}:", usage_detail)
 
-    return Padding.indent(table, level=2)
+    return table

klaude_code/tui/components/developer.py

@@ -6,7 +6,7 @@ from klaude_code.tui.components.common import create_grid
 from klaude_code.tui.components.rich.theme import ThemeKey
 from klaude_code.tui.components.tools import render_path
 
-REMINDER_BULLET = "  ⧉"
+REMINDER_BULLET = "⧉"
 
 
 def need_render_developer_message(e: events.DeveloperMessageEvent) -> bool:
@@ -56,8 +56,6 @@ def render_developer_message(e: events.DeveloperMessageEvent) -> RenderableType:
                             text = "Todo hasn't been updated recently"
                         case "empty":
                             text = "Todo list is empty"
-                        case _:
-                            text = "Todo reminder"
                     grid = create_grid()
                     grid.add_row(
                         Text(REMINDER_BULLET, style=ThemeKey.REMINDER),