EnterWorktree validates hook-created (non-git) worktrees against the git worktree list, refusing to enter them

Any news on this?

Any news on this?

Still waiting on this.

FWIW I made it work by making the jj workspace also be a git worktree. I think that should work without dangerous interactions, but I guess I'll be finding out. I think it might be possible to break it but should be enough for isolation purposes.

Here is .claude/hooks/jj-worktree-create.sh:

#!/bin/bash
# WorktreeCreate hook: create a jj workspace instead of a git worktree.
#
# Why not let Claude Code make a plain git worktree?
#   - It cuts from origin/<default-branch>, which in a jj repo lags `jj @` badly
#     (it was 11 commits behind when we tested).
#   - It has no .jj, so `jj st` run inside it silently walks UP to the main
#     checkout and reports/edits the main working copy. Verified empirically.
#
# Why not `git worktree add` and then colocate jj inside it? jj refuses:
#   "Cannot create a colocated jj repo inside a Git worktree."
# Git worktrees share one ref store, so two independent jj repos would fight
# over refs/heads/* on every import/export, and each would mint its own change
# ids for the same commits -- precisely what makes merging back painful.
#
# So: create a real jj workspace (shared repo, shared op log, shared change
# ids -- trivial to merge back), then ALSO register it with git by hand so it is
# visible to both VCSes. Without the git side, `git rev-parse --show-toplevel`
# from inside resolves to the main checkout and Claude Code's isolation guard
# rejects the directory outright -- correctly, since git commands there would
# write outside the worktree.
#
# `jj workspace add` has no --colocate (unlike `jj git init`), hence by hand.
#
# stdin:  {"hook_event_name":"WorktreeCreate","name":"<slug>", ...}
# stdout: absolute path of the new workspace (Claude Code reads the last
#         non-empty line; all diagnostics must go to stderr).
set -euo pipefail

name=$(jq -r '.name // empty')
[ -n "$name" ] || { echo "WorktreeCreate: no name in hook input" >&2; exit 1; }

root=$(jj workspace root 2>/dev/null) || {
  echo "WorktreeCreate: not inside a jj repo" >&2; exit 1; }

dest="$root/.claude/worktrees/$name"

# Idempotent: reuse an existing workspace rather than failing.
if [ -e "$dest/.jj" ]; then
  echo "$dest"
  exit 0
fi

jj -R "$root" workspace add --name "$name" "$dest" >&2

# --- make the workspace git-visible -------------------------------------
# jj commit ids ARE git commit ids in a colocated repo, so git can point
# straight at the workspace's parent commit. Detached HEAD at @- is what jj
# itself does when colocating: the jj working copy then shows up to git as
# uncommitted changes, which is the truthful view.
head=$(jj -R "$dest" log -r '@-' --no-graph -T 'commit_id')
admin="$root/.git/worktrees/$name"
mkdir -p "$admin"
echo "../.." > "$admin/commondir"   # shared object/ref store
echo "$dest/.git" > "$admin/gitdir" # back-pointer, used by `git worktree prune`
echo "$head" > "$admin/HEAD"
echo "gitdir: $admin" > "$dest/.git"

# Seed the index from HEAD, or git reports every tracked file as deleted.
# read-tree touches only the index, never the working tree.
git -C "$dest" read-tree HEAD

# `jj workspace add` does not self-ignore the way `jj git init` does (which
# writes .jj/.gitignore containing "/*"), so mimic it -- otherwise git sees an
# untracked .jj/ in every workspace.
echo '/*' > "$dest/.jj/.gitignore"

echo "$dest"

Here is .claude/hooks/jj-worktree-remove.sh

#!/bin/bash
# WorktreeRemove hook: forget the jj workspace, unregister it from git, and
# delete its directory. Counterpart to jj-worktree-create.sh.
#
# Deliberately conservative: refuses any path outside .claude/worktrees/ and
# any directory without its own .jj, so it can never reap the main checkout or
# a pre-existing plain git worktree.
#
# stdin: {"hook_event_name":"WorktreeRemove","worktree_path":"<abs path>", ...}
set -euo pipefail

path=$(jq -r '.worktree_path // empty')
[ -n "$path" ] || { echo "WorktreeRemove: no worktree_path in hook input" >&2; exit 1; }

case "$path" in
  */.claude/worktrees/*) ;;
  *) echo "WorktreeRemove: refusing path outside .claude/worktrees: $path" >&2; exit 1 ;;
esac
[ -e "$path/.jj" ] || { echo "WorktreeRemove: not a jj workspace: $path" >&2; exit 1; }

name=$(basename "$path")

# Run forget from the MAIN repo, not the workspace being removed -- jj warns
# and leaves the working copy behind if you forget the workspace you are in.
# `jj -R "$path" workspace root` is no help: it reports the workspace's own
# path. Instead follow the workspace's .jj/repo pointer, which is relative to
# .jj/ and points at <root>/.jj/repo, so strip those two components back off.
repo_ptr=$(cat "$path/.jj/repo") || {
  echo "WorktreeRemove: no .jj/repo pointer in $path" >&2; exit 1; }
repo_dir=$(realpath "$path/.jj/$repo_ptr") || {
  echo "WorktreeRemove: cannot resolve .jj/repo pointer: $repo_ptr" >&2; exit 1; }
root=$(dirname "$(dirname "$repo_dir")")

jj -R "$root" workspace forget "$name" >&2 || true

# Tear down the git-side registration the create hook built by hand. Removing
# the directories first and pruning after keeps git from complaining about a
# worktree whose path has vanished.
rm -rf "$root/.git/worktrees/$name"
rm -rf "$path"
git -C "$root" worktree prune >&2 || true

and .claude/settings.local.json:

{
  "hooks": {
    "WorktreeCreate": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/jj-worktree-create.sh\"",
            "timeout": 120,
            "statusMessage": "Creating jj workspace..."
          }
        ]
      }
    ],
    "WorktreeRemove": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR/.claude/hooks/jj-worktree-remove.sh\"",
            "timeout": 120,
            "statusMessage": "Removing jj workspace..."
          }
        ]
      }
    ]
  }
}

Ah. The limitation is that Git and Jujutsu disagree _inside the worktree/workspace hybrid_. From Git's point of view, it is a worktree of the root Git repository. From Jujutsu's point of view, it is a workspace from the root jj repo, so Jujutsu's backing Git repository is the root repository, not the worktree Git repository. This means the jj workspace updates are not stored in the Git worktree correctly, notably Git's HEAD will not be updated. So jj new in the jj workspace will not update the Git worktree's HEAD.

Hm, looks like it is easier to just use git-worktree for isolation. The above limitation means git commands in isolation will use the wrong index, so git checkout etc will undo changes in the jj working copy. What you can do is set worktree.baseRef to head in settings.local.json:

{
  "worktree": {
    "baseRef": "head"
  }
}