@maxiaochao/pi-worktree 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 2026-09-30 - v0.1.0
+
+- 将 pi-worktree CLI、bash completion 和 Pi skill 合并为可独立安装的子包。

package/README.md

@@ -0,0 +1,60 @@
+# @maxiaochao/pi-worktree
+
+`pi-worktree` CLI 与配套 Pi skill。CLI 创建、检查和清理 Git worktree，并在隔离目录中启动 Pi。
+
+![Worktree 在真实临时 Git 仓库中的运行截图](docs/screenshot.png)
+
+## 为什么有这个包
+
+这个包把原来分散在主包中的 shell CLI、bash completion、安装逻辑和 agent skill 合成一个发布单元。它让人和 agent 使用同一套隔离流程，避免在主 checkout 中混入并行任务改动。
+
+## 演示
+
+![Worktree 隔离流程演示](docs/demo.gif)
+
+```bash
+pi-worktree start feature -p "implement the feature"
+pi-worktree info feature
+pi-worktree out
+pi-worktree remove feature
+```
+
+`start` 从当前分支创建或复用 `.worktrees/feature`，记录 base，并在该目录启动 Pi。
+
+## 安装
+
+完整工具包已经包含 CLI 和 skill：
+
+```bash
+pi install npm:@maxiaochao/pi-toolkit
+```
+
+只需要 worktree 能力时单独安装：
+
+```bash
+pi install npm:@maxiaochao/pi-worktree
+```
+
+postinstall 会把 CLI 复制到 `~/.local/bin/pi-worktree`，把 bash completion 安装到 `~/.local/share/bash-completion/completions/pi-worktree`。两种安装方式二选一。
+
+## 更新
+
+```bash
+pi update npm:@maxiaochao/pi-toolkit  # 更新主包内置的 CLI 与 skill
+pi update npm:@maxiaochao/pi-worktree # 更新独立子包
+```
+
+更新会重新运行安装逻辑并覆盖 `~/.local/bin/pi-worktree` 和 completion。主包与子包版本独立，不要同时安装。
+
+## 命令
+
+```bash
+pi-worktree start <name> [pi args...]
+pi-worktree list
+pi-worktree info <name>
+pi-worktree out
+pi-worktree remove <name>
+pi-worktree prune
+```
+
+Agent 用法见 `skills/pi-worktree/SKILL.md`。测试流程、夹具和结果见 [TESTING.md](TESTING.md)。

package/TESTING.md

@@ -0,0 +1,21 @@
+# Worktree 测试方案
+
+## 流程
+
+1. `npm --prefix packages/worktree test`：在临时 Git 仓库中使用假的 `pi` 命令运行 CLI。
+2. `npm pack ./packages/worktree --dry-run`：确认 CLI、completion、skill 和安装脚本进入 tarball。
+3. 手工验收发布包的 `pi-worktree start` 交互流程。
+4. 确认 README 示例、真实临时 Git 仓库输出 `docs/screenshot.png` 和 `docs/demo.gif` 进入 tarball。
+
+## 用例数据
+
+- `--help` 输出命令说明。
+- `start` 从当前分支创建 `.worktrees/<name>` 并记录 base。
+- 假 Pi 收到正确工作目录和参数。
+- `list` 标记主 checkout 和子 worktree。
+- `info` 报告 clean、branch、base 和 ahead。
+- postinstall 把可执行 CLI 与 completion 复制到隔离 HOME，并保持执行权限。
+
+## 最近验证结果
+
+迁移基线要求全部 shell 断言通过，且 `npm pack --dry-run` 包含 `bin/`、`skills/` 和 `scripts/install.mjs`。

package/bin/pi-worktree

@@ -0,0 +1,298 @@
+#!/usr/bin/env bash
+# pi-worktree: create/reuse a git worktree, then launch pi inside it.
+#
+# Usage:
+#   pi-worktree start <name> [pi args...]  # enter worktree <name> and start pi
+#   pi-worktree start --base <ref> <name> [pi args...]  # branch from <ref> instead of current branch
+#   pi-worktree -l | --list                # list worktrees (main checkout marked "main checkout")
+#   pi-worktree -i <name>                  # show base commit, ahead/behind, unique commits
+#   pi-worktree -o | --out                 # cd back to the main checkout
+#   pi-worktree -r <name>                  # remove worktree <name> (must be clean & merged)
+#   pi-worktree -p | --prune               # drop stale worktree registrations
+set -euo pipefail
+
+# Colors: only when stdout is a TTY and NO_COLOR is unset (no-color.org)
+if [[ -t 1 && -z "${NO_COLOR:-}" ]]; then
+  C_BOLD=$'\e[1m' C_DIM=$'\e[2m' C_RED=$'\e[31m' C_GREEN=$'\e[32m' C_YELLOW=$'\e[33m' C_CYAN=$'\e[36m' C_RESET=$'\e[0m'
+else
+  C_BOLD='' C_DIM='' C_RED='' C_GREEN='' C_YELLOW='' C_CYAN='' C_RESET=''
+fi
+
+ok()      { printf '%spi-worktree:%s %s\n' "$C_GREEN" "$C_RESET" "$*"; }
+warn()    { printf '%s⚠️  %s%s\n' "$C_YELLOW" "$C_RESET" "$*"; }
+die()     { printf '%spi-worktree: %s%s\n' "$C_RED" "$C_RESET" "$*" >&2; exit 1; }
+
+require_repo() {
+  git rev-parse --is-inside-work-tree >/dev/null 2>&1 || die "not inside a git repository"
+}
+
+main_checkout() {
+  git rev-parse --path-format=absolute --git-common-dir | sed 's|/.git$||'
+}
+
+in_linked_worktree() {
+  local git_dir common_dir
+  git_dir=$(git rev-parse --git-dir 2>/dev/null) || return 1
+  common_dir=$(git rev-parse --git-common-dir 2>/dev/null) || return 1
+  [[ "$(cd "$git_dir" && pwd -P)" != "$(cd "$common_dir" && pwd -P)" ]] \
+    && [[ -z "$(git rev-parse --show-superproject-working-tree 2>/dev/null)" ]]
+}
+
+wt_dir() { echo ".worktrees/$1"; }
+
+# Best available base ref: current branch > HEAD (worktrees should branch
+# from where you actually are; a stale origin/main must not win)
+pick_base() {
+  local cur; cur=$(git branch --show-current 2>/dev/null || true)
+  if [[ -n "$cur" ]]; then
+    echo "$cur"
+  else
+    echo HEAD
+  fi
+}
+
+# Resolve base ref for a new worktree: explicit --base wins, else current branch.
+resolve_base() {
+  if [[ -n "${BASE_OVERRIDE:-}" ]]; then
+    git rev-parse --verify --quiet "${BASE_OVERRIDE}^{commit}" >/dev/null \
+      || die "base ref not found: $BASE_OVERRIDE"
+    echo "$BASE_OVERRIDE"
+  else
+    pick_base
+  fi
+}
+
+ensure_gitignore() {
+  # The trailing slash is load-bearing: `.worktrees/` is a directory-only
+  # pattern, and git check-ignore cannot match it against a path that does not
+  # exist yet — so `.worktrees` would look unignored on every first run and the
+  # rule would be appended again.
+  if ! git check-ignore -q .worktrees/ 2>/dev/null; then
+    printf '.worktrees/\n' >> .gitignore
+    ok "added .worktrees/ to .gitignore"
+  fi
+}
+
+cmd_list() {
+  require_repo
+  local main_dir; main_dir=$(main_checkout)
+  # Annotate the primary checkout and stale (prunable) entries.
+  git worktree list --porcelain | awk -v main="$main_dir" \
+    -v D="${C_DIM}" -v Y="${C_YELLOW}" -v C="${C_CYAN}" -v R="${C_RESET}" '
+    /^worktree / { path=substr($0,10); next }
+    /^HEAD /     { sha=substr($0,6); next }
+    /^branch /   { b=substr($0,8); sub("refs/heads/","",b); next }
+    /^detached/  { b="(detached)"; next }
+    /^bare/      { b="(bare)"; next }
+    /^prunable/  { stale=1; next }
+    /^$/ {
+      if (b=="") b="?"
+      mark=(path==main) ? "  " D "(main checkout)" R : ""
+      branch=(path==main) ? b : C b R
+      hint=(stale) ? "  " Y "← stale: dir gone, run: pi-worktree prune" R : ""
+      printf "%s  %s%s%s  %s%s%s\n", path, D, substr(sha,1,7), R, branch, mark, hint
+      path=""; sha=""; b=""; stale=0
+    }
+  '
+}
+
+subcmd_prune() {
+  require_repo
+  git worktree prune -v
+  ok "pruned stale worktree registrations"
+}
+
+cmd_out() {
+  cd "$(main_checkout)" && exec "${SHELL:-/bin/bash}"
+}
+
+cmd_info() {
+  require_repo
+  [[ $# -eq 1 ]] || die "usage: pi-worktree -i <name>"
+  local dir; dir="$(wt_dir "$1")"
+  [[ -d "$dir" ]] || die "worktree not found: $dir"
+  local branch; branch=$(git -C "$dir" branch --show-current)
+  echo "worktree: $dir"
+  if git -C "$dir" diff --quiet 2>/dev/null && git -C "$dir" diff --cached --quiet 2>/dev/null \
+     && [[ -z "$(git -C "$dir" ls-files --others --exclude-standard)" ]]; then
+    echo "status:   clean"
+  else
+    echo "status:   DIRTY"
+    git -C "$dir" status --short | head -10
+  fi
+  echo "branch:   $branch @ $(git -C "$dir" rev-parse --short HEAD)"
+  local base baseRef ahead behind
+  base=$(git config --get "branch.$branch.base" 2>/dev/null || true)
+  baseRef=$(git config --get "branch.$branch.baseRef" 2>/dev/null || true)
+  if [[ -n "$base" ]]; then
+    echo "based on: $baseRef @ $base"
+    ahead=$(git rev-list --count "$base..$branch" 2>/dev/null || echo "?")
+    echo "ahead:    $ahead commits since base"
+  else
+    echo "based on: (not recorded; run: git merge-base main $branch)"
+  fi
+  if git show-ref --verify --quiet refs/heads/main && [[ "$branch" != main ]]; then
+    behind=$(git rev-list --count "$branch..main" 2>/dev/null || echo "?")
+    echo "behind:   $behind commits vs main"$([[ "${behind:-0}" -gt 0 ]] && echo "  ← consider rebase")
+  fi
+  if [[ -n "$base" ]]; then
+    echo "unique commits:"
+    git log --oneline "$base..$branch" | head -5 || true
+  fi
+}
+
+cmd_remove() {
+  require_repo
+  [[ $# -eq 1 ]] || die "usage: pi-worktree -r <name>"
+  local dir; dir="$(wt_dir "$1")"
+  local branch registered rm_anyway=0 force=0
+  if [[ ! -d "$dir" ]]; then
+    # Directory already gone but possibly still registered (prunable), or a
+    # stale branch left behind by an earlier prune: clean the registration,
+    # then fall through to the branch cleanup.
+    local registered
+    registered=$(git worktree list --porcelain | awk -v p="$(pwd -P)/$dir" '
+      $0=="worktree "p {f=1; next}
+      f && /^branch /  {print substr($0,8); exit}
+      f && /^detached/ {print "-"; exit}
+      f && /^$/        {exit}')
+    if [[ "$registered" == "-" ]]; then
+      git worktree prune
+      ok "pruned stale registration: $dir (directory already gone)"
+      return 0  # detached HEAD, nothing else to clean up
+    fi
+    if [[ -n "$registered" ]]; then
+      branch=${registered#refs/heads/}
+    elif git show-ref --verify --quiet "refs/heads/$1"; then
+      branch=$1  # registration already pruned; only the stale branch remains
+    else
+      die "worktree not found: $dir"
+    fi
+    if [[ -n "$registered" ]]; then
+      git worktree prune
+      ok "pruned stale registration: $dir (directory already gone)"
+    fi
+  else
+    # dirty worktree: removing discards modified/untracked files, which git
+    # refuses to do without --force — so confirm the loss explicitly
+    if ! git -C "$dir" diff --quiet 2>/dev/null \
+       || ! git -C "$dir" diff --cached --quiet 2>/dev/null \
+       || [[ -n "$(git -C "$dir" ls-files --others --exclude-standard)" ]]; then
+      warn "worktree contains modified/untracked files that will be discarded:"
+      git -C "$dir" status --short | head -10
+      read -rp "Discard and remove anyway? [y/N] " ans
+      [[ "$ans" =~ ^[Yy]$ ]] || die "aborted"
+      force=1
+    fi
+    branch=$(git -C "$dir" branch --show-current)
+    # refuse to remove if the branch is not merged into main
+    if [[ -n "$branch" ]] && ! git merge-base --is-ancestor "$branch" main 2>/dev/null; then
+      warn "branch '$branch' does not appear merged into 'main' (or no main branch exists)."
+      read -rp "Remove anyway? [y/N] " ans
+      [[ "$ans" =~ ^[Yy]$ ]] || die "aborted"
+      rm_anyway=1
+    fi
+    local out
+    if [[ "$force" == 1 ]]; then
+      git worktree remove --force "$dir" && ok "removed: $dir (discarded changes as confirmed)"
+    elif out=$(git worktree remove "$dir" 2>&1); then
+      ok "removed: $dir"
+    elif [[ "$out" == *"submodules cannot be moved or removed"* ]]; then
+      # git refuses to remove worktrees with initialized submodules unless
+      # --force is used (--force only overrides the submodule check here; the
+      # branch deletion below still asks before dropping unmerged commits)
+      git worktree remove --force "$dir" && ok "removed: $dir (contained submodules)"
+    else
+      printf '%s\n' "$out" >&2
+      die "failed to remove worktree: $dir"
+    fi
+  fi
+  # The branch survives `git worktree remove`; recreating the same name would
+  # silently reuse this stale branch. Delete merged branches automatically.
+  if [[ -n "$branch" ]] && git show-ref --verify --quiet "refs/heads/$branch"; then
+    if git branch -d "$branch" 2>/dev/null; then
+      ok "deleted merged branch: $branch"
+    elif [[ "$rm_anyway" == 1 ]]; then
+      git branch -D "$branch" && ok "deleted unmerged branch: $branch (confirmed above)"
+    else
+      warn "branch '$branch' has unmerged commits."
+      read -rp "Delete anyway? [y/N] " ans
+      if [[ "$ans" =~ ^[Yy]$ ]]; then
+        git branch -D "$branch" && ok "deleted branch: $branch"
+      else
+        warn "branch '$branch' kept; 'pi-worktree start $branch' will reuse it as-is"
+      fi
+    fi
+  fi
+}
+
+cd_wt() {
+  local name="$1"; shift
+  require_repo
+
+  # Already isolated? Just launch pi here (superpowers Step 0).
+  if in_linked_worktree; then
+    ok "already in an isolated worktree ($(pwd)), launching pi here"
+    exec pi "$@"
+  fi
+
+  local dir; dir="$(wt_dir "$name")"
+
+  if [[ -d "$dir" ]]; then
+    # Reuse: must be a registered worktree for this repo.
+    # Skip the dirty-workspace prompt — the worktree already exists, nothing new to create.
+    git -C "$dir" rev-parse --git-dir >/dev/null 2>&1 || die "$dir exists but is not a git worktree"
+    ensure_gitignore
+    ok "reusing existing worktree $dir"
+  else
+    # Dirty workspace: uncommitted changes do NOT follow into the new worktree.
+    if ! git diff --quiet || ! git diff --cached --quiet || [[ -n "$(git ls-files --others --exclude-standard)" ]]; then
+      warn "Uncommitted changes stay in THIS directory; they will NOT appear in the worktree:"
+      git status --short | head -20
+      read -rp "Continue? [y/N] " ans
+      [[ "$ans" =~ ^[Yy]$ ]] || die "aborted"
+    fi
+
+    # After the check above, so the tool's own .gitignore edit is not reported
+    # as (and does not prompt about) the user's uncommitted work.
+    ensure_gitignore
+    mkdir -p .worktrees
+    # Reuse branch if it exists, else create it
+    if git show-ref --verify --quiet "refs/heads/$name"; then
+      git worktree add "$dir" "$name"
+      ok "checked out existing branch '$name'"
+      # record a best-effort base for -i display
+      local mb; mb=$(git merge-base main "$name" 2>/dev/null || true)
+      [[ -n "$mb" ]] && git config "branch.$name.base" "$(git rev-parse --short "$mb")" \
+        && git config "branch.$name.baseRef" main
+    else
+      local base; base=$(resolve_base)
+      git worktree add "$dir" -b "$name" "$base"
+      git config "branch.$name.base" "$(git rev-parse --short "$base")"
+      git config "branch.$name.baseRef" "$base"
+      ok "created branch '$name' from $base @ $(git rev-parse --short "$base")"
+    fi
+  fi
+
+  cd "$dir"
+  exec pi "$@"
+}
+
+case "${1:-}" in
+  -l|--list|list|ls) shift; cmd_list "$@" ;;
+  -i|--info|info) shift; cmd_info "$@" ;;
+  -o|--out|out) shift; cmd_out "$@" ;;
+  -r|--remove|rm|remove) shift; cmd_remove "$@" ;;
+  -p|--prune|prune) shift; subcmd_prune ;;
+  -h|--help|help) sed -n '2,10p' "$0" | sed 's/^# \{0,1\}//' ;;
+  start) shift
+    BASE_OVERRIDE=""
+    if [[ "${1:-}" == "--base" ]]; then
+      shift; [[ $# -ge 2 ]] || die "usage: pi-worktree start --base <ref> <name> [pi args...]"
+      BASE_OVERRIDE="$1"; shift
+    fi
+    [[ $# -ge 1 ]] || die "usage: pi-worktree start <name> [pi args...]"
+    name="$1"; shift; cd_wt "$name" "$@" ;;
+  "")  die "usage: pi-worktree start <name> [pi args...]  (or list / info / out / remove / prune)" ;;
+  *)   die "unknown command: $1  (usage: pi-worktree start <name> [pi args...])" ;;
+esac

package/bin/pi-worktree-completion.bash

@@ -0,0 +1,41 @@
+# bash completion for pi-worktree
+_pi_worktree() {
+  local cur first
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  first="${COMP_WORDS[1]}"
+
+  local SUBS="start list ls info out remove rm prune -l --list -i --info -o --out -r --remove -p --prune -h --help"
+
+  # existing worktree names (only linked worktrees, i.e. under .worktrees/)
+  local wts=""
+  if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    local main_dir
+    main_dir=$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null | sed 's|/.git$||')
+    wts=$(git worktree list --porcelain 2>/dev/null \
+      | sed -n 's|^worktree ||p' \
+      | while read -r p; do [[ "$p" != "$main_dir" ]] && basename "$p"; done || true)
+  fi
+
+  if (( COMP_CWORD == 1 )); then
+    # first word: subcommands, flags, and existing worktree names (to enter)
+    COMPREPLY=($(compgen -W "$SUBS $wts" -- "$cur"))
+    return
+  fi
+
+  case "$first" in
+    -i|--info|info|-r|--remove|remove|rm|start)
+      # only the second word of info/remove completes worktree names;
+      # later words offer nothing (info/remove take no further args)
+      if (( COMP_CWORD == 2 )); then
+        COMPREPLY=($(compgen -W "$wts" -- "$cur"))
+      else
+        COMPREPLY=()
+      fi
+      ;;
+    *)
+      # after a name: default (file) completion for pi args
+      COMPREPLY=()
+      ;;
+  esac
+}
+complete -F _pi_worktree pi-worktree

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@maxiaochao/pi-worktree",
+  "version": "0.1.0",
+  "description": "Git worktree CLI and Pi skill for isolated coding tasks.",
+  "type": "module",
+  "keywords": ["pi-package", "pi-skill", "git", "worktree"],
+  "files": ["bin", "skills", "scripts", "docs", "README.md", "TESTING.md", "CHANGELOG.md"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chaochaoxiaochao/pi-toolkit.git",
+    "directory": "packages/worktree"
+  },
+  "bin": { "pi-worktree": "bin/pi-worktree" },
+  "pi": { "skills": ["./skills"] },
+  "scripts": {
+    "test": "node --test tests/install.test.mjs && bash tests/run-tests.sh",
+    "postinstall": "node scripts/install.mjs"
+  },
+  "publishConfig": { "access": "public" }
+}

package/scripts/install.mjs

@@ -0,0 +1,26 @@
+import { chmodSync, copyFileSync, mkdirSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+export function installWorktree({ root = packageRoot, home = homedir() } = {}) {
+  if (platform() === "win32") return [];
+  const installed = [];
+  const binTarget = join(home, ".local", "bin", "pi-worktree");
+  mkdirSync(dirname(binTarget), { recursive: true });
+  copyFileSync(join(root, "bin", "pi-worktree"), binTarget);
+  chmodSync(binTarget, 0o755);
+  installed.push(binTarget);
+
+  const completionTarget = join(home, ".local", "share", "bash-completion", "completions", "pi-worktree");
+  mkdirSync(dirname(completionTarget), { recursive: true });
+  copyFileSync(join(root, "bin", "pi-worktree-completion.bash"), completionTarget);
+  installed.push(completionTarget);
+  return installed;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  for (const path of installWorktree()) console.log(`[pi-worktree] installed -> ${path}`);
+}

package/skills/pi-worktree/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: pi-worktree
+description: Create, inspect, and clean up git worktrees with the pi-worktree CLI (start/list/info/remove/prune), which also launches Pi inside the worktree. Use when a task warrants isolation in its own worktree, or when the user asks to handle something the worktree way.
+---
+
+# pi-worktree
+
+`pi-worktree` wraps git worktree creation and Pi launch into one command. Worktrees live in `.worktrees/<name>` (added to `.gitignore`), each with a branch of the same name, branched from the branch you are on now (or `HEAD` when detached). The base commit is recorded in `branch.<name>.base` / `branch.<name>.baseRef` so `info` can always report where the branch came from.
+
+Installed by the package postinstall hook to `~/.local/bin/pi-worktree`, with bash completion for subcommands and existing worktree names.
+
+## Commands
+
+| Command | Effect |
+|---|---|
+| `pi-worktree start <name> [pi args...]` | Create or reuse `.worktrees/<name>`, then launch Pi inside it. Already inside a linked worktree, it just launches Pi there. |
+| `pi-worktree start --base <ref> <name> [pi args...]` | Same, but branch from `<ref>` instead of the current branch. |
+| `pi-worktree list` | All worktrees; the main checkout is marked `(main checkout)`, stale registrations are flagged. |
+| `pi-worktree info <name>` | Clean/dirty status, branch and HEAD, base commit, ahead/behind `main`, unique commits. |
+| `pi-worktree out` | Open a shell in the main checkout (for merging). |
+| `pi-worktree remove <name>` | Remove the worktree and its branch; asks before discarding dirty files or unmerged commits. |
+| `pi-worktree prune` | Drop registrations whose directory was deleted by hand. |
+
+## Isolating a task
+
+1. **Survey** — `pi-worktree list`, plus `pi-worktree info <name>` when the name you want is already taken. Reuse is free; a removed worktree is gone for good, because `remove` deletes its branch.
+2. **Start** — `pi-worktree start <name>` (with `--base <ref>` when the work must not start from the current branch). Done when `list` shows the new worktree on its own branch.
+3. **Work** — inside the worktree: commit there, and check `pi-worktree info <name>` before claiming progress. `ahead: N commits since base` is the evidence.
+4. **Land** — `pi-worktree out`, then `git merge <name>` in the main checkout. Done when the worktree's unique commits are in the target branch.
+5. **Clean up** — `pi-worktree remove <name>`. A merged branch goes without prompting; anything unmerged asks once.
+
+## Driving it from an agent
+
+- `start` **execs `pi`** in the worktree, and `out` execs a shell. With no trailing Pi args both want an interactive terminal, so either run `start <name> -p "<task>"` for a headless nested run, or hand the bare `start <name>` to the user to run themselves.
+- `remove` asks before discarding dirty files or unmerged commits, and a non-interactive stdin (EOF) aborts safely. Answer explicitly when the removal is intended: `printf 'y\ny\n' | pi-worktree remove <name>`.
+- Your own working directory cannot change. "Isolate this in a worktree" therefore means launching a nested headless Pi in the worktree, or telling the user to run `pi-worktree start <name>`.