@cestoliv/wt 0.1.0-pr5.gd63269d → 0.2.0-pr9.g997ac8d

package/README.md

@@ -1,51 +1,79 @@
 # wt
 
-A fast, interactive TUI for managing git worktrees.
+A fast TUI for git worktrees — browse, create, open, and delete without leaving
+the terminal. Plus **one-command AI agents**:
 
-Browse, create, open, and delete worktrees without leaving the terminal. Fuzzy search across branches, auto-open your IDE, and run setup commands on new worktrees — all from one tool.
+```bash
+wt agent fix-auth "Plan the auth refactor"
+```
+
+→ spins up an isolated worktree and launches Claude in Zed, pre-loaded with your
+prompt.
 
 ## Install
 
 ```bash
-npm install -g @cestoliv/wt
+npm install -g @cestoliv/wt   # also the update command
 ```
 
 Requires Node.js 20+ and Git. The command is `wt`.
 
-### Update
+## Let your AI assistant set it up
 
-```bash
-npm install -g @cestoliv/wt
+Already using an AI coding assistant (Claude Code, Cursor, …)? Paste this prompt
+— it reads `wt skill` to learn the tool, then configures `wt` for you:
+
+```text
+Run `wt skill` to learn how the `wt` CLI works and what its config options are.
+Then configure it for me: choose sensible values for my editor, base branch,
+setup commands, and the `wt agent` settings — ask me about anything you can't
+infer from this project. Write the result to the config file (find its path with
+`wt config --path`), then show me the final config.
 ```
 
-### Pre-release builds
+## Quick start
 
-Add the `publish-dev` label to a PR to publish that branch as a unique,
-pinned prerelease version (e.g. `0.1.0-pr12.gabc1234`). The exact install
-command is posted as a comment on the PR. There is no rolling `dev` channel —
-each build is a distinct version you install explicitly.
+```bash
+wt                                   # Browse worktrees (interactive TUI)
+wt create my-feat                    # New worktree, opens your IDE
+wt agent my-feat "Plan the feature"  # New worktree + AI agent in Zed (macOS)
+wt config                            # Edit config in $EDITOR
+wt skill                             # Print the skill file (for AI agents)
+```
 
-## Quick Start
+## `wt agent <branch> <plan_prompt>` — the standout
 
 ```bash
-# Inside any git repo
-wt                  # Browse worktrees
-wt create my-feat   # Create a new worktree and open it in your IDE
-wt agent my-feat 'Plan the feature'  # Create + auto-start an AI agent in Zed (macOS)
-wt config           # Edit config in $EDITOR
-wt config --path    # Print config file path
-wt skill            # Print skill file (for AI agents)
+wt agent feat/login "Read the codebase, then propose a plan for login."
 ```
 
-## Usage
+Creates a worktree exactly like `wt create`, then auto-starts your agent
+(default `claude --permission-mode plan`) in Zed's integrated terminal —
+pre-filled with your prompt and left interactive for you to take over.
+
+Under the hood it writes a temporary `.zed/tasks.json`, installs a global Zed
+keymap chord, opens Zed and fires the chord via `osascript`, then removes the
+temp task so the repo stays clean.
 
-### Browse worktrees — `wt`
+**Requires** macOS, Zed, and Accessibility permission for the app running `wt`.
+Not granted yet? `wt agent` opens *System Settings → Privacy & Security →
+Accessibility*, waits while you grant it (you may need to quit and reopen the
+app), then retries automatically. On other platforms — or when `ide` isn't
+`zed` — the worktree is still created and opened, just without the agent.
 
-Launches an interactive list of worktrees with fuzzy search.
+If the path already exists, `wt agent` offers to open it — or open it and start
+the agent — instead of erroring (in a non-interactive shell it exits non-zero).
+
+> **Tip:** trust the parent directory of your worktrees in Claude once, and
+> every worktree created beneath it starts hands-free.
+
+## Browse — `wt`
+
+An interactive, fuzzy-searchable list of your worktrees:
 
 ```
 MY-PROJECT
-  ▶ main           ~/dev/my-project
+  ▶ main            ~/dev/my-project
       fix: resolve auth bug (2h ago)
     feat/dashboard  ~/dev/my-project-feat-dashboard
       wip: add chart component (1d ago)
@@ -53,89 +81,46 @@ MY-PROJECT
 ↕ navigate · Enter open · D delete · C create · Q quit
 ```
 
-| Key     | Action                          |
-| ------- | ------------------------------- |
-| `↑` `↓` | Navigate                        |
-| `Enter` | Open worktree in IDE            |
-| `D`     | Delete worktree (with confirm)  |
-| `C`     | Create new worktree (repo mode) |
-| `Q`     | Quit                            |
-
-Type to fuzzy-filter branches instantly.
+Type to fuzzy-filter branches instantly. Inside a repo it shows that repo's
+worktrees (and `C` creates one); run it outside any repo to browse worktrees
+across all registered repos.
 
-**Repo mode** (inside a git repo): shows worktrees for that repo.
-**Global mode** (outside a repo): shows worktrees across all registered repos.
-
-### Create a worktree — `wt create [branch]`
+## Create — `wt create [branch]`
 
 ```bash
-wt create feat/login    # Create from base branch (origin/main by default)
-wt create               # Prompts for branch name
+wt create feat/login   # From base branch (origin/main by default)
+wt create              # Prompts for a branch name
 ```
 
-What happens:
-
-1. Creates a worktree as a sibling directory: `../my-project-feat-login`
-2. Runs configured setup commands (e.g., `npm install`)
-3. Opens the worktree in your IDE
+Creates a worktree as a sibling directory (`../my-project-feat-login`), runs your
+`setup_commands`, and opens it in your IDE. Run it outside a repo to pick from
+registered repos.
 
-Run outside a repo to pick from registered repos via an interactive picker.
+If the path already exists, `wt create` offers to open it in your IDE instead of
+erroring (in a non-interactive shell it exits non-zero).
 
-### Start an AI agent — `wt agent <branch> <plan_prompt>` (macOS + Zed)
-
-```bash
-wt agent feat/login 'Read the codebase, then propose a plan for login.'
-```
-
-Creates the worktree exactly like `wt create`, then auto-starts an AI agent
-(default `claude --permission-mode plan`) in Zed's integrated terminal,
-pre-filled with your prompt and left interactive for you to take over.
-
-How it works:
-
-1. Writes a temporary `.zed/tasks.json` running `<agent_command> '<plan_prompt>'`.
-2. Ensures a global Zed keymap chord (`agent_trigger_chord`) spawns that task.
-3. Opens Zed, then presses the chord via `osascript`.
-4. Removes the temporary task afterwards, leaving the repo clean.
-
-**Requirements:** macOS, Zed, and **Accessibility** permission for the app that
-runs `wt` (Zed itself, when run from its integrated terminal). If it isn't
-granted yet, `wt agent` detects this, opens *System Settings → Privacy &
-Security → Accessibility* for you, and waits — grant it (you may need to quit and
-reopen the app), confirm, and `wt` retries automatically. On other platforms (or
-when `ide` is not `zed`), the worktree is still created and opened, but the agent
-is not auto-started.
-
-> Tip: trust the parent directory of your worktrees in Claude once (open it and
-> accept the trust prompt) so every worktree created beneath it is trusted
-> automatically and the agent starts hands-free.
-
-### Edit config — `wt config`
-
-Opens the config file in `$EDITOR`.
-
-```bash
-wt config           # Open in editor
-wt config --path    # Print the config file path only
-```
-
-### Print skill file — `wt skill`
+## Configuration
 
-Prints the bundled skill documentation to stdout. Useful for piping to AI agents or copying into a project.
+Edit with `wt config` (`wt config --path` prints the file location —
+`~/Library/Preferences/wt-nodejs/config.json` on macOS).
 
-## Configuration
+| Key                   | Default                           | Description                                       |
+| --------------------- | --------------------------------- | ------------------------------------------------- |
+| `ide`                 | `"zed"`                           | Editor to open worktrees with                     |
+| `ide_open_args`       | `["-n"]`                          | Extra args passed to the IDE command              |
+| `base_branch`         | `"origin/main"`                   | Branch new worktrees are created from             |
+| `worktree_path`       | `"../"`                           | Where worktrees are placed (relative to repo)     |
+| `setup_commands`      | `[]`                              | Commands to run in new worktrees                  |
+| `agent_command`       | `"claude --permission-mode plan"` | What `wt agent` runs in Zed (prompt appended)     |
+| `agent_trigger_chord` | `"ctrl-shift-cmd-c"`              | Zed keymap chord `wt agent` installs and presses  |
+| `repo_overrides`      | `{}`                              | Per-repo overrides for any key above              |
 
-Config is stored at `~/Library/Preferences/wt-nodejs/config.json` (macOS).
+Override any key per repo:
 
 ```json
 {
-  "ide": "code",
-  "ide_open_args": ["-n"],
-  "base_branch": "origin/main",
-  "worktree_path": "../",
-  "setup_commands": ["npm install"],
   "repo_overrides": {
-    "/path/to/special-repo": {
+    "/path/to/repo": {
       "base_branch": "origin/develop",
       "setup_commands": ["pnpm install", "pnpm build"]
     }
@@ -143,16 +128,12 @@ Config is stored at `~/Library/Preferences/wt-nodejs/config.json` (macOS).
 }
 ```
 
-| Key              | Default         | Description                                   |
-| ---------------- | --------------- | --------------------------------------------- |
-| `ide`            | `"zed"`         | Editor to open worktrees with                 |
-| `ide_open_args`  | `["-n"]`        | Extra args passed to the IDE command          |
-| `base_branch`    | `"origin/main"` | Branch new worktrees are created from         |
-| `worktree_path`  | `"../"`         | Where worktrees are placed (relative to repo) |
-| `setup_commands` | `[]`            | Commands to run in new worktrees              |
-| `agent_command`  | `"claude --permission-mode plan"` | Command `wt agent` runs in Zed (prompt appended) |
-| `agent_trigger_chord` | `"ctrl-shift-cmd-c"` | Zed keymap chord `wt agent` installs/presses |
-| `repo_overrides` | `{}`            | Per-repo overrides for any of the above       |
+## Pre-release builds
+
+Add the `publish-dev` label to a PR to publish that branch as a unique, pinned
+prerelease (e.g. `0.1.0-pr12.gabc1234`); the exact install command is posted as a
+PR comment. There's no rolling `dev` channel — each build is a distinct version
+you install explicitly.
 
 ## License
 

package/SKILL.md

@@ -30,6 +30,10 @@ The worktree is created as a sibling directory to the repo: `<parent>/<repo-name
 
 After creation, `wt` runs any configured `setup_commands` and opens the worktree in your IDE.
 
+If the worktree path already exists, `wt create` doesn't error — it prompts you
+to **open it in the IDE** or **quit**. (In a non-interactive shell it errors
+with a non-zero exit instead of prompting.)
+
 ### `wt agent <branch> <plan_prompt>`
 
 Create a worktree (same as `wt create`) **and** auto-start an AI agent in Zed's
@@ -52,6 +56,10 @@ for you to grant it and confirm, then retries automatically. On other platforms
 (or when `ide` is not `zed`) the worktree is still created and opened, but the
 agent is not auto-started.
 
+If the worktree path already exists, `wt agent` prompts you to **open it in the
+IDE**, **open it and start the agent**, or **quit** — instead of erroring. (In a
+non-interactive shell it errors with a non-zero exit instead of prompting.)
+
 ### `wt config`
 
 Open the global config file in `$EDITOR` (defaults to `nano`).

package/dist/{agent-PR7PGIE5.js → agent-PKCZHGN7.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
-  prepareWorktree
-} from "./chunk-D4BVSTNE.js";
-import {
-  openIde
-} from "./chunk-FSARWOCW.js";
+  openConfiguredIde,
+  prepareWorktree,
+  promptExistingWorktree
+} from "./chunk-BYWCGKUP.js";
+import "./chunk-FSARWOCW.js";
 import "./chunk-IQWENLPW.js";
 
 // src/commands/agent.ts
@@ -14,7 +14,6 @@ import pc from "picocolors";
 // src/lib/zed.ts
 import { spawn } from "child_process";
 import {
-  copyFileSync,
   existsSync,
   mkdirSync,
   readdirSync,
@@ -39,13 +38,6 @@ function buildAgentTask(agentCommand, prompt, label) {
     shell: "system"
   };
 }
-function upsertTask(tasks, task) {
-  const idx = tasks.findIndex((t) => t.label === task.label);
-  if (idx === -1) return [...tasks, task];
-  const next = [...tasks];
-  next[idx] = task;
-  return next;
-}
 function removeTask(tasks, label) {
   return tasks.filter((t) => t.label !== label);
 }
@@ -64,6 +56,12 @@ function upsertKeymapBinding(keymap, chord, label) {
   if (already) return keymap;
   return [...keymap, target];
 }
+function hasConflictingChord(keymap, chord, label) {
+  const ours = JSON.stringify(buildKeymapBinding(chord, label).bindings[chord]);
+  return keymap.some(
+    (e) => e.bindings != null && e.bindings[chord] !== void 0 && JSON.stringify(e.bindings[chord]) !== ours
+  );
+}
 var MODIFIER_MAP = {
   ctrl: "control down",
   control: "control down",
@@ -75,6 +73,37 @@ var MODIFIER_MAP = {
   opt: "option down",
   option: "option down"
 };
+var KEY_CODE_MAP = {
+  space: 49,
+  tab: 48,
+  return: 36,
+  enter: 36,
+  escape: 53,
+  esc: 53,
+  delete: 51,
+  backspace: 51,
+  forwarddelete: 117,
+  up: 126,
+  down: 125,
+  left: 123,
+  right: 124,
+  home: 115,
+  end: 119,
+  pageup: 116,
+  pagedown: 121,
+  f1: 122,
+  f2: 120,
+  f3: 99,
+  f4: 118,
+  f5: 96,
+  f6: 97,
+  f7: 98,
+  f8: 100,
+  f9: 101,
+  f10: 109,
+  f11: 103,
+  f12: 111
+};
 function parseChord(chord) {
   const parts = chord.split("-").map((p) => p.trim().toLowerCase()).filter(Boolean);
   if (parts.length === 0) {
@@ -94,17 +123,35 @@ function buildOsascript(chord, opts = {}) {
   const { loadDelay = 3, activateDelay = 0.8 } = opts;
   const { key, modifiers } = parseChord(chord);
   const using = modifiers.length > 0 ? ` using {${modifiers.join(", ")}}` : "";
+  let press;
+  if (key.length === 1) {
+    const escaped = key.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    press = `keystroke "${escaped}"`;
+  } else {
+    const code = KEY_CODE_MAP[key];
+    if (code === void 0) {
+      throw new Error(
+        `Unsupported key "${key}" in chord "${chord}". Use a single character or one of: ${Object.keys(KEY_CODE_MAP).join(", ")}.`
+      );
+    }
+    press = `key code ${code}`;
+  }
   return [
     `delay ${loadDelay}`,
     'tell application "Zed" to activate',
     `delay ${activateDelay}`,
-    `tell application "System Events" to keystroke "${key}"${using}`
+    `tell application "System Events" to ${press}${using}`
   ].join("\n");
 }
+function parseTasks(raw) {
+  const errors = [];
+  const parsed = parse(raw, errors, { allowTrailingComma: true });
+  if (errors.length > 0 || !Array.isArray(parsed)) return null;
+  return parsed;
+}
 function readTasks(tasksPath) {
   try {
-    const parsed = JSON.parse(readFileSync(tasksPath, "utf8"));
-    return Array.isArray(parsed) ? parsed : [];
+    return parseTasks(readFileSync(tasksPath, "utf8")) ?? [];
   } catch {
     return [];
   }
@@ -115,9 +162,28 @@ function writeAgentTask(worktreePath, task) {
   const createdDir = !existsSync(zedDir);
   if (createdDir) mkdirSync(zedDir, { recursive: true });
   const createdFile = !existsSync(tasksPath);
-  const existing = createdFile ? [] : readTasks(tasksPath);
-  const next = upsertTask(existing, task);
-  writeFileSync(tasksPath, `${JSON.stringify(next, null, 2)}
+  if (createdFile) {
+    writeFileSync(tasksPath, `${JSON.stringify([task], null, 2)}
+`);
+    return { createdDir, createdFile };
+  }
+  const raw = readFileSync(tasksPath, "utf8");
+  const tasks = parseTasks(raw);
+  if (tasks === null) {
+    process.stderr.write(
+      `
+Warning: could not parse ${tasksPath}; not modifying it. The agent task was not added.
+`
+    );
+    return { createdDir, createdFile };
+  }
+  const idx = tasks.findIndex((t) => t.label === task.label);
+  const edits = modify(raw, idx === -1 ? [tasks.length] : [idx], task, {
+    isArrayInsertion: idx === -1,
+    formattingOptions: { insertSpaces: true, tabSize: 2 }
+  });
+  const updated = applyEdits(raw, edits);
+  writeFileSync(tasksPath, updated.endsWith("\n") ? updated : `${updated}
 `);
   return { createdDir, createdFile };
 }
@@ -125,12 +191,30 @@ function cleanupAgentTask(worktreePath, label, created) {
   const zedDir = join(worktreePath, ".zed");
   const tasksPath = join(zedDir, "tasks.json");
   if (existsSync(tasksPath)) {
-    const next = removeTask(readTasks(tasksPath), label);
-    if (next.length === 0 && created.createdFile) {
-      rmSync(tasksPath, { force: true });
-    } else {
-      writeFileSync(tasksPath, `${JSON.stringify(next, null, 2)}
+    try {
+      if (created.createdFile) {
+        const next = removeTask(readTasks(tasksPath), label);
+        if (next.length === 0) {
+          rmSync(tasksPath, { force: true });
+        } else {
+          writeFileSync(tasksPath, `${JSON.stringify(next, null, 2)}
 `);
+        }
+      } else {
+        const raw = readFileSync(tasksPath, "utf8");
+        const tasks = parseTasks(raw);
+        const idx = tasks?.findIndex((t) => t.label === label) ?? -1;
+        if (idx !== -1) {
+          const edits = modify(raw, [idx], void 0, {});
+          const updated = applyEdits(raw, edits);
+          writeFileSync(
+            tasksPath,
+            updated.endsWith("\n") ? updated : `${updated}
+`
+          );
+        }
+      }
+    } catch {
     }
   }
   if (created.createdDir && existsSync(zedDir)) {
@@ -172,12 +256,18 @@ ${JSON.stringify(binding, null, 2)}
   if (upsertKeymapBinding(keymap, chord, label) === keymap) {
     return true;
   }
+  if (hasConflictingChord(keymap, chord, label)) {
+    process.stderr.write(
+      `
+Note: "${chord}" is already bound in ${keymapPath}; wt's agent binding will take precedence.
+`
+    );
+  }
   const edits = modify(raw, [keymap.length], binding, {
     isArrayInsertion: true,
     formattingOptions: { insertSpaces: true, tabSize: 2 }
   });
   const updated = applyEdits(raw, edits);
-  copyFileSync(keymapPath, `${keymapPath}.bak`);
   writeFileSync(keymapPath, updated.endsWith("\n") ? updated : `${updated}
 `);
   return true;
@@ -229,27 +319,38 @@ function openAccessibilitySettings(open = defaultOpen) {
 }
 
 // src/commands/agent.ts
-var CLEANUP_DELAY_MS = 2e3;
+var CLEANUP_DELAY_MS = 2e4;
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function createAgentWorktree(branch, planPrompt, options = {}) {
   const prepared = await prepareWorktree(branch, options);
   if (!prepared) return;
-  const { config, worktreePath } = prepared;
+  const { status, config, worktreePath } = prepared;
+  if (status === "exists") {
+    const prompt = options.existingWorktreePrompt ?? promptExistingWorktree;
+    const action = await prompt(worktreePath, { allowAgent: true });
+    if (action === "quit") return;
+    if (action === "open") {
+      await openConfiguredIde(config, worktreePath);
+      return;
+    }
+  }
+  await startAgentInWorktree(config, worktreePath, planPrompt);
+}
+async function startAgentInWorktree(config, worktreePath, planPrompt) {
   if (config.ide !== "zed") {
     console.warn(
       pc.yellow(
         `\u26A0 Agent auto-start requires Zed (ide is "${config.ide}"). Opening without starting the agent.`
       )
     );
-    if (config.ide) {
-      await openIde(config.ide, config.ide_open_args, worktreePath);
-    }
+    await openConfiguredIde(config, worktreePath);
     return;
   }
   if (!config.agent_command) {
     console.error(
       pc.red("No agent_command configured. Set it with `wt config`.")
     );
+    await openConfiguredIde(config, worktreePath);
     return;
   }
   const task = buildAgentTask(
@@ -258,14 +359,21 @@ async function createAgentWorktree(branch, planPrompt, options = {}) {
     AGENT_TASK_LABEL
   );
   const created = writeAgentTask(worktreePath, task);
-  ensureKeymap(config.agent_trigger_chord, AGENT_TASK_LABEL);
-  const opened = await openIde("zed", config.ide_open_args, worktreePath);
+  const keymapOk = ensureKeymap(config.agent_trigger_chord, AGENT_TASK_LABEL);
+  const opened = await openConfiguredIde(config, worktreePath);
   if (!opened) {
     console.error(pc.red("\u2717 Could not open Zed."));
     cleanupAgentTask(worktreePath, AGENT_TASK_LABEL, created);
     return;
   }
-  console.log(pc.green("\u2713 Opened Zed"));
+  if (!keymapOk) {
+    console.warn(
+      pc.yellow(
+        `\u26A0 Could not install the Zed keybinding (see above). In Zed, press ${config.agent_trigger_chord} to start the agent manually.`
+      )
+    );
+    return;
+  }
   console.log(pc.dim("Starting agent in Zed\u2026"));
   let result = await triggerChord(config.agent_trigger_chord);
   while (!result.ok && result.reason === "accessibility" && process.stdin.isTTY) {

package/dist/{chunk-D4BVSTNE.js → chunk-BYWCGKUP.js}

@@ -5,6 +5,7 @@ import {
   fetchRemote,
   getRegisteredRepos,
   getRepoRoot,
+  listWorktrees,
   openIde,
   registerRepo,
   resolveWorktreePath,
@@ -97,6 +98,25 @@ async function prepareWorktree(branch, options = {}) {
   }
   registerRepo(repoRoot, store);
   const config = getEffectiveConfig(repoRoot, store);
+  const worktreePath = resolveWorktreePath(
+    repoRoot,
+    config.worktree_path,
+    branch
+  );
+  if (existsSync(worktreePath)) {
+    const isWorktree = listWorktrees(repoRoot).some(
+      (wt) => wt.path === worktreePath
+    );
+    if (!isWorktree) {
+      console.error(
+        pc.red(
+          `Path already exists but is not a git worktree: ${worktreePath}`
+        )
+      );
+      process.exit(1);
+    }
+    return { status: "exists", repoRoot, worktreePath, config };
+  }
   const parts = config.base_branch.split("/", 2);
   if (parts.length === 2) {
     const remote = parts[0];
@@ -110,14 +130,6 @@ async function prepareWorktree(branch, options = {}) {
       );
     }
   }
-  const worktreePath = resolveWorktreePath(
-    repoRoot,
-    config.worktree_path,
-    branch
-  );
-  if (existsSync(worktreePath)) {
-    throw new Error(`Worktree path already exists: ${worktreePath}`);
-  }
   const exists = branchExists(repoRoot, branch);
   if (exists) {
     addWorktree(repoRoot, worktreePath, branch);
@@ -138,25 +150,47 @@ async function prepareWorktree(branch, options = {}) {
       process.exit(1);
     }
   }
-  return { repoRoot, worktreePath, config };
+  return { status: "created", repoRoot, worktreePath, config };
+}
+async function promptExistingWorktree(worktreePath, opts) {
+  if (!process.stdin.isTTY) {
+    console.error(pc.red(`Worktree path already exists: ${worktreePath}`));
+    process.exit(1);
+  }
+  const choice = await clack.select({
+    message: `Worktree already exists at ${worktreePath}.`,
+    options: [
+      { value: "open", label: "Open in IDE" },
+      ...opts.allowAgent ? [{ value: "agent", label: "Open and start agent" }] : [],
+      { value: "quit", label: "Ignore and quit" }
+    ]
+  });
+  if (clack.isCancel(choice)) return "quit";
+  return choice;
+}
+async function openConfiguredIde(config, worktreePath) {
+  if (!config.ide) return false;
+  const opened = await openIde(config.ide, config.ide_open_args, worktreePath);
+  if (opened) {
+    console.log(pc.green(`\u2713 Opened ${config.ide}`));
+  }
+  return opened;
 }
 async function createWorktree(branch, options = {}) {
   const prepared = await prepareWorktree(branch, options);
   if (!prepared) return;
-  const { config, worktreePath } = prepared;
-  if (config.ide) {
-    const opened = await openIde(
-      config.ide,
-      config.ide_open_args,
-      worktreePath
-    );
-    if (opened) {
-      console.log(pc.green(`\u2713 Opened ${config.ide}`));
-    }
+  const { status, config, worktreePath } = prepared;
+  if (status === "exists") {
+    const prompt = options.existingWorktreePrompt ?? promptExistingWorktree;
+    const action = await prompt(worktreePath, { allowAgent: false });
+    if (action !== "open") return;
   }
+  await openConfiguredIde(config, worktreePath);
 }
 
 export {
   prepareWorktree,
+  promptExistingWorktree,
+  openConfiguredIde,
   createWorktree
 };

package/dist/cli.js

@@ -3,16 +3,16 @@
 // src/cli.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("wt").description("Git worktree manager").version("0.1.0-pr5.gd63269d").action(async () => {
-  const { runList } = await import("./list-HO42YAEG.js");
+program.name("wt").description("Git worktree manager").version("0.2.0-pr9.g997ac8d").action(async () => {
+  const { runList } = await import("./list-5TXRTSIW.js");
   await runList();
 });
 program.command("create [branch]").description("Create a new worktree").action(async (branch) => {
-  const { createWorktree } = await import("./create-55SXEUZV.js");
+  const { createWorktree } = await import("./create-5J5NGGGM.js");
   await createWorktree(branch);
 });
 program.command("agent <branch> <plan_prompt>").description("Create a worktree and auto-start an AI agent in Zed (macOS)").action(async (branch, planPrompt) => {
-  const { createAgentWorktree } = await import("./agent-PR7PGIE5.js");
+  const { createAgentWorktree } = await import("./agent-PKCZHGN7.js");
   await createAgentWorktree(branch, planPrompt);
 });
 program.command("config").description("Open the config file in $EDITOR").option("--path", "Print the config file path and exit").action(async (options) => {
@@ -25,7 +25,7 @@ program.command("config").description("Open the config file in $EDITOR").option(
   }
 });
 program.command("skill").description("Print the wt skill file to stdout").action(async () => {
-  const { printSkill } = await import("./skill-CRAP2ALY.js");
+  const { printSkill } = await import("./skill-RR6MNLWH.js");
   printSkill();
 });
 await program.parseAsync(process.argv);

package/dist/create-5J5NGGGM.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  createWorktree,
+  openConfiguredIde,
+  prepareWorktree,
+  promptExistingWorktree
+} from "./chunk-BYWCGKUP.js";
+import "./chunk-FSARWOCW.js";
+import "./chunk-IQWENLPW.js";
+export {
+  createWorktree,
+  openConfiguredIde,
+  prepareWorktree,
+  promptExistingWorktree
+};

package/dist/{list-HO42YAEG.js → list-5TXRTSIW.js}

@@ -66,6 +66,23 @@ async function runList(options = {}) {
         return true;
       } catch (err) {
         const msg = String(err);
+        if (msg.includes("cannot be moved or removed")) {
+          clack.log.warn(
+            "Worktree contains git submodules, which prevent standard removal."
+          );
+          const force = await clack.confirm({
+            message: `Force delete ${pc.bold(item.branch)}? The worktree directory will be removed directly.`
+          });
+          if (clack.isCancel(force) || !force) return false;
+          try {
+            removeWorktree(item.repoRoot, item.path, true);
+            console.log(pc.green(`\u2713 Force-removed ${item.branch}`));
+            return true;
+          } catch (err2) {
+            console.error(pc.red(`\u2717 Failed to force-remove: ${String(err2)}`));
+            return false;
+          }
+        }
         if (msg.includes("modified or untracked files")) {
           const dirty = listWorktreeDirtyFiles(item.path);
           if (dirty.length > 0) {
@@ -93,7 +110,7 @@ ${dirty.map((f) => `  ${f}`).join("\n")}`
     },
     onCreate: async () => {
       if (repoRoot) {
-        const { createWorktree } = await import("./create-55SXEUZV.js");
+        const { createWorktree } = await import("./create-5J5NGGGM.js");
         await createWorktree(void 0, { cwd: repoRoot, store });
       }
     }

package/dist/skill-RR6MNLWH.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+// src/commands/skill.ts
+function printSkill() {
+  console.log('---\nname: wt-worktree-manager\ndescription: Use the wt CLI to create, browse, open, and delete git worktrees across repos. Use when the user asks to manage worktrees, create isolated branches, or configure worktree defaults.\n---\n\n# wt \u2014 Git Worktree Manager\n\n`wt` is a CLI for managing git worktrees. It provides an interactive TUI to browse, create, open in your IDE, and delete worktrees across multiple repos.\n\n## Commands\n\n### `wt` (no subcommand)\n\nLaunch the interactive TUI. Shows worktrees for the current repo (repo mode) or all registered repos (global mode, when run outside a repo).\n\n**Keybindings in the TUI:**\n\n- Arrow keys / `j`/`k` \u2014 navigate\n- `Enter` \u2014 open worktree in IDE\n- `d` \u2014 delete worktree\n- `c` \u2014 create new worktree (repo mode only)\n- `/` \u2014 search\n- `q` / `Esc` \u2014 quit\n\n### `wt create [branch]`\n\nCreate a new worktree. If `branch` is omitted, prompts interactively.\n\nThe worktree is created as a sibling directory to the repo: `<parent>/<repo-name>-<branch-name>`.\n\nAfter creation, `wt` runs any configured `setup_commands` and opens the worktree in your IDE.\n\nIf the worktree path already exists, `wt create` doesn\'t error \u2014 it prompts you\nto **open it in the IDE** or **quit**. (In a non-interactive shell it errors\nwith a non-zero exit instead of prompting.)\n\n### `wt agent <branch> <plan_prompt>`\n\nCreate a worktree (same as `wt create`) **and** auto-start an AI agent in Zed\'s\nintegrated terminal, pre-filled with `<plan_prompt>` and left interactive for\nyou to take over.\n\n```bash\nwt agent feature/login \'Read the codebase, then propose a plan for login.\'\n```\n\nIt writes a temporary `.zed/tasks.json` running\n`<agent_command> \'<plan_prompt>\'`, ensures a global Zed keymap chord\n(`agent_trigger_chord`) spawns that task, opens Zed, presses the chord via\n`osascript`, then removes the temporary task so the repo is left clean.\n\n**macOS + Zed only.** Requires Accessibility permission for the app that runs\n`wt` (Zed itself, when run from its integrated terminal). If it isn\'t granted,\n`wt agent` opens the *Privacy & Security \u2192 Accessibility* settings pane and waits\nfor you to grant it and confirm, then retries automatically. On other platforms\n(or when `ide` is not `zed`) the worktree is still created and opened, but the\nagent is not auto-started.\n\nIf the worktree path already exists, `wt agent` prompts you to **open it in the\nIDE**, **open it and start the agent**, or **quit** \u2014 instead of erroring. (In a\nnon-interactive shell it errors with a non-zero exit instead of prompting.)\n\n### `wt config`\n\nOpen the global config file in `$EDITOR` (defaults to `nano`).\n\n```bash\nwt config          # open in editor\nwt config --path   # print config file path only\n```\n\n### `wt skill`\n\nPrint this skill file to stdout. Useful for piping to agents or copying to a project.\n\n## Configuration\n\nConfig is stored as JSON. Get the path with `wt config --path`.\n\n### Schema\n\n| Key              | Type       | Default         | Description                                                               |\n| ---------------- | ---------- | --------------- | ------------------------------------------------------------------------- |\n| `worktree_path`  | `string`   | `"../"`         | Where to place new worktrees, relative to the repo root                   |\n| `base_branch`    | `string`   | `"origin/main"` | Branch to base new worktrees on                                           |\n| `setup_commands` | `string[]` | `[]`            | Commands to run in a new worktree after creation (e.g. `["npm install"]`) |\n| `ide`            | `string`   | `"zed"`         | IDE command to open worktrees with                                        |\n| `ide_open_args`  | `string[]` | `["-n"]`        | Arguments passed to the IDE command                                       |\n| `agent_command`  | `string`   | `"claude --permission-mode plan"` | Command `wt agent` runs in Zed; `<plan_prompt>` is appended single-quoted |\n| `agent_trigger_chord` | `string` | `"ctrl-shift-cmd-c"` | Zed keymap chord `wt agent` installs/presses to spawn the agent task    |\n| `repos`          | `string[]` | `[]`            | Registered repo paths (auto-populated on first use)                       |\n| `repo_overrides` | `object`   | `{}`            | Per-repo config overrides (see below)                                     |\n\n### Per-repo overrides\n\nOverride any field (`worktree_path`, `base_branch`, `setup_commands`, `ide`, `ide_open_args`, `agent_command`, `agent_trigger_chord`) for a specific repo:\n\n```json\n{\n  "base_branch": "origin/main",\n  "ide": "zed",\n  "repo_overrides": {\n    "/path/to/my-repo": {\n      "base_branch": "origin/develop",\n      "setup_commands": ["npm install", "npm run build"]\n    }\n  }\n}\n```\n\n## Common workflows\n\n### Create a worktree for a new feature\n\n```bash\ncd /path/to/repo\nwt create feature/my-branch\n```\n\n### Configure setup commands for a repo\n\n```bash\nwt config\n# Then add to the JSON:\n# "repo_overrides": {\n#   "/path/to/repo": {\n#     "setup_commands": ["npm install"]\n#   }\n# }\n```\n\n### Browse all worktrees across repos\n\nRun `wt` from any directory outside a git repo to see worktrees from all registered repos.\n');
+}
+export {
+  printSkill
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cestoliv/wt",
-  "version": "0.1.0-pr5.gd63269d",
+  "version": "0.2.0-pr9.g997ac8d",
   "description": "Fast, interactive TUI to browse, create, open, and delete git worktrees across repos.",
   "repository": {
     "type": "git",

package/dist/create-55SXEUZV.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import {
-  createWorktree,
-  prepareWorktree
-} from "./chunk-D4BVSTNE.js";
-import "./chunk-FSARWOCW.js";
-import "./chunk-IQWENLPW.js";
-export {
-  createWorktree,
-  prepareWorktree
-};

package/dist/skill-CRAP2ALY.js

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-// src/commands/skill.ts
-function printSkill() {
-  console.log('---\nname: wt-worktree-manager\ndescription: Use the wt CLI to create, browse, open, and delete git worktrees across repos. Use when the user asks to manage worktrees, create isolated branches, or configure worktree defaults.\n---\n\n# wt \u2014 Git Worktree Manager\n\n`wt` is a CLI for managing git worktrees. It provides an interactive TUI to browse, create, open in your IDE, and delete worktrees across multiple repos.\n\n## Commands\n\n### `wt` (no subcommand)\n\nLaunch the interactive TUI. Shows worktrees for the current repo (repo mode) or all registered repos (global mode, when run outside a repo).\n\n**Keybindings in the TUI:**\n\n- Arrow keys / `j`/`k` \u2014 navigate\n- `Enter` \u2014 open worktree in IDE\n- `d` \u2014 delete worktree\n- `c` \u2014 create new worktree (repo mode only)\n- `/` \u2014 search\n- `q` / `Esc` \u2014 quit\n\n### `wt create [branch]`\n\nCreate a new worktree. If `branch` is omitted, prompts interactively.\n\nThe worktree is created as a sibling directory to the repo: `<parent>/<repo-name>-<branch-name>`.\n\nAfter creation, `wt` runs any configured `setup_commands` and opens the worktree in your IDE.\n\n### `wt agent <branch> <plan_prompt>`\n\nCreate a worktree (same as `wt create`) **and** auto-start an AI agent in Zed\'s\nintegrated terminal, pre-filled with `<plan_prompt>` and left interactive for\nyou to take over.\n\n```bash\nwt agent feature/login \'Read the codebase, then propose a plan for login.\'\n```\n\nIt writes a temporary `.zed/tasks.json` running\n`<agent_command> \'<plan_prompt>\'`, ensures a global Zed keymap chord\n(`agent_trigger_chord`) spawns that task, opens Zed, presses the chord via\n`osascript`, then removes the temporary task so the repo is left clean.\n\n**macOS + Zed only.** Requires Accessibility permission for the app that runs\n`wt` (Zed itself, when run from its integrated terminal). If it isn\'t granted,\n`wt agent` opens the *Privacy & Security \u2192 Accessibility* settings pane and waits\nfor you to grant it and confirm, then retries automatically. On other platforms\n(or when `ide` is not `zed`) the worktree is still created and opened, but the\nagent is not auto-started.\n\n### `wt config`\n\nOpen the global config file in `$EDITOR` (defaults to `nano`).\n\n```bash\nwt config          # open in editor\nwt config --path   # print config file path only\n```\n\n### `wt skill`\n\nPrint this skill file to stdout. Useful for piping to agents or copying to a project.\n\n## Configuration\n\nConfig is stored as JSON. Get the path with `wt config --path`.\n\n### Schema\n\n| Key              | Type       | Default         | Description                                                               |\n| ---------------- | ---------- | --------------- | ------------------------------------------------------------------------- |\n| `worktree_path`  | `string`   | `"../"`         | Where to place new worktrees, relative to the repo root                   |\n| `base_branch`    | `string`   | `"origin/main"` | Branch to base new worktrees on                                           |\n| `setup_commands` | `string[]` | `[]`            | Commands to run in a new worktree after creation (e.g. `["npm install"]`) |\n| `ide`            | `string`   | `"zed"`         | IDE command to open worktrees with                                        |\n| `ide_open_args`  | `string[]` | `["-n"]`        | Arguments passed to the IDE command                                       |\n| `agent_command`  | `string`   | `"claude --permission-mode plan"` | Command `wt agent` runs in Zed; `<plan_prompt>` is appended single-quoted |\n| `agent_trigger_chord` | `string` | `"ctrl-shift-cmd-c"` | Zed keymap chord `wt agent` installs/presses to spawn the agent task    |\n| `repos`          | `string[]` | `[]`            | Registered repo paths (auto-populated on first use)                       |\n| `repo_overrides` | `object`   | `{}`            | Per-repo config overrides (see below)                                     |\n\n### Per-repo overrides\n\nOverride any field (`worktree_path`, `base_branch`, `setup_commands`, `ide`, `ide_open_args`, `agent_command`, `agent_trigger_chord`) for a specific repo:\n\n```json\n{\n  "base_branch": "origin/main",\n  "ide": "zed",\n  "repo_overrides": {\n    "/path/to/my-repo": {\n      "base_branch": "origin/develop",\n      "setup_commands": ["npm install", "npm run build"]\n    }\n  }\n}\n```\n\n## Common workflows\n\n### Create a worktree for a new feature\n\n```bash\ncd /path/to/repo\nwt create feature/my-branch\n```\n\n### Configure setup commands for a repo\n\n```bash\nwt config\n# Then add to the JSON:\n# "repo_overrides": {\n#   "/path/to/repo": {\n#     "setup_commands": ["npm install"]\n#   }\n# }\n```\n\n### Browse all worktrees across repos\n\nRun `wt` from any directory outside a git repo to see worktrees from all registered repos.\n');
-}
-export {
-  printSkill
-};