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

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/.github/workflows/ci.yml

@@ -31,12 +31,18 @@ jobs:
         run: ruff format --check tasktree_manager tests
 
   test:
-    name: Test (Python ${{ matrix.python-version }})
-    runs-on: ubuntu-latest
+    # Linux jobs keep the names branch protection requires
+    name: ${{ matrix.os == 'macos-latest' && format('Test (macOS, Python {0})', matrix.python-version) || format('Test (Python {0})', matrix.python-version) }}
+    runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
+        os: [ubuntu-latest]
         python-version: ["3.10", "3.11", "3.12", "3.13"]
+        include:
+          # Case-insensitive APFS: runs the case-variant epic tests Linux skips
+          - os: macos-latest
+            python-version: "3.13"
 
     steps:
       - name: Checkout code

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/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.16.1] - 2026-10-19
+
+### Fixed
+- **epic**: One membership rule and safer marker writes (#12)
+
+
 ## [2.16.0] - 2026-10-19
 
 ### Added

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

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

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

@@ -611,7 +611,8 @@ All 27 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"`     |
+| `set_epic`    | `E`     | Set the task's epic, or make it an epic | `set_epic = "ctrl+shift+e"` |
+| `delete_worktree` | `D` | Remove the selected worktree (the task stays) | `delete_worktree = "ctrl+d"` |
 
 ### Git Operations
 
@@ -632,6 +633,7 @@ All 27 customizable keybindings with descriptions:
 | `open_claude_resume`  | `c`     | Open Claude CLI (resume if session exists, else new) | `open_claude_resume = "ctrl+c"`      |
 | `open_claude_gui_code`| `C`     | Open Claude desktop on Code page in task folder      | `open_claude_gui_code = "ctrl+shift+c"` |
 | `toggle_messages`     | `m`     | Show/hide activity messages panel                    | `toggle_messages = "ctrl+m"`         |
+| `dispatch_agent`      | `b`     | Dispatch a background Claude agent into the worktree | `dispatch_agent = "ctrl+b"`          |
 
 ### Navigation
 

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

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tasktree_manager/_version.py

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

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

@@ -366,6 +366,9 @@ class TaskTreeApp(App):
             (kb.get("delete_worktree", "D"), "delete_worktree", "Del WT"),
         ]
 
+        # Every key a configured action uses ("s,space" binds two keys)
+        claimed_keys = {key.strip() for keys in kb.values() for key in keys.split(",")}
+
         yield AppHeader()
         with Horizontal(id="main-container"):
             # Left column: Tasks (top) and Worktrees (bottom)
@@ -382,7 +385,7 @@ class TaskTreeApp(App):
                         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()),
+                        fold_keys=tuple(k for k in ("enter", "space") if k not in claimed_keys),
                     )
                 with Vertical(id="worktree-panel"):
                     with Horizontal(classes="panel-title-bar"):
@@ -1302,7 +1305,8 @@ class TaskTreeApp(App):
                 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),
+                # A clone joins the source task's epic; a clone of an epic joins none
+                initial_epic=self.query_one("#task-list", TaskList).epic_of(self.current_task.name),
             ),
             handle_result,
         )
@@ -1432,7 +1436,7 @@ class TaskTreeApp(App):
                 return
             try:
                 self.task_manager.set_task_display_name(task, new_name)
-            except OSError as e:
+            except (OSError, ValueError) as e:
                 self.notify(escape(f"Rename failed: {e}"), severity="error")
                 return
             label = task.display_label
@@ -1452,6 +1456,7 @@ class TaskTreeApp(App):
             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]
+        parent = self.query_one("#task-list", TaskList).epic_of(task.name)
 
         def handle_choice(choice: tuple[str, str | None] | None) -> None:
             if choice is None:
@@ -1469,8 +1474,8 @@ class TaskTreeApp(App):
             EpicPickerModal(
                 task.display_label,
                 epics,
-                self.query_one("#task-list", TaskList).epic_of(task.name),
-                task.epic_name is None,
+                parent,
+                parent is None,
             ),
             handle_choice,
         )
@@ -2084,7 +2089,9 @@ class TaskTreeApp(App):
         """
         fresh_task = self.task_manager.get_task(task.name)
         if fresh_task:
-            self.task_manager.ensure_claude_md_files(fresh_task)
+            problem = self.task_manager.ensure_claude_md_files(fresh_task)
+            if problem:
+                self.call_from_thread(self.notify, escape(problem), severity="warning")
             self.task_manager.ensure_worktree_settings(fresh_task)
         ensure_claude_hooks(task.path, self.config.claude_memory_dir)
 

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

@@ -8,6 +8,7 @@ errors on stderr, exit code 0 on success and 1 on failure.
 
 import argparse
 import json
+import os
 import shutil
 import sys
 from pathlib import Path
@@ -16,7 +17,7 @@ from . import __version__
 from .services import forge
 from .services.config import Config, ConfigError
 from .services.git_ops import GitOps
-from .services.models import EPIC_KIND, TASK_KIND, ArchiveResult, Task
+from .services.models import EPIC_KIND, TASK_KIND, ArchiveResult, Task, parent_epic_name
 from .services.task_manager import ARCHIVE_NOTES_SHOWN, ArchiveIncompleteError, TaskManager
 
 
@@ -354,6 +355,8 @@ def _refuse_epic_with_children(manager: TaskManager, task: Task, verb: str) -> b
 def cmd_list(manager: TaskManager, config: Config, args: argparse.Namespace) -> int:
     """List tasks with their repos and dirty state."""
     tasks = manager.list_tasks()
+    # One TASKS_DIR listing for every parent_epic_name lookup below
+    listing = set(os.listdir(config.tasks_dir)) if config.tasks_dir.is_dir() else set()
     dirty: dict[str, bool] = {}
     errored: dict[str, bool] = {}
     for task in tasks:
@@ -369,7 +372,7 @@ def cmd_list(manager: TaskManager, config: Config, args: argparse.Namespace) ->
                 "name": task.name,
                 "display_name": task.display_name,
                 "kind": task.kind,
-                "epic": task.epic_name,
+                "epic": parent_epic_name(task, listing),
                 "path": str(task.path),
                 "repos": [wt.name for wt in task.worktrees],
                 "dirty": dirty[task.name],
@@ -635,7 +638,7 @@ def cmd_status(manager: TaskManager, config: Config, args: argparse.Namespace) -
         payload = {
             "task": task.name,
             "kind": task.kind,
-            "epic": task.epic_name,
+            "epic": parent_epic_name(task),
             "path": str(task.path),
             "claude": claude,
             "worktrees": [

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

@@ -2,6 +2,7 @@
 
 import os
 import re
+from collections.abc import Collection
 from dataclasses import dataclass, field
 from pathlib import Path
 
@@ -128,23 +129,60 @@ 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.
+def on_disk_name(path: Path, names: Collection[str] | None = None) -> str:
+    """The last path segment as spelled on disk, for an existing path.
 
-    A marker spelled in another case matches only when it opens the same
-    folder, as on a case-insensitive disk.
+    On a case-insensitive disk `epic-1` opens `EPIC-1`; markers, branches and
+    the epic checks must all use the real spelling. `names` is the listing of
+    path.parent when the caller already has it (one listing per scan).
     """
-    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
+    if names is None:
+        try:
+            names = set(os.listdir(path.parent))
+        except OSError:
+            return path.name
+    if path.name in names:
+        return path.name
+    for name in names:
+        if name.casefold() == path.name.casefold() and same_folder(path.parent / name, path):
+            return name
+    return path.name
+
+
+def same_folder(a: Path, b: Path) -> bool:
+    """True when two paths open the same file or folder."""
+    try:
+        return os.path.samefile(a, b)
+    except OSError:
+        return False
+
+
+def parent_epic_name(task: Task, names: Collection[str] | None = None) -> str | None:
+    """The epic a task belongs to, spelled as on disk, or None.
+
+    The one membership rule for the CLI, the TUI, the delete guard and the
+    CLAUDE.md block: the marker must name a real epic folder next to the
+    task. A symlink alias, a missing folder or a plain task makes it an orphan.
+    `names` is the TASKS_DIR listing, passed by callers that resolve many tasks.
+    """
+    marker = task.epic_name
+    if marker is None:
+        return None
+    path = task.path.parent / marker
+    if path.is_symlink() or not path.is_dir():
+        return None
+    name = on_disk_name(path, names)
+    if not Task(name=name, path=path.parent / name).is_epic:
+        return None
+    return name
+
+
+def resolve_epic(
+    task: Task, epics: dict[str, Task], names: Collection[str] | None = None
+) -> str | None:
+    """The epic in `epics` the task belongs to (see parent_epic_name), or None."""
+    parent = parent_epic_name(task, names)
+    return parent if parent in epics else None
 
 
 def group_by_epic(tasks: list[Task]) -> tuple[list[Task], dict[str, list[Task]]]:
@@ -154,11 +192,20 @@ def group_by_epic(tasks: list[Task]) -> tuple[list[Task], dict[str, list[Task]]]
     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}
+    # A symlinked folder never counts as an epic: it would alias a real one
+    epics = {task.name: task for task in tasks if task.is_epic and not task.path.is_symlink()}
     children: dict[str, list[Task]] = {name: [] for name in epics}
     top: list[Task] = []
+    listings: dict[Path, set[str]] = {}
     for task in tasks:
-        parent = None if task.name in epics else resolve_epic(task, epics)
+        folder = task.path.parent
+        if folder not in listings:
+            try:
+                listings[folder] = set(os.listdir(folder))
+            except OSError:
+                listings[folder] = set()
+        names = listings[folder]
+        parent = None if task.name in epics else resolve_epic(task, epics, names)
         if parent is None:
             top.append(task)
         else:

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tasktree_manager/services/task_manager.py

@@ -22,6 +22,9 @@ from .models import (
     Task,
     TaskSafetyReport,
     Worktree,
+    on_disk_name,
+    parent_epic_name,
+    same_folder,
     validate_task_name,
 )
 
@@ -272,13 +275,7 @@ class TaskManager:
         On a case-insensitive filesystem `epic-1` opens `EPIC-1`; markers and
         branches must use the real spelling or the epic checks miss children.
         """
-        path = self.config.tasks_dir / name
-        if any(item.name == name for item in self.config.tasks_dir.iterdir()):
-            return name
-        for item in self.config.tasks_dir.iterdir():
-            if item.name.casefold() == name.casefold() and os.path.samefile(item, path):
-                return item.name
-        return name
+        return on_disk_name(self.config.tasks_dir / name)
 
     def create_task(
         self,
@@ -669,16 +666,29 @@ class TaskManager:
         lives in <task>/.tasktree_name. Empty input — or an alias equal to the
         real name — clears the file.
         """
-        marker = task.path / ".tasktree_name"
-        if marker.is_symlink():
-            marker.unlink()
         name = (display_name or "").strip()
         if name == task.name:
             name = ""
-        if name:
-            marker.write_text(name + "\n", encoding="utf-8")
-        elif marker.exists():
-            marker.unlink()
+        self._write_file_marker(task, ".tasktree_name", name or None)
+
+    def _write_file_marker(self, task: Task, marker: str, value: str | None) -> None:
+        """Replace or remove <task>/<marker> without following links.
+
+        A planted symlink or hard link is swapped for a new file, never
+        written through; a task folder outside TASKS_DIR is refused.
+        """
+        self._require_inside(task)
+        path = task.path / marker
+        if value is not None:
+            self._replace_file(path, (value + "\n").encode("utf-8"))
+        elif path.is_symlink() or path.exists():
+            path.unlink()
+
+    def _require_inside(self, task: Task) -> None:
+        """Raise ValueError unless the task folder is a real folder in TASKS_DIR."""
+        tasks_dir = self.config.tasks_dir.resolve()
+        if task.path.is_symlink() or task.path.resolve().parent != tasks_dir:
+            raise ValueError(f"'{task.name}' is not a task folder inside {tasks_dir}")
 
     def _write_marker(self, task: Task, marker: str, value: str | None) -> None:
         """Write <task>/<marker>, or remove it when value is None.
@@ -687,14 +697,7 @@ class TaskManager:
         follows it. That sync never raises: callers that report problems run
         sync_epic_block again and show what it returns.
         """
-        path = task.path / marker
-        if path.is_symlink():
-            # Never write through a planted link to a file outside the task
-            path.unlink()
-        if value is not None:
-            path.write_text(value + "\n", encoding="utf-8")
-        else:
-            path.unlink(missing_ok=True)
+        self._write_file_marker(task, marker, value)
         self.sync_epic_block(task)
 
     def _render_epic_block(self, task: Task) -> str | None:
@@ -706,8 +709,7 @@ class TaskManager:
                 f"`{tasks_dir}` whose `.tasktree_epic` file names `{task.name}`; list them",
                 "with `tasktree-manager epic list`.",
             ]
-        elif task.epic_name is not None:
-            epic = task.epic_name
+        elif (epic := parent_epic_name(task)) is not None:
             body = [
                 f"This task belongs to the epic `{epic}` at `{tasks_dir / epic}`.",
                 "The epic folder holds the shared notes and plans. Its worktrees belong",
@@ -784,7 +786,10 @@ class TaskManager:
                 f.write(data)
                 f.flush()
                 os.fsync(f.fileno())
-            shutil.copymode(path, tmp)
+            if path.is_file() and not path.is_symlink():
+                shutil.copymode(path, tmp)
+            else:
+                os.chmod(tmp, 0o644)
             os.replace(tmp, path)
         except BaseException:
             Path(tmp).unlink(missing_ok=True)
@@ -801,6 +806,9 @@ class TaskManager:
         epic_path = self.config.tasks_dir / epic_name
         if not epic_path.is_dir():
             raise ValueError(f"No such epic: {epic_name}")
+        if epic_path.is_symlink():
+            # An alias would let delete/finish miss the children of the real epic
+            raise ValueError(f"'{epic_name}' is a symlink, not an epic folder")
         epic_name = self._on_disk_name(epic_name)
         if not Task(name=epic_name, path=epic_path).is_epic:
             raise ValueError(
@@ -811,37 +819,28 @@ class TaskManager:
     def epic_child_names(self, epic_name: str) -> list[str]:
         """Names of the tasks whose .tasktree_epic marker names this epic.
 
-        Reads markers only: list_tasks() walks every task's worktrees.
+        Reads markers only: list_tasks() walks every task's worktrees. A child
+        counts when its parent (parent_epic_name) is the same folder as
+        `epic_name`, so a case variant or symlink alias of the epic still
+        finds every child.
         """
         if not self.config.tasks_dir.exists():
             return []
         names = []
+        listing = set(os.listdir(self.config.tasks_dir))
+        # Symlinked task folders count too: the CLI and TUI show them as children
         for item in sorted(self.config.tasks_dir.iterdir()):
             if item.is_dir() and not item.name.startswith("."):
-                parent = Task(name=item.name, path=item).epic_name
-                if parent == epic_name or (
-                    parent is not None
-                    and parent.casefold() == epic_name.casefold()
-                    and self._same_task(parent, epic_name)
+                parent = parent_epic_name(Task(name=item.name, path=item), listing)
+                if parent is not None and (
+                    parent == epic_name or self._same_task(parent, epic_name)
                 ):
                     names.append(item.name)
         return names
 
     def _same_task(self, a: str, b: str) -> bool:
-        """True when two task names open the same folder (case-insensitive disks)."""
-        try:
-            return os.path.samefile(self.config.tasks_dir / a, self.config.tasks_dir / b)
-        except OSError:
-            return False
-
-    def epic_children(self, epic: Task) -> list[Task]:
-        """The tasks attached to an epic, with their worktrees, sorted by name."""
-        children = []
-        for name in self.epic_child_names(epic.name):
-            child = self.get_task(name)
-            if child is not None:
-                children.append(child)
-        return children
+        """True when two task names open the same folder."""
+        return same_folder(self.config.tasks_dir / a, self.config.tasks_dir / b)
 
     @staticmethod
     def _epic_has_children_message(epic: Task, children: list[str]) -> str:
@@ -856,6 +855,7 @@ class TaskManager:
         Returns the epic name as written. Epics don't nest: an epic cannot
         join an epic.
         """
+        self._require_inside(task)
         if epic_name is None:
             self._write_marker(task, ".tasktree_epic", None)
             return None
@@ -871,17 +871,22 @@ class TaskManager:
         A task that belongs to an epic cannot become one, and an epic with
         children cannot become a task.
         """
+        self._require_inside(task)
         if kind == EPIC_KIND:
-            if task.epic_name is not None:
+            parent = parent_epic_name(task)
+            if parent is not None:
                 raise ValueError(
-                    f"'{task.name}' belongs to epic '{task.epic_name}'; "
+                    f"'{task.name}' belongs to epic '{parent}'; "
                     "detach it first (tasktree-manager epic remove)"
                 )
             self._write_marker(task, ".tasktree_kind", EPIC_KIND)
             # An unreadable or self-naming parent marker reads as None; drop it
             self._write_marker(task, ".tasktree_epic", None)
         elif kind == TASK_KIND:
-            children = self.epic_child_names(task.name) if task.is_epic else []
+            if not task.is_epic:
+                # A plain task stays as it is; its parent marker is not ours to drop
+                return
+            children = self.epic_child_names(task.name)
             if children:
                 raise ValueError(self._epic_has_children_message(task, children))
             # A parent marker the epic carried was hidden; drop it before the
@@ -1480,7 +1485,7 @@ class TaskManager:
             if repo_path.exists() and worktree.path.exists():
                 ensure_worktree_claude_settings(worktree.path, repo_path, status_file)
 
-    def ensure_claude_md_files(self, task: Task) -> None:
+    def ensure_claude_md_files(self, task: Task) -> str | None:
         """Create the task CLAUDE.md and backfill worktree ones from the repo.
 
         The task-level file is generated (the task dir is not a git repo).
@@ -1490,16 +1495,20 @@ class TaskManager:
 
         Args:
             task: The task to create CLAUDE.md files for
+
+        Returns:
+            Why the epic block could not be synced, or None
         """
         task_claude_md = task.path / "CLAUDE.md"
         if not task_claude_md.exists():
             self._create_task_claude_md(task)
-        self.sync_epic_block(task)
+        problem = self.sync_epic_block(task)
 
         for worktree in task.worktrees:
             wt_claude_md = worktree.path / "CLAUDE.md"
             if not wt_claude_md.exists():
                 self._copy_repo_claude_md(worktree)
+        return problem
 
     def _create_task_claude_md(self, task: Task) -> None:
         """Generate task CLAUDE.md with task name + worktree paths.

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tasktree_manager/widgets/task_list.py

@@ -84,7 +84,7 @@ class TaskList(OptionList):
             self._bindings.bind(key, f"app.{action}", description, show=True)
         # Enter folds an epic instead of OptionList's select (a click still
         # selects); a fold key the user bound to an action stays theirs
-        claimed = {key for key, _, _ in context_bindings or []}
+        claimed = {key.strip() for keys, _, _ in context_bindings or [] for key in keys.split(",")}
         for i, key in enumerate(k for k in fold_keys if k not in claimed):
             self._bindings.key_to_bindings.pop(key, None)
             self._bindings.bind(key, "toggle_epic", "Fold", show=i == 0)
@@ -308,7 +308,10 @@ class TaskList(OptionList):
 
     @staticmethod
     def _mtime(task: Task) -> float:
-        return task.path.stat().st_mtime if task.path.exists() else 0
+        try:
+            return task.path.stat().st_mtime
+        except OSError:  # deleted or unreadable since it was listed
+            return 0
 
     def _sort_tasks(self, tasks: list[Task]) -> list[Task]:
         """Sort tasks according to current sort mode.

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tests/conftest.py

@@ -120,8 +120,14 @@ def sample_repos(temp_dirs):
 
 
 @pytest.fixture
-def app(config):
+def app(config, tmp_path, monkeypatch):
     """Create app with test config."""
+    # TaskTreeApp() loads the real config first: keep it (and the default
+    # ~/tasks it would create) inside the test's temp dir
+    monkeypatch.setenv("HOME", str(tmp_path / "home"))
+    monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "home" / ".config"))
+    for var in ("TASKS_DIR", "REPOS_DIR"):
+        monkeypatch.delenv(var, raising=False)
     config.ensure_dirs()
     # Keep TUI tests hermetic: never poll the real `claude` CLI from on_mount.
     # Badge/dispatch tests drive the poll/apply methods directly instead.

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tests/test_epic_claude_md.py

@@ -149,10 +149,10 @@ class TestEpicBlockRobustness:
         def full_disk(src, dst):
             raise OSError(28, "No space left on device")
 
+        (task.path / ".tasktree_epic").write_text("E-1\n")
         monkeypatch.setattr(os, "replace", full_disk)
-        tm.set_task_epic(task, "E-1")
-        assert path.read_text() == "notes\n" * 50
         assert "No space left" in tm.sync_epic_block(task)
+        assert path.read_text() == "notes\n" * 50
         assert [p.name for p in task.path.iterdir() if p.name.endswith(".tmp")] == []
 
     def test_unmark_with_planted_parent_marker(self, tm):

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tests/test_epic_tui.py

@@ -468,3 +468,28 @@ class TestReviewFixesTui:
             await pilot.press("h")
             await pilot.pause()
             assert started == []
+
+
+class TestCumulativeReviewTui:
+    async def test_comma_separated_binding_keeps_space(self, app, epic_tasks):
+        app.config.keybindings["cycle_sort"] = "s,space"
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            task_list = app.query_one("#task-list", TaskList)
+            task_list.focus()
+            await select(pilot, task_list, "E-1")
+            await pilot.press("space")
+            await pilot.pause()
+            assert task_list._sort_mode is SortMode.NAME_DESC
+
+    @pytest.mark.parametrize(("row", "expected"), [("E-1", None), ("T-1", "E-1")])
+    async def test_clone_preselects_source_parent(
+        self, app, epic_tasks, sample_repos, row, expected
+    ):
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            await select(pilot, app.query_one("#task-list", TaskList), row)
+            await pilot.press("y")
+            await pilot.pause()
+            assert isinstance(app.screen, CreateTaskModal)
+            assert app.screen.initial_epic == expected

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tests/test_epics.py

@@ -1,6 +1,7 @@
 """Tests for epics: the markers, the service rules and the `epic` CLI."""
 
 import json
+import os
 
 import pytest
 
@@ -159,7 +160,6 @@ class TestHierarchy:
         task_manager.create_task("T-1", [], epic="EPIC-1")
         task_manager.create_task("T-3", [])
         assert task_manager.epic_child_names("EPIC-1") == ["T-1", "T-2"]
-        assert [t.name for t in task_manager.epic_children(epic)] == ["T-1", "T-2"]
 
     def test_finish_refuses_epic_with_children(self, task_manager, epic):
         child = task_manager.create_task("T-1", [], epic="EPIC-1")
@@ -440,3 +440,80 @@ class TestMarkerSymlink:
         assert outside.read_text() == "keep\n"
         assert not (task.path / ".tasktree_epic").is_symlink()
         assert task.epic_name == "EPIC-1"
+
+
+class TestCumulativeReviewFixes:
+    def test_symlink_alias_is_not_an_epic(self, cli_config, capsys):
+        cli(cli_config, "epic", "create", "EPIC-1")
+        cli(cli_config, "create", "T-1", "--repos", "repo-alpha", "--epic", "EPIC-1")
+        (cli_config.tasks_dir / "alias").symlink_to(cli_config.tasks_dir / "EPIC-1")
+        capsys.readouterr()
+        assert cli(cli_config, "epic", "add", "alias", "T-1") == 1
+        assert "is a symlink" in capsys.readouterr().err
+        # Deleting through the alias still sees the real epic's children
+        assert cli(cli_config, "delete", "alias", "--force") == 1
+        assert "T-1" in capsys.readouterr().err
+        assert (cli_config.tasks_dir / "EPIC-1").exists()
+
+    def test_alias_marker_is_an_orphan(self, cli_config, capsys):
+        cli(cli_config, "epic", "create", "EPIC-1")
+        cli(cli_config, "create", "T-2", "--repos", "repo-alpha")
+        (cli_config.tasks_dir / "alias").symlink_to(cli_config.tasks_dir / "EPIC-1")
+        (cli_config.tasks_dir / "T-2" / ".tasktree_epic").write_text("alias\n")
+        capsys.readouterr()
+        assert cli(cli_config, "list", "--json") == 0
+        payload = {t["name"]: t for t in json.loads(capsys.readouterr().out)}
+        assert payload["T-2"]["epic"] is None
+
+    def test_orphan_marker_is_null_everywhere(self, cli_config, task_manager, capsys):
+        cli(cli_config, "create", "T-1", "--repos", "repo-alpha")
+        task = task_manager.get_task("T-1")
+        (task.path / ".tasktree_epic").write_text("GHOST\n")
+        task_manager.sync_epic_block(task)
+        assert "GHOST" not in (task.path / "CLAUDE.md").read_text()
+        capsys.readouterr()
+        assert cli(cli_config, "list", "--json") == 0
+        assert json.loads(capsys.readouterr().out)[0]["epic"] is None
+        assert cli(cli_config, "epic", "mark", "T-1") == 0  # an orphan may become an epic
+        assert not (task.path / ".tasktree_epic").exists()
+
+    def test_hard_linked_marker_not_written_through(self, task_manager, epic, tmp_path):
+        outside = tmp_path / "outside.txt"
+        outside.write_text("keep\n")
+        task = task_manager.create_task("T-1", [])
+        os.link(outside, task.path / ".tasktree_epic")
+        task_manager.set_task_epic(task, "EPIC-1")
+        assert outside.read_text() == "keep\n"
+        assert task.epic_name == "EPIC-1"
+
+    def test_task_folder_outside_tasks_dir_refused(self, task_manager, epic, tmp_path):
+        real = tmp_path / "elsewhere"
+        real.mkdir()
+        link = task_manager.config.tasks_dir / "T-LINK"
+        link.symlink_to(real)
+        task = Task(name="T-LINK", path=link)
+        with pytest.raises(ValueError, match="not a task folder"):
+            task_manager.set_task_epic(task, "EPIC-1")
+        assert not (real / ".tasktree_epic").exists()
+
+    def test_unmark_on_plain_child_keeps_its_epic(self, task_manager, epic):
+        child = task_manager.create_task("T-1", [], epic="EPIC-1")
+        task_manager.set_task_kind(child, "task")
+        assert child.epic_name == "EPIC-1"
+
+    def test_ensure_reports_block_problem(self, task_manager, epic):
+        from tasktree_manager.services.task_manager import EPIC_BLOCK_START
+
+        child = task_manager.create_task("T-1", [], epic="EPIC-1")
+        (child.path / "CLAUDE.md").write_text(EPIC_BLOCK_START + "\n")
+        assert "mismatched" in task_manager.ensure_claude_md_files(child)
+
+    def test_symlinked_child_still_blocks_epic_delete(self, cli_config, task_manager, capsys):
+        cli(cli_config, "epic", "create", "EPIC-1")
+        real = cli_config.tasks_dir.parent / "real-child"
+        real.mkdir()
+        (real / ".tasktree_epic").write_text("EPIC-1\n")
+        (cli_config.tasks_dir / "T-LINK").symlink_to(real)
+        assert task_manager.epic_child_names("EPIC-1") == ["T-LINK"]
+        capsys.readouterr()
+        assert cli(cli_config, "delete", "EPIC-1", "--force") == 1

{tasktree_manager-2.16.0 → tasktree_manager-2.16.1}/tests/test_safety_fixes.py

@@ -272,7 +272,10 @@ class TestDeleteWorktreeSafety:
             await pilot.pause()
             modal = app.screen_stack[-1]
             assert isinstance(modal, ConfirmModal)
-            modal.dismiss(True)
+            await modal.dismiss(True)
+            # The confirm callback starts the worker on a later message, so
+            # let it run before waiting, or the wait returns with no worker.
+            await pilot.pause()
             await app.workers.wait_for_complete()
             await pilot.pause()
             assert not wt.path.exists()