@staff0rd/assist 0.760.0 → 0.761.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.760.0",
+  version: "0.761.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -15735,6 +15735,9 @@ async function restartWeb(req, res, deps2 = {}) {
     respondJson(res, 400, { error: "Invalid target" });
     return;
   }
+  console.log(
+    `restart ${target} from=${req.headers["x-assist-linked-from"] ?? "local"} trace=${req.headers[TRACE_HEADER] ?? "none"}`
+  );
   await new Promise((resolve26) => {
     res.once("finish", resolve26);
     respondJson(res, 200, { ok: true });
@@ -15937,6 +15940,350 @@ function newSessionDefaults(req, res) {
   respondJson(res, 200, { mode });
 }
 
+// src/commands/sessions/nodes/fetchPeerJson.ts
+var PEER_TIMEOUT_MS = 3e3;
+function peerErrorCode(error) {
+  if (!(error instanceof Error)) return void 0;
+  const { code, cause } = error;
+  if (code) return code;
+  if (error.name === "TimeoutError") return "ETIMEDOUT";
+  return cause instanceof Error ? peerErrorCode(cause) : void 0;
+}
+function describePeerError(error) {
+  if (!(error instanceof Error)) return String(error);
+  const cause = error.cause;
+  return cause instanceof Error ? `${error.message}: ${describePeerError(cause)}` : error.message;
+}
+async function fetchPeerJson(baseUrl, path106, timeoutMs = PEER_TIMEOUT_MS) {
+  const res = await fetch(new URL(path106, baseUrl), {
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok)
+    throw Object.assign(
+      new Error(`GET ${path106} returned ${res.status} ${res.statusText}`),
+      { status: res.status }
+    );
+  return await res.json();
+}
+
+// src/commands/sessions/daemon/links/connectLinkWebSocket.ts
+import WebSocket from "ws";
+var HANDSHAKE_TIMEOUT_MS = 5e3;
+function linkWebSocketUrl(url) {
+  const target = new URL("/ws", url);
+  target.protocol = target.protocol === "https:" ? "wss:" : "ws:";
+  return target.toString();
+}
+function connectLinkWebSocket(url, handlers) {
+  return new Promise((resolve26, reject) => {
+    const ws = new WebSocket(linkWebSocketUrl(url), {
+      handshakeTimeout: HANDSHAKE_TIMEOUT_MS
+    });
+    let open = false;
+    ws.on("open", () => {
+      open = true;
+      resolve26({
+        send: (line) => {
+          if (ws.readyState !== WebSocket.OPEN) return false;
+          ws.send(line);
+          return true;
+        },
+        close: () => ws.close()
+      });
+    });
+    ws.on("message", (data) => handlers.onLine(data.toString()));
+    ws.on("error", (error) => {
+      if (!open) reject(error);
+    });
+    ws.on("close", (code, reason4) => {
+      const detail = `code ${code}${reason4.length ? ` ${reason4.toString()}` : ""}`;
+      if (open) handlers.onClose(detail);
+      else reject(new Error(`closed before open (${detail})`));
+    });
+  });
+}
+
+// src/commands/sessions/nodes/probePeerHello.ts
+var HELLO_TIMEOUT_MS = 5e3;
+async function probePeerHello(url) {
+  let settle = () => {
+  };
+  const reply2 = new Promise((resolve26) => {
+    settle = resolve26;
+  });
+  const socket = await connectLinkWebSocket(url, {
+    onLine: (line) => {
+      try {
+        const msg = JSON.parse(line);
+        if (msg.type === "hello") settle(msg);
+      } catch {
+      }
+    },
+    onClose: (reason4) => settle(new Error(`closed before hello reply (${reason4})`))
+  });
+  const timer = setTimeout(
+    () => settle(new Error(`no hello reply within ${HELLO_TIMEOUT_MS / 1e3}s`)),
+    HELLO_TIMEOUT_MS
+  );
+  socket.send(JSON.stringify(buildHello()));
+  const result = await reply2;
+  clearTimeout(timer);
+  socket.close();
+  if (result instanceof Error) throw result;
+  return result;
+}
+
+// src/commands/sessions/nodes/buildDoctorProbes.ts
+function buildDoctorProbes(live) {
+  return {
+    health: (url) => fetchPeerJson(url, "/api/health"),
+    hello: probePeerHello,
+    tailscale: tailscaleStatus,
+    linkState: (name) => {
+      if (!live) return "no-daemon";
+      return live.links.find((l) => l.name === name) ?? "unknown-link";
+    }
+  };
+}
+
+// src/commands/sessions/daemon/links/linkVersionCheck.ts
+function linkVersionCheck() {
+  return loadConfig().sessions?.linkVersionCheck ?? "block";
+}
+
+// src/commands/sessions/nodes/DoctorProbes.ts
+function passed(hop, detail) {
+  return { hop, ok: true, detail };
+}
+function failed(hop, error, remediation) {
+  return { hop, ok: false, error, remediation };
+}
+
+// src/commands/sessions/nodes/helloHop.ts
+async function helloHop(spec, probes) {
+  let msg;
+  try {
+    msg = await probes.hello(spec.url);
+  } catch (error) {
+    return failed(
+      "ws",
+      describePeerError(error),
+      `${spec.name}'s /api/health answers but its /ws does not \u2014 restart the web server on ${spec.name}, then check \`assist sessions nodes logs ${spec.name}\``
+    );
+  }
+  if (!isHello(msg))
+    return failed(
+      "ws",
+      `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 mode = linkVersionCheck();
+  if (mode !== "block")
+    return passed(
+      "ws",
+      `${mismatch}; 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`
+  );
+}
+
+// src/commands/sessions/nodes/linkStateHop.ts
+function linkStateHop(spec, probes) {
+  const status2 = probes.linkState(spec.name);
+  if (status2 === "no-daemon")
+    return failed(
+      "link",
+      "this node's daemon is not running",
+      "links run in the daemon \u2014 start this node's web server or run `assist daemon restart`"
+    );
+  if (status2 === "unknown-link")
+    return failed(
+      "link",
+      `this node's daemon has no link named ${spec.name}`,
+      "the daemon has not loaded sessions.links \u2014 run `assist daemon restart`"
+    );
+  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,
+    `every probe passed but the daemon's link is ${status2.state}; it retries behind the circuit breaker \u2014 check this node's daemon.log for \`link ${spec.name} ws:\` lines`
+  );
+}
+
+// src/commands/sessions/nodes/findTailscalePeer.ts
+function findTailscalePeer(status2, hostname2) {
+  const nodes = [
+    ...status2.Self ? [{ ...status2.Self, Online: true }] : [],
+    ...Object.values(status2.Peer ?? {})
+  ];
+  return nodes.find(
+    (node) => node.DNSName?.replace(/\.$/, "").toLowerCase() === hostname2
+  );
+}
+
+// src/commands/sessions/nodes/tailscaleHop.ts
+async function tailscaleHop(spec, probes) {
+  const cli = tailscaleCli();
+  let status2;
+  try {
+    status2 = await probes.tailscale();
+  } catch (error) {
+    return failed(
+      "tailscale",
+      describePeerError(error),
+      `\`${cli} status --json\` failed \u2014 install Tailscale on this node and sign in with \`${cli} up\``
+    );
+  }
+  if (status2.BackendState !== "Running")
+    return failed(
+      "tailscale",
+      `Tailscale on this node is ${status2.BackendState ?? "not running"}`,
+      `run \`${cli} up\` on this node`
+    );
+  const { hostname: hostname2 } = new URL(spec.url);
+  const peer = findTailscalePeer(status2, hostname2);
+  if (!peer)
+    return failed(
+      "tailscale",
+      `${hostname2} is not in this node's tailnet`,
+      `check the host in \`${cli} status\`, then relink with \`assist sessions nodes link ${spec.name} --tailscale <host> --port <port>\``
+    );
+  if (!peer.Online)
+    return failed(
+      "tailscale",
+      `${hostname2} is offline in the tailnet`,
+      `is ${spec.name}'s machine awake with Tailscale running and signed in?`
+    );
+  return passed(
+    "tailscale",
+    `${hostname2} online${peer.TailscaleIPs?.[0] ? ` (${peer.TailscaleIPs[0]})` : ""}`
+  );
+}
+
+// src/commands/sessions/nodes/tailscaleServeRemediation.ts
+function tailscaleServeRemediation(spec, error) {
+  const status2 = error.status;
+  if (status2 !== void 0 && status2 !== 502) return void 0;
+  const { hostname: hostname2, port } = new URL(spec.url);
+  const servePort = port || "443";
+  return status2 === 502 ? `tailscale serve on ${hostname2} answered but nothing listens on 127.0.0.1:${servePort} behind it \u2014 is ${spec.name}'s web server running (project-switch webservers)?` : `nothing serves https on ${servePort} on ${hostname2} \u2014 ${spec.name}'s web server runs tailscale serve when it starts: check the \`tailscale serve:\` line in its log (project-switch "View logs") and that sessions.tailscaleServe is not false there`;
+}
+
+// src/commands/sessions/nodes/isTailscaleLink.ts
+function isTailscaleLink(spec) {
+  return new URL(spec.url).hostname.endsWith(".ts.net");
+}
+
+// src/commands/sessions/nodes/webHop.ts
+function webRemediation(spec, error) {
+  const serve = isTailscaleLink(spec) ? tailscaleServeRemediation(spec, error) : void 0;
+  if (serve) return serve;
+  const { hostname: hostname2, port } = new URL(spec.url);
+  switch (peerErrorCode(error)) {
+    case "ECONNREFUSED":
+      return `nothing listening on ${port} on ${hostname2} \u2014 is ${spec.name}'s web server running (project-switch webservers)?`;
+    case "ETIMEDOUT":
+      return `${hostname2}:${port} did not answer \u2014 is ${spec.name} up and the port reachable from here?`;
+    case "ENOTFOUND":
+      return `cannot resolve ${hostname2} \u2014 fix the url with \`assist sessions nodes link ${spec.name} <url>\``;
+  }
+  if (error.status === 404)
+    return `${spec.name}'s web server has no /api/health \u2014 run \`assist update\` on ${spec.name}`;
+  return `check the link url ${spec.url} with \`assist sessions nodes\``;
+}
+async function webHop(spec, probes) {
+  let health2;
+  try {
+    health2 = await probes.health(spec.url);
+  } catch (error) {
+    return {
+      hop: failed("web", describePeerError(error), webRemediation(spec, error))
+    };
+  }
+  if (health2.nodeName !== spec.name)
+    return {
+      hop: failed(
+        "web",
+        `peer reports nodeName ${health2.nodeName}, link expects ${spec.name}`,
+        `relink with \`assist sessions nodes unlink ${spec.name}\` then \`assist sessions nodes link ${health2.nodeName} ${spec.url}\`, or set sessions.nodeName on the peer`
+      )
+    };
+  return {
+    hop: passed(
+      "web",
+      `${health2.nodeName} ${health2.version} (protocol ${health2.protocol})`
+    ),
+    health: health2
+  };
+}
+
+// src/commands/sessions/nodes/peerDaemonHop.ts
+function peerDaemonHop(spec, health2) {
+  if (health2.daemon?.reachable) return passed("daemon", "reachable");
+  return failed(
+    "daemon",
+    `${spec.name}'s web server reports its daemon unreachable`,
+    `run \`assist daemon status\` on ${spec.name}; restarting its web server starts the daemon`
+  );
+}
+
+// src/commands/sessions/nodes/diagnoseLink.ts
+async function diagnoseLink(spec, probes) {
+  const hops = [];
+  const done2 = () => ({ ...spec, ok: hops.every((h) => h.ok), hops });
+  if (isTailscaleLink(spec)) {
+    hops.push(await tailscaleHop(spec, probes));
+    if (!hops.at(-1)?.ok) return done2();
+  }
+  const web3 = await webHop(spec, probes);
+  hops.push(web3.hop);
+  if (!web3.health) return done2();
+  hops.push(peerDaemonHop(spec, web3.health));
+  if (!hops.at(-1)?.ok) return done2();
+  hops.push(await helloHop(spec, probes));
+  if (!hops.at(-1)?.ok) return done2();
+  hops.push(linkStateHop(spec, probes));
+  return done2();
+}
+
+// src/commands/sessions/nodes/firstBrokenHop.ts
+async function firstBrokenHop(name) {
+  const spec = findLinkSpec(name);
+  if (!spec)
+    return {
+      hop: "link",
+      ok: false,
+      error: `no link named ${name}`,
+      remediation: "see `assist sessions nodes`"
+    };
+  const diagnosis = await diagnoseLink(
+    spec,
+    buildDoctorProbes(await queryNodes())
+  );
+  return diagnosis.hops.find((hop) => !hop.ok);
+}
+
+// src/commands/sessions/web/nodeDoctor.ts
+async function nodeDoctor(req, res) {
+  const link3 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+    "link"
+  );
+  if (!link3) {
+    respondJson(res, 400, { error: "Missing link" });
+    return;
+  }
+  respondJson(res, 200, { hop: await firstBrokenHop(link3) ?? null });
+}
+
 // src/commands/sessions/shared/sessionViewDefaults.ts
 var sessionViewDefaults = {
   floatWaiting: true,
@@ -16840,6 +17187,7 @@ var routes2 = {
   "POST /api/pr-preview/upload-image": uploadPrImage,
   "GET /api/pr-preview/image": previewImage,
   "POST /api/restart": restartWeb,
+  "GET /api/node-doctor": nodeDoctor,
   "POST /api/self-update": selfUpdate,
   "GET /api/github-url": githubUrl,
   "GET /api/git-status": gitStatus,
@@ -25305,6 +25653,7 @@ var persistedSessionSchema = z9.object({
   activity: activitySchema.optional(),
   starred: z9.boolean().optional(),
   watcher: z9.boolean().optional(),
+  divergenceEscalation: z9.boolean().optional(),
   design: z9.boolean().optional(),
   auto: z9.boolean().optional(),
   autoRun: z9.boolean().optional(),
@@ -25338,6 +25687,7 @@ function toPersistedSession(session) {
     activity: session.activity,
     starred: session.starred,
     watcher: session.watcher,
+    divergenceEscalation: session.divergenceEscalation,
     design: session.design,
     auto: session.auto,
     autoRun: session.autoRun,
@@ -35647,7 +35997,7 @@ function skipReason(results, failures, strict) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-function failed(results) {
+function failed2(results) {
   return results.filter((r) => r.exitCode !== 0);
 }
 async function runAndSynthesise(args) {
@@ -35664,7 +36014,7 @@ async function runAndSynthesise(args) {
       models: args.models
     }
   );
-  const failures = failed(results);
+  const failures = failed2(results);
   const reason4 = skipReason(results, failures, args.strict);
   if (reason4) {
     console.error(reason4);
@@ -39548,11 +39898,19 @@ function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
 
 // src/commands/run/runPreCommands.ts
 import { execSync as execSync66 } from "child_process";
-function runPreCommands(pre, cwd) {
+function writeCapturedOutput(error) {
+  for (const stream of ["stdout", "stderr"]) {
+    const output = error[stream];
+    if (output) process.stdout.write(output);
+  }
+}
+function runPreCommands(pre, cwd, quiet) {
   for (const cmd of pre) {
     try {
-      execSync66(cmd, { stdio: "inherit", cwd });
+      execSync66(cmd, { stdio: quiet ? "pipe" : "inherit", cwd });
     } catch (error) {
+      if (quiet && error && typeof error === "object")
+        writeCapturedOutput(error);
       const code = error && typeof error === "object" && "status" in error ? error.status : 1;
       process.exit(code);
     }
@@ -39578,14 +39936,14 @@ async function runWatchBuild(entry) {
     if (!(error instanceof MissingRunCwdError)) throw error;
     return { kind: "failed", exitCode: 1, output: error.message };
   }
-  if (config.pre) runPreCommands(config.pre, cwd);
+  if (config.pre) runPreCommands(config.pre, cwd, true);
   return toBuildOutcome(
     await runCommandToCompletion(
       config.command,
       [...config.args ?? [], ...resolveParams(config.params, [])],
       config.env,
       cwd,
-      config.quiet
+      true
     )
   );
 }
@@ -39605,7 +39963,13 @@ async function reportBuildOrExit(entry) {
 // src/commands/watch/runPostBuildSync.ts
 async function runPostBuildSync() {
   return toBuildOutcome(
-    await runCommandToCompletion("assist", ["sync", "--yes"])
+    await runCommandToCompletion(
+      "assist",
+      ["sync", "--yes"],
+      void 0,
+      void 0,
+      true
+    )
   );
 }
 
@@ -40652,7 +41016,8 @@ function toSessionInfo(session) {
     pendingPrPreview,
     undurable,
     lastUserMessage,
-    activeViewer
+    activeViewer,
+    activeViewerNode
   } = session;
   return {
     ...toSessionRunInfo(session),
@@ -40679,6 +41044,7 @@ function toSessionInfo(session) {
     undurable,
     lastUserMessage,
     activeViewer,
+    activeViewerNode,
     joinable: joinRefusal(session) === void 0
   };
 }
@@ -40697,11 +41063,29 @@ function broadcastSessions(sessions, clients, linkedSessions = [], active) {
   broadcast(peers, { type: "sessions", sessions: local, active: {} });
 }
 
+// src/commands/sessions/daemon/releaseViewer.ts
+function releaseViewer(sessions, viewerId) {
+  let released = false;
+  for (const s of sessions.values()) {
+    if (s.activeViewer !== viewerId) continue;
+    daemonLog(
+      `session ${s.id} active viewer ${viewerId} on ${s.activeViewerNode ?? "unknown node"} left`
+    );
+    s.activeViewer = void 0;
+    s.activeViewerNode = void 0;
+    released = true;
+  }
+  return released;
+}
+
 // src/commands/sessions/daemon/claimViewer.ts
-function claimViewer(session, { viewerId, onClaim }, via) {
+function claimViewer(session, { viewerId, viewerNode, onClaim }, via) {
   if (!viewerId || session.activeViewer === viewerId) return;
   session.activeViewer = viewerId;
-  daemonLog(`session ${session.id} active viewer ${viewerId} (${via})`);
+  session.activeViewerNode = viewerNode;
+  daemonLog(
+    `session ${session.id} active viewer ${viewerId} on ${viewerNode ?? "unknown node"} (${via})`
+  );
   onClaim?.();
 }
 
@@ -40743,6 +41127,29 @@ function resizePty(s, cols, rows) {
   }
 }
 
+// src/commands/sessions/daemon/ViewerConnections.ts
+var ViewerConnections = class {
+  byClient = /* @__PURE__ */ new Map();
+  track(client, viewerId) {
+    const ids = this.byClient.get(client) ?? /* @__PURE__ */ new Set();
+    ids.add(viewerId);
+    this.byClient.set(client, ids);
+  }
+  releaseUnheld(client, viewerId) {
+    const ids = this.byClient.get(client);
+    if (!ids) return [];
+    const dropped = viewerId === void 0 ? [...ids] : [viewerId];
+    for (const id of dropped) ids.delete(id);
+    if (ids.size === 0) this.byClient.delete(client);
+    return dropped.filter((id) => !this.isHeld(id));
+  }
+  isHeld(viewerId) {
+    for (const ids of this.byClient.values())
+      if (ids.has(viewerId)) return true;
+    return false;
+  }
+};
+
 // src/commands/sessions/daemon/watchPromptSubmit.ts
 var CARRIAGE_RETURN = "\r";
 function isPromptSubmit(data) {
@@ -40793,14 +41200,29 @@ function setAutoAdvance(sessions, id, enabled) {
 
 // src/commands/sessions/daemon/SessionIo.ts
 var SessionIo = class {
-  constructor(sessions, onStatusChange, notify2) {
+  constructor(sessions, onStatusChange, notify2, links2) {
     this.sessions = sessions;
     this.onStatusChange = onStatusChange;
     this.notify = notify2;
+    this.links = links2;
+  }
+  viewers = new ViewerConnections();
+  trackViewer(client, d) {
+    if (typeof d.viewerId !== "string") return;
+    this.viewers.track(client, d.viewerId);
+    d.viewerNode ??= this.links.localNode();
   }
-  write(id, data, viewerId) {
+  viewerLeft(client, viewerId) {
+    let released = false;
+    for (const id of this.viewers.releaseUnheld(client, viewerId)) {
+      released = releaseViewer(this.sessions, id) || released;
+      this.links.viewerLeft(client, id);
+    }
+    if (released) this.notify();
+  }
+  write(id, data, viewer) {
     writeToSession(this.sessions, id, data, this.onStatusChange(), {
-      viewerId,
+      ...viewer,
       onClaim: this.notify
     });
   }
@@ -43246,6 +43668,7 @@ 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);
@@ -43253,6 +43676,8 @@ 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);
   const autoRun = shouldAutoRun(session);
   if (autoRun.run) {
     deps2.reuseForRun(session, autoRun.itemId);
@@ -43269,19 +43694,18 @@ function finishStatusChange(session, status2, exitCode, deps2) {
 }
 
 // src/commands/sessions/daemon/applyStatusChange.ts
-function applyStatusChange(session, status2, exitCode, dismiss, notify2, reuseForRun, sharedWithOtherAgents = () => false) {
+function applyStatusChange(session, status2, exitCode, deps2, sharedWithOtherAgents = () => false) {
   if (session.status === status2) return;
-  const deps2 = { dismiss, notify: notify2, reuseForRun };
   if (endsStreamLife(session, status2, sharedWithOtherAgents)) {
     session.closing = true;
     daemonLog(
       `session ${session.id} closing: checking durability of ${session.worktree?.path} before reap`
     );
-    notify2();
+    deps2.notify();
     void resolveCloseDurability(
       session,
       () => finishStatusChange(session, "done", exitCode, deps2),
-      notify2
+      deps2.notify
     );
     return;
   }
@@ -43289,18 +43713,378 @@ function applyStatusChange(session, status2, exitCode, dismiss, notify2, reuseFo
 }
 
 // src/commands/sessions/daemon/makeStatusChangeHandler.ts
-function makeStatusChangeHandler(sessions, dismiss, notify2, reuseForRun) {
+function makeStatusChangeHandler(sessions, deps2) {
   return (s, status2, exitCode) => applyStatusChange(
     s,
     status2,
     exitCode,
-    dismiss,
-    notify2,
-    reuseForRun,
+    deps2,
     (session) => otherTreeHolders(sessions, session).length > 0
   );
 }
 
+// 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 });
+  if (alloc)
+    bindNewWorktree(
+      session,
+      alloc,
+      tree?.notify ?? (() => {
+      }),
+      tree?.startHeld
+    );
+  else wirePtyEvents(session, clients, onStatusChange);
+}
+
+// src/commands/sessions/daemon/resetCardForRun.ts
+function resetCardForRun(session, assistArgs) {
+  session.pty?.kill();
+  session.gitWatcher?.close();
+  session.gitWatcher = void 0;
+  session.undurable = void 0;
+  session.assistArgs = assistArgs;
+  session.name = `assist ${assistArgs.join(" ")}`;
+  session.commandType = "assist";
+  session.activity = void 0;
+  removeActivity(session.id);
+  session.scrollback = "";
+  session.startedAt = Date.now();
+  session.runningMs = 0;
+  session.runningSince = null;
+  session.usageSeeded = false;
+  setStatus2(session, "running");
+  session.restored = void 0;
+  session.launchedFrom = void 0;
+}
+
+// src/commands/sessions/daemon/refuseSpawn.ts
+function refuseSpawn(session, error, clients, onStatusChange, stage = "respawned") {
+  const reason4 = error instanceof Error ? error.message : String(error);
+  session.pty = null;
+  session.pendingStart = void 0;
+  session.error = reason4;
+  daemonLog(
+    `session ${session.id} ("${session.name}") not ${stage}: ${reason4}`
+  );
+  broadcast(clients, { type: "clear", sessionId: session.id });
+  emitSessionOutput(
+    session,
+    clients,
+    `\r
+\x1B[31mCannot start this session: ${reason4}\x1B[0m\r
+`
+  );
+  onStatusChange(session, "error");
+}
+
+// src/commands/sessions/daemon/startReusedRunPty.ts
+function startReusedRunPty(session, assistArgs, itemId2, hold, clients, onStatusChange) {
+  try {
+    Object.assign(
+      session,
+      startOrHoldPty(
+        () => spawnPty(["assist", ...assistArgs], session.cwd, session.id),
+        hold
+      )
+    );
+  } catch (error) {
+    refuseSpawn(
+      session,
+      error,
+      clients,
+      onStatusChange,
+      `reused for backlog run ${itemId2}`
+    );
+    return false;
+  }
+  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/createWatcherSession.ts
+var WATCHER_ARGS = ["watch", "loop"];
+function createWatcherSession(id, cwd) {
+  return {
+    ...createAssistSession(id, WATCHER_ARGS, cwd),
+    watcher: true
+  };
+}
+
+// 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) {
+  const [command, subcommand, ...rest] = args;
+  if (command !== "backlog" || subcommand !== "run") return false;
+  return rest.some((arg) => ITEM_ID.test(arg));
+}
+
+// src/commands/sessions/daemon/worktree/isPrCheckoutArgs.ts
+var CHECKOUT_COMMANDS = /* @__PURE__ */ new Set([
+  "review",
+  "review-pr-comments",
+  "fix-conflict"
+]);
+function isPrCheckoutArgs(args) {
+  const [command, ...rest] = args;
+  if (!command || !CHECKOUT_COMMANDS.has(command)) return false;
+  return rest.some((arg) => /^[1-9]\d*$/.test(arg));
+}
+
+// src/commands/sessions/daemon/worktree/isCommittingArgs.ts
+function isCommittingArgs(args) {
+  return isPrCheckoutArgs(args) || isBacklogRunArgs(args);
+}
+
+// src/commands/sessions/daemon/worktree/planReuseTree.ts
+function planReuseTree(session, ctx, options2 = {}) {
+  if (!ctx || !session.cwd || session.worktree) return void 0;
+  const alloc = allocateTree(
+    session.cwd,
+    boundTreeRoots(ctx.sessions, session),
+    options2
+  );
+  if (alloc.kind !== "worktree" || !alloc.cwd) return void 0;
+  daemonLog(
+    `session ${session.id} moved from ${session.cwd} to ${alloc.cwd} for its chained run`
+  );
+  return alloc;
+}
+
+// src/commands/sessions/daemon/failChainedRun.ts
+function failChainedRun(session, itemId2, error, clients, tree) {
+  const reason4 = error instanceof Error ? error.message : String(error);
+  session.pty = null;
+  session.error = `backlog run ${itemId2} could not start: ${reason4}`;
+  setStatus2(session, "error");
+  daemonLog(
+    `session ${session.id} not reused for backlog run ${itemId2}: workspace allocation failed: ${reason4}`
+  );
+  broadcast(clients, { type: "clear", sessionId: session.id });
+  emitSessionOutput(
+    session,
+    clients,
+    `\r
+\x1B[31m${session.error}\x1B[0m\r
+`
+  );
+  tree?.notify();
+}
+
+// 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 {
+    alloc = planReuseTree(session, tree, {
+      commits: isCommittingArgs(assistArgs),
+      backlogRun: true
+    });
+  } catch (error) {
+    failChainedRun(session, itemId2, error, clients, tree);
+    return;
+  }
+  if (alloc) session.cwd = alloc.cwd;
+  const started = startReusedRunPty(
+    session,
+    assistArgs,
+    itemId2,
+    alloc !== void 0,
+    clients,
+    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/worktree/divergencePrompt.ts
+var MAX_REASON_LINES = 20;
+var MAX_REASON_CHARS = 2e3;
+function divergencePrompt(clone, scrollback) {
+  const reason4 = 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);
+  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)",
+    "```",
+    "",
+    "Diagnose why the local branch has diverged from its upstream and report what you find and the options for reconciling it. Do not force-push, `git reset`, or otherwise discard commits on either side \u2014 leave the decision to the user."
+  ].join("\n");
+}
+
+// src/commands/sessions/daemon/worktree/escalateDivergence.ts
+var ENDED = ["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 && !ENDED.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) => escalateDivergence(treeCtx(), watcher)
+  });
+  return handler;
+}
+
 // src/commands/sessions/daemon/applySetStatus.ts
 function applySetStatus(sessions, id, status2, source, onStatusChange, rebind) {
   const session = sessions.get(id);
@@ -43350,26 +44134,6 @@ function setStatusFromHook(sessions, report2, notify2, onStatusChange) {
   );
 }
 
-// src/commands/sessions/daemon/refuseSpawn.ts
-function refuseSpawn(session, error, clients, onStatusChange, stage = "respawned") {
-  const reason4 = error instanceof Error ? error.message : String(error);
-  session.pty = null;
-  session.pendingStart = void 0;
-  session.error = reason4;
-  daemonLog(
-    `session ${session.id} ("${session.name}") not ${stage}: ${reason4}`
-  );
-  broadcast(clients, { type: "clear", sessionId: session.id });
-  emitSessionOutput(
-    session,
-    clients,
-    `\r
-\x1B[31mCannot start this session: ${reason4}\x1B[0m\r
-`
-  );
-  onStatusChange(session, "error");
-}
-
 // src/commands/sessions/daemon/respawnSession.ts
 function respawnSession(session, respawn, status2, clients, onStatusChange) {
   session.gitWatcher?.close();
@@ -43566,6 +44330,13 @@ function restartManagedSession(sessions, id, clients, onStatusChange) {
   return { ok: true };
 }
 
+// src/commands/sessions/daemon/restartAndNotify.ts
+function restartAndNotify(sessions, id, clients, onStatusChange, notify2) {
+  const result = restartManagedSession(sessions, id, clients, onStatusChange);
+  if (result.ok) notify2();
+  return result;
+}
+
 // src/commands/sessions/daemon/releaseClient.ts
 function releaseClient(client, clients, prPreview, verify) {
   clients.delete(client);
@@ -43602,6 +44373,7 @@ function restoreBase(id, persisted) {
     initialPrompt: persisted.initialPrompt,
     starred: persisted.watcher ? false : persisted.starred,
     watcher: persisted.watcher,
+    divergenceEscalation: persisted.divergenceEscalation,
     design: persisted.design,
     auto: persisted.auto,
     autoRun: persisted.autoRun,
@@ -43990,6 +44762,25 @@ 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) {
@@ -44015,7 +44806,8 @@ function relaunchConsoleWatcher(id, persisted, base) {
 }
 
 // src/commands/sessions/daemon/restoreSession.ts
-function restoreSession(id, persisted) {
+function restoreSession(id, stored) {
+  const persisted = migrateClaudeWatcher(id, stored);
   const base = restoreBase(id, persisted);
   if (persisted.status === "stopped") return stoppedSession(base, persisted);
   if (isUpdate(persisted)) return updatedSession(id, persisted);
@@ -44136,40 +44928,6 @@ function accountedTrees(sessions) {
   return accounted;
 }
 
-// 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/reclaimVanishedWorktrees.ts
 import { existsSync as existsSync91 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
@@ -44453,257 +45211,6 @@ function runRetry(sessions, id, replace, deps2) {
   return null;
 }
 
-// src/commands/sessions/daemon/attachReusedRun.ts
-function attachReusedRun(session, alloc, clients, onStatusChange, tree) {
-  broadcast(clients, { type: "clear", sessionId: session.id });
-  if (alloc)
-    bindNewWorktree(
-      session,
-      alloc,
-      tree?.notify ?? (() => {
-      }),
-      tree?.startHeld
-    );
-  else wirePtyEvents(session, clients, onStatusChange);
-}
-
-// src/commands/sessions/daemon/resetCardForRun.ts
-function resetCardForRun(session, assistArgs) {
-  session.pty?.kill();
-  session.gitWatcher?.close();
-  session.gitWatcher = void 0;
-  session.undurable = void 0;
-  session.assistArgs = assistArgs;
-  session.name = `assist ${assistArgs.join(" ")}`;
-  session.commandType = "assist";
-  session.activity = void 0;
-  removeActivity(session.id);
-  session.scrollback = "";
-  session.startedAt = Date.now();
-  session.runningMs = 0;
-  session.runningSince = null;
-  session.usageSeeded = false;
-  setStatus2(session, "running");
-  session.restored = void 0;
-  session.launchedFrom = void 0;
-}
-
-// src/commands/sessions/daemon/startReusedRunPty.ts
-function startReusedRunPty(session, assistArgs, itemId2, hold, clients, onStatusChange) {
-  try {
-    Object.assign(
-      session,
-      startOrHoldPty(
-        () => spawnPty(["assist", ...assistArgs], session.cwd, session.id),
-        hold
-      )
-    );
-  } catch (error) {
-    refuseSpawn(
-      session,
-      error,
-      clients,
-      onStatusChange,
-      `reused for backlog run ${itemId2}`
-    );
-    return false;
-  }
-  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/createWatcherSession.ts
-var WATCHER_ARGS = ["watch", "loop"];
-function createWatcherSession(id, cwd) {
-  return {
-    ...createAssistSession(id, WATCHER_ARGS, cwd),
-    watcher: true
-  };
-}
-
-// 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) {
-  const [command, subcommand, ...rest] = args;
-  if (command !== "backlog" || subcommand !== "run") return false;
-  return rest.some((arg) => ITEM_ID.test(arg));
-}
-
-// src/commands/sessions/daemon/worktree/isPrCheckoutArgs.ts
-var CHECKOUT_COMMANDS = /* @__PURE__ */ new Set([
-  "review",
-  "review-pr-comments",
-  "fix-conflict"
-]);
-function isPrCheckoutArgs(args) {
-  const [command, ...rest] = args;
-  if (!command || !CHECKOUT_COMMANDS.has(command)) return false;
-  return rest.some((arg) => /^[1-9]\d*$/.test(arg));
-}
-
-// src/commands/sessions/daemon/worktree/isCommittingArgs.ts
-function isCommittingArgs(args) {
-  return isPrCheckoutArgs(args) || isBacklogRunArgs(args);
-}
-
-// src/commands/sessions/daemon/worktree/planReuseTree.ts
-function planReuseTree(session, ctx, options2 = {}) {
-  if (!ctx || !session.cwd || session.worktree) return void 0;
-  const alloc = allocateTree(
-    session.cwd,
-    boundTreeRoots(ctx.sessions, session),
-    options2
-  );
-  if (alloc.kind !== "worktree" || !alloc.cwd) return void 0;
-  daemonLog(
-    `session ${session.id} moved from ${session.cwd} to ${alloc.cwd} for its chained run`
-  );
-  return alloc;
-}
-
-// src/commands/sessions/daemon/failChainedRun.ts
-function failChainedRun(session, itemId2, error, clients, tree) {
-  const reason4 = error instanceof Error ? error.message : String(error);
-  session.pty = null;
-  session.error = `backlog run ${itemId2} could not start: ${reason4}`;
-  setStatus2(session, "error");
-  daemonLog(
-    `session ${session.id} not reused for backlog run ${itemId2}: workspace allocation failed: ${reason4}`
-  );
-  broadcast(clients, { type: "clear", sessionId: session.id });
-  emitSessionOutput(
-    session,
-    clients,
-    `\r
-\x1B[31m${session.error}\x1B[0m\r
-`
-  );
-  tree?.notify();
-}
-
-// 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 {
-    alloc = planReuseTree(session, tree, {
-      commits: isCommittingArgs(assistArgs),
-      backlogRun: true
-    });
-  } catch (error) {
-    failChainedRun(session, itemId2, error, clients, tree);
-    return;
-  }
-  if (alloc) session.cwd = alloc.cwd;
-  const started = startReusedRunPty(
-    session,
-    assistArgs,
-    itemId2,
-    alloc !== void 0,
-    clients,
-    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/setSessionTitle.ts
 function setSessionTitle(sessions, id, title) {
   const normalised = singleLineTitle(title);
@@ -44888,43 +45395,6 @@ async function collectHistory(linked) {
   return withRepoGroups(local).concat(remote);
 }
 
-// src/commands/sessions/daemon/links/connectLinkWebSocket.ts
-import WebSocket from "ws";
-var HANDSHAKE_TIMEOUT_MS = 5e3;
-function linkWebSocketUrl(url) {
-  const target = new URL("/ws", url);
-  target.protocol = target.protocol === "https:" ? "wss:" : "ws:";
-  return target.toString();
-}
-function connectLinkWebSocket(url, handlers) {
-  return new Promise((resolve26, reject) => {
-    const ws = new WebSocket(linkWebSocketUrl(url), {
-      handshakeTimeout: HANDSHAKE_TIMEOUT_MS
-    });
-    let open = false;
-    ws.on("open", () => {
-      open = true;
-      resolve26({
-        send: (line) => {
-          if (ws.readyState !== WebSocket.OPEN) return false;
-          ws.send(line);
-          return true;
-        },
-        close: () => ws.close()
-      });
-    });
-    ws.on("message", (data) => handlers.onLine(data.toString()));
-    ws.on("error", (error) => {
-      if (!open) reject(error);
-    });
-    ws.on("close", (code, reason4) => {
-      const detail = `code ${code}${reason4.length ? ` ${reason4.toString()}` : ""}`;
-      if (open) handlers.onClose(detail);
-      else reject(new Error(`closed before open (${detail})`));
-    });
-  });
-}
-
 // src/commands/sessions/daemon/links/guardLinkCallback.ts
 function guardLinkCallback(label2, callback) {
   return (...args) => {
@@ -45304,11 +45774,6 @@ var LinkHealer = class {
   }
 };
 
-// src/commands/sessions/daemon/links/linkVersionCheck.ts
-function linkVersionCheck() {
-  return loadConfig().sessions?.linkVersionCheck ?? "block";
-}
-
 // src/commands/sessions/daemon/links/acceptPeerHello.ts
 function acceptPeerHello(linkName, msg) {
   if (!isHello(msg)) return { kind: "reject", reason: "malformed hello" };
@@ -45535,6 +46000,11 @@ var NodeLink = class {
   route(client, data) {
     forwardToLink(this.ctx, client, data);
   }
+  viewerLeft(viewerId) {
+    if (!this.ctx.greeted) return;
+    if (sendToLink(this.ctx, { type: "viewer-left", viewerId }))
+      daemonLog(`link ${this.spec.name} ws: viewer ${viewerId} left`);
+  }
   replayScrollback(client) {
     replayLinkScrollback(this.ctx.relay, client);
   }
@@ -45627,6 +46097,10 @@ var NodeLinks = class {
     if (this.clients.isPeer(client)) return false;
     return routeToLink(this.links, this.localNode(), client, data);
   }
+  viewerLeft(client, viewerId) {
+    if (this.clients.isPeer(client)) return;
+    for (const link3 of this.all()) link3.viewerLeft(viewerId);
+  }
   dispose() {
     for (const link3 of this.all()) link3.dispose();
     this.links.clear();
@@ -45852,6 +46326,7 @@ var SessionManager = class {
   }
   replayLocal = (client) => replayScrollback(this.sessions, client);
   removeClient(client) {
+    this.io.viewerLeft(client);
     releaseClient(client, this.clients, this.prPreview, this.verify);
     this.onIdleChange?.(this.isIdle());
   }
@@ -45904,22 +46379,18 @@ var SessionManager = class {
   resume(sessionId, cwd, name, harness) {
     return resumeInTree(this.treeCtx(), sessionId, cwd, name, harness);
   }
-  onStatusChange = makeStatusChangeHandler(
+  onStatusChange = managerStatusChangeHandler(
     this.sessions,
+    this.clients,
     (id) => this.dismissSession(id),
     () => this.notify(),
-    (session, itemId2) => reuseSessionForRun(
-      session,
-      itemId2,
-      this.clients,
-      this.onStatusChange,
-      this.treeCtx()
-    )
+    () => this.treeCtx()
   );
   io = new SessionIo(
     this.sessions,
     () => this.onStatusChange,
-    () => this.notify()
+    () => this.notify(),
+    this.links
   );
   retrySession(id, replace = false) {
     return runRetry(this.sessions, id, replace, {
@@ -45930,14 +46401,13 @@ var SessionManager = class {
     });
   }
   restart(id) {
-    const result = restartManagedSession(
+    return restartAndNotify(
       this.sessions,
       id,
       this.clients,
-      this.onStatusChange
+      this.onStatusChange,
+      this.notify
     );
-    if (result.ok) this.notify();
-    return result;
   }
   dismissSession = (id) => {
     dismissSessionGated(this.sessions, id, this.notify);
@@ -46416,6 +46886,38 @@ var lifecycleHandlers = {
   shutdown: handleShutdown
 };
 
+// src/commands/sessions/daemon/viewed.ts
+function viewed(handler) {
+  return (client, m, d) => {
+    m.io.trackViewer(client, d);
+    handler(client, m, d);
+  };
+}
+
+// src/commands/sessions/daemon/viewerHandlers.ts
+var viewerOf = (d) => ({
+  viewerId: d.viewerId,
+  viewerNode: d.viewerNode
+});
+var viewerHandlers = {
+  input: viewed(
+    routed(
+      (_client, m, d) => m.io.write(d.sessionId, d.data, viewerOf(d))
+    )
+  ),
+  resize: viewed(
+    routed(
+      (_client, m, d) => m.io.resize(d.sessionId, d.cols, d.rows, {
+        ...viewerOf(d),
+        claim: d.claim === true
+      })
+    )
+  ),
+  "viewer-left": (client, m, d) => {
+    if (typeof d.viewerId === "string") m.io.viewerLeft(client, d.viewerId);
+  }
+};
+
 // src/commands/sessions/daemon/setSessionCwd.ts
 function setSessionCwd(sessions, id, cwd) {
   const s = sessions.get(id);
@@ -46537,19 +47039,7 @@ var messageHandlers = {
     d.usedPct
   ),
   "codex-usage": handleCodexUsage,
-  input: routed(
-    (_client, m, d) => m.io.write(
-      d.sessionId,
-      d.data,
-      d.viewerId
-    )
-  ),
-  resize: routed(
-    (_client, m, d) => m.io.resize(d.sessionId, d.cols, d.rows, {
-      viewerId: d.viewerId,
-      claim: d.claim === true
-    })
-  ),
+  ...viewerHandlers,
   retry: routed((client, m, d) => {
     const conflict = m.retrySession(d.sessionId, d.replace === true);
     if (conflict)
@@ -46788,236 +47278,6 @@ async function closeSession() {
   }
 }
 
-// src/commands/sessions/nodes/DoctorProbes.ts
-function passed(hop, detail) {
-  return { hop, ok: true, detail };
-}
-function failed2(hop, error, remediation) {
-  return { hop, ok: false, error, remediation };
-}
-
-// src/commands/sessions/nodes/fetchPeerJson.ts
-var PEER_TIMEOUT_MS = 3e3;
-function peerErrorCode(error) {
-  if (!(error instanceof Error)) return void 0;
-  const { code, cause } = error;
-  if (code) return code;
-  if (error.name === "TimeoutError") return "ETIMEDOUT";
-  return cause instanceof Error ? peerErrorCode(cause) : void 0;
-}
-function describePeerError(error) {
-  if (!(error instanceof Error)) return String(error);
-  const cause = error.cause;
-  return cause instanceof Error ? `${error.message}: ${describePeerError(cause)}` : error.message;
-}
-async function fetchPeerJson(baseUrl, path106, timeoutMs = PEER_TIMEOUT_MS) {
-  const res = await fetch(new URL(path106, baseUrl), {
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!res.ok)
-    throw Object.assign(
-      new Error(`GET ${path106} returned ${res.status} ${res.statusText}`),
-      { status: res.status }
-    );
-  return await res.json();
-}
-
-// src/commands/sessions/nodes/helloHop.ts
-async function helloHop(spec, probes) {
-  let msg;
-  try {
-    msg = await probes.hello(spec.url);
-  } catch (error) {
-    return failed2(
-      "ws",
-      describePeerError(error),
-      `${spec.name}'s /api/health answers but its /ws does not \u2014 restart the web server on ${spec.name}, then check \`assist sessions nodes logs ${spec.name}\``
-    );
-  }
-  if (!isHello(msg))
-    return failed2(
-      "ws",
-      `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 mode = linkVersionCheck();
-  if (mode !== "block")
-    return passed(
-      "ws",
-      `${mismatch}; allowed by sessions.linkVersionCheck=${mode}`
-    );
-  return failed2(
-    "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`
-  );
-}
-
-// src/commands/sessions/nodes/linkStateHop.ts
-function linkStateHop(spec, probes) {
-  const status2 = probes.linkState(spec.name);
-  if (status2 === "no-daemon")
-    return failed2(
-      "link",
-      "this node's daemon is not running",
-      "links run in the daemon \u2014 start this node's web server or run `assist daemon restart`"
-    );
-  if (status2 === "unknown-link")
-    return failed2(
-      "link",
-      `this node's daemon has no link named ${spec.name}`,
-      "the daemon has not loaded sessions.links \u2014 run `assist daemon restart`"
-    );
-  if (status2.state === "connected") return passed("link", "connected");
-  const error = status2.error ?? status2.state;
-  if (status2.state === "version-blocked")
-    return failed2("link", error, `version mismatch \u2014 heal latched. ${error}`);
-  return failed2(
-    "link",
-    error,
-    `every probe passed but the daemon's link is ${status2.state}; it retries behind the circuit breaker \u2014 check this node's daemon.log for \`link ${spec.name} ws:\` lines`
-  );
-}
-
-// src/commands/sessions/nodes/findTailscalePeer.ts
-function findTailscalePeer(status2, hostname2) {
-  const nodes = [
-    ...status2.Self ? [{ ...status2.Self, Online: true }] : [],
-    ...Object.values(status2.Peer ?? {})
-  ];
-  return nodes.find(
-    (node) => node.DNSName?.replace(/\.$/, "").toLowerCase() === hostname2
-  );
-}
-
-// src/commands/sessions/nodes/tailscaleHop.ts
-async function tailscaleHop(spec, probes) {
-  const cli = tailscaleCli();
-  let status2;
-  try {
-    status2 = await probes.tailscale();
-  } catch (error) {
-    return failed2(
-      "tailscale",
-      describePeerError(error),
-      `\`${cli} status --json\` failed \u2014 install Tailscale on this node and sign in with \`${cli} up\``
-    );
-  }
-  if (status2.BackendState !== "Running")
-    return failed2(
-      "tailscale",
-      `Tailscale on this node is ${status2.BackendState ?? "not running"}`,
-      `run \`${cli} up\` on this node`
-    );
-  const { hostname: hostname2 } = new URL(spec.url);
-  const peer = findTailscalePeer(status2, hostname2);
-  if (!peer)
-    return failed2(
-      "tailscale",
-      `${hostname2} is not in this node's tailnet`,
-      `check the host in \`${cli} status\`, then relink with \`assist sessions nodes link ${spec.name} --tailscale <host> --port <port>\``
-    );
-  if (!peer.Online)
-    return failed2(
-      "tailscale",
-      `${hostname2} is offline in the tailnet`,
-      `is ${spec.name}'s machine awake with Tailscale running and signed in?`
-    );
-  return passed(
-    "tailscale",
-    `${hostname2} online${peer.TailscaleIPs?.[0] ? ` (${peer.TailscaleIPs[0]})` : ""}`
-  );
-}
-
-// src/commands/sessions/nodes/tailscaleServeRemediation.ts
-function tailscaleServeRemediation(spec, error) {
-  const status2 = error.status;
-  if (status2 !== void 0 && status2 !== 502) return void 0;
-  const { hostname: hostname2, port } = new URL(spec.url);
-  const servePort = port || "443";
-  return status2 === 502 ? `tailscale serve on ${hostname2} answered but nothing listens on 127.0.0.1:${servePort} behind it \u2014 is ${spec.name}'s web server running (project-switch webservers)?` : `nothing serves https on ${servePort} on ${hostname2} \u2014 ${spec.name}'s web server runs tailscale serve when it starts: check the \`tailscale serve:\` line in its log (project-switch "View logs") and that sessions.tailscaleServe is not false there`;
-}
-
-// src/commands/sessions/nodes/isTailscaleLink.ts
-function isTailscaleLink(spec) {
-  return new URL(spec.url).hostname.endsWith(".ts.net");
-}
-
-// src/commands/sessions/nodes/webHop.ts
-function webRemediation(spec, error) {
-  const serve = isTailscaleLink(spec) ? tailscaleServeRemediation(spec, error) : void 0;
-  if (serve) return serve;
-  const { hostname: hostname2, port } = new URL(spec.url);
-  switch (peerErrorCode(error)) {
-    case "ECONNREFUSED":
-      return `nothing listening on ${port} on ${hostname2} \u2014 is ${spec.name}'s web server running (project-switch webservers)?`;
-    case "ETIMEDOUT":
-      return `${hostname2}:${port} did not answer \u2014 is ${spec.name} up and the port reachable from here?`;
-    case "ENOTFOUND":
-      return `cannot resolve ${hostname2} \u2014 fix the url with \`assist sessions nodes link ${spec.name} <url>\``;
-  }
-  if (error.status === 404)
-    return `${spec.name}'s web server has no /api/health \u2014 run \`assist update\` on ${spec.name}`;
-  return `check the link url ${spec.url} with \`assist sessions nodes\``;
-}
-async function webHop(spec, probes) {
-  let health2;
-  try {
-    health2 = await probes.health(spec.url);
-  } catch (error) {
-    return {
-      hop: failed2("web", describePeerError(error), webRemediation(spec, error))
-    };
-  }
-  if (health2.nodeName !== spec.name)
-    return {
-      hop: failed2(
-        "web",
-        `peer reports nodeName ${health2.nodeName}, link expects ${spec.name}`,
-        `relink with \`assist sessions nodes unlink ${spec.name}\` then \`assist sessions nodes link ${health2.nodeName} ${spec.url}\`, or set sessions.nodeName on the peer`
-      )
-    };
-  return {
-    hop: passed(
-      "web",
-      `${health2.nodeName} ${health2.version} (protocol ${health2.protocol})`
-    ),
-    health: health2
-  };
-}
-
-// src/commands/sessions/nodes/peerDaemonHop.ts
-function peerDaemonHop(spec, health2) {
-  if (health2.daemon?.reachable) return passed("daemon", "reachable");
-  return failed2(
-    "daemon",
-    `${spec.name}'s web server reports its daemon unreachable`,
-    `run \`assist daemon status\` on ${spec.name}; restarting its web server starts the daemon`
-  );
-}
-
-// src/commands/sessions/nodes/diagnoseLink.ts
-async function diagnoseLink(spec, probes) {
-  const hops = [];
-  const done2 = () => ({ ...spec, ok: hops.every((h) => h.ok), hops });
-  if (isTailscaleLink(spec)) {
-    hops.push(await tailscaleHop(spec, probes));
-    if (!hops.at(-1)?.ok) return done2();
-  }
-  const web3 = await webHop(spec, probes);
-  hops.push(web3.hop);
-  if (!web3.health) return done2();
-  hops.push(peerDaemonHop(spec, web3.health));
-  if (!hops.at(-1)?.ok) return done2();
-  hops.push(await helloHop(spec, probes));
-  if (!hops.at(-1)?.ok) return done2();
-  hops.push(linkStateHop(spec, probes));
-  return done2();
-}
-
 // src/commands/sessions/nodes/findUnlinkedWindowsNode.ts
 var WINDOWS_NODE_URL = "http://127.0.0.1:3101";
 async function findUnlinkedWindowsNode(health2, platform = detectPlatform()) {
@@ -47035,36 +47295,6 @@ async function findUnlinkedWindowsNode(health2, platform = detectPlatform()) {
   }
 }
 
-// src/commands/sessions/nodes/probePeerHello.ts
-var HELLO_TIMEOUT_MS = 5e3;
-async function probePeerHello(url) {
-  let settle = () => {
-  };
-  const reply2 = new Promise((resolve26) => {
-    settle = resolve26;
-  });
-  const socket = await connectLinkWebSocket(url, {
-    onLine: (line) => {
-      try {
-        const msg = JSON.parse(line);
-        if (msg.type === "hello") settle(msg);
-      } catch {
-      }
-    },
-    onClose: (reason4) => settle(new Error(`closed before hello reply (${reason4})`))
-  });
-  const timer = setTimeout(
-    () => settle(new Error(`no hello reply within ${HELLO_TIMEOUT_MS / 1e3}s`)),
-    HELLO_TIMEOUT_MS
-  );
-  socket.send(JSON.stringify(buildHello()));
-  const result = await reply2;
-  clearTimeout(timer);
-  socket.close();
-  if (result instanceof Error) throw result;
-  return result;
-}
-
 // src/commands/sessions/nodes/printReport.ts
 import chalk254 from "chalk";
 function printReport(report2) {
@@ -47089,22 +47319,11 @@ function printDiagnosis(diagnosis) {
 }
 
 // src/commands/sessions/nodes/doctorNodes.ts
-function doctorProbes(live) {
-  return {
-    health: (url) => fetchPeerJson(url, "/api/health"),
-    hello: probePeerHello,
-    tailscale: tailscaleStatus,
-    linkState: (name) => {
-      if (!live) return "no-daemon";
-      return live.links.find((l) => l.name === name) ?? "unknown-link";
-    }
-  };
-}
 async function doctorNodes(name, options2) {
   const specs = loadLinkSpecs().filter((spec) => !name || spec.name === name);
   if (name && specs.length === 0)
     throw new Error(`No link named ${name}; see assist sessions nodes`);
-  const probes = doctorProbes(await queryNodes());
+  const probes = buildDoctorProbes(await queryNodes());
   const report2 = { local: resolveNodeName(), links: [] };
   for (const spec of specs) report2.links.push(await diagnoseLink(spec, probes));
   if (specs.length === 0)