tasktree-manager 2.13.2__tar.gz → 2.13.3__tar.gz

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/.gitignore

@@ -53,7 +53,6 @@ tasktree_manager/_version.py
 
 # Documentation (tracked separately)
 PRD.md
-specs/
 CLAUDE.md
 
 # uv project-mode lockfile — tooling installs via `uv pip`/pip from pyproject.toml,

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/CHANGELOG.md

@@ -15,6 +15,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.13.3] - 2026-10-16
+
+### Changed
+- Remove unused specs and refresh the README roadmap
+
+### Fixed
+- **archive**: Keep task-folder files when a task is finished
+
+
 ## [2.13.2] - 2026-09-28
 
 ### Changed

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/CONTRIBUTING.md

@@ -18,7 +18,7 @@ Be respectful, inclusive, and constructive. We're all here to build something us
 
 1. **Fork and clone**
    ```bash
-   git clone https://github.com/yourusername/tasktree-manager.git
+   git clone https://github.com/ruslanfialkovskii/tasktree-manager.git
    cd tasktree-manager
    ```
 
@@ -149,7 +149,7 @@ def create_task(name: str, repos: list[str]) -> Task:
 - Add docstrings to all public functions/classes
 - Use Google-style docstrings
 - Update README.md for user-facing changes
-- Update OPENSPEC.md for architecture changes
+- Update the Architecture section of CLAUDE.md for architecture changes
 
 Example docstring:
 ```python
@@ -206,18 +206,15 @@ tasktree-manager/
 │   ├── themes/         # Color themes
 │   └── app.py          # Main app
 ├── tests/              # Test suite
-├── specs/              # Technical specs
 └── docs/               # Documentation
 ```
 
 ### Adding New Features
 
-1. **Check specs**: Review existing specs in `specs/`
-2. **Create spec**: Write a new spec (SPEC-XXX) if needed
-3. **Write tests**: Add tests first (TDD approach)
-4. **Implement**: Write the code
-5. **Document**: Update README/specs
-6. **PR**: Submit for review
+1. **Write tests**: Add tests first (TDD approach)
+2. **Implement**: Write the code
+3. **Document**: Update README.md and `docs/`
+4. **PR**: Submit for review
 
 ## Submitting Issues
 
@@ -260,7 +257,7 @@ Include:
 
 ## Questions?
 
-- Open a [Discussion](https://github.com/yourusername/tasktree-manager/discussions)
+- Open a [Discussion](https://github.com/ruslanfialkovskii/tasktree-manager/discussions)
 - Ask in Pull Request
 - Check existing issues
 

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/PKG-INFO

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

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/README.md

@@ -4,7 +4,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-228%20passed-green.svg)](./tests/)
+[![Tests](https://img.shields.io/badge/tests-pytest-green.svg)](./tests/)
 
 **tasktree-manager** is a terminal user interface (TUI) application for managing development tasks that span multiple git repositories. Create tasks, organize worktrees, and track status across your entire codebase—all from a beautiful, keyboard-driven interface inspired by [lazygit](https://github.com/jesseduffield/lazygit).
 
@@ -22,7 +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
-- 📦 **Finish Flow with Archives** - Ending a task saves its combined diff (committed-but-unmerged + uncommitted) to an archive before deleting
+- 📦 **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
 
@@ -82,15 +82,23 @@ tasktree-manager list --json     # tasks with repos and state: clean / dirty / e
 tasktree-manager repos           # available repos in REPOS_DIR
 tasktree-manager add-repo DIC-1901-argocd-tls infra
 tasktree-manager status                       # current task inferred from $PWD; also --json / --oneline / --forge
-tasktree-manager finish DIC-1901-argocd-tls   # safety sweep -> archive diff -> delete; --push / --no-archive / --force
-tasktree-manager delete DIC-1901-argocd-tls   # archive diff -> delete; refuses on unfinished work; --force overrides
+tasktree-manager finish DIC-1901-argocd-tls   # safety sweep -> archive diff + task files -> delete; --push / --no-archive / --force
+tasktree-manager delete DIC-1901-argocd-tls   # archive diff + task files -> delete; refuses on unfinished work; --force overrides
 ```
 
 Exit code is 0 on success, 1 on failure with the reason on stderr. `delete` and `finish` run
 the same safety check as the TUI (uncommitted, unpushed, or unmerged work blocks deletion);
 with `glab`/`gh` installed, squash/rebase-merged branches are recognized as merged. If the
 diff cannot be archived for any repo, the CLI stops before deleting and prints the path of
-the partial archive; the TUI warns and deletes anyway.
+the partial archive; the TUI warns and deletes anyway. Files in the task folder outside the
+worktrees are copied to `<task>-<timestamp>.files/` next to the patch:
+
+- Skipped silently: hidden files, symlinks, `node_modules`/`vendor`/`.terraform` folders and
+  an unedited generated `CLAUDE.md`.
+- Left out with a warning: key material (`*.pem`, `*.key`, `id_rsa`, kubeconfigs,
+  `*.tfstate`, `credentials*.json`), files over 10 MB and files past 100 MB in total.
+- A file that cannot be read or copied stops `delete`/`finish` before anything is removed,
+  unless `--force`; the TUI warns and deletes anyway.
 `status --oneline` emits a compact `TASK repoA✓ repoB●2↑1` summary that slots straight into
 a Claude Code statusline or shell prompt.
 
@@ -147,7 +155,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development setup and guidel
 
 **Quick Start:**
 ```bash
-git clone https://github.com/yourusername/tasktree-manager.git
+git clone https://github.com/ruslanfialkovskii/tasktree-manager.git
 cd tasktree-manager
 mise install
 mise run install
@@ -197,14 +205,13 @@ 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 with diff archiving, `status` subcommand for scripts and statuslines.
+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.
 
-Upcoming:
-- **v0.3.0** - Search/filter, task templates
-- **v0.4.0** - JIRA status column, git hooks, automation
-- **v1.0.0** - Stable release
+Next: epics, a layer that groups related tasks (for example a Jira epic and its child
+tasks) in the task list.
 
-See [ROADMAP.md](ROADMAP.md) and [CHANGELOG.md](CHANGELOG.md) for details.
+See [CHANGELOG.md](CHANGELOG.md) for the release history.
 
 ## 📄 License
 
@@ -218,11 +225,11 @@ MIT License - see [LICENSE](./LICENSE) for details.
 
 ## 💬 Support & Community
 
-- 🐛 [Bug Reports](https://github.com/yourusername/tasktree-manager/issues)
-- 💡 [Feature Requests](https://github.com/yourusername/tasktree-manager/issues)
-- 💬 [Discussions](https://github.com/yourusername/tasktree-manager/discussions)
+- 🐛 [Bug Reports](https://github.com/ruslanfialkovskii/tasktree-manager/issues)
+- 💡 [Feature Requests](https://github.com/ruslanfialkovskii/tasktree-manager/issues)
+- 💬 [Discussions](https://github.com/ruslanfialkovskii/tasktree-manager/discussions)
 - 📖 [Documentation](docs/)
 
 ---
 
-**Made with ❤️ by developers, for developers** | [⭐ Star this repo](https://github.com/yourusername/tasktree-manager)
+**Made with ❤️ by developers, for developers** | [⭐ Star this repo](https://github.com/ruslanfialkovskii/tasktree-manager)

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/docs/configuration.md

@@ -86,7 +86,7 @@ repos_dir = "/Users/username/repos"
 # Created automatically if it doesn't exist
 tasks_dir = "/Users/username/tasks"
 
-# Directory for finished-task diff archives
+# Directory for finished-task archives (diffs and task-folder files)
 # Relative paths resolve under tasks_dir (never the current directory)
 # Default: "" (uses <tasks_dir>/.archive)
 archive_dir = ""
@@ -305,7 +305,7 @@ blocklist = [
 |------------|------|-----------|---------------------|------------------------------------------------|
 | `repos_dir` | path | `~/repos` | `REPOS_DIR`         | Directory containing your git repositories     |
 | `tasks_dir` | path | `~/tasks` | `TASKS_DIR`         | Directory where task worktrees will be created |
-| `archive_dir` | path | `""` (`<tasks_dir>/.archive`) | - | Directory for finished-task diff archives |
+| `archive_dir` | path | `""` (`<tasks_dir>/.archive`) | - | Directory for finished-task archives (diffs and task-folder files) |
 
 ### Details
 

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/docs/troubleshooting.md

@@ -921,7 +921,7 @@ Yes! Each task creates its own worktree and branch:
 
 - Worktrees are removed from `TASKS_DIR`
 - The local task branch is deleted from the main repository (`git branch -D`);
-  the remaining diff is archived under `archive_dir` first
+  the remaining diff and the task-folder files are archived under `archive_dir` first
 - Remote branches remain on GitHub/GitLab (if pushed)
 
 **Manual cleanup (only for branches created outside tasktree):**

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/docs/user-guide.md

@@ -687,6 +687,12 @@ d (delete task)
 - ✅ The task's remaining diff (committed-but-unmerged + uncommitted work) is archived to
   `archive_dir` (default `<tasks_dir>/.archive/<task>-<timestamp>.patch`) before anything
   is removed — the messages panel (`m`) shows the archive path
+- ✅ Files in the task folder outside the worktrees (`PLAN.md`, ADRs, notes, scripts) are
+  copied to `<task>-<timestamp>.files/` next to the patch. Hidden files, symlinks,
+  `node_modules`/`vendor`/`.terraform` folders and an unedited generated `CLAUDE.md` are
+  skipped silently. Key material (`*.pem`, `*.key`, `id_rsa`, kubeconfigs, `*.tfstate`,
+  `credentials*.json`), files over 10 MB, files past 100 MB in total and files that cannot
+  be read or copied are listed in the messages panel
 - ✅ Worktrees removed from `TASKS_DIR`
 - ✅ Branches remain on remote (if pushed)
 - ✅ Original repos in `REPOS_DIR` untouched

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

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/tasktree_manager/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.13.2'
-__version_tuple__ = version_tuple = (2, 13, 2)
+__version__ = version = '2.13.3'
+__version_tuple__ = version_tuple = (2, 13, 3)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/tasktree_manager/app.py

@@ -24,8 +24,8 @@ 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 GitStatus, Task, TaskSafetyReport, Worktree
-from .services.task_manager import TaskManager
+from .services.models import 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
 from .widgets.create_modal import (
@@ -1378,14 +1378,15 @@ class TaskTreeApp(App):
 
         Removing worktrees runs git per repo and rmtree over trees that can
         be huge (node_modules etc.) - never block the UI thread on it.
-        The task's remaining diff (committed-but-unmerged + uncommitted) is
-        archived first — finish_task rmtrees the task directory.
+        The task's remaining diff (committed-but-unmerged + uncommitted) and
+        its task-folder files are archived first — finish_task rmtrees the
+        task directory.
         """
         error: str | None = None
-        archive_path: Path | None = None
+        archive: ArchiveResult | None = None
         try:
             try:
-                archive_path = self.task_manager.archive_task(task)
+                archive = self.task_manager.archive_task(task)
             except Exception as e:
                 # A failed archive must not block deletion, but it must be
                 # loud — the archive is the safety net for the work the
@@ -1394,6 +1395,8 @@ class TaskTreeApp(App):
                 detail = f"Archive failed for '{task.name}': {type(e).__name__}: {e}"
                 self.call_from_thread(self.notify, escape(detail), severity="warning", timeout=10)
                 self.call_from_thread(self._log_activity, detail, MessageLevel.ERROR, task.name)
+                # Still report the files that were saved and the ones left out
+                archive = getattr(e, "result", None)
             self.task_manager.finish_task(task)
         except ValueError as e:
             # finish_task raises ValueError (nothing removed) when worktrees
@@ -1402,37 +1405,66 @@ class TaskTreeApp(App):
             error = str(e)
         except Exception as e:
             error = f"{type(e).__name__}: {e}"
-        self.call_from_thread(self._apply_finish_task_result, task.name, force, error, archive_path)
+        self.call_from_thread(self._apply_finish_task_result, task.name, force, error, archive)
 
     def _apply_finish_task_result(
         self,
         task_name: str,
         force: bool,
         error: str | None,
-        archive_path: Path | None = None,
+        archive: ArchiveResult | None = None,
     ) -> None:
         """Report the delete outcome and reload (runs on the main thread)."""
         if error:
             self.notify(escape(f"Failed to delete task: {error}"), severity="error")
             self._log_activity(f"Failed to delete task: {error}", MessageLevel.ERROR, task_name)
-            if archive_path is not None:
+            if archive is not None:
                 # The archive succeeded before the delete itself failed - the
                 # user's work is not lost, but they should know where it is
-                self._log_activity(
-                    f"Archived diff to {archive_path} before the failed delete",
-                    MessageLevel.INFO,
-                    task_name,
-                )
+                self._log_archive(task_name, archive, " before the failed delete")
         else:
             self.notify(escape(f"Deleted task: {task_name}"))
             suffix = " (force)" if force else ""
             self._log_activity(
                 f"Task '{task_name}' deleted{suffix}", MessageLevel.SUCCESS, task_name
             )
-            if archive_path is not None:
-                self._log_activity(f"Archived diff to {archive_path}", MessageLevel.INFO, task_name)
+            if archive is not None:
+                self._log_archive(task_name, archive)
         self._load_tasks()
 
+    def _log_archive(self, task_name: str, archive: ArchiveResult, context: str = "") -> None:
+        """Log where a task's work was archived and warn about files left out.
+
+        The left-out notes come first and are capped, so the archive
+        location stays among the latest entries of the bounded panel.
+        """
+        notes = [f"Not archived: {item}" for item in archive.skipped]
+        notes += [f"Could not archive: {item}" for item in archive.failed]
+        for note in notes[:ARCHIVE_NOTES_SHOWN]:
+            self._log_activity(note, MessageLevel.WARNING, task_name)
+        if len(notes) > ARCHIVE_NOTES_SHOWN:
+            self._log_activity(
+                f"... and {len(notes) - ARCHIVE_NOTES_SHOWN} more not archived",
+                MessageLevel.WARNING,
+                task_name,
+            )
+        if archive.patch is not None:
+            self._log_activity(
+                f"Archived diff to {archive.patch}{context}", MessageLevel.INFO, task_name
+            )
+        if archive.files_dir is not None:
+            self._log_activity(
+                f"Archived {len(archive.files)} task file(s) to {archive.files_dir}{context}",
+                MessageLevel.INFO,
+                task_name,
+            )
+        if notes:
+            self.notify(
+                f"{len(notes)} task file note(s) - see messages",
+                severity="warning",
+                timeout=10,
+            )
+
     def _handle_safe_delete_action(
         self, task: Task, safety_report: TaskSafetyReport, action: str | None
     ) -> None:
@@ -1615,10 +1647,13 @@ class TaskTreeApp(App):
     def _remove_worktree_worker(self, task: Task, worktree: Worktree, force: bool = False) -> None:
         """Remove a single worktree in a background thread (archive, git, rmtree)."""
         error: str | None = None
-        archive_path: Path | None = None
+        archive: ArchiveResult | None = None
         try:
             try:
-                archive_path = self.task_manager.archive_task(self._worktree_view(task, worktree))
+                # Diff only: the task folder and its files stay in place
+                archive = self.task_manager.archive_task(
+                    self._worktree_view(task, worktree), include_files=False
+                )
             except Exception as e:
                 # Loud but non-blocking, same policy as task deletion
                 detail = f"Archive failed for '{worktree.name}': {type(e).__name__}: {e}"
@@ -1628,7 +1663,7 @@ class TaskTreeApp(App):
         except Exception as e:
             error = f"{type(e).__name__}: {e}"
         self.call_from_thread(
-            self._apply_remove_worktree_result, task.name, worktree.name, force, error, archive_path
+            self._apply_remove_worktree_result, task.name, worktree.name, force, error, archive
         )
 
     def _apply_remove_worktree_result(
@@ -1637,7 +1672,7 @@ class TaskTreeApp(App):
         worktree_name: str,
         force: bool,
         error: str | None,
-        archive_path: Path | None = None,
+        archive: ArchiveResult | None = None,
     ) -> None:
         """Report the worktree removal outcome and reload (main thread)."""
         if error:
@@ -1647,12 +1682,8 @@ class TaskTreeApp(App):
                 MessageLevel.ERROR,
                 task_name,
             )
-            if archive_path is not None:
-                self._log_activity(
-                    f"Archived diff to {archive_path} before the failed delete",
-                    MessageLevel.INFO,
-                    task_name,
-                )
+            if archive is not None:
+                self._log_archive(task_name, archive, " before the failed delete")
         else:
             self.notify(escape(f"Deleted worktree: {worktree_name}"))
             suffix = " (force)" if force else ""
@@ -1661,8 +1692,8 @@ class TaskTreeApp(App):
                 MessageLevel.SUCCESS,
                 task_name,
             )
-            if archive_path is not None:
-                self._log_activity(f"Archived diff to {archive_path}", MessageLevel.INFO, task_name)
+            if archive is not None:
+                self._log_archive(task_name, archive)
         self._load_tasks()
 
     def _open_lazygit_for_task(self, task: Task, safety_report: TaskSafetyReport) -> None:

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/tasktree_manager/cli.py

@@ -16,8 +16,8 @@ from . import __version__
 from .services import forge
 from .services.config import Config, ConfigError
 from .services.git_ops import GitOps
-from .services.models import Task
-from .services.task_manager import TaskManager
+from .services.models import ArchiveResult, Task
+from .services.task_manager import ARCHIVE_NOTES_SHOWN, ArchiveIncompleteError, TaskManager
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -55,7 +55,8 @@ def build_parser() -> argparse.ArgumentParser:
     delete.add_argument(
         "--force",
         action="store_true",
-        help="Delete even with uncommitted, unpushed or unmerged work",
+        help="Delete even with uncommitted, unpushed or unmerged work, or task files "
+        "that could not be archived",
     )
     delete.set_defaults(func=cmd_delete)
 
@@ -66,7 +67,7 @@ def build_parser() -> argparse.ArgumentParser:
     add_repo.set_defaults(func=cmd_add_repo)
 
     finish = sub.add_parser(
-        "finish", help="Finish a task: safety sweep, archive its diff, then delete"
+        "finish", help="Finish a task: safety sweep, archive its diff and files, then delete"
     )
     finish.add_argument("name", help="Task name")
     finish.add_argument("--push", action="store_true", help="Push unpushed branches first")
@@ -74,12 +75,13 @@ def build_parser() -> argparse.ArgumentParser:
         "--no-archive",
         action="store_true",
         dest="no_archive",
-        help="Skip writing the diff archive",
+        help="Skip the archive: the diff and the task-folder files are deleted unsaved",
     )
     finish.add_argument(
         "--force",
         action="store_true",
-        help="Finish even with unfinished work (the archive is still written)",
+        help="Finish even with unfinished work or task files that could not be archived "
+        "(the archive is still written)",
     )
     finish.set_defaults(func=cmd_finish)
 
@@ -201,6 +203,50 @@ def cmd_repos(manager: TaskManager, config: Config, args: argparse.Namespace) ->
     return 0
 
 
+def _print_archive(archive: ArchiveResult | None) -> bool:
+    """Report where a task's work was archived; True if anything was saved."""
+    if archive is None:
+        return False
+    notes = [f"not archived: {item}" for item in archive.skipped]
+    notes += [f"could not archive: {item}" for item in archive.failed]
+    for note in notes[:ARCHIVE_NOTES_SHOWN]:
+        print(f"warning: {note}", file=sys.stderr)
+    if len(notes) > ARCHIVE_NOTES_SHOWN:
+        print(f"warning: ... and {len(notes) - ARCHIVE_NOTES_SHOWN} more", file=sys.stderr)
+    if archive.patch is not None:
+        print(f"Archived diff to {archive.patch}")
+    if archive.files_dir is not None:
+        print(f"Archived {len(archive.files)} task file(s) to {archive.files_dir}")
+    return archive.saved
+
+
+def _archive_for_delete(
+    manager: TaskManager, task: Task, force: bool, verb: str, notes: list[str] | None = None
+) -> tuple[bool, bool]:
+    """Archive a task about to be deleted; returns (may delete, anything saved).
+
+    Any archive error stops the delete. Task files that could not be read or
+    copied stop it too unless --force: the task folder is their only copy.
+    """
+    try:
+        archive = manager.archive_task(task, notes=notes)
+    except ArchiveIncompleteError as e:
+        _print_archive(e.result)
+        _error(f"archive failed: {e}")
+        return False, False
+    except Exception as e:
+        _error(f"archive failed: {e}")
+        return False, False
+    saved = _print_archive(archive)
+    if archive is not None and archive.failed and not force:
+        _error(
+            f"{len(archive.failed)} task file(s) could not be archived; "
+            f"use --force to {verb} anyway"
+        )
+        return False, saved
+    return True, saved
+
+
 def cmd_delete(manager: TaskManager, config: Config, args: argparse.Namespace) -> int:
     """Delete a task after a safety check (bypass with --force)."""
     task = manager.get_task(args.name)
@@ -215,14 +261,11 @@ def cmd_delete(manager: TaskManager, config: Config, args: argparse.Namespace) -
         print("use --force to delete anyway", file=sys.stderr)
         return 1
 
-    # Same safety net as the TUI: the remaining diff is archived before the
-    # worktrees and branches are removed, --force included
-    try:
-        archive_path = manager.archive_task(task)
-    except Exception as e:
-        return _error(f"archive failed: {e}")
-    if archive_path is not None:
-        print(f"Archived diff to {archive_path}")
+    # Same safety net as the TUI: the remaining diff and the task files are
+    # archived before the worktrees and branches are removed, --force included
+    may_delete, _ = _archive_for_delete(manager, task, args.force, "delete")
+    if not may_delete:
+        return 1
     manager.finish_task(task)
     print(f"Deleted task {args.name}")
     return 0
@@ -262,13 +305,12 @@ def cmd_finish(manager: TaskManager, config: Config, args: argparse.Namespace) -
 
     if not args.no_archive:
         notes = [f"{issue.repo_name}: {issue.details}" for issue in report.merged_via_forge]
-        try:
-            archive_path = manager.archive_task(task, notes=notes or None)
-        except Exception as e:
-            return _error(f"archive failed: {e}")
-        if archive_path is not None:
-            print(f"Archived diff to {archive_path}")
-        else:
+        may_delete, saved = _archive_for_delete(
+            manager, task, args.force, "finish", notes=notes or None
+        )
+        if not may_delete:
+            return 1
+        if not saved:
             print("Nothing to archive")
 
     manager.finish_task(task)

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/tasktree_manager/services/config.py

@@ -95,6 +95,19 @@ def _toml_table(config_data: dict, key: str) -> dict:
     return value
 
 
+# Private keys and certificates: never symlinked into worktrees and never
+# copied into finished-task archives
+KEY_MATERIAL_PATTERNS: list[str] = [
+    "*.pem",
+    "*.key",
+    "*.p12",
+    "*.pfx",
+    "*.keystore",
+    "id_rsa",
+    "id_ecdsa",
+    "id_ed25519",
+]
+
 # Default patterns excluded when symlinking gitignored files into worktrees.
 # Caches/build artifacts are excluded as noise; key material is excluded so
 # private keys and certificates never spread beyond the main checkout
@@ -116,14 +129,7 @@ DEFAULT_SYMLINK_BLOCKLIST: list[str] = [
     ".nox",
     "*.so",
     "*.dylib",
-    "*.pem",
-    "*.key",
-    "*.p12",
-    "*.pfx",
-    "*.keystore",
-    "id_rsa",
-    "id_ecdsa",
-    "id_ed25519",
+    *KEY_MATERIAL_PATTERNS,
 ]
 
 
@@ -141,7 +147,8 @@ class Config:
     repos_dir: Path = field(default_factory=lambda: Path.home() / "repos")
     tasks_dir: Path = field(default_factory=lambda: Path.home() / "tasks")
     config_dir: Path = field(default_factory=lambda: Path.home() / ".config" / "tasktree-manager")
-    # Archive directory for finished-task diffs ("" = <tasks_dir>/.archive)
+    # Archive directory for finished-task diffs and task-folder files
+    # ("" = <tasks_dir>/.archive)
     archive_dir: str = ""
 
     # UI settings
@@ -395,7 +402,8 @@ repos_dir = "{self._toml_escape(str(self._persisted("repos_dir")))}"
 # Directory for task worktrees
 tasks_dir = "{self._toml_escape(str(self._persisted("tasks_dir")))}"
 
-# Directory for finished-task diff archives ("" = <tasks_dir>/.archive)
+# Directory for finished-task archives: diffs and task-folder files
+# ("" = <tasks_dir>/.archive)
 archive_dir = "{self._toml_escape(self.archive_dir)}"
 
 # ============================================================================
@@ -544,7 +552,7 @@ cursor_up = "{self._toml_escape(self.keybindings.get("cursor_up", "k"))}"
         self.config_dir.mkdir(parents=True, exist_ok=True)
 
     def get_archive_dir(self) -> Path:
-        """Get the archive directory for finished-task diffs.
+        """Get the archive directory for finished-task diffs and files.
 
         A relative path is anchored under tasks_dir, never $PWD — `finish`
         may run from inside a worktree, and a CWD-relative archive would be

{tasktree_manager-2.13.2 → tasktree_manager-2.13.3}/tasktree_manager/services/models.py

@@ -126,6 +126,22 @@ class RepoIssue:
     mr_state: str | None = None  # "open" | "merged" | "closed" | "none"
 
 
+@dataclass(frozen=True)
+class ArchiveResult:
+    """What archive_task saved before a task folder is deleted."""
+
+    patch: Path | None = None  # combined diff of every worktree
+    files_dir: Path | None = None  # copies of task-folder files outside worktrees
+    files: tuple[str, ...] = ()  # archived files, relative to the task folder
+    skipped: tuple[str, ...] = ()  # "name (reason)": left out by policy (caps, keys)
+    failed: tuple[str, ...] = ()  # "name (reason)": could not be read or copied
+
+    @property
+    def saved(self) -> bool:
+        """True when anything was written to the archive directory."""
+        return self.patch is not None or self.files_dir is not None
+
+
 @dataclass
 class TaskSafetyReport:
     """Report of safety issues for a task."""