tasktree-manager 2.7.2__tar.gz → 2.8.0__tar.gz

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/.github/workflows/release.yml

@@ -77,9 +77,11 @@ jobs:
           release_type="${{ inputs.release_type || 'auto' }}"
 
           if [ "$release_type" = "auto" ]; then
-            # Use semantic-release to determine bump type from commit history
+            # Use semantic-release to determine bump type from commit history.
+            # When no qualifying commits exist, `version --print` prints the
+            # CURRENT version — require an actual bump before releasing.
             VERSION=$(semantic-release version --print 2>/dev/null || echo "")
-            if [ -n "$VERSION" ]; then
+            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"

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/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.8.0] - 2026-07-14
+
+### Added
+- **claude**: Per-repo Claude memory for worktree sessions
+
+### Changed
+- Release only when semantic-release bumps the version
+
+
 ## [2.7.2] - 2026-07-13
 
 ### Changed

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/PKG-INFO

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

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/docs/configuration.md

@@ -153,6 +153,18 @@ claude_path = "claude"
 # Default: "~/.claude/tasktree-memory"
 claude_memory_dir = "~/.claude/tasktree-memory"
 
+# Per-repo Claude Code memory for worktree sessions.
+# Sessions started inside a worktree would otherwise key their auto memory to
+# the worktree path — memory that dies with the worktree. When enabled,
+# tasktree-manager writes .claude/settings.local.json into each worktree
+# pointing "autoMemoryDirectory" at the main repo's own memory directory
+# (~/.claude/projects/<encoded-repo-path>/memory). What Claude learns in any
+# 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.
+# Default: true
+claude_repo_memory = true
+
 # Preferred shell
 # Leave empty to use $SHELL environment variable
 # Default: "" (uses $SHELL, falls back to /bin/bash)

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/docs/user-guide.md

@@ -367,6 +367,7 @@ Useful when you're spinning up several similar tasks that share the same set of
 - The CLI variant (`c`) generates a task-level `CLAUDE.md` with task/worktree context, copies each repo's own `CLAUDE.md` into worktrees whose branch predates it (never generating stub content), 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.
+- Each worktree additionally gets its own `.claude/settings.local.json` pointing auto-memory at the **main repo's** memory directory (`claude_repo_memory`, enabled by default). Sessions started manually inside a worktree (`cd` + `claude`) would otherwise key their memory to the worktree path and lose it when the worktree is deleted; with this, what Claude learns about a repo persists across worktrees and is shared with sessions in the main checkout. The file is git-excluded so worktrees stay clean, and these sessions also report status back to the task indicator.
 
 ### General
 

{tasktree_manager-2.7.2 → tasktree_manager-2.8.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.7.2"
+version = "2.8.0"
 tag_format = "v{version}"
 branch = "main"
 commit_message = "chore(release): {version} [skip ci]"

{tasktree_manager-2.7.2 → tasktree_manager-2.8.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.7.2'
-__version_tuple__ = version_tuple = (2, 7, 2)
+__version__ = version = '2.8.0'
+__version_tuple__ = version_tuple = (2, 8, 0)
 
 __commit_id__ = commit_id = None

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/tasktree_manager/app.py

@@ -1379,6 +1379,7 @@ class TaskTreeApp(App):
         fresh_task = self.task_manager.get_task(self.current_task.name)
         if fresh_task:
             self.task_manager.ensure_claude_md_files(fresh_task)
+            self.task_manager.ensure_worktree_settings(fresh_task)
 
         ensure_claude_hooks(task_path, self.config.claude_memory_dir)
         if has_claude_session(task_path):
@@ -1401,6 +1402,10 @@ class TaskTreeApp(App):
             self.notify("Task directory not found", severity="error")
             return
 
+        fresh_task = self.task_manager.get_task(self.current_task.name)
+        if fresh_task:
+            self.task_manager.ensure_worktree_settings(fresh_task)
+
         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}"

tasktree_manager-2.8.0/tasktree_manager/services/claude_hooks.py

@@ -0,0 +1,139 @@
+"""Claude Code hook configuration for status monitoring."""
+
+import json
+from pathlib import Path
+
+
+def _encode_project_path(folder: Path) -> str:
+    """Encode a path the way Claude CLI names ~/.claude/projects/ entries.
+
+    The encoding replaces "/" and "." with "-".
+    """
+    return str(folder).replace("/", "-").replace(".", "-")
+
+
+def has_claude_session(folder: Path) -> bool:
+    """Return True if Claude Code has a recorded session for the given folder.
+
+    Claude CLI stores transcripts at ~/.claude/projects/<encoded-path>/*.jsonl.
+    """
+    project_dir = Path.home() / ".claude" / "projects" / _encode_project_path(folder)
+    if not project_dir.is_dir():
+        return False
+    return any(project_dir.glob("*.jsonl"))
+
+
+def repo_memory_dir(repo_path: Path) -> Path:
+    """Return the main repo's own Claude auto-memory directory.
+
+    Sessions running in the main checkout use this directory by default,
+    so pointing worktree sessions here gives every worktree of a repo —
+    and the main checkout itself — one shared memory that outlives any
+    single worktree.
+    """
+    return Path.home() / ".claude" / "projects" / _encode_project_path(repo_path) / "memory"
+
+
+def _make_hook(status: str, status_file: str) -> dict:
+    """Create a single hook entry that writes status to the given file path."""
+    safe_path = status_file.replace("'", "'\\''")
+    return {
+        "type": "command",
+        "command": f'printf \'{{"status":"{status}","ts":%d}}\' $(date +%s) > \'{safe_path}\'',
+        "async": True,
+    }
+
+
+def _build_hooks_config(status_file: str) -> dict:
+    """Build hooks config with absolute path to status file."""
+    return {
+        "SessionStart": [{"hooks": [_make_hook("running", status_file)]}],
+        "UserPromptSubmit": [{"hooks": [_make_hook("running", status_file)]}],
+        "Stop": [{"hooks": [_make_hook("waiting", status_file)]}],
+        "SessionEnd": [{"hooks": [_make_hook("ended", status_file)]}],
+    }
+
+
+def _load_settings(settings_file: Path) -> dict:
+    """Read existing settings JSON, tolerating a missing or corrupt file."""
+    if settings_file.exists():
+        try:
+            return json.loads(settings_file.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+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)
+
+    settings_file = claude_dir / "settings.local.json"
+    existing = _load_settings(settings_file)
+
+    # Merge hooks into existing settings
+    existing["hooks"] = _build_hooks_config(str(task_path / ".claude_status"))
+
+    if memory_dir:
+        existing["autoMemoryDirectory"] = str(Path(memory_dir).expanduser())
+
+    settings_file.write_text(json.dumps(existing, indent=2) + "\n")
+
+
+def _exclude_settings_from_git(repo_path: Path) -> None:
+    """Hide .claude/settings.local.json from git status in the repo.
+
+    Appends the path to <repo>/.git/info/exclude, which worktrees share
+    with the main checkout, so the generated settings file never shows
+    up as an untracked change in any of them.
+    """
+    git_dir = repo_path / ".git"
+    if not git_dir.is_dir():
+        return
+
+    entry = ".claude/settings.local.json"
+    exclude_file = git_dir / "info" / "exclude"
+    try:
+        existing = exclude_file.read_text().splitlines() if exclude_file.exists() else []
+        if entry in existing:
+            return
+        exclude_file.parent.mkdir(parents=True, exist_ok=True)
+        with exclude_file.open("a") as f:
+            f.write(entry + "\n")
+    except OSError:
+        return
+
+
+def ensure_worktree_claude_settings(
+    worktree_path: Path, repo_path: Path, status_file: Path
+) -> None:
+    """Create .claude/settings.local.json inside a worktree.
+
+    Points autoMemoryDirectory at the main repo's own memory directory, so
+    memory saved while working in any worktree of a repo persists after the
+    worktree is deleted and is shared with future worktrees and with
+    sessions in the main checkout. Also installs the status-reporting hooks
+    (writing to the task's status file) so sessions started manually inside
+    a worktree light up the task indicator.
+    """
+    claude_dir = worktree_path / ".claude"
+    claude_dir.mkdir(exist_ok=True)
+
+    settings_file = claude_dir / "settings.local.json"
+    existing = _load_settings(settings_file)
+
+    existing["hooks"] = _build_hooks_config(str(status_file))
+    existing["autoMemoryDirectory"] = str(repo_memory_dir(repo_path))
+
+    settings_file.write_text(json.dumps(existing, indent=2) + "\n")
+    _exclude_settings_from_git(repo_path)

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/tasktree_manager/services/config.py

@@ -95,6 +95,7 @@ class Config:
     hunk_path: str = "hunk"
     claude_path: str = "claude"
     claude_memory_dir: str = "~/.claude/tasktree-memory"
+    claude_repo_memory: bool = True
     shell: str = ""
 
     # Keybindings (action -> key mapping)
@@ -151,6 +152,7 @@ class Config:
         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")
+        claude_repo_memory = bool(tools_config.get("claude_repo_memory", True))
         shell = tools_config.get("shell", "")
 
         # Keybindings - start with defaults and override with config
@@ -193,6 +195,7 @@ class Config:
             hunk_path=hunk_path,
             claude_path=claude_path,
             claude_memory_dir=claude_memory_dir,
+            claude_repo_memory=claude_repo_memory,
             shell=shell,
             keybindings=keybindings,
             symlink_blocklist=symlink_blocklist,
@@ -328,6 +331,13 @@ claude_path = "{self._toml_escape(self.claude_path)}"
 # memory that is orphaned when the task is deleted. Set to "" to disable.
 claude_memory_dir = "{self._toml_escape(self.claude_memory_dir)}"
 
+# Per-repo Claude Code memory for worktree sessions. Writes
+# .claude/settings.local.json into each worktree pointing its auto-memory
+# at the main repo's memory directory, so memory saved in a worktree
+# survives worktree deletion and is shared with future worktrees of the
+# same repo and with the main checkout. Set to false to disable.
+claude_repo_memory = {str(self.claude_repo_memory).lower()}
+
 # Preferred shell (leave empty to use $SHELL)
 shell = "{self._toml_escape(self.shell)}"
 

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/tasktree_manager/services/task_manager.py

@@ -8,6 +8,7 @@ import subprocess
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
+from .claude_hooks import ensure_worktree_claude_settings
 from .config import Config
 from .models import RepoIssue, Task, TaskSafetyReport, Worktree
 
@@ -182,6 +183,14 @@ class TaskManager:
         # Create symlinks for gitignored files
         self._create_gitignore_symlinks(repo_path, worktree_path)
 
+        # Point Claude auto-memory at the repo's own memory dir so it
+        # survives worktree deletion (sessions may start here manually,
+        # before any launch-time backfill runs)
+        if self.config.claude_repo_memory:
+            ensure_worktree_claude_settings(
+                worktree_path, repo_path, task.path / ".claude_status"
+            )
+
     def _parse_gitignore(self, gitignore_path: Path) -> list[str]:
         """Parse .gitignore and return glob patterns for files (not directories).
 
@@ -456,6 +465,21 @@ class TaskManager:
 
         return success_repos, failed_repos
 
+    def ensure_worktree_settings(self, task: Task) -> None:
+        """Backfill per-worktree Claude settings for existing worktrees.
+
+        Covers worktrees created before repo memory support (or outside
+        tasktree). New worktrees get their settings at creation time.
+        """
+        if not self.config.claude_repo_memory:
+            return
+
+        status_file = task.path / ".claude_status"
+        for worktree in task.worktrees:
+            repo_path = self.config.repos_dir / worktree.name
+            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:
         """Create the task CLAUDE.md and backfill worktree ones from the repo.
 

tasktree_manager-2.8.0/tests/test_claude_hooks.py

@@ -0,0 +1,207 @@
+"""Tests for Claude Code hook and settings configuration."""
+
+import json
+from pathlib import Path
+
+from tasktree_manager.services.claude_hooks import (
+    ensure_claude_hooks,
+    ensure_worktree_claude_settings,
+    has_claude_session,
+    repo_memory_dir,
+)
+
+
+class TestEnsureClaudeHooks:
+    """Tests for ensure_claude_hooks."""
+
+    def test_creates_settings_with_hooks(self, tmp_path):
+        """Test that settings.local.json is created with status hooks."""
+        ensure_claude_hooks(tmp_path)
+
+        settings_file = tmp_path / ".claude" / "settings.local.json"
+        assert settings_file.exists()
+
+        settings = json.loads(settings_file.read_text())
+        for event in ("SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"):
+            assert event in settings["hooks"]
+        assert str(tmp_path / ".claude_status") in json.dumps(settings["hooks"])
+
+    def test_no_memory_dir_by_default(self, tmp_path):
+        """Test that autoMemoryDirectory is not written when memory_dir is empty."""
+        ensure_claude_hooks(tmp_path)
+
+        settings_file = tmp_path / ".claude" / "settings.local.json"
+        settings = json.loads(settings_file.read_text())
+        assert "autoMemoryDirectory" not in settings
+
+    def test_memory_dir_written_expanded(self, tmp_path):
+        """Test that memory_dir is written as an expanded absolute path."""
+        ensure_claude_hooks(tmp_path, "~/.claude/tasktree-memory")
+
+        settings_file = tmp_path / ".claude" / "settings.local.json"
+        settings = json.loads(settings_file.read_text())
+        assert settings["autoMemoryDirectory"] == str(Path.home() / ".claude" / "tasktree-memory")
+
+    def test_preserves_existing_settings(self, tmp_path):
+        """Test that unrelated existing settings keys survive a rewrite."""
+        claude_dir = tmp_path / ".claude"
+        claude_dir.mkdir()
+        settings_file = claude_dir / "settings.local.json"
+        settings_file.write_text(json.dumps({"permissions": {"allow": ["Bash(ls *)"]}}))
+
+        ensure_claude_hooks(tmp_path, "~/.claude/tasktree-memory")
+
+        settings = json.loads(settings_file.read_text())
+        assert settings["permissions"] == {"allow": ["Bash(ls *)"]}
+        assert "hooks" in settings
+        assert "autoMemoryDirectory" in settings
+
+    def test_empty_memory_dir_leaves_existing_value(self, tmp_path):
+        """Test that an existing autoMemoryDirectory is kept when memory_dir is empty."""
+        claude_dir = tmp_path / ".claude"
+        claude_dir.mkdir()
+        settings_file = claude_dir / "settings.local.json"
+        settings_file.write_text(json.dumps({"autoMemoryDirectory": "/custom/memory"}))
+
+        ensure_claude_hooks(tmp_path, "")
+
+        settings = json.loads(settings_file.read_text())
+        assert settings["autoMemoryDirectory"] == "/custom/memory"
+
+    def test_memory_dir_overrides_existing_value(self, tmp_path):
+        """Test that a configured memory_dir replaces a previously written one."""
+        ensure_claude_hooks(tmp_path, "/old/memory")
+        ensure_claude_hooks(tmp_path, "/new/memory")
+
+        settings_file = tmp_path / ".claude" / "settings.local.json"
+        settings = json.loads(settings_file.read_text())
+        assert settings["autoMemoryDirectory"] == "/new/memory"
+
+    def test_recovers_from_corrupt_settings(self, tmp_path):
+        """Test that invalid JSON in existing settings is replaced, not fatal."""
+        claude_dir = tmp_path / ".claude"
+        claude_dir.mkdir()
+        settings_file = claude_dir / "settings.local.json"
+        settings_file.write_text("{not json")
+
+        ensure_claude_hooks(tmp_path, "~/.claude/tasktree-memory")
+
+        settings = json.loads(settings_file.read_text())
+        assert "hooks" in settings
+        assert "autoMemoryDirectory" in settings
+
+
+class TestRepoMemoryDir:
+    """Tests for repo_memory_dir."""
+
+    def test_encodes_repo_path(self, tmp_path, monkeypatch):
+        """Test that the repo path is encoded like Claude project dirs."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        result = repo_memory_dir(Path("/repos/work.3"))
+        assert result == tmp_path / ".claude" / "projects" / "-repos-work-3" / "memory"
+
+
+class TestEnsureWorktreeClaudeSettings:
+    """Tests for ensure_worktree_claude_settings."""
+
+    @staticmethod
+    def _make_repo_and_worktree(tmp_path):
+        repo_path = tmp_path / "repos" / "work3"
+        (repo_path / ".git" / "info").mkdir(parents=True)
+        worktree_path = tmp_path / "tasks" / "TASK-1" / "work3"
+        worktree_path.mkdir(parents=True)
+        status_file = tmp_path / "tasks" / "TASK-1" / ".claude_status"
+        return repo_path, worktree_path, status_file
+
+    def test_points_memory_at_repo(self, tmp_path, monkeypatch):
+        """Test that autoMemoryDirectory targets the main repo's memory dir."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        repo_path, worktree_path, status_file = self._make_repo_and_worktree(tmp_path)
+
+        ensure_worktree_claude_settings(worktree_path, repo_path, status_file)
+
+        settings = json.loads((worktree_path / ".claude" / "settings.local.json").read_text())
+        assert settings["autoMemoryDirectory"] == str(repo_memory_dir(repo_path))
+
+    def test_writes_status_hooks(self, tmp_path, monkeypatch):
+        """Test that status hooks write to the task's status file."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        repo_path, worktree_path, status_file = self._make_repo_and_worktree(tmp_path)
+
+        ensure_worktree_claude_settings(worktree_path, repo_path, status_file)
+
+        settings = json.loads((worktree_path / ".claude" / "settings.local.json").read_text())
+        for event in ("SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"):
+            assert event in settings["hooks"]
+        assert str(status_file) in json.dumps(settings["hooks"])
+
+    def test_preserves_existing_settings(self, tmp_path, monkeypatch):
+        """Test that unrelated existing settings keys survive a rewrite."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        repo_path, worktree_path, status_file = self._make_repo_and_worktree(tmp_path)
+        claude_dir = worktree_path / ".claude"
+        claude_dir.mkdir()
+        settings_file = claude_dir / "settings.local.json"
+        settings_file.write_text(json.dumps({"permissions": {"allow": ["Bash(ls *)"]}}))
+
+        ensure_worktree_claude_settings(worktree_path, repo_path, status_file)
+
+        settings = json.loads(settings_file.read_text())
+        assert settings["permissions"] == {"allow": ["Bash(ls *)"]}
+        assert "autoMemoryDirectory" in settings
+
+    def test_excludes_settings_from_git(self, tmp_path, monkeypatch):
+        """Test that the settings file is added to the repo's git exclude."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        repo_path, worktree_path, status_file = self._make_repo_and_worktree(tmp_path)
+
+        ensure_worktree_claude_settings(worktree_path, repo_path, status_file)
+
+        exclude = (repo_path / ".git" / "info" / "exclude").read_text()
+        assert ".claude/settings.local.json" in exclude
+
+    def test_exclude_entry_is_idempotent(self, tmp_path, monkeypatch):
+        """Test that repeated calls do not duplicate the exclude entry."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        repo_path, worktree_path, status_file = self._make_repo_and_worktree(tmp_path)
+
+        ensure_worktree_claude_settings(worktree_path, repo_path, status_file)
+        ensure_worktree_claude_settings(worktree_path, repo_path, status_file)
+
+        lines = (repo_path / ".git" / "info" / "exclude").read_text().splitlines()
+        assert lines.count(".claude/settings.local.json") == 1
+
+    def test_git_file_instead_of_dir(self, tmp_path, monkeypatch):
+        """Test that a .git file (linked worktree/submodule) is skipped safely."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        repo_path = tmp_path / "repos" / "work3"
+        repo_path.mkdir(parents=True)
+        (repo_path / ".git").write_text("gitdir: /elsewhere\n")
+        worktree_path = tmp_path / "tasks" / "TASK-1" / "work3"
+        worktree_path.mkdir(parents=True)
+
+        ensure_worktree_claude_settings(
+            worktree_path, repo_path, tmp_path / "tasks" / "TASK-1" / ".claude_status"
+        )
+
+        assert (worktree_path / ".claude" / "settings.local.json").exists()
+
+
+class TestHasClaudeSession:
+    """Tests for has_claude_session."""
+
+    def test_no_project_dir(self, tmp_path, monkeypatch):
+        """Test False when no project directory exists."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        assert has_claude_session(Path("/some/task")) is False
+
+    def test_project_dir_with_transcript(self, tmp_path, monkeypatch):
+        """Test True when the encoded project directory holds a transcript."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        task_path = Path("/some/task.dir")
+        encoded = "-some-task-dir"
+        project_dir = tmp_path / ".claude" / "projects" / encoded
+        project_dir.mkdir(parents=True)
+        (project_dir / "abc.jsonl").touch()
+
+        assert has_claude_session(task_path) is True

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/tests/test_config.py

@@ -31,6 +31,16 @@ class TestConfig:
         config = Config(claude_memory_dir="")
         assert config.claude_memory_dir == ""
 
+    def test_claude_repo_memory_default(self):
+        """Test that per-repo worktree memory is enabled by default."""
+        config = Config()
+        assert config.claude_repo_memory is True
+
+    def test_claude_repo_memory_custom(self):
+        """Test disabling per-repo worktree memory."""
+        config = Config(claude_repo_memory=False)
+        assert config.claude_repo_memory is False
+
     def test_load_from_environment(self, temp_dirs, monkeypatch):
         """Test loading config from environment variables."""
         repos_dir, tasks_dir = temp_dirs

{tasktree_manager-2.7.2 → tasktree_manager-2.8.0}/tests/test_task_manager.py

@@ -823,3 +823,52 @@ class TestEnsureClaudeMdFiles:
         task_manager.ensure_claude_md_files(task)
 
         assert worktree_md.read_text() == "# my notes\n"
+
+
+class TestWorktreeClaudeSettings:
+    """Tests for per-repo Claude memory settings in worktrees."""
+
+    def test_create_task_writes_worktree_settings(self, task_manager, sample_repo):
+        """New worktrees get settings pointing memory at the repo's memory dir."""
+        import json
+
+        from tasktree_manager.services.claude_hooks import repo_memory_dir
+
+        repo_path, branch = sample_repo
+        task = task_manager.create_task("MEM-1", ["sample-repo"], branch)
+
+        settings_file = task.path / "sample-repo" / ".claude" / "settings.local.json"
+        assert settings_file.exists()
+        settings = json.loads(settings_file.read_text())
+        assert settings["autoMemoryDirectory"] == str(repo_memory_dir(repo_path))
+        assert str(task.path / ".claude_status") in json.dumps(settings["hooks"])
+
+    def test_worktree_stays_clean(self, task_manager, sample_repo):
+        """The generated settings file must not show up as a dirty worktree."""
+        from tasktree_manager.services.git_ops import GitOps
+
+        _, branch = sample_repo
+        task = task_manager.create_task("MEM-2", ["sample-repo"], branch)
+
+        status = GitOps.get_status(task.worktrees[0])
+        assert status.is_dirty is False
+
+    def test_disabled_by_config(self, task_manager, sample_repo):
+        """No settings file is written when claude_repo_memory is off."""
+        task_manager.config.claude_repo_memory = False
+        _, branch = sample_repo
+        task = task_manager.create_task("MEM-3", ["sample-repo"], branch)
+
+        assert not (task.path / "sample-repo" / ".claude").exists()
+
+    def test_ensure_worktree_settings_backfills(self, task_manager, sample_repo):
+        """Existing worktrees without settings get them backfilled."""
+        task_manager.config.claude_repo_memory = False
+        _, branch = sample_repo
+        task = task_manager.create_task("MEM-4", ["sample-repo"], branch)
+        assert not (task.path / "sample-repo" / ".claude").exists()
+
+        task_manager.config.claude_repo_memory = True
+        task_manager.ensure_worktree_settings(task)
+
+        assert (task.path / "sample-repo" / ".claude" / "settings.local.json").exists()

tasktree_manager-2.7.2/tasktree_manager/services/claude_hooks.py

@@ -1,71 +0,0 @@
-"""Claude Code hook configuration for status monitoring."""
-
-import json
-from pathlib import Path
-
-
-def has_claude_session(folder: Path) -> bool:
-    """Return True if Claude Code has a recorded session for the given folder.
-
-    Claude CLI stores transcripts at ~/.claude/projects/<encoded-path>/*.jsonl
-    where the encoding replaces "/" and "." with "-".
-    """
-    encoded = str(folder).replace("/", "-").replace(".", "-")
-    project_dir = Path.home() / ".claude" / "projects" / encoded
-    if not project_dir.is_dir():
-        return False
-    return any(project_dir.glob("*.jsonl"))
-
-
-def _make_hook(status: str, status_file: str) -> dict:
-    """Create a single hook entry that writes status to the given file path."""
-    safe_path = status_file.replace("'", "'\\''")
-    return {
-        "type": "command",
-        "command": f'printf \'{{"status":"{status}","ts":%d}}\' $(date +%s) > \'{safe_path}\'',
-        "async": True,
-    }
-
-
-def _build_hooks_config(task_path: Path) -> dict:
-    """Build hooks config with absolute path to status file."""
-    status_file = str(task_path / ".claude_status")
-    return {
-        "SessionStart": [{"hooks": [_make_hook("running", status_file)]}],
-        "UserPromptSubmit": [{"hooks": [_make_hook("running", status_file)]}],
-        "Stop": [{"hooks": [_make_hook("waiting", status_file)]}],
-        "SessionEnd": [{"hooks": [_make_hook("ended", status_file)]}],
-    }
-
-
-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)
-
-    settings_file = claude_dir / "settings.local.json"
-
-    if settings_file.exists():
-        try:
-            existing = json.loads(settings_file.read_text())
-        except (json.JSONDecodeError, OSError):
-            existing = {}
-    else:
-        existing = {}
-
-    # 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.7.2/tests/test_claude_hooks.py

@@ -1,106 +0,0 @@
-"""Tests for Claude Code hook and settings configuration."""
-
-import json
-from pathlib import Path
-
-from tasktree_manager.services.claude_hooks import ensure_claude_hooks, has_claude_session
-
-
-class TestEnsureClaudeHooks:
-    """Tests for ensure_claude_hooks."""
-
-    def test_creates_settings_with_hooks(self, tmp_path):
-        """Test that settings.local.json is created with status hooks."""
-        ensure_claude_hooks(tmp_path)
-
-        settings_file = tmp_path / ".claude" / "settings.local.json"
-        assert settings_file.exists()
-
-        settings = json.loads(settings_file.read_text())
-        for event in ("SessionStart", "UserPromptSubmit", "Stop", "SessionEnd"):
-            assert event in settings["hooks"]
-        assert str(tmp_path / ".claude_status") in json.dumps(settings["hooks"])
-
-    def test_no_memory_dir_by_default(self, tmp_path):
-        """Test that autoMemoryDirectory is not written when memory_dir is empty."""
-        ensure_claude_hooks(tmp_path)
-
-        settings_file = tmp_path / ".claude" / "settings.local.json"
-        settings = json.loads(settings_file.read_text())
-        assert "autoMemoryDirectory" not in settings
-
-    def test_memory_dir_written_expanded(self, tmp_path):
-        """Test that memory_dir is written as an expanded absolute path."""
-        ensure_claude_hooks(tmp_path, "~/.claude/tasktree-memory")
-
-        settings_file = tmp_path / ".claude" / "settings.local.json"
-        settings = json.loads(settings_file.read_text())
-        assert settings["autoMemoryDirectory"] == str(Path.home() / ".claude" / "tasktree-memory")
-
-    def test_preserves_existing_settings(self, tmp_path):
-        """Test that unrelated existing settings keys survive a rewrite."""
-        claude_dir = tmp_path / ".claude"
-        claude_dir.mkdir()
-        settings_file = claude_dir / "settings.local.json"
-        settings_file.write_text(json.dumps({"permissions": {"allow": ["Bash(ls *)"]}}))
-
-        ensure_claude_hooks(tmp_path, "~/.claude/tasktree-memory")
-
-        settings = json.loads(settings_file.read_text())
-        assert settings["permissions"] == {"allow": ["Bash(ls *)"]}
-        assert "hooks" in settings
-        assert "autoMemoryDirectory" in settings
-
-    def test_empty_memory_dir_leaves_existing_value(self, tmp_path):
-        """Test that an existing autoMemoryDirectory is kept when memory_dir is empty."""
-        claude_dir = tmp_path / ".claude"
-        claude_dir.mkdir()
-        settings_file = claude_dir / "settings.local.json"
-        settings_file.write_text(json.dumps({"autoMemoryDirectory": "/custom/memory"}))
-
-        ensure_claude_hooks(tmp_path, "")
-
-        settings = json.loads(settings_file.read_text())
-        assert settings["autoMemoryDirectory"] == "/custom/memory"
-
-    def test_memory_dir_overrides_existing_value(self, tmp_path):
-        """Test that a configured memory_dir replaces a previously written one."""
-        ensure_claude_hooks(tmp_path, "/old/memory")
-        ensure_claude_hooks(tmp_path, "/new/memory")
-
-        settings_file = tmp_path / ".claude" / "settings.local.json"
-        settings = json.loads(settings_file.read_text())
-        assert settings["autoMemoryDirectory"] == "/new/memory"
-
-    def test_recovers_from_corrupt_settings(self, tmp_path):
-        """Test that invalid JSON in existing settings is replaced, not fatal."""
-        claude_dir = tmp_path / ".claude"
-        claude_dir.mkdir()
-        settings_file = claude_dir / "settings.local.json"
-        settings_file.write_text("{not json")
-
-        ensure_claude_hooks(tmp_path, "~/.claude/tasktree-memory")
-
-        settings = json.loads(settings_file.read_text())
-        assert "hooks" in settings
-        assert "autoMemoryDirectory" in settings
-
-
-class TestHasClaudeSession:
-    """Tests for has_claude_session."""
-
-    def test_no_project_dir(self, tmp_path, monkeypatch):
-        """Test False when no project directory exists."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        assert has_claude_session(Path("/some/task")) is False
-
-    def test_project_dir_with_transcript(self, tmp_path, monkeypatch):
-        """Test True when the encoded project directory holds a transcript."""
-        monkeypatch.setenv("HOME", str(tmp_path))
-        task_path = Path("/some/task.dir")
-        encoded = "-some-task-dir"
-        project_dir = tmp_path / ".claude" / "projects" / encoded
-        project_dir.mkdir(parents=True)
-        (project_dir / "abc.jsonl").touch()
-
-        assert has_claude_session(task_path) is True