tasktree-manager 2.5.0__tar.gz → 2.6.0__tar.gz

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/CHANGELOG.md

@@ -15,6 +15,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.6.0] - 2026-07-13
+
+### Changed
+- Hunk diff viewer, shared Claude memory pool, repo filter fix (#8)
+
+
 ## [2.5.0] - 2026-06-10
 
 ### Added

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/PKG-INFO

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

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/README.md

@@ -57,8 +57,9 @@ On first run, you'll configure:
 
 1. **Create a task** - Press `n`, enter task name, select repositories
 2. **Work on code** - Press `e` for editor, `g` for lazygit, or `Enter` for shell
-3. **Push changes** - Press `p` to push all worktrees
-4. **Delete task** - Press `d` when finished
+3. **Review changes** - Press `h` to view the diff in [hunk](https://github.com/modem-dev/hunk) (all repos from the task panel, one repo from the worktree panel)
+4. **Push changes** - Press `p` to push all worktrees
+5. **Delete task** - Press `d` when finished
 
 For detailed workflows and examples, see the [User Guide](docs/user-guide.md).
 
@@ -75,14 +76,15 @@ For detailed workflows and examples, see the [User Guide](docs/user-guide.md).
 | Key | Action | Key | Action |
 |-----|--------|-----|--------|
 | `n` | New task | `g` | Open lazygit |
-| `a` | Add repo | `e` | Open editor |
-| `d` | Delete task | `o` | Open folder |
-| `p` | Push all | `P` | Pull all |
+| `a` | Add repo | `h` | Show diff (hunk) |
+| `d` | Delete task | `e` | Open editor |
+| `p` | Push all | `o` | Open folder |
+| `P` | Pull all | `Enter` | Open shell |
 | `c` | Claude (resume) | `C` | Claude (new) |
 | `r` | Refresh | `s` | Sort tasks |
 | `S` | Group worktrees | `m` | Messages |
-| `Enter` | Open shell | `Tab` | Next panel |
-| `?` | Show help | `q` | Quit |
+| `Tab` | Next panel | `?` | Show help |
+| `q` | Quit | | |
 
 **Themes:** Press `Ctrl+P` to switch between 7 built-in themes (textual-dark, nord, gruvbox, tokyo-night, monokai, dracula, textual-light).
 

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/docs/configuration.md

@@ -133,6 +133,25 @@ editor = ""
 # Default: "lazygit" (searches PATH)
 lazygit_path = "lazygit"
 
+# Path to hunk executable (terminal diff viewer)
+# https://github.com/modem-dev/hunk
+# Default: "hunk" (searches PATH)
+hunk_path = "hunk"
+
+# Path to claude CLI executable
+# Default: "claude" (searches PATH)
+claude_path = "claude"
+
+# Shared Claude Code auto-memory directory for task sessions.
+# Task folders are not git repositories, so by default Claude Code would key
+# its auto memory to the task path — memory that is orphaned when the task is
+# deleted. tasktree-manager writes this path as "autoMemoryDirectory" into each
+# task's .claude/settings.local.json so every task session reads and writes one
+# shared memory pool that persists across tasks.
+# Set to "" to disable (each task keeps its own throwaway memory).
+# Default: "~/.claude/tasktree-memory"
+claude_memory_dir = "~/.claude/tasktree-memory"
+
 # Preferred shell
 # Leave empty to use $SHELL environment variable
 # Default: "" (uses $SHELL, falls back to /bin/bash)
@@ -158,6 +177,7 @@ delete_task = "d"       # Delete/finish task
 
 # Git operations
 open_lazygit = "g"      # Open lazygit in selected worktree
+show_diff = "h"         # Open hunk diff (task panel = all repos, worktree panel = one repo)
 open_editor = "e"       # Open editor in selected task/worktree
 open_folder = "o"       # Open folder in new terminal tab
 open_shell = "enter"    # Open shell in selected worktree
@@ -305,6 +325,7 @@ refresh_interval = 15  # Refresh every 15 seconds
 |---------------|--------|-------------|---------------------|--------------------------------------|
 | `editor`      | string | `""`        | `EDITOR`            | Command to launch your editor        |
 | `lazygit_path` | string | `"lazygit"` | -                   | Path to lazygit executable           |
+| `hunk_path`   | string | `"hunk"`    | -                   | Path to hunk diff-viewer executable  |
 | `shell`       | string | `""`        | `SHELL`             | Shell to use when opening terminals  |
 
 ### Details
@@ -320,6 +341,13 @@ refresh_interval = 15  # Refresh every 15 seconds
 - Use absolute path for custom location: `"/opt/homebrew/bin/lazygit"`
 - Install lazygit: `brew install lazygit` (macOS), `apt install lazygit` (Ubuntu)
 
+**`hunk_path`:**
+- [hunk](https://github.com/modem-dev/hunk) is a review-first terminal diff viewer
+- Default `"hunk"` searches PATH
+- Use absolute path for custom location: `"/opt/homebrew/bin/hunk"`
+- Install hunk: `brew install hunk` (macOS) or `npm i -g hunkdiff`
+- Used when pressing `h`: from the task panel it opens a combined diff across all the task's repos; from the worktree panel it opens the selected repo's diff
+
 **`shell`:**
 - Leave empty (`""`) to use `$SHELL` environment variable
 - Fallback: `/bin/bash`
@@ -441,6 +469,7 @@ All 22 customizable keybindings with descriptions:
 | Action         | Default  | Description                           | Customization Example       |
 |----------------|----------|---------------------------------------|-----------------------------|
 | `open_lazygit` | `g`      | Open lazygit in selected worktree     | `open_lazygit = "ctrl+g"`   |
+| `show_diff`    | `h`      | Open hunk diff (task = all repos, worktree = one) | `show_diff = "ctrl+h"` |
 | `open_editor`  | `e`      | Open editor in task/worktree folder   | `open_editor = "ctrl+e"`    |
 | `open_folder`  | `o`      | Open folder in new terminal tab       | `open_folder = "ctrl+o"`    |
 | `open_shell`   | `enter`  | Open shell in selected worktree       | `open_shell = "ctrl+t"`     |

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/docs/user-guide.md

@@ -134,17 +134,22 @@ A **worktree** is a git working directory for a specific repository within a tas
    - Stage files, commit changes, resolve conflicts
    - Exit lazygit (press `q` in lazygit)
 
-3. **Or open a shell:**
+3. **Review the diff:**
+   - Press `h` from the worktree panel to review that repo's changes in [hunk](https://github.com/modem-dev/hunk)
+   - Press `h` from the task panel to review a combined diff across **all** the task's repos at once
+   - Exit hunk (press `q`)
+
+4. **Or open a shell:**
    - Press `Enter` to open a shell in the worktree
    - Make changes with your editor/IDE
    - Run build/test commands
    - Exit shell (type `exit`)
 
-4. **Push changes:**
+5. **Push changes:**
    - Press `p` to push all worktrees in the task
    - Or use lazygit (`g`) to push individually
 
-5. **Delete the task:**
+6. **Delete the task:**
    - Press `d` to delete/finish the task
    - Follow prompts if there are uncommitted or unpushed changes
    - Worktrees are removed (branches remain on remote)
@@ -168,7 +173,7 @@ tasktree-manager uses a **3-panel layout**:
 │   M  src/auth.py                                                       │
 │   ?? README.md                                                         │
 └──────────────────────────────────────────────────────────────────────────┘
-  n New  d Delete  g Lazygit  p Push  r Refresh  ? Help  q Quit
+  n New  d Delete  g Lazygit  h Diff  p Push  r Refresh  ? Help  q Quit
 ```
 
 ### Left Panel: Task List
@@ -325,6 +330,7 @@ Useful when you're spinning up several similar tasks that share the same set of
 | Key     | Action             | Description                                          |
 |---------|--------------------|------------------------------------------------------|
 | `g`     | Open lazygit       | Open lazygit in the selected worktree                |
+| `h`     | Show diff          | Open hunk: all repos from the task panel, the selected repo from the worktree panel |
 | `e`     | Open editor        | Open editor in task/worktree folder (runs `$EDITOR .`) |
 | `Enter` | Open shell         | Open a shell in the selected worktree                |
 | `p`     | Push all           | Push all worktrees in the current task (parallel)    |
@@ -359,6 +365,7 @@ Useful when you're spinning up several similar tasks that share the same set of
 - `C` opens the Claude desktop app via the `claude://code/new?folder=<task-folder>` URL scheme.
 - The CLI variant (`c`) generates `CLAUDE.md` files with task/worktree context and installs hooks that report session status back to tasktree-manager.
 - Session status (`⟳` running, `!` waiting, `✓` ended) appears next to the task name
+- Both variants point the session's Claude Code auto-memory at a shared pool (`claude_memory_dir`, default `~/.claude/tasktree-memory`). Task folders are not git repos, so without this each task would get its own memory directory that is orphaned when the task is deleted; with the shared pool, what Claude learns in one task carries over to future tasks.
 
 ### General
 
@@ -666,6 +673,34 @@ apt install lazygit
 # See: https://github.com/jesseduffield/lazygit
 ```
 
+### Hunk
+
+[hunk](https://github.com/modem-dev/hunk) is a review-first terminal diff viewer, well suited to reviewing agent-authored changesets across a multi-repo task.
+
+**Why hunk:**
+- Fast, keyboard-driven diff review with a desktop-inspired layout
+- Reviews an entire task's changes across all its repos in one view
+- Complements lazygit (which stages/commits per repo)
+
+**Using hunk:**
+1. From the **worktree panel**, press `h` to review the selected repo's uncommitted changes
+2. From the **task panel**, press `h` to review a combined diff across **all** the task's repos at once (each file is grouped under its repo name)
+3. tasktree-manager suspends, hunk opens
+4. Press `q` in hunk to return; status auto-refreshes and selection is preserved
+
+The combined task view includes both tracked (staged and unstaged) changes and untracked files.
+
+**Install hunk:**
+```bash
+# macOS
+brew install hunk
+
+# npm
+npm i -g hunkdiff
+
+# See: https://github.com/modem-dev/hunk
+```
+
 ### Editors
 
 **Direct editor integration:**

{tasktree_manager-2.5.0 → tasktree_manager-2.6.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.5.0"
+version = "2.6.0"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"

{tasktree_manager-2.5.0 → tasktree_manager-2.6.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.5.0'
-__version_tuple__ = version_tuple = (2, 5, 0)
+__version__ = version = '2.6.0'
+__version_tuple__ = version_tuple = (2, 6, 0)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/tasktree_manager/app.py

@@ -226,6 +226,7 @@ class TaskTreeApp(App):
         Binding("a", "add_repo", "Add Repo", show=False),
         Binding("d", "delete_task", "Delete", show=False),
         Binding("g", "open_lazygit", "Lazygit", show=False),
+        Binding("h", "show_diff", "Diff", show=False),
         Binding("e", "open_editor", "Editor", show=False),
         Binding("o", "open_folder", "Open", show=False),
         Binding("c", "open_claude_resume", "Claude", show=False),
@@ -287,6 +288,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("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),
             Binding(kb.get("open_folder", "o"), "open_folder", "Open", show=False),
             Binding(kb.get("open_claude_resume", "c"), "open_claude_resume", "Claude", show=False),
@@ -330,11 +332,13 @@ class TaskTreeApp(App):
             (kb.get("clone_task", "y"), "clone_task", "Clone"),
             (kb.get("add_repo", "a"), "add_repo", "Add Repo"),
             (kb.get("delete_task", "d"), "delete_task", "Delete"),
+            (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"),
         ]
         worktree_panel_bindings = [
             (kb.get("open_lazygit", "g"), "open_lazygit", "Lazygit"),
+            (kb.get("show_diff", "h"), "show_diff", "Diff"),
             (kb.get("open_editor", "e"), "open_editor", "Editor"),
             (kb.get("open_folder", "o"), "open_folder", "Open"),
             (kb.get("open_shell", "enter"), "open_shell", "Shell"),
@@ -1111,6 +1115,101 @@ class TaskTreeApp(App):
         # Restore focus to worktree list
         self.query_one("#worktree-list", WorktreeList).focus()
 
+    def action_show_diff(self) -> None:
+        """Open the hunk diff viewer, scoped by which panel is focused.
+
+        From the task panel, shows a combined diff across all the task's repos.
+        From the worktree panel, shows the diff for the selected worktree only.
+        """
+        focused = self.focused
+        if isinstance(focused, TaskList):
+            self._show_task_diff()
+        elif isinstance(focused, WorktreeList):
+            self._show_worktree_diff()
+        else:
+            self.notify("Select a task or worktree first", severity="warning")
+
+    def _show_worktree_diff(self) -> None:
+        """Open hunk on the selected worktree's working-tree changes."""
+        if not self.current_worktree:
+            self.notify("No worktree selected", severity="warning")
+            return
+
+        worktree_path = self.current_worktree.path
+        if not worktree_path.exists():
+            self.notify("Worktree directory not found", severity="error")
+            return
+
+        # Save selection state BEFORE suspend (as local variables)
+        saved_task_name = self.current_task.name if self.current_task else None
+        saved_worktree_name = self.current_worktree.name
+
+        self.notify("Opening hunk...")
+
+        # Suspend app and run hunk on this worktree's changes
+        with self.suspend():
+            self._run_external_command(
+                [self.config.hunk_path, "diff"],
+                cwd=worktree_path,
+                name="hunk",
+                install_hint="brew install hunk",
+            )
+
+        # Refresh status after hunk exits, restoring saved selection
+        self._load_tasks_with_selection(saved_task_name, saved_worktree_name)
+        # Restore focus to worktree list
+        self.query_one("#worktree-list", WorktreeList).focus()
+
+    def _show_task_diff(self) -> None:
+        """Open hunk on a combined diff across all of the task's repos."""
+        import os
+        import tempfile
+
+        if not self.current_task:
+            self.notify("No task selected", severity="warning")
+            return
+
+        task = self.current_task
+
+        # Building the diff runs local git commands only (no network), so a
+        # brief synchronous call before suspend is fine. The fresh git read
+        # also makes the "no changes" check accurate regardless of stale UI.
+        diff = GitOps.build_task_diff(task)
+        if not diff.strip():
+            self.notify("No changes to show", severity="information")
+            return
+
+        # Save selection state BEFORE suspend (as local variables)
+        saved_task_name = task.name
+        saved_worktree_name = self.current_worktree.name if self.current_worktree else None
+
+        # hunk reads the combined patch from a file, so keyboard input stays on
+        # the terminal (a stdin pipe would fight the interactive TUI for it).
+        with tempfile.NamedTemporaryFile("w", suffix=".patch", delete=False, encoding="utf-8") as f:
+            f.write(diff)
+            patch_path = f.name
+
+        self.notify("Opening hunk...")
+
+        try:
+            with self.suspend():
+                self._run_external_command(
+                    [self.config.hunk_path, "patch", patch_path],
+                    cwd=task.path,
+                    name="hunk",
+                    install_hint="brew install hunk",
+                )
+        finally:
+            try:
+                os.unlink(patch_path)
+            except OSError:
+                pass
+
+        # Refresh status after hunk exits, restoring saved selection
+        self._load_tasks_with_selection(saved_task_name, saved_worktree_name)
+        # Restore focus to task list
+        self.query_one("#task-list", TaskList).focus()
+
     def action_open_shell(self) -> None:
         """Open a shell in the current worktree."""
         if not self.current_worktree:
@@ -1199,7 +1298,7 @@ class TaskTreeApp(App):
         if fresh_task:
             self.task_manager.ensure_claude_md_files(fresh_task)
 
-        ensure_claude_hooks(task_path)
+        ensure_claude_hooks(task_path, self.config.claude_memory_dir)
         if has_claude_session(task_path):
             self._open_ghostty_tab(task_path, command=f"{self.config.claude_path} -r")
             self.notify("Opened Claude Code in new tab (resume)")
@@ -1220,6 +1319,7 @@ class TaskTreeApp(App):
             self.notify("Task directory not found", severity="error")
             return
 
+        ensure_claude_hooks(task_path, self.config.claude_memory_dir)
         encoded_path = quote(str(task_path), safe="")
         url = f"claude://code/new?folder={encoded_path}"
         try:

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/tasktree_manager/commands.py

@@ -14,6 +14,11 @@ APP_COMMANDS: list[tuple[str, str, str]] = [
     ("delete_task", "Delete Task", "Delete the current task (with safety checks)"),
     ("delete_worktree", "Delete Worktree", "Delete the selected worktree from the task"),
     ("open_lazygit", "Open Lazygit", "Open lazygit in the selected worktree"),
+    (
+        "show_diff",
+        "Show Diff",
+        "Open hunk: all repos from the task panel, the selected repo from the worktree panel",
+    ),
     ("open_editor", "Open Editor", "Open your editor in the focused task/worktree folder"),
     ("open_folder", "Open Folder", "Open the focused folder in a new terminal tab"),
     ("open_shell", "Open Shell", "Open a shell in the selected worktree"),

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/tasktree_manager/services/claude_hooks.py

@@ -38,11 +38,16 @@ def _build_hooks_config(task_path: Path) -> dict:
     }
 
 
-def ensure_claude_hooks(task_path: Path) -> None:
+def ensure_claude_hooks(task_path: Path, memory_dir: str = "") -> 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.
+
+    Task folders are not git repositories, so Claude Code keys its auto
+    memory to the task path — memory that becomes orphaned when the task
+    is deleted. When memory_dir is set, autoMemoryDirectory redirects all
+    task sessions to one shared pool that persists across tasks.
     """
     claude_dir = task_path / ".claude"
     claude_dir.mkdir(exist_ok=True)
@@ -60,4 +65,7 @@ def ensure_claude_hooks(task_path: Path) -> None:
     # Merge hooks into existing settings
     existing["hooks"] = _build_hooks_config(task_path)
 
+    if memory_dir:
+        existing["autoMemoryDirectory"] = str(Path(memory_dir).expanduser())
+
     settings_file.write_text(json.dumps(existing, indent=2) + "\n")

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/tasktree_manager/services/config.py

@@ -24,6 +24,7 @@ DEFAULT_KEYBINDINGS: dict[str, str] = {
     "add_repo": "a",
     "delete_task": "d",
     "open_lazygit": "g",
+    "show_diff": "h",
     "open_folder": "o",
     "open_shell": "enter",
     "open_editor": "e",
@@ -90,7 +91,9 @@ class Config:
     # External tools
     editor: str = ""
     lazygit_path: str = "lazygit"
+    hunk_path: str = "hunk"
     claude_path: str = "claude"
+    claude_memory_dir: str = "~/.claude/tasktree-memory"
     shell: str = ""
 
     # Keybindings (action -> key mapping)
@@ -144,7 +147,9 @@ class Config:
         tools_config = config_data.get("tools", {})
         editor = tools_config.get("editor", "")
         lazygit_path = tools_config.get("lazygit_path", "lazygit")
+        hunk_path = tools_config.get("hunk_path", "hunk")
         claude_path = tools_config.get("claude_path", "claude")
+        claude_memory_dir = tools_config.get("claude_memory_dir", "~/.claude/tasktree-memory")
         shell = tools_config.get("shell", "")
 
         # Keybindings - start with defaults and override with config
@@ -184,7 +189,9 @@ class Config:
             git_timeout=git_timeout,
             editor=editor,
             lazygit_path=lazygit_path,
+            hunk_path=hunk_path,
             claude_path=claude_path,
+            claude_memory_dir=claude_memory_dir,
             shell=shell,
             keybindings=keybindings,
             symlink_blocklist=symlink_blocklist,
@@ -308,9 +315,17 @@ editor = "{self._toml_escape(self.editor)}"
 # Path to lazygit executable
 lazygit_path = "{self._toml_escape(self.lazygit_path)}"
 
+# Path to hunk executable (terminal diff viewer, see https://github.com/modem-dev/hunk)
+hunk_path = "{self._toml_escape(self.hunk_path)}"
+
 # Path to claude CLI executable
 claude_path = "{self._toml_escape(self.claude_path)}"
 
+# Shared Claude Code auto-memory directory for task sessions.
+# Task folders are not git repos, so without this each task gets its own
+# memory that is orphaned when the task is deleted. Set to "" to disable.
+claude_memory_dir = "{self._toml_escape(self.claude_memory_dir)}"
+
 # Preferred shell (leave empty to use $SHELL)
 shell = "{self._toml_escape(self.shell)}"
 
@@ -328,6 +343,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"))}"
 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"))}"
 open_shell = "{self._toml_escape(self.keybindings.get("open_shell", "enter"))}"
 open_editor = "{self._toml_escape(self.keybindings.get("open_editor", "e"))}"

{tasktree_manager-2.5.0 → tasktree_manager-2.6.0}/tasktree_manager/services/git_ops.py

@@ -159,6 +159,76 @@ class GitOps:
         except (subprocess.SubprocessError, OSError) as e:
             return False, str(e)
 
+    @staticmethod
+    def _git_stdout(worktree: Worktree, args: list[str]) -> str:
+        """Run a local read-only git command in the worktree, returning stdout.
+
+        Returns "" on any failure. The exit code is intentionally ignored:
+        ``git diff --no-index`` returns non-zero whenever files differ, and a
+        failed command leaves stdout empty anyway.
+        """
+        try:
+            result = subprocess.run(
+                ["git", *args],
+                cwd=worktree.path,
+                capture_output=True,
+                text=True,
+                timeout=GitOps.LOCAL_TIMEOUT,
+            )
+        except (subprocess.SubprocessError, OSError):
+            return ""
+        return result.stdout
+
+    @staticmethod
+    def _list_untracked(worktree: Worktree) -> list[str]:
+        """List untracked (but not ignored) files in a worktree."""
+        out = GitOps._git_stdout(worktree, ["ls-files", "--others", "--exclude-standard", "-z"])
+        return [f for f in out.split("\0") if f]
+
+    @staticmethod
+    def get_worktree_diff(worktree: Worktree, label: str | None = None) -> str:
+        """Return a unified diff of all uncommitted changes in a worktree.
+
+        Combines staged and unstaged tracked changes (``git diff HEAD``) with
+        untracked files, so the result mirrors what a working-tree review shows.
+        When *label* is given, every file path is prefixed with ``<label>/`` so
+        diffs from several repos can be concatenated into one view without
+        colliding on identical relative paths.
+
+        Returns an empty string when the worktree is clean or missing.
+        """
+        if not worktree.path.exists():
+            return ""
+
+        # Without a label, git's default a/ b/ prefixes are used.
+        prefixes = [f"--src-prefix=a/{label}/", f"--dst-prefix=b/{label}/"] if label else []
+        parts: list[str] = []
+
+        # Tracked changes (staged + unstaged) relative to HEAD.
+        parts.append(GitOps._git_stdout(worktree, ["diff", "HEAD", "--no-color", *prefixes]))
+
+        # Untracked files, rendered as additions against /dev/null.
+        for untracked in GitOps._list_untracked(worktree):
+            parts.append(
+                GitOps._git_stdout(
+                    worktree,
+                    ["diff", "--no-index", "--no-color", *prefixes, "--", "/dev/null", untracked],
+                )
+            )
+
+        return "".join(parts)
+
+    @staticmethod
+    def build_task_diff(task: Task) -> str:
+        """Build a combined diff across all of a task's worktrees.
+
+        Each worktree's changes are labelled with its repo name so a single
+        review shows every repo without path collisions. Returns an empty
+        string when nothing in the task has changed.
+        """
+        parts = [GitOps.get_worktree_diff(wt, label=wt.name) for wt in task.worktrees]
+        return "".join(p for p in parts if p)
+
     @staticmethod
     def get_default_branch(worktree: Worktree) -> str:
         """Get the default branch (main/master) for a worktree's repo.