concurrent-session-checkout-clobbers-shared-worktree

Concurrent session's git checkout clobbers your shared working directory

Problem

Two Claude Code sessions (or any two agents/people) operate in the same working directory on the same clone. git checkout / git switch changes HEAD for the entire working tree — it is not per-session. When session B switches branches, session A's tree changes underneath it:

• Uncommitted edits to tracked files may be carried across, reverted, or left in a confusing half-state.
• Untracked files (new files you created) stay on disk but risk being swept into session B's next git add -A.
• Edits get silently lost — e.g. a config field you added disappears.

It is invisible until something breaks: a function you wrote is "gone", a test errors on a symbol you defined, or a harness emits "file was modified, either by the user or by a linter" for a file you didn't expect to change.

Context / Trigger Conditions

• A file you edited reverted to an older version with no action from you.
• git branch --show-current is not the branch you were working on.
• git status lists changes or untracked files you don't recognize.
• Decisive: git reflog shows checkout: moving from <yours> to <other> that you never performed.

Solution

Do not keep fighting inside the shared directory — you will collide again. Isolate into a git worktree.

1. Confirm the collision — git reflog -5 reveals the foreign checkout. git log <your-branch> --oneline confirms your committed work is still safe on its branch (commits survive a checkout; only uncommitted work is at risk).
2. Create a worktree for your existing branch (not a new branch):

   git worktree add /path/outside/repo/my-worktree <your-branch>
   

   Place it outside the repo (a sibling dir) to avoid .gitignore edits that would themselves collide.
3. Migrate uncommitted work into the worktree:
   • Copy untracked files (cp the new files you created).
   • Re-apply tracked-file edits in the worktree (apply them fresh; the worktree has the clean branch tip).
   • Re-apply any edit that was clobbered — recover it from conversation context.
4. Clean your pollution out of the shared dir so the other session gets it back as expected: git checkout <files-you-modified> and rm your untracked files (you copied them already).
5. Switch your session into the worktree and continue there.
6. Commit early and often to your feature branch — committed work cannot be clobbered by a foreign checkout.