tasktree-manager 2.12.1__tar.gz → 2.13.0__tar.gz

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/CHANGELOG.md

@@ -15,6 +15,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.13.0] - 2026-09-11
+
+### Added
+- **tui**: Show Claude session recap in the Info panel
+
+
 ## [2.12.1] - 2026-09-03
 
 ### Changed

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tasktree-manager
-Version: 2.12.1
+Version: 2.13.0
 Summary: TUI application for managing worktree-based tasks
 License-File: LICENSE
 Requires-Python: >=3.10

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/README.md

@@ -20,6 +20,7 @@
 - 🔧 **Flexible Configuration** - TOML config file, custom keybindings, environment variables
 - 🤖 **Headless CLI** - Create, list, inspect, finish, and delete tasks from scripts and AI agents without opening the TUI
 - 🛰️ **Agent Dashboard** - Live Claude Code session state per worktree (from `claude agents`), plus one-key background-agent dispatch — the multi-repo agent view Claude Code lacks natively
+- ✻ **Session Recap** - The Info panel shows each task's latest Claude Code session: title, last turn duration, and Claude's own idle recap of what was done and what comes next — read straight from the transcript, no CLI call
 - 🔀 **Forge-Aware Safety** - MR/PR and CI state via `glab`/`gh`; squash- and rebase-merged branches count as merged instead of blocking deletion forever
 - 📦 **Finish Flow with Archives** - Ending a task saves its combined diff (committed-but-unmerged + uncommitted) to an archive before deleting
 

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/docs/configuration.md

@@ -180,9 +180,21 @@ claude_memory_dir = "~/.claude/tasktree-memory"
 # worktree of a repo survives worktree deletion and is shared with future
 # worktrees of that repo and with sessions in the main checkout. The settings
 # file is added to the repo's .git/info/exclude so worktrees stay clean.
+# The directory name follows the current Claude CLI rule (every character
+# outside [A-Za-z0-9] becomes "-"); memory saved by older tasktree versions
+# under the previous name (which kept "_") is moved once, automatically.
 # Default: true
 claude_repo_memory = true
 
+# Claude session recap in the Info panel. When a task is highlighted, the
+# bottom of the panel shows its latest Claude Code session: title, last turn
+# duration ("Baked for 45s · done 5:27 PM"), and the idle recap Claude writes
+# a few minutes after a turn ("※ recap: ..."), or the last prompt when no
+# recap exists yet. Read from the session transcript under ~/.claude/projects
+# (honours CLAUDE_CONFIG_DIR); no CLI call.
+# Default: true
+claude_recap = true
+
 # Path to glab executable (GitLab CLI, used for MR/CI status)
 # Default: "glab" (searches PATH)
 glab_path = "glab"

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/docs/user-guide.md

@@ -219,6 +219,23 @@ Shows detailed git status for the selected worktree:
 - **Sync status**: Ahead/behind counts
 - **File changes**: Modified, staged, and untracked files with git status codes
 
+While the task list is focused, the panel shows the task summary instead (every
+repo with its changes or `clean`), followed by a **Claude session recap** when the
+task has a Claude Code session:
+
+```
+─ claude ─────────────────
+access-m2
+✻ Baked for 45s · done 5:27 PM · busy
+※ recap: Fulfilling ACCESS2-7180, read-only M2 access: gitops RBAC and
+terraform edits sit unstaged. Next, decide whether to hand-create the group.
+```
+
+- **Title**: the session name (`/rename`), else Claude's own title, else the session slug
+- **Turn line**: duration of the last turn and when it finished; `busy`/`idle` mirrors the task's Claude status indicator
+- **Recap**: the summary Claude writes a few minutes after a turn when the session idles. Until one exists, the dim `last prompt:` line shows what was asked last
+- Nothing is shown for tasks without a session. The block refreshes as you move the cursor and every 5 seconds while a transcript changes. Disable with `claude_recap = false` under `[tools]` in `config.toml`
+
 **Git status codes:**
 - `M` - Modified
 - `A` - Added (staged)

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/pyproject.toml

@@ -71,7 +71,7 @@ version-file = "tasktree_manager/_version.py"
 # Semantic Release Configuration
 [tool.semantic_release]
 version_toml = ["pyproject.toml:tool.semantic_release.version"]
-version = "2.12.1"
+version = "2.13.0"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/tasktree_manager/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.12.1'
-__version_tuple__ = version_tuple = (2, 12, 1)
+__version__ = version = '2.13.0'
+__version_tuple__ = version_tuple = (2, 13, 0)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/tasktree_manager/app.py

@@ -20,6 +20,7 @@ from . import __version__
 from .commands import TaskTreeCommands
 from .services.agent_sessions import list_agent_sessions, map_sessions_to_worktrees
 from .services.claude_hooks import ensure_claude_hooks, has_claude_session
+from .services.claude_sessions import ClaudeRecap, read_claude_recap, transcript_key
 from .services.config import Config, ConfigError
 from .services.forge import Forge, ForgeStatus, get_forge_status
 from .services.git_ops import GitOps
@@ -245,6 +246,9 @@ class TaskTreeApp(App):
         self._preserved_worktree_name: str | None = None
         # Claude session statuses: task_name -> status string
         self._claude_statuses: dict[str, str] = {}
+        # Transcript identity (path, mtime, size) behind the recap shown in
+        # the Info panel; None until the highlighted task has been scanned
+        self._recap_key: tuple[Path, int, int] | None = None
         # Agent session states from `claude agents --json`: worktree path -> state
         self._agent_sessions: dict[str, str] = {}
         # Forge MR/CI statuses: worktree path -> ForgeStatus
@@ -648,6 +652,50 @@ class TaskTreeApp(App):
         if statuses != self._claude_statuses:
             self._claude_statuses = statuses
             task_list.refresh_claude_indicators(statuses)
+            if self.current_task:
+                try:
+                    status_panel = self.query_one("#status-display", StatusPanel)
+                except Exception:
+                    return
+                status_panel.set_claude_live_status(statuses.get(self.current_task.name))
+
+        # Same tick keeps the recap fresh: a stat per poll, a read only on change
+        if self.config.claude_recap and self.current_task and task_list.has_focus:
+            self._update_claude_recap(self.current_task, self._recap_key)
+
+    @work(thread=True, exclusive=True, group="claude_recap_update")
+    def _update_claude_recap(self, task: Task, known_key: tuple[Path, int, int] | None) -> None:
+        """Read the task's latest Claude transcript tail when it changed.
+
+        ``known_key`` is passed in from the main thread so the worker never
+        reads mutable app state.
+        """
+        key = transcript_key(task.path)
+        if key == known_key:
+            return
+        recap = read_claude_recap(key[0]) if key else None
+        if get_current_worker().is_cancelled:
+            return
+        self.call_from_thread(self._apply_claude_recap, task, key, recap)
+
+    def _apply_claude_recap(
+        self, task: Task, key: tuple[Path, int, int] | None, recap: ClaudeRecap | None
+    ) -> None:
+        """Push a fetched recap to the Info panel (main thread)."""
+        if not (self.current_task and self.current_task.name == task.name):
+            return
+        self._recap_key = key
+        try:
+            status_panel = self.query_one("#status-display", StatusPanel)
+        except Exception:
+            return
+        status_panel.set_claude_recap(task.name, recap, self._claude_statuses.get(task.name))
+
+    def _request_claude_recap(self, task: Task) -> None:
+        """Start a fresh recap read for a newly shown task."""
+        self._recap_key = None
+        if self.config.claude_recap:
+            self._update_claude_recap(task, None)
 
     def _poll_agent_sessions_tick(self) -> None:
         """Dispatch an agent-session poll worker (never subprocess on UI thread)."""
@@ -936,6 +984,7 @@ class TaskTreeApp(App):
                 self._set_info_title(self.current_task.name)
                 status_panel.set_loading(True)
                 self._update_task_summary(self.current_task)
+                self._request_claude_recap(self.current_task)
         elif isinstance(event.widget, WorktreeList):
             # Worktree list focused → show worktree details
             if self.current_worktree:
@@ -983,6 +1032,7 @@ class TaskTreeApp(App):
                 self._set_info_title(event.task.name)
                 status_panel.set_loading(True)
                 self._update_task_summary(event.task)
+                self._request_claude_recap(event.task)
         else:
             worktree_list.clear_worktrees()
             status_panel.clear_status()

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/tasktree_manager/services/claude_hooks.py

@@ -1,7 +1,9 @@
-"""Claude Code hook configuration for status monitoring."""
+"""Claude Code integration: config/project-dir resolution, session discovery,
+and the hook/settings writers for status monitoring and shared memory."""
 
 import json
 import os
+import re
 from datetime import datetime
 from pathlib import Path
 
@@ -22,20 +24,37 @@ def claude_config_dir() -> Path:
 def _encode_project_path(folder: Path) -> str:
     """Encode a path the way Claude CLI names ~/.claude/projects/ entries.
 
-    The encoding replaces "/" and "." with "-".
+    Current CLIs replace every character outside [A-Za-z0-9] with "-".
     """
+    return re.sub(r"[^A-Za-z0-9]", "-", str(folder))
+
+
+def _encode_project_path_legacy(folder: Path) -> str:
+    """Older CLIs replaced only "/" and "." — dirs they created keep "_" etc."""
     return str(folder).replace("/", "-").replace(".", "-")
 
 
+def project_dir_candidates(folder: Path) -> list[Path]:
+    """Project dirs that may hold transcripts for a folder, current rule first.
+
+    A dir created by an older CLI for a path with "_" or spaces has a
+    different name than the current rule produces; checking both keeps
+    session resume and recaps working for it.
+    """
+    base = claude_config_dir() / "projects"
+    names = dict.fromkeys((_encode_project_path(folder), _encode_project_path_legacy(folder)))
+    return [base / name for name in names]
+
+
 def has_claude_session(folder: Path) -> bool:
     """Return True if Claude Code has a recorded session for the given folder.
 
     Claude CLI stores transcripts at <config dir>/projects/<encoded-path>/*.jsonl.
     """
-    project_dir = claude_config_dir() / "projects" / _encode_project_path(folder)
-    if not project_dir.is_dir():
-        return False
-    return any(project_dir.glob("*.jsonl"))
+    return any(
+        project_dir.is_dir() and any(project_dir.glob("*.jsonl"))
+        for project_dir in project_dir_candidates(folder)
+    )
 
 
 def repo_memory_dir(repo_path: Path) -> Path:
@@ -49,6 +68,29 @@ def repo_memory_dir(repo_path: Path) -> Path:
     return claude_config_dir() / "projects" / _encode_project_path(repo_path) / "memory"
 
 
+def migrate_legacy_memory_dir(repo_path: Path) -> bool:
+    """Move memory saved under an old-rule project dir to the current one.
+
+    Worktree settings written before the encoder matched the current CLI
+    pointed repos with "_" (etc.) at a differently named dir; the CLI never
+    reads it for the main checkout. A one-time rename keeps that memory in
+    the shared pool. Skipped when the current dir already exists (nothing
+    can be merged safely). Returns True when a move happened.
+    """
+    candidates = project_dir_candidates(repo_path)
+    if len(candidates) < 2:
+        return False
+    current, legacy = candidates[0] / "memory", candidates[1] / "memory"
+    if current.exists() or not legacy.is_dir():
+        return False
+    try:
+        current.parent.mkdir(parents=True, exist_ok=True)
+        legacy.rename(current)
+    except OSError:
+        return False
+    return True
+
+
 def _make_hook(status: str, status_file: str) -> dict:
     """Create a single hook entry that writes status to the given file path."""
     safe_path = status_file.replace("'", "'\\''")
@@ -199,6 +241,7 @@ def ensure_worktree_claude_settings(
 
     # Merge, preserving user-defined hook groups (same policy as task hooks)
     existing["hooks"] = _merge_hooks(existing.get("hooks"), _build_hooks_config(str(status_file)))
+    migrate_legacy_memory_dir(repo_path)
     existing["autoMemoryDirectory"] = str(repo_memory_dir(repo_path))
 
     settings_file.write_text(json.dumps(existing, indent=2) + "\n")

tasktree_manager-2.13.0/tasktree_manager/services/claude_sessions.py

@@ -0,0 +1,236 @@
+"""Read the recap of a task's latest Claude Code session from its transcript.
+
+Claude Code appends to ``<config>/projects/<encoded cwd>/<session>.jsonl`` as
+a session runs. The tail of that file carries what the terminal shows after
+a turn: a ``system/turn_duration`` record ("Baked for 45s · done 5:27 PM")
+and, when the session idles long enough, a ``system/away_summary`` record
+(the "※ recap:" line). Title latches (``custom-title``, ``ai-title``,
+``agent-name``) and ``last-prompt`` are rewritten near the end on every turn.
+
+Only the tail is read, newest line first, so a multi-megabyte transcript
+costs one bounded read regardless of its length.
+"""
+
+import json
+import os
+import re
+from dataclasses import dataclass
+from datetime import datetime, tzinfo
+from pathlib import Path
+
+from .claude_hooks import project_dir_candidates
+
+RECAP_SUFFIX = "(disable recaps in /config)"
+TAIL_WINDOW = 1 << 20
+TAIL_WINDOW_RETRY = 4 << 20
+# Turns that span a laptop sleep report days of "duration"; anything above
+# an hour is noise rather than work time
+DURATION_CAP_MS = 3_600_000
+LAST_PROMPT_MAX = 200
+
+# Cheap substring gate so multi-hundred-KB tool-result lines are never parsed
+_NEEDLES = (
+    b'"turn_duration"',
+    b'"away_summary"',
+    b'"custom-title"',
+    b'"ai-title"',
+    b'"agent-name"',
+    b'"last-prompt"',
+)
+_TITLE_KEYS = {
+    "custom-title": ("custom_title", "customTitle"),
+    "ai-title": ("ai_title", "aiTitle"),
+    "agent-name": ("agent_name", "agentName"),
+    "last-prompt": ("last_prompt", "lastPrompt"),
+}
+
+
+@dataclass(frozen=True)
+class ClaudeRecap:
+    """What the latest Claude session in a folder last did."""
+
+    title: str
+    duration_ms: int | None
+    finished_at: datetime | None  # tz-aware UTC
+    summary: str | None  # away_summary content, marketing suffix stripped
+    last_prompt: str | None
+
+
+def transcript_key(folder: Path) -> tuple[Path, int, int] | None:
+    """Return ``(path, mtime_ns, size)`` of the newest transcript for a folder.
+
+    One ``scandir`` per candidate project dir and no file reads, so callers
+    can poll it to detect changes cheaply.
+    """
+    newest: tuple[int, int, Path] | None = None
+    for project_dir in project_dir_candidates(folder):
+        try:
+            entries = list(os.scandir(project_dir))
+        except OSError:
+            continue
+        for entry in entries:
+            try:
+                if not entry.name.endswith(".jsonl") or not entry.is_file():
+                    continue
+                stat = entry.stat()
+            except OSError:
+                # Claude prunes old transcripts at startup; one can vanish
+                # between the scandir and the stat
+                continue
+            candidate = (stat.st_mtime_ns, stat.st_size, Path(entry.path))
+            if newest is None or candidate[0] > newest[0]:
+                newest = candidate
+    if newest is None:
+        return None
+    mtime_ns, size, path = newest
+    return path, mtime_ns, size
+
+
+def read_claude_recap(path: Path) -> ClaudeRecap | None:
+    """Read the recap from one transcript (see ``transcript_key`` to pick it)."""
+    try:
+        lines, truncated = _tail_lines(path, TAIL_WINDOW)
+        found = _scan(lines)
+        if "duration_ms" not in found and truncated:
+            lines, _ = _tail_lines(path, TAIL_WINDOW_RETRY)
+            found = _scan(lines)
+    except OSError:
+        return None
+
+    summary = found.get("summary")
+    last_prompt = found.get("last_prompt")
+    duration_ms = found.get("duration_ms")
+    if summary is None and last_prompt is None and duration_ms is None:
+        return None
+
+    title = (
+        found.get("custom_title")
+        or found.get("ai_title")
+        or found.get("agent_name")
+        or found.get("slug")
+        or path.stem[:8]
+    )
+    return ClaudeRecap(
+        title=title,
+        duration_ms=duration_ms,
+        finished_at=_parse_timestamp(found.get("finished_at")),
+        summary=summary,
+        last_prompt=last_prompt,
+    )
+
+
+def format_duration(ms: int) -> str:
+    """Render a turn duration the way Claude's terminal does: 45s, 3m 12s."""
+    if ms > DURATION_CAP_MS:
+        return ">1h"
+    seconds = max(0, ms // 1000)
+    if seconds < 60:
+        return f"{seconds}s"
+    return f"{seconds // 60}m {seconds % 60}s"
+
+
+def format_clock(dt: datetime, tz: tzinfo | None = None) -> str:
+    """Render a wall-clock time as 5:27 PM in ``tz`` (local time by default)."""
+    # %-I is not portable (Windows); strip the pad by hand instead
+    return dt.astimezone(tz).strftime("%I:%M %p").lstrip("0")
+
+
+def strip_recap_suffix(text: str) -> str:
+    """Drop the "(disable recaps in /config)" hint Claude appends to recaps."""
+    return text.strip().removesuffix(RECAP_SUFFIX).rstrip()
+
+
+def _tail_lines(path: Path, window: int) -> tuple[list[bytes], bool]:
+    """Return the last ``window`` bytes as whole lines, newest first.
+
+    The second element says whether the file extends beyond the window
+    (so a caller can retry with a bigger one).
+    """
+    with path.open("rb") as fh:
+        fh.seek(0, os.SEEK_END)
+        offset = max(0, fh.tell() - window)
+        fh.seek(offset)
+        data = fh.read()
+    lines = data.split(b"\n")
+    if offset > 0:
+        # The first chunk is a partial line cut by the seek
+        lines = lines[1:]
+    # The final line may be one Claude is still writing; it fails to parse
+    # and is skipped like any other bad line
+    return [line for line in reversed(lines) if line.strip()], offset > 0
+
+
+def _scan(lines: list[bytes]) -> dict:
+    """Collect recap fields from transcript lines ordered newest first."""
+    found: dict = {}
+    turn_seen = False
+    for raw in lines:
+        if not any(needle in raw for needle in _NEEDLES):
+            continue
+        try:
+            record = json.loads(raw)
+        except ValueError:
+            continue
+        if not isinstance(record, dict):
+            continue
+
+        rtype = record.get("type")
+        if rtype == "system":
+            subtype = record.get("subtype")
+            if subtype == "turn_duration":
+                if "duration_ms" not in found:
+                    found["duration_ms"] = _as_int(record.get("durationMs"))
+                    found["finished_at"] = _as_text(record.get("timestamp"))
+                turn_seen = True
+            elif subtype == "away_summary" and not turn_seen and "summary" not in found:
+                # A recap older than the latest turn describes a state that
+                # has since moved on; only accept one newer than the turn
+                content = _as_text(record.get("content"))
+                if content:
+                    found["summary"] = strip_recap_suffix(content)
+        elif rtype in _TITLE_KEYS:
+            field, source = _TITLE_KEYS[rtype]
+            value = _as_text(record.get(source))
+            if value and field not in found:
+                found[field] = _shorten_prompt(value) if field == "last_prompt" else value
+
+        slug = _as_text(record.get("slug"))
+        if slug and "slug" not in found:
+            found["slug"] = slug
+
+        if all(key in found for key in ("duration_ms", "last_prompt", "custom_title")):
+            break
+    return found
+
+
+def _as_int(value) -> int | None:
+    return value if isinstance(value, int) and not isinstance(value, bool) else None
+
+
+def _as_text(value) -> str | None:
+    """Return transcript text made safe for the terminal, or None if empty.
+
+    Transcript strings are model- or user-authored: control characters
+    (ESC and friends) would reach the terminal verbatim through Rich, so
+    they are dropped and whitespace is folded to single spaces.
+    """
+    if not isinstance(value, str):
+        return None
+    text = re.sub(r"[\x00-\x08\x0b-\x1f\x7f-\x9f]", "", value)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text or None
+
+
+def _shorten_prompt(text: str) -> str:
+    if len(text) > LAST_PROMPT_MAX:
+        text = text[: LAST_PROMPT_MAX - 1].rstrip() + "…"
+    return text
+
+
+def _parse_timestamp(value: str | None) -> datetime | None:
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/tasktree_manager/services/config.py

@@ -124,6 +124,7 @@ class Config:
     claude_path: str = "claude"
     claude_memory_dir: str = "~/.claude/tasktree-memory"
     claude_repo_memory: bool = True
+    claude_recap: bool = True
     glab_path: str = "glab"
     gh_path: str = "gh"
 
@@ -197,6 +198,7 @@ class Config:
         claude_path = os.path.expanduser(str(tools_config.get("claude_path", "claude")))
         claude_memory_dir = tools_config.get("claude_memory_dir", "~/.claude/tasktree-memory")
         claude_repo_memory = bool(tools_config.get("claude_repo_memory", True))
+        claude_recap = bool(tools_config.get("claude_recap", True))
         glab_path = os.path.expanduser(str(tools_config.get("glab_path", "glab")))
         gh_path = os.path.expanduser(str(tools_config.get("gh_path", "gh")))
 
@@ -267,6 +269,7 @@ class Config:
             claude_path=claude_path,
             claude_memory_dir=claude_memory_dir,
             claude_repo_memory=claude_repo_memory,
+            claude_recap=claude_recap,
             glab_path=glab_path,
             gh_path=gh_path,
             forge_enabled=forge_enabled,
@@ -416,6 +419,12 @@ claude_memory_dir = "{self._toml_escape(self.claude_memory_dir)}"
 # same repo and with the main checkout. Set to false to disable.
 claude_repo_memory = {str(self.claude_repo_memory).lower()}
 
+# Show a recap of the task's latest Claude Code session under the git
+# summary in the Info panel: session title, last turn duration, and the
+# idle recap (or the last prompt when no recap exists yet). Read from the
+# session transcript; no CLI call. Set to false to disable.
+claude_recap = {str(self.claude_recap).lower()}
+
 # Path to glab executable (GitLab CLI, used for MR/CI status)
 glab_path = "{self._toml_escape(self.glab_path)}"
 

{tasktree_manager-2.12.1 → tasktree_manager-2.13.0}/tasktree_manager/widgets/status_panel.py

@@ -3,8 +3,12 @@
 from rich.text import Text
 from textual.widgets import Static
 
+from ..services.claude_sessions import ClaudeRecap, format_clock, format_duration
 from ..services.models import GitStatus, Task, Worktree
 
+# .claude_status values worth a suffix on the recap line
+_LIVE_LABELS = {"running": ("busy", "yellow"), "waiting": ("idle", "green")}
+
 
 def _style_for_code(status_code: str) -> str:
     """Pick a display style for a git XY status code."""
@@ -29,6 +33,37 @@ class StatusPanel(Static):
         self._current_task: Task | None = None
         self._task_statuses: dict[str, GitStatus] = {}
         self._mode: str = "worktree"  # "worktree" or "task"
+        self._loading: bool = False
+        # Latest Claude session recap and the task it belongs to
+        self._claude_recap: ClaudeRecap | None = None
+        self._recap_task_name: str | None = None
+        self._claude_live: str | None = None
+
+    def set_claude_recap(
+        self, task_name: str, recap: ClaudeRecap | None, live: str | None = None
+    ) -> None:
+        """Store the Claude recap for a task; re-render if that task is shown.
+
+        A recap that lands while the git summary is still loading is kept
+        and drawn with the summary, so it never replaces "Loading...".
+        """
+        self._claude_recap = recap
+        self._recap_task_name = task_name
+        self._claude_live = live
+        self._rerender_task_view()
+
+    def set_claude_live_status(self, live: str | None) -> None:
+        """Update the busy/idle suffix on the recap line."""
+        if live != self._claude_live:
+            self._claude_live = live
+            self._rerender_task_view()
+
+    def _rerender_task_view(self) -> None:
+        """Redraw the task summary if the shown task owns the stored recap."""
+        if self._mode != "task" or self._loading or self._current_task is None:
+            return
+        if self._current_task.name == self._recap_task_name:
+            self._update_display()
 
     def update_status(self, worktree: Worktree | None, status: GitStatus | None) -> None:
         """Update the status display for a worktree."""
@@ -53,6 +88,7 @@ class StatusPanel(Static):
             statuses: Optional dict of worktree_name -> GitStatus with file details
         """
         self._mode = "task"
+        self._loading = False
         self._current_task = task
         self._task_statuses = statuses or {}
         self._update_display()
@@ -89,8 +125,36 @@ class StatusPanel(Static):
 
             text.append("\n")
 
+        if self._claude_recap is not None and self._recap_task_name == task.name:
+            self._append_claude_recap(text, self._claude_recap)
+
         self.update(text)
 
+    def _append_claude_recap(self, text: Text, recap: ClaudeRecap) -> None:
+        """Append the Claude session block: title, turn line, recap or prompt."""
+        text.append("─ claude " + "─" * 17 + "\n", style="dim")
+        text.append(f"{recap.title}\n", style="bold")
+
+        turn_parts = []
+        if recap.duration_ms is not None:
+            turn_parts.append(f"Baked for {format_duration(recap.duration_ms)}")
+        if recap.finished_at is not None:
+            turn_parts.append(f"done {format_clock(recap.finished_at)}")
+        live = _LIVE_LABELS.get(self._claude_live or "")
+        if turn_parts or live:
+            text.append("✻ ", style="magenta")
+            text.append(" · ".join(turn_parts), style="dim")
+            if live:
+                label, style = live
+                text.append(f"{' · ' if turn_parts else ''}{label}", style=style)
+            text.append("\n")
+
+        if recap.summary:
+            text.append("※ recap: ", style="cyan")
+            text.append(f"{recap.summary}\n")
+        elif recap.last_prompt:
+            text.append(f"last prompt: {recap.last_prompt}\n", style="dim")
+
     def _render_worktree_status(self) -> None:
         """Render the worktree-specific status view."""
         if not self._worktree_name or self._status is None:
@@ -149,6 +213,8 @@ class StatusPanel(Static):
         self._status = None
         self._current_task = None
         self._mode = "worktree"
+        self._claude_recap = None
+        self._recap_task_name = None
         self.update(Text("No worktree selected", style="dim"))
 
     def set_loading(self, loading: bool = True) -> None:
@@ -157,6 +223,7 @@ class StatusPanel(Static):
         Args:
             loading: If True, show loading indicator. If False, restore display.
         """
+        self._loading = loading
         if loading:
             self.update(Text("Loading...", style="dim italic"))
         else: