@staff0rd/assist 0.774.1 → 0.775.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.774.1",
+  version: "0.775.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -10943,209 +10943,11 @@ function delay(ms) {
   return new Promise((resolve28) => setTimeout(resolve28, ms));
 }
 
-// src/commands/sessions/daemon/originForCwd.ts
-var cache = /* @__PURE__ */ new Map();
-function originResolutionForCwd(cwd) {
-  if (!cwd) return void 0;
-  const cached = cache.get(cwd);
-  if (cached !== void 0) return { origin: cached, stable: true };
-  const resolved = resolveCurrentOrigin(cwd);
-  if (resolved.stable) cache.set(cwd, resolved.origin);
-  return resolved;
-}
-function originForCwd(cwd) {
-  return originResolutionForCwd(cwd)?.origin;
-}
-
-// src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync31 } from "fs";
-function repoDirExists(cwd) {
-  return existsSync31(cwd);
-}
-
-// src/commands/sessions/daemon/worktree/git.ts
-import { execFile as execFile2, execFileSync as execFileSync2 } from "child_process";
-function isWindowsPath(cwd) {
-  return /^[A-Za-z]:[\\/]/.test(cwd);
-}
-function gitInvocation(cwd, args) {
-  const windows = isWindowsPath(cwd);
-  return {
-    file: windows ? "git.exe" : "git",
-    argv: windows ? ["-C", cwd, ...args] : args,
-    options: {
-      encoding: "utf8",
-      windowsHide: true,
-      ...windows ? {} : { cwd }
-    }
-  };
-}
-function git(cwd, args) {
-  const { file, argv, options: options2 } = gitInvocation(cwd, args);
-  return new Promise((resolve28, reject) => {
-    execFile2(file, argv, options2, (error, stdout) => {
-      if (error) reject(error);
-      else resolve28(stdout.toString());
-    });
-  });
-}
-async function gitOrNull(cwd, args) {
-  try {
-    return (await git(cwd, args)).trim() || null;
-  } catch {
-    return null;
-  }
-}
-async function gitResult(cwd, args) {
-  try {
-    return { ok: true, out: (await git(cwd, args)).trim() };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function gitSyncResult(cwd, args) {
-  try {
-    return { ok: true, out: gitSync(cwd, args).trim() };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : String(error)
-    };
-  }
-}
-function gitSync(cwd, args) {
-  const { file, argv, options: options2 } = gitInvocation(cwd, args);
-  return execFileSync2(file, argv, {
-    ...options2,
-    stdio: ["pipe", "pipe", "pipe"]
-  }).toString();
-}
-function gitSyncOrNull(cwd, args) {
-  try {
-    return gitSync(cwd, args).trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-// src/commands/sessions/daemon/worktree/listWorktreePaths.ts
-function listWorktreePaths(cwd) {
-  const out = gitSyncOrNull(cwd, ["worktree", "list", "--porcelain"]);
-  if (!out) return [];
-  return out.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim());
-}
-function mainWorktree(cwd) {
-  return listWorktreePaths(cwd)[0] ?? null;
-}
-function listLocalBranches(cwd) {
-  const out = gitSyncOrNull(cwd, [
-    "for-each-ref",
-    "--format=%(refname:short)",
-    "refs/heads"
-  ]);
-  return out ? out.split("\n").map((line) => line.trim()) : [];
-}
-function gitCommonDir(cwd) {
-  return gitSyncOrNull(cwd, [
-    "rev-parse",
-    "--path-format=absolute",
-    "--git-common-dir"
-  ]);
-}
-
-// src/shared/loadJson.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync21 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join36 } from "path";
-function getStoreDir() {
-  return process.env.ASSIST_STORE_DIR || join36(homedir14(), ".assist");
-}
-function getStorePath(filename) {
-  return join36(getStoreDir(), filename);
-}
-function loadJson(filename) {
-  const path106 = getStorePath(filename);
-  if (existsSync32(path106)) {
-    try {
-      return JSON.parse(readFileSync20(path106, "utf8"));
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-function saveJson(filename, data) {
-  const dir = getStoreDir();
-  if (!existsSync32(dir)) {
-    mkdirSync11(dir, { recursive: true });
-  }
-  writeFileSync21(getStorePath(filename), JSON.stringify(data, null, 2));
-}
-
-// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
-var REGISTRY_FILE = "worktrees.json";
-function readWorktreeRegistry() {
-  const data = loadJson(REGISTRY_FILE);
-  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path106, record]) => ({ path: path106, ...record }));
-}
-function worktreeAttributionIncludingReaped(path106) {
-  const record = loadJson(REGISTRY_FILE)[path106];
-  return record ? { clone: record.clone, origin: record.origin } : void 0;
-}
-function recordWorktree(path106, clone, origin) {
-  const data = loadJson(REGISTRY_FILE);
-  data[path106] = { clone, origin };
-  saveJson(REGISTRY_FILE, data);
-}
-function forgetWorktree(path106) {
-  const data = loadJson(REGISTRY_FILE);
-  const record = data[path106];
-  if (!record || record.reaped) return;
-  data[path106] = { ...record, reaped: true };
-  saveJson(REGISTRY_FILE, data);
-}
-
-// src/commands/sessions/daemon/repoGroupForCwd.ts
-var cache2 = /* @__PURE__ */ new Map();
-function repoGroupForCwd(cwd) {
-  if (!cwd) return void 0;
-  if (cache2.has(cwd)) return cache2.get(cwd);
-  const { group, stable } = resolveRepoGroup(cwd);
-  if (stable) cache2.set(cwd, group);
-  return group;
-}
-function resolveRepoGroup(cwd) {
-  const clone = mainWorktree(cwd);
-  const origin = clone ? originResolutionForCwd(clone) : void 0;
-  if (clone && origin)
-    return {
-      group: hostedGroup(origin.origin, clone),
-      stable: origin.stable
-    };
-  const reaped = worktreeAttributionIncludingReaped(cwd);
-  if (!reaped) return { group: void 0, stable: repoDirExists(cwd) };
-  const current = currentOriginOfClone(reaped.clone);
-  return {
-    group: hostedGroup(current?.origin ?? reaped.origin, reaped.clone),
-    stable: current?.stable === true
-  };
-}
-function currentOriginOfClone(clone) {
-  const main = mainWorktree(clone);
-  return main ? originResolutionForCwd(main) : void 0;
-}
-function hostedGroup(origin, clone) {
-  return { origin, clone };
-}
-
 // src/commands/sessions/nodes/tailscaleStatus.ts
-import { execFile as execFile3 } from "child_process";
-import { existsSync as existsSync33 } from "fs";
+import { execFile as execFile2 } from "child_process";
+import { existsSync as existsSync31 } from "fs";
 import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile3);
+var execFileAsync2 = promisify2(execFile2);
 var STATUS_TIMEOUT_MS = 1e4;
 var INSTALLED_CLI = {
   wsl: "/mnt/c/Program Files/Tailscale/tailscale.exe",
@@ -11155,7 +10957,7 @@ var INSTALLED_CLI = {
 function tailscaleCli() {
   const platform = detectPlatform();
   const installed = INSTALLED_CLI[platform];
-  if (installed && existsSync33(installed)) return installed;
+  if (installed && existsSync31(installed)) return installed;
   return platform === "wsl" ? "tailscale.exe" : "tailscale";
 }
 async function tailscaleStatus() {
@@ -11214,9 +11016,9 @@ async function runningStatus(status2) {
 }
 
 // src/commands/sessions/nodes/runTailscale.ts
-import { execFile as execFile4 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile4);
+var execFileAsync3 = promisify3(execFile3);
 async function runTailscale(args) {
   const { stdout } = await execFileAsync3(tailscaleCli(), args, {
     encoding: "utf8",
@@ -11433,16 +11235,16 @@ function attachSessionSocket(server, ctx) {
 
 // src/shared/createBundleHandler.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync21, statSync as statSync5 } from "fs";
-import { dirname as dirname21, join as join37 } from "path";
+import { readFileSync as readFileSync20, statSync as statSync5 } from "fs";
+import { dirname as dirname21, join as join36 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function createBundleHandler(importMetaUrl, bundlePath, contentType = "application/javascript") {
-  const file = join37(dirname21(fileURLToPath4(importMetaUrl)), bundlePath);
+  const file = join36(dirname21(fileURLToPath4(importMetaUrl)), bundlePath);
   let cache6;
   return (req, res) => {
     const mtimeMs = statSync5(file).mtimeMs;
     if (cache6?.mtimeMs !== mtimeMs) {
-      const body = readFileSync21(file, "utf8");
+      const body = readFileSync20(file, "utf8");
       const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache6 = { body, etag, mtimeMs };
     }
@@ -11482,12 +11284,12 @@ function createFallbackHandler(routes3, htmlHandler2, extra) {
 }
 
 // src/commands/backlog/resolveRepoLocation.ts
-import { existsSync as existsSync34 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 function resolveRepoLocation(origin, knownCwd, baseDir) {
   if (knownCwd) return { cwd: knownCwd };
   const target = cloneTargetDir(origin, baseDir);
   if (!target) return {};
-  if (existsSync34(target) && getCurrentOrigin(target) === origin)
+  if (existsSync32(target) && getCurrentOrigin(target) === origin)
     return { cwd: target };
   return { cloneTarget: target };
 }
@@ -11896,9 +11698,9 @@ function getSessionParam(req) {
 }
 
 // src/commands/sessions/web/execGit.ts
-import { execFile as execFile5 } from "child_process";
+import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
-var execFileAsync4 = promisify4(execFile5);
+var execFileAsync4 = promisify4(execFile4);
 async function execGit(cwd, args, opts = {}) {
   const { maxBuffer, allowFailure } = opts;
   const { file, argv } = /^[A-Za-z]:[\\/]/.test(cwd) ? { file: "git.exe", argv: ["-C", cwd, ...args] } : { file: "git", argv: args };
@@ -12087,17 +11889,17 @@ async function commitPaths(cwd, sha) {
 }
 
 // src/commands/sessions/web/committedPaths.ts
-var cache3 = /* @__PURE__ */ new Map();
+var cache = /* @__PURE__ */ new Map();
 var inFlight = /* @__PURE__ */ new Map();
 var CACHE_TTL_MS = 1e4;
 async function committedPaths(cwd, sessionId) {
   const key = `${cwd} ${sessionId}`;
-  const cached = cache3.get(key);
+  const cached = cache.get(key);
   if (cached && cached.expiresAt > Date.now()) return cached.value;
   const pending = inFlight.get(key);
   if (pending) return pending;
   const lookup = loadCommittedPaths(cwd, sessionId).then((value) => {
-    cache3.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+    cache.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
     return value;
   }).finally(() => inFlight.delete(key));
   inFlight.set(key, lookup);
@@ -13549,26 +13351,26 @@ function handleServerRuns(req, res) {
 }
 
 // src/commands/sessions/web/getReviewSynthesis.ts
-import { execFile as execFile6 } from "child_process";
-import { readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir15 } from "os";
-import { basename as basename11, join as join39 } from "path";
+import { execFile as execFile5 } from "child_process";
+import { readFileSync as readFileSync21 } from "fs";
+import { homedir as homedir14 } from "os";
+import { basename as basename11, join as join38 } from "path";
 import { promisify as promisify5 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
-import { existsSync as existsSync35, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
-import { basename as basename10, dirname as dirname22, join as join38 } from "path";
+import { existsSync as existsSync33, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { basename as basename10, dirname as dirname22, join as join37 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
-  const branchKeyPath = join38(repoReviewsDir, `${branch2}-`);
+  const branchKeyPath = join37(repoReviewsDir, `${branch2}-`);
   const parent = dirname22(branchKeyPath);
   const branchPrefix = basename10(branchKeyPath);
-  if (!existsSync35(parent)) return null;
-  const synthesisFiles = readdirSync5(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join38(parent, name, "synthesis.md")).filter((path106) => existsSync35(path106)).map((path106) => ({ path: path106, mtime: statSync6(path106).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  if (!existsSync33(parent)) return null;
+  const synthesisFiles = readdirSync5(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join37(parent, name, "synthesis.md")).filter((path106) => existsSync33(path106)).map((path106) => ({ path: path106, mtime: statSync6(path106).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
 // src/commands/sessions/web/getReviewSynthesis.ts
-var execFileAsync5 = promisify5(execFile6);
+var execFileAsync5 = promisify5(execFile5);
 function runGit2(cwd, args) {
   return execFileAsync5("git", args, {
     encoding: "utf8",
@@ -13581,8 +13383,8 @@ async function resolveSynthesisPath(cwd) {
     runGit2(cwd, ["rev-parse", "--show-toplevel"]),
     runGit2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])
   ]);
-  const repoReviewsDir = join39(
-    homedir15(),
+  const repoReviewsDir = join38(
+    homedir14(),
     ".assist",
     "reviews",
     basename11(repoRoot2)
@@ -13598,7 +13400,7 @@ async function getReviewSynthesis(req, res) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync22(path106, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path106, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -13621,7 +13423,7 @@ var EMPTY = {
   defaultBranch: null,
   onDefaultBranch: false
 };
-var cache4 = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 async function currentBranch2(cwd) {
   try {
     const branch2 = (await execGit(cwd, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
@@ -13644,7 +13446,7 @@ async function resolve11(cwd) {
 }
 async function gitBranchInfo(cwd) {
   const now = Date.now();
-  const cached = cache4.get(cwd);
+  const cached = cache2.get(cwd);
   if (cached && cached.expires > now) return cached.value;
   let value = EMPTY;
   try {
@@ -13652,7 +13454,7 @@ async function gitBranchInfo(cwd) {
   } catch {
     value = EMPTY;
   }
-  cache4.set(cwd, { value, expires: now + CACHE_TTL_MS2 });
+  cache2.set(cwd, { value, expires: now + CACHE_TTL_MS2 });
   return value;
 }
 
@@ -13808,10 +13610,10 @@ function protocolMismatched(msg) {
   return typeof msg.protocol === "number" && msg.protocol !== PROTOCOL_VERSION;
 }
 
-// src/commands/sessions/nodes/queryNodes.ts
+// src/commands/sessions/daemon/requestDaemonReply.ts
 import { createInterface as createInterface5 } from "readline";
 var QUERY_TIMEOUT_MS = 3e3;
-async function queryNodes() {
+async function requestDaemonReply(request, replyType) {
   let socket;
   try {
     socket = await connectToDaemon();
@@ -13831,16 +13633,21 @@ async function queryNodes() {
     lines2.on("line", (line) => {
       try {
         const data = JSON.parse(line);
-        if (data.type === "nodes") finish2(data);
+        if (data.type === replyType) finish2(data);
       } catch {
       }
     });
     socket.on("error", () => finish2(void 0));
-    socket.write(`${JSON.stringify({ type: "nodes" })}
+    socket.write(`${JSON.stringify(request)}
 `);
   });
 }
 
+// src/commands/sessions/nodes/queryNodes.ts
+function queryNodes() {
+  return requestDaemonReply({ type: "nodes" }, "nodes");
+}
+
 // src/commands/sessions/web/health.ts
 async function health(_req, res) {
   const [reachable, nodes] = await Promise.all([
@@ -13871,6 +13678,35 @@ function hotkeyBindings(_req, res) {
   respondJson(res, 200, resolveHotkeys(loadConfig().sessions?.hotkeys));
 }
 
+// src/shared/loadJson.ts
+import { existsSync as existsSync34, mkdirSync as mkdirSync11, readFileSync as readFileSync22, writeFileSync as writeFileSync21 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join39 } from "path";
+function getStoreDir() {
+  return process.env.ASSIST_STORE_DIR || join39(homedir15(), ".assist");
+}
+function getStorePath(filename) {
+  return join39(getStoreDir(), filename);
+}
+function loadJson(filename) {
+  const path106 = getStorePath(filename);
+  if (existsSync34(path106)) {
+    try {
+      return JSON.parse(readFileSync22(path106, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function saveJson(filename, data) {
+  const dir = getStoreDir();
+  if (!existsSync34(dir)) {
+    mkdirSync11(dir, { recursive: true });
+  }
+  writeFileSync21(getStorePath(filename), JSON.stringify(data, null, 2));
+}
+
 // src/commands/sessions/web/jiraSite.ts
 function jiraSite(_req, res) {
   const config = loadJson("jira.json");
@@ -14086,11 +13922,11 @@ function newsNavConfig(_req, res) {
 }
 
 // src/commands/sessions/web/releases/ghJson.ts
-import { execFile as execFile7 } from "child_process";
+import { execFile as execFile6 } from "child_process";
 import { promisify as promisify6 } from "util";
-var execFileAsync6 = promisify6(execFile7);
+var execFileAsync6 = promisify6(execFile6);
 var CACHE_TTL_MS4 = 3e4;
-var cache5 = /* @__PURE__ */ new Map();
+var cache3 = /* @__PURE__ */ new Map();
 function partialGraphqlData(error) {
   const stdout = error.stdout;
   if (typeof stdout !== "string") return null;
@@ -14118,12 +13954,12 @@ async function runGh(cwd, args) {
 }
 function ghJson(cwd, args) {
   const key = [cwd, ...args].join("\0");
-  const hit = cache5.get(key);
+  const hit = cache3.get(key);
   if (hit && Date.now() - hit.at < CACHE_TTL_MS4)
     return hit.result;
   const result = runGh(cwd, args);
-  cache5.set(key, { at: Date.now(), result });
-  result.catch(() => cache5.delete(key));
+  cache3.set(key, { at: Date.now(), result });
+  result.catch(() => cache3.delete(key));
   return result;
 }
 
@@ -14649,7 +14485,7 @@ function assertProjectScope() {
 }
 
 // src/commands/github/issue/assignIssueToSelf.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 function assignIssueToSelf(number, repo) {
   const args = [
     "issue",
@@ -14661,7 +14497,7 @@ function assignIssueToSelf(number, repo) {
     "@me"
   ];
   try {
-    execFileSync3("gh", args, {
+    execFileSync2("gh", args, {
       stdio: ["ignore", "ignore", "pipe"],
       encoding: "utf8"
     });
@@ -14831,7 +14667,7 @@ async function nextPickup(req, res) {
 import path27 from "path";
 
 // src/commands/rules/readScopedRules.ts
-import { existsSync as existsSync37, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync23 } from "fs";
 import path26 from "path";
 
 // src/commands/rules/rulesSectionRange.ts
@@ -14867,24 +14703,24 @@ function parseRulesSection(content) {
   const lines2 = content.split(/\r?\n/);
   const range = rulesSectionRange(lines2);
   if (!range) return [];
-  const rules3 = [];
+  const rules2 = [];
   for (const line of lines2.slice(range.start + 1, range.end)) {
     const match = RULE_BULLET.exec(line);
     if (!match) continue;
     const code = match[1].trim();
     const rest = match[2].trim();
     if (code === "" || rest === "") continue;
-    rules3.push({ code, ...splitTitle(rest) });
+    rules2.push({ code, ...splitTitle(rest) });
   }
-  return rules3;
+  return rules2;
 }
 
 // src/commands/rules/scopeDirectory.ts
-import { existsSync as existsSync36, statSync as statSync7 } from "fs";
+import { existsSync as existsSync35, statSync as statSync7 } from "fs";
 import path25 from "path";
 function scopeDirectory(target) {
   const resolved = path25.resolve(target);
-  return existsSync36(resolved) && statSync7(resolved).isDirectory() ? resolved : path25.dirname(resolved);
+  return existsSync35(resolved) && statSync7(resolved).isDirectory() ? resolved : path25.dirname(resolved);
 }
 
 // src/commands/rules/readScopedRules.ts
@@ -14895,7 +14731,7 @@ function scopedClaudeFiles(target) {
   let current = startDir;
   while (true) {
     const candidate = path26.join(current, "CLAUDE.md");
-    if (existsSync37(candidate)) files.push(candidate);
+    if (existsSync36(candidate)) files.push(candidate);
     if (current === root2 || current === path26.dirname(current)) break;
     current = path26.dirname(current);
   }
@@ -15206,9 +15042,9 @@ async function openInCode(req, res) {
 }
 
 // src/commands/sessions/web/createCachedGhJson.ts
-import { execFile as execFile8 } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import { promisify as promisify8 } from "util";
-var execFileAsync7 = promisify8(execFile8);
+var execFileAsync7 = promisify8(execFile7);
 var CACHE_TTL_MS5 = 3e4;
 function createCachedGhJson(args, parse5, fallback, options2 = {}) {
   const { cacheFallback = true } = options2;
@@ -15306,7 +15142,7 @@ function peerTimeoutFor(pathname) {
 }
 
 // src/commands/sessions/web/isQuietPoll.ts
-var POLLED_PATHS = /* @__PURE__ */ new Set(["/api/git-status"]);
+var POLLED_PATHS = /* @__PURE__ */ new Set(["/api/git-status", "/api/updates"]);
 function isQuietPoll(pathname, status2) {
   return POLLED_PATHS.has(pathname) && status2 >= 200 && status2 < 300;
 }
@@ -15459,9 +15295,9 @@ async function previewImage(req, res) {
 }
 
 // src/commands/sessions/web/prStatus.ts
-import { execFile as execFile9 } from "child_process";
+import { execFile as execFile8 } from "child_process";
 import { promisify as promisify9 } from "util";
-var execFileAsync8 = promisify9(execFile9);
+var execFileAsync8 = promisify9(execFile8);
 function toPrSummary(parsed) {
   if (typeof parsed.number !== "number") return null;
   return {
@@ -16070,19 +15906,19 @@ async function revertDiffFile(req, res) {
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync38 } from "fs";
 
 // src/commands/run/resolveCommand.ts
-import { execFileSync as execFileSync4 } from "child_process";
-import { existsSync as existsSync38 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync37 } from "fs";
 import { dirname as dirname23, join as join40, resolve as resolve13 } from "path";
 function resolveCommand(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
-    const gitPath = execFileSync4("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
+    const gitPath = execFileSync3("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve13(dirname23(gitPath), "..");
     const gitBash = join40(gitRoot, "bin", "bash.exe");
-    if (existsSync38(gitBash)) return gitBash;
+    if (existsSync37(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -16092,7 +15928,7 @@ function resolveCommand(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync39(cwd)) {
+    if (cwd && !existsSync38(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -16406,6 +16242,23 @@ function findTailscalePeer(status2, hostname2) {
   );
 }
 
+// src/commands/sessions/nodes/tailscaleCliFailure.ts
+function tailscaleCliFailure(error, cli) {
+  const detail = describePeerError(error);
+  const owner = /Tailscale already in use by (\S+?),/.exec(detail)?.[1];
+  if (owner)
+    return failed(
+      "tailscale",
+      `Tailscale on this node is signed in by Windows user ${owner}, so it is disconnected while another user is active`,
+      `sign in to Windows as ${owner} and run \`${cli} up --unattended\` (or tick "Run unattended" in Tailscale's menu) so it stays connected for every user; otherwise sign ${owner} out and run \`${cli} up\` as this user`
+    );
+  return failed(
+    "tailscale",
+    detail,
+    `\`${cli} status --json\` failed \u2014 install Tailscale on this node and sign in with \`${cli} up\``
+  );
+}
+
 // src/commands/sessions/nodes/tailscaleHop.ts
 async function tailscaleHop(spec, probes) {
   const cli = tailscaleCli();
@@ -16413,11 +16266,7 @@ async function tailscaleHop(spec, probes) {
   try {
     status2 = await probes.tailscale();
   } catch (error) {
-    return failed(
-      "tailscale",
-      describePeerError(error),
-      `\`${cli} status --json\` failed \u2014 install Tailscale on this node and sign in with \`${cli} up\``
-    );
+    return tailscaleCliFailure(error, cli);
   }
   if (status2.BackendState !== "Running")
     return failed(
@@ -16437,7 +16286,7 @@ async function tailscaleHop(spec, probes) {
     return failed(
       "tailscale",
       `${hostname2} is offline in the tailnet`,
-      `is ${spec.name}'s machine awake with Tailscale running and signed in?`
+      `is ${spec.name}'s machine awake with Tailscale running and signed in? On Windows, Tailscale disconnects while a user other than the one who signed it in is active unless it runs unattended \u2014 run \`assist sessions nodes doctor\` on ${spec.name}`
     );
   return passed(
     "tailscale",
@@ -17164,6 +17013,194 @@ function unsetConfig(req, res) {
   });
 }
 
+// src/commands/watch/resolveUpstream.ts
+import { execFileSync as execFileSync4 } from "child_process";
+function runGit3(args, cwd) {
+  return execFileSync4("git", args, {
+    encoding: "utf8",
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd
+  }).trim();
+}
+function resolveUpstream(cwd) {
+  try {
+    runGit3(["rev-parse", "--is-inside-work-tree"], cwd);
+  } catch {
+    throw new Error(
+      "not a git repository \u2014 run assist watch wait from inside a repo"
+    );
+  }
+  let branch2;
+  try {
+    branch2 = runGit3(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
+  } catch {
+    throw new Error(
+      "HEAD is detached \u2014 check out a branch before waiting on its upstream"
+    );
+  }
+  try {
+    return {
+      branch: branch2,
+      upstream: runGit3(
+        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        cwd
+      )
+    };
+  } catch {
+    throw new Error(
+      `branch "${branch2}" has no upstream \u2014 set one with: git push -u origin ${branch2}`
+    );
+  }
+}
+
+// src/commands/watch/changedPaths.ts
+function changedPaths(from, cwd) {
+  return runGit3(["diff", "--name-only", `${from}..HEAD`], cwd).split("\n").filter((line) => line.length > 0);
+}
+
+// src/commands/watch/readBuiltVersion.ts
+import { join as join41 } from "path";
+function readBuiltVersion(cwd) {
+  try {
+    const root2 = runGit3(["rev-parse", "--show-toplevel"], cwd);
+    return readPackageJson(join41(root2, "package.json")).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+// src/commands/watch/restartRules.ts
+var webUiPrefix = "src/commands/sessions/web/ui/";
+var sessionsPrefix = "src/commands/sessions/";
+var restartRules = [
+  {
+    target: "webserver",
+    matches: (path106) => path106.startsWith(webUiPrefix),
+    advice: "restart the web server, then hard-reload the browser tab"
+  },
+  {
+    target: "daemon",
+    matches: (path106) => path106.startsWith(sessionsPrefix) && !path106.startsWith(webUiPrefix),
+    advice: "restart the daemon"
+  }
+];
+
+// src/commands/watch/restartTargets.ts
+function restartTargets(paths) {
+  return restartRules.filter((rule) => paths.some(rule.matches)).map((rule) => rule.target);
+}
+
+// src/commands/sessions/web/updates/pendingRestarts.ts
+function targetsSince(commit2, target, changedSince2) {
+  return commit2 !== void 0 && restartTargets(changedSince2(commit2)).includes(target);
+}
+function pendingRestarts(input) {
+  const { daemonVersion, built, changedSince: changedSince2 } = input;
+  const daemon = daemonVersion !== void 0 && (built !== "unknown" && daemonVersion !== built || targetsSince(input.daemonStartCommit, "daemon", changedSince2));
+  const web3 = targetsSince(input.webStartCommit, "webserver", changedSince2);
+  return [
+    ...daemon ? ["daemon"] : [],
+    ...web3 ? ["webserver"] : []
+  ];
+}
+
+// src/shared/stripAnsi.ts
+var ANSI = new RegExp(
+  `${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`,
+  "g"
+);
+function stripAnsi(text17) {
+  return text17.replace(ANSI, "");
+}
+
+// src/commands/sessions/daemon/worktree/watcherLogPath.ts
+import { createHash as createHash2 } from "crypto";
+import { homedir as homedir16 } from "os";
+import { basename as basename12, join as join42 } from "path";
+
+// src/commands/sessions/daemon/worktree/canonicalTreePath.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { resolve as resolve14 } from "path";
+function canonicalTreePath(path106) {
+  try {
+    return realpathSync2(path106);
+  } catch {
+    return resolve14(path106);
+  }
+}
+
+// src/commands/sessions/daemon/worktree/watcherLogPath.ts
+function watcherLogPath(cwd) {
+  const clone = canonicalTreePath(cwd);
+  const key = createHash2("sha1").update(clone).digest("hex").slice(0, 8);
+  const dir = process.env.ASSIST_WATCHER_LOG_DIR ?? join42(homedir16(), ".assist", "watchers");
+  return join42(dir, `${basename12(clone) || "root"}-${key}.log`);
+}
+
+// src/commands/sessions/web/updates/readUpdateHistory.ts
+var HISTORY_LINES = 200;
+function readUpdateHistory(installDir) {
+  return readLogTail(watcherLogPath(installDir), HISTORY_LINES * 2).flatMap((line) => line.split("\r")).map((line) => stripAnsi(line).trimEnd()).filter((line) => line.trim().length > 0).slice(-HISTORY_LINES);
+}
+
+// src/commands/watch/headCommit.ts
+function headCommit3(cwd) {
+  try {
+    return runGit3(["rev-parse", "HEAD"], cwd);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/sessions/web/updates/webStartCommit.ts
+var captured;
+var webStartCommit = {
+  capture: () => {
+    captured = headCommit3(getInstallDir());
+  },
+  value: () => captured
+};
+
+// src/commands/sessions/web/updates/updates.ts
+function changedSince(installDir) {
+  return (commit2) => {
+    try {
+      return changedPaths(commit2, installDir);
+    } catch {
+      return [];
+    }
+  };
+}
+async function updates(_req, res) {
+  const installDir = getInstallDir();
+  const reply2 = await requestDaemonReply(
+    { type: "auto-update" },
+    "auto-update"
+  );
+  const built = readBuiltVersion(installDir);
+  const status2 = {
+    nodeName: resolveNodeName(),
+    installDir,
+    running: reply2?.version ?? ASSIST_VERSION,
+    built,
+    restart: pendingRestarts({
+      daemonVersion: reply2?.version,
+      daemonStartCommit: reply2?.startCommit,
+      webStartCommit: webStartCommit.value(),
+      built,
+      changedSince: changedSince(installDir)
+    }),
+    daemonReachable: reply2 !== void 0,
+    loop: reply2?.loop ?? {
+      phase: "off",
+      since: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: "daemon not reachable"
+    },
+    history: readUpdateHistory(installDir)
+  };
+  respondJson(res, 200, status2);
+}
+
 // src/commands/sessions/web/readRequestBuffer.ts
 async function readRequestBuffer(req, limit) {
   const chunks = [];
@@ -17185,7 +17222,7 @@ async function readRequestBuffer(req, limit) {
 
 // src/commands/sessions/web/stageAttachment.ts
 import { mkdir as mkdir4, mkdtemp, writeFile as writeFile2 } from "fs/promises";
-import { extname as extname2, join as join41 } from "path";
+import { extname as extname2, join as join43 } from "path";
 function extensionFromMime(contentType) {
   const mime = contentType.split(";")[0].trim().toLowerCase();
   const known = attachmentMimeTypes[mime];
@@ -17213,9 +17250,9 @@ function safeBaseName(name) {
 async function stageAttachment(name, contentType, body) {
   const ext = pickExtension(name, contentType);
   await mkdir4(stagedAttachmentsDir, { recursive: true });
-  const dir = await mkdtemp(join41(stagedAttachmentsDir, "upload-"));
+  const dir = await mkdtemp(join43(stagedAttachmentsDir, "upload-"));
   const alt = safeBaseName(name);
-  const filePath = join41(dir, `${alt}.${ext}`);
+  const filePath = join43(dir, `${alt}.${ext}`);
   await writeFile2(filePath, body);
   return { dir, filePath, alt };
 }
@@ -17263,17 +17300,17 @@ async function uploadPrImage(req, res) {
 import { readFile as readFile3, stat as stat4, writeFile as writeFile3 } from "fs/promises";
 
 // src/commands/sessions/web/formatWithOxfmt.ts
-import { execFile as execFile10 } from "child_process";
-import { existsSync as existsSync40 } from "fs";
-import { dirname as dirname24, join as join42 } from "path";
+import { execFile as execFile9 } from "child_process";
+import { existsSync as existsSync39 } from "fs";
+import { dirname as dirname24, join as join44 } from "path";
 import { promisify as promisify10 } from "util";
-var execFileAsync9 = promisify10(execFile10);
+var execFileAsync9 = promisify10(execFile9);
 var TIMEOUT_MS = 15e3;
 function findOxfmtScript(root2) {
   let dir = root2;
   for (; ; ) {
-    const candidate = join42(dir, "node_modules", "oxfmt", "bin", "oxfmt");
-    if (existsSync40(candidate)) return candidate;
+    const candidate = join44(dir, "node_modules", "oxfmt", "bin", "oxfmt");
+    if (existsSync39(candidate)) return candidate;
     const parent = dirname24(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -17343,7 +17380,7 @@ async function writeFileContent(req, res) {
 }
 
 // src/commands/sessions/web/createCssHandler.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { readFileSync as readFileSync24 } from "fs";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -17353,7 +17390,7 @@ function createCssHandler(packageEntry) {
     if (!cache6) {
       const resolved = require2.resolve(packageEntry);
       const body = readFileSync24(resolved, "utf8");
-      const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
+      const etag = `"${createHash3("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache6 = { body, etag };
     }
     const headers = { ETag: cache6.etag, "Cache-Control": "no-cache" };
@@ -17436,7 +17473,8 @@ var routes2 = {
   "GET /api/config": getConfig,
   "POST /api/config/set": setConfig,
   "POST /api/config/unset": unsetConfig,
-  "GET /api/review/synthesis": getReviewSynthesis
+  "GET /api/review/synthesis": getReviewSynthesis,
+  "GET /api/updates": updates
 };
 var handleRequest = createFallbackHandler(
   routes2,
@@ -17705,11 +17743,183 @@ function scheduleReconnect() {
   setTimeout(() => void connect2(), RECONNECT_MS).unref();
 }
 
-// src/commands/sessions/web.ts
+// src/commands/sessions/daemon/originForCwd.ts
+var cache4 = /* @__PURE__ */ new Map();
+function originResolutionForCwd(cwd) {
+  if (!cwd) return void 0;
+  const cached = cache4.get(cwd);
+  if (cached !== void 0) return { origin: cached, stable: true };
+  const resolved = resolveCurrentOrigin(cwd);
+  if (resolved.stable) cache4.set(cwd, resolved.origin);
+  return resolved;
+}
+function originForCwd(cwd) {
+  return originResolutionForCwd(cwd)?.origin;
+}
+
+// src/commands/sessions/daemon/repoDirExists.ts
+import { existsSync as existsSync40 } from "fs";
+function repoDirExists(cwd) {
+  return existsSync40(cwd);
+}
+
+// src/commands/sessions/daemon/worktree/git.ts
+import { execFile as execFile10, execFileSync as execFileSync5 } from "child_process";
+function isWindowsPath(cwd) {
+  return /^[A-Za-z]:[\\/]/.test(cwd);
+}
+function gitInvocation(cwd, args) {
+  const windows = isWindowsPath(cwd);
+  return {
+    file: windows ? "git.exe" : "git",
+    argv: windows ? ["-C", cwd, ...args] : args,
+    options: {
+      encoding: "utf8",
+      windowsHide: true,
+      ...windows ? {} : { cwd }
+    }
+  };
+}
+function git(cwd, args) {
+  const { file, argv, options: options2 } = gitInvocation(cwd, args);
+  return new Promise((resolve28, reject) => {
+    execFile10(file, argv, options2, (error, stdout) => {
+      if (error) reject(error);
+      else resolve28(stdout.toString());
+    });
+  });
+}
+async function gitOrNull(cwd, args) {
+  try {
+    return (await git(cwd, args)).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function gitResult(cwd, args) {
+  try {
+    return { ok: true, out: (await git(cwd, args)).trim() };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function gitSyncResult(cwd, args) {
+  try {
+    return { ok: true, out: gitSync(cwd, args).trim() };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function gitSync(cwd, args) {
+  const { file, argv, options: options2 } = gitInvocation(cwd, args);
+  return execFileSync5(file, argv, {
+    ...options2,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).toString();
+}
+function gitSyncOrNull(cwd, args) {
+  try {
+    return gitSync(cwd, args).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/sessions/daemon/worktree/listWorktreePaths.ts
+function listWorktreePaths(cwd) {
+  const out = gitSyncOrNull(cwd, ["worktree", "list", "--porcelain"]);
+  if (!out) return [];
+  return out.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.slice("worktree ".length).trim());
+}
+function mainWorktree(cwd) {
+  return listWorktreePaths(cwd)[0] ?? null;
+}
+function listLocalBranches(cwd) {
+  const out = gitSyncOrNull(cwd, [
+    "for-each-ref",
+    "--format=%(refname:short)",
+    "refs/heads"
+  ]);
+  return out ? out.split("\n").map((line) => line.trim()) : [];
+}
+function gitCommonDir(cwd) {
+  return gitSyncOrNull(cwd, [
+    "rev-parse",
+    "--path-format=absolute",
+    "--git-common-dir"
+  ]);
+}
+
+// src/commands/sessions/daemon/worktree/readWorktreeRegistry.ts
+var REGISTRY_FILE = "worktrees.json";
+function readWorktreeRegistry() {
+  const data = loadJson(REGISTRY_FILE);
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path106, record]) => ({ path: path106, ...record }));
+}
+function worktreeAttributionIncludingReaped(path106) {
+  const record = loadJson(REGISTRY_FILE)[path106];
+  return record ? { clone: record.clone, origin: record.origin } : void 0;
+}
+function recordWorktree(path106, clone, origin) {
+  const data = loadJson(REGISTRY_FILE);
+  data[path106] = { clone, origin };
+  saveJson(REGISTRY_FILE, data);
+}
+function forgetWorktree(path106) {
+  const data = loadJson(REGISTRY_FILE);
+  const record = data[path106];
+  if (!record || record.reaped) return;
+  data[path106] = { ...record, reaped: true };
+  saveJson(REGISTRY_FILE, data);
+}
+
+// src/commands/sessions/daemon/repoGroupForCwd.ts
+var cache5 = /* @__PURE__ */ new Map();
+function repoGroupForCwd(cwd) {
+  if (!cwd) return void 0;
+  if (cache5.has(cwd)) return cache5.get(cwd);
+  const { group, stable } = resolveRepoGroup(cwd);
+  if (stable) cache5.set(cwd, group);
+  return group;
+}
+function resolveRepoGroup(cwd) {
+  const clone = mainWorktree(cwd);
+  const origin = clone ? originResolutionForCwd(clone) : void 0;
+  if (clone && origin)
+    return {
+      group: hostedGroup(origin.origin, clone),
+      stable: origin.stable
+    };
+  const reaped = worktreeAttributionIncludingReaped(cwd);
+  if (!reaped) return { group: void 0, stable: repoDirExists(cwd) };
+  const current = currentOriginOfClone(reaped.clone);
+  return {
+    group: hostedGroup(current?.origin ?? reaped.origin, reaped.clone),
+    stable: current?.stable === true
+  };
+}
+function currentOriginOfClone(clone) {
+  const main = mainWorktree(clone);
+  return main ? originResolutionForCwd(main) : void 0;
+}
+function hostedGroup(origin, clone) {
+  return { origin, clone };
+}
+
+// src/commands/sessions/repoEntryCwd.ts
 function repoEntryCwd(serverCwd) {
   return repoGroupForCwd(serverCwd)?.clone ?? serverCwd;
 }
+
+// src/commands/sessions/web.ts
 async function web(options2) {
+  webStartCommit.capture();
   const port = Number.parseInt(options2.port, 10);
   const server = startWebServer(
     "Assist",
@@ -18115,7 +18325,7 @@ function registerBranch(program2) {
 }
 
 // src/commands/cliHook.ts
-import { basename as basename12 } from "path";
+import { basename as basename13 } from "path";
 
 // src/shared/splitCompound.ts
 import { parse } from "shell-quote";
@@ -18691,7 +18901,7 @@ function findTruncatedReadDenyRaw(rawCommand) {
 }
 
 // src/shared/isApprovedRead.ts
-import { resolve as resolve15, sep as sep2 } from "path";
+import { resolve as resolve16, sep as sep2 } from "path";
 
 // src/shared/appliesFixStructure.ts
 var APPLY_RE = /^assist\s+github\s+issue\s+fix-structure\b.*\s--apply\b/;
@@ -18745,7 +18955,7 @@ function extractGraphqlQuery(args) {
 
 // src/shared/loadCliReads.ts
 import { existsSync as existsSync41, readFileSync as readFileSync26, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname25, resolve as resolve14 } from "path";
+import { dirname as dirname25, resolve as resolve15 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
 var __dirname4 = dirname25(__filename3);
@@ -18760,13 +18970,13 @@ var cachedReads;
 var cachedWrites;
 function getCliReadsLines() {
   if (!cachedReads) {
-    cachedReads = readLines(resolve14(packageRoot(), "allowed.cli-reads"));
+    cachedReads = readLines(resolve15(packageRoot(), "allowed.cli-reads"));
   }
   return cachedReads;
 }
 function getCliWritesLines() {
   if (!cachedWrites) {
-    cachedWrites = readLines(resolve14(packageRoot(), "allowed.cli-writes"));
+    cachedWrites = readLines(resolve15(packageRoot(), "allowed.cli-writes"));
   }
   return cachedWrites;
 }
@@ -18775,7 +18985,7 @@ function loadCliReads() {
 }
 function saveCliReads(commands) {
   writeFileSync22(
-    resolve14(packageRoot(), "allowed.cli-reads"),
+    resolve15(packageRoot(), "allowed.cli-reads"),
     `${commands.join("\n")}
 `
   );
@@ -18801,13 +19011,13 @@ function findCliWrite(command) {
 
 // src/shared/readSettingsPerms.ts
 import { existsSync as existsSync42, readFileSync as readFileSync27 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join43 } from "path";
+import { homedir as homedir17 } from "os";
+import { join as join45 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join43(homedir16(), ".claude", "settings.json"),
-    join43(process.cwd(), ".claude", "settings.json"),
-    join43(process.cwd(), ".claude", "settings.local.json")
+    join45(homedir17(), ".claude", "settings.json"),
+    join45(process.cwd(), ".claude", "settings.json"),
+    join45(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -18913,19 +19123,19 @@ function isCdToCwd(command) {
   const parts = command.split(/\s+/);
   if (parts[0] !== "cd" || parts.length > 2) return false;
   if (parts.length === 1) return false;
-  const resolved = resolve15(normalizeMsysPath(parts[1]));
-  return resolved === resolve15(process.cwd());
+  const resolved = resolve16(normalizeMsysPath(parts[1]));
+  return resolved === resolve16(process.cwd());
 }
 function isCdToReadAllowedDir(command) {
   const parts = command.split(/\s+/);
   if (parts[0] !== "cd" || parts.length !== 2) return void 0;
-  const target = resolve15(normalizeMsysPath(parts[1]));
+  const target = resolve16(normalizeMsysPath(parts[1]));
   for (const entry of readSettingsPerms("allow")) {
     const m = entry.match(READ_RE);
     if (!m) continue;
     const base = globBaseDir(m[1]);
     if (!base) continue;
-    const resolved = resolve15(normalizeMsysPath(base));
+    const resolved = resolve16(normalizeMsysPath(base));
     if (target === resolved || target.startsWith(resolved + sep2)) {
       return `cd to Read-allowed directory: ${entry}`;
     }
@@ -19030,12 +19240,12 @@ function decideCommand(toolName, rawCommand) {
 
 // src/commands/cliHook/logDeniedToolCall.ts
 import { mkdirSync as mkdirSync12 } from "fs";
-import { homedir as homedir17 } from "os";
-import { join as join44 } from "path";
+import { homedir as homedir18 } from "os";
+import { join as join46 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join44(homedir17(), ".assist");
+  return join46(homedir18(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -19054,7 +19264,7 @@ function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync12(dbDir, { recursive: true });
-  const db = new Database(join44(dbDir, "assist.db"));
+  const db = new Database(join46(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -19125,7 +19335,7 @@ async function cliHook() {
       logDeniedToolCall({
         tool: input.toolName,
         command: input.command,
-        repo: basename12(process.cwd()),
+        repo: basename13(process.cwd()),
         sessionId: process.env.CLAUDE_SESSION_ID,
         denyReason: decision.permissionDecisionReason
       });
@@ -19174,8 +19384,8 @@ ${reasons.join("\n")}`);
 
 // src/commands/permitCliReads.ts
 import { existsSync as existsSync43, mkdirSync as mkdirSync13, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join45 } from "path";
+import { homedir as homedir19 } from "os";
+import { join as join47 } from "path";
 
 // src/commands/permitCliReads/assertCliExists.ts
 function assertCliExists(cli) {
@@ -19438,7 +19648,7 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join45(homedir18(), ".assist", `cli-discover-${safeName}.log`);
+  return join47(homedir19(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
   const path106 = logPath(cli);
@@ -19446,7 +19656,7 @@ function readCache(cli) {
   return readFileSync28(path106, "utf8");
 }
 function writeCache(cli, output) {
-  const dir = join45(homedir18(), ".assist");
+  const dir = join47(homedir19(), ".assist");
   mkdirSync13(dir, { recursive: true });
   writeFileSync23(logPath(cli), output);
 }
@@ -19610,18 +19820,18 @@ function isHashCommentFile(filePath) {
 }
 
 // src/commands/codeComment/getRestrictedDir.ts
-import { homedir as homedir19 } from "os";
-import { join as join46 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join48 } from "path";
 function getRestrictedDir() {
-  return join46(homedir19(), ".assist", "restricted");
+  return join48(homedir20(), ".assist", "restricted");
 }
 function getPinStatePath(pin2) {
-  return join46(getRestrictedDir(), `code-comment-${pin2}.json`);
+  return join48(getRestrictedDir(), `code-comment-${pin2}.json`);
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
 import { readdirSync as readdirSync6, statSync as statSync8, unlinkSync as unlinkSync7 } from "fs";
-import { join as join47 } from "path";
+import { join as join49 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
   let entries;
@@ -19632,7 +19842,7 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path106 = join47(dir, entry);
+    const path106 = join49(dir, entry);
     try {
       if (statSync8(path106).mtimeMs < cutoff) unlinkSync7(path106);
     } catch {
@@ -21286,18 +21496,18 @@ import chalk137 from "chalk";
 
 // src/commands/criteriaExtension/criteriaExtensionDir.ts
 import { existsSync as existsSync46 } from "fs";
-import { dirname as dirname26, join as join48 } from "path";
+import { dirname as dirname26, join as join50 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var moduleDir = dirname26(fileURLToPath6(import.meta.url));
 function criteriaExtensionDir() {
-  const bundled = join48(
+  const bundled = join50(
     moduleDir,
     "commands",
     "criteriaExtension",
     "criteria-extension"
   );
   if (existsSync46(bundled)) return bundled;
-  return join48(moduleDir, "..", "..", "..", "criteria-extension");
+  return join50(moduleDir, "..", "..", "..", "criteria-extension");
 }
 
 // src/commands/criteriaExtension/criteriaExtension.ts
@@ -21325,24 +21535,24 @@ async function criteriaExtension() {
 
 // src/commands/criteriaExtension/printCriteriaExtensionUrl.ts
 import { readFile as readFile4 } from "fs/promises";
-import { join as join49 } from "path";
+import { join as join51 } from "path";
 import chalk138 from "chalk";
 
 // src/commands/criteriaExtension/latestUpdate.ts
-function latestUpdate(manifest, updates) {
+function latestUpdate(manifest, updates2) {
   const { id } = JSON.parse(manifest).browser_specific_settings.gecko;
-  return JSON.parse(updates).addons[id]?.updates.at(-1);
+  return JSON.parse(updates2).addons[id]?.updates.at(-1);
 }
 
 // src/commands/criteriaExtension/latestUpdateLink.ts
-function latestUpdateLink(manifest, updates) {
-  return latestUpdate(manifest, updates)?.update_link;
+function latestUpdateLink(manifest, updates2) {
+  return latestUpdate(manifest, updates2)?.update_link;
 }
 
 // src/commands/criteriaExtension/printCriteriaExtensionUrl.ts
 async function printCriteriaExtensionUrl() {
   const manifest = await readFile4(
-    join49(criteriaExtensionDir(), "manifest.json"),
+    join51(criteriaExtensionDir(), "manifest.json"),
     "utf8"
   );
   const { update_url } = JSON.parse(manifest).browser_specific_settings.gecko;
@@ -21358,16 +21568,16 @@ async function printCriteriaExtensionUrl() {
 
 // src/commands/criteriaExtension/signCriteriaExtension.ts
 import { rm as rm2 } from "fs/promises";
-import { homedir as homedir20, tmpdir as tmpdir3 } from "os";
-import { join as join55 } from "path";
+import { homedir as homedir21, tmpdir as tmpdir3 } from "os";
+import { join as join57 } from "path";
 import chalk140 from "chalk";
 
 // src/commands/criteriaExtension/copySignedXpi.ts
 import { copyFile } from "fs/promises";
-import { join as join50 } from "path";
+import { join as join52 } from "path";
 var SIGNED_XPI_NAME = "criteria-extension.xpi";
 async function copySignedXpi(xpi, dir) {
-  const fixed2 = join50(dir, SIGNED_XPI_NAME);
+  const fixed2 = join52(dir, SIGNED_XPI_NAME);
   if (fixed2 === xpi) return fixed2;
   await copyFile(xpi, fixed2);
   return fixed2;
@@ -21376,11 +21586,11 @@ async function copySignedXpi(xpi, dir) {
 // src/commands/criteriaExtension/findSignedXpi.ts
 import { existsSync as existsSync47 } from "fs";
 import { readdir } from "fs/promises";
-import { join as join51 } from "path";
+import { join as join53 } from "path";
 async function findSignedXpi(dir) {
   if (!existsSync47(dir)) return null;
   const name = (await readdir(dir)).find((entry) => entry.endsWith(".xpi"));
-  return name ? join51(dir, name) : null;
+  return name ? join53(dir, name) : null;
 }
 
 // src/commands/criteriaExtension/signedAddonInstallPath.ts
@@ -21403,10 +21613,10 @@ async function signedAddonInstallPath(xpi) {
 
 // src/commands/criteriaExtension/signPreflightProblem.ts
 import { existsSync as existsSync48 } from "fs";
-import { join as join52 } from "path";
+import { join as join54 } from "path";
 var KEY_URL = "https://addons.mozilla.org/en-US/developers/addon/api/key/";
 function signPreflightProblem(source) {
-  if (!existsSync48(join52(source, "content.js")))
+  if (!existsSync48(join54(source, "content.js")))
     return {
       message: `no content.js in ${source}`,
       hint: "run npm run build to bundle the content script"
@@ -21421,7 +21631,7 @@ function signPreflightProblem(source) {
 
 // src/commands/criteriaExtension/stageCriteriaExtension.ts
 import { cp as cp3, mkdir as mkdir5, readFile as readFile5, rm, writeFile as writeFile4 } from "fs/promises";
-import { basename as basename13, join as join53 } from "path";
+import { basename as basename14, join as join55 } from "path";
 
 // src/commands/criteriaExtension/stampManifestVersion.ts
 function stampManifestVersion(manifest, version2) {
@@ -21436,9 +21646,9 @@ async function stageCriteriaExtension(source, staging, version2) {
   await mkdir5(staging, { recursive: true });
   await cp3(source, staging, {
     recursive: true,
-    filter: (path106) => basename13(path106) !== "updates.json"
+    filter: (path106) => basename14(path106) !== "updates.json"
   });
-  const manifest = join53(staging, "manifest.json");
+  const manifest = join55(staging, "manifest.json");
   const stamped = stampManifestVersion(
     await readFile5(manifest, "utf8"),
     version2
@@ -21448,13 +21658,13 @@ async function stageCriteriaExtension(source, staging, version2) {
 
 // src/commands/criteriaExtension/writeUpdateManifest.ts
 import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { join as join54 } from "path";
+import { join as join56 } from "path";
 
 // src/commands/criteriaExtension/buildUpdateManifest.ts
 var RELEASE_DOWNLOAD_URL = "https://github.com/staff0rd/assist/releases/download";
 function buildUpdateManifest(manifest, version2) {
   const { id } = JSON.parse(manifest).browser_specific_settings.gecko;
-  const updates = {
+  const updates2 = {
     addons: {
       [id]: {
         updates: [
@@ -21466,24 +21676,24 @@ function buildUpdateManifest(manifest, version2) {
       }
     }
   };
-  return `${JSON.stringify(updates, null, "	")}
+  return `${JSON.stringify(updates2, null, "	")}
 `;
 }
 
 // src/commands/criteriaExtension/writeUpdateManifest.ts
 async function writeUpdateManifest(source, dir, version2) {
   await writeFile5(
-    join54(dir, "updates.json"),
+    join56(dir, "updates.json"),
     buildUpdateManifest(
-      await readFile6(join54(source, "manifest.json"), "utf8"),
+      await readFile6(join56(source, "manifest.json"), "utf8"),
       version2
     )
   );
 }
 
 // src/commands/criteriaExtension/signCriteriaExtension.ts
-var ARTIFACTS_DIR = join55(homedir20(), ".assist", "criteria-extension");
-var STAGING_DIR = join55(tmpdir3(), "assist-criteria-extension");
+var ARTIFACTS_DIR = join57(homedir21(), ".assist", "criteria-extension");
+var STAGING_DIR = join57(tmpdir3(), "assist-criteria-extension");
 async function signCriteriaExtension() {
   const source = criteriaExtensionDir();
   const problem = signPreflightProblem(source);
@@ -21671,12 +21881,12 @@ import { unlinkSync as unlinkSync9, writeFileSync as writeFileSync26 } from "fs"
 import chalk143 from "chalk";
 
 // src/commands/dbMigration/getMigrationPinPath.ts
-import { join as join56 } from "path";
+import { join as join58 } from "path";
 function getMigrationPinPath(pin2) {
-  return join56(getRestrictedDir(), `db-migration-pin-${pin2}.json`);
+  return join58(getRestrictedDir(), `db-migration-pin-${pin2}.json`);
 }
 function getMigrationApprovalPath(migrationId) {
-  return join56(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
+  return join58(getRestrictedDir(), `db-migration-approval-${migrationId}.json`);
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
@@ -21809,15 +22019,15 @@ function registerDeploy(program2) {
 }
 
 // src/commands/devlog/list.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import { basename as basename15 } from "path";
+import { execFileSync as execFileSync6 } from "child_process";
+import { basename as basename16 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
-import { homedir as homedir21 } from "os";
-import { join as join57 } from "path";
-var BLOG_REPO_ROOT = join57(homedir21(), "git/blog");
+import { homedir as homedir22 } from "os";
+import { join as join59 } from "path";
+var BLOG_REPO_ROOT = join59(homedir22(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join57(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join59(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
@@ -21829,13 +22039,13 @@ import chalk146 from "chalk";
 
 // src/shared/getRepoName.ts
 import { existsSync as existsSync51, readFileSync as readFileSync33 } from "fs";
-import { basename as basename14, join as join58 } from "path";
+import { basename as basename15, join as join60 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join58(process.cwd(), "package.json");
+  const packageJsonPath = join60(process.cwd(), "package.json");
   if (existsSync51(packageJsonPath)) {
     try {
       const content = readFileSync33(packageJsonPath, "utf8");
@@ -21846,13 +22056,13 @@ function getRepoName() {
     } catch {
     }
   }
-  return basename14(process.cwd());
+  return basename15(process.cwd());
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync as readdirSync7, readFileSync as readFileSync34 } from "fs";
-import { join as join59 } from "path";
-var DEVLOG_DIR = join59(BLOG_REPO_ROOT, "src/content/devlog");
+import { join as join61 } from "path";
+var DEVLOG_DIR = join61(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -21880,7 +22090,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync7(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync34(join59(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync34(join61(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -21982,14 +22192,14 @@ function list2(options2) {
   const config = loadConfig();
   const days = options2.days ?? 30;
   const ignore3 = options2.ignore ?? config.devlog?.ignore ?? [];
-  const repoName = basename15(process.cwd());
+  const repoName = basename16(process.cwd());
   const skipDays = loadBlogSkipDays(repoName);
   const devlogEntries = loadDevlogEntries(repoName);
   const args = ["log"];
   if (options2.reverse) args.push("--reverse");
   else args.push("-n", "500");
   args.push("--pretty=format:%ad|%h|%s", "--date=short");
-  const output = execFileSync5("git", args, { encoding: "utf8" });
+  const output = execFileSync6("git", args, { encoding: "utf8" });
   const commitsByDate = parseGitLogCommits(output, ignore3);
   let dateCount = 0;
   let isFirst = true;
@@ -22012,7 +22222,7 @@ function list2(options2) {
 }
 
 // src/commands/devlog/getLastVersionInfo.ts
-import { execFileSync as execFileSync6, execSync as execSync32 } from "child_process";
+import { execFileSync as execFileSync7, execSync as execSync32 } from "child_process";
 import semver from "semver";
 function getVersionAtCommit(hash) {
   try {
@@ -22031,7 +22241,7 @@ function stripToMinor(version2) {
 }
 function getLastVersionInfoFromGit() {
   try {
-    const output = execFileSync6(
+    const output = execFileSync7(
       "git",
       ["log", "-1", "--pretty=format:%ad|%h", "--date=short"],
       {
@@ -22076,7 +22286,7 @@ function bumpVersion(version2, type) {
 }
 
 // src/commands/devlog/next/displayNextEntry.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 import chalk149 from "chalk";
 
 // src/commands/devlog/next/displayNextEntry/displayVersion.ts
@@ -22110,7 +22320,7 @@ function findTargetDate(commitsByDate, skipDays) {
   return Array.from(commitsByDate.keys()).filter((d) => !skipDays.has(d)).sort()[0];
 }
 function fetchCommitsByDate(ignore3, lastDate) {
-  const output = execFileSync7(
+  const output = execFileSync8(
     "git",
     ["log", "--pretty=format:%ad|%h|%s", "--date=short", "-n", "500"],
     { encoding: "utf8" }
@@ -22268,11 +22478,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync29 } from "fs";
-import { join as join60 } from "path";
+import { join as join62 } from "path";
 import chalk151 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join60(BLOG_REPO_ROOT, "assist.yml");
+  return join62(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -22334,7 +22544,7 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync4, openSync as openSync5, readdirSync as readdirSync8 } from "fs";
-import { join as join61 } from "path";
+import { join as join63 } from "path";
 import chalk153 from "chalk";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
 function isLockedDll(debugDir) {
@@ -22346,7 +22556,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join61(debugDir, file);
+    const dllPath = join63(debugDir, file);
     try {
       const fd = openSync5(dllPath, "r+");
       closeSync4(fd);
@@ -22364,13 +22574,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join61(dir, "bin", "Debug"));
+    const locked = isLockedDll(join63(dir, "bin", "Debug"));
     if (locked) return locked;
   }
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry) || entry === "bin" || entry.startsWith("."))
       continue;
-    const found = findFirstLockedDll(join61(dir, entry));
+    const found = findFirstLockedDll(join63(dir, entry));
     if (found) return found;
   }
   return null;
@@ -22717,11 +22927,11 @@ import chalk159 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync10 } from "fs";
-import { dirname as dirname27, join as join62 } from "path";
+import { dirname as dirname27, join as join64 } from "path";
 import chalk158 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync10(dir).filter((f) => f.endsWith(".sln")).map((f) => join62(dir, f));
+    return readdirSync10(dir).filter((f) => f.endsWith(".sln")).map((f) => join64(dir, f));
   } catch {
     return [];
   }
@@ -23716,7 +23926,7 @@ function aggregateCommitters(authorLists) {
 import { spawnSync as spawnSync6 } from "child_process";
 import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync30 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join63 } from "path";
+import { join as join65 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -23726,7 +23936,7 @@ function buildArgs2(queryFile, vars) {
   return args;
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join63(tmpdir5(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join65(tmpdir5(), `gh-query-${Date.now()}.graphql`);
   writeFileSync30(queryFile, mutation);
   try {
     const result = spawnSync6("gh", buildArgs2(queryFile, vars), {
@@ -24439,7 +24649,7 @@ Anything nested below the leaf level fails the run before a single write, naming
 }
 
 // src/commands/github/issue/commentIssue.ts
-import { execFileSync as execFileSync8 } from "child_process";
+import { execFileSync as execFileSync9 } from "child_process";
 
 // src/shared/validateProposedContent.ts
 function validateProposedContent(labels, title, body) {
@@ -24500,7 +24710,7 @@ async function commentIssue(numberArg, options2) {
   const args = ["issue", "comment", String(number), "--body", body];
   if (options2.repo) args.push("--repo", options2.repo);
   try {
-    execFileSync8("gh", args, { stdio: "inherit" });
+    execFileSync9("gh", args, { stdio: "inherit" });
   } catch {
     process.exit(1);
   }
@@ -24903,8 +25113,8 @@ function attachArgs(attachments) {
 }
 
 // src/commands/prs/runGhWithAttachments.ts
-import { execFileSync as execFileSync9 } from "child_process";
-import { basename as basename16 } from "path";
+import { execFileSync as execFileSync10 } from "child_process";
+import { basename as basename17 } from "path";
 
 // src/shared/removeStagedAttachments.ts
 import { rmSync as rmSync4 } from "fs";
@@ -24921,7 +25131,7 @@ function removeStagedAttachments(attachments) {
 var PLACED_URL = /https:\/\/\S+\/(pull|issues)\/\d+/;
 function reportPartialFailure(attachments, stderr) {
   const failed3 = attachments.filter(
-    ({ path: path106 }) => stderr.includes(path106) || stderr.includes(basename16(path106))
+    ({ path: path106 }) => stderr.includes(path106) || stderr.includes(basename17(path106))
   );
   const named = failed3.length > 0 ? failed3 : attachments;
   console.error(
@@ -24931,7 +25141,7 @@ function reportPartialFailure(attachments, stderr) {
 function runGhWithAttachments(args, attachments) {
   const attaching = attachments.length > 0;
   try {
-    const stdout = execFileSync9("gh", args, {
+    const stdout = execFileSync10("gh", args, {
       encoding: "utf8",
       stdio: ["inherit", "pipe", attaching ? "pipe" : "inherit"]
     });
@@ -25042,7 +25252,7 @@ function inWebSession() {
 }
 
 // src/commands/github/issue/fetchIssue.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 function fetchIssue2(number, repo) {
   const args = [
     "issue",
@@ -25054,7 +25264,7 @@ function fetchIssue2(number, repo) {
   if (repo) args.push("--repo", repo);
   let raw;
   try {
-    raw = execFileSync10("gh", args, { encoding: "utf8" });
+    raw = execFileSync11("gh", args, { encoding: "utf8" });
   } catch {
     console.error(`Could not fetch issue #${number} with gh issue view`);
     process.exit(1);
@@ -25071,14 +25281,14 @@ function fetchIssue2(number, repo) {
 import { existsSync as existsSync56, readFileSync as readFileSync38 } from "fs";
 
 // src/commands/github/issue/issueWorkingFile.ts
-import { join as join64 } from "path";
+import { join as join66 } from "path";
 function issueWorkingFile(slug2, number) {
   const [owner = "unknown", repo = "unknown"] = slug2.split("/");
-  const dir = join64(getStoreDir(), "github-issues", owner, repo);
+  const dir = join66(getStoreDir(), "github-issues", owner, repo);
   return {
     dir,
-    bodyPath: join64(dir, `${number}.md`),
-    metaPath: join64(dir, `${number}.json`)
+    bodyPath: join66(dir, `${number}.md`),
+    metaPath: join66(dir, `${number}.json`)
   };
 }
 
@@ -25145,12 +25355,12 @@ function prepareIssueEdit(number, repo, fresh) {
 }
 
 // src/commands/github/issue/pushIssueBody.ts
-import { execFileSync as execFileSync11 } from "child_process";
+import { execFileSync as execFileSync12 } from "child_process";
 function pushIssueBody(number, repo, bodyPath) {
   const args = ["issue", "edit", String(number), "--body-file", bodyPath];
   if (repo) args.push("--repo", repo);
   try {
-    execFileSync11("gh", args, { stdio: "inherit" });
+    execFileSync12("gh", args, { stdio: "inherit" });
   } catch {
     process.exit(1);
   }
@@ -25210,12 +25420,12 @@ function setIssueParent(number, repo, parentArg) {
 }
 
 // src/commands/github/issue/viewIssue.ts
-import { execFileSync as execFileSync12 } from "child_process";
+import { execFileSync as execFileSync13 } from "child_process";
 function viewIssue(number, repo) {
   const args = ["issue", "view", String(number)];
   if (repo) args.push("--repo", repo);
   try {
-    execFileSync12("gh", args, { stdio: "inherit" });
+    execFileSync13("gh", args, { stdio: "inherit" });
   } catch {
     process.exit(1);
   }
@@ -25271,7 +25481,7 @@ function registerEditIssue(issueCommand) {
 }
 
 // src/commands/github/issue/editIssueComment.ts
-import { execFileSync as execFileSync13 } from "child_process";
+import { execFileSync as execFileSync14 } from "child_process";
 var USAGE4 = "Usage: assist github issue edit-comment <comment-id> --body <body> [-R <owner>/<repo>]";
 async function editIssueComment(commentIdArg, options2) {
   const commentId = Number.parseInt(commentIdArg, 10);
@@ -25298,7 +25508,7 @@ async function editIssueComment(commentIdArg, options2) {
   ];
   let raw;
   try {
-    raw = execFileSync13("gh", args, {
+    raw = execFileSync14("gh", args, {
       input: JSON.stringify({ body }),
       encoding: "utf8"
     });
@@ -25679,7 +25889,7 @@ function registerRefineLaunch(program2, resumeFlag) {
 import { randomUUID as randomUUID12 } from "crypto";
 
 // src/commands/review/checkoutPr.ts
-import { execFileSync as execFileSync15 } from "child_process";
+import { execFileSync as execFileSync16 } from "child_process";
 import chalk170 from "chalk";
 
 // src/commands/sessions/daemon/daemonLog.ts
@@ -25705,30 +25915,19 @@ function recentDaemonLogLines(includeRelayed = true) {
   return ring.filter((entry) => includeRelayed || !entry.relayed).map((entry) => entry.line);
 }
 
-// src/commands/sessions/daemon/worktree/canonicalTreePath.ts
-import { realpathSync as realpathSync2 } from "fs";
-import { resolve as resolve16 } from "path";
-function canonicalTreePath(path106) {
-  try {
-    return realpathSync2(path106);
-  } catch {
-    return resolve16(path106);
-  }
-}
-
 // src/commands/sessions/daemon/worktree/createWorktree.ts
 import { existsSync as existsSync57 } from "fs";
-import { basename as basename18, dirname as dirname29 } from "path";
+import { basename as basename19, dirname as dirname29 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename17, join as join65 } from "path";
+import { basename as basename18, join as join67 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
-  const name = basename17(clone);
+  const name = basename18(clone);
   for (let n = 2; n < 1e3; n++) {
-    const candidate = join65(base, `${name}-${n}`);
+    const candidate = join67(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
   }
   throw new Error(`no free worktree suffix for ${clone}`);
@@ -25764,7 +25963,7 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const base = strategy.root ? expandTilde2(strategy.root) : dirname29(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
-  const isTaken = (candidate) => registered.has(candidate) || existsSync57(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename18(candidate));
+  const isTaken = (candidate) => registered.has(candidate) || existsSync57(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename19(candidate));
   const path106 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start2 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
@@ -25772,13 +25971,13 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
     "add",
     start2.track ? "--track" : "--no-track",
     "-b",
-    basename18(path106),
+    basename19(path106),
     path106,
     start2.ref
   ]);
   recordWorktree(path106, clone, getCurrentOrigin(clone));
   daemonLog(
-    start2.track ? `worktree allocated ${path106} (branch ${basename18(path106)} tracking ${start2.ref}) for clone ${clone}` : `worktree allocated ${path106} (branch ${basename18(path106)} off ${start2.ref}, no mainline tracking) for clone ${clone}`
+    start2.track ? `worktree allocated ${path106} (branch ${basename19(path106)} tracking ${start2.ref}) for clone ${clone}` : `worktree allocated ${path106} (branch ${basename19(path106)} off ${start2.ref}, no mainline tracking) for clone ${clone}`
   );
   return path106;
 }
@@ -26080,19 +26279,19 @@ function persistedTreeRoots() {
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
 import { copyFileSync, existsSync as existsSync60, mkdirSync as mkdirSync17 } from "fs";
-import { dirname as dirname30, join as join67 } from "path";
+import { dirname as dirname30, join as join69 } from "path";
 
 // src/commands/sessions/daemon/worktree/runInstall.ts
 import { resolve as resolve17 } from "path";
 
 // src/commands/sessions/daemon/worktree/detectInstallCommand.ts
 import { existsSync as existsSync59 } from "fs";
-import { join as join66 } from "path";
+import { join as join68 } from "path";
 function detectInstallCommand(dir) {
-  if (!existsSync59(join66(dir, "package.json"))) return null;
-  if (existsSync59(join66(dir, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync59(join66(dir, "yarn.lock"))) return "yarn install";
-  if (existsSync59(join66(dir, "bun.lockb"))) return "bun install";
+  if (!existsSync59(join68(dir, "package.json"))) return null;
+  if (existsSync59(join68(dir, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync59(join68(dir, "yarn.lock"))) return "yarn install";
+  if (existsSync59(join68(dir, "bun.lockb"))) return "bun install";
   return "npm install";
 }
 
@@ -26254,9 +26453,9 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 }
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
-    const src = join67(clone, rel);
+    const src = join69(clone, rel);
     if (!existsSync60(src)) continue;
-    const dest = join67(worktreePath, rel);
+    const dest = join69(worktreePath, rel);
     try {
       mkdirSync17(dirname30(dest), { recursive: true });
       copyFileSync(src, dest);
@@ -26297,10 +26496,10 @@ async function moveToPrCheckoutTree() {
 }
 
 // src/commands/review/prHeadBranch.ts
-import { execFileSync as execFileSync14 } from "child_process";
+import { execFileSync as execFileSync15 } from "child_process";
 function prHeadBranch(number) {
   try {
-    const out = execFileSync14(
+    const out = execFileSync15(
       "gh",
       ["pr", "view", number, "--json", "headRefName", "-q", ".headRefName"],
       { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }
@@ -26362,7 +26561,7 @@ async function checkoutPr(number) {
   if (headRef && await moveToExistingCheckout(number, headRef)) return;
   await moveToPrCheckoutTree();
   try {
-    execFileSync15("gh", ["pr", "checkout", number], { stdio: "inherit" });
+    execFileSync16("gh", ["pr", "checkout", number], { stdio: "inherit" });
   } catch {
     console.error(chalk170.red(`gh pr checkout ${number} failed; aborting.`));
     process.exit(1);
@@ -26566,7 +26765,7 @@ import chalk175 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync39, writeFileSync as writeFileSync32 } from "fs";
-import { basename as basename19, extname as extname3, resolve as resolve18 } from "path";
+import { basename as basename20, extname as extname3, resolve as resolve18 } from "path";
 import chalk174 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -26593,7 +26792,7 @@ async function renderBlock(krokiUrl, source) {
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   const content = readFileSync39(file, "utf8");
   const blocks = extractMermaidBlocks(content);
-  const stem = basename19(file, extname3(file));
+  const stem = basename20(file, extname3(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
@@ -27290,15 +27489,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp as cp4, readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join69 } from "path";
+import { join as join71 } from "path";
 import chalk178 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname32, join as join68 } from "path";
+import { dirname as dirname32, join as join70 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 var moduleDir2 = dirname32(fileURLToPath7(import.meta.url));
 function netcapExtensionDir() {
-  return join68(moduleDir2, "commands", "netcap", "netcap-extension");
+  return join70(moduleDir2, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -27313,7 +27512,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join69(dir, "background.js");
+  const file = join71(dir, "background.js");
   const source = await readFile7(file, "utf8");
   await writeFile6(
     file,
@@ -27353,20 +27552,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute as isAbsolute5, join as join71, resolve as resolve21 } from "path";
+import { isAbsolute as isAbsolute5, join as join73, resolve as resolve21 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
-import { homedir as homedir22 } from "os";
-import { join as join70 } from "path";
+import { homedir as homedir23 } from "os";
+import { join as join72 } from "path";
 function defaultCapturePath() {
-  return join70(homedir22(), ".assist", "netcap", "capture.jsonl");
+  return join72(homedir23(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute5(out) ? out : resolve21(process.cwd(), out);
-  return join71(dir, "capture.jsonl");
+  return join73(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -27413,7 +27612,7 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync34 } from "fs";
-import { join as join72 } from "path";
+import { join as join74 } from "path";
 import chalk180 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
@@ -27858,7 +28057,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join72(captureFile, "..", "posts.json");
+  const outFile = join74(captureFile, "..", "posts.json");
   writeFileSync34(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -28221,18 +28420,18 @@ import { execSync as execSync41 } from "child_process";
 import { execSync as execSync40 } from "child_process";
 import { unlinkSync as unlinkSync14, writeFileSync as writeFileSync35 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join74 } from "path";
+import { join as join76 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
 import { existsSync as existsSync62, readFileSync as readFileSync43, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse3 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
-import { homedir as homedir23 } from "os";
-import { join as join73 } from "path";
+import { homedir as homedir24 } from "os";
+import { join as join75 } from "path";
 function commentsCachePath(org, repo, prNumber) {
-  return join73(
-    homedir23(),
+  return join75(
+    homedir24(),
     ".assist",
     "pr-comments",
     org,
@@ -28280,7 +28479,7 @@ function replyToComment(org, repo, prNumber, commentId, message3) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join74(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join76(tmpdir6(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync35(queryFile, mutation);
   try {
     execSync40(
@@ -28365,10 +28564,10 @@ function fixed(commentId, sha) {
 import { execSync as execSync42 } from "child_process";
 import { unlinkSync as unlinkSync15, writeFileSync as writeFileSync36 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join75 } from "path";
+import { join as join77 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
-  const queryFile = join75(tmpdir7(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join77(tmpdir7(), `gh-query-${Date.now()}.graphql`);
   writeFileSync36(queryFile, THREAD_QUERY);
   try {
     const result = execSync42(
@@ -28443,10 +28642,10 @@ import { stringify as stringify3 } from "yaml";
 
 // src/commands/prs/removeStaleCommentsCaches.ts
 import { readdirSync as readdirSync12, unlinkSync as unlinkSync16 } from "fs";
-import { join as join76 } from "path";
+import { join as join78 } from "path";
 var STALE_PATTERN = /^pr-\d+-comments\.yaml$/;
 function removeStaleCommentsCaches(cwd = process.cwd()) {
-  const dir = join76(cwd, ".assist");
+  const dir = join78(cwd, ".assist");
   let entries;
   try {
     entries = readdirSync12(dir);
@@ -28454,7 +28653,7 @@ function removeStaleCommentsCaches(cwd = process.cwd()) {
     return;
   }
   for (const entry of entries.filter((e) => STALE_PATTERN.test(e))) {
-    unlinkSync16(join76(dir, entry));
+    unlinkSync16(join78(dir, entry));
   }
 }
 
@@ -29088,7 +29287,7 @@ function buildValidatedBody(options2, usage) {
 }
 
 // src/commands/prs/placePr.ts
-import { execFileSync as execFileSync16 } from "child_process";
+import { execFileSync as execFileSync17 } from "child_process";
 
 // src/commands/prs/buildCreateArgs.ts
 function buildCreateArgs(title, body, options2, attachments = []) {
@@ -29174,7 +29373,7 @@ function buildEditArgs(number, title, body, attachments = []) {
 // src/commands/prs/placePr.ts
 function hasUpstream2() {
   try {
-    execFileSync16(
+    execFileSync17(
       "git",
       ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
       { stdio: "pipe" }
@@ -29186,7 +29385,7 @@ function hasUpstream2() {
 }
 function ensureBranchPushed() {
   const args = hasUpstream2() ? ["push"] : ["push", "--set-upstream", "origin", "HEAD"];
-  execFileSync16("git", args, { stdio: "inherit" });
+  execFileSync17("git", args, { stdio: "inherit" });
 }
 async function placePr(prNumber, title, body, options2, attachments = []) {
   const args = prNumber !== null ? buildEditArgs(prNumber, title, body, attachments) : buildCreateArgs(title, body, options2, attachments);
@@ -29332,10 +29531,10 @@ function warn(reason4) {
 }
 
 // src/commands/prs/enableAutoMerge.ts
-import { execFileSync as execFileSync17 } from "child_process";
+import { execFileSync as execFileSync18 } from "child_process";
 function enableAutoMerge() {
   try {
-    execFileSync17(
+    execFileSync18(
       "gh",
       ["pr", "merge", getCurrentBranch2(), "--auto", "--squash"],
       { stdio: "inherit" }
@@ -31093,7 +31292,7 @@ async function notify() {
 import { execSync as execSync52 } from "child_process";
 import { existsSync as existsSync63, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join77, resolve as resolve22 } from "path";
+import { join as join79, resolve as resolve22 } from "path";
 import chalk205 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -31230,7 +31429,7 @@ function buildOutputPath(outputDir, processName) {
   return resolve22(outputDir, `${processName}-${timestamp5}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join77(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join79(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync38(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync52(
@@ -31345,9 +31544,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync46, statSync as statSync10 } from "fs";
-import { isAbsolute as isAbsolute6, join as join78, resolve as resolve23 } from "path";
+import { isAbsolute as isAbsolute6, join as join80, resolve as resolve23 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join78(cwd, ".git");
+  const dotGit = join80(cwd, ".git");
   let stat5;
   try {
     stat5 = statSync10(dotGit);
@@ -31377,7 +31576,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync46(join78(gitDir, "HEAD"), "utf8");
+    head = readFileSync46(join80(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -33798,7 +33997,7 @@ function exitWith(message3) {
 }
 
 // src/commands/review/highLevel/proposeHighLevelGlobs.ts
-import { execFileSync as execFileSync19 } from "child_process";
+import { execFileSync as execFileSync20 } from "child_process";
 import chalk228 from "chalk";
 
 // src/commands/review/highLevel/buildGlobProposalPrompt.ts
@@ -33846,7 +34045,7 @@ function readGlobs(value) {
 }
 
 // src/commands/review/highLevel/summariseRepoTree.ts
-import { execFileSync as execFileSync18 } from "child_process";
+import { execFileSync as execFileSync19 } from "child_process";
 import { dirname as dirname36, extname as extname4 } from "path";
 var MAX_DIRECTORIES = 200;
 var MAX_EXTENSIONS_PER_DIRECTORY = 6;
@@ -33862,7 +34061,7 @@ function summariseRepoTree(cwd = process.cwd()) {
 }
 function listTrackedFiles(cwd) {
   try {
-    return execFileSync18("git", ["ls-files"], {
+    return execFileSync19("git", ["ls-files"], {
       cwd,
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024
@@ -33907,7 +34106,7 @@ function proposeHighLevelGlobs(cwd = process.cwd()) {
 }
 function askClaude(prompt, cwd) {
   try {
-    return execFileSync19("claude", ["-p", "--model", "sonnet", prompt], {
+    return execFileSync20("claude", ["-p", "--model", "sonnet", prompt], {
       cwd,
       encoding: "utf8",
       timeout: 12e4,
@@ -34000,7 +34199,7 @@ function groupFilesByDirectory(files) {
 }
 
 // src/commands/review/highLevel/buildHighLevelTree.ts
-function basename20(path106) {
+function basename21(path106) {
   return path106.slice(path106.lastIndexOf("/") + 1);
 }
 function sum(nodes, key) {
@@ -34016,7 +34215,7 @@ function nodesOf(at2, prefix2) {
   const files = at2.files.map(
     (file) => ({
       kind: "file",
-      name: basename20(file.path),
+      name: basename21(file.path),
       ...file
     })
   );
@@ -34287,7 +34486,7 @@ function evaluateHighLevelChecks(subject) {
 
 // src/commands/review/highLevel/fetchHighLevelFiles.ts
 import { execSync as execSync55 } from "child_process";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var JQ = ".[] | {filename,status,additions,deletions,patch} | @json";
 function toStatus(status2) {
   if (status2 === "added") return "added";
@@ -34295,7 +34494,7 @@ function toStatus(status2) {
   return "modified";
 }
 function diffUrl(repo, prNumber, path106) {
-  const anchor = createHash3("sha256").update(path106).digest("hex");
+  const anchor = createHash4("sha256").update(path106).digest("hex");
   return `https://github.com/${repo}/pull/${prNumber}/files#diff-${anchor}`;
 }
 function fetchHighLevelFiles(prNumber, repo) {
@@ -34336,12 +34535,12 @@ function fetchHighLevelPr(prNumber, repo) {
 import { existsSync as existsSync64, readFileSync as readFileSync47 } from "fs";
 
 // src/commands/review/highLevel/highLevelReviewPath.ts
-import { join as join79 } from "path";
+import { join as join81 } from "path";
 function slug(value) {
   return value.replace(/[^\w.-]+/g, "-");
 }
 function highLevelReviewPath(repo, headRef, headSha) {
-  return join79(
+  return join81(
     getStoreDir(),
     "high-level-reviews",
     slug(repo),
@@ -35417,18 +35616,7 @@ import { format } from "util";
 
 // src/commands/review/createReviewLogSink.ts
 import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync23 } from "fs";
-import { join as join80 } from "path";
-
-// src/shared/stripAnsi.ts
-var ANSI = new RegExp(
-  `${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`,
-  "g"
-);
-function stripAnsi(text17) {
-  return text17.replace(ANSI, "");
-}
-
-// src/commands/review/createReviewLogSink.ts
+import { join as join82 } from "path";
 var LOG_FILE = "review.log";
 function createReviewLogSink() {
   let logPath2;
@@ -35445,7 +35633,7 @@ function createReviewLogSink() {
     },
     attach(reviewDir) {
       mkdirSync23(reviewDir, { recursive: true });
-      logPath2 = join80(reviewDir, LOG_FILE);
+      logPath2 = join82(reviewDir, LOG_FILE);
       const lines2 = [
         "",
         `=== ${(/* @__PURE__ */ new Date()).toISOString()} ===`,
@@ -36526,22 +36714,22 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { homedir as homedir24 } from "os";
-import { basename as basename21, join as join81 } from "path";
+import { homedir as homedir25 } from "os";
+import { basename as basename22, join as join83 } from "path";
 function buildReviewPaths(repoRoot2, key) {
-  const reviewDir = join81(
-    homedir24(),
+  const reviewDir = join83(
+    homedir25(),
     ".assist",
     "reviews",
-    basename21(repoRoot2),
+    basename22(repoRoot2),
     key
   );
   return {
     reviewDir,
-    requestPath: join81(reviewDir, "request.md"),
-    claudePath: join81(reviewDir, "claude.md"),
-    codexPath: join81(reviewDir, "codex.md"),
-    synthesisPath: join81(reviewDir, "synthesis.md")
+    requestPath: join83(reviewDir, "request.md"),
+    claudePath: join83(reviewDir, "claude.md"),
+    codexPath: join83(reviewDir, "codex.md"),
+    synthesisPath: join83(reviewDir, "synthesis.md")
   };
 }
 
@@ -36995,16 +37183,16 @@ import path87 from "path";
 import chalk239 from "chalk";
 function listRules(target, options2 = {}) {
   const resolved = path87.resolve(target ?? process.cwd());
-  const rules3 = readScopedRules(resolved);
-  if (rules3.length === 0) {
+  const rules2 = readScopedRules(resolved);
+  if (rules2.length === 0) {
     const label2 = path87.relative(process.cwd(), resolved) || ".";
     console.log(chalk239.gray(`No rules in scope for ${label2}`));
     return;
   }
   const base = findRepoRoot(scopeDirectory(resolved));
-  const width = Math.max(...rules3.map((rule) => rule.code.length));
+  const width = Math.max(...rules2.map((rule) => rule.code.length));
   let shown;
-  for (const rule of rules3) {
+  for (const rule of rules2) {
     if (rule.source !== shown) {
       shown = rule.source;
       console.log(
@@ -37522,12 +37710,12 @@ async function reviewProposedSlackMessage(target, body, workingPath) {
 }
 
 // src/commands/slack/slackWorkingFile.ts
-import { join as join82 } from "path";
+import { join as join84 } from "path";
 function slackWorkingFile(channel, partIndex) {
   const slug2 = channel.replace(/^[#@]/, "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "channel";
-  const dir = join82(getStoreDir(), "slack");
+  const dir = join84(getStoreDir(), "slack");
   const name = partIndex === void 0 ? slug2 : `${slug2}-${partIndex}`;
-  return { dir, bodyPath: join82(dir, `${name}.md`) };
+  return { dir, bodyPath: join84(dir, `${name}.md`) };
 }
 
 // src/commands/slack/previewSlackThreadParts.ts
@@ -38707,20 +38895,20 @@ async function configure() {
 
 // src/commands/transcript/list.ts
 import { existsSync as existsSync76, readdirSync as readdirSync20, statSync as statSync12 } from "fs";
-import { join as join94 } from "path";
+import { join as join96 } from "path";
 function list3() {
   const { vttDir } = getTranscriptConfig();
   if (!existsSync76(vttDir)) return;
   for (const entry of readdirSync20(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync12(join94(vttDir, entry)).isDirectory()) continue;
+    if (statSync12(join96(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import { existsSync as existsSync77, mkdirSync as mkdirSync32, renameSync as renameSync2, writeFileSync as writeFileSync50 } from "fs";
-import { basename as basename25, join as join95 } from "path";
+import { basename as basename26, join as join97 } from "path";
 
 // src/commands/transcript/convertVttToMarkdown.ts
 function convertVttToMarkdown(inputPath) {
@@ -38730,9 +38918,9 @@ function convertVttToMarkdown(inputPath) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join95(vttDir, "processed");
+  const processedDir = join97(vttDir, "processed");
   mkdirSync32(processedDir, { recursive: true });
-  renameSync2(sourcePath, join95(processedDir, filename));
+  renameSync2(sourcePath, join97(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -38741,27 +38929,27 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename25(file);
-  const sourcePath = join95(vttDir, filename);
+  const filename = basename26(file);
+  const sourcePath = join97(vttDir, filename);
   if (!existsSync77(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename25(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename26(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join95(transcriptsDir, client);
+  const formattedDir = join97(transcriptsDir, client);
   mkdirSync32(formattedDir, { recursive: true });
-  const formattedPath = join95(formattedDir, outputName);
+  const formattedPath = join97(formattedDir, outputName);
   writeFileSync50(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join95(summaryDir, client, outputName);
+  const summaryPath = join97(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
 
 // src/commands/transcript/merge.ts
 import { existsSync as existsSync78, writeFileSync as writeFileSync51 } from "fs";
-import { basename as basename26 } from "path";
+import { basename as basename27 } from "path";
 
 // src/commands/transcript/failTranscript.ts
 function failTranscript(message3) {
@@ -38907,7 +39095,7 @@ function readSource3(file) {
   if (!existsSync78(file)) failTranscript(`VTT file not found: ${file}`);
   const cues = readCleanedCues(file);
   if (cues.length === 0) failTranscript(`no cues found in: ${file}`);
-  return { path: file, name: basename26(file), cues };
+  return { path: file, name: basename27(file), cues };
 }
 function wholePassages(sources) {
   return sources.map((source) => ({
@@ -39398,14 +39586,14 @@ function findRuleViolations(data, rule) {
   }
   return violations;
 }
-function findForbiddenStrings(rules3, readJson) {
-  return rules3.flatMap((rule) => findRuleViolations(readJson(rule.file), rule));
+function findForbiddenStrings(rules2, readJson) {
+  return rules2.flatMap((rule) => findRuleViolations(readJson(rule.file), rule));
 }
 
 // src/commands/verify/forbiddenStrings.ts
 function forbiddenStrings() {
-  const rules3 = loadConfig().forbiddenStrings ?? [];
-  if (rules3.length === 0) {
+  const rules2 = loadConfig().forbiddenStrings ?? [];
+  if (rules2.length === 0) {
     console.log("No forbidden-strings rules configured.");
     process.exit(0);
   }
@@ -39426,7 +39614,7 @@ function forbiddenStrings() {
     cache6.set(file, parsed);
     return parsed;
   };
-  const violations = findForbiddenStrings(rules3, readJson);
+  const violations = findForbiddenStrings(rules2, readJson);
   if (violations.length === 0) {
     console.log("No forbidden strings found.");
     process.exit(0);
@@ -39568,7 +39756,7 @@ function listMigrationFiles(dir) {
 
 // src/commands/verify/migrations/readBaselineMigrations.ts
 import { execSync as execSync63 } from "child_process";
-import { basename as basename27 } from "path";
+import { basename as basename28 } from "path";
 var MIGRATION_FILE3 = /^migration\d+[A-Za-z0-9]*\.ts$/;
 function readBaselineMigrations(repoRelativeDir, ref) {
   const baseline = /* @__PURE__ */ new Map();
@@ -39581,7 +39769,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path106) => MIGRATION_FILE3.test(basename27(path106)));
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path106) => MIGRATION_FILE3.test(basename28(path106)));
   for (const path106 of paths) {
     try {
       const content = execSync63(`git show "${ref}:${path106}"`, {
@@ -39589,7 +39777,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename27(path106), content);
+      baseline.set(basename28(path106), content);
     } catch {
     }
   }
@@ -39802,46 +39990,6 @@ function gitFailureReason(error) {
   return message3.trim() || "git failed without reporting a reason";
 }
 
-// src/commands/watch/resolveUpstream.ts
-import { execFileSync as execFileSync20 } from "child_process";
-function runGit3(args, cwd) {
-  return execFileSync20("git", args, {
-    encoding: "utf8",
-    stdio: ["pipe", "pipe", "pipe"],
-    cwd
-  }).trim();
-}
-function resolveUpstream(cwd) {
-  try {
-    runGit3(["rev-parse", "--is-inside-work-tree"], cwd);
-  } catch {
-    throw new Error(
-      "not a git repository \u2014 run assist watch wait from inside a repo"
-    );
-  }
-  let branch2;
-  try {
-    branch2 = runGit3(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
-  } catch {
-    throw new Error(
-      "HEAD is detached \u2014 check out a branch before waiting on its upstream"
-    );
-  }
-  try {
-    return {
-      branch: branch2,
-      upstream: runGit3(
-        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
-        cwd
-      )
-    };
-  } catch {
-    throw new Error(
-      `branch "${branch2}" has no upstream \u2014 set one with: git push -u origin ${branch2}`
-    );
-  }
-}
-
 // src/commands/watch/simulatedDivergencePath.ts
 import { resolve as resolve25 } from "path";
 function simulatedDivergencePath(cwd) {
@@ -39909,22 +40057,6 @@ async function watchLoop() {
   }
 }
 
-// src/commands/watch/changedPaths.ts
-function changedPaths(from, cwd) {
-  return runGit3(["diff", "--name-only", `${from}..HEAD`], cwd).split("\n").filter((line) => line.length > 0);
-}
-
-// src/commands/watch/readBuiltVersion.ts
-import { join as join96 } from "path";
-function readBuiltVersion(cwd) {
-  try {
-    const root2 = runGit3(["rev-parse", "--show-toplevel"], cwd);
-    return readPackageJson(join96(root2, "package.json")).version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-
 // src/commands/watch/readRecentCommits.ts
 function readRecentCommits(count8 = 10, cwd) {
   const output = runGit3(
@@ -39972,24 +40104,12 @@ function renderWatchReport({
 }
 
 // src/commands/watch/restartAdvice.ts
-var webUiPrefix = "src/commands/sessions/web/ui/";
-var sessionsPrefix = "src/commands/sessions/";
-var rules = [
-  {
-    matches: (path106) => path106.startsWith(webUiPrefix),
-    advice: "restart the web server, then hard-reload the browser tab"
-  },
-  {
-    matches: (path106) => path106.startsWith(sessionsPrefix) && !path106.startsWith(webUiPrefix),
-    advice: "restart the daemon"
-  }
-];
 function restartAdvice(paths) {
-  return rules.filter((rule) => paths.some(rule.matches)).map((rule) => rule.advice);
+  return restartRules.filter((rule) => paths.some(rule.matches)).map((rule) => rule.advice);
 }
 
 // src/commands/watch/syncAdvice.ts
-var rules2 = [
+var rules = [
   {
     matches: (path106) => path106.startsWith("claude/commands/"),
     reason: "claude/commands changed"
@@ -40016,7 +40136,7 @@ var rules2 = [
   }
 ];
 function syncAdvice(paths) {
-  return rules2.filter((rule) => paths.some(rule.matches)).map((rule) => rule.reason);
+  return rules.filter((rule) => paths.some(rule.matches)).map((rule) => rule.reason);
 }
 
 // src/commands/watch/buildWatchReport.ts
@@ -40702,7 +40822,7 @@ async function auth() {
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync22 } from "child_process";
 import { readdirSync as readdirSync22, readFileSync as readFileSync62, statSync as statSync13 } from "fs";
-import { join as join97 } from "path";
+import { join as join98 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -40711,7 +40831,7 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path106 = join97(roamDir, name);
+    const path106 = join98(roamDir, name);
     try {
       return { path: path106, mtimeMs: statSync13(path106).mtimeMs };
     } catch {
@@ -40728,7 +40848,7 @@ var PID_BY_APP = {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join97(appData, "Roam"));
+  const portFile = findPortFile(join98(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -40864,7 +40984,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync33, writeFileSync as writeFileSync53 } from "fs";
-import { join as join98 } from "path";
+import { join as join99 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -40925,7 +41045,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join98(".claude", "commands");
+  const dir = join99(".claude", "commands");
   mkdirSync33(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -40933,7 +41053,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join98(dir, `${name}.md`);
+  const filePath = join99(dir, `${name}.md`);
   writeFileSync53(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -40990,7 +41110,7 @@ function link2() {
 
 // src/commands/run/remove.ts
 import { existsSync as existsSync82, unlinkSync as unlinkSync21 } from "fs";
-import { join as join99 } from "path";
+import { join as join100 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -41005,7 +41125,7 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join99(".claude", "commands", `${name}.md`);
+  const filePath = join100(".claude", "commands", `${name}.md`);
   if (existsSync82(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
@@ -41996,7 +42116,116 @@ function createRunSession(id, { runName, runArgs, cwd, meta }) {
   };
 }
 
-// src/commands/sessions/daemon/autoUpdate/startAutoUpdate.ts
+// src/commands/sessions/daemon/autoUpdate/autoUpdateEnabled.ts
+function autoUpdateEnabled(installDir) {
+  try {
+    return loadConfigFrom(installDir).autoUpdate?.enabled ?? true;
+  } catch (error) {
+    daemonLog(
+      `auto-update: config failed to load, keeping the default (on): ${error instanceof Error ? error.message : String(error)}`
+    );
+    return true;
+  }
+}
+
+// src/commands/sessions/daemon/autoUpdate/autoUpdateState.ts
+var loop = {
+  phase: "off",
+  since: (/* @__PURE__ */ new Date()).toISOString(),
+  reason: "not started"
+};
+var startCommit;
+var autoUpdateState = {
+  loop: () => loop,
+  startCommit: () => startCommit,
+  setStartCommit: (commit2) => {
+    startCommit = commit2;
+  },
+  enter: (phase, extra = {}) => {
+    loop = { phase, since: (/* @__PURE__ */ new Date()).toISOString(), ...extra };
+  }
+};
+
+// src/commands/sessions/daemon/autoUpdate/holdForEscalation.ts
+var ESCALATION_POLL_MS = 5e3;
+async function holdForEscalation(sessionId, deps2) {
+  deps2.enter("diverged", { escalationId: sessionId });
+  deps2.note(`paused while session ${sessionId} reconciles the divergence`);
+  while (deps2.isLive(sessionId)) await deps2.sleep(ESCALATION_POLL_MS);
+  deps2.note(`session ${sessionId} ended; resuming`);
+}
+
+// src/commands/sessions/daemon/autoUpdate/runLapCapturingTail.ts
+var OUTPUT_TAIL = 16 * 1024;
+async function runLapCapturingTail(deps2) {
+  let tail = "";
+  const end = await deps2.runLap((text17) => {
+    tail = (tail + text17).slice(-OUTPUT_TAIL);
+    deps2.record(text17);
+  });
+  return { end, tail };
+}
+
+// src/commands/sessions/daemon/autoUpdate/runAutoUpdateLoop.ts
+var DIVERGED_EXIT_CODE = 3;
+var RETRY_AFTER_FAILURE_MS = 5 * 60 * 1e3;
+async function runAutoUpdateLoop(deps2, maxLaps = Number.POSITIVE_INFINITY) {
+  let held = deps2.liveEscalation();
+  for (let lap = 1; lap <= maxLaps; lap++) {
+    if (held) await holdForEscalation(held, deps2);
+    held = void 0;
+    deps2.enter("waiting");
+    deps2.note(
+      `lap ${lap} at ${(/* @__PURE__ */ new Date()).toLocaleString()}: assist ${WATCH_LAP_ARGS.join(" ")}`
+    );
+    let result;
+    try {
+      result = await runLapCapturingTail(deps2);
+    } catch (error) {
+      await backOff(
+        `lap ${lap} could not start (${error instanceof Error ? error.message : String(error)})`,
+        deps2
+      );
+      continue;
+    }
+    const { end, tail } = result;
+    const how = end.signal ? `killed by ${end.signal}` : `exited ${end.code}`;
+    if (end.code === DIVERGED_EXIT_CODE) {
+      held = deps2.escalate(tail);
+      deps2.note(`lap ${lap} ${how} (divergence); escalated to session ${held}`);
+      continue;
+    }
+    if (decideLap(end, false).kind === "relaunch") {
+      deps2.note(`lap ${lap} ${how}; relaunching`);
+      continue;
+    }
+    await backOff(`lap ${lap} ${how}`, deps2);
+  }
+}
+async function backOff(reason4, deps2) {
+  deps2.enter("retrying", { reason: reason4 });
+  deps2.note(`${reason4}; retrying in ${RETRY_AFTER_FAILURE_MS / 6e4}m`);
+  await deps2.sleep(RETRY_AFTER_FAILURE_MS);
+}
+
+// src/commands/sessions/daemon/autoUpdate/trimWatcherLog.ts
+import { readFileSync as readFileSync65, writeFileSync as writeFileSync54 } from "fs";
+var KEEP_TAIL = 256 * 1024;
+var MAX_LOG_SIZE = 4 * 1024 * 1024;
+function trimWatcherLog(cwd) {
+  const path106 = watcherLogPath(cwd);
+  let log2;
+  try {
+    log2 = readFileSync65(path106, "utf8");
+  } catch {
+    return;
+  }
+  if (log2.length <= MAX_LOG_SIZE) return;
+  writeFileSync54(path106, log2.slice(-KEEP_TAIL));
+  daemonLog(`auto-update: log ${path106} trimmed to its last ${KEEP_TAIL} chars`);
+}
+
+// src/commands/sessions/daemon/autoUpdate/loopDeps.ts
 import { setTimeout as sleep2 } from "timers/promises";
 
 // src/commands/sessions/daemon/watcherNote.ts
@@ -42009,19 +42238,6 @@ function watcherNote(text17) {
 // src/commands/sessions/daemon/worktree/appendWatcherLog.ts
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync34 } from "fs";
 import { dirname as dirname42 } from "path";
-
-// src/commands/sessions/daemon/worktree/watcherLogPath.ts
-import { createHash as createHash4 } from "crypto";
-import { homedir as homedir26 } from "os";
-import { basename as basename28, join as join101 } from "path";
-function watcherLogPath(cwd) {
-  const clone = canonicalTreePath(cwd);
-  const key = createHash4("sha1").update(clone).digest("hex").slice(0, 8);
-  const dir = process.env.ASSIST_WATCHER_LOG_DIR ?? join101(homedir26(), ".assist", "watchers");
-  return join101(dir, `${basename28(clone) || "root"}-${key}.log`);
-}
-
-// src/commands/sessions/daemon/worktree/appendWatcherLog.ts
 function appendWatcherLog(cwd, data) {
   try {
     const path106 = watcherLogPath(cwd);
@@ -42175,18 +42391,6 @@ function escalateDivergence(ctx, cwd, output) {
   return id;
 }
 
-// src/commands/sessions/daemon/autoUpdate/autoUpdateEnabled.ts
-function autoUpdateEnabled(installDir) {
-  try {
-    return loadConfigFrom(installDir).autoUpdate?.enabled ?? true;
-  } catch (error) {
-    daemonLog(
-      `auto-update: config failed to load, keeping the default (on): ${error instanceof Error ? error.message : String(error)}`
-    );
-    return true;
-  }
-}
-
 // src/commands/sessions/daemon/autoUpdate/lineRecorder.ts
 function lineRecorder(onLine) {
   let pending = "";
@@ -42200,64 +42404,6 @@ function lineRecorder(onLine) {
   };
 }
 
-// src/commands/sessions/daemon/autoUpdate/holdForEscalation.ts
-var ESCALATION_POLL_MS = 5e3;
-async function holdForEscalation(sessionId, deps2) {
-  deps2.note(`paused while session ${sessionId} reconciles the divergence`);
-  while (deps2.isLive(sessionId)) await deps2.sleep(ESCALATION_POLL_MS);
-  deps2.note(`session ${sessionId} ended; resuming`);
-}
-
-// src/commands/sessions/daemon/autoUpdate/runLapCapturingTail.ts
-var OUTPUT_TAIL = 16 * 1024;
-async function runLapCapturingTail(deps2) {
-  let tail = "";
-  const end = await deps2.runLap((text17) => {
-    tail = (tail + text17).slice(-OUTPUT_TAIL);
-    deps2.record(text17);
-  });
-  return { end, tail };
-}
-
-// src/commands/sessions/daemon/autoUpdate/runAutoUpdateLoop.ts
-var DIVERGED_EXIT_CODE = 3;
-var RETRY_AFTER_FAILURE_MS = 5 * 60 * 1e3;
-async function runAutoUpdateLoop(deps2, maxLaps = Number.POSITIVE_INFINITY) {
-  let held = deps2.liveEscalation();
-  for (let lap = 1; lap <= maxLaps; lap++) {
-    if (held) await holdForEscalation(held, deps2);
-    held = void 0;
-    deps2.note(
-      `lap ${lap} at ${(/* @__PURE__ */ new Date()).toLocaleString()}: assist ${WATCH_LAP_ARGS.join(" ")}`
-    );
-    let result;
-    try {
-      result = await runLapCapturingTail(deps2);
-    } catch (error) {
-      deps2.note(
-        `lap ${lap} could not start (${error instanceof Error ? error.message : String(error)}); retrying in ${RETRY_AFTER_FAILURE_MS / 6e4}m`
-      );
-      await deps2.sleep(RETRY_AFTER_FAILURE_MS);
-      continue;
-    }
-    const { end, tail } = result;
-    const how = end.signal ? `killed by ${end.signal}` : `exited ${end.code}`;
-    if (end.code === DIVERGED_EXIT_CODE) {
-      held = deps2.escalate(tail);
-      deps2.note(`lap ${lap} ${how} (divergence); escalated to session ${held}`);
-      continue;
-    }
-    if (decideLap(end, false).kind === "relaunch") {
-      deps2.note(`lap ${lap} ${how}; relaunching`);
-      continue;
-    }
-    deps2.note(
-      `lap ${lap} ${how}; retrying in ${RETRY_AFTER_FAILURE_MS / 6e4}m`
-    );
-    await deps2.sleep(RETRY_AFTER_FAILURE_MS);
-  }
-}
-
 // src/commands/sessions/daemon/autoUpdate/runUpdateLap.ts
 import { spawn as spawn11 } from "child_process";
 function runUpdateLap(cwd, onOutput) {
@@ -42290,24 +42436,7 @@ function runUpdateLap(cwd, onOutput) {
   });
 }
 
-// src/commands/sessions/daemon/autoUpdate/trimWatcherLog.ts
-import { readFileSync as readFileSync65, writeFileSync as writeFileSync54 } from "fs";
-var KEEP_TAIL = 256 * 1024;
-var MAX_LOG_SIZE = 4 * 1024 * 1024;
-function trimWatcherLog(cwd) {
-  const path106 = watcherLogPath(cwd);
-  let log2;
-  try {
-    log2 = readFileSync65(path106, "utf8");
-  } catch {
-    return;
-  }
-  if (log2.length <= MAX_LOG_SIZE) return;
-  writeFileSync54(path106, log2.slice(-KEEP_TAIL));
-  daemonLog(`auto-update: log ${path106} trimmed to its last ${KEEP_TAIL} chars`);
-}
-
-// src/commands/sessions/daemon/autoUpdate/startAutoUpdate.ts
+// src/commands/sessions/daemon/autoUpdate/loopDeps.ts
 function loopDeps(installDir, ctx) {
   const clone = canonicalTreePath(installDir);
   const logLine = lineRecorder((line) => daemonLog(`auto-update: ${line}`));
@@ -42321,6 +42450,7 @@ function loopDeps(installDir, ctx) {
       appendWatcherLog(installDir, watcherNote(text17));
       daemonLog(`auto-update: ${text17}`);
     },
+    enter: autoUpdateState.enter,
     liveEscalation: () => liveEscalationIn(ctx().sessions, clone)?.id,
     escalate: (output) => escalateDivergence(ctx(), installDir, output),
     isLive: (sessionId) => {
@@ -42330,14 +42460,21 @@ function loopDeps(installDir, ctx) {
     sleep: (ms) => sleep2(ms)
   };
 }
+
+// src/commands/sessions/daemon/autoUpdate/startAutoUpdate.ts
+function stayOff(reason4) {
+  autoUpdateState.enter("off", { reason: reason4 });
+  daemonLog(`auto-update: off (${reason4})`);
+}
 function startAutoUpdate(ctx) {
   const installDir = getInstallDir();
-  if (!autoUpdateEnabled(installDir)) {
-    daemonLog("auto-update: off (autoUpdate.enabled is false)");
+  if (!isGitRepo(installDir)) {
+    stayOff(`${installDir} is not a git clone`);
     return;
   }
-  if (!isGitRepo(installDir)) {
-    daemonLog(`auto-update: off (${installDir} is not a git clone)`);
+  autoUpdateState.setStartCommit(headCommit3(installDir));
+  if (!autoUpdateEnabled(installDir)) {
+    stayOff("autoUpdate.enabled is false");
     return;
   }
   trimWatcherLog(installDir);
@@ -47014,6 +47151,16 @@ function exitAfterFlush(code) {
 // src/commands/sessions/daemon/handleConnection.ts
 import { createInterface as createInterface10 } from "readline";
 
+// src/commands/sessions/daemon/autoUpdate/autoUpdateReply.ts
+function autoUpdateReply() {
+  return {
+    type: "auto-update",
+    version: ASSIST_VERSION,
+    startCommit: autoUpdateState.startCommit(),
+    loop: autoUpdateState.loop()
+  };
+}
+
 // src/commands/sessions/daemon/handleHelloRequest.ts
 var handleHelloRequest = (client, m, d) => {
   sendTo(client, buildHello());
@@ -47539,6 +47686,7 @@ var messageHandlers = {
   hello: handleHelloRequest,
   output: handleOutputRequest,
   nodes: (client, m) => m.links.sendNodes(client),
+  "auto-update": (client) => sendTo(client, autoUpdateReply()),
   "reload-links": (client, m) => {
     daemonLog("reload-links received");
     m.links.reload();