@staff0rd/assist 0.774.0 → 0.775.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.774.0",
+  version: "0.775.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -546,6 +546,13 @@ var LEGACY_SESSIONS_KEYS = [
   "windowsDaemonPort",
   "windowsVersionCheck"
 ];
+var LEGACY_WORKTREE_KEYS = ["watcher"];
+function withoutKeys(value, keys) {
+  if (!value || typeof value !== "object") return value;
+  const rest = { ...value };
+  for (const key of keys) delete rest[key];
+  return rest;
+}
 function stripLegacyConfigKeys(config) {
   const stripped = { ...config };
   const news = stripped.news;
@@ -553,12 +560,10 @@ function stripLegacyConfigKeys(config) {
     const { feeds: _feeds, ...rest } = news;
     stripped.news = rest;
   }
-  const sessions = stripped.sessions;
-  if (sessions && typeof sessions === "object") {
-    const rest = { ...sessions };
-    for (const key of LEGACY_SESSIONS_KEYS) delete rest[key];
-    stripped.sessions = rest;
-  }
+  if (stripped.sessions)
+    stripped.sessions = withoutKeys(stripped.sessions, LEGACY_SESSIONS_KEYS);
+  if (stripped.worktree)
+    stripped.worktree = withoutKeys(stripped.worktree, LEGACY_WORKTREE_KEYS);
   return stripped;
 }
 
@@ -906,9 +911,11 @@ var assistConfigShape = {
       })
     ).default([])
   }).optional(),
+  autoUpdate: z5.strictObject({
+    enabled: z5.boolean().default(true)
+  }).optional(),
   worktree: z5.strictObject({
     enabled: z5.boolean().default(false),
-    watcher: z5.boolean().default(false),
     trunk: z5.boolean().default(false),
     includeDrafts: z5.boolean().default(false),
     root: z5.string().optional(),
@@ -10936,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",
@@ -11148,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() {
@@ -11207,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",
@@ -11241,7 +11050,7 @@ var defaultDeps = {
   httpsPort: tailnetHttpsPort
 };
 async function ensureTailscaleServe(port, deps2 = {}) {
-  const { enabled, status: status2, serveStatus, serve, sleep: sleep2, httpsPort } = {
+  const { enabled, status: status2, serveStatus, serve, sleep: sleep3, httpsPort } = {
     ...defaultDeps,
     ...deps2
   };
@@ -11256,7 +11065,7 @@ async function ensureTailscaleServe(port, deps2 = {}) {
       return `serving ${plan2.target} at ${plan2.url}`;
     } catch (error) {
       if (attempt >= SERVE_WRITE_ATTEMPTS) throw error;
-      await sleep2(attempt * 500 + Math.random() * 500);
+      await sleep3(attempt * 500 + Math.random() * 500);
     }
   }
 }
@@ -11426,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 };
     }
@@ -11475,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 };
 }
@@ -11889,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 };
@@ -12080,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);
@@ -12786,6 +12595,15 @@ var harnessConfigHelp = [
   }
 ];
 
+// src/commands/sessions/daemon/autoUpdateConfigHelp.ts
+var autoUpdateConfigHelp = [
+  {
+    key: "autoUpdate.enabled",
+    setter: "assist config set autoUpdate.enabled false -g",
+    note: "when this install is a git clone, the daemon pulls and builds it in the background as origin moves (assist watch wait --pull --build), logging each lap to ~/.assist/watchers/; a branch that cannot fast-forward starts a claude session to reconcile it and the loop resumes once it closes. Set false to stop it (default on)"
+  }
+];
+
 // src/commands/branch/branchConfigHelp.ts
 var branchConfigHelp = [
   {
@@ -13279,11 +13097,6 @@ var sessionsConfigHelp = [
     setter: "assist config set worktree.enabled true -g --repo",
     note: "opt in per repo: spill concurrent sessions into adjacent <clone>-N worktrees (default off)"
   },
-  {
-    key: "worktree.watcher",
-    setter: "assist config set worktree.watcher true -g --repo",
-    note: "a backlog run also starts one starred console session in the clone running assist watch loop (no claude, relaunched after a daemon restart), so the built version stays current while the run works in its worktree; requires worktree.enabled and an auto-build run entry (default off)"
-  },
   {
     key: "worktree.trunk",
     setter: "assist config set worktree.trunk true -g --repo",
@@ -13390,6 +13203,7 @@ var verifyConfigHelp = [
 var configHelpEntries = [
   ...Object.values(rootConfigHelp).flat(),
   ...adviceConfigHelp,
+  ...autoUpdateConfigHelp,
   ...backlogConfigHelp,
   ...backupConfigHelp,
   ...branchConfigHelp,
@@ -13537,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",
@@ -13569,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)
@@ -13586,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" });
   }
@@ -13609,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();
@@ -13632,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 {
@@ -13640,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;
 }
 
@@ -13796,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();
@@ -13819,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([
@@ -13859,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");
@@ -14074,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;
@@ -14106,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;
 }
 
@@ -14637,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",
@@ -14649,7 +14497,7 @@ function assignIssueToSelf(number, repo) {
     "@me"
   ];
   try {
-    execFileSync3("gh", args, {
+    execFileSync2("gh", args, {
       stdio: ["ignore", "ignore", "pipe"],
       encoding: "utf8"
     });
@@ -14819,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
@@ -14855,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
@@ -14883,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);
   }
@@ -15194,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;
@@ -15294,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;
 }
@@ -15447,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 {
@@ -16058,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;
   }
@@ -16080,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`
@@ -17152,6 +17000,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 = [];
@@ -17173,7 +17209,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];
@@ -17201,9 +17237,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 };
 }
@@ -17251,17 +17287,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;
@@ -17331,7 +17367,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);
@@ -17341,7 +17377,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" };
@@ -17424,7 +17460,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,
@@ -17693,11 +17730,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",
@@ -18103,7 +18312,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";
@@ -18679,7 +18888,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/;
@@ -18733,7 +18942,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);
@@ -18748,13 +18957,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;
 }
@@ -18763,7 +18972,7 @@ function loadCliReads() {
 }
 function saveCliReads(commands) {
   writeFileSync22(
-    resolve14(packageRoot(), "allowed.cli-reads"),
+    resolve15(packageRoot(), "allowed.cli-reads"),
     `${commands.join("\n")}
 `
   );
@@ -18789,13 +18998,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) {
@@ -18901,19 +19110,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}`;
     }
@@ -19018,12 +19227,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(`
@@ -19042,7 +19251,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;
@@ -19113,7 +19322,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
       });
@@ -19162,8 +19371,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) {
@@ -19426,7 +19635,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);
@@ -19434,7 +19643,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);
 }
@@ -19598,18 +19807,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;
@@ -19620,7 +19829,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 {
@@ -21274,18 +21483,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
@@ -21313,24 +21522,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;
@@ -21346,16 +21555,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;
@@ -21364,11 +21573,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
@@ -21391,10 +21600,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"
@@ -21409,7 +21618,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) {
@@ -21424,9 +21633,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
@@ -21436,13 +21645,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: [
@@ -21454,24 +21663,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);
@@ -21659,12 +21868,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
@@ -21797,15 +22006,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]);
@@ -21817,13 +22026,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");
@@ -21834,13 +22043,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;
@@ -21868,7 +22077,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);
     }
@@ -21970,14 +22179,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;
@@ -22000,7 +22209,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 {
@@ -22019,7 +22228,7 @@ function stripToMinor(version2) {
 }
 function getLastVersionInfoFromGit() {
   try {
-    const output = execFileSync6(
+    const output = execFileSync7(
       "git",
       ["log", "-1", "--pretty=format:%ad|%h", "--date=short"],
       {
@@ -22064,7 +22273,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
@@ -22098,7 +22307,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" }
@@ -22256,11 +22465,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)) {
@@ -22322,7 +22531,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) {
@@ -22334,7 +22543,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);
@@ -22352,13 +22561,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;
@@ -22705,11 +22914,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 [];
   }
@@ -23704,7 +23913,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)) {
@@ -23714,7 +23923,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), {
@@ -24427,7 +24636,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) {
@@ -24488,7 +24697,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);
   }
@@ -24891,8 +25100,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";
@@ -24909,7 +25118,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(
@@ -24919,7 +25128,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"]
     });
@@ -25030,7 +25239,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",
@@ -25042,7 +25251,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);
@@ -25059,14 +25268,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`)
   };
 }
 
@@ -25133,12 +25342,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);
   }
@@ -25198,12 +25407,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);
   }
@@ -25259,7 +25468,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);
@@ -25286,7 +25495,7 @@ async function editIssueComment(commentIdArg, options2) {
   ];
   let raw;
   try {
-    raw = execFileSync13("gh", args, {
+    raw = execFileSync14("gh", args, {
       input: JSON.stringify({ body }),
       encoding: "utf8"
     });
@@ -25667,7 +25876,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
@@ -25693,30 +25902,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}`);
@@ -25752,7 +25950,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, [
@@ -25760,13 +25958,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;
 }
@@ -25861,7 +26059,6 @@ function wouldDisturbWorkInProgress(clone, forCheckout) {
 // src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
 var DISABLED = {
   enabled: false,
-  watcher: false,
   trunk: false,
   includeDrafts: false,
   install: true,
@@ -25994,7 +26191,6 @@ function toPersistedSession(session) {
     assistArgs: session.assistArgs,
     activity: session.activity,
     starred: session.starred,
-    watcher: session.watcher,
     divergenceEscalation: session.divergenceEscalation,
     design: session.design,
     auto: session.auto,
@@ -26070,19 +26266,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";
 }
 
@@ -26244,9 +26440,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);
@@ -26287,10 +26483,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"] }
@@ -26352,7 +26548,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);
@@ -26556,7 +26752,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
@@ -26583,7 +26779,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(
@@ -27280,15 +27476,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
@@ -27303,7 +27499,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,
@@ -27343,20 +27539,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
@@ -27403,7 +27599,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
@@ -27848,7 +28044,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(
@@ -28211,18 +28407,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,
@@ -28270,7 +28466,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(
@@ -28355,10 +28551,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(
@@ -28433,10 +28629,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);
@@ -28444,7 +28640,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));
   }
 }
 
@@ -29078,7 +29274,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 = []) {
@@ -29164,7 +29360,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" }
@@ -29176,7 +29372,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);
@@ -29322,10 +29518,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" }
@@ -31083,7 +31279,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
@@ -31220,7 +31416,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(
@@ -31335,9 +31531,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);
@@ -31367,7 +31563,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync46(join78(gitDir, "HEAD"), "utf8");
+    head = readFileSync46(join80(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -33788,7 +33984,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
@@ -33836,7 +34032,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;
@@ -33852,7 +34048,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
@@ -33897,7 +34093,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,
@@ -33990,7 +34186,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) {
@@ -34006,7 +34202,7 @@ function nodesOf(at2, prefix2) {
   const files = at2.files.map(
     (file) => ({
       kind: "file",
-      name: basename20(file.path),
+      name: basename21(file.path),
       ...file
     })
   );
@@ -34277,7 +34473,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";
@@ -34285,7 +34481,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) {
@@ -34326,12 +34522,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),
@@ -35407,18 +35603,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;
@@ -35435,7 +35620,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()} ===`,
@@ -36516,22 +36701,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")
   };
 }
 
@@ -36985,16 +37170,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(
@@ -37512,12 +37697,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
@@ -38697,20 +38882,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) {
@@ -38720,9 +38905,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;
@@ -38731,27 +38916,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) {
@@ -38897,7 +39082,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) => ({
@@ -39388,14 +39573,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);
   }
@@ -39416,7 +39601,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);
@@ -39558,7 +39743,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();
@@ -39571,7 +39756,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}"`, {
@@ -39579,7 +39764,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename27(path106), content);
+      baseline.set(basename28(path106), content);
     } catch {
     }
   }
@@ -39792,46 +39977,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) {
@@ -39899,22 +40044,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(
@@ -39962,24 +40091,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"
@@ -40006,7 +40123,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
@@ -40692,7 +40809,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 {
@@ -40701,7 +40818,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 {
@@ -40718,7 +40835,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 {
@@ -40854,7 +40971,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) {
@@ -40915,7 +41032,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}
@@ -40923,7 +41040,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}`);
 }
@@ -40980,7 +41097,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;
@@ -40995,7 +41112,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}`);
@@ -41405,7 +41522,6 @@ function toSessionInfo(session) {
     autoRun,
     autoAdvance,
     starred,
-    watcher,
     design,
     verifying,
     pendingPrPreview,
@@ -41432,7 +41548,6 @@ function toSessionInfo(session) {
     autoRun,
     autoAdvance,
     starred,
-    watcher,
     design,
     verifying,
     pendingPrPreview,
@@ -41988,6 +42103,376 @@ function createRunSession(id, { runName, runArgs, cwd, meta }) {
   };
 }
 
+// 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
+function watcherNote(text17) {
+  return `\r
+\x1B[2m\u2500\u2500 ${text17} \u2500\u2500\x1B[0m\r
+`;
+}
+
+// src/commands/sessions/daemon/worktree/appendWatcherLog.ts
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync34 } from "fs";
+import { dirname as dirname42 } from "path";
+function appendWatcherLog(cwd, data) {
+  try {
+    const path106 = watcherLogPath(cwd);
+    mkdirSync34(dirname42(path106), { recursive: true });
+    appendFileSync3(path106, data);
+  } catch {
+  }
+}
+
+// src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
+function detectExistingWorktree(cwd) {
+  const repoRoot2 = findRepoRoot(cwd) ?? cwd;
+  if (!worktreeConfigFor(repoRoot2).enabled) return void 0;
+  const clone = mainWorktree(repoRoot2);
+  if (clone && clone !== repoRoot2) return { path: repoRoot2, clone };
+  return void 0;
+}
+
+// src/commands/sessions/daemon/worktree/bindNewWorktree.ts
+function bindNewWorktree(session, alloc, notify2, startHeld = () => {
+}) {
+  if (alloc.kind !== "worktree" || !alloc.cwd || !alloc.clone || !session)
+    return;
+  session.worktree = { path: alloc.cwd, clone: alloc.clone };
+  if (alloc.created)
+    seedWorktree(alloc.cwd, alloc.clone, () => startHeld(session));
+  notify2();
+}
+function bindRestoredWorktrees(sessions) {
+  for (const session of sessions.values()) {
+    if (session.worktree || !session.cwd) continue;
+    const worktree = detectExistingWorktree(session.cwd);
+    if (worktree) session.worktree = worktree;
+  }
+}
+function bindResumedWorktree(session, cwd, notify2) {
+  if (!session) return;
+  const worktree = detectExistingWorktree(cwd);
+  if (!worktree) return;
+  session.worktree = worktree;
+  notify2();
+}
+
+// src/commands/sessions/daemon/worktree/boundTreeRoots.ts
+function boundTreeRoots(sessions, exclude) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const session of sessions.values()) {
+    if (session === exclude) continue;
+    const root2 = treeRootOf(session);
+    if (root2 && !roots.has(root2) && holdsTree(session, root2)) roots.add(root2);
+  }
+  return roots;
+}
+function treeRootOf(session) {
+  if (!session.cwd) return void 0;
+  return canonicalTreePath(findRepoRoot(session.cwd) ?? session.cwd);
+}
+function holdsTree(session, root2) {
+  if (session.closing) return true;
+  if (session.status !== "done" && session.status !== "error") return true;
+  if (!worktreeConfigFor(root2).enabled) return true;
+  const durability = checkDurabilitySync(root2);
+  daemonLog(`tree ${root2} ${releaseReason(durability, session)}`);
+  return !durability.durable;
+}
+function releaseReason(durability, session) {
+  if (!durability.durable)
+    return `still held by finished session ${session.id}: ${durability.reason}`;
+  if (durability.gone)
+    return `free for allocation: session ${session.id}'s directory is gone from disk \u2014 nothing to land, not landed work`;
+  return `free for allocation: session ${session.id} finished and its work is landed`;
+}
+
+// src/commands/sessions/daemon/worktree/allocateAndBind.ts
+function allocateAndBind(ctx, cwd, create, options2 = {}, context) {
+  const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions), options2);
+  const needsSeeding = alloc.kind === "worktree" && alloc.created === true;
+  const id = ctx.spawnWith(
+    (sid) => create(sid, alloc.cwd, needsSeeding),
+    context
+  );
+  bindNewWorktree(ctx.sessions.get(id), alloc, ctx.notify, ctx.startHeld);
+  return id;
+}
+
+// src/commands/sessions/daemon/worktree/divergencePrompt.ts
+var MAX_REASON_LINES = 20;
+var MAX_REASON_CHARS = 2e3;
+var RECONCILE_STEPS = [
+  "Reconcile it yourself, without discarding any commits on either side:",
+  "",
+  "1. Inspect `git status`, `git log --oneline @{u}..@` and `git log --oneline @..@{u}`.",
+  '2. Stash any uncommitted work with `git stash push -u -m "assist divergence"`, and restore it with `git stash pop` once the branch is reconciled.',
+  "3. Rebase the local commits onto the upstream with `git rebase @{u}`, resolving conflicts so both sides' changes survive. If the rebase cannot be resolved cleanly, `git rebase --abort` and `git merge @{u}` instead.",
+  "4. Push the result with a plain `git push` so the branch matches its upstream again.",
+  "5. Build the clone with `assist run auto-build`.",
+  "6. Run /close. The daemon resumes its auto-update loop once this session closes.",
+  "",
+  "Never force-push, `git reset`, or otherwise discard commits. If you cannot reconcile the branch without doing so, explain what is blocking it and leave this session open for the user instead of closing it."
+];
+var SIMULATED_STEPS = [
+  "This divergence was simulated to test the escalation; there is nothing to reconcile. Run /close now. The daemon resumes its auto-update loop once this session closes."
+];
+function divergenceReason(scrollback) {
+  return stripAnsi(scrollback).split(/\r?\n|\r/).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(-MAX_REASON_LINES).join("\n").slice(-MAX_REASON_CHARS);
+}
+function divergencePrompt(clone, scrollback) {
+  const reason4 = divergenceReason(scrollback);
+  return [
+    `The daemon's auto-update loop for the assist install in ${clone} paused because \`assist watch wait --pull --build\` could not fast-forward the branch (exit 3). The tail of its output:`,
+    "",
+    "```",
+    reason4 || "(no output captured)",
+    "```",
+    "",
+    ...reason4.includes(simulatedDivergenceNote) ? SIMULATED_STEPS : RECONCILE_STEPS
+  ].join("\n");
+}
+
+// src/commands/sessions/daemon/worktree/liveEscalationIn.ts
+var ENDED = ["done", "error"];
+function liveEscalationIn(sessions, clone) {
+  return [...sessions.values()].find(
+    (s) => s.divergenceEscalation === true && s.cwd !== void 0 && canonicalTreePath(s.cwd) === clone && !ENDED.includes(s.status)
+  );
+}
+
+// src/commands/sessions/daemon/worktree/escalateDivergence.ts
+function escalateDivergence(ctx, cwd, output) {
+  const clone = canonicalTreePath(cwd);
+  const live = liveEscalationIn(ctx.sessions, clone);
+  if (live) {
+    daemonLog(
+      `auto-update diverged in the clone ${clone}: no escalation spawned, session ${live.id} is already diagnosing it (${live.status})`
+    );
+    return live.id;
+  }
+  const prompt = divergencePrompt(clone, output);
+  const id = allocateAndBind(
+    ctx,
+    clone,
+    (sid, resolvedCwd) => ({
+      ...createSession(sid, { prompt, cwd: resolvedCwd ?? clone }),
+      divergenceEscalation: true
+    }),
+    { inPlace: true }
+  );
+  daemonLog(
+    `auto-update diverged in the clone ${clone}: spawned escalation session ${id} to diagnose it`
+  );
+  return id;
+}
+
+// src/commands/sessions/daemon/autoUpdate/lineRecorder.ts
+function lineRecorder(onLine) {
+  let pending = "";
+  return (text17) => {
+    const lines2 = (pending + text17).split(/\r?\n|\r/);
+    pending = lines2.pop() ?? "";
+    for (const line of lines2) {
+      const clean2 = stripAnsi(line).trimEnd();
+      if (clean2.trim()) onLine(clean2);
+    }
+  };
+}
+
+// src/commands/sessions/daemon/autoUpdate/runUpdateLap.ts
+import { spawn as spawn11 } from "child_process";
+function runUpdateLap(cwd, onOutput) {
+  return new Promise((resolve28, reject) => {
+    const { ASSIST_ACTIVITY_ID: _activity, ...env } = process.env;
+    const child = spawn11(
+      process.execPath,
+      [process.argv[1], ...WATCH_LAP_ARGS],
+      {
+        cwd,
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true
+      }
+    );
+    const killWithDaemon = () => {
+      child.kill();
+    };
+    process.on("exit", killWithDaemon);
+    child.stdout.on("data", (chunk) => onOutput(chunk.toString()));
+    child.stderr.on("data", (chunk) => onOutput(chunk.toString()));
+    child.on("close", (code, signal) => {
+      process.off("exit", killWithDaemon);
+      resolve28({ code, signal });
+    });
+    child.on("error", (error) => {
+      process.off("exit", killWithDaemon);
+      reject(error);
+    });
+  });
+}
+
+// src/commands/sessions/daemon/autoUpdate/loopDeps.ts
+function loopDeps(installDir, ctx) {
+  const clone = canonicalTreePath(installDir);
+  const logLine = lineRecorder((line) => daemonLog(`auto-update: ${line}`));
+  return {
+    runLap: (onOutput) => runUpdateLap(installDir, onOutput),
+    record: (text17) => {
+      appendWatcherLog(installDir, text17);
+      logLine(text17);
+    },
+    note: (text17) => {
+      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) => {
+      const status2 = ctx().sessions.get(sessionId)?.status;
+      return status2 !== void 0 && status2 !== "done" && status2 !== "error";
+    },
+    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 (!isGitRepo(installDir)) {
+    stayOff(`${installDir} is not a git clone`);
+    return;
+  }
+  autoUpdateState.setStartCommit(headCommit3(installDir));
+  if (!autoUpdateEnabled(installDir)) {
+    stayOff("autoUpdate.enabled is false");
+    return;
+  }
+  trimWatcherLog(installDir);
+  daemonLog(`auto-update: pulling and building ${installDir} as origin moves`);
+  void runAutoUpdateLoop(loopDeps(installDir, ctx)).catch(
+    (error) => daemonLog(
+      `auto-update: loop stopped: ${error instanceof Error ? error.message : String(error)}`
+    )
+  );
+}
+
 // src/commands/sessions/daemon/setStatus.ts
 function setStatus2(session, newStatus) {
   const now = Date.now();
@@ -42010,16 +42495,16 @@ function setStatus2(session, newStatus) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 import { existsSync as existsSync87 } from "fs";
-import { basename as basename28 } from "path";
+import { basename as basename29 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
 import { existsSync as existsSync86 } from "fs";
-import { join as join102 } from "path";
+import { join as join103 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
 import { statSync as statSync15 } from "fs";
 import { rm as rm3 } from "fs/promises";
-import { join as join101 } from "path";
+import { join as join102 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     const refusal = "it is a clone of its own, not a linked worktree";
@@ -42047,7 +42532,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync15(join101(worktreePath, ".git"), {
+  return statSync15(join102(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -42083,7 +42568,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync86(join102(worktreePath, ".git")))
+  if (!existsSync86(join103(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -42153,7 +42638,7 @@ async function reapWorktree(worktreePath, force = false) {
   const clone = owningClone(worktreePath);
   const removal = await removeTree(clone, worktreePath, force);
   if (!removal.removed) return removal;
-  await deleteWorktreeBranch(clone, basename28(worktreePath));
+  await deleteWorktreeBranch(clone, basename29(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return removal;
@@ -42227,34 +42712,6 @@ function killPtyTree(pty2) {
   }
 }
 
-// src/commands/sessions/daemon/worktree/liveWatcherFor.ts
-function liveWatcherFor(sessions, clone) {
-  for (const session of sessions.values())
-    if (session.watcher === true && session.cwd !== void 0 && (clone === void 0 || canonicalTreePath(session.cwd) === clone) && session.status !== "stopped" && session.status !== "error")
-      return session;
-  return void 0;
-}
-
-// src/commands/sessions/daemon/worktree/resolveClone.ts
-function resolveClone(cwd) {
-  const repoRoot2 = findRepoRoot(cwd) ?? cwd;
-  return canonicalTreePath(mainWorktree(repoRoot2) ?? repoRoot2);
-}
-
-// src/commands/sessions/daemon/worktree/orphanedWatcherFor.ts
-function orphanedWatcherFor(sessions, dismissed) {
-  if (dismissed.watcher === true || !dismissed.cwd) return void 0;
-  if (!liveWatcherFor(sessions)) return void 0;
-  const known = dismissed.worktree?.clone ?? dismissed.releasedFromClone;
-  const clone = known ? canonicalTreePath(known) : resolveClone(dismissed.cwd);
-  const watcher = liveWatcherFor(sessions, clone);
-  if (!watcher) return void 0;
-  const kept = [...sessions.values()].some(
-    (s) => s.watcher !== true && s.cwd !== void 0 && resolveClone(s.cwd) === clone
-  );
-  return kept ? void 0 : { watcher, clone };
-}
-
 // src/commands/sessions/daemon/worktree/treeUnderClose.ts
 function treeUnderClose(session) {
   if (session.worktree) return { path: session.worktree.path, removable: true };
@@ -42285,13 +42742,6 @@ function dismissSession(sessions, id) {
   if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
   sessions.delete(id);
   daemonLog(`session ${id} dismissed (${s.name})`);
-  const orphan = orphanedWatcherFor(sessions, s);
-  if (orphan) {
-    daemonLog(
-      `reaping watcher session ${orphan.watcher.id} for the clone ${orphan.clone}: its last session ${id} was dismissed`
-    );
-    dismissSession(sessions, orphan.watcher.id);
-  }
   if (!s.worktree) return true;
   if (sharedWith.length > 0)
     daemonLog(
@@ -42526,43 +42976,6 @@ function dismissSessionGated(sessions, id, notify2, discard = false) {
   settle();
 }
 
-// src/commands/sessions/daemon/worktree/resumeWatcherAfterEscalation.ts
-var ENDED = ["done", "error"];
-var endedViaDismissOrExit = /* @__PURE__ */ new WeakSet();
-function resumeWatcherAfterEscalation(sessions, escalation, restart) {
-  if (escalation.divergenceEscalation !== true || !escalation.cwd) return;
-  if (endedViaDismissOrExit.has(escalation)) return;
-  endedViaDismissOrExit.add(escalation);
-  const clone = canonicalTreePath(escalation.cwd);
-  const watcher = [...sessions.values()].find(
-    (s) => s.watcher === true && s.cwd !== void 0 && canonicalTreePath(s.cwd) === clone
-  );
-  if (!watcher) {
-    daemonLog(
-      `escalation session ${escalation.id} ended: no watcher left in the clone ${clone} to restart`
-    );
-    return;
-  }
-  if (!ENDED.includes(watcher.status)) {
-    daemonLog(
-      `escalation session ${escalation.id} ended: watcher session ${watcher.id} in the clone ${clone} is already ${watcher.status}`
-    );
-    return;
-  }
-  daemonLog(
-    `escalation session ${escalation.id} ended: restarting watcher session ${watcher.id} in the clone ${clone}`
-  );
-  watcher.watcherRestartReason = `after escalation session ${escalation.id} ended`;
-  restart(watcher.id);
-}
-
-// src/commands/sessions/daemon/dismissAndResumeWatcher.ts
-function dismissAndResumeWatcher(sessions, id, notify2, restart) {
-  const session = sessions.get(id);
-  dismissSessionGated(sessions, id, notify2);
-  if (session) resumeWatcherAfterEscalation(sessions, session, restart);
-}
-
 // src/commands/sessions/daemon/drainSessions.ts
 function drainSessions(sessions, notify2) {
   const drained = [...sessions.values()].map((s) => ({
@@ -42976,37 +43389,10 @@ function startSessionTitleGeneration(session, notify2) {
   runSessionTitleGeneration(session, prompt, notify2, singleLineTitle(prompt));
 }
 
-// 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 basename29, join as join103 } 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 ?? join103(homedir26(), ".assist", "watchers");
-  return join103(dir, `${basename29(clone) || "root"}-${key}.log`);
-}
-
-// src/commands/sessions/daemon/worktree/appendWatcherLog.ts
-function appendWatcherLog(session, data) {
-  if (session.watcher !== true || !session.cwd) return;
-  try {
-    const path106 = watcherLogPath(session.cwd);
-    mkdirSync34(dirname42(path106), { recursive: true });
-    appendFileSync3(path106, data);
-  } catch {
-  }
-}
-
 // src/commands/sessions/daemon/emitSessionOutput.ts
 var MAX_SCROLLBACK = 256 * 1024;
 function emitSessionOutput(session, clients, data) {
   session.scrollback += data;
-  appendWatcherLog(session, data);
   if (session.scrollback.length > MAX_SCROLLBACK) {
     session.scrollback = session.scrollback.slice(-MAX_SCROLLBACK);
   }
@@ -44077,13 +44463,6 @@ function applyUsageRecord(sessions, windows, notify2, claudeSessionId, transcrip
     notify2();
 }
 
-// src/commands/sessions/daemon/watcherNote.ts
-function watcherNote(text17) {
-  return `\r
-\x1B[2m\u2500\u2500 ${text17} \u2500\u2500\x1B[0m\r
-`;
-}
-
 // src/commands/sessions/daemon/shouldAutoRun.ts
 function shouldAutoRun(session, status2 = session.status) {
   if (!session.autoRun) return { run: false, reason: null };
@@ -44138,7 +44517,6 @@ function shouldAutoDismiss(session, exitCode) {
 }
 
 // src/commands/sessions/daemon/finishStatusChange.ts
-var DIVERGED_EXIT_CODE = 3;
 function finishStatusChange(session, status2, exitCode, deps2) {
   daemonLog(`session ${session.id} status: ${session.status} -> ${status2}`);
   void flushPhaseActiveMs(session);
@@ -44146,9 +44524,6 @@ function finishStatusChange(session, status2, exitCode, deps2) {
   if (status2 === "waiting")
     startTranscriptTitleGeneration(session, deps2.notify);
   if (status2 !== "stopped") session.undurable = void 0;
-  if (session.watcher === true && exitCode === DIVERGED_EXIT_CODE)
-    deps2.escalateDivergence?.(session);
-  if (status2 === "done" || status2 === "error") deps2.resumeWatcher?.(session);
   const autoRun = shouldAutoRun(session);
   if (autoRun.run) {
     deps2.reuseForRun(session, autoRun.itemId);
@@ -44194,40 +44569,6 @@ function makeStatusChangeHandler(sessions, deps2) {
   );
 }
 
-// src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
-function detectExistingWorktree(cwd) {
-  const repoRoot2 = findRepoRoot(cwd) ?? cwd;
-  if (!worktreeConfigFor(repoRoot2).enabled) return void 0;
-  const clone = mainWorktree(repoRoot2);
-  if (clone && clone !== repoRoot2) return { path: repoRoot2, clone };
-  return void 0;
-}
-
-// src/commands/sessions/daemon/worktree/bindNewWorktree.ts
-function bindNewWorktree(session, alloc, notify2, startHeld = () => {
-}) {
-  if (alloc.kind !== "worktree" || !alloc.cwd || !alloc.clone || !session)
-    return;
-  session.worktree = { path: alloc.cwd, clone: alloc.clone };
-  if (alloc.created)
-    seedWorktree(alloc.cwd, alloc.clone, () => startHeld(session));
-  notify2();
-}
-function bindRestoredWorktrees(sessions) {
-  for (const session of sessions.values()) {
-    if (session.worktree || !session.cwd) continue;
-    const worktree = detectExistingWorktree(session.cwd);
-    if (worktree) session.worktree = worktree;
-  }
-}
-function bindResumedWorktree(session, cwd, notify2) {
-  if (!session) return;
-  const worktree = detectExistingWorktree(cwd);
-  if (!worktree) return;
-  session.worktree = worktree;
-  notify2();
-}
-
 // src/commands/sessions/daemon/attachReusedRun.ts
 function attachReusedRun(session, alloc, clients, onStatusChange, tree) {
   broadcast(clients, { type: "clear", sessionId: session.id });
@@ -44306,137 +44647,6 @@ function startReusedRunPty(session, assistArgs, itemId2, hold, clients, onStatus
   return true;
 }
 
-// src/commands/sessions/daemon/createAssistSession.ts
-function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
-  const startedAt = Date.now();
-  return {
-    id,
-    name: `assist ${assistArgs.join(" ")}`,
-    title: meta?.title,
-    subtitle: meta?.subtitle,
-    commandType: "assist",
-    status: "running",
-    startedAt,
-    runningMs: 0,
-    runningSince: startedAt,
-    waitingSince: null,
-    ...startOrHoldPty(
-      () => spawnPty(["assist", ...assistArgs], cwd, id),
-      holdPty
-    ),
-    scrollback: "",
-    assistArgs,
-    cwd
-  };
-}
-
-// src/commands/sessions/daemon/worktree/seedWatcherScrollback.ts
-import { readFileSync as readFileSync65, writeFileSync as writeFileSync54 } from "fs";
-var SCROLLBACK_TAIL = 256 * 1024;
-var MAX_LOG_SIZE = 4 * 1024 * 1024;
-function readLogTail2(path106) {
-  let log2;
-  try {
-    log2 = readFileSync65(path106, "utf8");
-  } catch {
-    return "";
-  }
-  if (log2.length > MAX_LOG_SIZE) {
-    log2 = log2.slice(-SCROLLBACK_TAIL);
-    writeFileSync54(path106, log2);
-    daemonLog(`watcher log ${path106} trimmed to its last ${log2.length} chars`);
-  }
-  return log2.slice(-SCROLLBACK_TAIL);
-}
-function seedWatcherScrollback(cwd, event) {
-  const path106 = watcherLogPath(cwd);
-  const history = readLogTail2(path106);
-  const note = watcherNote(`${event} at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
-  appendWatcherLog({ watcher: true, cwd }, note);
-  daemonLog(
-    `watcher in ${cwd} seeded with ${history.length} chars of history from ${path106} (${event})`
-  );
-  return history + note;
-}
-
-// src/commands/sessions/daemon/createWatcherSession.ts
-var WATCHER_ARGS = ["watch", "loop"];
-function createWatcherSession(id, cwd) {
-  return {
-    ...createAssistSession(id, WATCHER_ARGS, cwd),
-    watcher: true,
-    scrollback: seedWatcherScrollback(cwd, "watcher started")
-  };
-}
-
-// src/commands/sessions/daemon/worktree/boundTreeRoots.ts
-function boundTreeRoots(sessions, exclude) {
-  const roots = /* @__PURE__ */ new Set();
-  for (const session of sessions.values()) {
-    if (session === exclude) continue;
-    const root2 = treeRootOf(session);
-    if (root2 && !roots.has(root2) && holdsTree(session, root2)) roots.add(root2);
-  }
-  return roots;
-}
-function treeRootOf(session) {
-  if (!session.cwd) return void 0;
-  return canonicalTreePath(findRepoRoot(session.cwd) ?? session.cwd);
-}
-function holdsTree(session, root2) {
-  if (session.closing) return true;
-  if (session.status !== "done" && session.status !== "error") return true;
-  if (!worktreeConfigFor(root2).enabled) return true;
-  const durability = checkDurabilitySync(root2);
-  daemonLog(`tree ${root2} ${releaseReason(durability, session)}`);
-  return !durability.durable;
-}
-function releaseReason(durability, session) {
-  if (!durability.durable)
-    return `still held by finished session ${session.id}: ${durability.reason}`;
-  if (durability.gone)
-    return `free for allocation: session ${session.id}'s directory is gone from disk \u2014 nothing to land, not landed work`;
-  return `free for allocation: session ${session.id} finished and its work is landed`;
-}
-
-// src/commands/sessions/daemon/worktree/allocateAndBind.ts
-function allocateAndBind(ctx, cwd, create, options2 = {}, context) {
-  const alloc = allocateTree(cwd, boundTreeRoots(ctx.sessions), options2);
-  const needsSeeding = alloc.kind === "worktree" && alloc.created === true;
-  const id = ctx.spawnWith(
-    (sid) => create(sid, alloc.cwd, needsSeeding),
-    context
-  );
-  bindNewWorktree(ctx.sessions.get(id), alloc, ctx.notify, ctx.startHeld);
-  return id;
-}
-
-// src/commands/sessions/daemon/worktree/ensureWatcher.ts
-function ensureWatcher(ctx, cwd) {
-  if (!cwd) return void 0;
-  const repoRoot2 = findRepoRoot(cwd) ?? cwd;
-  const cfg = worktreeConfigFor(repoRoot2);
-  if (!cfg.enabled || cfg.watcher !== true) return void 0;
-  const clone = resolveClone(repoRoot2);
-  const live = liveWatcherFor(ctx.sessions, clone);
-  if (live) {
-    daemonLog(
-      `no watcher spawned for the clone ${clone}: session ${live.id} is already watching it (${live.status})`
-    );
-    return void 0;
-  }
-  const id = allocateAndBind(
-    ctx,
-    clone,
-    (sid, resolvedCwd) => createWatcherSession(sid, resolvedCwd ?? clone),
-    { inPlace: true }
-  );
-  daemonLog(
-    `spawned watcher session ${id} running assist ${WATCHER_ARGS.join(" ")} in the clone ${clone}`
-  );
-  return id;
-}
-
 // src/commands/sessions/daemon/worktree/isBacklogRunArgs.ts
 var ITEM_ID = /^a?\d+$/;
 function isBacklogRunArgs(args) {
@@ -44500,7 +44710,6 @@ function failChainedRun(session, itemId2, error, clients, tree) {
 // src/commands/sessions/daemon/reuseSessionForRun.ts
 function reuseSessionForRun(session, itemId2, clients, onStatusChange, tree) {
   const assistArgs = ["backlog", "run", String(itemId2)];
-  const originCwd = session.cwd;
   resetCardForRun(session, assistArgs);
   let alloc;
   try {
@@ -44522,13 +44731,71 @@ function reuseSessionForRun(session, itemId2, clients, onStatusChange, tree) {
     onStatusChange
   );
   if (!started) return;
-  if (tree) ensureWatcher(tree, originCwd);
   attachReusedRun(session, alloc, clients, onStatusChange, tree);
   daemonLog(
     `session ${session.id} reused for backlog run ${itemId2}: ${session.name}`
   );
 }
 
+// src/commands/sessions/daemon/managerStatusChangeHandler.ts
+function managerStatusChangeHandler(sessions, clients, dismiss, notify2, treeCtx) {
+  const handler = makeStatusChangeHandler(sessions, {
+    dismiss,
+    notify: notify2,
+    reuseForRun: (session, itemId2) => reuseSessionForRun(session, itemId2, clients, handler, treeCtx())
+  });
+  return handler;
+}
+
+// src/commands/sessions/daemon/applySetStatus.ts
+function applySetStatus(sessions, id, status2, source, onStatusChange, rebind) {
+  const session = sessions.get(id);
+  if (!session) {
+    daemonLog(
+      `set-status for unknown session id=${id} status=${status2} (no live session; ignoring)`
+    );
+    return;
+  }
+  if (session.status === "stopped") {
+    daemonLog(
+      `set-status for stopped session id=${id} status=${status2} (held pending durable close; ignoring)`
+    );
+    return;
+  }
+  rebind?.(session);
+  if (source === "permission") session.permissionActive = true;
+  if (status2 === "running") session.permissionActive = false;
+  onStatusChange(session, status2);
+}
+
+// src/commands/sessions/daemon/rebindClaudeSession.ts
+function rebindClaudeSession(session, claudeSessionId, notify2, onStatusChange) {
+  if (!claudeSessionId) return;
+  if (session.claudeSessionId === claudeSessionId) return;
+  daemonLog(
+    `session ${session.id} claude session moved: ${session.claudeSessionId ?? "none"} -> ${claudeSessionId}`
+  );
+  session.claudeSessionId = claudeSessionId;
+  watchTranscript(session, notify2, onStatusChange);
+}
+
+// src/commands/sessions/daemon/setStatusFromHook.ts
+function setStatusFromHook(sessions, report, notify2, onStatusChange) {
+  applySetStatus(
+    sessions,
+    report.id,
+    report.status,
+    report.source,
+    onStatusChange,
+    (session) => rebindClaudeSession(
+      session,
+      report.claudeSessionId,
+      notify2,
+      onStatusChange
+    )
+  );
+}
+
 // src/commands/sessions/daemon/respawnSession.ts
 function respawnSession(session, respawn, status2, clients, onStatusChange) {
   session.gitWatcher?.close();
@@ -44537,8 +44804,7 @@ function respawnSession(session, respawn, status2, clients, onStatusChange) {
   session.pendingDismiss = void 0;
   session.closeGrace?.cancel();
   session.closing = void 0;
-  const keepHistory = session.watcher === true;
-  if (!keepHistory) session.scrollback = "";
+  session.scrollback = "";
   session.startedAt = Date.now();
   session.runningMs = 0;
   session.runningSince = null;
@@ -44555,15 +44821,7 @@ function respawnSession(session, respawn, status2, clients, onStatusChange) {
       session.pty?.resize(session.cols, session.rows);
     } catch {
     }
-  if (keepHistory) {
-    const reason4 = session.watcherRestartReason;
-    session.watcherRestartReason = void 0;
-    emitSessionOutput(
-      session,
-      clients,
-      watcherNote(reason4 ? `watcher restarted ${reason4}` : "watcher restarted")
-    );
-  } else broadcast(clients, { type: "clear", sessionId: session.id });
+  broadcast(clients, { type: "clear", sessionId: session.id });
   wirePtyEvents(session, clients, onStatusChange);
 }
 
@@ -44734,144 +44992,6 @@ function restartManagedSession(sessions, id, clients, onStatusChange) {
   return { ok: true };
 }
 
-// src/commands/sessions/daemon/worktree/divergencePrompt.ts
-var MAX_REASON_LINES = 20;
-var MAX_REASON_CHARS = 2e3;
-var RECONCILE_STEPS = [
-  "Reconcile it yourself, without discarding any commits on either side:",
-  "",
-  "1. Inspect `git status`, `git log --oneline @{u}..@` and `git log --oneline @..@{u}`.",
-  '2. Stash any uncommitted work with `git stash push -u -m "assist divergence"`, and restore it with `git stash pop` once the branch is reconciled.',
-  "3. Rebase the local commits onto the upstream with `git rebase @{u}`, resolving conflicts so both sides' changes survive. If the rebase cannot be resolved cleanly, `git rebase --abort` and `git merge @{u}` instead.",
-  "4. Push the result with a plain `git push` so the branch matches its upstream again.",
-  "5. Build the clone with `assist run auto-build`.",
-  "6. Run /close. The daemon restarts the watcher once this session closes.",
-  "",
-  "Never force-push, `git reset`, or otherwise discard commits. If you cannot reconcile the branch without doing so, explain what is blocking it and leave this session open for the user instead of closing it."
-];
-var SIMULATED_STEPS = [
-  "This divergence was simulated to test the escalation; there is nothing to reconcile. Run /close now. The daemon restarts the watcher once this session closes."
-];
-function divergenceReason(scrollback) {
-  return stripAnsi(scrollback).split(/\r?\n|\r/).map((line) => line.trimEnd()).filter((line) => line.trim().length > 0).slice(-MAX_REASON_LINES).join("\n").slice(-MAX_REASON_CHARS);
-}
-function divergencePrompt(clone, scrollback) {
-  const reason4 = divergenceReason(scrollback);
-  return [
-    `The watcher in ${clone} stopped because \`assist watch wait --pull --build\` could not fast-forward the branch (exit 3). The tail of its output:`,
-    "",
-    "```",
-    reason4 || "(no output captured)",
-    "```",
-    "",
-    ...reason4.includes(simulatedDivergenceNote) ? SIMULATED_STEPS : RECONCILE_STEPS
-  ].join("\n");
-}
-
-// src/commands/sessions/daemon/worktree/escalateDivergence.ts
-var ENDED2 = ["done", "error", "stopped"];
-function escalateDivergence(ctx, watcher) {
-  if (!watcher.cwd) return void 0;
-  const clone = canonicalTreePath(watcher.cwd);
-  const live = [...ctx.sessions.values()].find(
-    (s) => s.divergenceEscalation === true && s.cwd !== void 0 && canonicalTreePath(s.cwd) === clone && !ENDED2.includes(s.status)
-  );
-  if (live) {
-    daemonLog(
-      `watcher session ${watcher.id} exited 3 (divergence) in the clone ${clone}: no escalation spawned, session ${live.id} is already diagnosing it (${live.status})`
-    );
-    return void 0;
-  }
-  const prompt = divergencePrompt(clone, watcher.scrollback);
-  const id = allocateAndBind(
-    ctx,
-    clone,
-    (sid, resolvedCwd) => ({
-      ...createSession(sid, { prompt, cwd: resolvedCwd ?? clone }),
-      divergenceEscalation: true
-    }),
-    { inPlace: true }
-  );
-  daemonLog(
-    `watcher session ${watcher.id} exited 3 (divergence) in the clone ${clone}: spawned escalation session ${id} to diagnose it`
-  );
-  return id;
-}
-
-// src/commands/sessions/daemon/managerStatusChangeHandler.ts
-function managerStatusChangeHandler(sessions, clients, dismiss, notify2, treeCtx) {
-  const handler = makeStatusChangeHandler(sessions, {
-    dismiss,
-    notify: notify2,
-    reuseForRun: (session, itemId2) => reuseSessionForRun(session, itemId2, clients, handler, treeCtx()),
-    escalateDivergence: (watcher) => {
-      const id = escalateDivergence(treeCtx(), watcher);
-      if (id)
-        emitSessionOutput(
-          watcher,
-          clients,
-          watcherNote(
-            `divergence escalated to session ${id}; the watcher restarts once it ends`
-          )
-        );
-    },
-    resumeWatcher: (escalation) => resumeWatcherAfterEscalation(sessions, escalation, (watcherId) => {
-      if (restartManagedSession(sessions, watcherId, clients, handler).ok)
-        notify2();
-    })
-  });
-  return handler;
-}
-
-// src/commands/sessions/daemon/applySetStatus.ts
-function applySetStatus(sessions, id, status2, source, onStatusChange, rebind) {
-  const session = sessions.get(id);
-  if (!session) {
-    daemonLog(
-      `set-status for unknown session id=${id} status=${status2} (no live session; ignoring)`
-    );
-    return;
-  }
-  if (session.status === "stopped") {
-    daemonLog(
-      `set-status for stopped session id=${id} status=${status2} (held pending durable close; ignoring)`
-    );
-    return;
-  }
-  rebind?.(session);
-  if (source === "permission") session.permissionActive = true;
-  if (status2 === "running") session.permissionActive = false;
-  onStatusChange(session, status2);
-}
-
-// src/commands/sessions/daemon/rebindClaudeSession.ts
-function rebindClaudeSession(session, claudeSessionId, notify2, onStatusChange) {
-  if (!claudeSessionId) return;
-  if (session.claudeSessionId === claudeSessionId) return;
-  daemonLog(
-    `session ${session.id} claude session moved: ${session.claudeSessionId ?? "none"} -> ${claudeSessionId}`
-  );
-  session.claudeSessionId = claudeSessionId;
-  watchTranscript(session, notify2, onStatusChange);
-}
-
-// src/commands/sessions/daemon/setStatusFromHook.ts
-function setStatusFromHook(sessions, report, notify2, onStatusChange) {
-  applySetStatus(
-    sessions,
-    report.id,
-    report.status,
-    report.source,
-    onStatusChange,
-    (session) => rebindClaudeSession(
-      session,
-      report.claudeSessionId,
-      notify2,
-      onStatusChange
-    )
-  );
-}
-
 // src/commands/sessions/daemon/restartAndNotify.ts
 function restartAndNotify(sessions, id, clients, onStatusChange, notify2) {
   const result = restartManagedSession(sessions, id, clients, onStatusChange);
@@ -44913,8 +45033,7 @@ function restoreBase(id, persisted) {
     cwd: persisted.cwd,
     assistArgs: persisted.assistArgs,
     initialPrompt: persisted.initialPrompt,
-    starred: persisted.watcher ? false : persisted.starred,
-    watcher: persisted.watcher,
+    starred: persisted.starred,
     divergenceEscalation: persisted.divergenceEscalation,
     design: persisted.design,
     auto: persisted.auto,
@@ -44974,12 +45093,19 @@ function underTempRoot(path106) {
   );
 }
 
-// src/commands/sessions/daemon/dropTempRootedSessions.ts
-function dropTempRootedSessions(persisted) {
+// src/commands/sessions/daemon/dropUnrestorableSessions.ts
+function droppedReason(entry) {
+  if (underTempRoot(entry.cwd)) return "lies outside any project root";
+  if (entry.watcher === true)
+    return "is a retired watcher session (the daemon now runs the assist auto-update loop itself)";
+  return void 0;
+}
+function dropUnrestorableSessions(persisted) {
   return persisted.filter((entry) => {
-    if (!underTempRoot(entry.cwd)) return true;
+    const reason4 = droppedReason(entry);
+    if (!reason4) return true;
     daemonLog(
-      `persisted session ${describePersistedSession(entry)} lies outside any project root; dropped rather than restored`
+      `persisted session ${describePersistedSession(entry)} ${reason4}; dropped rather than restored`
     );
     return false;
   });
@@ -45304,25 +45430,6 @@ function isUpdate(persisted) {
   return persisted.commandType === "assist" && persisted.assistArgs?.[0] === "update";
 }
 
-// src/commands/sessions/daemon/migrateClaudeWatcher.ts
-function migrateClaudeWatcher(id, persisted) {
-  if (!persisted.watcher || persisted.commandType !== "claude")
-    return persisted;
-  daemonLog(
-    `migrating claude /watch watcher session ${id} to assist ${WATCHER_ARGS.join(" ")}`
-  );
-  return {
-    ...persisted,
-    name: `assist ${WATCHER_ARGS.join(" ")}`,
-    commandType: "assist",
-    assistArgs: WATCHER_ARGS,
-    initialPrompt: void 0,
-    claudeSessionId: void 0,
-    harness: void 0,
-    harnessSessionId: void 0
-  };
-}
-
 // src/commands/sessions/daemon/needsWrapperRelaunch.ts
 var LAUNCH_COMMANDS = ["draft", "feat", "bug", "refine"];
 function needsWrapperRelaunch(persisted) {
@@ -45335,36 +45442,11 @@ function isOnceLaunch(persisted) {
   return persisted.commandType === "assist" && !!persisted.assistArgs && LAUNCH_COMMANDS.includes(persisted.assistArgs[0]) && persisted.assistArgs.includes("--once");
 }
 
-// src/commands/sessions/daemon/relaunchConsoleWatcher.ts
-function isConsoleWatcher(persisted) {
-  return persisted.watcher === true && persisted.commandType === "assist" && !!persisted.assistArgs;
-}
-function relaunchConsoleWatcher(id, persisted, base) {
-  const command = ["assist", ...persisted.assistArgs];
-  daemonLog(
-    `relaunching watcher session ${id} running ${command.join(" ")} in ${persisted.cwd ?? "(no cwd)"}`
-  );
-  const session = runningSession(
-    base,
-    persisted,
-    spawnPty(command, persisted.cwd, id)
-  );
-  if (persisted.cwd)
-    session.scrollback = seedWatcherScrollback(
-      persisted.cwd,
-      "daemon restarted; watcher relaunched"
-    );
-  return session;
-}
-
 // src/commands/sessions/daemon/restoreSession.ts
-function restoreSession(id, stored) {
-  const persisted = migrateClaudeWatcher(id, stored);
+function restoreSession(id, persisted) {
   const base = restoreBase(id, persisted);
   if (persisted.status === "stopped") return stoppedSession(base, persisted);
   if (isUpdate(persisted)) return updatedSession(id, persisted);
-  if (isConsoleWatcher(persisted))
-    return relaunchConsoleWatcher(id, persisted, base);
   const status2 = deriveRestoreStatus(persisted);
   if (needsWrapperRelaunch(persisted)) {
     const resumesWrittenConversation = hasTranscriptOnDisk(persisted);
@@ -45418,7 +45500,7 @@ function logRestoreError(persisted, error) {
 
 // src/commands/sessions/daemon/restoreAll.ts
 function restoreAll(spawner, sessions) {
-  const persisted = dropTempRootedSessions(loadPersistedSessions());
+  const persisted = dropUnrestorableSessions(loadPersistedSessions());
   const cap2 = sessionLimits.maxRestore();
   const restoredIds = /* @__PURE__ */ new Map();
   const names = persisted.slice(0, cap2).map((entry) => {
@@ -45674,10 +45756,10 @@ function restoreAllSessions(spawner, sessions, notify2) {
 
 // src/commands/sessions/daemon/retrySession.ts
 function retrySession(session, clients, onStatusChange) {
-  const spawn11 = respawnThunk(session);
-  if (!spawn11) return false;
+  const spawn12 = respawnThunk(session);
+  if (!spawn12) return false;
   const respawn = () => {
-    respawnSession(session, spawn11, "running", clients, onStatusChange);
+    respawnSession(session, spawn12, "running", clients, onStatusChange);
     daemonLog(`session ${session.id} retried: ${session.name}`);
   };
   const pty2 = session.pty;
@@ -46706,6 +46788,30 @@ function addAgentToStream(ctx, targetId, request) {
   };
 }
 
+// src/commands/sessions/daemon/createAssistSession.ts
+function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
+  const startedAt = Date.now();
+  return {
+    id,
+    name: `assist ${assistArgs.join(" ")}`,
+    title: meta?.title,
+    subtitle: meta?.subtitle,
+    commandType: "assist",
+    status: "running",
+    startedAt,
+    runningMs: 0,
+    runningSince: startedAt,
+    waitingSince: null,
+    ...startOrHoldPty(
+      () => spawnPty(["assist", ...assistArgs], cwd, id),
+      holdPty
+    ),
+    scrollback: "",
+    assistArgs,
+    cwd
+  };
+}
+
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
 function spawnInTree(ctx, { prompt, cwd, design, auto, harness, inPlace }, context) {
   return allocateAndBind(
@@ -46724,7 +46830,7 @@ function spawnInTree(ctx, { prompt, cwd, design, auto, harness, inPlace }, conte
   );
 }
 function spawnAssistInTree(ctx, assistArgs, cwd, meta, context) {
-  const id = allocateAndBind(
+  return allocateAndBind(
     ctx,
     cwd,
     (sid, resolvedCwd, holdUntilSeeded) => createAssistSession(sid, assistArgs, resolvedCwd, meta, holdUntilSeeded),
@@ -46737,8 +46843,6 @@ function spawnAssistInTree(ctx, assistArgs, cwd, meta, context) {
     },
     context
   );
-  if (isBacklogRunArgs(assistArgs)) ensureWatcher(ctx, cwd);
-  return id;
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
@@ -46965,13 +47069,11 @@ var SessionManager = class {
     );
   }
   dismissSession = (id) => {
-    dismissAndResumeWatcher(
-      this.sessions,
-      id,
-      this.notify,
-      (watcherId) => this.restart(watcherId)
-    );
+    dismissSessionGated(this.sessions, id, this.notify);
   };
+  startAutoUpdate() {
+    startAutoUpdate(() => this.treeCtx());
+  }
   discardSession = (id) => {
     dismissSessionGated(this.sessions, id, this.notify, true);
   };
@@ -47036,6 +47138,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());
@@ -47049,10 +47161,10 @@ var handleHelloRequest = (client, m, d) => {
 };
 
 // src/commands/sessions/daemon/creator.ts
-function creator(isNew, spawn11) {
+function creator(isNew, spawn12) {
   return (client, m, d) => {
     if (m.links.route(client, d)) return;
-    const result = spawn11(m, d);
+    const result = spawn12(m, d);
     if (typeof result !== "string") {
       sendTo(client, { type: "error", message: result.error });
       return;
@@ -47561,6 +47673,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();
@@ -47718,6 +47831,7 @@ function onListening(manager, checkAutoExit) {
   );
   daemonLog(`listening on ${daemonPaths.socket}`);
   manager.links.reload();
+  manager.startAutoUpdate();
   checkAutoExit(manager.isIdle());
 }
 function cleanupOwnedFiles() {
@@ -47820,6 +47934,7 @@ function registerDaemon(program2) {
   cmd.command("drain").description(
     "Remove all sessions from the local daemon for a clean slate (does not affect the Windows daemon); prompts before closing live sessions, and a session holding unpushed work is stopped, not removed"
   ).option("--yes", "Close live sessions without confirming").action((options2) => drainDaemon(options2));
+  configHelp(cmd, autoUpdateConfigHelp);
 }
 
 // src/commands/sessions/closeSession.ts
@@ -48080,14 +48195,14 @@ async function linkStatus(name, query = queryNodes) {
   return (await query())?.links.find((l) => l.name === name);
 }
 async function awaitLinkReturn(name, options2, deps2 = {}) {
-  const { query = queryNodes, sleep: sleep2 = wait, now = Date.now } = deps2;
+  const { query = queryNodes, sleep: sleep3 = wait, now = Date.now } = deps2;
   const deadline = now() + options2.timeoutMs;
   let sawDown = options2.sawDown;
   while (now() < deadline) {
     const link3 = await linkStatus(name, query);
     if (link3?.state !== "connected") sawDown = true;
     else if (sawDown) return link3;
-    await sleep2(POLL_MS4);
+    await sleep3(POLL_MS4);
   }
   return void 0;
 }