klaude-code 2.10.3__py3-none-any.whl → 2.10.4__py3-none-any.whl

klaude_code/skill/assets/writing-plans/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: writing-plans
+description: Use when you have a spec or requirements for a multi-step task, before touching code
+---
+
+# Writing Plans
+
+## Overview
+
+Write comprehensive implementation plans assuming the engineer has zero context for our codebase and questionable taste. Document everything they need to know: which files to touch for each task, code, testing, docs they might need to check, how to test it. Give them the whole plan as bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.
+
+Assume they are a skilled developer, but know almost nothing about our toolset or problem domain. Assume they don't know good test design very well.
+
+**Announce at start:** "I'm using the writing-plans skill to create the implementation plan."
+
+**Context:** This should be run in a dedicated worktree (created by brainstorming skill).
+
+**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`
+
+## Bite-Sized Task Granularity
+
+**Each step is one action (2-5 minutes):**
+- "Write the failing test" - step
+- "Run it to make sure it fails" - step
+- "Implement the minimal code to make the test pass" - step
+- "Run the tests and make sure they pass" - step
+- "Commit" - step
+
+## Plan Document Header
+
+**Every plan MUST start with this header:**
+
+```markdown
+# [Feature Name] Implementation Plan
+
+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
+
+**Goal:** [One sentence describing what this builds]
+
+**Architecture:** [2-3 sentences about approach]
+
+**Tech Stack:** [Key technologies/libraries]
+
+---
+```
+
+## Task Structure
+
+```markdown
+### Task N: [Component Name]
+
+**Files:**
+- Create: `exact/path/to/file.py`
+- Modify: `exact/path/to/existing.py:123-145`
+- Test: `tests/exact/path/to/test.py`
+
+**Step 1: Write the failing test**
+
+```python
+def test_specific_behavior():
+    result = function(input)
+    assert result == expected
+```
+
+**Step 2: Run test to verify it fails**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: FAIL with "function not defined"
+
+**Step 3: Write minimal implementation**
+
+```python
+def function(input):
+    return expected
+```
+
+**Step 4: Run test to verify it passes**
+
+Run: `pytest tests/path/test.py::test_name -v`
+Expected: PASS
+
+**Step 5: Commit**
+
+```bash
+git add tests/path/test.py src/path/file.py
+git commit -m "feat: add specific feature"
+```
+```
+
+## Remember
+- Exact file paths always
+- Complete code in plan (not "add validation")
+- Exact commands with expected output
+- Reference relevant skills with @ syntax
+- DRY, YAGNI, TDD, frequent commits
+
+## Execution Handoff
+
+After saving the plan, offer execution choice:
+
+**"Plan complete and saved to `docs/plans/<filename>.md`. Two execution options:**
+
+**1. Subagent-Driven (this session)** - I dispatch fresh subagent per task, review between tasks, fast iteration
+
+**2. Parallel Session (separate)** - Open new session with executing-plans, batch execution with checkpoints
+
+**Which approach?"**
+
+**If Subagent-Driven chosen:**
+- **REQUIRED SUB-SKILL:** Use superpowers:subagent-driven-development
+- Stay in this session
+- Fresh subagent per task + code review
+
+**If Parallel Session chosen:**
+- Guide them to open new session in worktree
+- **REQUIRED SUB-SKILL:** New session uses superpowers:executing-plans

klaude_code/tui/commands.py

@@ -183,3 +183,18 @@ class TaskClockClear(RenderCommand):
 class RenderCompactionSummary(RenderCommand):
     summary: str
     kept_items_brief: tuple[tuple[str, int, str], ...] = ()  # (item_type, count, preview)
+
+
+@dataclass(frozen=True, slots=True)
+class RenderBacktrack(RenderCommand):
+    checkpoint_id: int
+    note: str
+    rationale: str
+    original_user_message: str
+    messages_discarded: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class UpdateTerminalTitlePrefix(RenderCommand):
+    prefix: str | None
+    model_name: str | None

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:

klaude_code/tui/components/rich/status.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import contextlib
 import math
-import random
 import time
 from collections.abc import Callable
 
@@ -21,23 +20,14 @@ from klaude_code.const import (
     STATUS_HINT_TEXT,
     STATUS_SHIMMER_ALPHA_SCALE,
     STATUS_SHIMMER_BAND_HALF_WIDTH,
+    STATUS_SHIMMER_ENABLED,
     STATUS_SHIMMER_PADDING,
 )
 from klaude_code.tui.components.rich.theme import ThemeKey
-from klaude_code.tui.terminal.color import get_last_terminal_background_rgb
 
 # Use an existing Rich spinner name; BreathingSpinner overrides its rendering
 BREATHING_SPINNER_NAME = "dots"
 
-# Alternating glyphs for the breathing spinner - switches at each "transparent" point
-_BREATHING_SPINNER_GLYPHS_BASE = [
-    "✦",
-]
-
-# Shuffle glyphs on module load for variety across sessions
-BREATHING_SPINNER_GLYPHS = _BREATHING_SPINNER_GLYPHS_BASE.copy()
-random.shuffle(BREATHING_SPINNER_GLYPHS)
-
 
 _process_start: float | None = None
 _task_start: float | None = None
@@ -158,6 +148,9 @@ def _shimmer_profile(main_text: str) -> list[tuple[str, float]]:
     if not chars:
         return []
 
+    if not STATUS_SHIMMER_ENABLED:
+        return [(ch, 0.0) for ch in chars]
+
     padding = STATUS_SHIMMER_PADDING
     char_count = len(chars)
     period = char_count + padding * 2
@@ -211,58 +204,6 @@ def _shimmer_style(console: Console, base_style: Style, intensity: float) -> Sty
     return base_style + Style(color=shimmer_color)
 
 
-def _breathing_intensity() -> float:
-    """Compute breathing intensity in [0, 1] for the spinner.
-
-    Intensity follows a smooth cosine curve over the configured period, starting
-    from 0 (fully blended into background), rising to 1 (full style color),
-    then returning to 0, giving a subtle "breathing" effect.
-    """
-
-    period = max(SPINNER_BREATH_PERIOD_SECONDS, 0.1)
-    elapsed = _elapsed_since_start()
-    phase = (elapsed % period) / period
-    return 0.5 * (1.0 - math.cos(2.0 * math.pi * phase))
-
-
-def _breathing_glyph() -> str:
-    """Get the current glyph for the breathing spinner.
-
-    Alternates between glyphs at each breath cycle (when intensity reaches 0).
-    """
-    period = max(SPINNER_BREATH_PERIOD_SECONDS, 0.1)
-    elapsed = _elapsed_since_start()
-    cycle = int(elapsed / period)
-    return BREATHING_SPINNER_GLYPHS[cycle % len(BREATHING_SPINNER_GLYPHS)]
-
-
-def _breathing_style(console: Console, base_style: Style, intensity: float) -> Style:
-    """Blend a base style's foreground color toward terminal background.
-
-    When intensity is 0, the color matches the background (effectively
-    "transparent"); when intensity is 1, the color is the base style color.
-    """
-
-    base_color = base_style.color or Color.default()
-    base_triplet = base_color.get_truecolor()
-    base_r, base_g, base_b = base_triplet
-
-    cached_bg = get_last_terminal_background_rgb()
-    if cached_bg is not None:
-        bg_r, bg_g, bg_b = cached_bg
-    else:
-        bg_triplet = Color.default().get_truecolor(foreground=False)
-        bg_r, bg_g, bg_b = bg_triplet
-
-    intensity_clamped = max(0.0, min(1.0, intensity))
-    r = int(bg_r * (1.0 - intensity_clamped) + base_r * intensity_clamped)
-    g = int(bg_g * (1.0 - intensity_clamped) + base_g * intensity_clamped)
-    b = int(bg_b * (1.0 - intensity_clamped) + base_b * intensity_clamped)
-
-    breathing_color = Color.from_rgb(r, g, b)
-    return base_style + Style(color=breathing_color)
-
-
 def truncate_left(text: Text, max_cells: int, *, console: Console, ellipsis: str = "…") -> Text:
     """Left-truncate Text to fit within max_cells.
 
@@ -409,21 +350,11 @@ class BreathingSpinner(RichSpinner):
         return console.get_style(style_name)
 
     def _render_breathing(self, console: Console) -> RenderableType:
-        base_style = self._resolve_base_style(console)
-        intensity = _breathing_intensity()
-        style = _breathing_style(console, base_style, intensity)
-
-        glyph = _breathing_glyph()
-        frame = Text(glyph, style=style)
-
         if not self.text:
-            return frame
+            return Text()
         if isinstance(self.text, (str, Text)):
-            return Text.assemble(frame, " ", self.text)
-
-        table = Table.grid(padding=1)
-        table.add_row(frame, self.text)
-        return table
+            return self.text if isinstance(self.text, Text) else Text(self.text)
+        return self.text
 
 
 # Monkey-patch Rich's Status module to use the breathing spinner implementation

klaude_code/tui/components/rich/theme.py

@@ -189,6 +189,11 @@ class ThemeKey(str, Enum):
     THINKING_BOLD = "thinking.bold"
     # COMPACTION
     COMPACTION_SUMMARY = "compaction.summary"
+    # BACKTRACK
+    BACKTRACK = "backtrack"
+    BACKTRACK_INFO = "backtrack.info"
+    BACKTRACK_USER_MESSAGE = "backtrack.user_message"
+    BACKTRACK_NOTE = "backtrack.note"
     # TODO_ITEM
     TODO_EXPLANATION = "todo.explanation"
     TODO_PENDING_MARK = "todo.pending.mark"
@@ -311,6 +316,11 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.THINKING_BOLD.value: "italic " + palette.grey1,
                 # COMPACTION
                 ThemeKey.COMPACTION_SUMMARY.value: palette.grey1,
+                # BACKTRACK
+                ThemeKey.BACKTRACK.value: palette.orange,
+                ThemeKey.BACKTRACK_INFO.value: "dim " + palette.grey2,
+                ThemeKey.BACKTRACK_USER_MESSAGE.value: palette.cyan,
+                ThemeKey.BACKTRACK_NOTE.value: palette.grey1,
                 # TODO_ITEM
                 ThemeKey.TODO_EXPLANATION.value: palette.grey1 + " italic",
                 ThemeKey.TODO_PENDING_MARK.value: "bold " + palette.grey1,

klaude_code/tui/components/tools.py

@@ -10,7 +10,6 @@ from rich.style import Style
 from rich.text import Text
 
 from klaude_code.const import (
-    BASH_OUTPUT_PANEL_THRESHOLD,
     DIFF_PREFIX_WIDTH,
     INVALID_TOOL_CALL_MAX_LENGTH,
     QUERY_DISPLAY_TRUNCATE_LENGTH,
@@ -24,7 +23,6 @@ from klaude_code.tui.components import diffs as r_diffs
 from klaude_code.tui.components import mermaid_viewer as r_mermaid_viewer
 from klaude_code.tui.components.bash_syntax import highlight_bash_command
 from klaude_code.tui.components.common import create_grid, truncate_middle
-from klaude_code.tui.components.rich.code_panel import CodePanel
 from klaude_code.tui.components.rich.markdown import NoInsetMarkdown
 from klaude_code.tui.components.rich.quote import TreeQuote
 from klaude_code.tui.components.rich.theme import ThemeKey
@@ -40,6 +38,7 @@ MARK_MERMAID = "⧉"
 MARK_WEB_FETCH = "→"
 MARK_WEB_SEARCH = "✱"
 MARK_DONE = "✔"
+MARK_BACKTRACK = "↶"
 
 # Todo status markers
 MARK_TODO_PENDING = "▢"
@@ -168,22 +167,6 @@ def render_bash_tool_call(arguments: str) -> RenderableType:
         cmd_str = command.strip()
         highlighted = highlight_bash_command(cmd_str)
 
-        display_line_count = len(highlighted.plain.splitlines())
-
-        if display_line_count > BASH_OUTPUT_PANEL_THRESHOLD:
-            code_panel = CodePanel(highlighted, border_style=ThemeKey.LINES)
-            if isinstance(timeout_ms, int):
-                if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
-                    timeout_text = Text(f"{timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
-                else:
-                    timeout_text = Text(f"{timeout_ms}ms", style=ThemeKey.TOOL_TIMEOUT)
-                return _render_tool_call_tree(
-                    mark=MARK_BASH,
-                    tool_name=tool_name,
-                    details=Group(code_panel, timeout_text),
-                )
-            else:
-                return _render_tool_call_tree(mark=MARK_BASH, tool_name=tool_name, details=code_panel)
         if isinstance(timeout_ms, int):
             if timeout_ms >= 1000 and timeout_ms % 1000 == 0:
                 highlighted.append(f" {timeout_ms // 1000}s", style=ThemeKey.TOOL_TIMEOUT)
@@ -552,6 +535,33 @@ def render_report_back_tool_call() -> RenderableType:
     return _render_tool_call_tree(mark=MARK_DONE, tool_name="Report Back", details=None)
 
 
+def render_backtrack_tool_call(arguments: str) -> RenderableType:
+    tool_name = "Backtrack"
+
+    try:
+        payload: dict[str, Any] = json.loads(arguments)
+    except json.JSONDecodeError:
+        details = Text(
+            arguments.strip()[:INVALID_TOOL_CALL_MAX_LENGTH],
+            style=ThemeKey.INVALID_TOOL_CALL_ARGS,
+        )
+        return _render_tool_call_tree(mark=MARK_BACKTRACK, tool_name=tool_name, details=details)
+
+    checkpoint_id = payload.get("checkpoint_id")
+    rationale = payload.get("rationale", "")
+
+    summary = Text("", ThemeKey.TOOL_PARAM)
+    if isinstance(checkpoint_id, int):
+        summary.append(f"Checkpoint {checkpoint_id}", ThemeKey.TOOL_PARAM_BOLD)
+    if rationale:
+        rationale_preview = rationale if len(rationale) <= 50 else rationale[:47] + "..."
+        if summary.plain:
+            summary.append(" - ")
+        summary.append(rationale_preview, ThemeKey.TOOL_PARAM)
+
+    return _render_tool_call_tree(mark=MARK_BACKTRACK, tool_name=tool_name, details=summary if summary.plain else None)
+
+
 # Tool name to active form mapping (for spinner status)
 _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.BASH: "Bashing",
@@ -567,6 +577,7 @@ _TOOL_ACTIVE_FORM: dict[str, str] = {
     tools.REPORT_BACK: "Reporting",
     tools.IMAGE_GEN: "Generating Image",
     tools.TASK: "Spawning Task",
+    tools.BACKTRACK: "Backtracking",
 }
 
 
@@ -609,6 +620,8 @@ def render_tool_call(e: events.ToolCallEvent) -> RenderableType | None:
             return render_mermaid_tool_call(e.arguments)
         case tools.REPORT_BACK:
             return render_report_back_tool_call()
+        case tools.BACKTRACK:
+            return render_backtrack_tool_call(e.arguments)
         case tools.WEB_FETCH:
             return render_web_fetch_tool_call(e.arguments)
         case tools.WEB_SEARCH:

klaude_code/tui/display.py

@@ -101,3 +101,7 @@ class TUIDisplay(DisplayABC):
             self._renderer.spinner_stop()
         with contextlib.suppress(Exception):
             self._renderer.stop_bottom_live()
+
+    def set_model_name(self, model_name: str | None) -> None:
+        """Set model name for terminal title updates."""
+        self._machine.set_model_name(model_name)

klaude_code/tui/input/prompt_toolkit.py

@@ -448,6 +448,9 @@ class PromptToolkitInput(InputProviderABC):
             # Keep a comfortable multiline editing area even when no completion
             # space is reserved. (We set reserve_space_for_menu=0 to avoid the
             # bottom toolbar jumping when completions open/close.)
+            #
+            # Also allow the input area to grow with content so that large multi-line
+            # inputs expand the prompt instead of scrolling within a fixed-height window.
             base_rows = 10
 
             def _height():  # type: ignore[no-untyped-def]
@@ -465,7 +468,18 @@ class PromptToolkitInput(InputProviderABC):
                 elif isinstance(original_height_value, int):
                     original_min = int(original_height_value)
 
-                target_rows = 24 if picker_open else base_rows
+                try:
+                    buffer_line_count = int(self._session.default_buffer.document.line_count)
+                except Exception:
+                    buffer_line_count = 1
+
+                # Grow with content (based on newline count), but keep a sensible minimum.
+                content_rows = max(1, buffer_line_count)
+                target_rows = max(base_rows, content_rows)
+
+                # When a picker overlay is open, keep enough height for it to be usable.
+                if picker_open:
+                    target_rows = max(target_rows, 24)
 
                 # Cap to the current terminal size.
                 # Leave a small buffer to avoid triggering "Window too small".

klaude_code/tui/machine.py

@@ -24,6 +24,7 @@ from klaude_code.tui.commands import (
     EndThinkingStream,
     PrintBlankLine,
     RenderAssistantImage,
+    RenderBacktrack,
     RenderBashCommandEnd,
     RenderBashCommandStart,
     RenderCommand,
@@ -47,6 +48,7 @@ from klaude_code.tui.commands import (
     StartThinkingStream,
     TaskClockClear,
     TaskClockStart,
+    UpdateTerminalTitlePrefix,
 )
 from klaude_code.tui.components.rich import status as r_status
 from klaude_code.tui.components.rich.theme import ThemeKey
@@ -65,6 +67,7 @@ FAST_TOOLS: frozenset[str] = frozenset(
         tools.UPDATE_PLAN,
         tools.APPLY_PATCH,
         tools.REPORT_BACK,
+        tools.BACKTRACK,
     }
 )
 
@@ -135,7 +138,7 @@ class ActivityState:
                 for name, count in counts.items():
                     if not first:
                         activity_text.append(", ")
-                    activity_text.append(Text(name, style=ThemeKey.STATUS_TEXT_BOLD))
+                    activity_text.append(Text(name, style=ThemeKey.STATUS_TEXT))
                     if count > 1:
                         activity_text.append(f" x {count}")
                     first = False
@@ -238,24 +241,21 @@ class SpinnerStatusState:
 
         if extra_reasoning is not None:
             if activity_text is None:
-                activity_text = Text(extra_reasoning, style=ThemeKey.STATUS_TEXT_BOLD_ITALIC)
+                activity_text = Text(extra_reasoning, style=ThemeKey.STATUS_TEXT)
             else:
-                prefixed = Text(extra_reasoning, style=ThemeKey.STATUS_TEXT_BOLD_ITALIC)
+                prefixed = Text(extra_reasoning, style=ThemeKey.STATUS_TEXT)
                 prefixed.append(" , ")
                 prefixed.append_text(activity_text)
                 activity_text = prefixed
 
         if base_status:
-            # Default "Thinking ..." uses normal style; custom headers use bold italic
-            is_default_reasoning = base_status in {STATUS_THINKING_TEXT, STATUS_RUNNING_TEXT}
-            status_style = ThemeKey.STATUS_TEXT if is_default_reasoning else ThemeKey.STATUS_TEXT_BOLD_ITALIC
             if activity_text:
                 result = Text()
-                result.append(base_status, style=status_style)
+                result.append(base_status, style=ThemeKey.STATUS_TEXT)
                 result.append(" | ")
                 result.append_text(activity_text)
             else:
-                result = Text(base_status, style=status_style)
+                result = Text(base_status, style=ThemeKey.STATUS_TEXT)
         elif activity_text:
             activity_text.append(" …")
             result = activity_text
@@ -323,6 +323,10 @@ class DisplayStateMachine:
         self._sessions: dict[str, _SessionState] = {}
         self._primary_session_id: str | None = None
         self._spinner = SpinnerStatusState()
+        self._model_name: str | None = None
+
+    def set_model_name(self, model_name: str | None) -> None:
+        self._model_name = model_name
 
     def _reset_sessions(self) -> None:
         self._sessions = {}
@@ -442,6 +446,7 @@ class DisplayStateMachine:
                         self._primary_session_id = e.session_id
                     if not is_replay:
                         cmds.append(TaskClockStart())
+                        cmds.append(UpdateTerminalTitlePrefix(prefix="\u26ac", model_name=self._model_name))
 
                 if not is_replay:
                     cmds.append(SpinnerStart())
@@ -469,6 +474,18 @@ class DisplayStateMachine:
                     cmds.append(RenderCompactionSummary(summary=e.summary, kept_items_brief=kept_brief))
                 return cmds
 
+            case events.BacktrackEvent() as e:
+                cmds.append(
+                    RenderBacktrack(
+                        checkpoint_id=e.checkpoint_id,
+                        note=e.note,
+                        rationale=e.rationale,
+                        original_user_message=e.original_user_message,
+                        messages_discarded=e.messages_discarded,
+                    )
+                )
+                return cmds
+
             case events.DeveloperMessageEvent() as e:
                 cmds.append(RenderDeveloperMessage(e))
                 return cmds
@@ -747,6 +764,7 @@ class DisplayStateMachine:
                     self._spinner.reset()
                     cmds.append(SpinnerStop())
                     cmds.append(EmitTmuxSignal())
+                    cmds.append(UpdateTerminalTitlePrefix(prefix="\u2714", model_name=self._model_name))
                 return cmds
 
             case events.InterruptEvent() as e: