@cestoliv/wt 0.1.0-pr1.f956696 → 0.1.0-pr5.g3ca944a

package/README.md

@@ -20,12 +20,10 @@ npm install -g @cestoliv/wt
 
 ### Pre-release builds
 
-Add the `publish-dev` label to a PR to publish that branch under the `dev`
-dist-tag (the label is removed automatically afterwards):
-
-```bash
-npm install -g @cestoliv/wt@dev
-```
+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.
 
 ## Quick Start
 
@@ -33,7 +31,10 @@ npm install -g @cestoliv/wt@dev
 # 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)
 ```
 
 ## Usage
@@ -80,10 +81,48 @@ What happens:
 
 Run outside a repo to pick from registered repos via an interactive picker.
 
+### 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`
+
+Prints the bundled skill documentation to stdout. Useful for piping to AI agents or copying into a project.
+
 ## Configuration
 
 Config is stored at `~/Library/Preferences/wt-nodejs/config.json` (macOS).
@@ -111,6 +150,8 @@ Config is stored at `~/Library/Preferences/wt-nodejs/config.json` (macOS).
 | `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       |
 
 ## License

package/SKILL.md

@@ -0,0 +1,126 @@
+---
+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.
+
+### `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.
+
+### `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-SKQRHH3U.js

@@ -0,0 +1,415 @@
+#!/usr/bin/env node
+import {
+  openConfiguredIde,
+  prepareWorktree
+} from "./chunk-YNGWUXCX.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 { config, worktreePath } = prepared;
+  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/{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/{create-42OYRFQF.js → chunk-YNGWUXCX.js}

@@ -2,6 +2,7 @@
 import {
   addWorktree,
   branchExists,
+  fetchRemote,
   getRegisteredRepos,
   getRepoRoot,
   openIde,
@@ -9,11 +10,11 @@ import {
   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 +49,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 +67,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,25 +78,38 @@ 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 || v.length === 0 ? "Required" : void 0
     });
-    if (clack.isCancel(input)) return;
+    if (clack.isCancel(input)) return null;
     branch = input;
   }
   registerRepo(repoRoot, store);
   const config = getEffectiveConfig(repoRoot, store);
+  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 worktreePath = resolveWorktreePath(
     repoRoot,
     config.worktree_path,
@@ -124,17 +138,24 @@ 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 { repoRoot, worktreePath, config };
+}
+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;
+  await openConfiguredIde(prepared.config, prepared.worktreePath);
+}
+
 export {
+  prepareWorktree,
+  openConfiguredIde,
   createWorktree
 };

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-Q7CFJ66L.js");
+program.name("wt").description("Git worktree manager").version("0.1.0-pr5.g3ca944a").action(async () => {
+  const { runList } = await import("./list-KG6HKRMK.js");
   await runList();
 });
 program.command("create [branch]").description("Create a new worktree").action(async (branch) => {
-  const { createWorktree } = await import("./create-42OYRFQF.js");
+  const { createWorktree } = await import("./create-66LRJRWI.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-SKQRHH3U.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-CRAP2ALY.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-66LRJRWI.js

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

package/dist/{list-Q7CFJ66L.js → list-KG6HKRMK.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-42OYRFQF.js");
+        const { createWorktree } = await import("./create-66LRJRWI.js");
         await createWorktree(void 0, { cwd: repoRoot, store });
       }
     }

package/dist/skill-CRAP2ALY.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\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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cestoliv/wt",
-  "version": "0.1.0-pr1.f956696",
+  "version": "0.1.0-pr5.g3ca944a",
   "description": "Fast, interactive TUI to browse, create, open, and delete git worktrees across repos.",
   "repository": {
     "type": "git",
@@ -14,7 +14,8 @@
     "wt": "./dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "SKILL.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -34,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": {