@staff0rd/assist 0.774.0 → 0.774.1

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.774.1",
   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(),
@@ -11241,7 +11248,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 +11263,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);
     }
   }
 }
@@ -12786,6 +12793,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 +13295,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 +13401,7 @@ var verifyConfigHelp = [
 var configHelpEntries = [
   ...Object.values(rootConfigHelp).flat(),
   ...adviceConfigHelp,
+  ...autoUpdateConfigHelp,
   ...backlogConfigHelp,
   ...backupConfigHelp,
   ...branchConfigHelp,
@@ -25861,7 +25873,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 +26005,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,
@@ -41405,7 +41415,6 @@ function toSessionInfo(session) {
     autoRun,
     autoAdvance,
     starred,
-    watcher,
     design,
     verifying,
     pendingPrPreview,
@@ -41432,7 +41441,6 @@ function toSessionInfo(session) {
     autoRun,
     autoAdvance,
     starred,
-    watcher,
     design,
     verifying,
     pendingPrPreview,
@@ -41988,6 +41996,359 @@ function createRunSession(id, { runName, runArgs, cwd, meta }) {
   };
 }
 
+// src/commands/sessions/daemon/autoUpdate/startAutoUpdate.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";
+
+// src/commands/sessions/daemon/worktree/watcherLogPath.ts
+import { createHash as createHash4 } from "crypto";
+import { homedir as homedir26 } from "os";
+import { basename as basename28, join as join101 } from "path";
+function watcherLogPath(cwd) {
+  const clone = canonicalTreePath(cwd);
+  const key = createHash4("sha1").update(clone).digest("hex").slice(0, 8);
+  const dir = process.env.ASSIST_WATCHER_LOG_DIR ?? join101(homedir26(), ".assist", "watchers");
+  return join101(dir, `${basename28(clone) || "root"}-${key}.log`);
+}
+
+// src/commands/sessions/daemon/worktree/appendWatcherLog.ts
+function appendWatcherLog(cwd, data) {
+  try {
+    const path106 = watcherLogPath(cwd);
+    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/autoUpdateEnabled.ts
+function autoUpdateEnabled(installDir) {
+  try {
+    return loadConfigFrom(installDir).autoUpdate?.enabled ?? true;
+  } catch (error) {
+    daemonLog(
+      `auto-update: config failed to load, keeping the default (on): ${error instanceof Error ? error.message : String(error)}`
+    );
+    return true;
+  }
+}
+
+// src/commands/sessions/daemon/autoUpdate/lineRecorder.ts
+function lineRecorder(onLine) {
+  let pending = "";
+  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/holdForEscalation.ts
+var ESCALATION_POLL_MS = 5e3;
+async function holdForEscalation(sessionId, deps2) {
+  deps2.note(`paused while session ${sessionId} reconciles the divergence`);
+  while (deps2.isLive(sessionId)) await deps2.sleep(ESCALATION_POLL_MS);
+  deps2.note(`session ${sessionId} ended; resuming`);
+}
+
+// src/commands/sessions/daemon/autoUpdate/runLapCapturingTail.ts
+var OUTPUT_TAIL = 16 * 1024;
+async function runLapCapturingTail(deps2) {
+  let tail = "";
+  const end = await deps2.runLap((text17) => {
+    tail = (tail + text17).slice(-OUTPUT_TAIL);
+    deps2.record(text17);
+  });
+  return { end, tail };
+}
+
+// src/commands/sessions/daemon/autoUpdate/runAutoUpdateLoop.ts
+var DIVERGED_EXIT_CODE = 3;
+var RETRY_AFTER_FAILURE_MS = 5 * 60 * 1e3;
+async function runAutoUpdateLoop(deps2, maxLaps = Number.POSITIVE_INFINITY) {
+  let held = deps2.liveEscalation();
+  for (let lap = 1; lap <= maxLaps; lap++) {
+    if (held) await holdForEscalation(held, deps2);
+    held = void 0;
+    deps2.note(
+      `lap ${lap} at ${(/* @__PURE__ */ new Date()).toLocaleString()}: assist ${WATCH_LAP_ARGS.join(" ")}`
+    );
+    let result;
+    try {
+      result = await runLapCapturingTail(deps2);
+    } catch (error) {
+      deps2.note(
+        `lap ${lap} could not start (${error instanceof Error ? error.message : String(error)}); retrying in ${RETRY_AFTER_FAILURE_MS / 6e4}m`
+      );
+      await deps2.sleep(RETRY_AFTER_FAILURE_MS);
+      continue;
+    }
+    const { end, tail } = result;
+    const how = end.signal ? `killed by ${end.signal}` : `exited ${end.code}`;
+    if (end.code === DIVERGED_EXIT_CODE) {
+      held = deps2.escalate(tail);
+      deps2.note(`lap ${lap} ${how} (divergence); escalated to session ${held}`);
+      continue;
+    }
+    if (decideLap(end, false).kind === "relaunch") {
+      deps2.note(`lap ${lap} ${how}; relaunching`);
+      continue;
+    }
+    deps2.note(
+      `lap ${lap} ${how}; retrying in ${RETRY_AFTER_FAILURE_MS / 6e4}m`
+    );
+    await deps2.sleep(RETRY_AFTER_FAILURE_MS);
+  }
+}
+
+// src/commands/sessions/daemon/autoUpdate/runUpdateLap.ts
+import { spawn as spawn11 } from "child_process";
+function runUpdateLap(cwd, onOutput) {
+  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/trimWatcherLog.ts
+import { readFileSync as readFileSync65, writeFileSync as writeFileSync54 } from "fs";
+var KEEP_TAIL = 256 * 1024;
+var MAX_LOG_SIZE = 4 * 1024 * 1024;
+function trimWatcherLog(cwd) {
+  const path106 = watcherLogPath(cwd);
+  let log2;
+  try {
+    log2 = readFileSync65(path106, "utf8");
+  } catch {
+    return;
+  }
+  if (log2.length <= MAX_LOG_SIZE) return;
+  writeFileSync54(path106, log2.slice(-KEEP_TAIL));
+  daemonLog(`auto-update: log ${path106} trimmed to its last ${KEEP_TAIL} chars`);
+}
+
+// src/commands/sessions/daemon/autoUpdate/startAutoUpdate.ts
+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}`);
+    },
+    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)
+  };
+}
+function startAutoUpdate(ctx) {
+  const installDir = getInstallDir();
+  if (!autoUpdateEnabled(installDir)) {
+    daemonLog("auto-update: off (autoUpdate.enabled is false)");
+    return;
+  }
+  if (!isGitRepo(installDir)) {
+    daemonLog(`auto-update: off (${installDir} is not a git clone)`);
+    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 +42371,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 +42408,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 +42444,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 +42514,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 +42588,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 +42618,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 +42852,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 +43265,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 +44339,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 +44393,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 +44400,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 +44445,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 +44523,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 +44586,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 +44607,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 +44680,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 +44697,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 +44868,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 +44909,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 +44969,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 +45306,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 +45318,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 +45376,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 +45632,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 +46664,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 +46706,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 +46719,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 +46945,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);
   };
@@ -47049,10 +47027,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;
@@ -47718,6 +47696,7 @@ function onListening(manager, checkAutoExit) {
   );
   daemonLog(`listening on ${daemonPaths.socket}`);
   manager.links.reload();
+  manager.startAutoUpdate();
   checkAutoExit(manager.isIdle());
 }
 function cleanupOwnedFiles() {
@@ -47820,6 +47799,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 +48060,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;
 }