Worktrees should share the same project directory as the main repo

[fbaltor]

Problem

When using git worktrees (either via claude --worktree or manually created), Claude Code creates a separate project directory in ~/.claude/projects/ for each worktree path. This splits conversation history, auto-memory, and project-level settings across multiple isolated directories — even though the worktrees are branches of the same repository.

For example, working in ~/project and then creating a worktree at ~/project-feature-branch produces:

~/.claude/projects/-home-user-project/           # main
~/.claude/projects/-home-user-project-feature-branch/  # worktree — separate conversations, memory, settings

This means:

• Auto-memory is fragmented — memories saved in a worktree session are invisible to main repo sessions and vice versa
• Conversation history is split — the /resume picker may show sessions across worktrees, but project-level context is lost
• Project settings diverge — each worktree gets its own project config

Over time this creates significant knowledge fragmentation, especially for teams using worktrees for parallel development (e.g., running multiple Claude Code sessions in tmux panes on different branches).

Proposed Solution

Detect when a working directory is a git worktree and resolve the project directory to the main worktree's path instead of the current working directory path.

Git already provides this via:

git worktree list --porcelain  # lists all worktrees and identifies the main one
git rev-parse --git-common-dir  # resolves to the shared .git dir

All worktrees of the same repo would then share:

• ~/.claude/projects/<main-repo-path>/memory/
• ~/.claude/projects/<main-repo-path>/*.jsonl (conversations)
• ~/.claude/projects/<main-repo-path>/ (project-level settings)

Alternative: opt-in configuration

If automatic detection is too opinionated, a configuration option would also work:

// ~/.claude/settings.json or project CLAUDE.md
{
  "projectDirectoryStrategy": "git-root"  // vs default "working-directory"
}

Current Workaround

Manually moving .jsonl files, UUID session directories, and memory files from worktree project directories into the main project directory, then deleting the empty source directories. This works but needs to be repeated after every worktree session.

Environment

• Claude Code CLI
• Linux (also applicable to macOS)

[github-actions]

Found 2 possible duplicate issues:

1. Session state should persist across git worktrees #15776
2. [BUG] Auto-memory resolves to main repo path for git worktrees, preventing per-worktree memory #30667

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

[epechuzal]

+1 — heavy worktree user here and this is a real pain point.

My specific case: I use team-provisioned claude.ai MCP servers (Gmail, Google Calendar, Slack, etc.) which also brings along ~10 MCPs I don't use (Figma, Miro, Notion, Pendo, Postman, etc.). I disable them via disabledMcpServers in the project entry, but every new worktree creates a fresh project entry with an empty disable list — so the unwanted MCPs come back every time.

Two compounding issues:

1. Settings don't carry over — disabledMcpServers (and other per-project config) needs to be re-applied in every worktree session via /mcp
2. Dead entries accumulate — nuked worktrees leave orphaned project entries in ~/.claude.json. I just cleaned out 22 dead entries out of 31 total. There's no built-in GC for these.

Resolving the project directory to the main worktree's path (via git rev-parse --git-common-dir) as proposed here would fix both.

[jboulter11]

This, alongside shared permissions, would be great. Just because I make a new worktree, I should not have to also now re-approve all the same stuff and lose my project memories.

[nickrahman]

The docs actually say that it should already work this way, so this seems to be a bug.

https://code.claude.com/docs/en/memory#storage-location

 Each project gets its own memory directory at ~/.claude/projects//memory/. The path is derived from the git repository, so all worktrees and subdirectories within the same repo share one auto memory directory. Outside a git repo, the project root is used instead.

[yurukusa]

/tmp/issue-34437-comment.md

[cderv]

We encountered this while investigating why auto-memory wasn't shared across worktrees on Windows (v2.1.89). The memory docs state:

The <project> path is derived from the git repository, so all worktrees and subdirectories within the same repo share one auto memory directory.

In practice, each worktree gets its own ~/.claude/projects/<key>/ directory — including separate memory, session transcripts, and project settings.

The resulting project keys match what git rev-parse --show-toplevel returns for each worktree, which always gives the worktree's own root rather than the shared repo:

# Main repo
$ git rev-parse --show-toplevel   → /home/user/my-project
$ git rev-parse --git-common-dir  → .git

# Worktree (external sibling dir)
$ git rev-parse --show-toplevel   → /home/user/my-project-feature
$ git rev-parse --git-common-dir  → /home/user/my-project/.git

# Worktree (internal)
$ git rev-parse --show-toplevel   → /home/user/my-project/.worktrees/fix-bug
$ git rev-parse --git-common-dir  → /home/user/my-project/.git

Using --git-common-dir to derive the parent repo path would let all worktrees resolve to the same project key.

Note: on macOS, #39920 reports the opposite for memory — it resolves to the main repo via --git-common-dir, but sessions go to the worktree path. So the behavior appears platform-inconsistent.

Partial workaround for auto-memory only: autoMemoryDirectory in .claude/settings.local.json (per the docs, this setting is not accepted from project-scoped .claude/settings.json):

{
  "autoMemoryDirectory": "~/.claude/projects/<main-project-key>/memory"
}

We automated this with a SessionStart hook that detects worktrees via --git-common-dir and injects the setting if not already present. This only fixes memory sharing — session transcripts and other project data still land in separate directories per worktree.

See also #41283 for a broader discussion of memory identity being tied to filesystem paths.