@cestoliv/wt 0.5.0 → 0.5.1

package/README.md

@@ -16,7 +16,10 @@ prompt.
 npm install -g @cestoliv/wt   # also the update command
 ```
 
-Requires Node.js 20+ and Git. The command is `wt`.
+Requires Node.js 20+ and Git. The command is `wt`. Optionally install the
+[`gh`](https://cli.github.com/) and/or [`glab`](https://gitlab.com/gitlab-org/cli)
+CLIs (authenticated) to let `wt prune` confirm merges via merged PRs/MRs — see
+[Prune](#prune--wt-prune).
 
 ## Let your AI assistant set it up
 
@@ -37,7 +40,8 @@ infer from this project. Write the result to the config file (find its path with
 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 agent fix-bug "Fix bug" --mode auto    # Use auto mode instead of the default
+wt prune                                  # Remove merged worktrees (per-branch confirm)
 wt config                                 # Edit config in $EDITOR
 wt skill                                  # Print the skill file (for AI agents)
 ```
@@ -51,14 +55,15 @@ 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.
+(default `claude`, run with `--permission-mode default`) in Zed's integrated
+terminal — pre-filled with your prompt and left interactive for you to take over.
 
-**Available modes** (`--mode`, defaults to `plan`):
+**Available modes** (`--mode`, defaults to `default`; change the default with
+the `agent_mode` config key):
 
-- `default` — Standard interactive mode with approval for each action
+- `default` — Standard interactive mode with approval for each action (default)
 - `acceptEdits` — Allow file changes but keep command execution controlled
-- `plan` — Architecture-first mode with no surprise mutations (default)
+- `plan` — Architecture-first mode with no surprise mutations
 - `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)
@@ -85,12 +90,12 @@ An interactive, fuzzy-searchable list of your worktrees:
 
 ```
 MY-PROJECT
-  ▶ main            ~/dev/my-project
+  ▶ main            (main)  ~/dev/my-project
       fix: resolve auth bug (2h ago)
     feat/dashboard  ~/dev/my-project-feat-dashboard
       wip: add chart component (1d ago)
 
-↕ navigate · Enter open · D delete · C create · A agent · Q quit
+↕ navigate · Enter open · D delete · P prune · C create · A agent · Q quit
 ```
 
 Type to fuzzy-filter branches instantly. Inside a repo it shows that repo's
@@ -104,8 +109,12 @@ and a permission mode — **worktree (repo → branch) → plan prompt → permi
 mode**. Pressing `Esc` steps back to the previous question (answers preserved),
 or back to the list from the first step. After creating, the list **refreshes
 and stays open** (preserving your search and cursor) instead of exiting — only
-`Enter` and `Q`/`Esc` leave the TUI. Note that `a`/`c`/`d` are command keys, so
-they can't be typed into the search box.
+`Enter` and `Q`/`Esc` leave the TUI. `P` prunes every worktree whose branch has
+already been merged (see [`wt prune`](#prune--wt-prune) below). Note that
+`a`/`c`/`d`/`p` are command keys, so they can't be typed into the search box.
+
+The main worktree is tagged `(main)` and is protected — `D` only removes linked
+worktrees, never the main repository.
 
 ## Create — `wt create [branch]`
 
@@ -121,6 +130,34 @@ registered repos.
 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).
 
+## Prune — `wt prune`
+
+```bash
+wt prune   # remove every merged worktree, one confirmation per branch
+```
+
+Cleans up the worktrees you're done with: it finds every worktree whose branch
+has already been merged into the base branch (`base_branch`, default
+`origin/main`) and removes it — **always confirming each branch individually**,
+and force-confirming when git refuses (submodules or uncommitted changes), just
+like a manual `D` delete. The branch itself stays; only the worktree is removed.
+Your `teardown_commands` run before each removal.
+
+Merge detection is tiered. Patch-id matches (via `git cherry`) catch a
+single-commit branch **squash-merged** through a PR, offline. For the ambiguous
+case — the branch tip is an ancestor of base but 0 commits ahead, which both a
+**fast-forward / merge-commit** merge and a worktree holding only *uncommitted*
+work produce — it consults the **forge**: a merged PR/MR (via `gh` for GitHub or
+`glab` for GitLab, including self-hosted, auto-detected from the remote) is the
+only reliable signal, so a branch with unmerged work-in-progress is never
+mistaken for merged. If no forge CLI is available (or you're offline) such
+branches are simply left alone. A worktree still sitting exactly on the base
+commit is never offered. `wt prune` best-effort fetches
+the remote first; if the base ref can't be resolved (offline, missing), it
+removes nothing. The TUI exposes the same action under the `P` key. Works in
+repo mode and across all registered repos in global mode (each against its own
+`base_branch`).
+
 ## Configuration
 
 Edit with `wt config` (`wt config --path` prints the file location —
@@ -134,8 +171,10 @@ Edit with `wt config` (`wt config --path` prints the file location —
 | `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_command`       | `"claude"`                        | Base command; `--permission-mode <mode>` injected, then prompt appended             |
+| `agent_mode`          | `"default"`                       | Default permission mode for `wt agent` (overridden by `--mode`)                     |
 | `agent_trigger_chord` | `"ctrl-shift-cmd-c"`              | Zed keymap chord `wt agent` installs and presses                                    |
+| `auto_refresh_minutes`| `5`                               | How often the interactive list re-fetches worktrees (shows a "last refreshed" header); `0` disables it |
 | `repo_overrides`      | `{}`                              | Per-repo overrides for any key above                                                |
 
 Override any key per repo:

package/SKILL.md

@@ -17,7 +17,8 @@ Launch the interactive TUI. Shows worktrees for the current repo (repo mode) or
 
 - Arrow keys — navigate
 - `Enter` — open worktree in IDE (exits the TUI)
-- `D` — delete worktree
+- `D` — delete worktree (the main worktree is tagged `(main)` and cannot be deleted — only linked worktrees can)
+- `P` — prune all merged worktrees (per-branch confirmation)
 - `C` — create a new worktree (works in both repo and global mode)
 - `A` — create a worktree and start an AI agent in it (works in both modes)
 - type to search · `Backspace` — edit search
@@ -38,8 +39,8 @@ After a create or agent action the TUI **refreshes and stays open** on the list
 (your search and cursor are preserved) rather than exiting — only `Enter` (open)
 and `Q`/`Esc` exit.
 
-Because `a`/`A`, `c`/`C`, and `d`/`D` are reserved as command keys, those
-letters can't be typed into the search box.
+Because `a`/`A`, `c`/`C`, `d`/`D`, and `p`/`P` are reserved as command keys,
+those letters can't be typed into the search box.
 
 ### `wt create [branch]`
 
@@ -65,11 +66,12 @@ 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`):
+The `--mode` flag sets Claude Code's permission mode (defaults to `default`;
+change the default with the `agent_mode` config key):
 
-- `default` — Standard interactive mode with approval for each action
+- `default` — Standard interactive mode with approval for each action (default)
 - `acceptEdits` — Allow file changes but keep command execution controlled
-- `plan` — Architecture-first mode with no surprise mutations (default)
+- `plan` — Architecture-first mode with no surprise mutations
 - `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)
@@ -97,6 +99,33 @@ 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 prune`
+
+Remove every worktree whose branch has already been merged into the base
+branch (`base_branch`, default `origin/main`). Each candidate is confirmed
+individually — and force-confirmed when git refuses (submodules / uncommitted
+changes), exactly like a manual `d` delete. The branch itself is left intact;
+only the worktree is removed.
+
+```bash
+wt prune   # review and remove merged worktrees, one prompt per branch
+```
+
+Merge detection works in tiers. A branch whose diff already exists in base by
+patch id (via `git cherry`, so a single-commit branch **squash-merged** through a
+PR is recognized offline) is merged. For the ambiguous case — the branch tip is
+an ancestor of base but 0 commits ahead, which a **fast-forward / merge-commit**
+merge and a worktree holding only *uncommitted* work both produce — it consults
+the **forge**: a merged PR/MR (via `gh` for GitHub, `glab` for GitLab incl.
+self-hosted, auto-detected from the remote) is the only reliable signal. If the
+forge can't answer (CLI missing, offline, branch unpushed, no merged PR/MR) the
+branch is left alone. A worktree still sitting exactly on the base commit is
+never offered. `wt prune` also best-effort fetches the remote first so detection
+sees up-to-date refs; if the
+base ref can't be resolved (e.g. offline), nothing is removed. Works in repo
+mode (current repo) and global mode (all registered repos, each against its own
+`base_branch`). The TUI exposes the same action under the `p` key.
+
 ### `wt config`
 
 Open the global config file in `$EDITOR` (defaults to `nano`).
@@ -124,14 +153,16 @@ Config is stored as JSON. Get the path with `wt config --path`.
 | `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_command`       | `string`   | `"claude"`                        | Base command `wt agent` runs in Zed; `--permission-mode <mode>` is injected (any existing one replaced), then `<plan_prompt>` is appended single-quoted                   |
+| `agent_mode`          | `string`   | `"default"`                       | Default Claude Code permission mode for `wt agent`; the `--mode` flag overrides it. One of `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`        |
 | `agent_trigger_chord` | `string`   | `"ctrl-shift-cmd-c"`              | Zed keymap chord `wt agent` installs/presses to spawn the agent task                                                                                                      |
+| `auto_refresh_minutes`| `number`   | `5`                               | How often the interactive list (`wt`) re-fetches worktrees and updates the "last refreshed" header; `0` disables auto-refresh                                             |
 | `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`, `teardown_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_mode`, `agent_trigger_chord`, `auto_refresh_minutes`) for a specific repo:
 
 ```json
 {

package/dist/{agent-Z3YCY245.js → agent-QYE5UNA3.js}

@@ -3,9 +3,9 @@ import {
   openConfiguredIde,
   prepareWorktree,
   promptExistingWorktree
-} from "./chunk-QGSJG72F.js";
-import "./chunk-GHYUCETL.js";
-import "./chunk-FNAMNRUH.js";
+} from "./chunk-OA55NRNT.js";
+import "./chunk-XOP26UY4.js";
+import "./chunk-OUWQ6NIV.js";
 
 // src/commands/agent.ts
 import * as clack from "@clack/prompts";
@@ -424,19 +424,30 @@ var VALID_MODES = [
   "dontAsk",
   "bypassPermissions"
 ];
+var isValidMode = (mode) => VALID_MODES.includes(mode);
 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)) {
+  if (options.mode !== void 0 && !isValidMode(options.mode)) {
     console.error(
-      pc.red(`Invalid mode "${mode}". Valid modes: ${VALID_MODES.join(", ")}`)
+      pc.red(
+        `Invalid mode "${options.mode}". Valid modes: ${VALID_MODES.join(", ")}`
+      )
     );
     process.exit(1);
   }
   const prepared = await prepareWorktree(branch, options);
   if (!prepared) return;
   const { status, config, worktreePath } = prepared;
+  let mode = options.mode ?? config.agent_mode ?? "default";
+  if (!isValidMode(mode)) {
+    console.warn(
+      pc.yellow(
+        `\u26A0 Invalid agent_mode "${mode}" in config; using "default". Valid modes: ${VALID_MODES.join(", ")}`
+      )
+    );
+    mode = "default";
+  }
   if (status === "exists") {
     const prompt = options.existingWorktreePrompt ?? promptExistingWorktree;
     const action = await prompt(worktreePath, { allowAgent: true });

package/dist/chunk-BJDZXGOC.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+import {
+  fetchRemote,
+  getRegisteredRepos,
+  getRepoRoot,
+  isBranchMerged,
+  listWorktreeDirtyFiles,
+  listWorktrees,
+  openIde,
+  registerRepo,
+  removeWorktree,
+  runBranchInput,
+  runCommands,
+  runInteractiveList,
+  runRepoPicker,
+  runWizard
+} from "./chunk-XOP26UY4.js";
+import {
+  createStore,
+  getEffectiveConfig,
+  getGlobalConfig
+} from "./chunk-OUWQ6NIV.js";
+
+// src/commands/list.ts
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+function buildWorktreeSteps(repoRoot, store, state) {
+  const steps = [];
+  if (!repoRoot) {
+    const repos = getRegisteredRepos(store);
+    steps.push(async () => {
+      const picked = await runRepoPicker(repos, state.pickedRepo);
+      if (!picked) return false;
+      state.pickedRepo = picked;
+      return true;
+    });
+  }
+  steps.push(async () => {
+    const entered = await runBranchInput(
+      state.pickedRepo,
+      state.branch ?? ""
+    );
+    if (!entered) return false;
+    state.branch = entered;
+    return true;
+  });
+  return steps;
+}
+async function prepareListItems(options = {}) {
+  const { cwd = process.cwd(), store = createStore() } = options;
+  let repoRoot = null;
+  try {
+    repoRoot = getRepoRoot(cwd);
+  } catch {
+  }
+  if (repoRoot) {
+    registerRepo(repoRoot, store);
+    const items2 = listWorktrees(repoRoot, cwd);
+    return { items: items2, mode: "repo", repoRoot };
+  }
+  const repos = getRegisteredRepos(store);
+  const items = repos.flatMap((repo) => {
+    try {
+      return listWorktrees(repo, cwd);
+    } catch {
+      return [];
+    }
+  });
+  return { items, mode: "global", repoRoot: null };
+}
+async function runList(options = {}) {
+  const { store = createStore(), cwd = process.cwd() } = options;
+  const { items, mode, repoRoot } = await prepareListItems({ cwd, store });
+  if (items.length === 0 && mode === "global") {
+    console.log(
+      pc.dim(
+        "No repos registered. Run `wt create` inside a repo to get started."
+      )
+    );
+    return;
+  }
+  const autoRefreshMinutes = mode === "repo" && repoRoot ? getEffectiveConfig(repoRoot, store).auto_refresh_minutes : getGlobalConfig(store).auto_refresh_minutes;
+  await runInteractiveList(
+    items,
+    mode,
+    {
+      onOpen: (item) => {
+        const config = getEffectiveConfig(item.repoRoot, store);
+        openIde(config.ide, config.ide_open_args, item.path);
+      },
+      onDelete: (item) => deleteWorktree(item, store),
+      onWipe: (items2) => wipeWorktrees(items2, store, { fetch: true }),
+      onCreate: async () => {
+        const state = { pickedRepo: repoRoot ?? void 0 };
+        const steps = buildWorktreeSteps(repoRoot, store, state);
+        if (!await runWizard(steps)) return;
+        if (state.pickedRepo === void 0 || state.branch === void 0)
+          return;
+        const { createWorktree } = await import("./create-K4OQIX7A.js");
+        await createWorktree(state.branch, { cwd: state.pickedRepo, store });
+      },
+      onAgent: async () => {
+        const { createAgentWorktree, VALID_MODES } = await import("./agent-QYE5UNA3.js");
+        const state = {
+          pickedRepo: repoRoot ?? void 0
+        };
+        const steps = buildWorktreeSteps(repoRoot, store, state);
+        steps.push(async () => {
+          const entered = await clack.text({
+            message: "Plan prompt for the agent:",
+            initialValue: state.plan,
+            validate: (v) => !v || v.length === 0 ? "Required" : void 0
+          });
+          if (clack.isCancel(entered)) return false;
+          state.plan = entered;
+          return true;
+        });
+        steps.push(async () => {
+          const configuredMode = state.pickedRepo ? getEffectiveConfig(state.pickedRepo, store).agent_mode : void 0;
+          const chosen = await clack.select({
+            message: "Permission mode:",
+            initialValue: state.mode ?? configuredMode,
+            options: VALID_MODES.map((m) => ({ value: String(m), label: m }))
+          });
+          if (clack.isCancel(chosen)) return false;
+          state.mode = chosen;
+          return true;
+        });
+        if (!await runWizard(steps)) return;
+        if (state.pickedRepo === void 0 || state.branch === void 0 || state.plan === void 0)
+          return;
+        await createAgentWorktree(state.branch, state.plan, {
+          cwd: state.pickedRepo,
+          store,
+          mode: state.mode
+        });
+      },
+      refreshItems: async () => {
+        const refreshed = await prepareListItems({ cwd, store });
+        return refreshed.items;
+      }
+    },
+    { autoRefreshMinutes }
+  );
+}
+async function deleteWorktree(item, store) {
+  const confirmed = await clack.confirm({
+    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}`));
+    return true;
+  } catch (err) {
+    const msg = String(err);
+    if (msg.includes("cannot be moved or removed")) {
+      clack.log.warn(
+        "Worktree contains git submodules, which prevent standard removal."
+      );
+      const force = await clack.confirm({
+        message: `Force delete ${pc.bold(item.branch)}? The worktree directory will be removed directly.`
+      });
+      if (clack.isCancel(force) || !force) return false;
+      try {
+        removeWorktree(item.repoRoot, item.path, true);
+        console.log(pc.green(`\u2713 Force-removed ${item.branch}`));
+        return true;
+      } catch (err2) {
+        console.error(pc.red(`\u2717 Failed to force-remove: ${String(err2)}`));
+        return false;
+      }
+    }
+    if (msg.includes("modified or untracked files")) {
+      const dirty = listWorktreeDirtyFiles(item.path);
+      if (dirty.length > 0) {
+        clack.log.warn(
+          `Worktree has uncommitted changes:
+${dirty.map((f) => `  ${f}`).join("\n")}`
+        );
+      }
+      const force = await clack.confirm({
+        message: `Force delete ${pc.bold(item.branch)}? All changes will be lost.`
+      });
+      if (clack.isCancel(force) || !force) return false;
+      try {
+        removeWorktree(item.repoRoot, item.path, true);
+        console.log(pc.green(`\u2713 Force-removed ${item.branch}`));
+        return true;
+      } catch (err2) {
+        console.error(pc.red(`\u2717 Failed to force-remove: ${String(err2)}`));
+        return false;
+      }
+    }
+    console.error(pc.red(`\u2717 Failed to remove: ${msg}`));
+    return false;
+  }
+}
+function selectWipeCandidates(items, isMerged) {
+  return items.filter(
+    (wt) => !wt.isCurrent && !wt.isMain && wt.branch !== "(detached)" && isMerged(wt)
+  );
+}
+function buildMergedPredicate(store) {
+  return (wt) => {
+    const config = getEffectiveConfig(wt.repoRoot, store);
+    const base = config.base_branch;
+    const baseLocal = base.split("/", 2).slice(1).join("/") || base;
+    if (wt.branch === base || wt.branch === baseLocal) return false;
+    return isBranchMerged(wt.repoRoot, wt.branch, base);
+  };
+}
+async function wipeWorktrees(items, store, options = {}) {
+  if (options.fetch) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const wt of items) {
+      if (seen.has(wt.repoRoot)) continue;
+      seen.add(wt.repoRoot);
+      const parts = getEffectiveConfig(wt.repoRoot, store).base_branch.split(
+        "/",
+        2
+      );
+      if (parts.length !== 2) continue;
+      const remote = parts[0] || "origin";
+      try {
+        fetchRemote(wt.repoRoot, remote);
+      } catch (err) {
+        console.warn(
+          pc.yellow(
+            `\u26A0 Could not fetch from ${remote} \u2014 using local state${err instanceof Error ? ` (${err.message})` : ""}`
+          )
+        );
+      }
+    }
+  }
+  const candidates = selectWipeCandidates(items, buildMergedPredicate(store));
+  if (candidates.length === 0) {
+    console.log(pc.dim("No merged worktrees to wipe."));
+    return [];
+  }
+  const removed = [];
+  for (const candidate of candidates) {
+    if (await deleteWorktree(candidate, store)) {
+      removed.push(candidate);
+    }
+  }
+  return removed;
+}
+
+export {
+  prepareListItems,
+  runList,
+  deleteWorktree,
+  selectWipeCandidates,
+  buildMergedPredicate,
+  wipeWorktrees
+};

package/dist/{chunk-QGSJG72F.js → chunk-OA55NRNT.js}

@@ -13,11 +13,11 @@ import {
   runCommands,
   runRepoPicker,
   setUpstreamTracking
-} from "./chunk-GHYUCETL.js";
+} from "./chunk-XOP26UY4.js";
 import {
   createStore,
   getEffectiveConfig
-} from "./chunk-FNAMNRUH.js";
+} from "./chunk-OUWQ6NIV.js";
 
 // src/commands/create.ts
 import { existsSync } from "fs";

package/dist/{chunk-FNAMNRUH.js → chunk-OUWQ6NIV.js}

@@ -68,8 +68,10 @@ var DEFAULT_CONFIG = {
   teardown_commands: [],
   ide: "zed",
   ide_open_args: ["-n"],
-  agent_command: "claude --permission-mode plan",
+  agent_command: "claude",
   agent_trigger_chord: "ctrl-shift-cmd-c",
+  auto_refresh_minutes: 5,
+  agent_mode: "default",
   repos: [],
   repo_overrides: {}
 };