@xbghc/warden 0.15.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 randomUUID3 } 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,8 +652,9 @@ var serve = (options, listeningListener) => {
 };
 
 // packages/server/src/app.ts
-import path9 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import path10 from "path";
+import { stat as stat7 } from "fs/promises";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
@@ -812,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--) {
@@ -888,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;
     }
@@ -906,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) => {
@@ -1052,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) {
@@ -1826,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();
@@ -1885,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) {
@@ -1912,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;
   }
   /**
@@ -1988,7 +1989,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path12, applicationHandler, options) {
+  mount(path13, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -2015,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);
@@ -2030,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) {
@@ -2054,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,
@@ -2160,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];
@@ -2176,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
@@ -2293,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) => {
@@ -2325,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();
@@ -2352,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]];
     }
   }
@@ -2378,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) {
@@ -2401,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]) {
@@ -2451,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]) => [
@@ -2479,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");
     }
@@ -2500,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;
@@ -2535,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) {
@@ -2577,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;
@@ -2624,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];
@@ -2690,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);
   }
 };
 
@@ -3000,6 +3001,17 @@ function moveBefore(list, id, before) {
   return rest;
 }
 
+// packages/shared/src/comments.ts
+function commentWorktree(c) {
+  return tryParseTargetKey(c.targetKey)?.worktree;
+}
+function awaitsAgent(c) {
+  return !c.exportedAt;
+}
+function awaitsReviewer(c) {
+  return c.replies?.at(-1)?.author === "agent";
+}
+
 // packages/server/src/errors.ts
 var HttpError = class extends Error {
   constructor(status, message, code) {
@@ -3399,39 +3411,286 @@ async function getRepoInfo(ctx, defaultTarget) {
 }
 
 // packages/server/src/targets.ts
-import path3 from "path";
-import { readFile } from "fs/promises";
+import path4 from "path";
+import { readFile as readFile2 } from "fs/promises";
 
 // packages/server/src/checkpoints.ts
+import path3 from "path";
+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 { randomUUID } from "crypto";
-import { copyFile, mkdir, rm, stat, utimes } from "fs/promises";
+import { mkdir, open, readFile, rename, stat, unlink, utimes } from "fs/promises";
+
+// packages/server/src/hash.ts
+import { createHash } from "crypto";
+function sha1(input) {
+  return createHash("sha1").update(input).digest("hex");
+}
+function lineHash(content) {
+  return sha1(content.trimEnd());
+}
+function hunkHash(lineContents) {
+  return sha1(
+    lineContents.map((l) => l.trimEnd()).join("\n").trim()
+  );
+}
+
+// packages/server/src/state.ts
+function dataDir() {
+  const xdg = process.env.XDG_DATA_HOME;
+  const base = xdg?.trim() ? xdg : path2.join(os.homedir(), ".local", "share");
+  return path2.join(base, "warden");
+}
+function repoHash(repoRoot) {
+  return sha1(repoRoot).slice(0, 12);
+}
+function stateFilePath(repoRoot, baseDir = dataDir()) {
+  return path2.join(baseDir, repoHash(repoRoot), "state.json");
+}
+function defaultPrefs() {
+  return { viewMode: "unified", nvimSocketByRoot: {}, autoRefresh: true, railOpen: false, ignoreDebug: true };
+}
+function defaultState(repoRoot) {
+  return { schemaVersion: 1, repoRoot, targets: {}, todos: [], checkpoints: [], prefs: defaultPrefs() };
+}
+function ensureTarget(state, key) {
+  let t = state.targets[key];
+  if (!t) {
+    t = { viewed: {}, comments: [] };
+    state.targets[key] = t;
+  }
+  return t;
+}
+var usable = (v) => !!v && typeof v === "object" && typeof v.id === "string";
+var usableCheckpoint = (v) => {
+  const c = 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;
+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 (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;
+    targets[k] = {
+      viewed: typeof v.viewed === "object" && v.viewed ? v.viewed : {},
+      comments: Array.isArray(v.comments) ? v.comments.filter(usableComment) : [],
+      ...typeof v.head === "string" ? { head: v.head } : {}
+    };
+  }
+  migrateLocalViews(targets);
+  return {
+    ...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,
+    // and the next write leaves them out of the file.
+    todos: Array.isArray(r.todos) ? r.todos.filter(usable) : [],
+    checkpoints: Array.isArray(r.checkpoints) ? r.checkpoints.filter(usableCheckpoint) : [],
+    prefs: {
+      ...defaultPrefs(),
+      ...r.prefs ?? {},
+      nvimSocketByRoot: r.prefs?.nvimSocketByRoot ?? {},
+      autoRefresh: typeof r.prefs?.autoRefresh === "boolean" ? r.prefs.autoRefresh : true,
+      railOpen: typeof r.prefs?.railOpen === "boolean" ? r.prefs.railOpen : false,
+      ignoreDebug: typeof r.prefs?.ignoreDebug === "boolean" ? r.prefs.ignoreDebug : true
+    }
+  };
+}
+function migrateLocalViews(targets) {
+  for (const key of Object.keys(targets).sort()) {
+    const scope = commentScopeKey(key);
+    if (scope === key) continue;
+    const src = targets[key];
+    delete targets[key];
+    if (src.comments.length === 0) continue;
+    let dst = targets[scope];
+    if (!dst) {
+      dst = { viewed: {}, comments: [] };
+      targets[scope] = dst;
+    }
+    dst.comments.push(...src.comments);
+  }
+}
+var LOCK_STALE_MS = 5e3;
+var LOCK_WAIT_MS = 5e3;
+async function sleep(ms) {
+  await new Promise((r) => setTimeout(r, ms));
+}
+var StateStore = class {
+  constructor(file, repoRoot) {
+    this.file = file;
+    this.repoRoot = repoRoot;
+  }
+  file;
+  repoRoot;
+  queue = Promise.resolve();
+  async load() {
+    try {
+      const text = await readFile(this.file, "utf8");
+      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 || e instanceof NotAState) {
+        try {
+          await rename(this.file, `${this.file}.corrupt-${Date.now()}`);
+        } catch {
+        }
+        return defaultState(this.repoRoot);
+      }
+      throw e;
+    }
+  }
+  /** Apply a mutation under lock. The callback receives the freshest on-disk state. */
+  update(fn) {
+    const run2 = async () => {
+      await mkdir(path2.dirname(this.file), { recursive: true });
+      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 lock.release();
+      }
+    };
+    const p = this.queue.then(run2, run2);
+    this.queue = p.catch(() => void 0);
+    return p;
+  }
+  async writeAtomic(state) {
+    const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+    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(token);
+        await fh.close();
+        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) {
+            const aside = `${lock}.stale-${token.replace(":", "-")}`;
+            await rename(lock, aside).then(
+              () => unlink(aside).catch(() => void 0),
+              () => void 0
+            );
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        if (Date.now() - started > LOCK_WAIT_MS) {
+          throw new Error(`timed out waiting for state lock ${lock}`);
+        }
+        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) {
+  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];
+  }
+  unlinkComments(state, gone);
+  state.checkpoints = state.checkpoints.filter((c) => c.worktree !== worktreePath);
+}
+function unlinkComments(state, ids) {
+  const gone = new Set(ids);
+  if (gone.size === 0) return;
+  for (const todo of state.todos) {
+    if (!todo.commentIds?.some((id) => gone.has(id))) continue;
+    const kept = todo.commentIds.filter((id) => !gone.has(id));
+    if (kept.length) todo.commentIds = kept;
+    else delete todo.commentIds;
+  }
+}
+
+// packages/server/src/checkpoints.ts
 function checkpointStore(stateFile) {
-  return path2.join(path2.dirname(stateFile), "checkpoints");
+  return path3.join(path3.dirname(stateFile), "checkpoints");
 }
 async function repoObjects(cwd) {
   const r = await runGit(["rev-parse", "--git-path", "objects"], { cwd });
-  return path2.resolve(cwd, r.stdout.trim());
+  return path3.resolve(cwd, r.stdout.trim());
 }
 async function repoIndex(cwd) {
   const r = await runGit(["rev-parse", "--git-path", "index"], { cwd });
-  return path2.resolve(cwd, r.stdout.trim());
+  return path3.resolve(cwd, r.stdout.trim());
 }
 async function checkpointObjects(cwd, store) {
-  return { objects: path2.join(store, "objects"), alternates: await repoObjects(cwd) };
+  return { objects: path3.join(store, "objects"), alternates: await repoObjects(cwd) };
 }
 async function withIndexCopy(cwd, store, fn) {
-  const tmp = path2.join(store, "tmp");
-  await mkdir(path2.join(store, "objects"), { recursive: true });
-  await mkdir(tmp, { recursive: true });
+  const tmp = path3.join(store, "tmp");
+  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 = path2.join(tmp, `index-${randomUUID()}`);
+  const copy = path3.join(tmp, `index-${randomUUID2()}`);
   try {
-    const st = await stat(index).catch(() => void 0);
+    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 {
@@ -3468,29 +3727,26 @@ function forgetCheckpoint(state, c) {
   const key = checkpointKey(c);
   const gone = new Set((state.targets[key]?.comments ?? []).map((x) => x.id));
   delete state.targets[key];
-  if (gone.size) for (const issue of state.issues) issue.commentIds = issue.commentIds.filter((id) => !gone.has(id));
+  unlinkComments(state, gone);
 }
-function addCheckpoint(state, worktree, tree, head) {
+function addCheckpoint(state, worktree, tree, head, handoff = false) {
   const mine = checkpointsOf(state, worktree);
   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() };
+  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;
 }
-
-// packages/server/src/hash.ts
-import { createHash } from "crypto";
-function sha1(input) {
-  return createHash("sha1").update(input).digest("hex");
-}
-function lineHash(content) {
-  return sha1(content.trimEnd());
-}
-function hunkHash(lineContents) {
-  return sha1(
-    lineContents.map((l) => l.trimEnd()).join("\n").trim()
-  );
+async function takeCheckpoint(store, cwd, worktree, opts = {}) {
+  const tree = await snapshotWorktree(cwd, checkpointStore(store.file));
+  const head = await revParse(cwd, "HEAD") ?? "";
+  return store.update((s) => {
+    const newest = checkpointsOf(s, worktree).at(-1);
+    if (newest?.tree === tree) return { checkpoint: newest, unchanged: true };
+    return { checkpoint: addCheckpoint(s, worktree, tree, head, opts.handoff), unchanged: false };
+  });
 }
 
 // packages/server/src/diffparse.ts
@@ -3745,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 {
@@ -3754,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");
@@ -3814,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]
   });
@@ -3841,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));
@@ -3892,7 +4149,7 @@ async function getFullFile(ctx, filePath, side) {
   const ref = await refForSide(ctx, side);
   if (ref === void 0) {
     try {
-      const buf = await readFile(path3.join(ctx.cwd, filePath));
+      const buf = await readFile2(path4.join(ctx.cwd, filePath));
       return buf.toString("utf8");
     } catch {
       return null;
@@ -3911,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);
@@ -4192,15 +4449,15 @@ function buildStagePatch(diff, mode, selection, opts = {}) {
 }
 
 // packages/server/src/worktrees.ts
-import path4 from "path";
-import { readdir, realpath as realpath2, stat as stat2 } from "fs/promises";
+import path5 from "path";
+import { readdir, realpath as realpath2, stat as stat3 } from "fs/promises";
 function slotPath(ctx, slot) {
-  return path4.join(path4.dirname(ctx.commonRoot), `${path4.basename(ctx.commonRoot)}-${slot}`);
+  return path5.join(path5.dirname(ctx.commonRoot), `${path5.basename(ctx.commonRoot)}-${slot}`);
 }
 function slotOf(ctx, p) {
-  if (path4.dirname(p) !== path4.dirname(ctx.commonRoot)) return void 0;
-  const prefix = `${path4.basename(ctx.commonRoot)}-`;
-  const name = path4.basename(p);
+  if (path5.dirname(p) !== path5.dirname(ctx.commonRoot)) return void 0;
+  const prefix = `${path5.basename(ctx.commonRoot)}-`;
+  const name = path5.basename(p);
   const n = name.startsWith(prefix) ? name.slice(prefix.length) : "";
   return /^[1-9]\d*$/.test(n) ? Number(n) : void 0;
 }
@@ -4227,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);
@@ -4234,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;
@@ -4285,7 +4579,7 @@ async function assertBranchName(ctx, name) {
   }
 }
 async function dirUsable(p) {
-  const st = await stat2(p).catch((e) => {
+  const st = await stat3(p).catch((e) => {
     if (e.code === "ENOENT") return void 0;
     throw e;
   });
@@ -4307,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);
@@ -4363,8 +4659,8 @@ async function checkoutWorktree(ctx, req) {
     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.path).catch(() => target.path);
-  const worktree = (await listWorktrees(ctx)).find((w) => w.path === real);
+  const real2 = await realpath2(target.path).catch(() => target.path);
+  const worktree = (await listWorktrees(ctx)).find((w) => w.path === real2);
   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 };
 }
@@ -4382,11 +4678,14 @@ async function dropBranch(ctx, wt, asked) {
 }
 async function releaseWorktree(ctx, req) {
   const p = req.path.trim();
-  const wt = (await listWorktreesAll(ctx)).find((w) => w.path === p || p && w.path === path4.resolve(p));
+  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 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) {
@@ -4398,9 +4697,13 @@ async function releaseWorktree(ctx, req) {
 }
 async function removeWorktree(ctx, req) {
   const p = req.path.trim();
-  const wt = (await listWorktreesAll(ctx)).find((w) => w.path === p || p && w.path === path4.resolve(p));
+  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);
@@ -4418,187 +4721,6 @@ async function removeWorktree(ctx, req) {
   return dropBranch(ctx, wt, req.deleteBranch);
 }
 
-// packages/server/src/state.ts
-import os from "os";
-import path5 from "path";
-import { mkdir as mkdir2, open, readFile as readFile2, rename, stat as stat3, unlink, writeFile } from "fs/promises";
-function dataDir() {
-  const xdg = process.env.XDG_DATA_HOME;
-  const base = xdg?.trim() ? xdg : path5.join(os.homedir(), ".local", "share");
-  return path5.join(base, "warden");
-}
-function repoHash(repoRoot) {
-  return sha1(repoRoot).slice(0, 12);
-}
-function stateFilePath(repoRoot, baseDir = dataDir()) {
-  return path5.join(baseDir, repoHash(repoRoot), "state.json");
-}
-function defaultPrefs() {
-  return { viewMode: "unified", nvimSocketByRoot: {}, autoRefresh: true, railOpen: false, ignoreDebug: true };
-}
-function defaultState(repoRoot) {
-  return { schemaVersion: 1, repoRoot, targets: {}, issues: [], todos: [], checkpoints: [], prefs: defaultPrefs() };
-}
-function ensureTarget(state, key) {
-  let t = state.targets[key];
-  if (!t) {
-    t = { viewed: {}, comments: [] };
-    state.targets[key] = t;
-  }
-  return t;
-}
-var usable = (v) => !!v && typeof v === "object" && typeof v.id === "string";
-var usableCheckpoint = (v) => {
-  const c = 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;
-  const r = raw2;
-  if (r.schemaVersion !== 1) return base;
-  const targets = {};
-  for (const [k, v] of Object.entries(r.targets ?? {})) {
-    if (!v || typeof v !== "object") continue;
-    targets[k] = {
-      viewed: typeof v.viewed === "object" && v.viewed ? v.viewed : {},
-      comments: Array.isArray(v.comments) ? v.comments.filter(usableComment) : [],
-      ...typeof v.head === "string" ? { head: v.head } : {}
-    };
-  }
-  migrateLocalViews(targets);
-  return {
-    schemaVersion: 1,
-    repoRoot: r.repoRoot ?? repoRoot,
-    targets,
-    issues: Array.isArray(r.issues) ? r.issues.filter(usable) : [],
-    todos: Array.isArray(r.todos) ? r.todos.filter(usable) : [],
-    checkpoints: Array.isArray(r.checkpoints) ? r.checkpoints.filter(usableCheckpoint) : [],
-    prefs: {
-      ...defaultPrefs(),
-      ...r.prefs ?? {},
-      nvimSocketByRoot: r.prefs?.nvimSocketByRoot ?? {},
-      autoRefresh: typeof r.prefs?.autoRefresh === "boolean" ? r.prefs.autoRefresh : true,
-      railOpen: typeof r.prefs?.railOpen === "boolean" ? r.prefs.railOpen : false,
-      ignoreDebug: typeof r.prefs?.ignoreDebug === "boolean" ? r.prefs.ignoreDebug : true
-    }
-  };
-}
-function migrateLocalViews(targets) {
-  for (const key of Object.keys(targets).sort()) {
-    const scope = commentScopeKey(key);
-    if (scope === key) continue;
-    const src = targets[key];
-    delete targets[key];
-    if (src.comments.length === 0) continue;
-    let dst = targets[scope];
-    if (!dst) {
-      dst = { viewed: {}, comments: [] };
-      targets[scope] = dst;
-    }
-    dst.comments.push(...src.comments);
-  }
-}
-var LOCK_STALE_MS = 5e3;
-var LOCK_WAIT_MS = 5e3;
-async function sleep(ms) {
-  await new Promise((r) => setTimeout(r, ms));
-}
-var StateStore = class {
-  constructor(file, repoRoot) {
-    this.file = file;
-    this.repoRoot = repoRoot;
-  }
-  file;
-  repoRoot;
-  queue = Promise.resolve();
-  async load() {
-    try {
-      const text = await readFile2(this.file, "utf8");
-      return normalise(JSON.parse(text), this.repoRoot);
-    } catch (e) {
-      const err = e;
-      if (err.code === "ENOENT") return defaultState(this.repoRoot);
-      if (e instanceof SyntaxError) {
-        try {
-          await rename(this.file, `${this.file}.corrupt-${Date.now()}`);
-        } catch {
-        }
-        return defaultState(this.repoRoot);
-      }
-      throw e;
-    }
-  }
-  /** Apply a mutation under lock. The callback receives the freshest on-disk state. */
-  update(fn) {
-    const run2 = async () => {
-      await mkdir2(path5.dirname(this.file), { recursive: true });
-      const release = await this.acquireLock();
-      try {
-        const state = await this.load();
-        const result = await fn(state);
-        await this.writeAtomic(state);
-        return result;
-      } finally {
-        await release();
-      }
-    };
-    const p = this.queue.then(run2, run2);
-    this.queue = p.catch(() => void 0);
-    return p;
-  }
-  async writeAtomic(state) {
-    const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tmp, JSON.stringify(state, null, 2) + "\n", "utf8");
-    await rename(tmp, this.file);
-  }
-  async acquireLock() {
-    const lock = `${this.file}.lock`;
-    const started = Date.now();
-    for (; ; ) {
-      try {
-        const fh = await open(lock, "wx");
-        await fh.writeFile(String(process.pid));
-        await fh.close();
-        return async () => {
-          try {
-            await unlink(lock);
-          } catch {
-          }
-        };
-      } catch (e) {
-        const err = e;
-        if (err.code !== "EEXIST") throw e;
-        try {
-          const st = await stat3(lock);
-          if (Date.now() - st.mtimeMs > LOCK_STALE_MS) {
-            await unlink(lock).catch(() => void 0);
-            continue;
-          }
-        } catch {
-          continue;
-        }
-        if (Date.now() - started > LOCK_WAIT_MS) {
-          throw new Error(`timed out waiting for state lock ${lock}`);
-        }
-        await sleep(20);
-      }
-    }
-  }
-};
-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));
-  state.checkpoints = state.checkpoints.filter((c) => c.worktree !== worktreePath);
-}
-
 // packages/server/src/export.ts
 var LANG_BY_EXT = {
   ts: "ts",
@@ -4646,29 +4768,116 @@ function langForPath(filePath) {
   if (!m?.[1]) return "";
   return LANG_BY_EXT[m[1].toLowerCase()] ?? m[1].toLowerCase();
 }
+function shortId(id) {
+  return id.slice(0, 8);
+}
+var quote = (text) => text.replace(/\r\n/g, "\n").split("\n").map((l) => l ? `> ${l}` : ">").join("\n");
 function formatCommentSection(c) {
   const range = c.startLine === c.endLine ? `${c.startLine}` : `${c.startLine}-${c.endLine}`;
   const width = String(c.endLine).length;
   const code = c.codeSnippet.map((line, i) => `${String(c.startLine + i).padStart(width, " ")} | ${line}`).join("\n");
   const lang = langForPath(c.filePath);
-  const body = c.body.replace(/\r\n/g, "\n").split("\n").map((l) => l ? `> ${l}` : ">").join("\n");
   const fence = code.includes("```") ? "````" : "```";
   const orphanNote = c.status === "orphaned" ? " [orphaned: original location no longer exists]" : "";
-  return [`## ${c.filePath}:${range} (${c.side})${orphanNote}`, `${fence}${lang}`, code, fence, body].join("\n");
+  const parts = [`## ${c.filePath}:${range} (${c.side}) [id: ${shortId(c.id)}]${orphanNote}`, `${fence}${lang}`, code, fence, quote(c.body)];
+  for (const r of c.replies ?? []) parts.push(`${r.author === "agent" ? "Agent" : "Reviewer"} replied:
+${quote(r.body)}`);
+  return parts.join("\n");
 }
-function formatCommentsExport({ repoRoot, comments }) {
+function replyFooter(replyCommand) {
+  return `When you have dealt with a comment, answer it with \`${replyCommand} reply <id> "<what you changed, or why you did not>"\` so the reviewer sees your answer beside it.`;
+}
+function formatCommentsExport({ repoRoot, comments, replyCommand }) {
   const targets = [...new Set(comments.map((c) => c.targetKey))];
   const head = ["# Review comments", `Target: ${targets.join(", ") || "-"}`, `Repo: ${repoRoot}`, `Count: ${comments.length}`];
   const sections = comments.map(formatCommentSection);
-  return [head.join("\n"), ...sections].join("\n\n") + "\n";
+  const tail = replyCommand && comments.length > 0 ? [replyFooter(replyCommand)] : [];
+  return [head.join("\n"), ...sections, ...tail].join("\n\n") + "\n";
 }
-function formatIssueExport({ repoRoot, issue, comments }) {
-  const targets = [...new Set(comments.map((c) => c.targetKey))];
-  const head = [`# Issue: ${issue.title}`, `Status: ${issue.status}`, `Target: ${targets.join(", ") || "-"}`, `Repo: ${repoRoot}`, `Count: ${comments.length}`];
-  const parts = [head.join("\n")];
-  if (issue.body.trim()) parts.push(issue.body.trim());
-  parts.push(...comments.map(formatCommentSection));
-  return parts.join("\n\n") + "\n";
+function formatTodoExport({ todo, comments, replyCommand }) {
+  const body = todo.body.replace(/\r\n/g, "\n").trim();
+  const parts = [todo.title, ...body ? [body] : [], ...comments.map(formatCommentSection)];
+  if (replyCommand && comments.length > 0) parts.push(replyFooter(replyCommand));
+  return parts.join("\n\n");
+}
+
+// packages/server/src/feedback.ts
+import { realpath as realpath3 } from "fs/promises";
+import { randomUUID as randomUUID3 } from "crypto";
+async function real(p) {
+  try {
+    return await realpath3(p);
+  } catch {
+    return p;
+  }
+}
+function worktreeOf(c, mainRoot) {
+  return commentWorktree(c) ?? mainRoot;
+}
+async function commentsIn(state, worktreeRoot, mainRoot) {
+  const want = await real(worktreeRoot);
+  const resolved = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const t of Object.values(state.targets)) {
+    for (const c of t.comments) {
+      const wt = worktreeOf(c, mainRoot);
+      let p = resolved.get(wt);
+      if (!p) {
+        p = real(wt);
+        resolved.set(wt, p);
+      }
+      if (await p === want) out.push(c);
+    }
+  }
+  return out;
+}
+async function takeFeedback(store, opts) {
+  if (opts.peek) return (await commentsIn(await store.load(), opts.worktreeRoot, opts.mainRoot)).filter(awaitsAgent);
+  return store.update(async (s) => {
+    const ids = new Set((await commentsIn(s, opts.worktreeRoot, opts.mainRoot)).filter(awaitsAgent).map((c) => c.id));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const taken = [];
+    for (const t of Object.values(s.targets)) {
+      t.comments = t.comments.map((c) => {
+        if (!ids.has(c.id)) return c;
+        const next = { ...c, exportedAt: now, updatedAt: now, status: c.status === "active" ? "exported" : c.status };
+        taken.push(next);
+        return next;
+      });
+    }
+    return taken;
+  });
+}
+function locate(state, ref) {
+  const needle = ref.trim().toLowerCase();
+  if (!needle) throw badRequest("a comment id is required", "bad_comment_id");
+  const hits = [];
+  for (const t of Object.values(state.targets)) {
+    t.comments.forEach((c, index) => {
+      if (c.id === needle) hits.unshift({ list: t.comments, index });
+      else if (c.id.startsWith(needle)) hits.push({ list: t.comments, index });
+    });
+  }
+  const exact = hits[0] && hits[0].list[hits[0].index].id === needle;
+  if (hits.length === 0) throw notFound(`no comment with id ${ref}; it may have been resolved or deleted`, "unknown_comment");
+  if (!exact && hits.length > 1) throw badRequest(`id ${ref} matches ${hits.length} comments; give more of it`, "ambiguous_comment");
+  return hits[0];
+}
+async function addReply(store, ref, author, body) {
+  if (!body.trim()) throw badRequest("reply must not be empty", "empty_reply");
+  return store.update((s) => {
+    const { list, index } = locate(s, ref);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    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") {
+      delete next.exportedAt;
+      if (next.status === "exported") next.status = "active";
+    }
+    list[index] = next;
+    return next;
+  });
 }
 
 // packages/server/src/nvim.ts
@@ -4738,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;
@@ -4792,7 +5006,8 @@ var NvimService = class {
 
 // packages/server/src/tmux.ts
 import { execFile as execFile3 } from "child_process";
-import { realpath as realpath3 } from "fs/promises";
+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) => {
     if (!error) return resolve(stdout);
@@ -4802,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 realpath3(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 realpath3(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");
-    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 };
+  /**
+   * 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 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) {
@@ -4926,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}	-`;
@@ -4938,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",
@@ -4956,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 {
@@ -4977,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,
@@ -4990,6 +5219,7 @@ async function serveStaticFile(c, webDir) {
 
 // packages/server/src/app.ts
 var SSE_HEARTBEAT_MS = 15e3;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost"]);
 var LISTING_HINT_TTL_MS = 5 * 6e4;
 function createApp(opts) {
   const { repo, store } = opts;
@@ -5014,6 +5244,10 @@ function createApp(opts) {
     return list;
   };
   const checkpoints = checkpointStore(store.file);
+  const stateStamp = () => stat7(store.file).then(
+    (st) => st.mtimeMs,
+    () => 0
+  );
   const worktreeCtx = async (key) => {
     let list = await worktrees();
     try {
@@ -5041,6 +5275,14 @@ function createApp(opts) {
       untracked: explicit?.untracked ?? hint?.untracked
     });
   };
+  const checkpointHandoff = (comments) => {
+    const worktrees2 = new Set(comments.map((x) => tryParseTargetKey(x.targetKey)?.worktree));
+    for (const wt of worktrees2) {
+      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}`);
+      });
+    }
+  };
   const findComment = (state, id) => {
     for (const [targetKey, t] of Object.entries(state.targets)) {
       const index = t.comments.findIndex((c) => c.id === id);
@@ -5048,6 +5290,13 @@ function createApp(opts) {
     }
     return void 0;
   };
+  const linkable = (state, raw2) => {
+    if (!Array.isArray(raw2) || raw2.some((x) => typeof x !== "string")) throw badRequest("commentIds must be a list of ids");
+    const ids = [...new Set(raw2)];
+    const missing = ids.find((x) => !findComment(state, x));
+    if (missing) throw notFound(`no comment with id ${missing}`, "unknown_comment");
+    return ids;
+  };
   app.onError((err, c) => {
     if (err instanceof HttpError) {
       return c.json({ error: err.message, code: err.code }, err.status);
@@ -5055,26 +5304,41 @@ function createApp(opts) {
     console.error(err);
     return c.json({ error: err instanceof Error ? err.message : String(err), code: "internal" }, 500);
   });
+  app.use("*", async (c, next) => {
+    const host = new URL(c.req.url).hostname;
+    if (!LOOPBACK_HOSTS.has(host)) {
+      throw new HttpError(403, `requests for host ${host} are refused; open warden at http://127.0.0.1 or http://localhost`, "bad_host");
+    }
+    await next();
+  });
   const api = new Hono2();
   api.use("*", async (c, next) => {
-    if (c.req.method !== "GET" && c.req.method !== "HEAD" && c.req.header("sec-fetch-site") === "cross-site") {
-      throw new HttpError(403, "cross-site requests are refused", "cross_site");
+    if (c.req.method !== "GET" && c.req.method !== "HEAD") {
+      const origin = c.req.header("origin");
+      if (c.req.header("sec-fetch-site") === "cross-site" || origin && origin !== new URL(c.req.url).origin) {
+        throw new HttpError(403, "cross-site requests are refused", "cross_site");
+      }
     }
     await next();
   });
   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);
   });
@@ -5175,15 +5439,9 @@ function createApp(opts) {
   });
   api.post("/targets/:key/checkpoints", async (c) => {
     const ctx = await worktreeCtx(c.req.param("key"));
-    const tree = await snapshotWorktree(ctx.cwd, checkpoints);
-    const head = await revParse(ctx.cwd, "HEAD") ?? "";
-    const res = await store.update((s) => {
-      const newest = checkpointsOf(s, ctx.target.worktree).at(-1);
-      const unchanged = newest?.tree === tree;
-      const checkpoint = unchanged ? newest : addCheckpoint(s, ctx.target.worktree, tree, head);
-      return { checkpoint, unchanged, targetKey: checkpointKey(checkpoint) };
-    });
-    return c.json(res, res.unchanged ? 200 : 201);
+    const { checkpoint, unchanged } = await takeCheckpoint(store, ctx.cwd, ctx.target.worktree);
+    const res = { checkpoint, unchanged, targetKey: checkpointKey(checkpoint) };
+    return c.json(res, unchanged ? 200 : 201);
   });
   api.delete("/targets/:key/checkpoints/:id", async (c) => {
     const ctx = await worktreeCtx(c.req.param("key"));
@@ -5236,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: randomUUID2(),
+      id: randomUUID4(),
       targetKey: key,
       filePath: body.filePath,
       side: body.side,
@@ -5307,12 +5565,19 @@ function createApp(opts) {
       if (!t) return false;
       const before = t.comments.length;
       t.comments = t.comments.filter((x) => x.id !== id);
-      for (const issue of s.issues) issue.commentIds = issue.commentIds.filter((x) => x !== id);
+      unlinkComments(s, [id]);
       return t.comments.length !== before;
     });
     if (!removed) throw notFound("comment not found");
     return c.json({ ok: true });
   });
+  api.post("/targets/:key/comments/:id/replies", async (c) => {
+    const body = await c.req.json();
+    if (typeof body.body !== "string") throw badRequest("body is required");
+    const found = findComment(await store.load(), c.req.param("id"));
+    if (!found || found.targetKey !== commentScopeKey(c.req.param("key"))) throw notFound("comment not found");
+    return c.json(await addReply(store, found.comment.id, "reviewer", body.body), 201);
+  });
   api.post("/targets/:key/comments/reanchor", async (c) => {
     const key = c.req.param("key");
     const ctx = await targetCtx(key);
@@ -5353,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(
@@ -5377,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 = [];
@@ -5384,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) {
+          if (landed.has(cm.id) && !cm.replies?.length) {
             dropped.push(cm.id);
             return [];
           }
@@ -5394,9 +5671,7 @@ function createApp(opts) {
         const unchanged = cm.targetKey === next.targetKey && cm.status === next.status && cm.startLine === next.startLine && cm.endLine === next.endLine && cm.anchor.hunkHash === next.anchor.hunkHash;
         return [unchanged ? cm : { ...next, updatedAt: now }];
       });
-      for (const id of dropped) {
-        for (const issue of s.issues) issue.commentIds = issue.commentIds.filter((x) => x !== id);
-      }
+      unlinkComments(s, dropped);
       t.head = head;
       return t.comments;
     });
@@ -5407,6 +5682,7 @@ function createApp(opts) {
     const body = await c.req.json();
     if (!Array.isArray(body.commentIds)) throw badRequest("commentIds required");
     const ids = body.commentIds.filter((x) => typeof x === "string");
+    let handed = [];
     const res = await store.update((s) => {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const selected = [];
@@ -5418,94 +5694,14 @@ function createApp(opts) {
         s.targets[found.targetKey].comments[found.index] = next;
         selected.push(next);
       }
+      handed = selected;
       return {
-        text: formatCommentsExport({ repoRoot: repo.root, comments: selected }),
+        text: formatCommentsExport({ repoRoot: repo.root, comments: selected, replyCommand: opts.replyCommand }),
         count: selected.length,
         commentIds: selected.map((x) => x.id)
       };
     });
-    return c.json(res);
-  });
-  api.get("/issues", async (c) => {
-    const s = await store.load();
-    return c.json({ issues: s.issues });
-  });
-  api.post("/issues", async (c) => {
-    const body = await c.req.json();
-    if (!body.title?.trim()) throw badRequest("title is required");
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const issue = {
-      id: randomUUID2(),
-      title: body.title.trim(),
-      body: typeof body.body === "string" ? body.body : "",
-      status: body.status === "closed" ? "closed" : "open",
-      commentIds: Array.isArray(body.commentIds) ? body.commentIds.filter((x) => typeof x === "string") : [],
-      createdAt: now,
-      updatedAt: now
-    };
-    await store.update((s) => {
-      s.issues = insertAfter(s.issues, issue, typeof body.after === "string" ? body.after : void 0);
-    });
-    return c.json(issue, 201);
-  });
-  api.post("/issues/:id/move", async (c) => {
-    const id = c.req.param("id");
-    const body = await c.req.json();
-    if (body.before !== null && typeof body.before !== "string") throw badRequest("before must be an id or null");
-    const issues = await store.update((s) => {
-      const next = moveBefore(s.issues, id, body.before);
-      if (!next) throw notFound("issue not found");
-      s.issues = next;
-      return s.issues;
-    });
-    return c.json({ issues });
-  });
-  api.patch("/issues/:id", async (c) => {
-    const id = c.req.param("id");
-    const body = await c.req.json();
-    const updated = await store.update((s) => {
-      const issue = s.issues.find((i) => i.id === id);
-      if (!issue) throw notFound("issue not found");
-      if (typeof body.title === "string" && body.title.trim()) issue.title = body.title.trim();
-      if (typeof body.body === "string") issue.body = body.body;
-      if (body.status === "open" || body.status === "closed") issue.status = body.status;
-      if (Array.isArray(body.commentIds)) issue.commentIds = [...new Set(body.commentIds.filter((x) => typeof x === "string"))];
-      issue.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      return issue;
-    });
-    return c.json(updated);
-  });
-  api.delete("/issues/:id", async (c) => {
-    const id = c.req.param("id");
-    const removed = await store.update((s) => {
-      const before = s.issues.length;
-      s.issues = s.issues.filter((i) => i.id !== id);
-      return s.issues.length !== before;
-    });
-    if (!removed) throw notFound("issue not found");
-    return c.json({ ok: true });
-  });
-  api.post("/issues/:id/export", async (c) => {
-    const id = c.req.param("id");
-    const res = await store.update((s) => {
-      const issue = s.issues.find((i) => i.id === id);
-      if (!issue) throw notFound("issue not found");
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const comments = [];
-      for (const cid of issue.commentIds) {
-        const found = findComment(s, cid);
-        if (!found) continue;
-        const next = { ...found.comment, exportedAt: now, updatedAt: now };
-        if (next.status === "active") next.status = "exported";
-        s.targets[found.targetKey].comments[found.index] = next;
-        comments.push(next);
-      }
-      return {
-        text: formatIssueExport({ repoRoot: repo.root, issue, comments }),
-        count: comments.length,
-        commentIds: comments.map((x) => x.id)
-      };
-    });
+    checkpointHandoff(handed);
     return c.json(res);
   });
   const knownRoot = async (rootParam) => {
@@ -5529,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: randomUUID2(),
+      id: randomUUID4(),
       branch,
       title: body.title.trim(),
       body: typeof body.body === "string" ? body.body : "",
@@ -5538,6 +5734,10 @@ function createApp(opts) {
       updatedAt: now
     };
     await store.update((s) => {
+      if (body.commentIds !== void 0) {
+        const ids = linkable(s, body.commentIds);
+        if (ids.length) todo.commentIds = ids;
+      }
       s.todos = insertAfter(s.todos, todo, typeof body.after === "string" ? body.after : void 0);
     });
     return c.json(todo, 201);
@@ -5564,11 +5764,40 @@ function createApp(opts) {
       if (typeof body.title === "string" && body.title.trim()) todo.title = body.title.trim();
       if (typeof body.body === "string") todo.body = body.body;
       if (body.status === "open" || body.status === "done") todo.status = body.status;
+      if (body.commentIds !== void 0) {
+        const ids = linkable(s, body.commentIds);
+        if (ids.length) todo.commentIds = ids;
+        else delete todo.commentIds;
+      }
       todo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       return todo;
     });
     return c.json(updated);
   });
+  api.post("/todos/:id/export", async (c) => {
+    const id = c.req.param("id");
+    const handed = [];
+    const res = await store.update((s) => {
+      const todo = s.todos.find((t) => t.id === id);
+      if (!todo) throw notFound("todo not found");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const cid of todo.commentIds ?? []) {
+        const found = findComment(s, cid);
+        if (!found) continue;
+        const next = { ...found.comment, exportedAt: now, updatedAt: now };
+        if (next.status === "active") next.status = "exported";
+        s.targets[found.targetKey].comments[found.index] = next;
+        handed.push(next);
+      }
+      return {
+        text: formatTodoExport({ todo, comments: handed, replyCommand: opts.replyCommand }),
+        count: handed.length,
+        commentIds: handed.map((x) => x.id)
+      };
+    });
+    checkpointHandoff(handed);
+    return c.json(res);
+  });
   api.delete("/todos/:id", async (c) => {
     const id = c.req.param("id");
     const removed = await store.update((s) => {
@@ -5599,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;
@@ -5619,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];
       }
     }
@@ -5638,17 +5868,40 @@ 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 = await listWorktreesDetailed(repo);
+    const [list, state] = await Promise.all([listWorktreesDetailed(repo), store.load()]);
     const [branches, newSlot] = await Promise.all([listBranches(repo, list), nextSlot(repo, list)]);
+    const review = /* @__PURE__ */ new Map();
+    const latest = /* @__PURE__ */ new Map();
+    for (const t of Object.values(state.targets)) {
+      for (const cm of t.comments) {
+        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)) {
+          r.toAgent++;
+          if (cm.updatedAt >= seen.agent) [seen.agent, r.toAgentTarget] = [cm.updatedAt, cm.targetKey];
+        }
+        if (awaitsReviewer(cm)) {
+          r.toReviewer++;
+          if (cm.updatedAt >= seen.reviewer) [seen.reviewer, r.toReviewerTarget] = [cm.updatedAt, cm.targetKey];
+        }
+        review.set(at, r);
+        latest.set(at, seen);
+      }
+    }
+    for (const wt of list) {
+      const r = review.get(wt.path);
+      if (r && (r.toAgent || r.toReviewer)) wt.review = r;
+    }
     const res = { worktrees: list, branches, newSlot };
     return c.json(res);
   });
@@ -5656,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);
@@ -5669,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);
   });
@@ -5695,7 +5954,19 @@ function createApp(opts) {
         const event = { type: "changed", ...change };
         void enqueue(() => stream2.writeSSE({ event: "changed", data: JSON.stringify(event) }));
       });
-      stream2.onAbort(release);
+      let stamp = await stateStamp();
+      const statePoll = setInterval(() => {
+        void stateStamp().then((next) => {
+          if (next === stamp) return;
+          stamp = next;
+          const event = { type: "state", at: (/* @__PURE__ */ new Date()).toISOString() };
+          void enqueue(() => stream2.writeSSE({ event: "state", data: JSON.stringify(event) }));
+        });
+      }, opts.watchIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+      stream2.onAbort(() => {
+        clearInterval(statePoll);
+        release();
+      });
       try {
         while (!stream2.aborted && !stream2.closed) {
           await stream2.sleep(SSE_HEARTBEAT_MS);
@@ -5703,6 +5974,7 @@ function createApp(opts) {
           await enqueue(() => stream2.write(": ping\n\n"));
         }
       } finally {
+        clearInterval(statePoll);
         release();
       }
     });
@@ -5714,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);
   });
@@ -5730,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) => {
@@ -5791,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;
@@ -5832,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 {
   }
 }
@@ -5877,8 +6167,8 @@ 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 = randomUUID3();
-  const app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir, instanceToken, update: opts.update });
+  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));
     s.once("error", reject);
@@ -5920,8 +6210,68 @@ async function startServer(opts) {
   };
 }
 
+// bin/agent.ts
+var AGENT_COMMANDS = ["feedback", "reply"];
+function agentUsage(cmd) {
+  return `Commands for the agent, run inside the worktree under review:
+  ${cmd} feedback [--peek]      Print the review comments not yet handed over, and mark them handed
+                               over (--peek leaves them as they are)
+  ${cmd} reply <id> <message>   Answer a comment; <id> is the one in its heading. A message of "-",
+                               or none with stdin piped, is read from stdin
+`;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function openStore() {
+  const repo = await resolveRepo(process.cwd());
+  return { store: new StateStore(stateFilePath(repo.commonRoot), repo.commonRoot), root: repo.root, commonRoot: repo.commonRoot };
+}
+async function feedback(args, replyCommand) {
+  const unknown = args.find((a) => a !== "--peek");
+  if (unknown) throw new Error(`unknown argument: ${unknown}`);
+  const { store, root, commonRoot } = await openStore();
+  const peek = args.includes("--peek");
+  const comments = await takeFeedback(store, { worktreeRoot: root, mainRoot: commonRoot, peek });
+  if (comments.length === 0) {
+    console.log("No review comments are waiting for you.");
+    return;
+  }
+  if (!peek) {
+    await takeCheckpoint(store, root, root === commonRoot ? void 0 : root, { handoff: true }).catch((e) => {
+      console.error(`warden feedback: no checkpoint taken: ${e instanceof Error ? e.message : e}`);
+    });
+  }
+  process.stdout.write(formatCommentsExport({ repoRoot: root, comments, replyCommand }));
+}
+async function reply(args) {
+  const [id, ...words] = args;
+  if (!id) throw new Error("reply needs a comment id");
+  let body = words.join(" ");
+  if (body === "-" || !body && !process.stdin.isTTY) body = await readStdin();
+  if (!body.trim()) throw new Error("reply needs a message");
+  const { store } = await openStore();
+  const c = await addReply(store, id, "agent", body);
+  const range = c.startLine === c.endLine ? `${c.startLine}` : `${c.startLine}-${c.endLine}`;
+  console.log(`Replied to ${shortId(c.id)} (${c.filePath}:${range}).`);
+}
+async function runAgentCommand(argv, replyCommand) {
+  const [cmd, ...rest] = argv;
+  if (!cmd || !AGENT_COMMANDS.includes(cmd)) return void 0;
+  try {
+    if (cmd === "feedback") await feedback(rest, replyCommand);
+    else await reply(rest);
+    return 0;
+  } catch (e) {
+    console.error(`warden ${cmd}: ${e instanceof HttpError || e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+}
+
 // bin/cli.ts
-var VERSION = true ? "0.15.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++) {
@@ -5940,14 +6290,17 @@ 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(`${path12.sep}_npx${path12.sep}`);
+var selfCommand = viaNpx ? "npx @xbghc/warden" : "warden";
 function usage() {
   return `warden \u2014 local git diff review UI
 
 Usage: warden [repoPath] [options]
+       warden <command> [args]
 
 Options:
   --port <n>, -p <n>   Listen on a fixed port (default: first free port from 4100, and under WSL
@@ -5957,6 +6310,9 @@ Options:
                        (also: WARDEN_NO_UPDATE_CHECK=1, NO_UPDATE_NOTIFIER=1, CI)
   -h, --help           Show this help
   -v, --version        Print version
+
+${agentUsage("warden")}
+A repository in a directory named after a command is given as ./<name>.
 `;
 }
 async function openBrowser(url) {
@@ -5985,20 +6341,22 @@ 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;
 }
 async function main() {
+  const code = await runAgentCommand(process.argv.slice(2), selfCommand);
+  if (code !== void 0) process.exit(code);
   let args;
   try {
     args = parseArgs(process.argv.slice(2));
@@ -6019,12 +6377,11 @@ async function main() {
   if (!webDir) {
     console.error("warning: built web assets not found (dist/web). Only the /api endpoints will be served.");
   }
-  const viaNpx = fileURLToPath(import.meta.url).includes(`${path11.sep}_npx${path11.sep}`);
   const checking = args.updateCheck && VERSION !== "dev" && updateCheckEnabled();
   const update = checking ? checkForUpdate({ current: VERSION, npx: viaNpx }) : Promise.resolve(null);
   let server;
   try {
-    server = await startServer({ repoPath: args.repoPath, port: args.port, webDir, update });
+    server = await startServer({ repoPath: args.repoPath, port: args.port, webDir, update, replyCommand: selfCommand });
   } catch (e) {
     console.error(`warden: ${e.message}`);
     process.exit(1);