@cestoliv/wt 0.1.0 → 0.2.0

package/README.md

@@ -1,50 +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:
 
-### Pre-release builds
+```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.
+```
 
-Add the `publish-dev` label to a PR to publish that branch under the `dev`
-dist-tag (the label is removed automatically afterwards):
+## Quick start
 
 ```bash
-npm install -g @cestoliv/wt@dev
+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 config           # Edit config in $EDITOR
+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.
+
+**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.
 
-### Browse worktrees — `wt`
+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).
 
-Launches an interactive list of worktrees with fuzzy search.
+> **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)
@@ -52,51 +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.
-
-**Repo mode** (inside a git repo): shows worktrees for that repo.
-**Global mode** (outside a repo): shows worktrees across all registered repos.
+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.
 
-### 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:
+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.
 
-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
+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).
 
-Run outside a repo to pick from registered repos via an interactive picker.
-
-### Edit config — `wt config`
+## Configuration
 
-Opens the config file in `$EDITOR`.
+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"]
     }
@@ -104,14 +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              |
-| `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

@@ -0,0 +1,134 @@
+---
+name: wt-worktree-manager
+description: 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.
+---
+
+# wt — Git Worktree Manager
+
+`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.
+
+## Commands
+
+### `wt` (no subcommand)
+
+Launch the interactive TUI. Shows worktrees for the current repo (repo mode) or all registered repos (global mode, when run outside a repo).
+
+**Keybindings in the TUI:**
+
+- Arrow keys / `j`/`k` — navigate
+- `Enter` — open worktree in IDE
+- `d` — delete worktree
+- `c` — create new worktree (repo mode only)
+- `/` — search
+- `q` / `Esc` — quit
+
+### `wt create [branch]`
+
+Create a new worktree. If `branch` is omitted, prompts interactively.
+
+The worktree is created as a sibling directory to the repo: `<parent>/<repo-name>-<branch-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
+integrated terminal, pre-filled with `<plan_prompt>` and left interactive for
+you to take over.
+
+```bash
+wt agent feature/login 'Read the codebase, then propose a plan for login.'
+```
+
+It writes a temporary `.zed/tasks.json` running
+`<agent_command> '<plan_prompt>'`, ensures a global Zed keymap chord
+(`agent_trigger_chord`) spawns that task, opens Zed, presses the chord via
+`osascript`, then removes the temporary task so the repo is left clean.
+
+**macOS + Zed only.** Requires Accessibility permission for the app that runs
+`wt` (Zed itself, when run from its integrated terminal). If it isn't granted,
+`wt agent` opens the *Privacy & Security → Accessibility* settings pane and waits
+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`).
+
+```bash
+wt config          # open in editor
+wt config --path   # print config file path only
+```
+
+### `wt skill`
+
+Print this skill file to stdout. Useful for piping to agents or copying to a project.
+
+## Configuration
+
+Config is stored as JSON. Get the path with `wt config --path`.
+
+### Schema
+
+| Key              | Type       | Default         | Description                                                               |
+| ---------------- | ---------- | --------------- | ------------------------------------------------------------------------- |
+| `worktree_path`  | `string`   | `"../"`         | Where to place new worktrees, relative to the repo root                   |
+| `base_branch`    | `string`   | `"origin/main"` | Branch to base new worktrees on                                           |
+| `setup_commands` | `string[]` | `[]`            | Commands to run in a new worktree after creation (e.g. `["npm install"]`) |
+| `ide`            | `string`   | `"zed"`         | IDE command to open worktrees with                                        |
+| `ide_open_args`  | `string[]` | `["-n"]`        | Arguments passed to the IDE command                                       |
+| `agent_command`  | `string`   | `"claude --permission-mode plan"` | Command `wt agent` runs in Zed; `<plan_prompt>` is appended single-quoted |
+| `agent_trigger_chord` | `string` | `"ctrl-shift-cmd-c"` | Zed keymap chord `wt agent` installs/presses to spawn the agent task    |
+| `repos`          | `string[]` | `[]`            | Registered repo paths (auto-populated on first use)                       |
+| `repo_overrides` | `object`   | `{}`            | Per-repo config overrides (see below)                                     |
+
+### Per-repo overrides
+
+Override any field (`worktree_path`, `base_branch`, `setup_commands`, `ide`, `ide_open_args`, `agent_command`, `agent_trigger_chord`) for a specific repo:
+
+```json
+{
+  "base_branch": "origin/main",
+  "ide": "zed",
+  "repo_overrides": {
+    "/path/to/my-repo": {
+      "base_branch": "origin/develop",
+      "setup_commands": ["npm install", "npm run build"]
+    }
+  }
+}
+```
+
+## Common workflows
+
+### Create a worktree for a new feature
+
+```bash
+cd /path/to/repo
+wt create feature/my-branch
+```
+
+### Configure setup commands for a repo
+
+```bash
+wt config
+# Then add to the JSON:
+# "repo_overrides": {
+#   "/path/to/repo": {
+#     "setup_commands": ["npm install"]
+#   }
+# }
+```
+
+### Browse all worktrees across repos
+
+Run `wt` from any directory outside a git repo to see worktrees from all registered repos.

package/dist/agent-PKCZHGN7.js

@@ -0,0 +1,428 @@
+#!/usr/bin/env node
+import {
+  openConfiguredIde,
+  prepareWorktree,
+  promptExistingWorktree
+} from "./chunk-BYWCGKUP.js";
+import "./chunk-FSARWOCW.js";
+import "./chunk-IQWENLPW.js";
+
+// src/commands/agent.ts
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/zed.ts
+import { spawn } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+var AGENT_TASK_LABEL = "wt: agent";
+function buildAgentTask(agentCommand, prompt, label) {
+  const escaped = prompt.replace(/'/g, "'\\''");
+  return {
+    label,
+    command: `${agentCommand} '${escaped}'`,
+    cwd: "$ZED_WORKTREE_ROOT",
+    use_new_terminal: true,
+    allow_concurrent_runs: false,
+    reveal: "always",
+    reveal_target: "dock",
+    shell: "system"
+  };
+}
+function removeTask(tasks, label) {
+  return tasks.filter((t) => t.label !== label);
+}
+function buildKeymapBinding(chord, label) {
+  return {
+    context: "Workspace",
+    bindings: { [chord]: ["task::Spawn", { task_name: label }] }
+  };
+}
+function upsertKeymapBinding(keymap, chord, label) {
+  const target = buildKeymapBinding(chord, label);
+  const targetValue = JSON.stringify(target.bindings[chord]);
+  const already = keymap.some(
+    (e) => e.context === "Workspace" && e.bindings != null && JSON.stringify(e.bindings[chord]) === targetValue
+  );
+  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",
+  shift: "shift down",
+  cmd: "command down",
+  command: "command down",
+  super: "command down",
+  alt: "option down",
+  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) {
+    throw new Error(`Invalid chord: "${chord}"`);
+  }
+  const key = parts[parts.length - 1];
+  const modifiers = parts.slice(0, -1).map((m) => {
+    const mapped = MODIFIER_MAP[m];
+    if (!mapped) {
+      throw new Error(`Unknown modifier "${m}" in chord "${chord}"`);
+    }
+    return mapped;
+  });
+  return { key, modifiers };
+}
+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 ${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 {
+    return parseTasks(readFileSync(tasksPath, "utf8")) ?? [];
+  } catch {
+    return [];
+  }
+}
+function writeAgentTask(worktreePath, task) {
+  const zedDir = join(worktreePath, ".zed");
+  const tasksPath = join(zedDir, "tasks.json");
+  const createdDir = !existsSync(zedDir);
+  if (createdDir) mkdirSync(zedDir, { recursive: true });
+  const createdFile = !existsSync(tasksPath);
+  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 };
+}
+function cleanupAgentTask(worktreePath, label, created) {
+  const zedDir = join(worktreePath, ".zed");
+  const tasksPath = join(zedDir, "tasks.json");
+  if (existsSync(tasksPath)) {
+    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)) {
+    try {
+      if (readdirSync(zedDir).length === 0) {
+        rmSync(zedDir, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+}
+function defaultKeymapPath() {
+  return join(homedir(), ".config", "zed", "keymap.json");
+}
+function ensureKeymap(chord, label, keymapPath = defaultKeymapPath()) {
+  const binding = buildKeymapBinding(chord, label);
+  if (!existsSync(keymapPath)) {
+    mkdirSync(dirname(keymapPath), { recursive: true });
+    writeFileSync(keymapPath, `${JSON.stringify([binding], null, 2)}
+`);
+    return true;
+  }
+  const raw = readFileSync(keymapPath, "utf8");
+  const errors = [];
+  const parsed = parse(raw, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0 || !Array.isArray(parsed)) {
+    process.stderr.write(
+      `
+Warning: could not parse ${keymapPath}; not modifying it. Add this binding manually:
+${JSON.stringify(binding, null, 2)}
+`
+    );
+    return false;
+  }
+  const keymap = parsed;
+  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);
+  writeFileSync(keymapPath, updated.endsWith("\n") ? updated : `${updated}
+`);
+  return true;
+}
+var ACCESSIBILITY_SETTINGS_URL = "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility";
+function defaultRunner(script) {
+  return new Promise((resolve) => {
+    const child = spawn("osascript", ["-e", script], {
+      stdio: ["ignore", "ignore", "pipe"]
+    });
+    let stderr = "";
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", (err) => resolve({ code: null, stderr: err.message }));
+    child.on("close", (code) => resolve({ code, stderr }));
+  });
+}
+function isAccessibilityError(stderr) {
+  return /\b1002\b/.test(stderr) || /-1719\b/.test(stderr) || /not allowed to send keystrokes/i.test(stderr) || /not allowed assistive access/i.test(stderr);
+}
+async function triggerChord(chord, opts = {}) {
+  if (process.platform !== "darwin") {
+    return { ok: false, reason: "unsupported" };
+  }
+  const { runner = defaultRunner, loadDelay, activateDelay } = opts;
+  const { code, stderr } = await runner(
+    buildOsascript(chord, { loadDelay, activateDelay })
+  );
+  if (code === 0) return { ok: true };
+  if (isAccessibilityError(stderr)) {
+    return { ok: false, reason: "accessibility", message: stderr.trim() };
+  }
+  return {
+    ok: false,
+    reason: "error",
+    message: stderr.trim() || `osascript exited with code ${code}`
+  };
+}
+function defaultOpen(url) {
+  const child = spawn("open", [url], { detached: true, stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function openAccessibilitySettings(open = defaultOpen) {
+  if (process.platform !== "darwin") return;
+  open(ACCESSIBILITY_SETTINGS_URL);
+}
+
+// src/commands/agent.ts
+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 { 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.`
+      )
+    );
+    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(
+    config.agent_command,
+    planPrompt,
+    AGENT_TASK_LABEL
+  );
+  const created = writeAgentTask(worktreePath, task);
+  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;
+  }
+  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) {
+    console.warn(
+      pc.yellow(
+        "\u26A0 macOS Accessibility permission is required to send the keystroke that starts the agent."
+      )
+    );
+    openAccessibilitySettings();
+    const proceed = await clack.confirm({
+      message: "Grant Accessibility to the app running wt (e.g. Zed) in the panel that opened, then confirm to retry. (If that app was already running, you may need to quit and reopen it for the grant to take effect.)"
+    });
+    if (clack.isCancel(proceed) || !proceed) break;
+    result = await triggerChord(config.agent_trigger_chord, {
+      loadDelay: 0,
+      activateDelay: 0.5
+    });
+  }
+  if (!result.ok) {
+    reportTriggerFailure(result, config.agent_trigger_chord);
+    return;
+  }
+  console.log(pc.green("\u2713 Agent started"));
+  await delay(CLEANUP_DELAY_MS);
+  cleanupAgentTask(worktreePath, AGENT_TASK_LABEL, created);
+}
+function reportTriggerFailure(result, chord) {
+  if (result.reason === "unsupported") {
+    console.warn(
+      pc.yellow(
+        `\u26A0 Agent auto-start is only supported on macOS. The worktree and Zed are open; press ${chord} in Zed to start the agent.`
+      )
+    );
+    return;
+  }
+  if (result.reason === "accessibility") {
+    console.warn(
+      pc.yellow(
+        `\u26A0 Agent not started (Accessibility not granted). In Zed, press ${chord} to start it manually.`
+      )
+    );
+    return;
+  }
+  console.warn(
+    pc.yellow(
+      `\u26A0 Could not auto-start the agent${result.message ? `: ${result.message}` : ""}. In Zed, press ${chord} to start it manually.`
+    )
+  );
+}
+export {
+  createAgentWorktree
+};

package/dist/{create-FV5XL2ON.js → chunk-BYWCGKUP.js}

@@ -2,18 +2,20 @@
 import {
   addWorktree,
   branchExists,
+  fetchRemote,
   getRegisteredRepos,
   getRepoRoot,
+  listWorktrees,
   openIde,
   registerRepo,
   resolveWorktreePath,
   runBranchInput,
   runRepoPicker
-} from "./chunk-25JVZOCI.js";
+} from "./chunk-FSARWOCW.js";
 import {
   createStore,
   getEffectiveConfig
-} from "./chunk-HIGP6FSR.js";
+} from "./chunk-IQWENLPW.js";
 
 // src/commands/create.ts
 import { existsSync } from "fs";
@@ -48,7 +50,7 @@ function runCommand(command, cwd) {
 }
 
 // src/commands/create.ts
-async function createWorktree(branch, options = {}) {
+async function prepareWorktree(branch, options = {}) {
   const {
     cwd = process.cwd(),
     store = createStore(),
@@ -66,7 +68,7 @@ async function createWorktree(branch, options = {}) {
           "No repos registered. cd into a repo and run wt create to get started."
         )
       );
-      return;
+      return null;
     }
     if (!process.stdin.isTTY) {
       console.error(
@@ -77,21 +79,21 @@ async function createWorktree(branch, options = {}) {
       process.exit(1);
     }
     const picked = await repoPicker(repos);
-    if (!picked) return;
+    if (!picked) return null;
     repoRoot = picked;
     if (!branch) {
       const entered = await branchInput(repoRoot);
-      if (!entered) return;
+      if (!entered) return null;
       branch = entered;
     }
   }
-  if (!repoRoot) return;
+  if (!repoRoot) return null;
   if (!branch) {
     const input = await clack.text({
       message: "Branch name:",
-      validate: (v) => v.length === 0 ? "Required" : void 0
+      validate: (v) => !v || v.length === 0 ? "Required" : void 0
     });
-    if (clack.isCancel(input)) return;
+    if (clack.isCancel(input)) return null;
     branch = input;
   }
   registerRepo(repoRoot, store);
@@ -102,7 +104,31 @@ async function createWorktree(branch, options = {}) {
     branch
   );
   if (existsSync(worktreePath)) {
-    throw new Error(`Worktree path already exists: ${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];
+    try {
+      fetchRemote(repoRoot, remote);
+    } catch (err) {
+      console.warn(
+        pc.yellow(
+          `\u26A0 Could not fetch from ${remote} \u2014 using local state${err instanceof Error ? ` (${err.message})` : ""}`
+        )
+      );
+    }
   }
   const exists = branchExists(repoRoot, branch);
   if (exists) {
@@ -124,17 +150,47 @@ async function createWorktree(branch, options = {}) {
       process.exit(1);
     }
   }
-  if (config.ide) {
-    const opened = await openIde(
-      config.ide,
-      config.ide_open_args,
-      worktreePath
-    );
-    if (opened) {
-      console.log(pc.green(`\u2713 Opened ${config.ide}`));
-    }
+  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 { 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/{chunk-25JVZOCI.js → chunk-FSARWOCW.js}

@@ -2,11 +2,11 @@
 import {
   createStore,
   getGlobalConfig
-} from "./chunk-HIGP6FSR.js";
+} from "./chunk-IQWENLPW.js";
 
 // src/lib/git.ts
 import { execFileSync } from "child_process";
-import { realpathSync } from "fs";
+import { existsSync, realpathSync, rmSync } from "fs";
 import path from "path";
 function getRepoRoot(cwd = process.cwd()) {
   try {
@@ -75,11 +75,22 @@ function addWorktree(repoRoot, worktreePath, branch, baseBranch) {
   }
 }
 function removeWorktree(repoRoot, worktreePath, force = false) {
-  execFileSync(
-    "git",
-    ["worktree", "remove", ...force ? ["--force"] : [], worktreePath],
-    { cwd: repoRoot, stdio: "pipe" }
-  );
+  try {
+    execFileSync(
+      "git",
+      ["worktree", "remove", ...force ? ["--force"] : [], worktreePath],
+      { cwd: repoRoot, stdio: "pipe" }
+    );
+  } catch (err) {
+    if (!force) throw err;
+    if (existsSync(worktreePath)) {
+      rmSync(worktreePath, { recursive: true, force: true });
+    }
+    execFileSync("git", ["worktree", "prune"], {
+      cwd: repoRoot,
+      stdio: "pipe"
+    });
+  }
 }
 function listWorktreeDirtyFiles(worktreePath) {
   try {
@@ -113,6 +124,13 @@ function branchExists(repoRoot, branch) {
     return false;
   }
 }
+function fetchRemote(repoRoot, remote = "origin") {
+  execFileSync("git", ["fetch", remote], {
+    cwd: repoRoot,
+    stdio: "pipe",
+    timeout: 3e4
+  });
+}
 function resolveWorktreePath(repoRoot, worktreePath, branch) {
   const repoName = path.basename(repoRoot);
   const safeBranch = branch.replace(/\//g, "-");
@@ -480,6 +498,7 @@ export {
   removeWorktree,
   listWorktreeDirtyFiles,
   branchExists,
+  fetchRemote,
   resolveWorktreePath,
   openIde,
   registerRepo,

package/dist/{chunk-HIGP6FSR.js → chunk-IQWENLPW.js}

@@ -8,6 +8,8 @@ var DEFAULT_CONFIG = {
   setup_commands: [],
   ide: "zed",
   ide_open_args: ["-n"],
+  agent_command: "claude --permission-mode plan",
+  agent_trigger_chord: "ctrl-shift-cmd-c",
   repos: [],
   repo_overrides: {}
 };

package/dist/cli.js

@@ -3,16 +3,29 @@
 // src/cli.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("wt").description("Git worktree manager").version("0.1.0").action(async () => {
-  const { runList } = await import("./list-ZKJZEMCV.js");
+program.name("wt").description("Git worktree manager").version("0.2.0").action(async () => {
+  const { runList } = await import("./list-7UDMSJOS.js");
   await runList();
 });
 program.command("create [branch]").description("Create a new worktree").action(async (branch) => {
-  const { createWorktree } = await import("./create-FV5XL2ON.js");
+  const { createWorktree } = await import("./create-5J5NGGGM.js");
   await createWorktree(branch);
 });
-program.command("config").description("Open the config file in $EDITOR").action(async () => {
-  const { openConfig } = await import("./config-FRLXDMRY.js");
-  openConfig();
+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-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) => {
+  if (options.path) {
+    const { printConfigPath } = await import("./config-OSNYQCZL.js");
+    printConfigPath();
+  } else {
+    const { openConfig } = await import("./config-OSNYQCZL.js");
+    openConfig();
+  }
+});
+program.command("skill").description("Print the wt skill file to stdout").action(async () => {
+  const { printSkill } = await import("./skill-RR6MNLWH.js");
+  printSkill();
 });
 await program.parseAsync(process.argv);

package/dist/{config-FRLXDMRY.js → config-OSNYQCZL.js}

@@ -1,13 +1,16 @@
 #!/usr/bin/env node
 import {
   createStore
-} from "./chunk-HIGP6FSR.js";
+} from "./chunk-IQWENLPW.js";
 
 // src/commands/config.ts
 import { spawn } from "child_process";
 function getConfigPath(store = createStore()) {
   return store.path;
 }
+function printConfigPath(store = createStore()) {
+  console.log(store.path);
+}
 function openConfig(store = createStore()) {
   const configPath = store.path;
   console.log(`Config: ${configPath}`);
@@ -21,5 +24,6 @@ function openConfig(store = createStore()) {
 }
 export {
   getConfigPath,
-  openConfig
+  openConfig,
+  printConfigPath
 };

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-ZKJZEMCV.js → list-7UDMSJOS.js}

@@ -8,11 +8,11 @@ import {
   registerRepo,
   removeWorktree,
   runInteractiveList
-} from "./chunk-25JVZOCI.js";
+} from "./chunk-FSARWOCW.js";
 import {
   createStore,
   getEffectiveConfig
-} from "./chunk-HIGP6FSR.js";
+} from "./chunk-IQWENLPW.js";
 
 // src/commands/list.ts
 import * as clack from "@clack/prompts";
@@ -93,7 +93,7 @@ ${dirty.map((f) => `  ${f}`).join("\n")}`
     },
     onCreate: async () => {
       if (repoRoot) {
-        const { createWorktree } = await import("./create-FV5XL2ON.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,7 +1,7 @@
 {
   "name": "@cestoliv/wt",
-  "version": "0.1.0",
-  "description": "Git worktree manager",
+  "version": "0.2.0",
+  "description": "Fast, interactive TUI to browse, create, open, and delete git worktrees across repos.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cestoliv/worktrees.git"
@@ -14,7 +14,8 @@
     "wt": "./dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "SKILL.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -25,6 +26,7 @@
     "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
     "lint": "biome check .",
     "format": "biome format --write ."
   },
@@ -33,6 +35,7 @@
     "commander": "^14.0.3",
     "conf": "^15.1.0",
     "fuse.js": "^7.1.0",
+    "jsonc-parser": "^3.3.1",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {