tasktree-manager 2.14.0__tar.gz → 2.16.0__tar.gz

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/CHANGELOG.md

@@ -15,6 +15,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.16.0] - 2026-10-19
+
+### Added
+- **epic**: Add a managed epic block to task CLAUDE.md files
+
+
+## [2.15.0] - 2026-10-19
+
+### Added
+- **epic**: Show epics as foldable groups in the task list
+
+
 ## [2.14.0] - 2026-10-19
 
 ### Added

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/PKG-INFO

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

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/README.md

@@ -22,6 +22,7 @@
 - 🛰️ **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
+- 🗂️ **Epics** - Group related tasks under an epic: a foldable row with rolled-up dirty and Claude state, `E` to attach tasks
 - 📦 **Finish Flow with Archives** - Ending a task saves its combined diff (committed-but-unmerged + uncommitted) and the task-folder files outside the worktrees (plans, ADRs, notes) to an archive before deleting
 
 ## 📊 Status Indicators
@@ -39,6 +40,8 @@
 | `↓N` yellow | N commits behind remote |
 | `○` green / `●` magenta / `×` red | MR open / merged / closed |
 | `◐` yellow / `✔` green / `✘` red | CI running / passed / failed |
+| `▾` / `▸` | Epic, unfolded / folded (`· N` = its task count) |
+| `├` / `└` | Task inside the epic above |
 
 ## 🚀 Quick Start
 
@@ -99,7 +102,9 @@ tasktree-manager epic mark DIC-2466-pcaps-epic                # turn an existing
 tasktree-manager epic list                                    # epics and their tasks; also --json
 ```
 
-Epics don't nest. `list --json` and `status --json` carry `kind` (`task` or `epic`) and
+Each task's `CLAUDE.md` gets a managed block naming its epic and how to find sibling
+tasks; it follows every epic change and leaves the rest of the file alone. Epics don't
+nest. `list --json` and `status --json` carry `kind` (`task` or `epic`) and
 `epic` (the parent epic or `null`). `delete` and `finish` refuse an epic that still has
 tasks, even with `--force`.
 
@@ -141,7 +146,8 @@ a Claude Code statusline or shell prompt.
 | `r` | Refresh | `s` | Sort tasks |
 | `S` | Group worktrees | `m` | Messages |
 | `t` | Cycle theme | `Tab` | Next panel |
-| `R` | Rename task | | |
+| `R` | Rename task | `E` | Set epic |
+| `enter` | Fold epic | | |
 | `?` | Show help | `q` | Quit |
 
 **Themes:** The default `tasktree` theme pairs a lazygit-classic ANSI palette with layered panels, numbered title bars, green focus borders, and a keycap footer. Five more design-system palettes ship tuned to the same shape — tokyo-night, catppuccin-mocha, gruvbox, dracula, nord — and every other Textual built-in theme works too (`Ctrl+P` to switch); the whole UI is styled with Textual design tokens, so any theme restyles it consistently.
@@ -223,10 +229,10 @@ For comprehensive troubleshooting, see the [Troubleshooting Guide](docs/troubles
 Recently shipped: agent dashboard (per-worktree Claude session badges + background dispatch),
 forge-aware merged detection (glab/gh, squash/rebase merges), MR/CI status badges,
 guided `finish` flow that archives the diff and the task-folder files, `status` subcommand
-for scripts and statuslines, Claude session recap in the Info panel.
+for scripts and statuslines, Claude session recap in the Info panel, epics in the CLI, the
+task list and each task's CLAUDE.md.
 
-Next: epics, a layer that groups related tasks (for example a Jira epic and its child
-tasks) in the task list.
+Ideas and bugs go to [GitHub Issues](https://github.com/ruslanfialkovskii/tasktree-manager/issues).
 
 See [CHANGELOG.md](CHANGELOG.md) for the release history.
 

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/docs/configuration.md

@@ -246,6 +246,7 @@ new_task = "n"          # Create new task
 add_repo = "a"          # Add repository to current task
 delete_task = "d"       # Delete/finish task
 rename_task = "R"       # Rename task display label (folder/branch unchanged, shift+r)
+set_epic = "E"          # Set the task's epic, or make the task an epic (shift+e)
 delete_worktree = "D"   # Remove single worktree from task (shift+d)
 
 # Git operations
@@ -592,7 +593,7 @@ blocklist = ["*"]
 
 ## Keybindings Reference
 
-All 22 customizable keybindings with descriptions:
+All 27 customizable keybindings with descriptions:
 
 ### Application Control
 
@@ -610,6 +611,7 @@ All 22 customizable keybindings with descriptions:
 | `add_repo`    | `a`     | Add repository to current task         | `add_repo = "ctrl+a"`      |
 | `delete_task` | `d`     | Delete/finish current task             | `delete_task = "delete"`   |
 | `rename_task` | `R`     | Rename task display label (alias only) | `rename_task = "ctrl+r"`   |
+| `set_epic`    | `E`     | Set the task's epic, or make it an epic | `set_epic = "ctrl+e"`     |
 
 ### Git Operations
 

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/docs/user-guide.md

@@ -65,6 +65,32 @@ Task: FEAT-123
 - Stored in `TASKS_DIR/task-name/`
 - Each task gets its own set of branches across selected repos
 
+### Epics
+
+An **epic** groups related tasks, for example a Jira epic and its child tasks.
+An epic is a task folder too: it can hold notes, a Claude session and its own
+worktrees, or none. Child tasks keep their own folders; only a marker file
+names their epic, so nothing moves on disk.
+
+```
+▾ ● DIC-2466-pcaps-epic · 3
+├   DIC-2861-pcaps-logs
+├ ● DIC-2862-pcaps-s3
+└   DIC-2865-pcaps-docs
+```
+
+- Press `E` on a task to add it to an epic, move it, remove it, create a new
+  empty epic for it, or turn the task itself into an epic.
+- `n` and `y` preselect the epic of the highlighted row.
+- `enter` or `space` folds an epic. A folded epic row still shows the dirty
+  count and the most urgent Claude state of its tasks.
+- Epics don't nest. An epic that still has tasks can't be deleted.
+- Each task's `CLAUDE.md` gets a short block between `<!-- tasktree:epic -->` markers
+  that names the epic folder and how to find sibling tasks, so a Claude session knows
+  the bigger picture. It updates on every epic change; text outside the markers is
+  never touched.
+- From scripts: `tasktree-manager epic create/add/remove/mark/unmark/list`.
+
 ### Worktrees
 
 A **worktree** is a git working directory for a specific repository within a task.
@@ -186,6 +212,8 @@ Shows all your tasks:
 - **CLAUDE.md indicator** `◆`: Blue diamond — task has a CLAUDE.md file
 - **Claude session status**: `⟳` running (magenta), `!` waiting (yellow), `✓` ended (green)
 - **Sort mode**: Press `s` to cycle through sort modes (name ↑/↓, date ↑/↓, dirty/clean first)
+- **Epics**: `▾`/`▸` marks an epic with its task count; its tasks follow with `├`/`└`.
+  An epic sorts by its newest task and counts as dirty when any task is dirty
 
 **Navigation:**
 - `j/k` or arrow keys: Move up/down
@@ -318,6 +346,8 @@ what is displayed. Press `?` for the full reference at any time.
 | `a` | Add repository   | Add additional repositories to the current task           |
 | `d` | Delete/finish    | Delete current task and remove worktrees                  |
 | `R` | Rename task      | Set a display alias shown in the task list (folder/branch unchanged; empty input reverts) |
+| `E` | Set epic         | Add the task to an epic, move or remove it, or make it an epic |
+| `enter`/`space` | Fold epic | Fold or unfold the highlighted epic (on a task, folds its epic) |
 
 **Task creation workflow:**
 1. Press `n`

{tasktree_manager-2.14.0 → tasktree_manager-2.16.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.14.0"
+version = "2.16.0"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"

{tasktree_manager-2.14.0 → tasktree_manager-2.16.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.14.0'
-__version_tuple__ = version_tuple = (2, 14, 0)
+__version__ = version = '2.16.0'
+__version_tuple__ = version_tuple = (2, 16, 0)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/tasktree_manager/app.py

@@ -24,7 +24,7 @@ from .services.claude_sessions import ClaudeRecap, read_claude_recap, transcript
 from .services.config import Config, ConfigError
 from .services.forge import Forge, ForgeStatus, get_forge_status
 from .services.git_ops import GitOps
-from .services.models import ArchiveResult, GitStatus, Task, TaskSafetyReport, Worktree
+from .services.models import EPIC_KIND, ArchiveResult, GitStatus, Task, TaskSafetyReport, Worktree
 from .services.task_manager import ARCHIVE_NOTES_SHOWN, TaskManager
 from .themes import ALL_THEMES, THEME_CYCLE
 from .widgets.app_header import AppHeader
@@ -33,7 +33,9 @@ from .widgets.create_modal import (
     ConfirmModal,
     CreateTaskModal,
     DispatchAgentModal,
+    EpicPickerModal,
     HelpModal,
+    NewEpicModal,
     PushResultModal,
     RenameTaskModal,
     SafeDeleteModal,
@@ -199,6 +201,7 @@ class TaskTreeApp(App):
         Binding("y", "clone_task", "Clone", show=False),
         Binding("a", "add_repo", "Add Repo", show=False),
         Binding("d", "delete_task", "Delete", show=False),
+        Binding("E", "set_epic", "Epic", show=False),
         Binding("g", "open_lazygit", "Lazygit", show=False),
         Binding("h", "show_diff", "Diff", show=False),
         Binding("e", "open_editor", "Editor", show=False),
@@ -281,6 +284,7 @@ class TaskTreeApp(App):
             Binding(kb.get("add_repo", "a"), "add_repo", "Add Repo", show=False),
             Binding(kb.get("delete_task", "d"), "delete_task", "Delete", show=False),
             Binding(kb.get("rename_task", "R"), "rename_task", "Rename", show=False),
+            Binding(kb.get("set_epic", "E"), "set_epic", "Epic", show=False),
             Binding(kb.get("open_lazygit", "g"), "open_lazygit", "Lazygit", show=False),
             Binding(kb.get("show_diff", "h"), "show_diff", "Diff", show=False),
             Binding(kb.get("open_editor", "e"), "open_editor", "Editor", show=False),
@@ -347,6 +351,7 @@ class TaskTreeApp(App):
             (kb.get("add_repo", "a"), "add_repo", "Add Repo"),
             (kb.get("delete_task", "d"), "delete_task", "Delete"),
             (kb.get("rename_task", "R"), "rename_task", "Rename"),
+            (kb.get("set_epic", "E"), "set_epic", "Epic"),
             (kb.get("show_diff", "h"), "show_diff", "Diff"),
             (kb.get("open_claude_resume", "c"), "open_claude_resume", "Claude"),
             (kb.get("cycle_sort", "s"), "cycle_sort", "Sort"),
@@ -373,7 +378,12 @@ class TaskTreeApp(App):
                             id="task-panel-title",
                         )
                         yield Static("", classes="panel-counter", id="task-panel-counter")
-                    yield TaskList(id="task-list", context_bindings=task_panel_bindings)
+                    yield TaskList(
+                        id="task-list",
+                        context_bindings=task_panel_bindings,
+                        # A fold key bound to any action in config stays that action
+                        fold_keys=tuple(k for k in ("enter", "space") if k not in kb.values()),
+                    )
                 with Vertical(id="worktree-panel"):
                     with Horizontal(classes="panel-title-bar"):
                         yield Static(
@@ -591,7 +601,7 @@ class TaskTreeApp(App):
         follow-up scan can skip its UI reload when nothing actually changed.
         """
         try:
-            previous = self.query_one("#task-list", TaskList).tasks
+            previous = self.query_one("#task-list", TaskList).all_tasks
         except Exception:
             return
         known = {(task.name, wt.name): wt for task in previous for wt in task.worktrees}
@@ -645,7 +655,8 @@ class TaskTreeApp(App):
             return
 
         statuses: dict[str, str] = {}
-        for task in task_list.tasks:
+        # all_tasks: a folded child still feeds its epic row rollup
+        for task in task_list.all_tasks:
             status_file = task.path / ".claude_status"
             if not status_file.exists():
                 continue
@@ -659,7 +670,9 @@ class TaskTreeApp(App):
                 # Valid JSON but not an object (e.g. "[]") - .get() below
                 # would raise AttributeError and kill the poll interval
                 continue
-            statuses[task.name] = data.get("status", "unknown")
+            status = data.get("status", "unknown")
+            if isinstance(status, str):
+                statuses[task.name] = status
 
         if statuses != self._claude_statuses:
             self._claude_statuses = statuses
@@ -670,6 +683,9 @@ class TaskTreeApp(App):
                 except Exception:
                     return
                 status_panel.set_claude_live_status(statuses.get(self.current_task.name))
+                if self.current_task.is_epic:
+                    children, _ = self._epic_context(self.current_task, task_list)
+                    status_panel.set_epic_children(self.current_task.name, children or [])
 
         # 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:
@@ -719,7 +735,7 @@ class TaskTreeApp(App):
             task_list = self.query_one("#task-list", TaskList)
         except Exception:
             return
-        paths = [str(wt.path) for task in task_list.tasks for wt in task.worktrees]
+        paths = [str(wt.path) for task in task_list.all_tasks for wt in task.worktrees]
         if paths:
             self._run_agent_poll(paths)
 
@@ -850,6 +866,8 @@ class TaskTreeApp(App):
         return tuple(
             (
                 task.name,
+                task.kind,
+                task.epic_name,
                 tuple((wt.name, wt.branch, wt.is_dirty, wt.changed_files) for wt in task.worktrees),
             )
             for task in tasks
@@ -1131,10 +1149,46 @@ class TaskTreeApp(App):
                 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)
+                    children, parent = self._epic_context(task, task_list)
+                    status_panel.update_task_summary(
+                        task, statuses, epic_children=children, epic_label=parent
+                    )
             except Exception:
                 pass
 
+    def _epic_context(
+        self, task: Task, task_list: TaskList
+    ) -> tuple[list[tuple[str, bool, str | None]] | None, str | None]:
+        """The Info panel epic block (children) or parent line for a task."""
+        if task.is_epic:
+            children = [
+                (child.display_label, child.is_dirty, self._claude_statuses.get(child.name))
+                for child in task_list.epic_children(task.name)
+            ]
+            return children, None
+        epic_name = task_list.epic_of(task.name)
+        if epic_name is None:
+            return None, None
+        parent = next(t for t in task_list.all_tasks if t.name == epic_name)
+        return None, parent.display_label
+
+    def _epic_choices(self) -> list[tuple[str, str]]:
+        """(label, name) of every loaded epic, sorted by label."""
+        try:
+            tasks = self.query_one("#task-list", TaskList).all_tasks
+        except Exception:
+            return []
+        epics = [(task.display_label, task.name) for task in tasks if task.is_epic]
+        return sorted(epics, key=lambda pair: pair[0].lower())
+
+    def _epic_of(self, task: Task | None) -> str | None:
+        """The epic a new task next to `task` should join: itself or its parent."""
+        if task is None:
+            return None
+        if task.is_epic:
+            return task.name
+        return self.query_one("#task-list", TaskList).epic_of(task.name)
+
     def action_quit(self) -> None:
         """Quit the application."""
         self.exit()
@@ -1168,16 +1222,23 @@ class TaskTreeApp(App):
 
         def handle_result(result):
             if result and self._begin_mutation("task-list"):
-                name, repos, base_branch = result
-                self._create_task_worker(name, repos, base_branch, verb="created")
+                name, repos, base_branch, epic = result
+                self._create_task_worker(name, repos, base_branch, verb="created", epic=epic)
 
         self.push_screen(
-            CreateTaskModal(available_repos, initial_base_branch=self.config.default_base_branch),
+            CreateTaskModal(
+                available_repos,
+                initial_base_branch=self.config.default_base_branch,
+                epics=self._epic_choices(),
+                initial_epic=self._epic_of(self.current_task),
+            ),
             handle_result,
         )
 
     @work(thread=True, group="task_mutation")
-    def _create_task_worker(self, name: str, repos: list[str], base_branch: str, verb: str) -> None:
+    def _create_task_worker(
+        self, name: str, repos: list[str], base_branch: str, verb: str, epic: str | None = None
+    ) -> None:
         """Create a task in a background thread.
 
         Creation fetches the base branch from origin for every repo, so it
@@ -1186,7 +1247,7 @@ class TaskTreeApp(App):
         """
         error: str | None = None
         try:
-            self.task_manager.create_task(name, repos, base_branch)
+            self.task_manager.create_task(name, repos, base_branch, epic=epic)
         except FileNotFoundError as e:
             error = f"Repository not found: {e}"
         except PermissionError:
@@ -1196,10 +1257,10 @@ class TaskTreeApp(App):
             error = str(e)
         except Exception as e:
             error = f"{type(e).__name__}: {e}"
-        self.call_from_thread(self._apply_create_task_result, name, len(repos), verb, error)
+        self.call_from_thread(self._apply_create_task_result, name, len(repos), verb, error, epic)
 
     def _apply_create_task_result(
-        self, name: str, repo_count: int, verb: str, error: str | None
+        self, name: str, repo_count: int, verb: str, error: str | None, epic: str | None = None
     ) -> None:
         """Report the create/clone outcome and reload (runs on the main thread)."""
         if error:
@@ -1208,8 +1269,11 @@ class TaskTreeApp(App):
             self._load_tasks()
         else:
             self.notify(escape(f"Created task: {name}"))
+            in_epic = f" in epic '{epic}'" if epic else ""
             self._log_activity(
-                f"Task '{name}' {verb} with {repo_count} repo(s)", MessageLevel.SUCCESS, name
+                f"Task '{name}' {verb} with {repo_count} repo(s){in_epic}",
+                MessageLevel.SUCCESS,
+                name,
             )
             self._load_tasks(select_task=name)
 
@@ -1228,8 +1292,8 @@ class TaskTreeApp(App):
 
         def handle_result(result):
             if result and self._begin_mutation("task-list"):
-                name, repos, base_branch = result
-                self._create_task_worker(name, repos, base_branch, verb="cloned")
+                name, repos, base_branch, epic = result
+                self._create_task_worker(name, repos, base_branch, verb="cloned", epic=epic)
 
         self.push_screen(
             CreateTaskModal(
@@ -1237,6 +1301,8 @@ class TaskTreeApp(App):
                 initial_repos=source_repos,
                 initial_base_branch=self.config.default_base_branch,
                 title=f"Clone Task: {self.current_task.name}",
+                epics=self._epic_choices(),
+                initial_epic=self._epic_of(self.current_task),
             ),
             handle_result,
         )
@@ -1376,6 +1442,91 @@ class TaskTreeApp(App):
 
         self.push_screen(RenameTaskModal(task.name, task.display_name), handle_rename)
 
+    def action_set_epic(self) -> None:
+        """Attach the current task to an epic, detach it, or make it an epic."""
+        task = self.current_task
+        if not task:
+            self.notify("No task selected", severity="warning")
+            return
+        if task.is_epic:
+            self.notify("Epics don't nest: an epic can't join another epic", severity="warning")
+            return
+        epics = [(label, name) for label, name in self._epic_choices() if name != task.name]
+
+        def handle_choice(choice: tuple[str, str | None] | None) -> None:
+            if choice is None:
+                return
+            action, epic = choice
+            if action == "new":
+                self.push_screen(
+                    NewEpicModal(task.name),
+                    lambda name: self._apply_epic_choice(task, "new", name) if name else None,
+                )
+            else:
+                self._apply_epic_choice(task, action, epic)
+
+        self.push_screen(
+            EpicPickerModal(
+                task.display_label,
+                epics,
+                self.query_one("#task-list", TaskList).epic_of(task.name),
+                task.epic_name is None,
+            ),
+            handle_choice,
+        )
+
+    def _apply_epic_choice(self, task: Task, action: str, epic: str | None) -> None:
+        """Write the picked epic change; marker writes are local and fast."""
+        if self._mutation_in_flight():
+            # A delete worker may be rmtree-ing the very folders written here
+            self.notify("Another task operation is still running", severity="warning")
+            return
+        previous = task.epic_name
+        try:
+            if action == "new" and epic:
+                self.task_manager.create_task(epic, [], kind=EPIC_KIND)
+                try:
+                    epic = self.task_manager.set_task_epic(task, epic)
+                except (ValueError, OSError) as e:
+                    # The epic exists now; show it and say what did not happen
+                    self.notify(
+                        escape(f"Created epic '{epic}' but could not add '{task.name}': {e}"),
+                        severity="warning",
+                    )
+                    self._load_tasks(select_task=epic)
+                    return
+                message = f"Created epic '{epic}' and added '{task.name}' to it"
+            elif action == "set" and epic:
+                epic = self.task_manager.set_task_epic(task, epic)
+                if previous == epic:
+                    message = f"Task '{task.name}' already in epic '{epic}'"
+                elif previous:
+                    message = f"Moved '{task.name}' from epic '{previous}' to '{epic}'"
+                else:
+                    message = f"Added '{task.name}' to epic '{epic}'"
+            elif action == "none":
+                self.task_manager.set_task_epic(task, None)
+                message = (
+                    f"Removed '{task.name}' from epic '{previous}'"
+                    if previous
+                    else f"Task '{task.name}' is not in an epic"
+                )
+            elif action == "mark":
+                self.task_manager.set_task_kind(task, EPIC_KIND)
+                message = f"Task '{task.name}' is an epic now"
+            else:
+                return
+        except (ValueError, OSError) as e:
+            self.notify(escape(f"Epic change failed: {e}"), severity="error")
+            return
+        self.notify(escape(message))
+        self._log_activity(message, MessageLevel.INFO, task.name)
+        problem = self.task_manager.sync_epic_block(task)
+        if problem:
+            self.notify(escape(problem), severity="warning")
+            self._log_activity(problem, MessageLevel.WARNING, task.name)
+        self._load_tasks(select_task=task.name)
+
     def _finish_task(self, task: Task, force: bool = False) -> None:
         """Kick off task deletion in a background thread."""
         if not self._begin_mutation("task-list"):
@@ -1831,6 +1982,9 @@ class TaskTreeApp(App):
             return
 
         task = self.current_task
+        if not task.worktrees:
+            self.notify("Task has no worktrees", severity="information")
+            return
 
         # Building the combined diff is local git work, but it scales with
         # the size of the trees (one add + diff per worktree), so it runs in
@@ -2262,6 +2416,9 @@ class TaskTreeApp(App):
             # that's disappearing under it.
             self.notify("Another task operation is still running", severity="warning")
             return
+        if not self.current_task.worktrees:
+            self.notify("Task has no worktrees", severity="information")
+            return
 
         worktree_list = self.query_one("#worktree-list", WorktreeList)
         worktree_list.loading = True
@@ -2285,6 +2442,9 @@ class TaskTreeApp(App):
         if self._mutation_in_flight():
             self.notify("Another task operation is still running", severity="warning")
             return
+        if not self.current_task.worktrees:
+            self.notify("Task has no worktrees", severity="information")
+            return
 
         worktree_list = self.query_one("#worktree-list", WorktreeList)
         worktree_list.loading = True

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/tasktree_manager/cli.py

@@ -213,9 +213,17 @@ def _create(
     if task.epic_name is not None:
         line += f" in epic {task.epic_name}"
     print(line)
+    _warn_epic_block(manager, task)
     return 0
 
 
+def _warn_epic_block(manager: TaskManager, task: Task) -> None:
+    """Print why the task's CLAUDE.md epic block could not follow a change."""
+    problem = manager.sync_epic_block(task)
+    if problem:
+        print(f"warning: {problem}", file=sys.stderr)
+
+
 def _get_tasks(manager: TaskManager, names: list[str]) -> list[Task] | None:
     """Resolve task names, printing an error for each missing one (None if any)."""
     tasks = []
@@ -250,6 +258,7 @@ def cmd_epic_add(manager: TaskManager, config: Config, args: argparse.Namespace)
             print(f"Added {task.name} to epic {epic}")
         else:
             print(f"Moved {task.name} from epic {previous} to epic {epic}")
+        _warn_epic_block(manager, task)
     return code
 
 
@@ -265,6 +274,7 @@ def cmd_epic_remove(manager: TaskManager, config: Config, args: argparse.Namespa
             print(f"Task {task.name} is not in an epic")
         else:
             print(f"Removed {task.name} from epic {previous}")
+        _warn_epic_block(manager, task)
     return 0
 
 
@@ -278,6 +288,7 @@ def cmd_epic_mark(manager: TaskManager, config: Config, args: argparse.Namespace
         return 0
     manager.set_task_kind(task, EPIC_KIND)
     print(f"Marked {args.name} as an epic")
+    _warn_epic_block(manager, task)
     return 0
 
 
@@ -291,6 +302,7 @@ def cmd_epic_unmark(manager: TaskManager, config: Config, args: argparse.Namespa
         return 0
     manager.set_task_kind(task, TASK_KIND)
     print(f"Unmarked {args.name}: it is a plain task now")
+    _warn_epic_block(manager, task)
     return 0
 
 

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/tasktree_manager/services/config.py

@@ -26,6 +26,7 @@ DEFAULT_KEYBINDINGS: dict[str, str] = {
     "add_repo": "a",
     "delete_task": "d",
     "rename_task": "R",
+    "set_epic": "E",
     "open_lazygit": "g",
     "show_diff": "h",
     "open_folder": "o",
@@ -509,6 +510,7 @@ clone_task = "{self._toml_escape(self.keybindings.get("clone_task", "y"))}"
 add_repo = "{self._toml_escape(self.keybindings.get("add_repo", "a"))}"
 delete_task = "{self._toml_escape(self.keybindings.get("delete_task", "d"))}"
 rename_task = "{self._toml_escape(self.keybindings.get("rename_task", "R"))}"
+set_epic = "{self._toml_escape(self.keybindings.get("set_epic", "E"))}"
 open_lazygit = "{self._toml_escape(self.keybindings.get("open_lazygit", "g"))}"
 show_diff = "{self._toml_escape(self.keybindings.get("show_diff", "h"))}"
 open_folder = "{self._toml_escape(self.keybindings.get("open_folder", "o"))}"

{tasktree_manager-2.14.0 → tasktree_manager-2.16.0}/tasktree_manager/services/models.py

@@ -1,5 +1,6 @@
 """Data models for tasktree-manager."""
 
+import os
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -127,6 +128,44 @@ class Task:
         return value
 
 
+def resolve_epic(task: Task, epics: dict[str, Task]) -> str | None:
+    """The epic in `epics` that the task's marker names, or None.
+
+    A marker spelled in another case matches only when it opens the same
+    folder, as on a case-insensitive disk.
+    """
+    parent = task.epic_name
+    if parent is None or parent in epics:
+        return parent
+    for name, epic in epics.items():
+        if name.casefold() == parent.casefold():
+            try:
+                if os.path.samefile(task.path.parent / parent, epic.path):
+                    return name
+            except OSError:
+                pass
+    return None
+
+
+def group_by_epic(tasks: list[Task]) -> tuple[list[Task], dict[str, list[Task]]]:
+    """Split tasks into top-level rows and the children of each epic.
+
+    A task is a child when its marker names an epic in `tasks`, by the same
+    rule as TaskManager.epic_child_names (the delete guard). Anything else, an
+    orphan included, is top-level. Order within both is kept.
+    """
+    epics = {task.name: task for task in tasks if task.is_epic}
+    children: dict[str, list[Task]] = {name: [] for name in epics}
+    top: list[Task] = []
+    for task in tasks:
+        parent = None if task.name in epics else resolve_epic(task, epics)
+        if parent is None:
+            top.append(task)
+        else:
+            children[parent].append(task)
+    return top, children
+
+
 @dataclass
 class GitStatus:
     """Represents the git status of a worktree."""