@xbghc/warden 0.16.0 → 0.16.1

package/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
 // bin/cli.ts
-import path11 from "path";
+import path12 from "path";
 import { spawn } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { fileURLToPath } from "url";
 
 // packages/server/src/index.ts
 import net from "net";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 // node_modules/.pnpm/@hono+node-server@1.19.17_hono@4.13.7/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -652,9 +652,9 @@ var serve = (options, listeningListener) => {
 };
 
 // packages/server/src/app.ts
-import path9 from "path";
+import path10 from "path";
 import { stat as stat7 } from "fs/promises";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -813,26 +813,26 @@ var throwNestingLimitExceeded = () => {
 };
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/url.js
-var splitPath = (path12) => {
-  const paths = path12.split("/");
+var splitPath = (path13) => {
+  const paths = path13.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path12 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path12);
+  const { groups, path: path13 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path13);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path12) => {
+var extractGroupsFromPath = (path13) => {
   const groups = [];
-  path12 = path12.replace(/\{[^}]+\}/g, (match2, index) => {
+  path13 = path13.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path12 };
+  return { groups, path: path13 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -889,8 +889,8 @@ var getPath = (request) => {
       const queryIndex = url.indexOf("?", i);
       const hashIndex = url.indexOf("#", i);
       const end = queryIndex === -1 ? hashIndex === -1 ? void 0 : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
-      const path12 = url.slice(start, end);
-      return tryDecodeURI(path12.includes("%25") ? path12.replace(/%25/g, "%2525") : path12);
+      const path13 = url.slice(start, end);
+      return tryDecodeURI(path13.includes("%25") ? path13.replace(/%25/g, "%2525") : path13);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -907,11 +907,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path12) => {
-  if (path12.charCodeAt(path12.length - 1) !== 63 || !path12.includes(":")) {
+var checkOptionalParameter = (path13) => {
+  if (path13.charCodeAt(path13.length - 1) !== 63 || !path13.includes(":")) {
     return null;
   }
-  const segments = path12.split("/");
+  const segments = path13.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -1053,9 +1053,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path12 = "/", matchResult = [[]]) {
+  constructor(request, path13 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path12;
+    this.path = path13;
     this.#matchResult = matchResult;
   }
   param(key) {
@@ -1827,8 +1827,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path12, ...handlers) => {
-      for (const p of [path12].flat()) {
+    this.on = (method, path13, ...handlers) => {
+      for (const p of [path13].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           const methodName = m.toUpperCase();
@@ -1886,8 +1886,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path12, app) {
-    const subApp = this.basePath(path12);
+  route(path13, app) {
+    const subApp = this.basePath(path13);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -1913,9 +1913,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path12) {
+  basePath(path13) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path12);
+    subApp._basePath = mergePath(this._basePath, path13);
     return subApp;
   }
   /**
@@ -1989,7 +1989,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path12, applicationHandler, options) {
+  mount(path13, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -2016,7 +2016,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path12);
+      const mergedPath = mergePath(this._basePath, path13);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -2031,18 +2031,18 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path12, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path13, "*"), handler);
     return this;
   }
-  #addRoute(method, path12, handler, baseRoutePath) {
-    path12 = mergePath(this._basePath, path12);
+  #addRoute(method, path13, handler, baseRoutePath) {
+    path13 = mergePath(this._basePath, path13);
     const r = {
       basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
-      path: path12,
+      path: path13,
       method,
       handler
     };
-    this.router.add(method, path12, [handler, r]);
+    this.router.add(method, path13, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -2055,10 +2055,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path12 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path12);
+    const path13 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path13);
     const c = new Context(request, {
-      path: path12,
+      path: path13,
       matchResult,
       env,
       executionCtx,
@@ -2161,7 +2161,7 @@ var createNullObject = () => /* @__PURE__ */ Object.create(null);
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
-function match(method, path12) {
+function match(method, path13) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -2177,7 +2177,7 @@ function match(method, path12) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path12);
+  return match2(method, path13);
 }
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -2294,14 +2294,14 @@ var Trie = class {
   #index = 0;
   // dynamic path -> [handler index, param assoc]; static paths are not registered
   paths = createNullObject();
-  insert(path12, isStatic) {
+  insert(path13, isStatic) {
     if (isStatic) {
-      this.#root.insert(path12.split(""), 0, [], this.#context, true);
+      this.#root.insert(path13.split(""), 0, [], this.#context, true);
       return;
     }
     const paramAssoc = [];
     const groups = [];
-    let markedPath = path12;
+    let markedPath = path13;
     for (let i = 0; ; ) {
       let replaced = false;
       markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
@@ -2326,7 +2326,7 @@ var Trie = class {
       }
     }
     this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
-    this.paths[path12] = [this.#index++, paramAssoc];
+    this.paths[path13] = [this.#index++, paramAssoc];
   }
   buildRegExp() {
     let regexp = this.#root.buildRegExpStr();
@@ -2353,17 +2353,17 @@ var Trie = class {
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/router.js
 var wildcardRegExpCache = createNullObject();
-function buildWildcardRegExp(path12) {
-  return wildcardRegExpCache[path12] ??= new RegExp(
-    `^${path12.replace(
+function buildWildcardRegExp(path13) {
+  return wildcardRegExpCache[path13] ??= new RegExp(
+    `^${path13.replace(
       /\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g,
       (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ONLY_WILDCARD_REG_EXP_STR : `/:${LABEL_REG_EXP_STR}`
     )}$`
   );
 }
-function findMiddleware(middleware, path12) {
+function findMiddleware(middleware, path13) {
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path12)) {
+    if (buildWildcardRegExp(k).test(path13)) {
       return [...middleware[k]];
     }
   }
@@ -2379,14 +2379,14 @@ var RegExpRouter = class {
     this.#routes = { [METHOD_NAME_ALL]: createNullObject() };
     this.#tries = { [METHOD_NAME_ALL]: new Trie() };
   }
-  #insertPath(method, path12) {
+  #insertPath(method, path13) {
     try {
-      this.#tries[method].insert(path12, !/\*|\/:/.test(path12));
+      this.#tries[method].insert(path13, !/\*|\/:/.test(path13));
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path12) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path13) : e;
     }
   }
-  add(method, path12, handler) {
+  add(method, path13, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware) {
@@ -2402,28 +2402,28 @@ var RegExpRouter = class {
         }
       }
     }
-    if (path12 === "/*") {
-      path12 = "*";
+    if (path13 === "/*") {
+      path13 = "*";
     }
     const methods = method === METHOD_NAME_ALL ? Object.keys(middleware) : [method];
-    if (/\*$/.test(path12)) {
-      const re = buildWildcardRegExp(path12);
+    if (/\*$/.test(path13)) {
+      const re = buildWildcardRegExp(path13);
       for (const m of methods) {
-        if (!middleware[m][path12]) {
-          this.#insertPath(m, path12);
-          middleware[m][path12] = findMiddleware(middleware[m], path12) || findMiddleware(middleware[METHOD_NAME_ALL], path12) || [];
+        if (!middleware[m][path13]) {
+          this.#insertPath(m, path13);
+          middleware[m][path13] = findMiddleware(middleware[m], path13) || findMiddleware(middleware[METHOD_NAME_ALL], path13) || [];
         }
       }
       for (const handlerMap of [middleware, routes]) {
         for (const m of methods) {
           for (const p in handlerMap[m]) {
-            re.test(p) && handlerMap[m][p].push([handler, path12]);
+            re.test(p) && handlerMap[m][p].push([handler, path13]);
           }
         }
       }
       return;
     }
-    const paths = checkOptionalParameter(path12) || [path12];
+    const paths = checkOptionalParameter(path13) || [path13];
     for (const path22 of paths) {
       for (const m of methods) {
         if (!routes[m][path22]) {
@@ -2452,11 +2452,11 @@ var RegExpRouter = class {
     const handlerData = [];
     const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
     for (const r of [middleware, routes]) {
-      for (const path12 in r) {
-        const handlers = r[path12];
-        const pathData = trie.paths[path12];
+      for (const path13 in r) {
+        const handlers = r[path13];
+        const pathData = trie.paths[path13];
         if (!pathData) {
-          staticMap[path12] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+          staticMap[path13] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
           continue;
         }
         handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [
@@ -2480,13 +2480,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path12, handler) {
+  add(method, path13, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path12, handler]);
+    this.#routes.push([method, path13, handler]);
   }
-  match(method, path12) {
+  match(method, path13) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -2501,7 +2501,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path12);
+        res = router.match(method, path13);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -2536,9 +2536,9 @@ var Node2 = class _Node2 {
   #patterns = [];
   #pattern;
   #params = emptyParams;
-  insert(method, path12, handler) {
+  insert(method, path13, handler) {
     let curNode = this;
-    const parts = splitRoutingPath(path12);
+    const parts = splitRoutingPath(path13);
     const possibleKeys = /* @__PURE__ */ new Set();
     let i = 0;
     for (const p of parts) {
@@ -2578,12 +2578,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path12) {
+  search(method, path13) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path12);
+    const parts = splitPath(path13);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -2625,13 +2625,13 @@ var Node2 = class _Node2 {
           if (matcher !== true) {
             if (!partOffsets) {
               partOffsets = [];
-              let offset = path12[0] === "/" ? 1 : 0;
+              let offset = path13[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path12.slice(partOffsets[i]);
+            const restPathString = path13.slice(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -2691,13 +2691,13 @@ var Node2 = class _Node2 {
 var TrieRouter = class {
   name = "TrieRouter";
   #node = new Node2();
-  add(method, path12, handler) {
-    for (const result of checkOptionalParameter(path12) || [path12]) {
+  add(method, path13, handler) {
+    for (const result of checkOptionalParameter(path13) || [path13]) {
       this.#node.insert(method, result, handler);
     }
   }
-  match(method, path12) {
-    return this.#node.search(method, path12);
+  match(method, path13) {
+    return this.#node.search(method, path13);
   }
 };
 
@@ -3416,13 +3416,14 @@ import { readFile as readFile2 } from "fs/promises";
 
 // packages/server/src/checkpoints.ts
 import path3 from "path";
-import { randomUUID } from "crypto";
-import { copyFile, mkdir as mkdir2, rm, stat as stat2, utimes } from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+import { copyFile, mkdir as mkdir2, rm, stat as stat2, utimes as utimes2 } from "fs/promises";
 
 // packages/server/src/state.ts
 import os from "os";
 import path2 from "path";
-import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { mkdir, open, readFile, rename, stat, unlink, utimes } from "fs/promises";
 
 // packages/server/src/hash.ts
 import { createHash } from "crypto";
@@ -3470,11 +3471,21 @@ var usableCheckpoint = (v) => {
   return !!c && typeof c === "object" && Number.isInteger(c.id) && typeof c.tree === "string" && (c.worktree === void 0 || typeof c.worktree === "string");
 };
 var usableComment = (v) => usable(v) && typeof v.anchor === "object" && !!v.anchor;
-function normalise(raw2, repoRoot) {
-  const base = defaultState(repoRoot);
-  if (!raw2 || typeof raw2 !== "object") return base;
+var SCHEMA_VERSION = 1;
+var KNOWN_KEYS = /* @__PURE__ */ new Set(["schemaVersion", "repoRoot", "targets", "todos", "checkpoints", "prefs", "issues"]);
+var StateTooNew = class extends HttpError {
+  constructor(file, version) {
+    super(409, `${file} was written by a newer warden (schema ${version}); upgrade warden to use it`, "state_too_new");
+  }
+};
+var NotAState = class extends Error {
+};
+function normalise(raw2, repoRoot, file) {
+  if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) throw new NotAState();
   const r = raw2;
-  if (r.schemaVersion !== 1) return base;
+  if (typeof r.schemaVersion !== "number") throw new NotAState();
+  if (r.schemaVersion > SCHEMA_VERSION) throw new StateTooNew(file, r.schemaVersion);
+  const extra = Object.fromEntries(Object.entries(r).filter(([k]) => !KNOWN_KEYS.has(k)));
   const targets = {};
   for (const [k, v] of Object.entries(r.targets ?? {})) {
     if (!v || typeof v !== "object") continue;
@@ -3486,7 +3497,8 @@ function normalise(raw2, repoRoot) {
   }
   migrateLocalViews(targets);
   return {
-    schemaVersion: 1,
+    ...extra,
+    schemaVersion: SCHEMA_VERSION,
     repoRoot: r.repoRoot ?? repoRoot,
     targets,
     // Issues were folded into todos (a todo links comments now); the few there were are let go,
@@ -3534,11 +3546,11 @@ var StateStore = class {
   async load() {
     try {
       const text = await readFile(this.file, "utf8");
-      return normalise(JSON.parse(text), this.repoRoot);
+      return normalise(JSON.parse(text), this.repoRoot, this.file);
     } catch (e) {
       const err = e;
       if (err.code === "ENOENT") return defaultState(this.repoRoot);
-      if (e instanceof SyntaxError) {
+      if (e instanceof SyntaxError || e instanceof NotAState) {
         try {
           await rename(this.file, `${this.file}.corrupt-${Date.now()}`);
         } catch {
@@ -3552,14 +3564,15 @@ var StateStore = class {
   update(fn) {
     const run2 = async () => {
       await mkdir(path2.dirname(this.file), { recursive: true });
-      const release = await this.acquireLock();
+      const lock = await this.acquireLock();
       try {
         const state = await this.load();
         const result = await fn(state);
+        if (!await lock.held()) throw new HttpError(409, "the state lock was taken over while this change was prepared; try again", "state_lock_lost");
         await this.writeAtomic(state);
         return result;
       } finally {
-        await release();
+        await lock.release();
       }
     };
     const p = this.queue.then(run2, run2);
@@ -3568,30 +3581,42 @@ var StateStore = class {
   }
   async writeAtomic(state) {
     const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", "utf8");
+    const fh = await open(tmp, "w");
+    try {
+      await fh.writeFile(JSON.stringify(state, null, 2) + "\n", "utf8");
+      await fh.sync();
+    } finally {
+      await fh.close();
+    }
     await rename(tmp, this.file);
   }
+  /**
+   * An exclusive lock file beside the state file, shared by every warden process and the agent
+   * CLI. It carries a token of its own, so a holder releases only the lock it took, and its mtime
+   * is refreshed while held: a lock left by a process that died goes stale and is taken over, one
+   * whose holder is merely slow does not.
+   */
   async acquireLock() {
     const lock = `${this.file}.lock`;
+    const token = `${process.pid}:${randomUUID()}`;
     const started = Date.now();
     for (; ; ) {
       try {
         const fh = await open(lock, "wx");
-        await fh.writeFile(String(process.pid));
+        await fh.writeFile(token);
         await fh.close();
-        return async () => {
-          try {
-            await unlink(lock);
-          } catch {
-          }
-        };
+        break;
       } catch (e) {
         const err = e;
         if (err.code !== "EEXIST") throw e;
         try {
           const st = await stat(lock);
           if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
-            await unlink(lock).catch(() => void 0);
+            const aside = `${lock}.stale-${token.replace(":", "-")}`;
+            await rename(lock, aside).then(
+              () => unlink(aside).catch(() => void 0),
+              () => void 0
+            );
             continue;
           }
         } catch {
@@ -3603,6 +3628,18 @@ var StateStore = class {
         await sleep(20);
       }
     }
+    const ours = async () => await readFile(lock, "utf8").catch(() => "") === token;
+    const beat = setInterval(() => {
+      void ours().then((mine) => mine ? utimes(lock, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date()).catch(() => void 0) : void 0);
+    }, LOCK_STALE_MS / 4);
+    beat.unref();
+    return {
+      held: ours,
+      release: async () => {
+        clearInterval(beat);
+        if (await ours()) await unlink(lock).catch(() => void 0);
+      }
+    };
   }
 };
 function forgetWorktreeTargets(state, worktreePath) {
@@ -3647,13 +3684,13 @@ async function withIndexCopy(cwd, store, fn) {
   await mkdir2(path3.join(store, "objects"), { recursive: true });
   await mkdir2(tmp, { recursive: true });
   const [objects, index] = await Promise.all([checkpointObjects(cwd, store), repoIndex(cwd)]);
-  const copy = path3.join(tmp, `index-${randomUUID()}`);
+  const copy = path3.join(tmp, `index-${randomUUID2()}`);
   try {
     const st = await stat2(index).catch(() => void 0);
     if (st) {
       await copyFile(index, copy);
       const earlier = Math.floor(st.mtimeMs / 1e3) - 1;
-      await utimes(copy, earlier, earlier);
+      await utimes2(copy, earlier, earlier);
     }
     return await fn({ ...objects, index: copy });
   } finally {
@@ -3697,7 +3734,9 @@ function addCheckpoint(state, worktree, tree, head, handoff = false) {
   const id = mine.reduce((n, c) => Math.max(n, c.id), 0) + 1;
   const checkpoint = { id, ...worktree ? { worktree } : {}, tree, head, createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...handoff ? { handoff } : {} };
   state.checkpoints.push(checkpoint);
-  for (const old of mine.slice(0, Math.max(0, mine.length + 1 - MAX_CHECKPOINTS))) forgetCheckpoint(state, old);
+  const evictable = mine.filter((c) => !state.targets[checkpointKey(c)]?.comments.length);
+  const excess = mine.length + 1 - MAX_CHECKPOINTS;
+  for (const old of evictable.slice(0, Math.max(0, excess))) forgetCheckpoint(state, old);
   return checkpoint;
 }
 async function takeCheckpoint(store, cwd, worktree, opts = {}) {
@@ -3962,7 +4001,8 @@ async function runDiff(ctx, args) {
   if (ctx.target.kind !== "checkpoint") return (await runGit(args, { cwd: ctx.cwd })).stdout;
   return withCheckpointIndex(ctx.cwd, checkpointOf(ctx).store, async (snapshot) => (await runGit(args, { cwd: ctx.cwd, snapshot })).stdout);
 }
-var DIFF_BASE_ARGS = ["diff", "--no-color", "--no-ext-diff", "-U3", "-M", "--find-renames"];
+var DIFF_OUTPUT_ARGS = ["--no-color", "--no-ext-diff", "--no-textconv", "--src-prefix=a/", "--dst-prefix=b/", "--submodule=short", "-U3"];
+var DIFF_BASE_ARGS = ["diff", ...DIFF_OUTPUT_ARGS, "-M", "--find-renames"];
 function resolveTargetContext(repo, worktrees, key) {
   let target;
   try {
@@ -3971,7 +4011,7 @@ function resolveTargetContext(repo, worktrees, key) {
     if (e instanceof TargetKeyError) throw badRequest(e.message, "invalid_target");
     throw e;
   }
-  let cwd = repo.root;
+  let cwd = repo.commonRoot;
   if (target.worktree) {
     const wt = worktrees.find((w) => w.path === target.worktree);
     if (!wt) throw badRequest(`unknown worktree: ${target.worktree}`, "unknown_worktree");
@@ -4031,7 +4071,7 @@ async function isUntracked(cwd, file) {
   return r.stdout.split("\0").filter(Boolean).includes(file);
 }
 async function untrackedDiff(cwd, file) {
-  const r = await runGit(["diff", "--no-color", "--no-ext-diff", "-U3", "--no-index", "--", "/dev/null", file], {
+  const r = await runGit(["diff", ...DIFF_OUTPUT_ARGS, "--no-index", "--", "/dev/null", file], {
     cwd,
     okCodes: [0, 1]
   });
@@ -4058,7 +4098,7 @@ async function mapLimit(items, limit, fn) {
 }
 async function listTargetDiffs(ctx) {
   const args = await diffArgs(ctx);
-  const files = parseUnifiedDiff(await runDiff(ctx, args));
+  const files = parseUnifiedDiff(await runDiff(ctx, [...args, "--"]));
   if (includesUntracked(ctx.target)) {
     const untracked = await listUntracked(ctx.cwd);
     const extra = await mapLimit(untracked, 8, (f) => untrackedDiff(ctx.cwd, f).catch(() => void 0));
@@ -4128,7 +4168,7 @@ async function pathsWithMarkers(ctx, side, paths) {
   const found = /* @__PURE__ */ new Set();
   if (paths.length === 0) return found;
   const ref = await refForSide(ctx, side);
-  const args = ["grep", "-l", "-z", "-I", "-i", "-F", ...DEBUG_MARKER_STRINGS.flatMap((m) => ["-e", m])];
+  const args = ["grep", "--no-color", "--no-recurse-submodules", "-l", "-z", "-I", "-i", "-F", ...DEBUG_MARKER_STRINGS.flatMap((m) => ["-e", m])];
   if (ref === void 0) args.push("--untracked");
   else if (ref === ":0") args.push("--cached");
   else args.push(ref);
@@ -4444,6 +4484,39 @@ async function listUpstreams(ctx) {
   }
   return out;
 }
+async function commonDirOf(dir) {
+  try {
+    const r = await runGit(["rev-parse", "--show-toplevel", "--git-common-dir"], { cwd: dir });
+    const [top, common] = r.stdout.trim().split("\n");
+    if (!top || !common || await realpath2(top) !== await realpath2(dir)) return void 0;
+    return await realpath2(path5.resolve(dir, common));
+  } catch {
+    return void 0;
+  }
+}
+var IN_PROGRESS = [
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase"],
+  ["MERGE_HEAD", "merge"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"],
+  ["BISECT_LOG", "bisect"]
+];
+async function checkoutState(ctx, dir) {
+  const [ours, theirs] = await Promise.all([commonDirOf(ctx.commonRoot), commonDirOf(dir)]);
+  if (!ours || ours !== theirs) return { foreign: true };
+  const r = await runGit(["rev-parse", ...IN_PROGRESS.flatMap(([f]) => ["--git-path", f])], { cwd: dir });
+  const paths = r.stdout.trim().split("\n");
+  for (const [i, [, what]] of IN_PROGRESS.entries()) {
+    const p = paths[i];
+    if (p && await stat3(path5.resolve(dir, p)).then(
+      () => true,
+      () => false
+    ))
+      return { foreign: false, busy: what };
+  }
+  return { foreign: false };
+}
 async function listWorktreesDetailed(ctx) {
   const [all, upstreams] = await Promise.all([listWorktreesAll(ctx), listUpstreams(ctx)]);
   const main2 = all.find((w) => w.isMain);
@@ -4451,12 +4524,16 @@ async function listWorktreesDetailed(ctx) {
     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 state = slot === void 0 || w.prunable ? { foreign: false } : await checkoutState(ctx, 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
+        ...state.foreign ? { foreign: true } : {},
+        ...state.busy ? { busy: state.busy } : {},
+        // Free is what the next checkout may take over: a detached HEAD, nothing that would be lost,
+        // nothing stopped halfway, and a checkout that is this repository's own.
+        free: slot !== void 0 && !w.prunable && w.detached && dirty === 0 && !state.foreign && !state.busy
       };
       if (detail.free) return detail;
       const upstream = w.branch ? upstreams.get(w.branch) : void 0;
@@ -4524,6 +4601,8 @@ async function pickSlot(ctx, worktrees, wanted) {
   }
   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?.foreign) throw new HttpError(409, `${have.path} is not a checkout of this repository`, "not_our_checkout");
+  if (have?.busy) throw new HttpError(409, `a ${have.busy} is in progress in slot ${wanted}`, "operation_in_progress");
   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);
@@ -4604,6 +4683,9 @@ async function releaseWorktree(ctx, req) {
   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 state = await checkoutState(ctx, wt.path);
+  if (state.foreign) throw new HttpError(409, `${wt.path} is not a checkout of this repository; warden will not write in it`, "not_our_checkout");
+  if (state.busy) throw new HttpError(409, `a ${state.busy} is in progress in ${wt.path}; finish or abort it first`, "operation_in_progress");
   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) {
@@ -4618,6 +4700,10 @@ async function removeWorktree(ctx, req) {
   const wt = (await listWorktreesAll(ctx)).find((w) => w.path === p || p && w.path === path5.resolve(p));
   if (!wt) throw badRequest(`unknown worktree: ${p}`, "unknown_worktree");
   if (wt.isMain) throw badRequest("the main worktree cannot be removed", "main_worktree");
+  if (!wt.prunable && !req.force) {
+    const state = await checkoutState(ctx, wt.path);
+    if (state.busy) throw new HttpError(409, `a ${state.busy} is in progress in ${wt.path}; removing it throws that away`, "needs_force");
+  }
   const args = ["worktree", "remove"];
   if (req.force) args.push("--force");
   args.push(wt.path);
@@ -4717,7 +4803,7 @@ function formatTodoExport({ todo, comments, replyCommand }) {
 
 // packages/server/src/feedback.ts
 import { realpath as realpath3 } from "fs/promises";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 async function real(p) {
   try {
     return await realpath3(p);
@@ -4782,7 +4868,7 @@ async function addReply(store, ref, author, body) {
   return store.update((s) => {
     const { list, index } = locate(s, ref);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const reply2 = { id: randomUUID2(), author, body: body.trim(), at: now };
+    const reply2 = { id: randomUUID3(), author, body: body.trim(), at: now };
     const prev = list[index];
     const next = { ...prev, replies: [...prev.replies ?? [], reply2], updatedAt: now };
     if (author === "reviewer") {
@@ -4861,6 +4947,11 @@ async function findSockets(dirs = socketDirs()) {
   for (const d of dirs) await visit(d, 0);
   return [...found.entries()].map(([socket, pid]) => ({ socket, pid }));
 }
+function chooseNvim(matching, wanted) {
+  for (const w of wanted) if (w && matching.some((i) => i.socket === w)) return { socket: w };
+  if (matching.length === 1) return { socket: matching[0].socket };
+  return { error: matching.length ? "ambiguous" : "none" };
+}
 var NvimService = class {
   constructor(dirs) {
     this.dirs = dirs;
@@ -4915,6 +5006,7 @@ var NvimService = class {
 
 // packages/server/src/tmux.ts
 import { execFile as execFile3 } from "child_process";
+import path7 from "path";
 import { realpath as realpath4 } 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) => {
@@ -4925,34 +5017,48 @@ var runTmux = (args) => new Promise((resolve, reject) => {
     );
   });
 });
+function sessionNameFor(worktreePath) {
+  return path7.basename(worktreePath).replace(/[.:#]/g, "_") || "warden";
+}
 var TmuxService = class {
   constructor(run2 = runTmux) {
     this.run = run2;
   }
   run;
-  async sessions(mainRoot) {
-    const root = await realpath4(mainRoot);
-    const output = await this.run(["list-sessions", "-F", "#{session_id}	#{session_name}	#{session_path}"]);
+  async list() {
+    const output = await this.run(["list-sessions", "-F", "#{session_id}	#{session_name}	#{session_path}"]).catch((e) => {
+      if (e instanceof HttpError && /no server running|error connecting/i.test(e.message)) return "";
+      throw e;
+    });
     const sessions = [];
     for (const line of output.trimEnd().split("\n")) {
       const [id, name, ...parts] = line.split("	");
-      const path12 = parts.join("	");
-      if (!id || !/^\$\d+$/.test(id) || !name || !path12) continue;
-      if (await realpath4(path12).catch(() => null) === root) sessions.push({ id, name, path: path12 });
+      const dir = parts.join("	");
+      if (!id || !/^\$\d+$/.test(id) || !name || !dir) continue;
+      sessions.push({ id, name, path: dir });
     }
     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");
+  /**
+   * A detached session in the worktree, named after its directory, with a shell and nothing run in
+   * it. One already there for the same directory is handed back rather than doubled; one of that
+   * name elsewhere is refused, not replaced — it is someone's work.
+   */
+  async openSession(worktreePath) {
     const directory = await realpath4(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 };
+    const name = sessionNameFor(directory);
+    const existing = (await this.list()).find((x) => x.name === name);
+    if (existing) {
+      if (await realpath4(existing.path).catch(() => null) === directory) return { session: name, created: false };
+      throw new HttpError(409, `\u5DF2\u6709\u540C\u540D tmux session ${name}\uFF0C\u5DE5\u4F5C\u76EE\u5F55\u662F ${existing.path}`, "tmux_name_taken");
+    }
+    await this.run(["new-session", "-d", "-s", name, "-c", directory.replaceAll("#", "##")]);
+    return { session: name, created: true };
   }
 };
 
 // packages/server/src/watcher.ts
-import path7 from "path";
+import path8 from "path";
 import { stat as stat5 } from "fs/promises";
 var DEFAULT_POLL_INTERVAL_MS = 1500;
 function statusPaths(out) {
@@ -5049,7 +5155,7 @@ var RepoWatcher = class {
     const stats = await Promise.all(
       statusPaths(statusRes.stdout).map(async (rel) => {
         try {
-          const st = await stat5(path7.join(this.root, rel));
+          const st = await stat5(path8.join(this.root, rel));
           return `${rel}	${st.mtimeMs}	${st.size}`;
         } catch {
           return `${rel}	-`;
@@ -5061,7 +5167,7 @@ var RepoWatcher = class {
 };
 
 // packages/server/src/static.ts
-import path8 from "path";
+import path9 from "path";
 import { readFile as readFile3, stat as stat6 } from "fs/promises";
 var MIME = {
   ".html": "text/html; charset=utf-8",
@@ -5079,20 +5185,20 @@ var MIME = {
   ".txt": "text/plain; charset=utf-8"
 };
 async function serveStaticFile(c, webDir) {
-  const root = path8.resolve(webDir);
+  const root = path9.resolve(webDir);
   let rel;
   try {
     rel = decodeURIComponent(c.req.path);
   } catch {
     return c.text("Bad Request", 400);
   }
-  let target = path8.resolve(root, "." + rel);
-  if (target !== root && !target.startsWith(root + path8.sep)) return c.text("Forbidden", 403);
+  let target = path9.resolve(root, "." + rel);
+  if (target !== root && !target.startsWith(root + path9.sep)) return c.text("Forbidden", 403);
   try {
     const st = await stat6(target);
-    if (st.isDirectory()) target = path8.join(target, "index.html");
+    if (st.isDirectory()) target = path9.join(target, "index.html");
   } catch {
-    target = path8.join(root, "index.html");
+    target = path9.join(root, "index.html");
   }
   let body;
   try {
@@ -5100,7 +5206,7 @@ async function serveStaticFile(c, webDir) {
   } catch {
     return c.text("Not Found", 404);
   }
-  const ext = path8.extname(target).toLowerCase();
+  const ext = path9.extname(target).toLowerCase();
   const isAsset = rel.startsWith("/assets/");
   return new Response(new Uint8Array(body), {
     status: 200,
@@ -5172,8 +5278,8 @@ function createApp(opts) {
   const checkpointHandoff = (comments) => {
     const worktrees2 = new Set(comments.map((x) => tryParseTargetKey(x.targetKey)?.worktree));
     for (const wt of worktrees2) {
-      takeCheckpoint(store, wt ?? repo.root, wt, { handoff: true }).catch((e) => {
-        console.error(`warden: no checkpoint for the comments handed over in ${wt ?? repo.root}: ${e instanceof Error ? e.message : e}`);
+      takeCheckpoint(store, wt ?? repo.commonRoot, wt, { handoff: true }).catch((e) => {
+        console.error(`warden: no checkpoint for the comments handed over in ${wt ?? repo.commonRoot}: ${e instanceof Error ? e.message : e}`);
       });
     }
   };
@@ -5218,16 +5324,21 @@ function createApp(opts) {
   api.get("/ping", (c) => c.text(opts.instanceToken ?? ""));
   api.get("/repo", async (c) => {
     const state = await store.load();
-    const info = await getRepoInfo(repo, "working");
+    const own = repo.root === repo.commonRoot ? "working" : formatTargetKey({ kind: "working", worktree: repo.root });
+    const info = await getRepoInfo(repo, own);
     worktreeCache = { at: Date.now(), list: info.worktrees };
     const last = state.prefs.lastTarget;
     const target = last ? tryParseTargetKey(last) : void 0;
-    const usable2 = !!target && (!target.worktree || info.worktrees.some((w) => w.path === target.worktree)) && (target.kind !== "checkpoint" || !!findCheckpoint(state, target.worktree, target.id));
+    const usable2 = !!target && (!target.worktree || info.worktrees.some((w) => w.path === target.worktree)) && // A server started in a linked worktree is there to review that one, not whatever the main
+    // worktree's page last looked at: the preference is shared by every server on the repository.
+    (repo.root === repo.commonRoot || target.worktree === repo.root) && (target.kind !== "checkpoint" || !!findCheckpoint(state, target.worktree, target.id));
     if (last && usable2) info.defaultTarget = last;
     else if (last) {
-      await store.update((s) => {
-        s.prefs.lastTarget = "working";
-      });
+      if (repo.root === repo.commonRoot) {
+        await store.update((s) => {
+          s.prefs.lastTarget = "working";
+        });
+      }
     }
     return c.json(info);
   });
@@ -5383,7 +5494,7 @@ function createApp(opts) {
     if (!anchored) throw badRequest("selection is not fully visible in the diff on that side (must be inside one hunk)", "bad_selection");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const comment = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       targetKey: key,
       filePath: body.filePath,
       side: body.side,
@@ -5507,7 +5618,6 @@ function createApp(opts) {
     const comments = state.targets[scope]?.comments ?? [];
     const prevHead = state.targets[scope]?.head;
     const head = await revParse(ctx.cwd, "HEAD") ?? "";
-    const committed = local && prevHead !== void 0 && prevHead !== head;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const located = /* @__PURE__ */ new Map();
     await Promise.all(
@@ -5531,6 +5641,19 @@ function createApp(opts) {
         }
       })
     );
+    const landed = /* @__PURE__ */ new Set();
+    const lost = comments.filter((cm) => !located.has(cm.id));
+    if (local && lost.length && prevHead && head && prevHead !== head && await mergeBase(ctx.cwd, prevHead, head) === prevHead) {
+      const range = await worktreeCtx(
+        formatTargetKey({ kind: "range", base: prevHead, head, ...ctx.target.worktree ? { worktree: ctx.target.worktree } : {} })
+      );
+      await Promise.all(
+        lost.map(async (cm) => {
+          const committedDiff = await getFileDiff(range, cm.filePath).catch(() => void 0);
+          if (committedDiff && reanchorComment(cm, committedDiff, now).status !== "orphaned") landed.add(cm.id);
+        })
+      );
+    }
     const result = await store.update((s) => {
       const t = ensureTarget(s, scope);
       const dropped = [];
@@ -5538,7 +5661,7 @@ function createApp(opts) {
         const patch = located.get(cm.id);
         if (!patch) {
           if (!comments.some((x) => x.id === cm.id)) return [cm];
-          if (committed && !cm.replies?.length) {
+          if (landed.has(cm.id) && !cm.replies?.length) {
             dropped.push(cm.id);
             return [];
           }
@@ -5602,7 +5725,7 @@ function createApp(opts) {
     const branch = body.branch?.trim() || await currentBranch(await knownRoot(body.root));
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const todo = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       branch,
       title: body.title.trim(),
       body: typeof body.body === "string" ? body.body : "",
@@ -5705,13 +5828,14 @@ function createApp(opts) {
     if (ref && !isValidRef(ref)) throw badRequest("invalid ref");
     if (filePath && (filePath.startsWith("/") || filePath.split("/").includes(".."))) throw badRequest("invalid path");
     if (q.length > 200 || author.length > 200) throw badRequest("search text too long");
-    const args = ["log", `--max-count=${limit + 1}`, `--skip=${offset}`, `--format=${COMMIT_FORMAT}`];
+    const args = ["log", "--no-show-signature", `--max-count=${limit + 1}`, `--skip=${offset}`, `--format=${COMMIT_FORMAT}`];
     if (firstParent) args.push("--first-parent");
     if (q || author) args.push("--fixed-strings", "--regexp-ignore-case");
     if (q) args.push(`--grep=${q}`);
     if (author) args.push(`--author=${author}`);
     if (ref) args.push(ref);
-    if (filePath) args.push("--", filePath);
+    args.push("--");
+    if (filePath) args.push(literal(filePath));
     let stdout = "";
     try {
       stdout = (await runGit(args, { cwd })).stdout;
@@ -5725,7 +5849,7 @@ function createApp(opts) {
     if (q && offset === 0 && /^[0-9a-f]{4,40}$/i.test(q)) {
       const sha = await revParse(cwd, `${q}^{commit}`);
       if (sha && !commits.some((x) => x.sha === sha)) {
-        const hit = parseCommitLog((await runGit(["log", "--max-count=1", `--format=${COMMIT_FORMAT}`, sha], { cwd })).stdout)[0];
+        const hit = parseCommitLog((await runGit(["log", "--no-show-signature", "--max-count=1", `--format=${COMMIT_FORMAT}`, sha, "--"], { cwd })).stdout)[0];
         if (hit) commits = [hit, ...commits];
       }
     }
@@ -5744,13 +5868,13 @@ function createApp(opts) {
     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) => {
+  api.post("/tmux/sessions", 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");
+    if (!body || typeof body.path !== "string") throw badRequest("path is 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);
+    const res = await tmux.openSession(wt.path);
+    return c.json(res, res.created ? 201 : 200);
   });
   api.get("/worktrees", async (c) => {
     const [list, state] = await Promise.all([listWorktreesDetailed(repo), store.load()]);
@@ -5759,7 +5883,7 @@ function createApp(opts) {
     const latest = /* @__PURE__ */ new Map();
     for (const t of Object.values(state.targets)) {
       for (const cm of t.comments) {
-        const at = commentWorktree(cm) ?? repo.root;
+        const at = commentWorktree(cm) ?? repo.commonRoot;
         const r = review.get(at) ?? { toAgent: 0, toReviewer: 0 };
         const seen = latest.get(at) ?? { agent: "", reviewer: "" };
         if (awaitsAgent(cm)) {
@@ -5785,12 +5909,18 @@ function createApp(opts) {
     const res = { remotes: await lookupRemoteBranches(repo, c.req.query("branch") ?? "") };
     return c.json(res);
   });
+  let worktreeWrites = Promise.resolve();
+  const oneAtATime = (fn) => {
+    const run2 = worktreeWrites.then(fn, fn);
+    worktreeWrites = run2.catch(() => void 0);
+    return run2;
+  };
   api.post("/worktrees", async (c) => {
     const body = await c.req.json();
     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");
     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);
+    const res = await oneAtATime(() => checkoutWorktree(repo, body));
     worktreeCache = null;
     await store.update((s) => forgetWorktreeTargets(s, res.worktree.path));
     return c.json(res, 201);
@@ -5798,14 +5928,14 @@ function createApp(opts) {
   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);
+    const res = await oneAtATime(() => releaseWorktree(repo, body));
     worktreeCache = null;
     return c.json(res);
   });
   api.post("/worktrees/remove", async (c) => {
     const body = await c.req.json();
     if (typeof body.path !== "string") throw badRequest("path is required");
-    const res = await removeWorktree(repo, body);
+    const res = await oneAtATime(() => removeWorktree(repo, body));
     worktreeCache = null;
     return c.json(res);
   });
@@ -5856,9 +5986,8 @@ function createApp(opts) {
     const instances = NvimService.matching(scan.instances, root);
     const state = await store.load();
     const preferred = state.prefs.nvimSocketByRoot[root];
-    let selected;
-    if (preferred && instances.some((i) => i.socket === preferred)) selected = preferred;
-    else if (instances.length === 1) selected = instances[0].socket;
+    const choice = chooseNvim(instances, [preferred]);
+    const selected = "socket" in choice ? choice.socket : void 0;
     const res = { root, nvimAvailable: scan.nvimAvailable, instances, selected, scannedAt: scan.scannedAt };
     return c.json(res);
   });
@@ -5872,19 +6001,38 @@ function createApp(opts) {
   });
   api.post("/nvim/open", async (c) => {
     const body = await c.req.json();
-    if (!body.socket || !body.absPath) throw badRequest("socket and absPath are required");
-    if (!path9.isAbsolute(body.absPath)) throw badRequest("absPath must be absolute");
-    const scan = await nvim.scan();
-    if (!scan.instances.some((i) => i.socket === body.socket)) {
-      const fresh = await nvim.scan(true);
-      if (!fresh.instances.some((i) => i.socket === body.socket)) throw badRequest("nvim instance not found (rescan)", "nvim_gone");
+    if (!body.absPath) throw badRequest("absPath is required");
+    if (!path10.isAbsolute(body.absPath)) throw badRequest("absPath must be absolute");
+    const root = await knownRoot(body.root);
+    const wanted = [body.socket, (await store.load()).prefs.nvimSocketByRoot[root]];
+    const line = Number(body.line) || 1;
+    const pick = async (force) => {
+      const scan = await nvim.scan(force);
+      if (!scan.nvimAvailable) throw badRequest("nvim is not on PATH", "nvim_unavailable");
+      return { matching: NvimService.matching(scan.instances, root), choice: chooseNvim(NvimService.matching(scan.instances, root), wanted) };
+    };
+    let { choice } = await pick(false);
+    if ("error" in choice) choice = (await pick(true)).choice;
+    if ("error" in choice) {
+      if (choice.error === "none") throw notFound(`no nvim is open inside ${root}`, "nvim_none");
+      throw new HttpError(409, `several nvim instances are open inside ${root}; select one`, "nvim_ambiguous");
     }
     try {
-      await nvim.open(body.socket, body.absPath, Number(body.line) || 1);
+      await nvim.open(choice.socket, body.absPath, line);
+      const res = { ok: true, socket: choice.socket };
+      return c.json(res);
     } catch (e) {
-      throw new HttpError(502, e instanceof Error ? e.message : String(e), "nvim_failed");
+      const failure = new HttpError(502, e instanceof Error ? e.message : String(e), "nvim_failed");
+      const fresh = await pick(true);
+      if (fresh.matching.some((i) => i.socket === choice.socket) || "error" in fresh.choice) throw failure;
+      try {
+        await nvim.open(fresh.choice.socket, body.absPath, line);
+      } catch (e2) {
+        throw new HttpError(502, e2 instanceof Error ? e2.message : String(e2), "nvim_failed");
+      }
+      const res = { ok: true, socket: fresh.choice.socket };
+      return c.json(res);
     }
-    return c.json({ ok: true });
   });
   app.route("/api", api);
   app.notFound((c) => {
@@ -5933,14 +6081,14 @@ function reachableFromWindows(port, token, timeoutMs = PROBE_TIMEOUT_MS) {
 }
 
 // packages/server/src/update.ts
-import path10 from "path";
-import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import path11 from "path";
+import { mkdir as mkdir3, readFile as readFile5, writeFile } from "fs/promises";
 var PACKAGE = "@xbghc/warden";
 var LATEST_URL = "https://registry.npmjs.org/@xbghc%2fwarden/latest";
 var FETCH_TIMEOUT_MS = 3e3;
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 function updateCacheFile(baseDir = dataDir()) {
-  return path10.join(baseDir, "update-check.json");
+  return path11.join(baseDir, "update-check.json");
 }
 function updateCheckEnabled(env = process.env) {
   return !env.WARDEN_NO_UPDATE_CHECK && !env.NO_UPDATE_NOTIFIER && !env.CI;
@@ -5974,8 +6122,8 @@ async function readCache(file, now) {
 }
 async function writeCache(file, cache) {
   try {
-    await mkdir3(path10.dirname(file), { recursive: true });
-    await writeFile2(file, JSON.stringify(cache));
+    await mkdir3(path11.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(cache));
   } catch {
   }
 }
@@ -6019,7 +6167,7 @@ async function startServer(opts) {
   const repo = await resolveRepo(opts.repoPath);
   const stateFile = opts.stateFile ?? stateFilePath(repo.commonRoot);
   const store = new StateStore(stateFile, repo.commonRoot);
-  const instanceToken = randomUUID4();
+  const instanceToken = randomUUID5();
   const app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir, instanceToken, update: opts.update, replyCommand: opts.replyCommand });
   const listen = (p) => new Promise((resolve, reject) => {
     const s = serve({ fetch: app.fetch, hostname: HOST, port: p }, () => resolve(s));
@@ -6123,7 +6271,7 @@ async function runAgentCommand(argv, replyCommand) {
 }
 
 // bin/cli.ts
-var VERSION = true ? "0.16.0" : "dev";
+var VERSION = true ? "0.16.1" : "dev";
 function parseArgs(argv) {
   const args = { repoPath: process.cwd(), open: true, updateCheck: true, help: false, version: false };
   for (let i = 0; i < argv.length; i++) {
@@ -6142,11 +6290,11 @@ function parseArgs(argv) {
     } else if (a === "--help" || a === "-h") args.help = true;
     else if (a === "--version" || a === "-v") args.version = true;
     else if (a.startsWith("-")) throw new Error(`unknown option: ${a}`);
-    else args.repoPath = path11.resolve(a);
+    else args.repoPath = path12.resolve(a);
   }
   return args;
 }
-var viaNpx = fileURLToPath(import.meta.url).includes(`${path11.sep}_npx${path11.sep}`);
+var viaNpx = fileURLToPath(import.meta.url).includes(`${path12.sep}_npx${path12.sep}`);
 var selfCommand = viaNpx ? "npx @xbghc/warden" : "warden";
 function usage() {
   return `warden \u2014 local git diff review UI
@@ -6193,16 +6341,16 @@ async function openBrowser(url) {
   return false;
 }
 function resolveWebDir() {
-  const here = path11.dirname(fileURLToPath(import.meta.url));
+  const here = path12.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     process.env.WARDEN_WEB_DIR,
-    path11.join(here, "web"),
+    path12.join(here, "web"),
     // dist/cli.js -> dist/web
-    path11.join(here, "..", "dist", "web")
+    path12.join(here, "..", "dist", "web")
     // bin/cli.ts (tsx dev) -> dist/web
   ].filter((p) => !!p);
   for (const dir of candidates) {
-    if (existsSync2(path11.join(dir, "index.html"))) return dir;
+    if (existsSync2(path12.join(dir, "index.html"))) return dir;
   }
   return void 0;
 }