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

klaude_code/session/session.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import re
 import time
 import uuid
 from collections.abc import Iterable, Sequence
@@ -15,6 +16,15 @@ from klaude_code.session.store import JsonlSessionStore, build_meta_snapshot
 
 _DEFAULT_STORES: dict[str, JsonlSessionStore] = {}
 
+_CHECKPOINT_RE = re.compile(r"<system>Checkpoint (\d+)</system>")
+
+
+def _extract_checkpoint_id(text: str) -> int | None:
+    match = _CHECKPOINT_RE.search(text)
+    if match is None:
+        return None
+    return int(match.group(1))
+
 
 def _read_json_dict(path: Path) -> dict[str, Any] | None:
     try:
@@ -51,6 +61,8 @@ class Session(BaseModel):
     todos: list[model.TodoItem] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
     model_name: str | None = None
 
+    next_checkpoint_id: int = 0
+
     model_config_name: str | None = None
     model_thinking: llm_param.Thinking | None = None
     created_at: float = Field(default_factory=lambda: time.time())
@@ -153,6 +165,8 @@ class Session(BaseModel):
         model_name = raw.get("model_name") if isinstance(raw.get("model_name"), str) else None
         model_config_name = raw.get("model_config_name") if isinstance(raw.get("model_config_name"), str) else None
 
+        next_checkpoint_id = int(raw.get("next_checkpoint_id", 0))
+
         model_thinking_raw = raw.get("model_thinking")
         model_thinking = (
             llm_param.Thinking.model_validate(model_thinking_raw) if isinstance(model_thinking_raw, dict) else None
@@ -169,6 +183,7 @@ class Session(BaseModel):
             model_name=model_name,
             model_config_name=model_config_name,
             model_thinking=model_thinking,
+            next_checkpoint_id=next_checkpoint_id,
         )
         session._store = store
         return session
@@ -221,19 +236,103 @@ class Session(BaseModel):
             model_name=self.model_name,
             model_config_name=self.model_config_name,
             model_thinking=self.model_thinking,
+            next_checkpoint_id=self.next_checkpoint_id,
         )
         self._store.append_and_flush(session_id=self.id, items=items, meta=meta)
 
+    @property
+    def n_checkpoints(self) -> int:
+        return self.next_checkpoint_id
+
+    def create_checkpoint(self) -> int:
+        checkpoint_id = self.next_checkpoint_id
+        self.next_checkpoint_id += 1
+        checkpoint_msg = message.DeveloperMessage(
+            parts=[message.TextPart(text=f"<system>Checkpoint {checkpoint_id}</system>")]
+        )
+        self.append_history([checkpoint_msg])
+        return checkpoint_id
+
+    def find_checkpoint_index(self, checkpoint_id: int) -> int | None:
+        target_text = f"<system>Checkpoint {checkpoint_id}</system>"
+        for i, item in enumerate(self.conversation_history):
+            if not isinstance(item, message.DeveloperMessage):
+                continue
+            text = message.join_text_parts(item.parts)
+            if target_text in text:
+                return i
+        return None
+
+    def get_user_message_before_checkpoint(self, checkpoint_id: int) -> str | None:
+        checkpoint_idx = self.find_checkpoint_index(checkpoint_id)
+        if checkpoint_idx is None:
+            return None
+
+        for i in range(checkpoint_idx - 1, -1, -1):
+            item = self.conversation_history[i]
+            if isinstance(item, message.UserMessage):
+                return message.join_text_parts(item.parts)
+        return None
+
+    def get_checkpoint_user_messages(self) -> dict[int, str]:
+        checkpoints: dict[int, str] = {}
+        last_user_message = ""
+        for item in self.conversation_history:
+            if isinstance(item, message.UserMessage):
+                last_user_message = message.join_text_parts(item.parts)
+                continue
+            if not isinstance(item, message.DeveloperMessage):
+                continue
+            text = message.join_text_parts(item.parts)
+            checkpoint_id = _extract_checkpoint_id(text)
+            if checkpoint_id is None:
+                continue
+            checkpoints[checkpoint_id] = last_user_message
+        return checkpoints
+
+    def revert_to_checkpoint(self, checkpoint_id: int, note: str, rationale: str) -> message.BacktrackEntry:
+        target_idx = self.find_checkpoint_index(checkpoint_id)
+        if target_idx is None:
+            raise ValueError(f"Checkpoint {checkpoint_id} not found")
+
+        user_message = self.get_user_message_before_checkpoint(checkpoint_id) or ""
+        reverted_from = len(self.conversation_history)
+        entry = message.BacktrackEntry(
+            checkpoint_id=checkpoint_id,
+            note=note,
+            rationale=rationale,
+            reverted_from_index=reverted_from,
+            original_user_message=user_message,
+        )
+
+        self.conversation_history = self.conversation_history[: target_idx + 1]
+        self.next_checkpoint_id = checkpoint_id + 1
+        self._invalidate_messages_count_cache()
+        self._user_messages_cache = None
+        return entry
+
     def get_llm_history(self) -> list[message.HistoryEvent]:
         """Return the LLM-facing history view with compaction summary injected."""
         history = self.conversation_history
+
+        def _convert(item: message.HistoryEvent) -> message.HistoryEvent:
+            if isinstance(item, message.BacktrackEntry):
+                return message.DeveloperMessage(
+                    parts=[
+                        message.TextPart(
+                            text=f"<system>After this, some operations were performed and context was refined via Backtrack. Rationale: {item.rationale}. Summary: {item.note}. Please continue.</system>"
+                        )
+                    ]
+                )
+            return item
+
         last_compaction: message.CompactionEntry | None = None
         for item in reversed(history):
             if isinstance(item, message.CompactionEntry):
                 last_compaction = item
                 break
         if last_compaction is None:
-            return [it for it in history if not isinstance(it, message.CompactionEntry)]
+            return [_convert(it) for it in history if not isinstance(it, message.CompactionEntry)]
 
         summary_message = message.UserMessage(parts=[message.TextPart(text=last_compaction.summary)])
         kept = [it for it in history[last_compaction.first_kept_index :] if not isinstance(it, message.CompactionEntry)]
@@ -246,7 +345,7 @@ class Session(BaseModel):
                 first_non_tool += 1
             kept = kept[first_non_tool:]
 
-        return [summary_message, *kept]
+        return [summary_message, *[_convert(it) for it in kept]]
 
     def fork(self, *, new_id: str | None = None, until_index: int | None = None) -> Session:
         """Create a new session as a fork of the current session.
@@ -266,6 +365,7 @@ class Session(BaseModel):
         forked.model_name = self.model_name
         forked.model_config_name = self.model_config_name
         forked.model_thinking = self.model_thinking.model_copy(deep=True) if self.model_thinking is not None else None
+        forked.next_checkpoint_id = self.next_checkpoint_id
         forked.file_tracker = {k: v.model_copy(deep=True) for k, v in self.file_tracker.items()}
         forked.todos = [todo.model_copy(deep=True) for todo in self.todos]
 
@@ -437,6 +537,15 @@ class Session(BaseModel):
                     yield events.DeveloperMessageEvent(session_id=self.id, item=dm)
                 case message.StreamErrorItem() as se:
                     yield events.ErrorEvent(error_message=se.error, can_retry=False, session_id=self.id)
+                case message.BacktrackEntry() as be:
+                    yield events.BacktrackEvent(
+                        session_id=self.id,
+                        checkpoint_id=be.checkpoint_id,
+                        note=be.note,
+                        rationale=be.rationale,
+                        original_user_message=be.original_user_message,
+                        messages_discarded=None,
+                    )
                 case message.CompactionEntry() as ce:
                     yield events.CompactionStartEvent(session_id=self.id, reason="threshold")
                     yield events.CompactionEndEvent(

klaude_code/session/store.py

@@ -169,6 +169,7 @@ def build_meta_snapshot(
     model_name: str | None,
     model_config_name: str | None,
     model_thinking: llm_param.Thinking | None,
+    next_checkpoint_id: int = 0,
 ) -> dict[str, Any]:
     return {
         "id": session_id,
@@ -186,4 +187,5 @@ def build_meta_snapshot(
         "model_thinking": model_thinking.model_dump(mode="json", exclude_defaults=True, exclude_none=True)
         if model_thinking
         else None,
+        "next_checkpoint_id": next_checkpoint_id,
     }

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

@@ -0,0 +1,84 @@
+---
+name: executing-plans
+description: Use when you have a written implementation plan to execute in a separate session with review checkpoints
+---
+
+# Executing Plans
+
+## Overview
+
+Load plan, review critically, execute tasks in batches, report for review between batches.
+
+**Core principle:** Batch execution with checkpoints for architect review.
+
+**Announce at start:** "I'm using the executing-plans skill to implement this plan."
+
+## The Process
+
+### Step 1: Load and Review Plan
+1. Read plan file
+2. Review critically - identify any questions or concerns about the plan
+3. If concerns: Raise them with your human partner before starting
+4. If no concerns: Create TodoWrite and proceed
+
+### Step 2: Execute Batch
+**Default: First 3 tasks**
+
+For each task:
+1. Mark as in_progress
+2. Follow each step exactly (plan has bite-sized steps)
+3. Run verifications as specified
+4. Mark as completed
+
+### Step 3: Report
+When batch complete:
+- Show what was implemented
+- Show verification output
+- Say: "Ready for feedback."
+
+### Step 4: Continue
+Based on feedback:
+- Apply changes if needed
+- Execute next batch
+- Repeat until complete
+
+### Step 5: Complete Development
+
+After all tasks complete and verified:
+- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
+- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
+- Follow that skill to verify tests, present options, execute choice
+
+## When to Stop and Ask for Help
+
+**STOP executing immediately when:**
+- Hit a blocker mid-batch (missing dependency, test fails, instruction unclear)
+- Plan has critical gaps preventing starting
+- You don't understand an instruction
+- Verification fails repeatedly
+
+**Ask for clarification rather than guessing.**
+
+## When to Revisit Earlier Steps
+
+**Return to Review (Step 1) when:**
+- Partner updates the plan based on your feedback
+- Fundamental approach needs rethinking
+
+**Don't force through blockers** - stop and ask.
+
+## Remember
+- Review plan critically first
+- Follow plan steps exactly
+- Don't skip verifications
+- Reference skills when plan says to
+- Between batches: just report and wait
+- Stop when blocked, don't guess
+- Never start implementation on main/master branch without explicit user consent
+
+## Integration
+
+**Required workflow skills:**
+- **superpowers:using-git-worktrees** - REQUIRED: Set up isolated workspace before starting
+- **superpowers:writing-plans** - Creates the plan this skill executes
+- **superpowers:finishing-a-development-branch** - Complete development after all tasks

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

@@ -9,8 +9,7 @@ def render_error(error_msg: Text) -> RenderableType:
     """Render error with X mark for error events."""
     grid = create_grid()
     error_msg.style = ThemeKey.ERROR
-    error_msg.overflow = "ellipsis"
-    error_msg.no_wrap = True
+    error_msg.overflow = "fold"
     grid.add_row(Text("✘", style=ThemeKey.ERROR_BOLD), error_msg)
     return grid
 
@@ -19,7 +18,6 @@ def render_tool_error(error_msg: Text) -> RenderableType:
     """Render error with indent for tool results."""
     grid = create_grid()
     error_msg.style = ThemeKey.ERROR
-    error_msg.overflow = "ellipsis"
-    error_msg.no_wrap = True
+    error_msg.overflow = "fold"
     grid.add_row(Text(" "), error_msg)
     return grid

klaude_code/tui/components/metadata.py

@@ -32,9 +32,6 @@ def _render_task_metadata_block(
 
     # Second column: provider/model description / tokens / cost / …
     content = Text()
-    if metadata.provider is not None:
-        content.append_text(Text(metadata.provider.lower().replace(" ", "-"), style=ThemeKey.METADATA))
-        content.append_text(Text("/", style=ThemeKey.METADATA))
     content.append_text(Text(metadata.model_name, style=ThemeKey.METADATA))
     if metadata.description:
         content.append_text(Text(" ", style=ThemeKey.METADATA)).append_text(
@@ -129,7 +126,7 @@ def _render_task_metadata_block(
 
     if parts:
         content.append_text(Text(" ", style=ThemeKey.METADATA))
-        content.append_text(Text(" ", style=ThemeKey.METADATA).join(parts))
+        content.append_text(Text(" ", style=ThemeKey.METADATA_DIM).join(parts))
 
     grid.add_row(mark, content)
     return grid
@@ -140,15 +137,14 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
     renderables: list[RenderableType] = []
 
     has_sub_agents = len(e.metadata.sub_agent_task_metadata) > 0
-    # Use an extra space for the main agent mark to align with two-character marks (├─, └─)
-    main_mark_text = "●"
+    main_mark_text = "•"
     main_mark = Text(main_mark_text, style=ThemeKey.METADATA)
 
     renderables.append(_render_task_metadata_block(e.metadata.main_agent, mark=main_mark, show_context_and_time=True))
 
     # Render each sub-agent metadata block
     for meta in e.metadata.sub_agent_task_metadata:
-        sub_mark = Text("  └", style=ThemeKey.METADATA)
+        sub_mark = Text("  •", style=ThemeKey.METADATA)
         renderables.append(_render_task_metadata_block(meta, mark=sub_mark, show_context_and_time=True))
 
     # Add total cost line when there are sub-agents
@@ -165,9 +161,8 @@ def render_task_metadata(e: events.TaskMetadataEvent) -> RenderableType:
 
         currency_symbol = "¥" if currency == "CNY" else "$"
         total_line = Text.assemble(
-            ("  └", ThemeKey.METADATA),
-            (" Σ ", ThemeKey.METADATA),
-            ("total ", ThemeKey.METADATA),
+            ("  •", ThemeKey.METADATA),
+            (" total ", ThemeKey.METADATA),
             (currency_symbol, ThemeKey.METADATA),
             (f"{total_cost:.4f}", ThemeKey.METADATA),
         )

klaude_code/tui/components/rich/markdown.py

@@ -609,7 +609,11 @@ class MarkdownStream:
 
         live_text_to_set: Text | None = None
         if not final and MARKDOWN_STREAM_LIVE_REPAINT_ENABLED and self._live_sink is not None:
-            # Only update live area after we have rendered at least one stable block
+            # Only update the live area after we have rendered at least one stable block.
+            #
+            # This keeps the bottom "live" region anchored to stable scrollback, and
+            # avoids showing a live frame that would later need to be retroactively
+            # re-rendered once stable content exists.
             if not self._stable_rendered_lines:
                 return
             # When nothing is stable yet, we still want to show incremental output.

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"
@@ -262,8 +267,8 @@ def get_theme(theme: str | None = None) -> Themes:
                 ThemeKey.ERROR_DIM.value: "dim " + palette.red,
                 ThemeKey.INTERRUPT.value: palette.red,
                 # USER_INPUT
-                ThemeKey.USER_INPUT.value: f"{palette.magenta} on {palette.user_message_background}",
-                ThemeKey.USER_INPUT_PROMPT.value: f"bold {palette.magenta} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT.value: f"{palette.cyan} on {palette.user_message_background}",
+                ThemeKey.USER_INPUT_PROMPT.value: f"bold {palette.cyan} on {palette.user_message_background}",
                 ThemeKey.USER_INPUT_AT_PATTERN.value: f"{palette.purple} on {palette.user_message_background}",
                 ThemeKey.USER_INPUT_SLASH_COMMAND.value: f"bold {palette.blue} on {palette.user_message_background}",
                 ThemeKey.USER_INPUT_SKILL.value: f"bold {palette.green} on {palette.user_message_background}",
@@ -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,