@xbghc/warden 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 
 // bin/cli.ts
-import path7 from "path";
+import path8 from "path";
 import { spawn } from "child_process";
 import { existsSync } from "fs";
 import { fileURLToPath } from "url";
 
 // packages/server/src/index.ts
 import net from "net";
+import { randomUUID as randomUUID2 } 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";
@@ -324,13 +325,13 @@ function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromi
     }
   }
 }
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
+function writeFromReadableStream(stream2, writable) {
+  if (stream2.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
     return;
   }
-  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+  return writeFromReadableStreamDefaultReader(stream2.getReader(), writable);
 }
 var buildOutgoingHttpHeaders = (headers) => {
   const res = {};
@@ -651,7 +652,7 @@ var serve = (options, listeningListener) => {
 };
 
 // packages/server/src/app.ts
-import path6 from "path";
+import path7 from "path";
 import { randomUUID } from "crypto";
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/compose.js
@@ -811,26 +812,26 @@ var throwNestingLimitExceeded = () => {
 };
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/url.js
-var splitPath = (path8) => {
-  const paths = path8.split("/");
+var splitPath = (path9) => {
+  const paths = path9.split("/");
   if (paths[0] === "") {
     paths.shift();
   }
   return paths;
 };
 var splitRoutingPath = (routePath) => {
-  const { groups, path: path8 } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path8);
+  const { groups, path: path9 } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path9);
   return replaceGroupMarks(paths, groups);
 };
-var extractGroupsFromPath = (path8) => {
+var extractGroupsFromPath = (path9) => {
   const groups = [];
-  path8 = path8.replace(/\{[^}]+\}/g, (match2, index) => {
+  path9 = path9.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
     groups.push([mark, match2]);
     return mark;
   });
-  return { groups, path: path8 };
+  return { groups, path: path9 };
 };
 var replaceGroupMarks = (paths, groups) => {
   for (let i = groups.length - 1; i >= 0; i--) {
@@ -887,8 +888,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 path8 = url.slice(start, end);
-      return tryDecodeURI(path8.includes("%25") ? path8.replace(/%25/g, "%2525") : path8);
+      const path9 = url.slice(start, end);
+      return tryDecodeURI(path9.includes("%25") ? path9.replace(/%25/g, "%2525") : path9);
     } else if (charCode === 63 || charCode === 35) {
       break;
     }
@@ -905,11 +906,11 @@ var mergePath = (base, sub, ...rest) => {
   }
   return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
 };
-var checkOptionalParameter = (path8) => {
-  if (path8.charCodeAt(path8.length - 1) !== 63 || !path8.includes(":")) {
+var checkOptionalParameter = (path9) => {
+  if (path9.charCodeAt(path9.length - 1) !== 63 || !path9.includes(":")) {
     return null;
   }
-  const segments = path8.split("/");
+  const segments = path9.split("/");
   const results = [];
   let basePath = "";
   segments.forEach((segment) => {
@@ -1051,9 +1052,9 @@ var HonoRequest = class {
    */
   path;
   bodyCache = {};
-  constructor(request, path8 = "/", matchResult = [[]]) {
+  constructor(request, path9 = "/", matchResult = [[]]) {
     this.raw = request;
-    this.path = path8;
+    this.path = path9;
     this.#matchResult = matchResult;
   }
   param(key) {
@@ -1825,8 +1826,8 @@ var Hono = class _Hono {
         return this;
       };
     });
-    this.on = (method, path8, ...handlers) => {
-      for (const p of [path8].flat()) {
+    this.on = (method, path9, ...handlers) => {
+      for (const p of [path9].flat()) {
         this.#path = p;
         for (const m of [method].flat()) {
           const methodName = m.toUpperCase();
@@ -1884,8 +1885,8 @@ var Hono = class _Hono {
    * app.route("/api", app2) // GET /api/user
    * ```
    */
-  route(path8, app) {
-    const subApp = this.basePath(path8);
+  route(path9, app) {
+    const subApp = this.basePath(path9);
     app.routes.map((r) => {
       let handler;
       if (app.errorHandler === errorHandler) {
@@ -1911,9 +1912,9 @@ var Hono = class _Hono {
    * const api = new Hono().basePath('/api')
    * ```
    */
-  basePath(path8) {
+  basePath(path9) {
     const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path8);
+    subApp._basePath = mergePath(this._basePath, path9);
     return subApp;
   }
   /**
@@ -1987,7 +1988,7 @@ var Hono = class _Hono {
    * })
    * ```
    */
-  mount(path8, applicationHandler, options) {
+  mount(path9, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
     if (options) {
@@ -2014,7 +2015,7 @@ var Hono = class _Hono {
       return [c.env, executionContext];
     };
     replaceRequest ||= (() => {
-      const mergedPath = mergePath(this._basePath, path8);
+      const mergedPath = mergePath(this._basePath, path9);
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
@@ -2029,18 +2030,18 @@ var Hono = class _Hono {
       }
       await next();
     };
-    this.#addRoute(METHOD_NAME_ALL, mergePath(path8, "*"), handler);
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path9, "*"), handler);
     return this;
   }
-  #addRoute(method, path8, handler, baseRoutePath) {
-    path8 = mergePath(this._basePath, path8);
+  #addRoute(method, path9, handler, baseRoutePath) {
+    path9 = mergePath(this._basePath, path9);
     const r = {
       basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
-      path: path8,
+      path: path9,
       method,
       handler
     };
-    this.router.add(method, path8, [handler, r]);
+    this.router.add(method, path9, [handler, r]);
     this.routes.push(r);
   }
   #handleError(err, c) {
@@ -2053,10 +2054,10 @@ var Hono = class _Hono {
     if (method === "HEAD") {
       return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
     }
-    const path8 = this.getPath(request, { env });
-    const matchResult = this.router.match(method, path8);
+    const path9 = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path9);
     const c = new Context(request, {
-      path: path8,
+      path: path9,
       matchResult,
       env,
       executionCtx,
@@ -2159,7 +2160,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, path8) {
+function match(method, path9) {
   const matchers = this.buildAllMatchers();
   const match2 = ((method2, path22) => {
     const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
@@ -2175,7 +2176,7 @@ function match(method, path8) {
     return [matcher[1][index], match3];
   });
   this.match = match2;
-  return match2(method, path8);
+  return match2(method, path9);
 }
 
 // node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/router/reg-exp-router/node.js
@@ -2292,14 +2293,14 @@ var Trie = class {
   #index = 0;
   // dynamic path -> [handler index, param assoc]; static paths are not registered
   paths = createNullObject();
-  insert(path8, isStatic) {
+  insert(path9, isStatic) {
     if (isStatic) {
-      this.#root.insert(path8.split(""), 0, [], this.#context, true);
+      this.#root.insert(path9.split(""), 0, [], this.#context, true);
       return;
     }
     const paramAssoc = [];
     const groups = [];
-    let markedPath = path8;
+    let markedPath = path9;
     for (let i = 0; ; ) {
       let replaced = false;
       markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
@@ -2324,7 +2325,7 @@ var Trie = class {
       }
     }
     this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
-    this.paths[path8] = [this.#index++, paramAssoc];
+    this.paths[path9] = [this.#index++, paramAssoc];
   }
   buildRegExp() {
     let regexp = this.#root.buildRegExpStr();
@@ -2351,17 +2352,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(path8) {
-  return wildcardRegExpCache[path8] ??= new RegExp(
-    `^${path8.replace(
+function buildWildcardRegExp(path9) {
+  return wildcardRegExpCache[path9] ??= new RegExp(
+    `^${path9.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, path8) {
+function findMiddleware(middleware, path9) {
   for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path8)) {
+    if (buildWildcardRegExp(k).test(path9)) {
       return [...middleware[k]];
     }
   }
@@ -2377,14 +2378,14 @@ var RegExpRouter = class {
     this.#routes = { [METHOD_NAME_ALL]: createNullObject() };
     this.#tries = { [METHOD_NAME_ALL]: new Trie() };
   }
-  #insertPath(method, path8) {
+  #insertPath(method, path9) {
     try {
-      this.#tries[method].insert(path8, !/\*|\/:/.test(path8));
+      this.#tries[method].insert(path9, !/\*|\/:/.test(path9));
     } catch (e) {
-      throw e === PATH_ERROR ? new UnsupportedPathError(path8) : e;
+      throw e === PATH_ERROR ? new UnsupportedPathError(path9) : e;
     }
   }
-  add(method, path8, handler) {
+  add(method, path9, handler) {
     const middleware = this.#middleware;
     const routes = this.#routes;
     if (!middleware) {
@@ -2400,28 +2401,28 @@ var RegExpRouter = class {
         }
       }
     }
-    if (path8 === "/*") {
-      path8 = "*";
+    if (path9 === "/*") {
+      path9 = "*";
     }
     const methods = method === METHOD_NAME_ALL ? Object.keys(middleware) : [method];
-    if (/\*$/.test(path8)) {
-      const re = buildWildcardRegExp(path8);
+    if (/\*$/.test(path9)) {
+      const re = buildWildcardRegExp(path9);
       for (const m of methods) {
-        if (!middleware[m][path8]) {
-          this.#insertPath(m, path8);
-          middleware[m][path8] = findMiddleware(middleware[m], path8) || findMiddleware(middleware[METHOD_NAME_ALL], path8) || [];
+        if (!middleware[m][path9]) {
+          this.#insertPath(m, path9);
+          middleware[m][path9] = findMiddleware(middleware[m], path9) || findMiddleware(middleware[METHOD_NAME_ALL], path9) || [];
         }
       }
       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, path8]);
+            re.test(p) && handlerMap[m][p].push([handler, path9]);
           }
         }
       }
       return;
     }
-    const paths = checkOptionalParameter(path8) || [path8];
+    const paths = checkOptionalParameter(path9) || [path9];
     for (const path22 of paths) {
       for (const m of methods) {
         if (!routes[m][path22]) {
@@ -2450,11 +2451,11 @@ var RegExpRouter = class {
     const handlerData = [];
     const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
     for (const r of [middleware, routes]) {
-      for (const path8 in r) {
-        const handlers = r[path8];
-        const pathData = trie.paths[path8];
+      for (const path9 in r) {
+        const handlers = r[path9];
+        const pathData = trie.paths[path9];
         if (!pathData) {
-          staticMap[path8] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+          staticMap[path9] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
           continue;
         }
         handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [
@@ -2478,13 +2479,13 @@ var SmartRouter = class {
   constructor(init) {
     this.#routers = init.routers;
   }
-  add(method, path8, handler) {
+  add(method, path9, handler) {
     if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.#routes.push([method, path8, handler]);
+    this.#routes.push([method, path9, handler]);
   }
-  match(method, path8) {
+  match(method, path9) {
     if (!this.#routes) {
       throw new Error("Fatal error");
     }
@@ -2499,7 +2500,7 @@ var SmartRouter = class {
         for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
           router.add(...routes[i2]);
         }
-        res = router.match(method, path8);
+        res = router.match(method, path9);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {
           continue;
@@ -2534,9 +2535,9 @@ var Node2 = class _Node2 {
   #patterns = [];
   #pattern;
   #params = emptyParams;
-  insert(method, path8, handler) {
+  insert(method, path9, handler) {
     let curNode = this;
-    const parts = splitRoutingPath(path8);
+    const parts = splitRoutingPath(path9);
     const possibleKeys = /* @__PURE__ */ new Set();
     let i = 0;
     for (const p of parts) {
@@ -2576,12 +2577,12 @@ var Node2 = class _Node2 {
       }
     }
   }
-  search(method, path8) {
+  search(method, path9) {
     const handlerSets = [];
     this.#params = emptyParams;
     const curNode = this;
     let curNodes = [curNode];
-    const parts = splitPath(path8);
+    const parts = splitPath(path9);
     const curNodesQueue = [];
     const len = parts.length;
     let partOffsets = null;
@@ -2623,13 +2624,13 @@ var Node2 = class _Node2 {
           if (matcher !== true) {
             if (!partOffsets) {
               partOffsets = [];
-              let offset = path8[0] === "/" ? 1 : 0;
+              let offset = path9[0] === "/" ? 1 : 0;
               for (let p = 0; p < len; p++) {
                 partOffsets[p] = offset;
                 offset += parts[p].length + 1;
               }
             }
-            const restPathString = path8.slice(partOffsets[i]);
+            const restPathString = path9.slice(partOffsets[i]);
             const m = matcher.exec(restPathString);
             if (m) {
               params[name] = m[0];
@@ -2689,13 +2690,13 @@ var Node2 = class _Node2 {
 var TrieRouter = class {
   name = "TrieRouter";
   #node = new Node2();
-  add(method, path8, handler) {
-    for (const result of checkOptionalParameter(path8) || [path8]) {
+  add(method, path9, handler) {
+    for (const result of checkOptionalParameter(path9) || [path9]) {
       this.#node.insert(method, result, handler);
     }
   }
-  match(method, path8) {
-    return this.#node.search(method, path8);
+  match(method, path9) {
+    return this.#node.search(method, path9);
   }
 };
 
@@ -2714,6 +2715,167 @@ var Hono2 = class extends Hono {
   }
 };
 
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/utils/stream.js
+var StreamingApi = class {
+  writer;
+  encoder;
+  writable;
+  abortSubscribers = [];
+  responseReadable;
+  /**
+   * Whether the stream has been aborted.
+   */
+  aborted = false;
+  /**
+   * Whether the stream has been closed normally.
+   */
+  closed = false;
+  constructor(writable, _readable) {
+    this.writable = writable;
+    this.writer = writable.getWriter();
+    this.encoder = new TextEncoder();
+    const reader = _readable.getReader();
+    this.abortSubscribers.push(async () => {
+      await reader.cancel();
+    });
+    this.responseReadable = new ReadableStream({
+      async pull(controller) {
+        const { done, value } = await reader.read();
+        done ? controller.close() : controller.enqueue(value);
+      },
+      cancel: () => {
+        if (!this.closed) {
+          this.abort();
+        }
+      }
+    });
+  }
+  async write(input) {
+    try {
+      if (typeof input === "string") {
+        input = this.encoder.encode(input);
+      }
+      await this.writer.write(input);
+    } catch {
+    }
+    return this;
+  }
+  async writeln(input) {
+    await this.write(input + "\n");
+    return this;
+  }
+  sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async close() {
+    this.closed = true;
+    try {
+      await this.writer.close();
+    } catch {
+    }
+  }
+  async pipe(body) {
+    this.writer.releaseLock();
+    try {
+      await body.pipeTo(this.writable, { preventClose: true, preventAbort: true });
+    } finally {
+      this.writer = this.writable.getWriter();
+    }
+  }
+  onAbort(listener) {
+    this.abortSubscribers.push(listener);
+  }
+  /**
+   * Abort the stream.
+   * You can call this method when stream is aborted by external event.
+   */
+  abort() {
+    if (!this.aborted) {
+      this.aborted = true;
+      this.abortSubscribers.forEach((subscriber) => {
+        try {
+          void Promise.resolve(subscriber()).catch(() => {
+          });
+        } catch {
+        }
+      });
+    }
+  }
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/helper/streaming/utils.js
+var isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+
+// node_modules/.pnpm/hono@4.13.7/node_modules/hono/dist/helper/streaming/sse.js
+var SSEStreamingApi = class extends StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    for (const key of ["event", "id"]) {
+      const value = message[key];
+      if (value && /[\r\n]/.test(value)) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id !== void 0 && `id: ${message.id}`,
+      message.retry !== void 0 && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+};
+var run = async (stream2, cb, onError) => {
+  try {
+    await cb(stream2);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream2);
+      await stream2.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream2.close();
+  }
+};
+var contextStash = /* @__PURE__ */ new WeakMap();
+var streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new SSEStreamingApi(writable, readable);
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
+  contextStash.set(stream2.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream2, cb, onError);
+  return c.newResponse(stream2.responseReadable);
+};
+
 // packages/shared/src/target.ts
 var TargetKeyError = class extends Error {
   constructor(message) {
@@ -2758,6 +2920,47 @@ function parseTargetKey(key) {
   }
   return parseSuffix(key);
 }
+function formatTargetKey(t) {
+  let suffix;
+  switch (t.kind) {
+    case "working":
+    case "staged":
+    case "all":
+      suffix = t.kind;
+      break;
+    case "commit":
+      suffix = `commit:${t.sha}`;
+      break;
+    case "range":
+      suffix = `range:${t.base}..${t.head}`;
+      break;
+  }
+  return t.worktree ? `worktree:${t.worktree}:${suffix}` : suffix;
+}
+function tryParseTargetKey(key) {
+  try {
+    return parseTargetKey(key);
+  } catch {
+    return void 0;
+  }
+}
+function isLocalTarget(t) {
+  return t.kind === "working" || t.kind === "staged" || t.kind === "all";
+}
+function commentScopeKey(key) {
+  const t = tryParseTargetKey(key);
+  if (!t || !isLocalTarget(t)) return key;
+  return t.worktree ? `worktree:${t.worktree}:local` : "local";
+}
+function localViewKeys(key) {
+  const t = tryParseTargetKey(key);
+  const wt = t?.worktree ? { worktree: t.worktree } : {};
+  return [
+    formatTargetKey({ kind: "working", ...wt }),
+    formatTargetKey({ kind: "staged", ...wt }),
+    formatTargetKey({ kind: "all", ...wt })
+  ];
+}
 
 // packages/server/src/errors.ts
 var HttpError = class extends Error {
@@ -2939,16 +3142,24 @@ async function listWorktrees(ctx) {
   }
   return out;
 }
+async function currentBranch(cwd) {
+  const res = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd }).catch(() => ({ stdout: "" }));
+  const name = res.stdout.trim();
+  if (name && name !== "HEAD") return name;
+  const head = await runGit(["rev-parse", "--verify", "--quiet", "HEAD"], { cwd }).catch(() => ({ stdout: "" }));
+  const sha = head.stdout.trim();
+  return sha ? sha.slice(0, 7) : "HEAD";
+}
 async function getRepoInfo(ctx, defaultTarget) {
-  const [branchRes, headRes, worktrees] = await Promise.all([
-    runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: ctx.root }).catch(() => ({ stdout: "HEAD" })),
+  const [branch, headRes, worktrees] = await Promise.all([
+    currentBranch(ctx.root),
     runGit(["rev-parse", "HEAD"], { cwd: ctx.root }).catch(() => ({ stdout: "" })),
     listWorktrees(ctx)
   ]);
   return {
     root: ctx.root,
     commonRoot: ctx.commonRoot,
-    branch: branchRes.stdout.trim(),
+    branch,
     head: headRes.stdout.trim(),
     worktrees,
     defaultTarget
@@ -3459,10 +3670,10 @@ function stateFilePath(repoRoot, baseDir = dataDir()) {
   return path3.join(baseDir, repoHash(repoRoot), "state.json");
 }
 function defaultPrefs() {
-  return { viewMode: "unified", nvimSocketByRoot: {} };
+  return { viewMode: "unified", nvimSocketByRoot: {}, autoRefresh: true };
 }
 function defaultState(repoRoot) {
-  return { schemaVersion: 1, repoRoot, targets: {}, issues: [], prefs: defaultPrefs() };
+  return { schemaVersion: 1, repoRoot, targets: {}, issues: [], todos: [], prefs: defaultPrefs() };
 }
 function ensureTarget(state, key) {
   let t = state.targets[key];
@@ -3482,17 +3693,40 @@ function normalise(raw2, repoRoot) {
     if (!v || typeof v !== "object") continue;
     targets[k] = {
       viewed: typeof v.viewed === "object" && v.viewed ? v.viewed : {},
-      comments: Array.isArray(v.comments) ? v.comments : []
+      comments: Array.isArray(v.comments) ? v.comments : [],
+      ...typeof v.head === "string" ? { head: v.head } : {}
     };
   }
+  migrateLocalComments(targets);
   return {
     schemaVersion: 1,
     repoRoot: r.repoRoot ?? repoRoot,
     targets,
     issues: Array.isArray(r.issues) ? r.issues : [],
-    prefs: { ...defaultPrefs(), ...r.prefs ?? {}, nvimSocketByRoot: r.prefs?.nvimSocketByRoot ?? {} }
+    todos: Array.isArray(r.todos) ? r.todos : [],
+    prefs: {
+      ...defaultPrefs(),
+      ...r.prefs ?? {},
+      nvimSocketByRoot: r.prefs?.nvimSocketByRoot ?? {},
+      autoRefresh: typeof r.prefs?.autoRefresh === "boolean" ? r.prefs.autoRefresh : true
+    }
   };
 }
+function migrateLocalComments(targets) {
+  for (const key of Object.keys(targets).sort()) {
+    const scope = commentScopeKey(key);
+    if (scope === key) continue;
+    const src = 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);
+    src.comments = [];
+  }
+}
 var LOCK_STALE_MS = 5e3;
 var LOCK_WAIT_MS = 5e3;
 async function sleep(ms) {
@@ -3525,7 +3759,7 @@ var StateStore = class {
   }
   /** Apply a mutation under lock. The callback receives the freshest on-disk state. */
   update(fn) {
-    const run = async () => {
+    const run2 = async () => {
       await mkdir(path3.dirname(this.file), { recursive: true });
       const release = await this.acquireLock();
       try {
@@ -3537,7 +3771,7 @@ var StateStore = class {
         await release();
       }
     };
-    const p = this.queue.then(run, run);
+    const p = this.queue.then(run2, run2);
     this.queue = p.catch(() => void 0);
     return p;
   }
@@ -3658,6 +3892,16 @@ function formatIssueExport({ repoRoot, issue, comments }) {
   parts.push(...comments.map(formatCommentSection));
   return parts.join("\n\n") + "\n";
 }
+function formatTodosExport({ repoRoot, branch, todos }) {
+  const head = ["# TODO", `Branch: ${branch}`, `Repo: ${repoRoot}`, `Count: ${todos.length}`];
+  const sections = todos.map((t, i) => {
+    const title = `## ${i + 1}. ${t.title}${t.status === "done" ? " (done)" : ""}`;
+    const body = t.body.replace(/\r\n/g, "\n").trim();
+    return body ? `${title}
+${body}` : title;
+  });
+  return [head.join("\n"), ...sections].join("\n\n") + "\n";
+}
 
 // packages/server/src/nvim.ts
 import os2 from "os";
@@ -3778,9 +4022,116 @@ var NvimService = class {
   }
 };
 
-// packages/server/src/static.ts
+// packages/server/src/watcher.ts
 import path5 from "path";
-import { readFile as readFile3, stat as stat3 } from "fs/promises";
+import { stat as stat3 } from "fs/promises";
+var DEFAULT_POLL_INTERVAL_MS = 1500;
+function statusPaths(out) {
+  const parts = out.split("\0");
+  const paths = [];
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (!entry || entry.length < 3) continue;
+    const x = entry[0];
+    const y = entry[1];
+    const p = entry.slice(3);
+    if (p) paths.push(p);
+    if (x === "R" || x === "C" || y === "R" || y === "C") {
+      const origin = parts[++i];
+      if (origin) paths.push(origin);
+    }
+  }
+  return paths;
+}
+var RepoWatcher = class {
+  constructor(root, intervalMs = DEFAULT_POLL_INTERVAL_MS) {
+    this.root = root;
+    this.intervalMs = intervalMs;
+  }
+  root;
+  intervalMs;
+  listeners = /* @__PURE__ */ new Set();
+  timer = null;
+  signature = null;
+  polling = false;
+  get subscriberCount() {
+    return this.listeners.size;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    this.start();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0) this.stop();
+    };
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => void this.poll(), this.intervalMs);
+    this.timer.unref?.();
+    void this.poll();
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    this.signature = null;
+  }
+  /**
+   * Runs one comparison. Returns the change that was broadcast, or undefined when nothing moved.
+   * The first poll of a watch only records the baseline. Public so tests can step it deterministically.
+   */
+  async poll() {
+    if (this.polling) return void 0;
+    this.polling = true;
+    try {
+      const snap = await this.snapshot();
+      const baseline = this.signature === null;
+      if (this.signature === snap.signature) return void 0;
+      this.signature = snap.signature;
+      if (baseline) return void 0;
+      const change = { head: snap.head, branch: snap.branch, at: (/* @__PURE__ */ new Date()).toISOString() };
+      for (const listener of [...this.listeners]) {
+        try {
+          listener(change);
+        } catch {
+        }
+      }
+      return change;
+    } catch {
+      return void 0;
+    } finally {
+      this.polling = false;
+    }
+  }
+  async snapshot() {
+    const [statusRes, headRes, branch] = await Promise.all([
+      runGit(["status", "--porcelain", "-z"], { cwd: this.root }),
+      runGit(["rev-parse", "HEAD"], { cwd: this.root }).catch(() => ({ stdout: "" })),
+      // The same label getRepoInfo reports, so the branch identity the client filters todos by
+      // never flips between `HEAD` and a short sha depending on which of the two spoke last.
+      currentBranch(this.root)
+    ]);
+    const head = headRes.stdout.trim();
+    const stats = await Promise.all(
+      statusPaths(statusRes.stdout).map(async (rel) => {
+        try {
+          const st = await stat3(path5.join(this.root, rel));
+          return `${rel}	${st.mtimeMs}	${st.size}`;
+        } catch {
+          return `${rel}	-`;
+        }
+      })
+    );
+    return { signature: [head, branch, statusRes.stdout, ...stats].join("\n"), head, branch };
+  }
+};
+
+// packages/server/src/static.ts
+import path6 from "path";
+import { readFile as readFile3, stat as stat4 } from "fs/promises";
 var MIME = {
   ".html": "text/html; charset=utf-8",
   ".js": "text/javascript; charset=utf-8",
@@ -3797,20 +4148,20 @@ var MIME = {
   ".txt": "text/plain; charset=utf-8"
 };
 async function serveStaticFile(c, webDir) {
-  const root = path5.resolve(webDir);
+  const root = path6.resolve(webDir);
   let rel;
   try {
     rel = decodeURIComponent(c.req.path);
   } catch {
     return c.text("Bad Request", 400);
   }
-  let target = path5.resolve(root, "." + rel);
-  if (target !== root && !target.startsWith(root + path5.sep)) return c.text("Forbidden", 403);
+  let target = path6.resolve(root, "." + rel);
+  if (target !== root && !target.startsWith(root + path6.sep)) return c.text("Forbidden", 403);
   try {
-    const st = await stat3(target);
-    if (st.isDirectory()) target = path5.join(target, "index.html");
+    const st = await stat4(target);
+    if (st.isDirectory()) target = path6.join(target, "index.html");
   } catch {
-    target = path5.join(root, "index.html");
+    target = path6.join(root, "index.html");
   }
   let body;
   try {
@@ -3818,7 +4169,7 @@ async function serveStaticFile(c, webDir) {
   } catch {
     return c.text("Not Found", 404);
   }
-  const ext = path5.extname(target).toLowerCase();
+  const ext = path6.extname(target).toLowerCase();
   const isAsset = rel.startsWith("/assets/");
   return new Response(new Uint8Array(body), {
     status: 200,
@@ -3830,6 +4181,7 @@ async function serveStaticFile(c, webDir) {
 }
 
 // packages/server/src/app.ts
+var SSE_HEARTBEAT_MS = 15e3;
 var LISTING_HINT_TTL_MS = 5 * 6e4;
 function createApp(opts) {
   const { repo, store } = opts;
@@ -3837,6 +4189,15 @@ function createApp(opts) {
   const app = new Hono2();
   const listings = /* @__PURE__ */ new Map();
   const changedNotices = /* @__PURE__ */ new Map();
+  const watchers = /* @__PURE__ */ new Map();
+  const watcherFor = (root) => {
+    let w = watchers.get(root);
+    if (!w) {
+      w = new RepoWatcher(root, opts.watchIntervalMs);
+      watchers.set(root, w);
+    }
+    return w;
+  };
   let worktreeCache = null;
   const worktrees = async (force = false) => {
     if (!force && worktreeCache && Date.now() - worktreeCache.at < 1e4) return worktreeCache.list;
@@ -3886,6 +4247,7 @@ function createApp(opts) {
     return c.json({ error: err instanceof Error ? err.message : String(err), code: "internal" }, 500);
   });
   const api = new Hono2();
+  api.get("/ping", (c) => c.text(opts.instanceToken ?? ""));
   api.get("/repo", async (c) => {
     const state = await store.load();
     const info = await getRepoInfo(repo, state.prefs.lastTarget ?? "working");
@@ -3898,6 +4260,7 @@ function createApp(opts) {
     const prefs = await store.update((s) => {
       if (body.viewMode === "unified" || body.viewMode === "split") s.prefs.viewMode = body.viewMode;
       if (typeof body.lastTarget === "string") s.prefs.lastTarget = body.lastTarget;
+      if (typeof body.autoRefresh === "boolean") s.prefs.autoRefresh = body.autoRefresh;
       if (body.nvimSocketByRoot && typeof body.nvimSocketByRoot === "object") {
         s.prefs.nvimSocketByRoot = { ...s.prefs.nvimSocketByRoot, ...body.nvimSocketByRoot };
       }
@@ -3937,7 +4300,8 @@ function createApp(opts) {
       viewed: !stale.includes(d.path) && viewed[d.path] === d.contentHash,
       changed: notices.has(d.path)
     }));
-    const res = { targetKey: key, root: ctx.cwd, files, comments: t?.comments ?? [] };
+    const scope = state.targets[commentScopeKey(key)];
+    const res = { targetKey: key, root: ctx.cwd, files, comments: scope?.comments ?? [] };
     return c.json(res);
   });
   api.get("/targets/:key/file", async (c) => {
@@ -3978,7 +4342,7 @@ function createApp(opts) {
   api.get("/targets/:key/comments", async (c) => {
     const key = decodeKey(c.req.param("key"));
     const state = await store.load();
-    return c.json({ comments: state.targets[key]?.comments ?? [] });
+    return c.json({ comments: state.targets[commentScopeKey(key)]?.comments ?? [] });
   });
   api.post("/targets/:key/comments", async (c) => {
     const key = decodeKey(c.req.param("key"));
@@ -4009,7 +4373,7 @@ function createApp(opts) {
       updatedAt: now
     };
     await store.update((s) => {
-      ensureTarget(s, key).comments.push(comment);
+      ensureTarget(s, commentScopeKey(key)).comments.push(comment);
     });
     return c.json(comment, 201);
   });
@@ -4018,8 +4382,9 @@ function createApp(opts) {
     const id = c.req.param("id");
     const ctx = await targetCtx(key);
     const body = await c.req.json();
+    const scope = commentScopeKey(key);
     const state = await store.load();
-    const existing = state.targets[key]?.comments.find((x) => x.id === id);
+    const existing = state.targets[scope]?.comments.find((x) => x.id === id);
     if (!existing) throw notFound("comment not found");
     let patch = {};
     if (typeof body.body === "string") {
@@ -4042,11 +4407,13 @@ function createApp(opts) {
         endLine: anchored.endLine,
         codeSnippet: anchored.snippet,
         anchor: anchored.anchor,
-        status: existing.exportedAt ? "exported" : "active"
+        status: existing.exportedAt ? "exported" : "active",
+        // Re-attaching in a view moves the comment to it.
+        targetKey: key
       };
     }
     const updated = await store.update((s) => {
-      const t = ensureTarget(s, key);
+      const t = ensureTarget(s, scope);
       const idx = t.comments.findIndex((x) => x.id === id);
       if (idx < 0) throw notFound("comment not found");
       const next = { ...t.comments[idx], ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -4059,7 +4426,7 @@ function createApp(opts) {
     const key = decodeKey(c.req.param("key"));
     const id = c.req.param("id");
     const removed = await store.update((s) => {
-      const t = s.targets[key];
+      const t = s.targets[commentScopeKey(key)];
       if (!t) return false;
       const before = t.comments.length;
       t.comments = t.comments.filter((x) => x.id !== id);
@@ -4072,30 +4439,88 @@ function createApp(opts) {
   api.post("/targets/:key/comments/reanchor", async (c) => {
     const key = decodeKey(c.req.param("key"));
     const ctx = await targetCtx(key);
+    const scope = commentScopeKey(key);
+    const local = isLocalTarget(ctx.target);
     const body = await c.req.json().catch(() => ({})) ?? {};
     const provided = /* @__PURE__ */ new Map();
     for (const f of body.files ?? []) if (f && typeof f.path === "string" && Array.isArray(f.hunks)) provided.set(f.path, f);
-    const state = await store.load();
-    const comments = state.targets[key]?.comments ?? [];
-    const paths = [...new Set(comments.map((x) => x.filePath))];
+    const views = local ? localViewKeys(key) : [key];
+    const contexts = /* @__PURE__ */ new Map([[key, ctx]]);
     const diffs = /* @__PURE__ */ new Map();
+    const diffFor = (view, filePath) => {
+      let byPath = diffs.get(view);
+      if (!byPath) {
+        byPath = /* @__PURE__ */ new Map();
+        diffs.set(view, byPath);
+      }
+      let pending = byPath.get(filePath);
+      if (!pending) {
+        pending = (async () => {
+          if (view === key && provided.has(filePath)) return provided.get(filePath);
+          try {
+            let viewCtx = contexts.get(view);
+            if (!viewCtx) {
+              viewCtx = await targetCtx(view);
+              contexts.set(view, viewCtx);
+            }
+            return await fileDiffWithHints(viewCtx, filePath);
+          } catch {
+            return void 0;
+          }
+        })();
+        byPath.set(filePath, pending);
+      }
+      return pending;
+    };
+    const state = await store.load();
+    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(
-      paths.map(async (p) => {
-        if (provided.has(p)) {
-          diffs.set(p, provided.get(p));
+      comments.map(async (cm) => {
+        const ordered = views.includes(cm.targetKey) ? [cm.targetKey, ...views.filter((v) => v !== cm.targetKey)] : views;
+        for (const view of ordered) {
+          const diff = await diffFor(view, cm.filePath);
+          if (!diff) continue;
+          const next = reanchorComment(cm, diff, now);
+          if (next.status === "orphaned") continue;
+          located.set(cm.id, {
+            side: next.side,
+            startLine: next.startLine,
+            endLine: next.endLine,
+            codeSnippet: next.codeSnippet,
+            anchor: next.anchor,
+            status: next.status,
+            targetKey: view
+          });
           return;
         }
-        try {
-          diffs.set(p, await fileDiffWithHints(ctx, p));
-        } catch {
-          diffs.set(p, void 0);
-        }
       })
     );
-    const now = (/* @__PURE__ */ new Date()).toISOString();
     const result = await store.update((s) => {
-      const t = ensureTarget(s, key);
-      t.comments = t.comments.map((cm) => reanchorComment(cm, diffs.get(cm.filePath), now));
+      const t = ensureTarget(s, scope);
+      const dropped = [];
+      t.comments = t.comments.flatMap((cm) => {
+        const patch = located.get(cm.id);
+        if (!patch) {
+          if (!comments.some((x) => x.id === cm.id)) return [cm];
+          if (committed) {
+            dropped.push(cm.id);
+            return [];
+          }
+          return [cm.status === "orphaned" ? cm : { ...cm, status: "orphaned", updatedAt: now }];
+        }
+        const next = { ...cm, ...patch };
+        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);
+      }
+      t.head = head;
       return t.comments;
     });
     const res = { comments: result };
@@ -4194,6 +4619,73 @@ function createApp(opts) {
     });
     return c.json(res);
   });
+  const knownRoot = async (rootParam) => {
+    if (!rootParam) return repo.root;
+    if (rootParam === repo.root || rootParam === repo.commonRoot) return rootParam;
+    if ((await worktrees()).some((w) => w.path === rootParam)) return rootParam;
+    throw badRequest(`unknown root: ${rootParam}`, "unknown_worktree");
+  };
+  api.get("/todos", async (c) => {
+    const branch = c.req.query("branch") || void 0;
+    const s = await store.load();
+    const res = {
+      todos: branch ? s.todos.filter((t) => t.branch === branch) : s.todos,
+      ...branch ? { branch } : {}
+    };
+    return c.json(res);
+  });
+  api.post("/todos", async (c) => {
+    const body = await c.req.json();
+    if (!body.title || !body.title.trim()) throw badRequest("title is required");
+    const branch = body.branch?.trim() || await currentBranch(await knownRoot(body.root));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const todo = {
+      id: randomUUID(),
+      branch,
+      title: body.title.trim(),
+      body: typeof body.body === "string" ? body.body : "",
+      status: "open",
+      createdAt: now,
+      updatedAt: now
+    };
+    await store.update((s) => {
+      s.todos.push(todo);
+    });
+    return c.json(todo, 201);
+  });
+  api.post("/todos/export", async (c) => {
+    const body = await c.req.json();
+    const branch = typeof body.branch === "string" ? body.branch.trim() : "";
+    if (!branch) throw badRequest("branch is required");
+    const s = await store.load();
+    const todos = s.todos.filter((t) => t.branch === branch && (body.includeDone === true || t.status === "open"));
+    const res = { text: formatTodosExport({ repoRoot: repo.root, branch, todos }), count: todos.length };
+    return c.json(res);
+  });
+  api.patch("/todos/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json();
+    const updated = await store.update((s) => {
+      const todo = s.todos.find((t) => t.id === id);
+      if (!todo) throw notFound("todo not found");
+      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;
+      todo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return todo;
+    });
+    return c.json(updated);
+  });
+  api.delete("/todos/:id", async (c) => {
+    const id = c.req.param("id");
+    const removed = await store.update((s) => {
+      const before = s.todos.length;
+      s.todos = s.todos.filter((t) => t.id !== id);
+      return s.todos.length !== before;
+    });
+    if (!removed) throw notFound("todo not found");
+    return c.json({ ok: true });
+  });
   api.get("/commits", async (c) => {
     const limitRaw = Number(c.req.query("limit") ?? 200);
     const limit = Math.min(Math.max(Number.isFinite(limitRaw) ? Math.floor(limitRaw) : 200, 1), 1e3);
@@ -4231,6 +4723,33 @@ function createApp(opts) {
     const res = { commits: commits.slice(0, limit), hasMore };
     return c.json(res);
   });
+  api.get("/events", async (c) => {
+    const root = c.req.query("root") || repo.root;
+    const known = root === repo.root || root === repo.commonRoot || (await worktrees()).some((w) => w.path === root);
+    if (!known) throw badRequest(`unknown root: ${root}`, "unknown_worktree");
+    return streamSSE(c, async (stream2) => {
+      const watcher = watcherFor(root);
+      let chain = Promise.resolve();
+      const enqueue = (write) => {
+        chain = chain.then(write).catch(() => stream2.abort());
+        return chain;
+      };
+      const release = watcher.subscribe((change) => {
+        const event = { type: "changed", ...change };
+        void enqueue(() => stream2.writeSSE({ event: "changed", data: JSON.stringify(event) }));
+      });
+      stream2.onAbort(release);
+      try {
+        while (!stream2.aborted && !stream2.closed) {
+          await stream2.sleep(SSE_HEARTBEAT_MS);
+          if (stream2.aborted || stream2.closed) break;
+          await enqueue(() => stream2.write(": ping\n\n"));
+        }
+      } finally {
+        release();
+      }
+    });
+  });
   api.get("/nvim/instances", async (c) => {
     const root = c.req.query("root") || repo.root;
     const force = c.req.query("rescan") === "1";
@@ -4255,7 +4774,7 @@ 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 (!path6.isAbsolute(body.absPath)) throw badRequest("absPath must be absolute");
+    if (!path7.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);
@@ -4283,6 +4802,37 @@ function createApp(opts) {
   return app;
 }
 
+// packages/server/src/wsl.ts
+import { execFile as execFile3 } from "child_process";
+import { readFile as readFile4 } from "fs/promises";
+var PROBE_TIMEOUT_MS = 3e3;
+async function isWsl(env = process.env, platform = process.platform) {
+  if (platform !== "linux") return false;
+  if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) return true;
+  try {
+    return /microsoft/i.test(await readFile4("/proc/sys/kernel/osrelease", "utf8"));
+  } catch {
+    return false;
+  }
+}
+function reachableFromWindows(port, token, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    execFile3(
+      "curl.exe",
+      ["--silent", "--max-time", String(Math.ceil(timeoutMs / 1e3)), `http://127.0.0.1:${port}/api/ping`],
+      { timeout: timeoutMs + 1e3, encoding: "utf8", windowsHide: true },
+      (error, stdout) => {
+        const code = error?.code;
+        if (typeof code === "string") {
+          resolve(void 0);
+          return;
+        }
+        resolve(stdout.trim() === token);
+      }
+    );
+  });
+}
+
 // packages/server/src/index.ts
 var HOST = "127.0.0.1";
 var DEFAULT_PORT_START = 4100;
@@ -4301,35 +4851,56 @@ async function findFreePort(start = DEFAULT_PORT_START, host = HOST) {
   }
   throw new Error(`no free port found starting at ${start}`);
 }
+var PROBE_ATTEMPTS = 5;
 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 app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir });
+  const instanceToken = randomUUID2();
+  const app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir, instanceToken });
+  const listen = (p) => new Promise((resolve, reject) => {
+    const s = serve({ fetch: app.fetch, hostname: HOST, port: p }, () => resolve(s));
+    s.once("error", reject);
+  });
+  const stop = (s) => new Promise((resolve, reject) => {
+    s.close((err) => err ? reject(err) : resolve());
+    if ("closeAllConnections" in s) s.closeAllConnections();
+  });
   let port;
+  let server;
+  const skippedPorts = [];
+  let windowsReachable;
   if (opts.port !== void 0) {
     if (!await isPortFree(opts.port)) throw new Error(`port ${opts.port} is already in use`);
     port = opts.port;
+    server = await listen(port);
   } else {
-    port = await findFreePort();
+    const probe = opts.probeWindows ?? (await isWsl() ? reachableFromWindows : void 0);
+    let start = DEFAULT_PORT_START;
+    for (let attempt = 1; ; attempt++) {
+      port = await findFreePort(start);
+      server = await listen(port);
+      if (!probe) break;
+      windowsReachable = await probe(port, instanceToken);
+      if (windowsReachable !== false || attempt >= PROBE_ATTEMPTS) break;
+      await stop(server);
+      skippedPorts.push(port);
+      start = port + 1;
+    }
   }
-  const server = await new Promise((resolve, reject) => {
-    const s = serve({ fetch: app.fetch, hostname: HOST, port }, () => resolve(s));
-    s.once("error", reject);
-  });
   return {
     url: `http://${HOST}:${port}/`,
     port,
     repo,
     stateFile,
-    close: () => new Promise((resolve, reject) => {
-      server.close((err) => err ? reject(err) : resolve());
-    })
+    skippedPorts,
+    windowsReachable,
+    close: () => stop(server)
   };
 }
 
 // bin/cli.ts
-var VERSION = true ? "0.1.0" : "dev";
+var VERSION = true ? "0.3.0" : "dev";
 function parseArgs(argv) {
   const args = { repoPath: process.cwd(), open: true, help: false, version: false };
   for (let i = 0; i < argv.length; i++) {
@@ -4347,7 +4918,7 @@ 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 = path7.resolve(a);
+    else args.repoPath = path8.resolve(a);
   }
   return args;
 }
@@ -4357,7 +4928,8 @@ function usage() {
 Usage: warden [repoPath] [options]
 
 Options:
-  --port <n>, -p <n>   Listen on a fixed port (default: first free port from 4100)
+  --port <n>, -p <n>   Listen on a fixed port (default: first free port from 4100, and under WSL
+                       the first one the Windows side can reach)
   --no-open            Do not try to open the browser
   -h, --help           Show this help
   -v, --version        Print version
@@ -4389,16 +4961,16 @@ async function openBrowser(url) {
   return false;
 }
 function resolveWebDir() {
-  const here = path7.dirname(fileURLToPath(import.meta.url));
+  const here = path8.dirname(fileURLToPath(import.meta.url));
   const candidates = [
     process.env.WARDEN_WEB_DIR,
-    path7.join(here, "web"),
+    path8.join(here, "web"),
     // dist/cli.js -> dist/web
-    path7.join(here, "..", "dist", "web")
+    path8.join(here, "..", "dist", "web")
     // bin/cli.ts (tsx dev) -> dist/web
   ].filter((p) => !!p);
   for (const dir of candidates) {
-    if (existsSync(path7.join(dir, "index.html"))) return dir;
+    if (existsSync(path8.join(dir, "index.html"))) return dir;
   }
   return void 0;
 }
@@ -4434,6 +5006,14 @@ async function main() {
   console.log(`  repo:  ${server.repo.root}`);
   console.log(`  state: ${server.stateFile}`);
   console.log(`  url:   ${server.url}`);
+  if (server.skippedPorts.length > 0) {
+    const ports = server.skippedPorts.join(", ");
+    const plural = server.skippedPorts.length > 1 ? "s" : "";
+    console.log(`  note:  skipped port${plural} ${ports} \u2014 the WSL2 localhost relay does not publish ${plural ? "them" : "it"} to Windows`);
+  }
+  if (server.windowsReachable === false) {
+    console.error(`warning: Windows cannot reach ${server.url} either. Run with --port <n> to pick a port it can publish.`);
+  }
   if (args.open) {
     const opened = await openBrowser(server.url);
     if (!opened) console.log("  (could not open a browser automatically; open the URL manually)");