@cestoliv/wt 0.3.0 → 0.4.0-pr17.g3b7d0a6

package/README.md

@@ -34,30 +34,42 @@ infer from this project. Write the result to the config file (find its path with
 ## Quick start
 
 ```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)
+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 agent fix-bug "Fix bug" --mode auto    # Use auto mode instead of plan
+wt config                                 # Edit config in $EDITOR
+wt skill                                  # Print the skill file (for AI agents)
 ```
 
-## `wt agent <branch> <plan_prompt>` — the standout
+## `wt agent <branch> <plan_prompt> [--mode <mode>]` — the standout
 
 ```bash
 wt agent feat/login "Read the codebase, then propose a plan for login."
+wt agent fix-bug "Fix the auth bug" --mode auto
+wt agent refactor "Refactor API layer" --mode default
 ```
 
 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.
 
+**Available modes** (`--mode`, defaults to `plan`):
+
+- `default` — Standard interactive mode with approval for each action
+- `acceptEdits` — Allow file changes but keep command execution controlled
+- `plan` — Architecture-first mode with no surprise mutations (default)
+- `auto` — Claude's safety model makes decisions instead of prompting
+- `dontAsk` — Minimal interruptions in trusted environments
+- `bypassPermissions` — Skip all permission checks (dangerous, CI/sandbox only)
+
 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
+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.
 
@@ -104,16 +116,17 @@ erroring (in a non-interactive shell it exits non-zero).
 Edit with `wt config` (`wt config --path` prints the file location —
 `~/Library/Preferences/wt-nodejs/config.json` on 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"` | 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              |
+| 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                                                    |
+| `teardown_commands`   | `[]`                              | Commands to run in a worktree just before it is deleted (e.g. `["docker compose down -v"]`) |
+| `agent_command`       | `"claude --permission-mode plan"` | Base command; `--permission-mode` replaced by `--mode` option, then 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                                                |
 
 Override any key per repo:
 

package/SKILL.md

@@ -34,7 +34,7 @@ If the worktree path already exists, `wt create` doesn't error — it prompts yo
 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>`
+### `wt agent <branch> <plan_prompt> [--mode <mode>]`
 
 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
@@ -42,20 +42,38 @@ you to take over.
 
 ```bash
 wt agent feature/login 'Read the codebase, then propose a plan for login.'
+wt agent feature/fix 'Fix the bug in payment processing' --mode auto
+wt agent refactor/api 'Refactor the API layer' --mode default
 ```
 
+The `--mode` flag sets Claude Code's permission mode (defaults to `plan`):
+
+- `default` — Standard interactive mode with approval for each action
+- `acceptEdits` — Allow file changes but keep command execution controlled
+- `plan` — Architecture-first mode with no surprise mutations (default)
+- `auto` — Claude's safety model makes decisions instead of prompting
+- `dontAsk` — Minimal interruptions in trusted environments
+- `bypassPermissions` — Skip all permission checks (dangerous, CI/sandbox only)
+
 It writes a temporary `.zed/tasks.json` running
-`<agent_command> '<plan_prompt>'`, ensures a global Zed keymap chord
+`<agent_command> --permission-mode <mode> '<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
+`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.
 
+Over SSH it still works, provided the same user has an active graphical login on
+the Mac: the keystroke is run inside the GUI session via Launch Services
+(`open -a Terminal` briefly flashes a Terminal window). Grant Accessibility to
+Terminal (not Zed) the first time. With no one logged in graphically there is
+nothing to drive, so it falls back to the manual "press the chord in Zed"
+message.
+
 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.)
@@ -79,21 +97,22 @@ 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)                                     |
+| 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"]`)                                                                                                 |
+| `teardown_commands`   | `string[]` | `[]`                              | Commands to run in a worktree just before it is deleted (e.g. `["docker compose down -v"]`); on failure you are prompted whether to delete anyway                         |
+| `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"` | Base command `wt agent` runs in Zed; any `--permission-mode` flag is replaced by the `--mode` option (defaults to `plan`), then `<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:
+Override any field (`worktree_path`, `base_branch`, `setup_commands`, `teardown_commands`, `ide`, `ide_open_args`, `agent_command`, `agent_trigger_chord`) for a specific repo:
 
 ```json
 {

package/dist/{agent-3N6CSK7A.js → agent-CIGIZGIS.js}

@@ -3,9 +3,9 @@ import {
   openConfiguredIde,
   prepareWorktree,
   promptExistingWorktree
-} from "./chunk-B6EPGPXW.js";
-import "./chunk-DKFHAASV.js";
-import "./chunk-IQWENLPW.js";
+} from "./chunk-BSMGKL27.js";
+import "./chunk-XM4EABZV.js";
+import "./chunk-FNAMNRUH.js";
 
 // src/commands/agent.ts
 import * as clack from "@clack/prompts";
@@ -14,22 +14,29 @@ import pc from "picocolors";
 // src/lib/zed.ts
 import { spawn } from "child_process";
 import {
+  chmodSync,
   existsSync,
   mkdirSync,
+  mkdtempSync,
   readdirSync,
   readFileSync,
   rmSync,
   writeFileSync
 } from "fs";
-import { homedir } from "os";
+import { homedir, tmpdir } 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) {
+function buildAgentTask(agentCommand, prompt, label, mode) {
+  let finalCommand = agentCommand;
+  if (mode) {
+    const baseCommand = agentCommand.replace(/--permission-mode\s+\S+/g, "").replace(/\s+/g, " ").trim();
+    finalCommand = `${baseCommand} --permission-mode ${mode}`.trim();
+  }
   const escaped = prompt.replace(/'/g, "'\\''");
   return {
     label,
-    command: `${agentCommand} '${escaped}'`,
+    command: `${finalCommand} '${escaped}'`,
     cwd: "$ZED_WORKTREE_ROOT",
     use_new_terminal: true,
     allow_concurrent_runs: false,
@@ -273,19 +280,109 @@ Note: "${chord}" is already bound in ${keymapPath}; wt's agent binding will take
   return true;
 }
 var ACCESSIBILITY_SETTINGS_URL = "x-apple.systempreferences:com.apple.preference.security?Privacy_Accessibility";
-function defaultRunner(script) {
+function isHeadlessSession(env = process.env) {
+  return Boolean(env.SSH_CONNECTION || env.SSH_TTY || env.SSH_CLIENT);
+}
+function buildGuiHelperScript(scriptPath, resultPath) {
+  const q = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+  return [
+    "#!/bin/sh",
+    `out=$(osascript ${q(scriptPath)} 2>&1)`,
+    "code=$?",
+    `printf '%s\\n%s' "$code" "$out" > ${q(`${resultPath}.tmp`)} && mv ${q(`${resultPath}.tmp`)} ${q(resultPath)}`,
+    `osascript -e 'tell application "Terminal" to close front window' >/dev/null 2>&1 &`,
+    ""
+  ].join("\n");
+}
+function parseGuiResult(content) {
+  const newline = content.indexOf("\n");
+  const codeStr = (newline === -1 ? content : content.slice(0, newline)).trim();
+  const stderr = newline === -1 ? "" : content.slice(newline + 1);
+  const code = Number.parseInt(codeStr, 10);
+  if (Number.isNaN(code)) {
+    return {
+      code: null,
+      stderr: stderr || `unexpected result format (first line: ${JSON.stringify(codeStr)})`
+    };
+  }
+  return { code, stderr };
+}
+var OSASCRIPT_TIMEOUT_MS = 3e4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function spawnOpen(helperPath) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("open", ["-a", "Terminal", helperPath], {
+      stdio: "ignore"
+    });
+    child.on("error", reject);
+    child.on("close", () => resolve());
+  });
+}
+async function pollFile(path, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (existsSync(path)) return readFileSync(path, "utf8");
+    await sleep(200);
+  }
+  return null;
+}
+async function runViaGuiHelper(script) {
+  const dir = mkdtempSync(join(tmpdir(), "wt-agent-"));
+  const scriptPath = join(dir, "chord.applescript");
+  const helperPath = join(dir, "run.command");
+  const resultPath = join(dir, "result");
+  try {
+    writeFileSync(scriptPath, script);
+    writeFileSync(helperPath, buildGuiHelperScript(scriptPath, resultPath));
+    chmodSync(helperPath, 493);
+    await spawnOpen(helperPath);
+    const content = await pollFile(resultPath, OSASCRIPT_TIMEOUT_MS);
+    if (content === null) {
+      return {
+        code: null,
+        stderr: "Timed out waiting for the keystroke \u2014 is a user logged into the Mac's graphical session?"
+      };
+    }
+    return parseGuiResult(content);
+  } catch (err) {
+    return {
+      code: null,
+      stderr: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+function runOsascriptDirect(script) {
   return new Promise((resolve) => {
     const child = spawn("osascript", ["-e", script], {
       stdio: ["ignore", "ignore", "pipe"]
     });
     let stderr = "";
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      child.kill();
+      finish({
+        code: null,
+        stderr: "osascript timed out \u2014 is a user logged into the Mac's graphical session?"
+      });
+    }, OSASCRIPT_TIMEOUT_MS);
     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 }));
+    child.on("error", (err) => finish({ code: null, stderr: err.message }));
+    child.on("close", (code) => finish({ code, stderr }));
   });
 }
+function defaultRunner(script) {
+  return isHeadlessSession() ? runViaGuiHelper(script) : runOsascriptDirect(script);
+}
 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);
 }
@@ -319,9 +416,24 @@ function openAccessibilitySettings(open = defaultOpen) {
 }
 
 // src/commands/agent.ts
+var VALID_MODES = [
+  "default",
+  "acceptEdits",
+  "plan",
+  "auto",
+  "dontAsk",
+  "bypassPermissions"
+];
 var CLEANUP_DELAY_MS = 2e4;
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function createAgentWorktree(branch, planPrompt, options = {}) {
+  const mode = options.mode ?? "plan";
+  if (!VALID_MODES.includes(mode)) {
+    console.error(
+      pc.red(`Invalid mode "${mode}". Valid modes: ${VALID_MODES.join(", ")}`)
+    );
+    process.exit(1);
+  }
   const prepared = await prepareWorktree(branch, options);
   if (!prepared) return;
   const { status, config, worktreePath } = prepared;
@@ -334,9 +446,9 @@ async function createAgentWorktree(branch, planPrompt, options = {}) {
       return;
     }
   }
-  await startAgentInWorktree(config, worktreePath, planPrompt);
+  await startAgentInWorktree(config, worktreePath, planPrompt, mode);
 }
-async function startAgentInWorktree(config, worktreePath, planPrompt) {
+async function startAgentInWorktree(config, worktreePath, planPrompt, mode) {
   if (config.ide !== "zed") {
     console.warn(
       pc.yellow(
@@ -356,7 +468,8 @@ async function startAgentInWorktree(config, worktreePath, planPrompt) {
   const task = buildAgentTask(
     config.agent_command,
     planPrompt,
-    AGENT_TASK_LABEL
+    AGENT_TASK_LABEL,
+    mode
   );
   const created = writeAgentTask(worktreePath, task);
   const keymapOk = ensureKeymap(config.agent_trigger_chord, AGENT_TASK_LABEL);
@@ -383,8 +496,9 @@ async function startAgentInWorktree(config, worktreePath, planPrompt) {
       )
     );
     openAccessibilitySettings();
+    const grantee = isHeadlessSession() ? "Terminal" : "the app running wt (e.g. Zed)";
     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.)"
+      message: `Grant Accessibility to ${grantee} 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, {
@@ -419,7 +533,7 @@ function reportTriggerFailure(result, chord) {
   }
   console.warn(
     pc.yellow(
-      `\u26A0 Could not auto-start the agent${result.message ? `: ${result.message}` : ""}. In Zed, press ${chord} to start it manually.`
+      `\u26A0 Could not auto-start the agent${result.message ? `: ${result.message}` : ""}. In Zed, press ${chord} to start it manually. (Over SSH, this needs the same user logged into the Mac's graphical session.)`
     )
   );
 }

package/dist/{chunk-B6EPGPXW.js → chunk-BSMGKL27.js}

@@ -10,47 +10,19 @@ import {
   registerRepo,
   resolveWorktreePath,
   runBranchInput,
+  runCommands,
   runRepoPicker,
   setUpstreamTracking
-} from "./chunk-DKFHAASV.js";
+} from "./chunk-XM4EABZV.js";
 import {
   createStore,
   getEffectiveConfig
-} from "./chunk-IQWENLPW.js";
+} from "./chunk-FNAMNRUH.js";
 
 // src/commands/create.ts
 import { existsSync } from "fs";
 import * as clack from "@clack/prompts";
 import pc from "picocolors";
-
-// src/lib/setup.ts
-import { spawn } from "child_process";
-async function runSetupCommands(commands, cwd) {
-  for (const command of commands) {
-    const result = await runCommand(command, cwd);
-    if (!result.success) {
-      return {
-        success: false,
-        failedCommand: command,
-        exitCode: result.exitCode
-      };
-    }
-  }
-  return { success: true };
-}
-function runCommand(command, cwd) {
-  return new Promise((resolve) => {
-    const child = spawn(command, { cwd, stdio: "inherit", shell: true });
-    child.on("error", () => {
-      resolve({ success: false, exitCode: void 0 });
-    });
-    child.on("close", (code) => {
-      resolve({ success: code === 0, exitCode: code ?? void 0 });
-    });
-  });
-}
-
-// src/commands/create.ts
 async function prepareWorktree(branch, options = {}) {
   const {
     cwd = process.cwd(),
@@ -141,7 +113,7 @@ async function prepareWorktree(branch, options = {}) {
   console.log(pc.green(`\u2713 Created worktree at ${worktreePath}`));
   if (config.setup_commands.length > 0) {
     console.log(pc.dim("Running setup commands..."));
-    const result = await runSetupCommands(config.setup_commands, worktreePath);
+    const result = await runCommands(config.setup_commands, worktreePath);
     if (!result.success) {
       console.error(
         pc.red(

package/dist/chunk-FNAMNRUH.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+// src/lib/config.ts
+import path2 from "path";
+import Conf from "conf";
+
+// node_modules/env-paths/index.js
+import path from "path";
+import os from "os";
+import process2 from "process";
+var homedir = os.homedir();
+var tmpdir = os.tmpdir();
+var { env } = process2;
+var macos = (name) => {
+  const library = path.join(homedir, "Library");
+  return {
+    data: path.join(library, "Application Support", name),
+    config: path.join(library, "Preferences", name),
+    cache: path.join(library, "Caches", name),
+    log: path.join(library, "Logs", name),
+    temp: path.join(tmpdir, name)
+  };
+};
+var windows = (name) => {
+  const appData = env.APPDATA || path.join(homedir, "AppData", "Roaming");
+  const localAppData = env.LOCALAPPDATA || path.join(homedir, "AppData", "Local");
+  return {
+    // Data/config/cache/log are invented by me as Windows isn't opinionated about this
+    data: path.join(localAppData, name, "Data"),
+    config: path.join(appData, name, "Config"),
+    cache: path.join(localAppData, name, "Cache"),
+    log: path.join(localAppData, name, "Log"),
+    temp: path.join(tmpdir, name)
+  };
+};
+var linux = (name) => {
+  const username = path.basename(homedir);
+  return {
+    data: path.join(env.XDG_DATA_HOME || path.join(homedir, ".local", "share"), name),
+    config: path.join(env.XDG_CONFIG_HOME || path.join(homedir, ".config"), name),
+    cache: path.join(env.XDG_CACHE_HOME || path.join(homedir, ".cache"), name),
+    // https://wiki.debian.org/XDGBaseDirectorySpecification#state
+    log: path.join(env.XDG_STATE_HOME || path.join(homedir, ".local", "state"), name),
+    temp: path.join(tmpdir, username, name)
+  };
+};
+function envPaths(name, { suffix = "nodejs" } = {}) {
+  if (typeof name !== "string") {
+    throw new TypeError(`Expected a string, got ${typeof name}`);
+  }
+  if (suffix) {
+    name += `-${suffix}`;
+  }
+  if (process2.platform === "darwin") {
+    return macos(name);
+  }
+  if (process2.platform === "win32") {
+    return windows(name);
+  }
+  return linux(name);
+}
+
+// src/lib/config.ts
+var DEFAULT_CONFIG = {
+  worktree_path: "../",
+  base_branch: "origin/main",
+  setup_commands: [],
+  teardown_commands: [],
+  ide: "zed",
+  ide_open_args: ["-n"],
+  agent_command: "claude --permission-mode plan",
+  agent_trigger_chord: "ctrl-shift-cmd-c",
+  repos: [],
+  repo_overrides: {}
+};
+var DEFAULT_CONFIG_DIR = envPaths("wt").config;
+function getConfigFilePath(cwd) {
+  const dir = cwd ?? DEFAULT_CONFIG_DIR;
+  return path2.join(dir, "config.json");
+}
+function createStore(cwd) {
+  try {
+    return new Conf({
+      projectName: "wt",
+      defaults: DEFAULT_CONFIG,
+      ...cwd ? { cwd } : {}
+    });
+  } catch (error) {
+    const configPath = getConfigFilePath(cwd);
+    console.error(
+      `Error reading config file: ${configPath}
+${error instanceof Error ? error.message : error}`
+    );
+    process.exit(1);
+  }
+}
+function getGlobalConfig(store = createStore()) {
+  return store.store;
+}
+function getEffectiveConfig(repoPath, store = createStore()) {
+  const {
+    repos: _repos,
+    repo_overrides,
+    ...repoFields
+  } = getGlobalConfig(store);
+  const override = repo_overrides[repoPath] ?? {};
+  return { ...repoFields, ...override };
+}
+
+export {
+  getConfigFilePath,
+  createStore,
+  getGlobalConfig,
+  getEffectiveConfig
+};

package/dist/{chunk-DKFHAASV.js → chunk-XM4EABZV.js}

@@ -2,7 +2,7 @@
 import {
   createStore,
   getGlobalConfig
-} from "./chunk-IQWENLPW.js";
+} from "./chunk-FNAMNRUH.js";
 
 // src/lib/git.ts
 import { execFileSync } from "child_process";
@@ -11,11 +11,13 @@ import path from "path";
 function getRepoRoot(cwd = process.cwd()) {
   try {
     const realCwd = realpathSync(cwd);
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    const output = execFileSync("git", ["worktree", "list", "--porcelain"], {
       cwd: realCwd,
       encoding: "utf8",
       stdio: "pipe"
-    }).trim();
+    });
+    const firstLine = output.trim().split("\n")[0];
+    return realpathSync(firstLine.slice("worktree ".length));
   } catch {
     throw new Error("Not in a git repository");
   }
@@ -197,6 +199,33 @@ function getRegisteredRepos(store = createStore()) {
   return getGlobalConfig(store).repos;
 }
 
+// src/lib/setup.ts
+import { spawn as spawn2 } from "child_process";
+async function runCommands(commands, cwd) {
+  for (const command of commands) {
+    const result = await runCommand(command, cwd);
+    if (!result.success) {
+      return {
+        success: false,
+        failedCommand: command,
+        exitCode: result.exitCode
+      };
+    }
+  }
+  return { success: true };
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve) => {
+    const child = spawn2(command, { cwd, stdio: "inherit", shell: true });
+    child.on("error", () => {
+      resolve({ success: false, exitCode: void 0 });
+    });
+    child.on("close", (code) => {
+      resolve({ success: code === 0, exitCode: code ?? void 0 });
+    });
+  });
+}
+
 // src/lib/tui.ts
 import path2 from "path";
 import Fuse from "fuse.js";
@@ -224,37 +253,57 @@ function shortenPath(p) {
   const home = process.env.HOME ?? "";
   return home && p.startsWith(home) ? `~${p.slice(home.length)}` : p;
 }
-function renderList(items, selectedIndex, query, mode) {
-  const lines = [];
+function buildListLayout(items, selectedIndex, query, mode) {
+  const header = [];
   if (mode === "global") {
-    lines.push(
+    header.push(
       pc.dim("\u2139 Not in a git repository \u2014 showing all registered worktrees")
     );
-    lines.push("");
+    header.push("");
   }
-  lines.push(pc.cyan(`> ${query}_`));
-  lines.push("");
+  header.push(pc.cyan(`> ${query}_`));
+  const body = [];
+  const itemSpans = [];
   const groups = groupByRepo(items);
   let i = 0;
   for (const [repoPath, groupItems] of groups) {
-    lines.push(pc.bold(path2.basename(repoPath).toUpperCase()));
+    body.push(pc.bold(path2.basename(repoPath).toUpperCase()));
     for (const item of groupItems) {
+      const start = body.length;
       const cursor = i === selectedIndex ? pc.cyan("\u25B6") : " ";
       const branchLabel = item.isCurrent ? pc.dim(`${item.branch} (current)`) : pc.white(item.branch);
       const pathLabel = pc.dim(shortenPath(item.path));
-      lines.push(`  ${cursor} ${branchLabel}  ${pathLabel}`);
+      body.push(`  ${cursor} ${branchLabel}  ${pathLabel}`);
       if (item.lastCommit) {
-        lines.push(`      ${pc.dim(item.lastCommit)}`);
+        body.push(`      ${pc.dim(item.lastCommit)}`);
       }
+      itemSpans[i] = { start, end: body.length - 1 };
       i++;
     }
   }
-  lines.push("");
   const createHint = mode === "repo" ? " \xB7 C create" : "";
-  lines.push(
+  const footer = [
     pc.dim(`\u2195 navigate \xB7 Enter open \xB7 D delete${createHint} \xB7 Q quit`)
-  );
-  return lines.join("\n");
+  ];
+  return { header, body, footer, itemSpans };
+}
+function clampScroll(offset, span, viewportHeight, bodyLength) {
+  const maxOffset = Math.max(0, bodyLength - viewportHeight);
+  let next = offset;
+  if (span.start < next) next = span.start;
+  if (span.end >= next + viewportHeight) next = span.end - viewportHeight + 1;
+  return Math.max(0, Math.min(next, maxOffset));
+}
+function composeView(layout, offset, viewportHeight) {
+  const { header, body, footer } = layout;
+  const visible = body.slice(offset, offset + viewportHeight);
+  while (visible.length < viewportHeight) visible.push("");
+  const topSlot = offset > 0 ? pc.dim("  \u2191 more") : "";
+  const bottomSlot = offset + viewportHeight < body.length ? pc.dim("  \u2193 more") : "";
+  return [...header, topSlot, ...visible, bottomSlot, ...footer].join("\n");
+}
+function fixedHeight(layout) {
+  return layout.header.length + layout.footer.length + 2;
 }
 function setupRawMode() {
   process.stdin.setRawMode(true);
@@ -406,10 +455,21 @@ async function runBranchInput(repoRoot) {
 async function runInteractiveList(allItems, mode, handlers) {
   let query = "";
   let selectedIndex = 0;
+  let scrollOffset = 0;
   let filtered = allItems;
   const render = () => {
+    const rows = process.stdout.rows ?? 24;
+    const layout = buildListLayout(filtered, selectedIndex, query, mode);
+    const viewport = Math.max(1, rows - fixedHeight(layout));
+    const span = layout.itemSpans[selectedIndex] ?? { start: 0, end: 0 };
+    scrollOffset = clampScroll(
+      scrollOffset,
+      span,
+      viewport,
+      layout.body.length
+    );
     process.stdout.write("\x1B[2J\x1B[H");
-    process.stdout.write(renderList(filtered, selectedIndex, query, mode));
+    process.stdout.write(composeView(layout, scrollOffset, viewport));
   };
   setupRawMode();
   render();
@@ -418,11 +478,13 @@ async function runInteractiveList(allItems, mode, handlers) {
     const attachListener = () => {
       if (!listenerActive) {
         process.stdin.on("data", onData);
+        process.stdout.on("resize", render);
         listenerActive = true;
       }
     };
     const detachListener = () => {
       process.stdin.removeListener("data", onData);
+      process.stdout.removeListener("resize", render);
       listenerActive = false;
     };
     const onData = async (key) => {
@@ -484,11 +546,13 @@ async function runInteractiveList(allItems, mode, handlers) {
           query = query.slice(0, -1);
           filtered = filterItems(allItems, query);
           selectedIndex = 0;
+          scrollOffset = 0;
           render();
         } else if (key.length === 1 && key >= " ") {
           query += key;
           filtered = filterItems(allItems, query);
           selectedIndex = 0;
+          scrollOffset = 0;
           render();
         }
       } catch (err) {
@@ -514,6 +578,7 @@ export {
   openIde,
   registerRepo,
   getRegisteredRepos,
+  runCommands,
   runRepoPicker,
   runBranchInput,
   runInteractiveList

package/dist/cli.js

@@ -3,29 +3,35 @@
 // src/cli.ts
 import { Command } from "commander";
 var program = new Command();
-program.name("wt").description("Git worktree manager").version("0.3.0").action(async () => {
-  const { runList } = await import("./list-FOLV77ET.js");
+program.name("wt").description("Git worktree manager").version("0.4.0-pr17.g3b7d0a6").action(async () => {
+  const { runList } = await import("./list-WC5GM3PI.js");
   await runList();
 });
 program.command("create [branch]").description("Create a new worktree").action(async (branch) => {
-  const { createWorktree } = await import("./create-5BZUA7QH.js");
+  const { createWorktree } = await import("./create-WRMXQIGN.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-3N6CSK7A.js");
-  await createAgentWorktree(branch, planPrompt);
-});
+program.command("agent <branch> <plan_prompt>").description("Create a worktree and auto-start an AI agent in Zed (macOS)").option(
+  "--mode <mode>",
+  "Claude Code permission mode (default, plan, auto, etc.)",
+  "plan"
+).action(
+  async (branch, planPrompt, options) => {
+    const { createAgentWorktree } = await import("./agent-CIGIZGIS.js");
+    await createAgentWorktree(branch, planPrompt, { mode: options.mode });
+  }
+);
 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");
+    const { printConfigPath } = await import("./config-DBM7HJE4.js");
     printConfigPath();
   } else {
-    const { openConfig } = await import("./config-OSNYQCZL.js");
+    const { openConfig } = await import("./config-DBM7HJE4.js");
     openConfig();
   }
 });
 program.command("skill").description("Print the wt skill file to stdout").action(async () => {
-  const { printSkill } = await import("./skill-RR6MNLWH.js");
+  const { printSkill } = await import("./skill-FEUVQMK6.js");
   printSkill();
 });
 await program.parseAsync(process.argv);

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

@@ -1,18 +1,16 @@
 #!/usr/bin/env node
 import {
-  createStore
-} from "./chunk-IQWENLPW.js";
+  getConfigFilePath
+} from "./chunk-FNAMNRUH.js";
 
 // src/commands/config.ts
 import { spawn } from "child_process";
-function getConfigPath(store = createStore()) {
-  return store.path;
+function printConfigPath(cwd) {
+  const configPath = getConfigFilePath(cwd);
+  console.log(configPath);
 }
-function printConfigPath(store = createStore()) {
-  console.log(store.path);
-}
-function openConfig(store = createStore()) {
-  const configPath = store.path;
+function openConfig(cwd) {
+  const configPath = getConfigFilePath(cwd);
   console.log(`Config: ${configPath}`);
   const editor = process.env.EDITOR ?? "nano";
   const child = spawn(editor, [configPath], { stdio: "inherit" });
@@ -23,7 +21,6 @@ function openConfig(store = createStore()) {
   child.on("close", (code) => process.exit(code ?? 0));
 }
 export {
-  getConfigPath,
   openConfig,
   printConfigPath
 };

package/dist/{create-5BZUA7QH.js → create-WRMXQIGN.js}

@@ -4,9 +4,9 @@ import {
   openConfiguredIde,
   prepareWorktree,
   promptExistingWorktree
-} from "./chunk-B6EPGPXW.js";
-import "./chunk-DKFHAASV.js";
-import "./chunk-IQWENLPW.js";
+} from "./chunk-BSMGKL27.js";
+import "./chunk-XM4EABZV.js";
+import "./chunk-FNAMNRUH.js";
 export {
   createWorktree,
   openConfiguredIde,

package/dist/{list-FOLV77ET.js → list-WC5GM3PI.js}

@@ -7,12 +7,13 @@ import {
   openIde,
   registerRepo,
   removeWorktree,
+  runCommands,
   runInteractiveList
-} from "./chunk-DKFHAASV.js";
+} from "./chunk-XM4EABZV.js";
 import {
   createStore,
   getEffectiveConfig
-} from "./chunk-IQWENLPW.js";
+} from "./chunk-FNAMNRUH.js";
 
 // src/commands/list.ts
 import * as clack from "@clack/prompts";
@@ -60,6 +61,20 @@ async function runList(options = {}) {
         message: `Remove worktree ${pc.bold(item.branch)}? This cannot be undone.`
       });
       if (clack.isCancel(confirmed) || !confirmed) return false;
+      const config = getEffectiveConfig(item.repoRoot, store);
+      if (config.teardown_commands.length > 0) {
+        console.log(pc.dim("Running teardown commands..."));
+        const result = await runCommands(config.teardown_commands, item.path);
+        if (!result.success) {
+          clack.log.warn(
+            `Teardown command failed: ${result.failedCommand} (exit code ${result.exitCode})`
+          );
+          const proceed = await clack.confirm({
+            message: `Delete ${pc.bold(item.branch)} anyway?`
+          });
+          if (clack.isCancel(proceed) || !proceed) return false;
+        }
+      }
       try {
         removeWorktree(item.repoRoot, item.path);
         console.log(pc.green(`\u2713 Removed ${item.branch}`));
@@ -110,7 +125,7 @@ ${dirty.map((f) => `  ${f}`).join("\n")}`
     },
     onCreate: async () => {
       if (repoRoot) {
-        const { createWorktree } = await import("./create-5BZUA7QH.js");
+        const { createWorktree } = await import("./create-WRMXQIGN.js");
         await createWorktree(void 0, { cwd: repoRoot, store });
       }
     }

package/dist/skill-FEUVQMK6.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> [--mode <mode>]`\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.\'\nwt agent feature/fix \'Fix the bug in payment processing\' --mode auto\nwt agent refactor/api \'Refactor the API layer\' --mode default\n```\n\nThe `--mode` flag sets Claude Code\'s permission mode (defaults to `plan`):\n\n- `default` \u2014 Standard interactive mode with approval for each action\n- `acceptEdits` \u2014 Allow file changes but keep command execution controlled\n- `plan` \u2014 Architecture-first mode with no surprise mutations (default)\n- `auto` \u2014 Claude\'s safety model makes decisions instead of prompting\n- `dontAsk` \u2014 Minimal interruptions in trusted environments\n- `bypassPermissions` \u2014 Skip all permission checks (dangerous, CI/sandbox only)\n\nIt writes a temporary `.zed/tasks.json` running\n`<agent_command> --permission-mode <mode> \'<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\nOver SSH it still works, provided the same user has an active graphical login on\nthe Mac: the keystroke is run inside the GUI session via Launch Services\n(`open -a Terminal` briefly flashes a Terminal window). Grant Accessibility to\nTerminal (not Zed) the first time. With no one logged in graphically there is\nnothing to drive, so it falls back to the manual "press the chord in Zed"\nmessage.\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| `teardown_commands`   | `string[]` | `[]`                              | Commands to run in a worktree just before it is deleted (e.g. `["docker compose down -v"]`); on failure you are prompted whether to delete anyway                         |\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"` | Base command `wt agent` runs in Zed; any `--permission-mode` flag is replaced by the `--mode` option (defaults to `plan`), then `<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`, `teardown_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.3.0",
+  "version": "0.4.0-pr17.g3b7d0a6",
   "description": "Fast, interactive TUI to browse, create, open, and delete git worktrees across repos.",
   "repository": {
     "type": "git",

package/dist/chunk-IQWENLPW.js

@@ -1,40 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/config.ts
-import Conf from "conf";
-var DEFAULT_CONFIG = {
-  worktree_path: "../",
-  base_branch: "origin/main",
-  setup_commands: [],
-  ide: "zed",
-  ide_open_args: ["-n"],
-  agent_command: "claude --permission-mode plan",
-  agent_trigger_chord: "ctrl-shift-cmd-c",
-  repos: [],
-  repo_overrides: {}
-};
-function createStore(cwd) {
-  return new Conf({
-    projectName: "wt",
-    defaults: DEFAULT_CONFIG,
-    ...cwd ? { cwd } : {}
-  });
-}
-function getGlobalConfig(store = createStore()) {
-  return store.store;
-}
-function getEffectiveConfig(repoPath, store = createStore()) {
-  const {
-    repos: _repos,
-    repo_overrides,
-    ...repoFields
-  } = getGlobalConfig(store);
-  const override = repo_overrides[repoPath] ?? {};
-  return { ...repoFields, ...override };
-}
-
-export {
-  createStore,
-  getGlobalConfig,
-  getEffectiveConfig
-};

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