tasktree-manager 2.12.0__tar.gz → 2.13.0__tar.gz

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/.github/workflows/release.yml

@@ -4,9 +4,16 @@
 # Handles version bumping, testing, building, PyPI publishing,
 # and GitHub release creation.
 #
+# Order matters: the version is only *computed* up front; lint and the full
+# test matrix run against the pushed commit, and only when they pass is the
+# bump committed, tagged and pushed. A red release run therefore never
+# leaves a ghost tag or a bumped pyproject on main.
+#
 # Triggers:
 #   - Push to main: semantic-release determines if a release is needed
-#   - Manual dispatch: choose release type, pre-release, and draft options
+#   - Manual dispatch: choose release type, pre-release, and draft options.
+#     Both `draft` and `pre_release` skip the PyPI upload (the pipeline can
+#     only produce final X.Y.Z versions) and only shape the GitHub release.
 
 name: Release
 
@@ -26,12 +33,12 @@ on:
           - minor
           - major
       pre_release:
-        description: "Mark as pre-release?"
+        description: "Mark the GitHub release as pre-release? (skips PyPI)"
         required: false
         default: false
         type: boolean
       draft:
-        description: "Create as draft release?"
+        description: "Create the GitHub release as a draft? (skips PyPI)"
         required: false
         default: false
         type: boolean
@@ -49,7 +56,6 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
-          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
 
       - name: Set up Python
         uses: actions/setup-python@v5
@@ -57,84 +63,79 @@ jobs:
           python-version: "3.12"
 
       - name: Install dependencies
-        run: pip install python-semantic-release build hatch-vcs
+        # Pinned: an unpinned resolver pull once produced a PSR/GitPython
+        # combination that crashed on startup
+        run: pip install "python-semantic-release==10.6.2"
 
       - name: Determine version
         id: determine_version
         env:
-          GH_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          # Get current version from pyproject.toml
-          current_version=$(python -c "
-          import re
-          content = open('pyproject.toml').read()
-          match = re.search(r'^\s*version\s*=\s*\"([^\"]+)\"', content, re.MULTILINE)
-          print(match.group(1) if match else '0.0.0')
-          ")
+          # The latest v* tag is the source of truth for the current version
+          # (semantic-release derives the next one from it). pyproject is
+          # only reported: a stray local bump must not shift the release.
+          latest_tag=$(git describe --tags --abbrev=0 --match 'v[0-9]*' 2>/dev/null || echo "v0.0.0")
+          current_version="${latest_tag#v}"
           echo "current_version=${current_version}" >> $GITHUB_OUTPUT
-          echo "Current version: ${current_version}"
+          echo "Current version (latest tag): ${current_version}"
 
           release_type="${{ inputs.release_type || 'auto' }}"
 
           if [ "$release_type" = "auto" ]; then
-            # Use semantic-release to determine bump type from commit history.
-            # When no qualifying commits exist, `version --print` prints the
+            # Use semantic-release to determine the next version from the
+            # commit history. When no qualifying commits exist it prints the
             # CURRENT version — require an actual bump before releasing.
-            VERSION=$(semantic-release version --print 2>/dev/null || echo "")
+            # A tool crash is an error, never "no release needed".
+            if ! VERSION=$(semantic-release version --print); then
+              echo "::error::semantic-release failed to compute the next version"
+              exit 1
+            fi
             if [ -n "$VERSION" ] && [ "$VERSION" != "$current_version" ]; then
-              # Determine bump type by comparing versions
-              IFS='.' read -r cur_major cur_minor cur_patch <<< "$current_version"
-              IFS='.' read -r new_major new_minor new_patch <<< "$VERSION"
-              if [ "$new_major" -gt "$cur_major" ]; then
-                bump_type="major"
-              elif [ "$new_minor" -gt "$cur_minor" ]; then
-                bump_type="minor"
-              else
-                bump_type="patch"
-              fi
-              # Use bump_version.py to get the actual new version
-              new_version=$(python scripts/bump_version.py "$bump_type" --dry-run 2>&1 | grep "New version:" | awk '{print $3}')
+              new_version="$VERSION"
               echo "new_version=${new_version}" >> $GITHUB_OUTPUT
               echo "released=true" >> $GITHUB_OUTPUT
-              echo "bump_type=${bump_type}" >> $GITHUB_OUTPUT
-              echo "Auto-detected bump type: ${bump_type}, version: ${new_version}"
+              echo "Auto-detected next version: ${new_version}"
             else
               echo "released=false" >> $GITHUB_OUTPUT
               echo "No release needed (no qualifying commits)"
             fi
           else
-            # Manual bump using bump_version.py
-            new_version=$(python scripts/bump_version.py "$release_type" --dry-run 2>&1 | grep "New version:" | awk '{print $3}')
-            if [ -n "$new_version" ]; then
-              echo "new_version=${new_version}" >> $GITHUB_OUTPUT
-              echo "released=true" >> $GITHUB_OUTPUT
-              echo "bump_type=${release_type}" >> $GITHUB_OUTPUT
-              echo "Manual bump to: ${new_version}"
-            else
-              echo "released=false" >> $GITHUB_OUTPUT
-              echo "Failed to determine new version"
-              exit 1
-            fi
+            # Manual bump computed from the latest tag
+            IFS='.' read -r major minor patch <<< "$current_version"
+            case "$release_type" in
+              major) new_version="$((major + 1)).0.0" ;;
+              minor) new_version="${major}.$((minor + 1)).0" ;;
+              patch) new_version="${major}.${minor}.$((patch + 1))" ;;
+              *) echo "::error::unknown release type ${release_type}"; exit 1 ;;
+            esac
+            echo "new_version=${new_version}" >> $GITHUB_OUTPUT
+            echo "released=true" >> $GITHUB_OUTPUT
+            echo "Manual bump to: ${new_version}"
           fi
 
-      - name: Apply version bump
-        if: steps.determine_version.outputs.released == 'true'
-        run: |
-          bump_type="${{ steps.determine_version.outputs.bump_type }}"
-          python scripts/bump_version.py "$bump_type"
+  lint:
+    name: Lint
+    needs: prepare-release
+    if: needs.prepare-release.outputs.released == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-      - name: Commit and tag version
-        if: steps.determine_version.outputs.released == 'true'
-        run: |
-          new_version="${{ steps.determine_version.outputs.new_version }}"
-          git config --local user.email "github-actions[bot]@users.noreply.github.com"
-          git config --local user.name "github-actions[bot]"
-          git add -A
-          git diff --cached --quiet && echo "No changes to commit" || \
-            git commit -m "chore(release): ${new_version} [skip ci]"
-          git tag -fa "v${new_version}" -m "Release v${new_version}"
-          git push origin main
-          git push origin "v${new_version}" --force
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install ruff
+        run: pip install ruff
+
+      - name: Run ruff linter
+        run: ruff check tasktree_manager tests
+
+      - name: Run ruff formatter check
+        run: ruff format --check tasktree_manager tests
 
   test:
     name: Test (Python ${{ matrix.python-version }})
@@ -144,12 +145,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.13"]
+        # Same matrix as ci.yml: the release gate must not be weaker than CI
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
         with:
-          ref: "v${{ needs.prepare-release.outputs.new_version }}"
           fetch-depth: 0
 
       - name: Set up Python ${{ matrix.python-version }}
@@ -170,9 +171,47 @@ jobs:
       - name: Run tests
         run: pytest tests/ -v --tb=short
 
+  tag-release:
+    name: Commit and Tag
+    needs: [prepare-release, lint, test]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          # The exact commit that was tested. Pushing HEAD:main below fails
+          # (non-fast-forward) if main moved in the meantime, instead of
+          # tagging code the gate never saw.
+          ref: ${{ github.sha }}
+          fetch-depth: 0
+          token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Apply version bump
+        # Write the exact version semantic-release computed; deriving it
+        # again from pyproject would drift whenever pyproject and the tag
+        # disagree (phantom or skipped releases)
+        run: python scripts/bump_version.py --set "${{ needs.prepare-release.outputs.new_version }}"
+
+      - name: Commit and tag version
+        run: |
+          new_version="${{ needs.prepare-release.outputs.new_version }}"
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add -A
+          git diff --cached --quiet && echo "No changes to commit" || \
+            git commit -m "chore(release): ${new_version} [skip ci]"
+          git tag -a "v${new_version}" -m "Release v${new_version}"
+          git push origin HEAD:main
+          git push origin "v${new_version}"
+
   build:
     name: Build Package
-    needs: [prepare-release, test]
+    needs: [prepare-release, tag-release]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
@@ -210,6 +249,9 @@ jobs:
   publish-pypi:
     name: Publish to PyPI
     needs: [prepare-release, build]
+    # Drafts and pre-releases never reach PyPI: bump_version.py only emits
+    # final X.Y.Z versions, so uploading would publish a real release
+    if: ${{ !inputs.draft && !inputs.pre_release }}
     runs-on: ubuntu-latest
     environment: pypi
     permissions:
@@ -231,7 +273,13 @@ jobs:
 
   github-release:
     name: Create GitHub Release
-    needs: [prepare-release, publish-pypi]
+    needs: [prepare-release, build, publish-pypi]
+    # Run after a successful build whether PyPI publishing ran or was
+    # skipped (draft / pre-release), but never after a failed upload
+    if: >-
+      always() &&
+      needs.build.result == 'success' &&
+      (needs.publish-pypi.result == 'success' || needs.publish-pypi.result == 'skipped')
     runs-on: ubuntu-latest
     permissions:
       contents: write

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/CHANGELOG.md

@@ -15,6 +15,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Git hooks support
 - Custom task metadata
 
+## [2.13.0] - 2026-09-11
+
+### Added
+- **tui**: Show Claude session recap in the Info panel
+
+
+## [2.12.1] - 2026-09-03
+
+### Changed
+- Align guides with deletion, config and platform behaviour
+- **release**: Gate tag on lint and tests, derive version from tags
+
+### Fixed
+- **tui**: Install configured keybindings, safe worktree delete, markup-safe rows
+- **config**: Keep env overrides out of config.toml and fail on bad TOML
+- **services**: Harden task deletion, creation and archive safety
+
+
 ## [2.12.0] - 2026-07-31
 
 ### Added

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/PKG-INFO

@@ -1,10 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: tasktree-manager
-Version: 2.12.0
+Version: 2.13.0
 Summary: TUI application for managing worktree-based tasks
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: textual>=7.0.0
+Requires-Dist: tomli>=2.0.1; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: build>=1.0.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/README.md

@@ -20,6 +20,7 @@
 - 🔧 **Flexible Configuration** - TOML config file, custom keybindings, environment variables
 - 🤖 **Headless CLI** - Create, list, inspect, finish, and delete tasks from scripts and AI agents without opening the TUI
 - 🛰️ **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
 
@@ -82,7 +83,7 @@ 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   # low-level delete; refuses on unfinished work; --force overrides
+tasktree-manager delete DIC-1901-argocd-tls   # archive diff -> 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
@@ -173,7 +174,9 @@ Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 - Python 3.10+ (3.13+ recommended)
 - Git 2.0+
 - 256-color terminal
-- Unix-like OS (macOS, Linux, WSL2)
+- Unix-like OS (macOS, Linux, WSL2). Opening a folder, editor or Claude session in a
+  new terminal tab (`o`, `e`, `c`) drives Ghostty via AppleScript and is macOS-only;
+  elsewhere those keys show a notice
 
 See [Installation Guide](docs/installation.md) for detailed requirements and setup.
 

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/docs/configuration.md

@@ -165,6 +165,9 @@ claude_path = "claude"
 # 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).
+# If you relocated Claude Code's config home with $CLAUDE_CONFIG_DIR, point
+# this under that directory too (the per-repo worktree memory below and
+# session resume already honour the variable).
 # Default: "~/.claude/tasktree-memory"
 claude_memory_dir = "~/.claude/tasktree-memory"
 
@@ -177,9 +180,21 @@ claude_memory_dir = "~/.claude/tasktree-memory"
 # worktree of a repo survives worktree deletion and is shared with future
 # worktrees of that repo and with sessions in the main checkout. The settings
 # file is added to the repo's .git/info/exclude so worktrees stay clean.
+# The directory name follows the current Claude CLI rule (every character
+# outside [A-Za-z0-9] becomes "-"); memory saved by older tasktree versions
+# under the previous name (which kept "_") is moved once, automatically.
 # Default: true
 claude_repo_memory = true
 
+# Claude session recap in the Info panel. When a task is highlighted, the
+# bottom of the panel shows its latest Claude Code session: title, last turn
+# duration ("Baked for 45s · done 5:27 PM"), and the idle recap Claude writes
+# a few minutes after a turn ("※ recap: ..."), or the last prompt when no
+# recap exists yet. Read from the session transcript under ~/.claude/projects
+# (honours CLAUDE_CONFIG_DIR); no CLI call.
+# Default: true
+claude_recap = true
+
 # Path to glab executable (GitLab CLI, used for MR/CI status)
 # Default: "glab" (searches PATH)
 glab_path = "glab"
@@ -547,7 +562,10 @@ blocklist = [
 > **Upgrading note:** if your existing `config.toml` already contains a
 > `blocklist`, it keeps overriding the defaults — the key-material patterns
 > added in newer versions do NOT apply until you add them (or delete the
-> `blocklist` line to inherit the defaults).
+> `blocklist` line to inherit the defaults). Saving the config from the app
+> (for example on a theme switch) no longer writes the default list: the key
+> is only written when you customised it, so the built-in defaults keep
+> applying as they evolve.
 
 ### Common Use Cases
 
@@ -687,10 +705,14 @@ Override configuration for a single session using environment variables:
 | `TASKS_DIR`               | `tasks_dir`            | `export TASKS_DIR=~/worktrees`   |
 | `TASKTREE_THEME`          | `ui.theme`             | `export TASKTREE_THEME=nord`     |
 | `TASKTREE_DEFAULT_BRANCH` | `git.default_base_branch` | `export TASKTREE_DEFAULT_BRANCH=develop` |
-| `EDITOR`                  | `tools.editor`         | `export EDITOR=nvim`             |
-| `SHELL`                   | `tools.shell`          | `export SHELL=/bin/zsh`          |
+| `EDITOR`                  | `tools.editor` (fallback: used only when `tools.editor` is empty) | `export EDITOR=nvim` |
 | `XDG_CONFIG_HOME`         | (config location)      | `export XDG_CONFIG_HOME=~/.cfg`  |
 
+Environment overrides apply to the running session only: saving the config (for
+example by switching themes with `t`) writes the config-file values back, never the
+overridden ones. Empty values (`TASKS_DIR=`) are ignored. A config file that fails to
+parse is an error at startup, not an empty config.
+
 ### Usage Examples
 
 **Temporary different repos directory:**

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/docs/installation.md

@@ -256,7 +256,10 @@ Launch tasktree-manager:
 tasktree-manager
 ```
 
-On first run, you'll see a configuration wizard:
+On first run, you'll see a configuration wizard (it appears when the repositories
+directory, `~/repos` by default, does not exist yet; with `~/repos` already present
+the defaults apply and no `config.toml` is written until you change a setting, such
+as the theme):
 
 #### Configuration Wizard
 

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/docs/troubleshooting.md

@@ -692,34 +692,33 @@ wsl --shutdown
 
 ## Git-Specific Issues
 
-### "Branch already exists"
+### Task branch already exists
 
-**Error:**
+Creating a task whose branch already exists in a repo (left behind by an earlier
+task, or created by hand) is not an error: the worktree is created **on the existing
+branch as-is**, keeping every commit on it. The base branch you enter is ignored for
+that repo.
+
+**Error you can still hit:**
 ```
-fatal: A branch named 'FEAT-123' already exists
+fatal: 'FEAT-123' is already checked out at '/Users/you/repos/repo-name'
 ```
 
-**Cause:** Branch exists in repository from previous task.
+**Cause:** the branch is checked out in the main repository (or another worktree);
+git allows a branch in only one worktree at a time.
 
-**Solutions:**
-
-1. **Use different task name:**
-   ```bash
-   # Instead of FEAT-123, use FEAT-123-v2
-   ```
-
-2. **Delete old branch:**
-   ```bash
-   cd ~/repos/repo-name
-   git branch -d FEAT-123  # If merged
-   git branch -D FEAT-123  # Force delete
-   ```
+**Solution:**
+```bash
+cd ~/repos/repo-name
+git switch main            # move the main checkout off the task branch
+# then retry the task creation / add-repo
+```
 
-3. **Use existing branch:**
-   ```bash
-   # When creating task, use existing branch as base
-   Base branch: FEAT-123
-   ```
+To start the task fresh from the base branch instead, delete the old branch first:
+```bash
+git branch -d FEAT-123  # If merged
+git branch -D FEAT-123  # Force delete (loses its unmerged commits)
+```
 
 ### "Detached HEAD state"
 
@@ -921,10 +920,11 @@ Yes! Each task creates its own worktree and branch:
 ### What happens to branches when I delete a task?
 
 - Worktrees are removed from `TASKS_DIR`
-- Local branches remain in main repository
+- The local task branch is deleted from the main repository (`git branch -D`);
+  the remaining diff is archived under `archive_dir` first
 - Remote branches remain on GitHub/GitLab (if pushed)
 
-**Manual cleanup:**
+**Manual cleanup (only for branches created outside tasktree):**
 ```bash
 cd ~/repos/repo-name
 git branch -d FEAT-123  # Delete local branch

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/docs/user-guide.md

@@ -219,6 +219,23 @@ Shows detailed git status for the selected worktree:
 - **Sync status**: Ahead/behind counts
 - **File changes**: Modified, staged, and untracked files with git status codes
 
+While the task list is focused, the panel shows the task summary instead (every
+repo with its changes or `clean`), followed by a **Claude session recap** when the
+task has a Claude Code session:
+
+```
+─ claude ─────────────────
+access-m2
+✻ Baked for 45s · done 5:27 PM · busy
+※ recap: Fulfilling ACCESS2-7180, read-only M2 access: gitops RBAC and
+terraform edits sit unstaged. Next, decide whether to hand-create the group.
+```
+
+- **Title**: the session name (`/rename`), else Claude's own title, else the session slug
+- **Turn line**: duration of the last turn and when it finished; `busy`/`idle` mirrors the task's Claude status indicator
+- **Recap**: the summary Claude writes a few minutes after a turn when the session idles. Until one exists, the dim `last prompt:` line shows what was asked last
+- Nothing is shown for tasks without a session. The block refreshes as you move the cursor and every 5 seconds while a transcript changes. Disable with `claude_recap = false` under `[tools]` in `config.toml`
+
 **Git status codes:**
 - `M` - Modified
 - `A` - Added (staged)
@@ -310,10 +327,10 @@ what is displayed. Press `?` for the full reference at any time.
 5. Select repos with `Space` (can select multiple)
 6. Tab to "Create" button, press `Enter`
 
-Task names may contain letters, numbers, `.`, `_`, `/` and `-`. Because the
-name becomes a directory under your tasks dir (and a git branch), names with
-`.`/`..` path segments, empty segments, or a leading `-` are rejected; base
-branch names must not start with `-` either.
+Task names may contain letters, numbers, `.`, `_` and `-`. The name becomes a
+single directory under your tasks dir (and a git branch), so `/`, `.`, `..` and a
+leading `-` are rejected; base branch names must be plain branch names too (no
+leading `-`/`+`, no `:` refspecs, none of the characters git forbids in refs).
 
 **Clone task workflow:**
 Useful when you're spinning up several similar tasks that share the same set of repos.
@@ -648,6 +665,14 @@ d (delete task)
    - **Uncommitted changes**: Commit or stash first
    - **Unpushed commits**: Push or force delete
    - **Unmerged branches**: Merge PR or force delete
+   - **Wrong branch checked out**: a worktree that is detached or on another branch
+     is reported as an error — switch back to the task branch (the check and the
+     archive follow the task branch, because that is what deletion removes)
+
+**Delete a single worktree:**
+1. Highlight the worktree in the right panel
+2. Press `D` — the same safety check, dialog (Push / Open Lazygit / Force Delete)
+   and diff archive apply, scoped to that one repo
 
 **Safety features:**
 - tasktree-manager checks for uncommitted changes
@@ -664,7 +689,9 @@ d (delete task)
 - ✅ Worktrees removed from `TASKS_DIR`
 - ✅ Branches remain on remote (if pushed)
 - ✅ Original repos in `REPOS_DIR` untouched
-- ❌ Local branches remain in original repos (cleanup manually if needed)
+- ❌ The local task branch is deleted from each repo (`git branch -D`) — unpushed
+  commits survive only in the archive patch, which is why the safety check blocks
+  unpushed work and why a worktree must be on its task branch to count as safe
 
 **From scripts:** `tasktree-manager finish <task>` runs the same guided flow headlessly
 (safety sweep → optional `--push` → archive → delete), and `tasktree-manager status
@@ -752,9 +779,9 @@ npm i -g hunkdiff
 
 **Direct editor integration:**
 1. Highlight task or worktree
-2. Press `e` to open your configured editor
-3. tasktree-manager suspends while editor runs
-4. Selection is preserved when you return
+2. Press `e` to open your configured editor in a new Ghostty tab (`$EDITOR .`)
+3. tasktree-manager keeps running alongside the editor (macOS + Ghostty only, see
+   Limitations)
 
 **Configure your editor** in `~/.config/tasktree-manager/config.toml`:
 ```toml

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/mise.toml

@@ -69,17 +69,20 @@ description = "Run tasktree-manager in dev mode with textual console"
 run = "textual run --dev tasktree_manager.app:TaskTreeApp"
 
 [tasks."release:check"]
-description = "Dry-run to preview what a release would do"
+description = "Dry-run to preview what a patch release would do"
 run = "python scripts/bump_version.py patch --dry-run"
 
+# Releases are cut by the Release workflow (tests gate the tag). Bumping
+# pyproject locally desyncs it from the latest tag and makes the workflow
+# skip or double-bump, so these tasks dispatch the workflow instead.
 [tasks."release:patch"]
-description = "Bump patch version locally"
-run = "python scripts/bump_version.py patch"
+description = "Trigger a patch release via GitHub Actions"
+run = "gh workflow run release.yml -f release_type=patch"
 
 [tasks."release:minor"]
-description = "Bump minor version locally"
-run = "python scripts/bump_version.py minor"
+description = "Trigger a minor release via GitHub Actions"
+run = "gh workflow run release.yml -f release_type=minor"
 
 [tasks."release:major"]
-description = "Bump major version locally"
-run = "python scripts/bump_version.py major"
+description = "Trigger a major release via GitHub Actions"
+run = "gh workflow run release.yml -f release_type=major"

{tasktree_manager-2.12.0 → tasktree_manager-2.13.0}/pyproject.toml

@@ -9,6 +9,7 @@ description = "TUI application for managing worktree-based tasks"
 requires-python = ">=3.10"
 dependencies = [
     "textual>=7.0.0",
+    "tomli>=2.0.1; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]
@@ -70,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.12.0"
+version = "2.13.0"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"