@staff0rd/assist 0.775.6 → 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.775.6",
+  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);
     }
   }
 }
@@ -13009,7 +13010,7 @@ var nodesConfigHelp = [
   {
     key: "sessions.linkVersionCheck",
     setter: "assist config set sessions.linkVersionCheck block -g",
-    note: "reaction to a protocol mismatch with a linked node (app versions may differ): block (default) heals an older peer via its /api/self-update and latches if the gap remains, warn proceeds, off skips the check"
+    note: "reaction when a linked node's protocol range doesn't overlap this node's (app versions may differ; never restarts a peer): block (default) holds the link version-blocked until the older node is updated, warn proceeds, off skips the check"
   }
 ];
 
@@ -13592,11 +13593,13 @@ function harnessCapabilities(_req, res) {
 // src/commands/sessions/daemon/buildHello.ts
 var ASSIST_VERSION = package_default.version;
 var PROTOCOL_VERSION = 2;
+var MIN_PROTOCOL_VERSION = 1;
 function buildHello(extra = {}) {
   return {
     type: "hello",
     version: ASSIST_VERSION,
     protocol: PROTOCOL_VERSION,
+    minProtocol: MIN_PROTOCOL_VERSION,
     nodeName: resolveNodeName(),
     ...extra
   };
@@ -13604,15 +13607,26 @@ function buildHello(extra = {}) {
 function isHello(msg) {
   return msg.type === "hello" && typeof msg.version === "string" && (msg.protocol === void 0 || typeof msg.protocol === "number");
 }
-function helloCompatible(msg) {
-  if (typeof msg.protocol === "number") return !protocolMismatched(msg);
-  return msg.version === ASSIST_VERSION;
+function peerProtocolRange(msg) {
+  if (typeof msg.protocol !== "number") return void 0;
+  const min = typeof msg.minProtocol === "number" ? Math.min(msg.minProtocol, msg.protocol) : msg.protocol;
+  return { min, max: msg.protocol };
 }
-function helloMismatchKind(msg) {
-  return protocolMismatched(msg) ? "protocol" : "version";
+function negotiateProtocol(msg) {
+  const peer = peerProtocolRange(msg);
+  if (!peer) return void 0;
+  const common = Math.min(peer.max, PROTOCOL_VERSION);
+  return common >= Math.max(peer.min, MIN_PROTOCOL_VERSION) ? common : void 0;
 }
-function protocolMismatched(msg) {
-  return typeof msg.protocol === "number" && msg.protocol !== PROTOCOL_VERSION;
+function formatRange(range) {
+  if (!range) return "legacy (no protocol)";
+  return range.min === range.max ? `protocol ${range.max}` : `protocols ${range.min}\u2013${range.max}`;
+}
+function describeProtocolGap(node, msg) {
+  const peer = peerProtocolRange(msg);
+  const local = { min: MIN_PROTOCOL_VERSION, max: PROTOCOL_VERSION };
+  const behind = peer && peer.min > local.max ? "this node" : node;
+  return `no common protocol: ${node} ${msg.version} speaks ${formatRange(peer)}, this node ${ASSIST_VERSION} speaks ${formatRange(local)}; update ${behind} and restart it when convenient \u2014 the link reconnects once the ranges overlap`;
 }
 
 // src/commands/sessions/daemon/requestDaemonReply.ts
@@ -16194,19 +16208,17 @@ async function helloHop(spec, probes) {
       `malformed hello: ${JSON.stringify(msg)}`,
       `run \`assist update\` on ${spec.name}`
     );
-  const detail = `hello ${msg.version} (protocol ${msg.protocol ?? "legacy"})`;
-  if (helloCompatible(msg)) return passed("ws", detail);
-  const mismatch = `${helloMismatchKind(msg)} mismatch: peer ${msg.version} (protocol ${msg.protocol ?? "legacy"}), this node ${ASSIST_VERSION} (protocol ${PROTOCOL_VERSION})`;
+  const protocol = negotiateProtocol(msg);
+  if (protocol !== void 0)
+    return passed("ws", `hello ${msg.version} (protocol ${protocol})`);
+  const gap = describeProtocolGap(spec.name, msg);
   const mode = linkVersionCheck();
   if (mode !== "block")
-    return passed(
-      "ws",
-      `${mismatch}; allowed by sessions.linkVersionCheck=${mode}`
-    );
+    return passed("ws", `${gap}; allowed by sessions.linkVersionCheck=${mode}`);
   return failed(
     "ws",
-    mismatch,
-    `this node heals an older peer via its /api/self-update on connect; if the heal latched, run \`assist update\` on the older node, then \`assist daemon restart\` here`
+    gap,
+    `run \`assist update\` on the older node, then restart its daemon (\`assist daemon restart\`) when convenient`
   );
 }
 
@@ -16228,7 +16240,11 @@ function linkStateHop(spec, probes) {
   if (status2.state === "connected") return passed("link", "connected");
   const error = status2.error ?? status2.state;
   if (status2.state === "version-blocked")
-    return failed("link", error, `version mismatch \u2014 heal latched. ${error}`);
+    return failed(
+      "link",
+      error,
+      "no common protocol \u2014 update the older node and restart its daemon when convenient; the link retries every minute"
+    );
   return failed(
     "link",
     error,
@@ -17206,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 = [];
@@ -17479,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,
@@ -39995,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 {
@@ -40511,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;
@@ -40524,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;
@@ -40558,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
@@ -40586,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;
@@ -40601,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
@@ -42121,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 {
@@ -42151,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) {
@@ -42171,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) {
@@ -42226,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";
@@ -42409,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(
@@ -42451,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),
@@ -42462,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
   };
 }
 
@@ -42483,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)}`
@@ -42512,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
@@ -42586,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";
@@ -42638,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`
@@ -42663,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(
@@ -42866,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)
@@ -43418,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);
 }
@@ -43435,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`;
 }
 
@@ -43483,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
@@ -43569,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;
@@ -45560,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
@@ -45581,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`
@@ -45749,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) ?? [],
@@ -46060,18 +46195,6 @@ function guardLinkCallback(label2, callback) {
   };
 }
 
-// src/commands/sessions/daemon/links/selfUpdatePeer.ts
-var SELF_UPDATE_TIMEOUT_MS = 10 * 6e4;
-async function selfUpdatePeer(url) {
-  const response = await fetch(new URL("/api/self-update", url), {
-    method: "POST",
-    signal: AbortSignal.timeout(SELF_UPDATE_TIMEOUT_MS)
-  });
-  if (response.ok) return;
-  const body = await response.json().catch(() => ({}));
-  throw new Error(body.error ?? `self-update responded ${response.status}`);
-}
-
 // src/commands/sessions/daemon/links/linkDeps.ts
 function linkDeps(options2, callbacks) {
   return {
@@ -46089,7 +46212,6 @@ function linkDeps(options2, callbacks) {
       callbacks.onHistoryChanged
     ),
     transport: options2.transport ?? connectLinkWebSocket,
-    heal: options2.heal ?? selfUpdatePeer,
     reconnectMs: options2.reconnectMs ?? 3e3,
     blockedRetryMs: options2.blockedRetryMs ?? 6e4,
     createTimeoutMs: options2.createTimeoutMs ?? 15e3
@@ -46201,10 +46323,6 @@ function createLinkContext(spec, deps2) {
     state: "disconnected",
     disposed: false,
     connect: () => {
-    },
-    onMismatch: () => {
-    },
-    onCompatible: () => {
     }
   };
 }
@@ -46218,7 +46336,8 @@ function describeLink(ctx) {
     error: ctx.blockedMessage ?? ctx.lastError?.message,
     errorAt: ctx.lastError?.at,
     peerVersion: ctx.peer?.version,
-    peerProtocol: ctx.peer?.protocol
+    peerProtocol: ctx.peer?.protocol,
+    protocol: ctx.protocol
   };
 }
 function unavailableReason(ctx) {
@@ -46299,139 +46418,12 @@ function forwardToLink(ctx, client, data) {
     daemonLog(`link ${node} ws: forwarded ${data.type} for ${data.sessionId}`);
 }
 
-// src/commands/sessions/daemon/links/linkHealRefusal.ts
-import semver2 from "semver";
-function peerIsNewer(peerVersion) {
-  return semver2.valid(peerVersion) !== null && semver2.valid(ASSIST_VERSION) !== null && semver2.gt(peerVersion, ASSIST_VERSION);
-}
-function linkHealRefusal(node, peerVersion, healAttempted) {
-  if (peerIsNewer(peerVersion))
-    return `This node (${ASSIST_VERSION}) is older than ${node} (${peerVersion}); update this node and restart its daemon.`;
-  if (healAttempted)
-    return `${node} is still on ${peerVersion} after auto-update (this node is ${ASSIST_VERSION}); update ${node} manually; this node reconnects once it reports a compatible version.`;
-  return void 0;
-}
-
-// src/commands/sessions/daemon/links/scheduleReconnect.ts
-function armReconnect(ctx, delay2) {
-  clearTimeout(ctx.reconnectTimer);
-  ctx.reconnectTimer = setTimeout(ctx.connect, delay2);
-  ctx.reconnectTimer.unref?.();
-}
-function scheduleReconnect2(ctx) {
-  if (ctx.disposed) return;
-  if (ctx.blockedMessage) return armReconnect(ctx, ctx.deps.blockedRetryMs);
-  const delay2 = ctx.breaker.tripped() ? ctx.breaker.remainingMs() : ctx.deps.reconnectMs;
-  armReconnect(ctx, delay2);
-}
-function reconnectNow(ctx) {
-  ctx.breaker.clear();
-  armReconnect(ctx, ctx.deps.reconnectMs);
-}
-
-// src/commands/sessions/daemon/links/teardownLink.ts
-function teardownLink(ctx) {
-  const hadSessions = ctx.relay.sessions.length > 0;
-  ctx.socket = null;
-  ctx.greeted = false;
-  resetRelayState(ctx.relay, `${ctx.spec.name} connection closed`);
-  if (!ctx.blockedMessage) setLinkState(ctx, "disconnected");
-  if (hadSessions) ctx.deps.onSessionsChanged();
-}
-function disconnectLink(ctx) {
-  const socket = ctx.socket;
-  teardownLink(ctx);
-  socket?.close();
-}
-function failLink(ctx, message3) {
-  daemonLog(`link ${ctx.spec.name} ws: ${message3}`);
-  ctx.lastError = { message: message3, at: (/* @__PURE__ */ new Date()).toISOString() };
-  ctx.breaker.fail(message3);
-  setLinkState(ctx, ctx.blockedMessage ? "version-blocked" : "disconnected");
-  scheduleReconnect2(ctx);
-}
-function blockLink(ctx, message3) {
-  const repeat = ctx.blockedMessage === message3;
-  ctx.blockedMessage = message3;
-  disconnectLink(ctx);
-  setLinkState(ctx, "version-blocked");
-  if (!repeat) broadcastToViewers(ctx.relay, { type: "error", message: message3 });
-  scheduleReconnect2(ctx);
-}
-
-// src/commands/sessions/daemon/links/runLinkHeal.ts
-async function runLinkHeal(ctx, peerVersion) {
-  const node = ctx.spec.name;
-  daemonLog(
-    `link ${node} heal: peer ${peerVersion} is older than ${ASSIST_VERSION}; requesting self-update`
-  );
-  failPendingCreators(
-    ctx.relay,
-    `${node} is out of date; updating it now \u2014 retry once the update finishes.`
-  );
-  disconnectLink(ctx);
-  try {
-    await ctx.deps.heal(ctx.spec.url);
-    daemonLog(`link ${node} heal: self-update done, reconnecting`);
-  } catch (error) {
-    const message3 = error instanceof Error ? error.message : String(error);
-    daemonLog(`link ${node} heal: self-update failed: ${message3}`);
-    broadcastToViewers(ctx.relay, {
-      type: "error",
-      message: `${node} auto-update failed: ${message3}`
-    });
-  }
-  reconnectNow(ctx);
-}
-
-// src/commands/sessions/daemon/links/LinkHealer.ts
-var LinkHealer = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  healAttempted = false;
-  healing = false;
-  awaitingConfirmation = false;
-  async onMismatch(peerVersion) {
-    if (this.healing) return;
-    const node = this.ctx.spec.name;
-    const refusal = linkHealRefusal(node, peerVersion, this.healAttempted);
-    if (refusal) {
-      this.awaitingConfirmation = false;
-      if (this.ctx.blockedMessage !== refusal)
-        daemonLog(`link ${node} heal: latched, retrying slowly: ${refusal}`);
-      return blockLink(this.ctx, refusal);
-    }
-    this.healing = true;
-    this.healAttempted = true;
-    this.awaitingConfirmation = true;
-    try {
-      await runLinkHeal(this.ctx, peerVersion);
-    } finally {
-      this.healing = false;
-    }
-  }
-  reset() {
-    this.healAttempted = false;
-    this.awaitingConfirmation = false;
-  }
-  onCompatible() {
-    if (!this.awaitingConfirmation) return;
-    this.awaitingConfirmation = false;
-    const node = this.ctx.spec.name;
-    daemonLog(`link ${node} heal: post-heal handshake compatible`);
-    broadcastToViewers(this.ctx.relay, {
-      type: "notice",
-      message: `${node} is up to date.`
-    });
-  }
-};
-
 // src/commands/sessions/daemon/links/acceptPeerHello.ts
 var helloFields = /* @__PURE__ */ new Set([
   "type",
   "version",
   "protocol",
+  "minProtocol",
   "nodeName",
   "peer"
 ]);
@@ -46448,22 +46440,22 @@ function acceptPeerHello(linkName, msg) {
       reason: `peer reports nodeName ${msg.nodeName}, link expects ${linkName}`,
       peer
     };
-  if (helloCompatible(msg)) {
+  const protocol = negotiateProtocol(msg);
+  if (protocol !== void 0) {
     daemonLog(
-      `link ${linkName} ws: hello ok (${msg.version})${unrecognisedHelloFields(msg)}`
+      `link ${linkName} ws: hello ok (${msg.version}, protocol ${protocol})${unrecognisedHelloFields(msg)}`
     );
-    return { kind: "accept", peer };
+    return { kind: "accept", peer, protocol };
   }
   const mode = linkVersionCheck();
-  const detail = `${helloMismatchKind(msg)} mismatch: peer protocol ${msg.protocol ?? "legacy"} version ${msg.version} (this node protocol ${PROTOCOL_VERSION} version ${ASSIST_VERSION})`;
+  const reason4 = describeProtocolGap(linkName, msg);
   if (mode !== "block") {
     daemonLog(
-      `link ${linkName} ws: ${detail}; proceeding (sessions.linkVersionCheck=${mode})`
+      `link ${linkName} ws: ${reason4}; proceeding (sessions.linkVersionCheck=${mode})`
     );
     return { kind: "accept", peer };
   }
-  daemonLog(`link ${linkName} ws: ${detail}`);
-  return { kind: "heal", peer };
+  return { kind: "block", reason: reason4, peer };
 }
 
 // src/commands/sessions/daemon/logUnrecognisedType.ts
@@ -46566,6 +46558,55 @@ function relayLinkMessage(state, msg) {
     );
 }
 
+// src/commands/sessions/daemon/links/scheduleReconnect.ts
+function armReconnect(ctx, delay2) {
+  clearTimeout(ctx.reconnectTimer);
+  ctx.reconnectTimer = setTimeout(ctx.connect, delay2);
+  ctx.reconnectTimer.unref?.();
+}
+function scheduleReconnect2(ctx) {
+  if (ctx.disposed) return;
+  if (ctx.blockedMessage) return armReconnect(ctx, ctx.deps.blockedRetryMs);
+  const delay2 = ctx.breaker.tripped() ? ctx.breaker.remainingMs() : ctx.deps.reconnectMs;
+  armReconnect(ctx, delay2);
+}
+function reconnectNow(ctx) {
+  ctx.breaker.clear();
+  armReconnect(ctx, ctx.deps.reconnectMs);
+}
+
+// src/commands/sessions/daemon/links/teardownLink.ts
+function teardownLink(ctx) {
+  const hadSessions = ctx.relay.sessions.length > 0;
+  ctx.socket = null;
+  ctx.greeted = false;
+  ctx.protocol = void 0;
+  resetRelayState(ctx.relay, `${ctx.spec.name} connection closed`);
+  if (!ctx.blockedMessage) setLinkState(ctx, "disconnected");
+  if (hadSessions) ctx.deps.onSessionsChanged();
+}
+function disconnectLink(ctx) {
+  const socket = ctx.socket;
+  teardownLink(ctx);
+  socket?.close();
+}
+function failLink(ctx, message3) {
+  daemonLog(`link ${ctx.spec.name} ws: ${message3}`);
+  ctx.lastError = { message: message3, at: (/* @__PURE__ */ new Date()).toISOString() };
+  ctx.breaker.fail(message3);
+  setLinkState(ctx, ctx.blockedMessage ? "version-blocked" : "disconnected");
+  scheduleReconnect2(ctx);
+}
+function blockLink(ctx, message3) {
+  const repeat = ctx.blockedMessage === message3;
+  if (!repeat) daemonLog(`link ${ctx.spec.name} ws: ${message3}`);
+  ctx.blockedMessage = message3;
+  disconnectLink(ctx);
+  setLinkState(ctx, "version-blocked");
+  if (!repeat) broadcastToViewers(ctx.relay, { type: "error", message: message3 });
+  scheduleReconnect2(ctx);
+}
+
 // src/commands/sessions/daemon/links/onLinkLine.ts
 function onHello(ctx, msg) {
   const verdict = acceptPeerHello(ctx.spec.name, msg);
@@ -46577,18 +46618,18 @@ function onHello(ctx, msg) {
     disconnectLink(ctx);
     return failLink(ctx, verdict.reason);
   }
-  if (verdict.kind === "heal") return ctx.onMismatch(verdict.peer.version);
+  if (verdict.kind === "block") return blockLink(ctx, verdict.reason);
   if (ctx.blockedMessage)
     daemonLog(
-      `link ${ctx.spec.name} heal: peer now reports ${verdict.peer.version}; latch cleared`
+      `link ${ctx.spec.name} ws: peer now reports ${verdict.peer.version}; protocol block cleared`
     );
   ctx.blockedMessage = void 0;
+  ctx.protocol = verdict.protocol;
   ctx.greeted = true;
   ctx.breaker.clear();
   ctx.lastError = void 0;
   setLinkState(ctx, "connected");
   ctx.deps.onHistoryChanged();
-  ctx.onCompatible();
 }
 function onLinkLine(ctx, line) {
   let msg;
@@ -46661,21 +46702,15 @@ var NodeLink = class {
   constructor(spec, deps2) {
     this.spec = spec;
     const ctx = createLinkContext(spec, deps2);
-    const healer = new LinkHealer(ctx);
     ctx.connect = () => void openLink(ctx);
-    ctx.onMismatch = (version2) => void healer.onMismatch(version2);
-    ctx.onCompatible = () => healer.onCompatible();
     this.ctx = ctx;
-    this.healer = healer;
   }
   ctx;
-  healer;
   start = () => this.ctx.connect();
   unlatch() {
     if (!this.ctx.blockedMessage) return;
-    daemonLog(`link ${this.spec.name} heal: latch cleared by reload`);
+    daemonLog(`link ${this.spec.name} ws: protocol block cleared by reload`);
     this.ctx.blockedMessage = void 0;
-    this.healer.reset();
     setLinkState(this.ctx, "disconnected");
     reconnectNow(this.ctx);
   }
@@ -46894,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) {
@@ -46925,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);
@@ -46939,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;
   }
@@ -46990,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}`
     );
@@ -46999,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)
@@ -47192,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());
@@ -47722,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();
@@ -47838,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";
@@ -47860,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(() => {
@@ -48246,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;
 }