@xbghc/warden 0.9.0 → 0.11.0

package/README.md

@@ -7,6 +7,8 @@ with line comments you can copy back to the agent as a prompt.
 - Diff sources: working tree, staged, working tree vs HEAD, a branch since it forked off its base (commits and
   uncommitted work together), any commit, any two refs, and git worktrees.
 - Worktrees are made and taken down from the page, one per agent branch, with the path ready to paste.
+  Their directories are numbered slots beside the repository that get reused rather than remade:
+  releasing one keeps the directory, installed dependencies included, for the next branch.
 - Side-by-side **Unstaged** and **Staged** file lists: staged means reviewed. Stage from the UI by dragging
   over the lines you have read (or a hunk, or a file), and unstage the same way from the Staged view.
 - GitHub-style unified / side-by-side diff with syntax highlighting, collapsed file tree, lazy per-file loading, context expansion, virtual scrolling.
@@ -23,8 +25,10 @@ with line comments you can copy back to the agent as a prompt.
   path (each a `git log` on the server, not a filter over the rows already loaded), and a
   first-parent view that folds merged branches into their merge commits.
 - Click a line number to jump to that line in a running nvim instance (WSL2 friendly).
-- Git is touched through whitelisted read sub-commands plus exactly one write, `git apply --cached`, which is
-  what the stage / unstage controls run. The working tree and HEAD are never written.
+- Git is touched through whitelisted read sub-commands plus a few writes the server composes itself:
+  `git apply --cached`, which is what the stage / unstage controls run, and the worktree slot
+  operations (`worktree add` / `remove`, `branch`, `switch`). Reviewing and staging never write the
+  working tree or HEAD; only checking a branch out into a free slot, or releasing one, does.
 
 ## Install / run
 
@@ -65,8 +69,8 @@ Worktrees are discovered with `git worktree list` (and made in the *Worktrees* t
 share the review state of the main repository.
 One whose directory is gone (git lists it as *prunable*) is not offered, and a remembered target
 inside a removed worktree falls back to the working tree on the next load. The comments and viewed
-flags kept under that worktree's key stay in the state file and come back if a worktree is created
-at the same path again.
+flags kept under a worktree's key stay in the state file until a branch is checked out into that
+slot again, which drops them: they were about another branch.
 
 The sidebar is the navigation, and the only navigation: its three tabs — *变更*, *提交*, *Worktree* —
 each fill the left column with the controls for what the middle is showing, and the top bar carries
@@ -101,25 +105,50 @@ the fix and delete or re-attach it.
 ## Worktrees
 
 Agents do their best work each in a worktree of its own, and the sidebar's *Worktree* tab is
-where those are made and taken down without a trip to the terminal:
-
-- *新建 worktree*, the form in the sidebar, takes a branch and a base. A name that is not a branch yet becomes one from the
-  base (`main` or `master` unless you say otherwise; any ref goes) — `git worktree add -b <branch>
-  <path> <base>`; an existing branch is checked out as it is, unless another worktree already has it.
-  The path is suggested as a sibling of the main worktree named `<repo>-<branch>` (slashes become
-  dashes) and can be edited, within limits: it has to sit under the main worktree's parent directory,
-  outside every existing worktree, and be new or an empty directory.
-- Each row names the checkout, its branch, and whether it is clean or how many paths `git status`
-  reports. *查看* switches the review to it (the kind of target carries over, as with the selector
-  in the top bar), *复制路径* is for the agent's prompt.
-- *删除* always asks first, in the row it would remove, and runs `git worktree remove` without
-  `--force`: a worktree with uncommitted changes is not removed until you confirm again, since those
-  changes go with it, and whatever else git refuses without `--force` is put to you the same way.
-  *一并删除分支* is offered in that same confirmation, ticked by default, and takes the branch by
-  `git branch -d`: one that is not merged is kept and the toast says why. The comments and viewed
-  flags kept under the worktree's key stay in the state file, as before.
+where those are made and taken down without a trip to the terminal. The directories are numbered
+**slots** beside the main worktree — `<repo>-1`, `<repo>-2`, … (工位 in the UI) — rather than one
+directory per branch: a directory is where the dependencies get installed, and a fresh one for every
+branch meant installing them for every branch. A slot outlives its branch. Releasing it leaves the
+directory behind, `node_modules` and all, and the next branch is checked out into it.
+
+- *检出分支*, the form in the sidebar, takes a branch, a base and a slot. An existing branch is
+  checked out as it is, unless another worktree already has it. A branch only a remote has is
+  checked out tracking the remote one (what `git worktree add` itself guesses) rather than started
+  afresh; when several remotes have it, the base says which. The branch list offers local branches
+  only, since a remote can carry thousands: the name typed is looked up on its own
+  (`GET /api/worktrees/remotes`), so the form says it is a remote branch before you submit. Any
+  other name becomes a branch from the base (`main` or `master` unless you say otherwise; any ref
+  goes). The server looks the name up when the request arrives, so a branch fetched or made after the page
+  loaded its list is still found, and a base typed for a name that already exists is refused.
+- The slot picker lists the free slots, lowest first, then *新目录*: the next number, which is made
+  with `git worktree add [--track] [-b <branch>] <repo>-<n> [<base>]`. Into a free slot the checkout
+  is `git branch [--track] <branch> <base>` in the main worktree — so a base such as `HEAD` means what
+  it would to `worktree add` — followed by `git switch <branch>` in the slot, which rewrites the
+  tracked files and leaves the ignored ones alone; the toast says which of the two happened. Nothing
+  in the request names a directory: the server composes the path from the number, so a checkout
+  cannot land anywhere but beside the main worktree. Whatever review state was kept under the slot's
+  key (comments, viewed flags, its `base` pool included) is dropped: it was about another branch.
+- Each row names the branch, its directory, and whether it is clean or how many paths `git status`
+  reports. *查看* switches the review to it (the kind of target carries over), *复制路径* is for the
+  agent's prompt. A free slot is a row of its own, marked *空闲*, and its *检出到这里* points the form
+  at it.
+- *释放* is what a slot's row offers, and it always asks first, in the row: `git switch --detach` in
+  the slot leaves the last commit checked out with no branch on it and touches no file, and the slot
+  is free for the next checkout. A slot with uncommitted changes is not released until you confirm
+  again, since those changes go: only that second request discards them — `git reset --hard`, then
+  `git clean -fd` for the untracked files, never `-x`, so the ignored ones, the installed
+  dependencies above all, stay. *一并删除分支* is offered in the same confirmation,
+  ticked by default, and takes the branch by `git branch -d`: one that is not merged is kept and the
+  toast says why. *连目录一起删除* turns the release into a removal.
+- *删除* is for a worktree that is not a slot (one made by hand, wherever it is) and for a free slot
+  whose directory you no longer want; a slot on a branch gets it through *连目录一起删除*. It runs
+  `git worktree remove` without `--force`: uncommitted changes are put to you first, as with a
+  release, and so is whatever else git refuses without `--force`.
 - A worktree whose directory was deleted behind git's back is listed struck through; *清理* drops that
-  one entry (`git worktree remove` handles it; nothing is pruned wholesale).
+  one entry (`git worktree remove` handles it; nothing is pruned wholesale). A slot in that state
+  cannot be released or checked out into, and its number is skipped until the entry is gone.
+
+`git switch` needs git 2.23 or newer.
 
 ## Keyboard
 
@@ -319,11 +348,17 @@ flag; requests that would need anything else get HTTP 400. The writes are few an
 own arguments. `POST /api/targets/:key/stage` runs `git apply --cached` (with `--reverse` for the
 Staged view) on a patch the server itself builds from the diff it just produced — the patch is never
 taken from the request, only the line indices are, and they are checked against the diff's hash
-first. `POST /api/worktrees` and `POST /api/worktrees/remove` run `git worktree add`, `git worktree
-remove` and `git branch -d` with a branch name git has validated, a ref that resolves, and a
-path confined to the main worktree's parent directory. Nothing writes to the working tree or HEAD of
-an existing checkout; refs change only when a worktree is made (its new branch) or removed (its merged
-branch, on request), and the review state lives outside the repository. A mutating request the
+first. `POST /api/worktrees`, `POST /api/worktrees/release` and `POST /api/worktrees/remove` run
+`git worktree add`, `git branch`, `git switch`, `git worktree remove` and `git branch -d` with a
+branch name git has validated, a ref that resolves, and a slot path the server composes from a
+number — `<repo>-<n>` beside the main worktree; no request names a directory. The working tree and
+HEAD of an existing checkout are written only inside such a slot: `git switch <branch>` into a free
+one (detached, clean) when a branch is checked out there, `git switch --detach` when it is released,
+and `git reset --hard` plus `git clean -fd` only on the forced release the reviewer confirmed after
+a 409. Refs change only when a branch is made for a checkout (plus its upstream setting when it comes
+from a remote) — undone with `branch -D` should the switch into the slot then fail — or deleted on
+request after a release or removal (`-d`, so only a merged one), and the review state lives outside
+the repository. A mutating request the
 browser labels as coming from another site (`Sec-Fetch-Site: cross-site`) is refused with 403, so a
 page from elsewhere cannot drive the server through the browser it is open in.
 
@@ -365,4 +400,16 @@ MIT
 
 ## Storybook
 
+[Browse the hosted Storybook](https://xbghc.github.io/warden/). Every push to `main` builds and deploys it through `.github/workflows/storybook-pages.yml`; the workflow can also be run manually. Repository Settings → Pages must use **GitHub Actions** as the publishing source.
+
 Run `pnpm storybook` for isolated review and layout components at http://127.0.0.1:6006. Stories use in-memory fixtures and include interaction checks. Run `pnpm build:storybook` to build the static preview.
+
+### Worktree details and tmux
+
+Each checkout reports how many commits it is ahead of and behind a base, named beside the counts. A branch with an upstream, the main checkout's included, is counted against it (`origin/topic`): what is not pushed and what is not pulled yet, as `git status` counts them. Any other checkout, or one whose upstream is gone (`[origin/topic: gone]`, which the row notes), is counted against the branch currently checked out in the main repository; “已合并” there means its HEAD is reachable from the main checkout HEAD, which squash merges and cherry-picks do not imply. Either way the base is the ref `git branch -d` checks, so a branch with nothing ahead is one *一并删除分支* will take. Expand a row to browse its paginated commit history (including shared commits) or view that branch’s todos.
+
+The optional tmux integration discovers sessions whose `session_path` resolves to the main repository directory. Click tmux to create a window immediately when exactly one session matches. With multiple matches, choose a session first. The new window starts in the worktree directory. It uses `tmux new-window -d -c` without sending a shell command; existing windows stay selected. No session is created automatically. Run warden alongside tmux in Linux, macOS, or WSL, using the same user/server environment. See the [tmux manual](https://man.openbsd.org/tmux.1).
+
+`GET /api/tmux/sessions` lists matching sessions. `POST /api/tmux/windows` accepts a registered worktree `path` and a matching `sessionId`; the server revalidates both before creating a window. This optional action creates a terminal window but does not modify repository files.
+
+The sidebar uses a view selector for Changes, Commits, and Worktrees. The `Layout/Sidebar` stories demonstrate the selector together with each view’s real sidebar controls and content.

package/dist/cli.js

@@ -3982,8 +3982,15 @@ function buildStagePatch(diff, mode, selection) {
 // packages/server/src/worktrees.ts
 import path3 from "path";
 import { readdir, realpath as realpath2, stat } from "fs/promises";
-function worktreePathPrefix(ctx) {
-  return path3.join(path3.dirname(ctx.commonRoot), `${path3.basename(ctx.commonRoot)}-`);
+function slotPath(ctx, slot) {
+  return path3.join(path3.dirname(ctx.commonRoot), `${path3.basename(ctx.commonRoot)}-${slot}`);
+}
+function slotOf(ctx, p) {
+  if (path3.dirname(p) !== path3.dirname(ctx.commonRoot)) return void 0;
+  const prefix = `${path3.basename(ctx.commonRoot)}-`;
+  const name = path3.basename(p);
+  const n = name.startsWith(prefix) ? name.slice(prefix.length) : "";
+  return /^[1-9]\d*$/.test(n) ? Number(n) : void 0;
 }
 async function dirtyCount(cwd) {
   try {
@@ -3993,12 +4000,57 @@ async function dirtyCount(cwd) {
     return 0;
   }
 }
+async function listUpstreams(ctx) {
+  const r = await runGit(["for-each-ref", "--format=%(refname)%09%(upstream:short)%09%(upstream:track)", "refs/heads"], { cwd: ctx.commonRoot });
+  const out = /* @__PURE__ */ new Map();
+  for (const line of r.stdout.split("\n")) {
+    const [ref = "", name = "", track = ""] = line.split("	");
+    if (!name) continue;
+    out.set(ref.replace(/^refs\/heads\//, ""), {
+      name,
+      gone: track === "[gone]",
+      ahead: Number(/ahead (\d+)/.exec(track)?.[1] ?? 0),
+      behind: Number(/behind (\d+)/.exec(track)?.[1] ?? 0)
+    });
+  }
+  return out;
+}
 async function listWorktreesDetailed(ctx) {
-  const all = await listWorktreesAll(ctx);
-  return Promise.all(all.map(async (w) => ({ ...w, dirty: w.prunable || w.bare ? 0 : await dirtyCount(w.path) })));
+  const [all, upstreams] = await Promise.all([listWorktreesAll(ctx), listUpstreams(ctx)]);
+  const main2 = all.find((w) => w.isMain);
+  return Promise.all(
+    all.map(async (w) => {
+      const slot = w.isMain || w.bare ? void 0 : slotOf(ctx, w.path);
+      const dirty = w.prunable || w.bare ? 0 : await dirtyCount(w.path);
+      const detail = {
+        ...w,
+        dirty,
+        ...slot === void 0 ? {} : { slot },
+        // Free is what the next checkout may take over: a detached HEAD and nothing that would be lost.
+        free: slot !== void 0 && !w.prunable && w.detached && dirty === 0
+      };
+      if (detail.free) return detail;
+      const upstream = w.branch ? upstreams.get(w.branch) : void 0;
+      if (upstream && !upstream.gone) {
+        detail.comparison = { kind: "upstream", base: upstream.name, ahead: upstream.ahead, behind: upstream.behind };
+        return detail;
+      }
+      if (upstream) detail.upstreamGone = upstream.name;
+      if (w.isMain) return detail;
+      if (!main2?.head || !w.head || /^0+$/.test(main2.head) || /^0+$/.test(w.head)) return { ...detail, comparisonError: "\u5206\u652F\u5C1A\u65E0\u63D0\u4EA4" };
+      try {
+        const result = await runGit(["rev-list", "--left-right", "--count", `${main2.head}...${w.head}`, "--"], { cwd: ctx.commonRoot });
+        const [behind, ahead] = result.stdout.trim().split(/\s+/).map(Number);
+        detail.comparison = { kind: "base", base: main2.branch ?? `HEAD ${main2.head.slice(0, 7)}`, ahead, behind };
+      } catch {
+        detail.comparisonError = "\u65E0\u6CD5\u6BD4\u8F83\u63D0\u4EA4\u5386\u53F2";
+      }
+      return detail;
+    })
+  );
 }
 async function listBranches(ctx, worktrees) {
-  const r = await runGit(["for-each-ref", "--format=%(refname:short)%09%(objectname:short)", "refs/heads"], { cwd: ctx.commonRoot });
+  const r = await runGit(["for-each-ref", "--format=%(refname:lstrip=2)%09%(objectname:short)", "refs/heads"], { cwd: ctx.commonRoot });
   const at = /* @__PURE__ */ new Map();
   for (const w of worktrees) if (w.branch) at.set(w.branch, w.path);
   return r.stdout.split("\n").filter(Boolean).map((line) => {
@@ -4007,6 +4059,11 @@ async function listBranches(ctx, worktrees) {
     return { name, sha, ...worktree ? { worktree } : {} };
   });
 }
+async function lookupRemoteBranches(ctx, name) {
+  const branch = name.trim();
+  await assertBranchName(ctx, branch);
+  return remoteBranches(ctx.commonRoot, branch);
+}
 async function assertBranchName(ctx, name) {
   if (!isValidRef(name) || name.includes("@{") || name.startsWith("refs/")) throw badRequest(`invalid branch name: ${name}`, "invalid_branch");
   try {
@@ -4015,64 +4072,128 @@ async function assertBranchName(ctx, name) {
     throw badRequest(`invalid branch name: ${name}`, "invalid_branch");
   }
 }
-async function assertNewWorktreePath(ctx, worktrees, p) {
-  if (!p || !path3.isAbsolute(p)) throw badRequest("worktree path must be absolute", "invalid_path");
-  const target = path3.resolve(p);
-  const parent = path3.dirname(ctx.commonRoot);
-  if (target === parent || !target.startsWith(parent + path3.sep)) throw badRequest(`worktree path must be under ${parent}`, "invalid_path");
-  for (const w of worktrees) {
-    if (target === w.path || target.startsWith(w.path + path3.sep)) throw badRequest(`${target} is inside the worktree at ${w.path}`, "invalid_path");
-  }
-  const st = await stat(target).catch((e) => {
+async function dirUsable(p) {
+  const st = await stat(p).catch((e) => {
     if (e.code === "ENOENT") return void 0;
     throw e;
   });
-  if (!st) return target;
-  if (!st.isDirectory() || (await readdir(target)).length > 0) throw badRequest(`${target} already exists`, "path_exists");
-  return target;
+  return !st || st.isDirectory() && (await readdir(p)).length === 0;
+}
+async function nextSlot(ctx, worktrees) {
+  const listed = new Set(worktrees.map((w) => w.path));
+  for (let slot = 1; ; slot++) {
+    const p = slotPath(ctx, slot);
+    if (!listed.has(p) && await dirUsable(p)) return { slot, path: p };
+  }
+}
+async function pickSlot(ctx, worktrees, wanted) {
+  const slots = worktrees.filter((w) => w.slot !== void 0);
+  if (wanted === void 0) {
+    const free = slots.filter((w) => w.free).sort((a, b) => a.slot - b.slot)[0];
+    if (free) return { slot: free.slot, path: free.path, reuse: true };
+    return { ...await nextSlot(ctx, worktrees), reuse: false };
+  }
+  const have = slots.find((w) => w.slot === wanted);
+  if (have?.prunable) throw new HttpError(409, `the directory of slot ${wanted} is gone; remove its entry first`, "slot_gone");
+  if (have && !have.free) throw new HttpError(409, `slot ${wanted} is in use${have.branch ? ` by ${have.branch}` : ""}`, "slot_in_use");
+  if (have) return { slot: wanted, path: have.path, reuse: true };
+  const p = slotPath(ctx, wanted);
+  if (!await dirUsable(p)) throw badRequest(`${p} already exists`, "path_exists");
+  return { slot: wanted, path: p, reuse: false };
 }
-async function addWorktree(ctx, req) {
+async function remoteBranches(cwd, branch) {
+  const r = await runGit(["for-each-ref", "--format=%(refname:lstrip=2)", `refs/remotes/*/${branch}`], { cwd });
+  return r.stdout.split("\n").filter(Boolean);
+}
+async function checkoutWorktree(ctx, req) {
   const branch = req.branch.trim();
   const base = req.base?.trim();
   await assertBranchName(ctx, branch);
-  const existing = await listWorktreesAll(ctx);
-  const target = await assertNewWorktreePath(ctx, existing, req.path.trim());
   const cwd = ctx.commonRoot;
-  const branchExists = await refExists(cwd, `refs/heads/${branch}`);
-  let args;
   if (base) {
     if (!isValidRef(base)) throw badRequest(`invalid base ref: ${base}`, "invalid_ref");
     if (!await refExists(cwd, base)) throw badRequest(`unknown ref: ${base}`, "unknown_ref");
-    if (branchExists) throw new HttpError(409, `branch ${branch} already exists`, "branch_exists");
-    args = ["worktree", "add", "-b", branch, target, base];
-  } else {
-    if (!branchExists) throw badRequest(`unknown branch: ${branch}`, "unknown_ref");
+  }
+  const existing = await listWorktreesDetailed(ctx);
+  let create;
+  if (await refExists(cwd, `refs/heads/${branch}`)) {
+    if (base) throw new HttpError(409, `branch ${branch} already exists`, "branch_exists");
     const holder = existing.find((w) => w.branch === branch);
     if (holder) throw new HttpError(409, `${branch} is already checked out at ${holder.path}`, "branch_in_use");
-    args = ["worktree", "add", target, branch];
+  } else if (await refExists(cwd, `refs/remotes/${branch}`)) {
+    throw new HttpError(409, `${branch} is a remote branch; enter ${branch.slice(branch.indexOf("/") + 1)} to check it out`, "branch_exists");
+  } else {
+    const remote = await remoteBranches(cwd, branch);
+    if (remote.length > 1 && !remote.includes(base ?? "")) {
+      throw new HttpError(409, `branch ${branch} exists on several remotes; enter ${remote.join(" or ")} as the base`, "ambiguous_branch");
+    }
+    if (remote.length === 1 && base && base !== remote[0]) {
+      throw new HttpError(409, `branch ${branch} already exists as ${remote[0]}; leave the base empty to check it out`, "branch_exists");
+    }
+    create = remote.length ? { start: base || remote[0], track: true } : { start: base || await detectDefaultBase(cwd) || "HEAD", track: false };
   }
+  const target = await pickSlot(ctx, existing, req.slot);
+  let made = false;
   try {
-    await runGitWrite(args, { cwd });
+    if (target.reuse) {
+      if (create) {
+        await runGitWrite(["branch", ...create.track ? ["--track"] : [], branch, create.start], { cwd });
+        made = true;
+      }
+      await runGitWrite(["switch", "--no-guess", branch], { cwd: target.path });
+    } else if (create) {
+      await runGitWrite(["worktree", "add", ...create.track ? ["--track"] : [], "-b", branch, target.path, create.start], { cwd });
+    } else {
+      await runGitWrite(["worktree", "add", target.path, branch], { cwd });
+    }
   } catch (e) {
+    if (made) await runGitWrite(["branch", "-D", branch], { cwd }).catch(() => void 0);
     if (e instanceof GitError && /already (checked out|used by worktree)/.test(e.stderr)) throw new HttpError(409, e.message, "branch_in_use");
     throw e;
   }
-  const real = await realpath2(target).catch(() => target);
-  const made = (await listWorktrees(ctx)).find((w) => w.path === real);
-  if (!made) throw new HttpError(500, `git created ${target} but does not list it`, "git_failed");
-  return made;
+  const real = await realpath2(target.path).catch(() => target.path);
+  const worktree = (await listWorktrees(ctx)).find((w) => w.path === real);
+  if (!worktree) throw new HttpError(500, `git checked ${branch} out at ${target.path} but does not list it`, "git_failed");
+  return { worktree, slot: target.slot, reused: target.reuse };
+}
+async function dropBranch(ctx, wt, asked) {
+  const res = { ok: true, branchDeleted: false };
+  if (asked && wt.branch) {
+    try {
+      await runGitWrite(["branch", "-d", wt.branch], { cwd: ctx.commonRoot });
+      res.branchDeleted = true;
+    } catch (e) {
+      res.branchError = e instanceof Error ? e.message : String(e);
+    }
+  }
+  return res;
+}
+async function releaseWorktree(ctx, req) {
+  const p = req.path.trim();
+  const wt = (await listWorktreesAll(ctx)).find((w) => w.path === p || p && w.path === path3.resolve(p));
+  if (!wt) throw badRequest(`unknown worktree: ${p}`, "unknown_worktree");
+  if (wt.isMain) throw badRequest("the main worktree cannot be released", "main_worktree");
+  if (wt.bare || slotOf(ctx, wt.path) === void 0) throw badRequest(`${wt.path} is not a slot; remove it instead`, "not_a_slot");
+  if (wt.prunable) throw badRequest(`the directory of ${wt.path} is gone; remove its entry instead`, "worktree_gone");
+  const dirty = await dirtyCount(wt.path);
+  if (dirty > 0 && !req.force) throw new HttpError(409, `${wt.path} has uncommitted changes`, "worktree_dirty");
+  if (dirty > 0) {
+    await runGitWrite(["reset", "-q", "--hard"], { cwd: wt.path });
+    await runGitWrite(["clean", "-fdq"], { cwd: wt.path });
+  }
+  if (!wt.detached) await runGitWrite(["switch", "--detach"], { cwd: wt.path });
+  return dropBranch(ctx, wt, req.deleteBranch);
 }
 async function removeWorktree(ctx, req) {
   const p = req.path.trim();
   const wt = (await listWorktreesAll(ctx)).find((w) => w.path === p || p && w.path === path3.resolve(p));
   if (!wt) throw badRequest(`unknown worktree: ${p}`, "unknown_worktree");
   if (wt.isMain) throw badRequest("the main worktree cannot be removed", "main_worktree");
-  const cwd = ctx.commonRoot;
   const args = ["worktree", "remove"];
   if (req.force) args.push("--force");
   args.push(wt.path);
   try {
-    await runGitWrite(args, { cwd });
+    await runGitWrite(args, { cwd: ctx.commonRoot });
   } catch (e) {
     if (e instanceof GitError && /contains modified or untracked files/.test(e.stderr)) {
       throw new HttpError(409, `${wt.path} has uncommitted changes`, "worktree_dirty");
@@ -4082,16 +4203,7 @@ async function removeWorktree(ctx, req) {
     }
     throw e;
   }
-  const res = { ok: true, branchDeleted: false };
-  if (req.deleteBranch && wt.branch) {
-    try {
-      await runGitWrite(["branch", "-d", wt.branch], { cwd });
-      res.branchDeleted = true;
-    } catch (e) {
-      res.branchError = e instanceof Error ? e.message : String(e);
-    }
-  }
-  return res;
+  return dropBranch(ctx, wt, req.deleteBranch);
 }
 
 // packages/server/src/state.ts
@@ -4257,6 +4369,16 @@ var StateStore = class {
     }
   }
 };
+function forgetWorktreeTargets(state, worktreePath) {
+  const prefix = `worktree:${worktreePath}:`;
+  const gone = /* @__PURE__ */ new Set();
+  for (const key of Object.keys(state.targets)) {
+    if (!key.startsWith(prefix)) continue;
+    for (const c of state.targets[key].comments) gone.add(c.id);
+    delete state.targets[key];
+  }
+  if (gone.size) for (const issue of state.issues) issue.commentIds = issue.commentIds.filter((id) => !gone.has(id));
+}
 
 // packages/server/src/export.ts
 var LANG_BY_EXT = {
@@ -4449,6 +4571,44 @@ var NvimService = class {
   }
 };
 
+// packages/server/src/tmux.ts
+import { execFile as execFile3 } from "child_process";
+import { realpath as realpath3 } from "fs/promises";
+var runTmux = (args) => new Promise((resolve, reject) => {
+  execFile3("tmux", args, { encoding: "utf8", timeout: 5e3, maxBuffer: 1024 * 1024, windowsHide: true }, (error, stdout, stderr) => {
+    if (!error) return resolve(stdout);
+    const missing = error.code === "ENOENT";
+    reject(
+      new HttpError(503, missing ? "tmux \u4E0D\u53EF\u7528\uFF0C\u8BF7\u5728\u5B89\u88C5\u4E86 tmux \u7684 Linux/macOS \u6216 WSL \u4E2D\u8FD0\u884C warden" : stderr.trim() || "\u65E0\u6CD5\u8FDE\u63A5 tmux", "tmux_unavailable")
+    );
+  });
+});
+var TmuxService = class {
+  constructor(run2 = runTmux) {
+    this.run = run2;
+  }
+  run;
+  async sessions(mainRoot) {
+    const root = await realpath3(mainRoot);
+    const output = await this.run(["list-sessions", "-F", "#{session_id}	#{session_name}	#{session_path}"]);
+    const sessions = [];
+    for (const line of output.trimEnd().split("\n")) {
+      const [id, name, ...parts] = line.split("	");
+      const path10 = parts.join("	");
+      if (!id || !/^\$\d+$/.test(id) || !name || !path10) continue;
+      if (await realpath3(path10).catch(() => null) === root) sessions.push({ id, name, path: path10 });
+    }
+    return sessions;
+  }
+  async open(mainRoot, worktreePath, sessionId) {
+    const session = (await this.sessions(mainRoot)).find((s) => s.id === sessionId);
+    if (!session) throw new HttpError(409, "\u4E3B\u4ED3\u5E93\u5BF9\u5E94\u7684 tmux session \u5DF2\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5237\u65B0\u540E\u91CD\u8BD5", "tmux_session_missing");
+    const directory = await realpath3(worktreePath);
+    const window = (await this.run(["new-window", "-d", "-P", "-F", "#{window_id}", "-t", `${session.id}:`, "-c", directory.replaceAll("#", "##")])).trim();
+    return { session: session.name, window };
+  }
+};
+
 // packages/server/src/watcher.ts
 import path6 from "path";
 import { stat as stat4 } from "fs/promises";
@@ -5217,18 +5377,41 @@ function createApp(opts) {
     const res = { base, sha, ahead: Number(counts[1] ?? 0), behind: Number(counts[0] ?? 0) };
     return c.json(res);
   });
+  const tmux = opts.tmux ?? new TmuxService();
+  api.get("/tmux/sessions", async (c) => c.json({ sessions: await tmux.sessions(repo.commonRoot) }));
+  api.post("/tmux/windows", async (c) => {
+    const body = await c.req.json();
+    if (!body || typeof body.path !== "string" || typeof body.sessionId !== "string") throw badRequest("path and sessionId are required");
+    const wt = (await worktrees(true)).find((w) => w.path === body.path && !w.bare);
+    if (!wt) throw badRequest("unknown worktree", "unknown_worktree");
+    return c.json(await tmux.open(repo.commonRoot, wt.path, body.sessionId), 201);
+  });
   api.get("/worktrees", async (c) => {
     const list = await listWorktreesDetailed(repo);
-    const res = { worktrees: list, branches: await listBranches(repo, list), pathPrefix: worktreePathPrefix(repo) };
+    const [branches, newSlot] = await Promise.all([listBranches(repo, list), nextSlot(repo, list)]);
+    const res = { worktrees: list, branches, newSlot };
+    return c.json(res);
+  });
+  api.get("/worktrees/remotes", async (c) => {
+    const res = { remotes: await lookupRemoteBranches(repo, c.req.query("branch") ?? "") };
     return c.json(res);
   });
   api.post("/worktrees", async (c) => {
     const body = await c.req.json();
-    if (typeof body.path !== "string" || typeof body.branch !== "string") throw badRequest("path and branch are required");
+    if (typeof body.branch !== "string") throw badRequest("branch is required");
     if (body.base !== void 0 && typeof body.base !== "string") throw badRequest("base must be a ref");
-    const made = await addWorktree(repo, body);
+    if (body.slot !== void 0 && (!Number.isInteger(body.slot) || body.slot < 1)) throw badRequest("slot must be a positive integer", "invalid_slot");
+    const res = await checkoutWorktree(repo, body);
+    worktreeCache = null;
+    await store.update((s) => forgetWorktreeTargets(s, res.worktree.path));
+    return c.json(res, 201);
+  });
+  api.post("/worktrees/release", async (c) => {
+    const body = await c.req.json();
+    if (typeof body.path !== "string") throw badRequest("path is required");
+    const res = await releaseWorktree(repo, body);
     worktreeCache = null;
-    return c.json(made, 201);
+    return c.json(res);
   });
   api.post("/worktrees/remove", async (c) => {
     const body = await c.req.json();
@@ -5317,7 +5500,7 @@ function createApp(opts) {
 }
 
 // packages/server/src/wsl.ts
-import { execFile as execFile3 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { readFile as readFile4 } from "fs/promises";
 var PROBE_TIMEOUT_MS = 3e3;
 async function isWsl(env = process.env, platform = process.platform) {
@@ -5331,7 +5514,7 @@ async function isWsl(env = process.env, platform = process.platform) {
 }
 function reachableFromWindows(port, token, timeoutMs = PROBE_TIMEOUT_MS) {
   return new Promise((resolve) => {
-    execFile3(
+    execFile4(
       "curl.exe",
       ["--silent", "--max-time", String(Math.ceil(timeoutMs / 1e3)), `http://127.0.0.1:${port}/api/ping`],
       { timeout: timeoutMs + 1e3, encoding: "utf8", windowsHide: true },
@@ -5414,7 +5597,7 @@ async function startServer(opts) {
 }
 
 // bin/cli.ts
-var VERSION = true ? "0.9.0" : "dev";
+var VERSION = true ? "0.11.0" : "dev";
 function parseArgs(argv) {
   const args = { repoPath: process.cwd(), open: true, help: false, version: false };
   for (let i = 0; i < argv.length; i++) {