@staff0rd/assist 0.776.0 → 0.777.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.776.0",
+  version: "0.777.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -1936,6 +1936,7 @@ var daemonPaths = {
   socket: process.platform === "win32" ? perUserWindowsPipe() : join9(DAEMON_DIR, "daemon.sock"),
   log: join9(DAEMON_DIR, "daemon.log"),
   pid: join9(DAEMON_DIR, "daemon.pid"),
+  autoUpdatePaused: join9(DAEMON_DIR, "auto-update-paused"),
   spawnLock: join9(DAEMON_DIR, "spawn.lock"),
   hooksSettings: join9(DAEMON_DIR, "hooks-settings.json")
 };
@@ -11055,7 +11056,7 @@ var defaultDeps = {
   httpsPort: tailnetHttpsPort
 };
 async function ensureTailscaleServe(port, deps2 = {}) {
-  const { enabled, status: status2, serveStatus, serve, sleep: sleep3, httpsPort } = {
+  const { enabled, status: status2, serveStatus, serve, sleep: sleep2, httpsPort } = {
     ...defaultDeps,
     ...deps2
   };
@@ -11070,7 +11071,7 @@ async function ensureTailscaleServe(port, deps2 = {}) {
       return `serving ${plan2.target} at ${plan2.url}`;
     } catch (error) {
       if (attempt >= SERVE_WRITE_ATTEMPTS) throw error;
-      await sleep3(attempt * 500 + Math.random() * 500);
+      await sleep2(attempt * 500 + Math.random() * 500);
     }
   }
 }
@@ -17221,6 +17222,33 @@ async function updates(_req, res) {
   respondJson(res, 200, status2);
 }
 
+// src/commands/sessions/shared/AutoUpdateAction.ts
+var AUTO_UPDATE_ACTIONS = ["pause", "resume", "check"];
+
+// src/commands/sessions/web/updates/updatesControl.ts
+async function updatesControl(req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const action = url.searchParams.get("action");
+  if (!AUTO_UPDATE_ACTIONS.includes(action)) {
+    respondJson(res, 400, { error: "Invalid action" });
+    return;
+  }
+  console.log(`auto-update ${action} ${linkedRequester(req)}`);
+  const reply2 = await requestDaemonReply(
+    { type: "auto-update-control", action },
+    "auto-update-control"
+  );
+  if (!reply2) {
+    respondJson(res, 503, { error: "Daemon not reachable" });
+    return;
+  }
+  if (!reply2.ok) {
+    respondJson(res, 409, { error: reply2.error ?? `${action} failed` });
+    return;
+  }
+  respondJson(res, 200, { ok: true });
+}
+
 // src/commands/sessions/web/readRequestBuffer.ts
 async function readRequestBuffer(req, limit) {
   const chunks = [];
@@ -17494,7 +17522,8 @@ var routes2 = {
   "POST /api/config/set": setConfig,
   "POST /api/config/unset": unsetConfig,
   "GET /api/review/synthesis": getReviewSynthesis,
-  "GET /api/updates": updates
+  "GET /api/updates": updates,
+  "POST /api/updates/control": updatesControl
 };
 var handleRequest = createFallbackHandler(
   routes2,
@@ -40010,15 +40039,20 @@ function gitFailureReason(error) {
   return message3.trim() || "git failed without reporting a reason";
 }
 
-// src/commands/watch/simulatedDivergencePath.ts
+// src/commands/watch/gitMarkerPath.ts
 import { resolve as resolve25 } from "path";
-function simulatedDivergencePath(cwd) {
+function gitMarkerPath(name, cwd) {
   return resolve25(
     cwd ?? process.cwd(),
-    runGit3(["rev-parse", "--git-path", "assist-simulate-divergence"], cwd)
+    runGit3(["rev-parse", "--git-path", name], cwd)
   );
 }
 
+// src/commands/watch/simulatedDivergencePath.ts
+function simulatedDivergencePath(cwd) {
+  return gitMarkerPath("assist-simulate-divergence", cwd);
+}
+
 // src/commands/watch/simulateDivergence.ts
 function simulateDivergence() {
   try {
@@ -40526,11 +40560,10 @@ ${buildWatchReport(from)}`);
   process.exit(0);
 }
 
-// src/commands/watch/consumeSimulatedDivergence.ts
+// src/commands/watch/consumeMarker.ts
 import { existsSync as existsSync81, rmSync as rmSync8 } from "fs";
-function consumeSimulatedDivergence(cwd) {
+function consumeMarker(path106) {
   try {
-    const path106 = simulatedDivergencePath(cwd);
     if (!existsSync81(path106)) return false;
     rmSync8(path106);
     return true;
@@ -40539,6 +40572,15 @@ function consumeSimulatedDivergence(cwd) {
   }
 }
 
+// src/commands/watch/consumeSimulatedDivergence.ts
+function consumeSimulatedDivergence(cwd) {
+  try {
+    return consumeMarker(simulatedDivergencePath(cwd));
+  } catch {
+    return false;
+  }
+}
+
 // src/commands/watch/fetchQuietly.ts
 import { execFileSync as execFileSync21 } from "child_process";
 var MIN_FETCH_TIMEOUT_MS = 6e4;
@@ -40573,26 +40615,33 @@ function readMovement(cwd) {
 }
 
 // src/commands/watch/pollForMovement.ts
+var CONTROL_POLL_MS = 1e3;
 function pollForMovement(options2) {
-  const { upstream, intervalMs, timeoutMs, timeout, cwd } = options2;
+  const { upstream, intervalMs, timeoutMs, timeout, cwd, control } = options2;
   return new Promise((resolve28) => {
     let settled = false;
     const finish2 = (outcome) => {
       if (settled) return;
       settled = true;
       clearInterval(ticker);
+      clearInterval(controller);
       clearTimeout(deadline);
       process.off("SIGINT", onInterrupt);
       resolve28(outcome);
     };
     const onInterrupt = () => finish2({ kind: "interrupted" });
-    const ticker = setInterval(() => {
+    const check2 = () => {
       if (consumeSimulatedDivergence(cwd))
         return finish2({ kind: "simulated-divergence", upstream });
       fetchQuietly(cwd, intervalMs);
       const found = readMovement(cwd);
       if (found) finish2({ kind: "moved", upstream, ...found });
-    }, intervalMs);
+    };
+    const ticker = setInterval(check2, intervalMs);
+    const controller = control && setInterval(() => {
+      if (consumeMarker(control.stop)) return finish2({ kind: "interrupted" });
+      if (consumeMarker(control.check)) check2();
+    }, CONTROL_POLL_MS);
     const deadline = timeoutMs === void 0 ? void 0 : setTimeout(
       () => finish2({ kind: "timeout", upstream, timeout }),
       timeoutMs
@@ -40601,6 +40650,18 @@ function pollForMovement(options2) {
   });
 }
 
+// src/commands/watch/watchControlPaths.ts
+function watchControlPaths(cwd) {
+  try {
+    return {
+      check: gitMarkerPath("assist-watch-check", cwd),
+      stop: gitMarkerPath("assist-watch-stop", cwd)
+    };
+  } catch {
+    return void 0;
+  }
+}
+
 // src/commands/watch/waitForUpstream.ts
 function waitForUpstream(options2) {
   const { intervalMs, timeoutMs, timeout, cwd, onStart } = options2;
@@ -40616,10 +40677,20 @@ function waitForUpstream(options2) {
   onStart?.(upstream);
   if (consumeSimulatedDivergence(cwd))
     return Promise.resolve({ kind: "simulated-divergence", upstream });
+  const control = watchControlPaths(cwd);
   fetchQuietly(cwd, intervalMs);
+  if (control && consumeMarker(control.stop))
+    return Promise.resolve({ kind: "interrupted" });
   const moved = readMovement(cwd);
   if (moved) return Promise.resolve({ kind: "moved", upstream, ...moved });
-  return pollForMovement({ upstream, intervalMs, timeoutMs, timeout, cwd });
+  return pollForMovement({
+    upstream,
+    intervalMs,
+    timeoutMs,
+    timeout,
+    cwd,
+    control
+  });
 }
 
 // src/commands/watch/watchWait.ts
@@ -42136,6 +42207,39 @@ function createRunSession(id, { runName, runArgs, cwd, meta }) {
   };
 }
 
+// src/commands/sessions/daemon/autoUpdate/autoUpdateControl.ts
+import { existsSync as existsSync86, rmSync as rmSync9, writeFileSync as writeFileSync54 } from "fs";
+var paused;
+var wake;
+function persist2(value) {
+  try {
+    if (value) writeFileSync54(daemonPaths.autoUpdatePaused, "");
+    else rmSync9(daemonPaths.autoUpdatePaused, { force: true });
+  } catch {
+  }
+}
+var autoUpdateControl = {
+  paused: () => {
+    paused ??= existsSync86(daemonPaths.autoUpdatePaused);
+    return paused;
+  },
+  setPaused: (value) => {
+    paused = value;
+    persist2(value);
+    wake?.();
+  },
+  sleep: (ms) => new Promise((resolve28) => {
+    const done2 = () => {
+      clearTimeout(timer);
+      if (wake === done2) wake = void 0;
+      resolve28();
+    };
+    const timer = setTimeout(done2, ms);
+    wake = done2;
+  }),
+  wake: () => wake?.()
+};
+
 // src/commands/sessions/daemon/autoUpdate/autoUpdateEnabled.ts
 function autoUpdateEnabled(installDir) {
   try {
@@ -42166,6 +42270,14 @@ var autoUpdateState = {
   }
 };
 
+// src/commands/sessions/daemon/autoUpdate/backOff.ts
+var RETRY_AFTER_FAILURE_MS = 5 * 60 * 1e3;
+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/holdForEscalation.ts
 var ESCALATION_POLL_MS = 5e3;
 async function holdForEscalation(sessionId, deps2) {
@@ -42186,50 +42298,47 @@ async function runLapCapturingTail(deps2) {
   return { end, tail };
 }
 
-// src/commands/sessions/daemon/autoUpdate/runAutoUpdateLoop.ts
+// src/commands/sessions/daemon/autoUpdate/settleLap.ts
 var DIVERGED_EXIT_CODE = 3;
-var RETRY_AFTER_FAILURE_MS = 5 * 60 * 1e3;
+async function settleLap(lap, { end, tail }, deps2) {
+  const how = end.signal ? `killed by ${end.signal}` : `exited ${end.code}`;
+  if (end.code === DIVERGED_EXIT_CODE) {
+    const held = deps2.escalate(tail);
+    deps2.note(`lap ${lap} ${how} (divergence); escalated to session ${held}`);
+    return held;
+  }
+  if (deps2.paused()) deps2.note(`lap ${lap} ${how}; paused`);
+  else if (decideLap(end, false).kind === "relaunch")
+    deps2.note(`lap ${lap} ${how}; relaunching`);
+  else await backOff(`lap ${lap} ${how}`, deps2);
+  return void 0;
+}
+
+// src/commands/sessions/daemon/autoUpdate/runAutoUpdateLoop.ts
+var PAUSE_POLL_MS = 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;
+    while (deps2.paused()) await deps2.sleep(PAUSE_POLL_MS);
     deps2.enter("waiting");
     deps2.note(
       `lap ${lap} at ${(/* @__PURE__ */ new Date()).toLocaleString()}: assist ${WATCH_LAP_ARGS.join(" ")}`
     );
-    let result;
     try {
-      result = await runLapCapturingTail(deps2);
+      held = await settleLap(lap, await runLapCapturingTail(deps2), 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";
+import { readFileSync as readFileSync65, writeFileSync as writeFileSync55 } from "fs";
 var KEEP_TAIL = 256 * 1024;
 var MAX_LOG_SIZE = 4 * 1024 * 1024;
 function trimWatcherLog(cwd) {
@@ -42241,20 +42350,10 @@ function trimWatcherLog(cwd) {
     return;
   }
   if (log2.length <= MAX_LOG_SIZE) return;
-  writeFileSync54(path106, log2.slice(-KEEP_TAIL));
+  writeFileSync55(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";
@@ -42424,9 +42523,30 @@ function lineRecorder(onLine) {
   };
 }
 
+// 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/autoUpdate/noteAutoUpdate.ts
+function noteAutoUpdate(installDir, text17) {
+  appendWatcherLog(installDir, watcherNote(text17));
+  daemonLog(`auto-update: ${text17}`);
+}
+
 // src/commands/sessions/daemon/autoUpdate/runUpdateLap.ts
 import { spawn as spawn11 } from "child_process";
+import { rmSync as rmSync10 } from "fs";
+function clearLapSignals(cwd) {
+  const control = watchControlPaths(cwd);
+  if (!control) return;
+  for (const path106 of [control.check, control.stop])
+    rmSync10(path106, { force: true });
+}
 function runUpdateLap(cwd, onOutput) {
+  clearLapSignals(cwd);
   return new Promise((resolve28, reject) => {
     const { ASSIST_ACTIVITY_ID: _activity, ...env } = process.env;
     const child = spawn11(
@@ -42466,10 +42586,7 @@ function loopDeps(installDir, ctx) {
       appendWatcherLog(installDir, text17);
       logLine(text17);
     },
-    note: (text17) => {
-      appendWatcherLog(installDir, watcherNote(text17));
-      daemonLog(`auto-update: ${text17}`);
-    },
+    note: (text17) => noteAutoUpdate(installDir, text17),
     enter: autoUpdateState.enter,
     liveEscalation: () => liveEscalationIn(ctx().sessions, clone)?.id,
     escalate: (output) => escalateDivergence(ctx(), installDir, output),
@@ -42477,7 +42594,8 @@ function loopDeps(installDir, ctx) {
       const status2 = ctx().sessions.get(sessionId)?.status;
       return status2 !== void 0 && status2 !== "done" && status2 !== "error";
     },
-    sleep: (ms) => sleep2(ms)
+    paused: autoUpdateControl.paused,
+    sleep: autoUpdateControl.sleep
   };
 }
 
@@ -42498,7 +42616,9 @@ function startAutoUpdate(ctx) {
     return;
   }
   trimWatcherLog(installDir);
-  daemonLog(`auto-update: pulling and building ${installDir} as origin moves`);
+  daemonLog(
+    autoUpdateControl.paused() ? `auto-update: paused for ${installDir}; resume it from the Updates page` : `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)}`
@@ -42527,11 +42647,11 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync87 } from "fs";
+import { existsSync as existsSync88 } from "fs";
 import { basename as basename30 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync86 } from "fs";
+import { existsSync as existsSync87 } from "fs";
 import { join as join103 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
@@ -42601,7 +42721,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync86(join103(worktreePath, ".git")))
+  if (!existsSync87(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";
@@ -42653,7 +42773,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync87(worktreePath)) {
+  if (!existsSync88(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -42678,7 +42798,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync87(recorded)) return recorded;
+  if (recorded && existsSync88(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -42881,12 +43001,12 @@ async function closeBlockReason(sessionId, tree) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync88, watch } from "fs";
+import { existsSync as existsSync89, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS2 = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync88(common)) return void 0;
+  if (!common || !existsSync89(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -43433,10 +43553,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync89 } from "fs";
+import { existsSync as existsSync90 } from "fs";
 import { resolve as resolve27 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync89(session.cwd))
+  if (session.cwd && !existsSync90(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -43450,7 +43570,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve27(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync89(configured)) return void 0;
+  if (existsSync90(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -43498,7 +43618,7 @@ function handleRefusedRun(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync90, mkdirSync as mkdirSync35, watch as watch2 } from "fs";
+import { existsSync as existsSync91, mkdirSync as mkdirSync35, watch as watch2 } from "fs";
 import { dirname as dirname43 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -43584,7 +43704,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read3, DEBOUNCE_MS2);
   });
-  if (existsSync90(path106)) read3();
+  if (existsSync91(path106)) read3();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -45575,7 +45695,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync93 } from "fs";
+import { existsSync as existsSync94 } from "fs";
 import { basename as basename32 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -45596,9 +45716,9 @@ function accountedTrees(sessions) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync92 } from "fs";
+import { existsSync as existsSync93 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync92(clone)) {
+  if (!existsSync93(clone)) {
     for (const { path: path106 } of paths) forgetWorktree(path106);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -45764,7 +45884,7 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
       );
       continue;
     }
-    if (!existsSync93(path106)) {
+    if (!existsSync94(path106)) {
       logVanishedTree(sessions, path106);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
@@ -46809,7 +46929,7 @@ function spawnAssistInTree(ctx, assistArgs, cwd, meta, context) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync96 } from "fs";
+import { existsSync as existsSync97 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -46840,10 +46960,10 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync95 } from "fs";
+import { existsSync as existsSync96 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync5, existsSync as existsSync94, mkdirSync as mkdirSync37 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync95, mkdirSync as mkdirSync37 } from "fs";
 import { join as join105 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
@@ -46854,7 +46974,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   const dest = join105(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync94(dest)) {
+  if (existsSync95(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -46905,7 +47025,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync95(clone))
+  if (!clone || !existsSync96(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -46914,7 +47034,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync96(cwd))
+  if (!existsSync97(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -47107,10 +47227,60 @@ function autoUpdateReply() {
     type: "auto-update",
     version: ASSIST_VERSION,
     startCommit: autoUpdateState.startCommit(),
-    loop: autoUpdateState.loop()
+    loop: { ...autoUpdateState.loop(), paused: autoUpdateControl.paused() }
   };
 }
 
+// src/commands/sessions/daemon/autoUpdate/applyAutoUpdateAction.ts
+import { rmSync as rmSync11, writeFileSync as writeFileSync56 } from "fs";
+function signalLap(installDir, marker2) {
+  const control = watchControlPaths(installDir);
+  if (control) writeFileSync56(control[marker2], "");
+}
+function applyAutoUpdateAction(action) {
+  const installDir = getInstallDir();
+  const loop2 = autoUpdateState.loop();
+  if (action === "resume") {
+    if (!autoUpdateControl.paused()) return void 0;
+    const control = watchControlPaths(installDir);
+    if (control) rmSync11(control.stop, { force: true });
+    autoUpdateControl.setPaused(false);
+    noteAutoUpdate(installDir, "resumed from Updates");
+    return void 0;
+  }
+  if (loop2.phase === "off")
+    return `auto-update is off (${loop2.reason ?? "not running"})`;
+  if (action === "pause") {
+    if (autoUpdateControl.paused()) return void 0;
+    autoUpdateControl.setPaused(true);
+    signalLap(installDir, "stop");
+    noteAutoUpdate(installDir, "paused from Updates");
+    return void 0;
+  }
+  if (autoUpdateControl.paused())
+    return "auto-update is paused; resume it first";
+  signalLap(installDir, "check");
+  autoUpdateControl.wake();
+  noteAutoUpdate(installDir, "check requested from Updates");
+  return void 0;
+}
+
+// src/commands/sessions/daemon/autoUpdate/handleAutoUpdateControl.ts
+function tryAction(action) {
+  if (!AUTO_UPDATE_ACTIONS.includes(action))
+    return `unknown auto-update action ${String(action)}`;
+  try {
+    return applyAutoUpdateAction(action);
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+var handleAutoUpdateControl = (client, _m, d) => {
+  const error = tryAction(d.action);
+  daemonLog(`auto-update-control ${String(d.action)}: ${error ?? "ok"}`);
+  sendTo(client, { type: "auto-update-control", ok: !error, error });
+};
+
 // src/commands/sessions/daemon/handleHelloRequest.ts
 var handleHelloRequest = (client, m, d) => {
   sendTo(client, buildHello());
@@ -47637,6 +47807,7 @@ var messageHandlers = {
   output: handleOutputRequest,
   nodes: (client, m) => m.links.sendNodes(client),
   "auto-update": (client) => sendTo(client, autoUpdateReply()),
+  "auto-update-control": handleAutoUpdateControl,
   "reload-links": (client, m) => {
     daemonLog("reload-links received");
     m.links.reload();
@@ -47753,7 +47924,7 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync22, writeFileSync as writeFileSync55 } from "fs";
+import { unlinkSync as unlinkSync22, writeFileSync as writeFileSync57 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
 import { readFileSync as readFileSync66 } from "fs";
@@ -47775,7 +47946,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync55(daemonPaths.pid, String(process.pid));
+  writeFileSync57(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     void manager.flushActiveMs().finally(() => {
@@ -48161,14 +48332,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: sleep3 = wait, now = Date.now } = deps2;
+  const { query = queryNodes, sleep: sleep2 = 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 sleep3(POLL_MS4);
+    await sleep2(POLL_MS4);
   }
   return void 0;
 }