tasktree-manager 2.0.0__tar.gz → 2.1.0__tar.gz

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/CHANGELOG.md

@@ -15,24 +15,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
-## [2.0.0] - 2026-02-07
+## [2.1.0] - 2026-02-10
 
 ### Added
-- 
+- Add context-aware info panel with task summary and focus-driven updates
+- Add Claude session status monitoring with Ghostty integration
 
 ### Changed
-- 
+- Update example task names in README and user guide
+
+
+## [2.0.1] - 2026-02-07
 
 ### Fixed
-- 
+- Auto-generate changelog from conventional commits
 
 
-## [1.0.1] - 2026-02-07
+## [2.0.0] - 2026-02-07
 
 ### Changed
+- **BREAKING**: CLI command renamed from `tasktree` to `tasktree-manager`
+- **BREAKING**: Config directory moved from `~/.config/tasktree/` to `~/.config/tasktree-manager/`
 - Renamed Python module from `tasktree` to `tasktree_manager` for PyPI consistency
-- Renamed CLI command from `tasktree` to `tasktree-manager`
-- Renamed config directory from `~/.config/tasktree/` to `~/.config/tasktree-manager/`
 - Renamed GitHub repository to `tasktree-manager`
 - Updated all documentation, CI workflows, and build configuration
 

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/PKG-INFO

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

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/README.md

@@ -24,13 +24,13 @@
 ```
 ┌─ tasktree-manager ──────────────────────────────────────────────────────┐
 │  Tasks                    │  Worktrees                                   │
-│  ● DIC-1813 (2)          │    gitops-hpc         DIC-1813        ✗ 3   │
-│    DIC-1770-env          │    hpc                DIC-1813        ✓     │
+│  ● FEAT-42 (2)           │    web-api            FEAT-42          ✗ 3   │
+│    FEAT-38-auth          │    frontend           FEAT-42          ✓     │
 │                          │                                              │
 │                          │                                              │
 ├──────────────────────────────────────────────────────────────────────────┤
-│  Status: gitops-hpc                                                      │
-│  Branch: DIC-1813                                                        │
+│  Status: web-api                                                         │
+│  Branch: FEAT-42                                                         │
 │  Sync:   ↑2 ↓1                                                          │
 │                                                                          │
 │   M  src/main.py                                                        │

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/docs/user-guide.md

@@ -60,7 +60,7 @@ Task: FEAT-123
 ```
 
 **Characteristics:**
-- Created with a unique name (e.g., `FEAT-123`, `DIC-1813-auth`)
+- Created with a unique name (e.g., `FEAT-123`, `BUG-456-auth`)
 - Contains one or more worktrees
 - Stored in `TASKS_DIR/task-name/`
 - Each task gets its own set of branches across selected repos
@@ -696,7 +696,7 @@ gh pr create --head FEAT-123
 ### Naming Conventions
 
 **Task names:**
-- Use issue tracker IDs: `JIRA-1234`, `DIC-1813`
+- Use issue tracker IDs: `JIRA-1234`, `PROJ-567`
 - Or descriptive names: `feat-auth`, `bugfix-login`, `refactor-api`
 - Avoid spaces: Use `-` or `_`
 - Keep short but meaningful

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/pyproject.toml

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

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/scripts/bump_version.py

@@ -125,6 +125,90 @@ def update_pyproject_version(current_version: str, new_version: str, dry_run: bo
     return True
 
 
+def get_changelog_from_commits() -> str:
+    """Generate changelog content from conventional commits since the last tag.
+
+    Parses git log for conventional commit messages and groups them into
+    Added, Changed, and Fixed sections.
+    """
+    # Find the last tag
+    try:
+        result = subprocess.run(
+            ["git", "describe", "--tags", "--abbrev=0"],
+            capture_output=True, text=True, cwd=PROJECT_ROOT,
+        )
+        last_tag = result.stdout.strip() if result.returncode == 0 else ""
+    except Exception:
+        last_tag = ""
+
+    # Get commits since last tag (or all commits if no tag)
+    git_log_cmd = ["git", "log", "--pretty=format:%s"]
+    if last_tag:
+        git_log_cmd.append(f"{last_tag}..HEAD")
+
+    try:
+        result = subprocess.run(
+            git_log_cmd, capture_output=True, text=True, cwd=PROJECT_ROOT,
+        )
+        commits = result.stdout.strip().splitlines() if result.returncode == 0 else []
+    except Exception:
+        commits = []
+
+    if not commits:
+        return ""
+
+    # Conventional commit type -> changelog section mapping
+    added_types = {"feat"}
+    fixed_types = {"fix"}
+    changed_types = {"refactor", "perf", "style", "build", "ci", "chore", "docs", "test"}
+
+    added = []
+    changed = []
+    fixed = []
+
+    # Pattern: type(scope): description  or  type!: description  or  type: description
+    commit_re = re.compile(r"^(\w+)(?:\(([^)]*)\))?(!)?:\s*(.+)$")
+
+    for commit in commits:
+        # Skip release commits
+        if commit.startswith("chore(release):"):
+            continue
+
+        match = commit_re.match(commit)
+        if match:
+            ctype, scope, breaking, description = match.groups()
+            # Capitalize first letter of description
+            description = description[0].upper() + description[1:] if description else description
+            scope_prefix = f"**{scope}**: " if scope else ""
+            entry = f"- {scope_prefix}{description}"
+
+            if breaking:
+                entry = f"- **BREAKING**: {description}"
+                changed.append(entry)
+            elif ctype in added_types:
+                added.append(entry)
+            elif ctype in fixed_types:
+                fixed.append(entry)
+            elif ctype in changed_types:
+                changed.append(entry)
+            else:
+                changed.append(entry)
+        else:
+            # Non-conventional commit — include as-is under Changed
+            if commit.strip():
+                changed.append(f"- {commit}")
+
+    sections = []
+    if added:
+        sections.append("### Added\n" + "\n".join(added))
+    if changed:
+        sections.append("### Changed\n" + "\n".join(changed))
+    if fixed:
+        sections.append("### Fixed\n" + "\n".join(fixed))
+
+    return "\n\n".join(sections)
+
+
 def update_changelog(new_version: str, message: str = "", dry_run: bool = False) -> bool:
     """Update CHANGELOG.md with a new version entry."""
     if not CHANGELOG_PATH.exists():
@@ -142,7 +226,12 @@ def update_changelog(new_version: str, message: str = "", dry_run: bool = False)
     if message:
         new_entry = f"## [{new_version}] - {today}\n\n{message}\n\n"
     else:
-        new_entry = f"## [{new_version}] - {today}\n\n### Added\n- \n\n### Changed\n- \n\n### Fixed\n- \n\n"
+        # Auto-generate from conventional commits
+        changelog_content = get_changelog_from_commits()
+        if changelog_content:
+            new_entry = f"## [{new_version}] - {today}\n\n{changelog_content}\n\n"
+        else:
+            new_entry = f"## [{new_version}] - {today}\n\nNo notable changes.\n\n"
 
     if dry_run:
         print(f"Would add new entry to CHANGELOG.md for version {new_version}")

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/tasktree_manager/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.0.0'
-__version_tuple__ = version_tuple = (2, 0, 0)
+__version__ = version = '2.1.0'
+__version_tuple__ = version_tuple = (2, 1, 0)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/tasktree_manager/app.py

@@ -1,5 +1,6 @@
 """Main application for tasktree-manager."""
 
+import json
 import subprocess
 
 from textual import work
@@ -8,6 +9,7 @@ from textual.binding import Binding
 from textual.containers import Horizontal, Vertical
 from textual.widgets import Footer, Header, Static
 
+from .services.claude_hooks import ensure_claude_hooks
 from .services.config import Config
 from .services.git_ops import GitOps
 from .services.models import GitStatus, Task, Worktree
@@ -141,7 +143,7 @@ class TaskTreeApp(App):
     /* Status panel styling */
     #status-display {
         height: 100%;
-        padding: 0 1;
+        padding: 1 1 0 1;
         background: $background;
         color: $text;
         overflow-y: auto;
@@ -250,6 +252,8 @@ class TaskTreeApp(App):
         self._show_messages_panel: bool = False
         # Used to preserve worktree selection during task list reload
         self._preserved_worktree_name: str | None = None
+        # Claude session statuses: task_name -> status string
+        self._claude_statuses: dict[str, str] = {}
 
     def _build_bindings_from_config(self) -> list[Binding]:
         """Build keybindings list from config.
@@ -306,6 +310,7 @@ class TaskTreeApp(App):
             # Right column: Info/Status panel
             with Vertical(id="right-column"):
                 with Vertical(id="status-panel"):
+                    yield Static("Info", classes="panel-title", id="status-panel-title")
                     yield StatusPanel(id="status-display")
                 with Vertical(id="messages-panel"):
                     yield MessagesPanel(id="messages-display")
@@ -330,6 +335,9 @@ class TaskTreeApp(App):
             task_list = self.query_one("#task-list", TaskList)
             task_list.focus()
 
+        # Poll Claude session status files every 5 seconds
+        self.set_interval(5, self._poll_claude_statuses)
+
     def watch_theme(self, theme: str) -> None:
         """Save theme to config when changed."""
         if hasattr(self, "config") and self.config.theme != theme:
@@ -420,6 +428,27 @@ class TaskTreeApp(App):
         finally:
             task_list.loading = False
 
+    def _poll_claude_statuses(self) -> None:
+        """Check .claude_status files and update task indicators."""
+        try:
+            task_list = self.query_one("#task-list", TaskList)
+        except Exception:
+            return
+
+        statuses: dict[str, str] = {}
+        for task in task_list.tasks:
+            status_file = task.path / ".claude_status"
+            if status_file.exists():
+                try:
+                    data = json.loads(status_file.read_text())
+                    statuses[task.name] = data.get("status", "unknown")
+                except (json.JSONDecodeError, OSError):
+                    pass
+
+        if statuses != self._claude_statuses:
+            self._claude_statuses = statuses
+            task_list.refresh_claude_indicators(statuses)
+
     def _refresh_current_task(self, preserve_selection: bool = False) -> None:
         """Refresh the current task's worktrees and status.
 
@@ -469,6 +498,26 @@ class TaskTreeApp(App):
             self.notify(f"Failed to run {name}: {e}", severity="error")
             return False
 
+    def on_descendant_focus(self, event) -> None:
+        """Handle focus changes to update info panel mode."""
+        try:
+            status_panel = self.query_one("#status-display", StatusPanel)
+        except Exception:
+            return
+
+        if isinstance(event.widget, TaskList):
+            # Task list focused → show task changed files
+            if self.current_task:
+                status_panel.set_loading(True)
+                self._update_task_summary(self.current_task)
+        elif isinstance(event.widget, WorktreeList):
+            # Worktree list focused → show worktree details
+            if self.current_worktree and self.current_status:
+                status_panel.update_status(self.current_worktree, self.current_status)
+            elif self.current_worktree:
+                status_panel.set_loading(True)
+                self._update_worktree_status(self.current_worktree)
+
     def on_task_list_task_highlighted(self, event: TaskList.TaskHighlighted) -> None:
         """Handle task highlight in task list."""
         self.current_task = event.task
@@ -484,6 +533,12 @@ class TaskTreeApp(App):
             preserved = self._preserved_worktree_name
             self._preserved_worktree_name = None  # Clear after use
             worktree_list.load_worktrees(event.task.worktrees, preserve_selection=preserved)
+
+            # Show task summary if task list is focused
+            task_list = self.query_one("#task-list", TaskList)
+            if task_list.has_focus:
+                status_panel.set_loading(True)
+                self._update_task_summary(event.task)
         else:
             worktree_list.clear_worktrees()
             status_panel.clear_status()
@@ -499,12 +554,19 @@ class TaskTreeApp(App):
             # Widget not mounted yet during app startup
             return
 
+        # Only update status panel if worktree list is focused
+        worktree_list = self.query_one("#worktree-list", WorktreeList)
         if event.worktree:
-            status_panel.set_loading(True)
-            self._update_worktree_status(event.worktree)
+            if worktree_list.has_focus:
+                status_panel.set_loading(True)
+                self._update_worktree_status(event.worktree)
+            else:
+                # Still fetch status in background for when user switches focus
+                self._update_worktree_status(event.worktree)
         else:
             self.current_status = None
-            status_panel.clear_status()
+            if worktree_list.has_focus:
+                status_panel.clear_status()
 
     @work(thread=True, exclusive=True, group="status_update")
     def _update_worktree_status(self, worktree: Worktree) -> None:
@@ -520,7 +582,31 @@ class TaskTreeApp(App):
             self.current_status = status
             try:
                 status_panel = self.query_one("#status-display", StatusPanel)
-                status_panel.update_status(worktree, status)
+                # Only show worktree status if worktree list is focused
+                worktree_list = self.query_one("#worktree-list", WorktreeList)
+                if worktree_list.has_focus:
+                    status_panel.update_status(worktree, status)
+            except Exception:
+                pass
+
+    @work(thread=True, exclusive=True, group="task_summary_update")
+    def _update_task_summary(self, task: Task) -> None:
+        """Fetch git status for all dirty worktrees in background thread."""
+        statuses: dict[str, GitStatus] = {}
+        for wt in task.worktrees:
+            if wt.is_dirty:
+                statuses[wt.name] = GitOps.get_status(wt)
+        self.call_from_thread(self._apply_task_summary, task, statuses)
+
+    def _apply_task_summary(self, task: Task, statuses: dict[str, GitStatus]) -> None:
+        """Apply fetched task summary to the UI (called on main thread)."""
+        # Only update if this task is still selected and task list is focused
+        if self.current_task and self.current_task.name == task.name:
+            try:
+                status_panel = self.query_one("#status-display", StatusPanel)
+                task_list = self.query_one("#task-list", TaskList)
+                if task_list.has_focus:
+                    status_panel.update_task_summary(task, statuses)
             except Exception:
                 pass
 
@@ -918,7 +1004,7 @@ class TaskTreeApp(App):
             self.query_one("#worktree-list", WorktreeList).focus()
 
     def action_open_claude_resume(self) -> None:
-        """Open Claude Code with session list (claude -r) in the current task folder."""
+        """Open Claude Code in a new Ghostty tab (resume session)."""
         if not self.current_task:
             self.notify("No task selected", severity="warning")
             return
@@ -928,30 +1014,17 @@ class TaskTreeApp(App):
             self.notify("Task directory not found", severity="error")
             return
 
-        saved_task_name = self.current_task.name
-        saved_worktree_name = self.current_worktree.name if self.current_worktree else None
-
         # Fetch fresh task data to ensure worktrees are up-to-date
-        fresh_task = self.task_manager.get_task(saved_task_name)
+        fresh_task = self.task_manager.get_task(self.current_task.name)
         if fresh_task:
-            # Create claude.md files if they don't exist
             self.task_manager.ensure_claude_md_files(fresh_task)
 
-        self.notify("Opening Claude Code (resume)...")
-
-        with self.suspend():
-            self._run_external_command(
-                [self.config.claude_path, "-r"],
-                cwd=task_path,
-                name="Claude Code",
-                install_hint="npm install -g @anthropic-ai/claude-code",
-            )
-
-        self._load_tasks_with_selection(saved_task_name, saved_worktree_name)
-        self.query_one("#task-list", TaskList).focus()
+        ensure_claude_hooks(task_path)
+        self._open_ghostty_tab(task_path, command=f"{self.config.claude_path} -r")
+        self.notify("Opened Claude Code in new tab (resume)")
 
     def action_open_claude_new(self) -> None:
-        """Open a new Claude Code session in the current task folder."""
+        """Open a new Claude Code session in a new Ghostty tab."""
         if not self.current_task:
             self.notify("No task selected", severity="warning")
             return
@@ -961,27 +1034,14 @@ class TaskTreeApp(App):
             self.notify("Task directory not found", severity="error")
             return
 
-        saved_task_name = self.current_task.name
-        saved_worktree_name = self.current_worktree.name if self.current_worktree else None
-
         # Fetch fresh task data to ensure worktrees are up-to-date
-        fresh_task = self.task_manager.get_task(saved_task_name)
+        fresh_task = self.task_manager.get_task(self.current_task.name)
         if fresh_task:
-            # Create claude.md files if they don't exist
             self.task_manager.ensure_claude_md_files(fresh_task)
 
-        self.notify("Opening new Claude Code session...")
-
-        with self.suspend():
-            self._run_external_command(
-                [self.config.claude_path],
-                cwd=task_path,
-                name="Claude Code",
-                install_hint="npm install -g @anthropic-ai/claude-code",
-            )
-
-        self._load_tasks_with_selection(saved_task_name, saved_worktree_name)
-        self.query_one("#task-list", TaskList).focus()
+        ensure_claude_hooks(task_path)
+        self._open_ghostty_tab(task_path, command=self.config.claude_path)
+        self.notify("Opened new Claude Code session in new tab")
 
     def action_open_folder(self) -> None:
         """Open current folder in a new terminal tab."""
@@ -1006,15 +1066,23 @@ class TaskTreeApp(App):
         # Open in new terminal tab
         self._open_ghostty_tab(folder_path)
 
-    def _open_ghostty_tab(self, path) -> None:
-        """Open a new terminal tab at the given path.
+    def _open_ghostty_tab(self, path, command: str | None = None) -> None:
+        """Open a new terminal tab at the given path, optionally running a command.
 
         NOTE: This implementation is specific to the Ghostty terminal emulator
         on macOS, using AppleScript. It will silently fail on other terminals.
+
+        Args:
+            path: Directory to cd into in the new tab
+            command: Optional command to run after cd (e.g., "claude -r")
         """
         # Ghostty: Use AppleScript to activate and open new tab, then cd
         # Escape single quotes for AppleScript string interpolation
         safe_path = str(path).replace("'", "'\\''")
+        if command:
+            shell_cmd = f"cd '{safe_path}' && clear && {command}"
+        else:
+            shell_cmd = f"cd '{safe_path}' && clear"
         script = f"""
         tell application "Ghostty"
             activate
@@ -1023,7 +1091,7 @@ class TaskTreeApp(App):
             tell process "Ghostty"
                 keystroke "t" using command down
                 delay 0.1
-                keystroke "cd '{safe_path}' && clear"
+                keystroke "{shell_cmd}"
                 key code 36
             end tell
         end tell

tasktree_manager-2.1.0/tasktree_manager/services/claude_hooks.py

@@ -0,0 +1,50 @@
+"""Claude Code hook configuration for status monitoring."""
+
+import json
+from pathlib import Path
+
+
+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("'", "'\\''")
+    return {
+        "type": "command",
+        "command": f"printf '{{\"status\":\"{status}\",\"ts\":%d}}' $(date +%s) > '{safe_path}'",
+        "async": True,
+    }
+
+
+def _build_hooks_config(task_path: Path) -> dict:
+    """Build hooks config with absolute path to status file."""
+    status_file = str(task_path / ".claude_status")
+    return {
+        "SessionStart": [{"hooks": [_make_hook("running", status_file)]}],
+        "UserPromptSubmit": [{"hooks": [_make_hook("running", status_file)]}],
+        "Stop": [{"hooks": [_make_hook("waiting", status_file)]}],
+        "SessionEnd": [{"hooks": [_make_hook("ended", status_file)]}],
+    }
+
+
+def ensure_claude_hooks(task_path: Path) -> None:
+    """Create .claude/settings.local.json with status-reporting hooks.
+
+    Merges with existing settings if the file already exists, preserving
+    user's own configuration while adding/updating the status hooks.
+    """
+    claude_dir = task_path / ".claude"
+    claude_dir.mkdir(exist_ok=True)
+
+    settings_file = claude_dir / "settings.local.json"
+
+    if settings_file.exists():
+        try:
+            existing = json.loads(settings_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            existing = {}
+    else:
+        existing = {}
+
+    # Merge hooks into existing settings
+    existing["hooks"] = _build_hooks_config(task_path)
+
+    settings_file.write_text(json.dumps(existing, indent=2) + "\n")

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/tasktree_manager/widgets/status_panel.py

@@ -3,19 +3,23 @@
 from rich.text import Text
 from textual.widgets import Static
 
-from ..services.models import GitStatus, Worktree
+from ..services.models import GitStatus, Task, Worktree
 
 
 class StatusPanel(Static):
-    """Panel displaying git status for selected worktree."""
+    """Panel displaying git status for selected worktree or task summary."""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._worktree_name: str = ""
         self._status: GitStatus | None = None
+        self._current_task: Task | None = None
+        self._task_statuses: dict[str, GitStatus] = {}
+        self._mode: str = "worktree"  # "worktree" or "task"
 
     def update_status(self, worktree: Worktree | None, status: GitStatus | None) -> None:
         """Update the status display for a worktree."""
+        self._mode = "worktree"
         if worktree is None or status is None:
             self._worktree_name = ""
             self._status = None
@@ -26,8 +30,69 @@ class StatusPanel(Static):
         self._status = status
         self._update_display()
 
+    def update_task_summary(
+        self, task: Task | None, statuses: dict[str, GitStatus] | None = None
+    ) -> None:
+        """Update the display with a task summary.
+
+        Args:
+            task: The task to display
+            statuses: Optional dict of worktree_name -> GitStatus with file details
+        """
+        self._mode = "task"
+        self._current_task = task
+        self._task_statuses = statuses or {}
+        self._update_display()
+
     def _update_display(self) -> None:
         """Update the display content."""
+        if self._mode == "task":
+            self._render_task_summary()
+        else:
+            self._render_worktree_status()
+
+    def _render_task_summary(self) -> None:
+        """Render the task summary view — changed files grouped by repo."""
+        if self._current_task is None:
+            self.update(Text("No task selected", style="dim"))
+            return
+
+        task = self._current_task
+        text = Text()
+
+        dirty_worktrees = [wt for wt in task.worktrees if wt.is_dirty]
+
+        if not dirty_worktrees:
+            text.append("All repos clean", style="green")
+            self.update(text)
+            return
+
+        for wt in dirty_worktrees:
+            # Repo header
+            text.append(f"{wt.name}", style="bold")
+            text.append("\n")
+
+            status = self._task_statuses.get(wt.name)
+            if status:
+                for status_code, filename in status.all_changes:
+                    if status_code.strip().startswith("?"):
+                        text.append(f" {status_code} ", style="red")
+                        text.append(f"{filename}\n", style="red")
+                    elif status_code.strip().startswith("M") or status_code.strip() == "M":
+                        text.append(f" {status_code} ", style="yellow")
+                        text.append(f"{filename}\n")
+                    else:
+                        text.append(f" {status_code} ", style="green")
+                        text.append(f"{filename}\n")
+            else:
+                text.append(f"  {wt.changed_files} files changed\n", style="dim italic")
+
+            text.append("\n")
+
+        self.update(text)
+
+    def _render_worktree_status(self) -> None:
+        """Render the worktree-specific status view."""
         if not self._worktree_name or self._status is None:
             self.update(Text("No worktree selected", style="dim"))
             return
@@ -81,6 +146,8 @@ class StatusPanel(Static):
         """Clear the status display."""
         self._worktree_name = ""
         self._status = None
+        self._current_task = None
+        self._mode = "worktree"
         self.update(Text("No worktree selected", style="dim"))
 
     def set_loading(self, loading: bool = True) -> None:

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/tasktree_manager/widgets/task_list.py

@@ -60,27 +60,42 @@ class TaskList(OptionList):
         """Compatibility property - sets highlighted index."""
         self.highlighted = value
 
-    def _format_task_option(self, task: Task) -> Option:
+    def _format_task_option(self, task: Task, claude_status: str | None = None) -> Option:
         """Format a task as an Option for display."""
-        claude_indicator = "[blue]◆[/]" if task.has_claude_md else " "
+        claude_md = "[blue]◆[/]" if task.has_claude_md else " "
+        if claude_status == "running":
+            hook_indicator = " [magenta]⟳[/]"
+        elif claude_status == "waiting":
+            hook_indicator = " [yellow]![/]"
+        elif claude_status == "ended":
+            hook_indicator = " [green]✓[/]"
+        else:
+            hook_indicator = ""
         if task.is_dirty:
-            prompt = f"[red]●[/]{claude_indicator}{task.name} [red]({task.dirty_count})[/]"
+            prompt = f"[red]●[/]{claude_md}{task.name} [red]({task.dirty_count})[/]{hook_indicator}"
         else:
-            prompt = f"  {claude_indicator}{task.name}"
+            prompt = f"  {claude_md}{task.name}{hook_indicator}"
         return Option(prompt, id=task.name)
 
-    def load_tasks(self, tasks: list[Task], preserve_selection: str | None = None) -> None:
+    def load_tasks(
+        self,
+        tasks: list[Task],
+        preserve_selection: str | None = None,
+        claude_statuses: dict[str, str] | None = None,
+    ) -> None:
         """Load tasks into the list.
 
         Args:
             tasks: List of tasks to load
             preserve_selection: Optional task name to preserve selection for
+            claude_statuses: Optional dict of task_name -> claude status string
         """
         sorted_tasks = self._sort_tasks(tasks)
         self.tasks = sorted_tasks
         self.clear_options()
+        statuses = claude_statuses or {}
         for task in sorted_tasks:
-            self.add_option(self._format_task_option(task))
+            self.add_option(self._format_task_option(task, statuses.get(task.name)))
 
         # Select item - preserve previous selection if specified
         if self.tasks and self.option_count > 0:
@@ -131,6 +146,15 @@ class TaskList(OptionList):
             self.highlighted = current_index
             self._emit_highlighted()
 
+    def refresh_claude_indicators(self, statuses: dict[str, str]) -> None:
+        """Update Claude status indicators without full reload.
+
+        Re-renders all option labels with updated claude status indicators.
+        """
+        for i, task in enumerate(self.tasks):
+            new_option = self._format_task_option(task, statuses.get(task.name))
+            self.replace_option_prompt_at_index(i, new_option.prompt)
+
     def cycle_sort_mode(self) -> None:
         """Cycle through sort modes and reload tasks."""
         modes = list(SortMode)

{tasktree_manager-2.0.0 → tasktree_manager-2.1.0}/tasktree_manager/widgets/worktree_list.py

@@ -140,9 +140,9 @@ class WorktreeList(OptionList):
         claude_indicator = "[blue]◆[/]" if worktree.has_claude_md else " "
 
         if worktree.is_dirty:
-            prompt = f" {claude_indicator}{name_col}  [cyan]{branch_col}[/]  [red]✗ {worktree.changed_files} files[/]"
+            prompt = f" {claude_indicator}{name_col}  {branch_col}  [red]✗ {worktree.changed_files} files[/]"
         else:
-            prompt = f" {claude_indicator}{name_col}  [cyan]{branch_col}[/]  [green]✓[/]"
+            prompt = f" {claude_indicator}{name_col}  {branch_col}  [green]✓[/]"
         self.add_option(Option(prompt, id=worktree.name))
 
     def _emit_highlighted(self) -> None: