very-happy-cli 0.2.189 → 0.2.190

package/dist/{run-Ca8BiNCp.cjs → run-rPqQwDi_.cjs}

@@ -1,27 +1,27 @@
 'use strict';
 
-var mirrorProtocol = require('./mirrorProtocol-CiA3hO2y.cjs');
+var mirrorProtocol = require('./mirrorProtocol-GuWMxLkh.cjs');
 var fsMkdir = require('./fsMkdir-0K3yENml.cjs');
-var piRunnerArgs = require('./piRunnerArgs-BtzW_kfh.cjs');
+var piRunnerArgs = require('./piRunnerArgs-C3jZ1M6b.cjs');
 var fs = require('fs/promises');
 var os$1 = require('os');
 var tmp = require('tmp');
 var axios = require('axios');
 var node_fs = require('node:fs');
 var path = require('node:path');
-var configuration = require('./configuration-C0ctLGW2.cjs');
-var api = require('./api-BDuuyys8.cjs');
+var configuration = require('./configuration-Dt5lKW3P.cjs');
+var api = require('./api-CXL6jp-p.cjs');
 var spawnAgents = require('./spawnAgents-C1-4m7aN.cjs');
-var logger = require('./logger-BP1SW7Cs.cjs');
-var index$2 = require('./index-4TpmBb2Q.cjs');
-var auth = require('./auth-DQKSpaEf.cjs');
+var logger = require('./logger-BBRTTVsQ.cjs');
+var index$2 = require('./index-CwRW11hT.cjs');
+var auth = require('./auth-Bb_SL2os.cjs');
 var child_process = require('child_process');
-var _package = require('./package-CYDdLA6R.cjs');
-var doctor = require('./doctor-wVNvRarN.cjs');
-var spawnHappyCLI = require('./spawnHappyCLI-CxiR2Qoy.cjs');
-var persistence = require('./persistence-CrzC7yr_.cjs');
-var controlClient = require('./controlClient-F7hAEEy2.cjs');
-var sessionOps = require('./sessionOps-BzeOKIEF.cjs');
+var _package = require('./package-DrY090nZ.cjs');
+var doctor = require('./doctor-B9lW1WlG.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-CTy3p6V_.cjs');
+var persistence = require('./persistence-Bl5S3TLB.cjs');
+var controlClient = require('./controlClient-BRk65BRO.cjs');
+var sessionOps = require('./sessionOps-DeWVqpe4.cjs');
 var fastify = require('fastify');
 var z = require('zod');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
@@ -29,63 +29,63 @@ var authRelay = require('./authRelay-Dy1qU9td.cjs');
 var node_crypto = require('node:crypto');
 var previewPath = require('./previewPath-B0rBdhy1.cjs');
 var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
-var rateLimitWindows = require('./rateLimitWindows-Cs56YJCH.cjs');
-var peerTools = require('./peerTools-B4315xjX.cjs');
+var rateLimitWindows = require('./rateLimitWindows-Bx3ROBP5.cjs');
+var peerTools = require('./peerTools-5ZM4spcZ.cjs');
 var os = require('node:os');
-var remoteSessionClient = require('./remoteSessionClient-Dq8XTLQP.cjs');
-var bootstrap = require('./bootstrap-CDY-Vz8q.cjs');
-var index$1 = require('./index-De02DNu5.cjs');
+var remoteSessionClient = require('./remoteSessionClient-DGFI__5Z.cjs');
+var bootstrap = require('./bootstrap-DBJB0y-H.cjs');
+var index$1 = require('./index-Bs5FD8JF.cjs');
 var require$$0 = require('fs');
 var require$$1 = require('path');
 var node_child_process = require('node:child_process');
 var projectPath = require('./projectPath-C3ioB4Bu.cjs');
 var doctorReadiness = require('./doctorReadiness-Dl6yRQCy.cjs');
-var machineMetadata = require('./machineMetadata-BKX3ov9g.cjs');
+var machineMetadata = require('./machineMetadata-DnFNlrVK.cjs');
 var fileStore = require('./fileStore-7qhnbs6N.cjs');
 var pi = require('./pi-DlsrPCTa.cjs');
 var require$$3 = require('crypto');
 var detectCLI = require('./detectCLI-BuYR_Qxe.cjs');
-var handleResumeCommand = require('./handleResumeCommand-CMUTygsm.cjs');
+var handleResumeCommand = require('./handleResumeCommand-DXOuWr4p.cjs');
 var webPanels = require('./webPanels-FCgFKvVe.cjs');
 var index = require('./index-BOe6dKnL.cjs');
 var promises = require('node:fs/promises');
 var cliUpdate = require('./cliUpdate-DsKXPFYp.cjs');
-var client = require('./client-DIfxYk7B.cjs');
-var client$1 = require('./client-D0aYWt53.cjs');
+var client = require('./client-CMKGrnmT.cjs');
+var sessionLock = require('./sessionLock-BFBReiKq.cjs');
+var client$1 = require('./client-Bffkrs5p.cjs');
 var daemonSupervisor = require('./daemonSupervisor-alqGPANc.cjs');
 var path$1 = require('./path-B7zW-WwE.cjs');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
-var startFileWatcher = require('./startFileWatcher-C-XCZ5t2.cjs');
-var sync = require('./sync-CoChLEIg.cjs');
+var startFileWatcher = require('./startFileWatcher-BQs0cJA-.cjs');
+var sync = require('./sync-DtWB7RzA.cjs');
 var types = require('./types-CRS-srZK.cjs');
 var tmuxSocket = require('./tmuxSocket-D-Xt6Vn-.cjs');
-var sessionLock = require('./sessionLock-DSqiP2lH.cjs');
 var doctor$1 = require('./doctor-u46qYYKX.cjs');
 var resources = require('./resources-BZ_Be0qM.cjs');
 var node_util = require('node:util');
 var template = require('./template-17HATY_Y.cjs');
 var loginShellEnv = require('./loginShellEnv-BkuYtExZ.cjs');
-require('./acpSessionResume-2BTMsB7_.cjs');
-require('./lidState-B4dHJCeS.cjs');
+require('./acpSessionResume-CZao6QEd.cjs');
+require('./lidState-q_XFYg33.cjs');
 require('node:events');
 require('socket.io-client');
-require('./pushNotifications-CalIS9sq.cjs');
+require('./pushNotifications-CfspRcl-.cjs');
 require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('./limits-C-a7gr04.cjs');
-require('./time-XwEZxKGc.cjs');
-require('./registerCommonHandlers-DZPozYxc.cjs');
+require('./time-gPD_EmA-.cjs');
+require('./registerCommonHandlers-Beun-cQv.cjs');
 require('util');
 require('cross-spawn');
 require('@paralleldrive/cuid2');
 require('chalk');
 require('node:module');
 require('tweetnacl');
-require('./browser-D1yzC0Tu.cjs');
+require('./browser-CLJWcodR.cjs');
 require('open');
 require('./specialCommands-J3JFOq0J.cjs');
 require('./ids-B6ZC0HGt.cjs');
 require('url');
-require('./localHappyAgentAuth-CG2nPD_H.cjs');
+require('./localHappyAgentAuth-CKNW-MXw.cjs');
 require('./processTreeSnapshot-mDbnuojn.cjs');
 require('ps-list');
 
@@ -569,7 +569,8 @@ const WrapperIdleSnapshotSchema = z.z.object({
   backgroundTasks: z.z.number().int().nonnegative(),
   scheduledWakeups: z.z.number().int().nonnegative().optional(),
   lastActivityAt: z.z.number(),
-  exiting: z.z.boolean().optional()
+  exiting: z.z.boolean().optional(),
+  agentVersion: z.z.string().max(64).optional()
 }).passthrough();
 const HibernateCheckBodySchema = z.z.object({
   sessionId: z.z.string().min(1).max(200),
@@ -1537,6 +1538,7 @@ function summaryFromPersisted(id, persisted) {
     ...meta?.flavor ? { flavor: meta.flavor } : {},
     ...meta?.tags?.length ? { tags: [...meta.tags] } : {},
     ...meta?.variant ? { variant: meta.variant } : {},
+    ...sessionOps.lineageOf(meta),
     ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
     url: sessionOps.sessionWebUrl(id)
   };
@@ -5295,6 +5297,253 @@ async function waitForSessionLive(sessionId, live, timeoutMs = AUTOMATION_WAKE_T
   return true;
 }
 
+function createAutoRestart(deps) {
+  const now = () => (deps.now ?? Date.now)();
+  const random = deps.random ?? Math.random;
+  const statuses = /* @__PURE__ */ new Map();
+  const attempts = /* @__PURE__ */ new Map();
+  const agentVersions = /* @__PURE__ */ new Map();
+  const behindSince = /* @__PURE__ */ new Map();
+  const offline = /* @__PURE__ */ new Map();
+  const schedule = deps.schedule ?? ((fn, ms) => {
+    setTimeout(fn, ms).unref?.();
+  });
+  let inFlight = 0;
+  let lastStartedAt = null;
+  let publishedSignature = "";
+  function publish() {
+    const snapshot = Object.fromEntries([...statuses.entries()].sort(([a], [b]) => a.localeCompare(b)));
+    const signature = JSON.stringify(snapshot);
+    if (signature === publishedSignature) return;
+    publishedSignature = signature;
+    deps.publish(snapshot);
+  }
+  function setStatus(sessionId, status) {
+    if (!status) {
+      statuses.delete(sessionId);
+      return;
+    }
+    const clock = behindSince.get(sessionId);
+    const since = clock && clock.target === status.target ? clock.since : status.since;
+    behindSince.set(sessionId, { target: status.target, since });
+    statuses.set(sessionId, { ...status, since });
+  }
+  function clearSession(sessionId) {
+    statuses.delete(sessionId);
+    behindSince.delete(sessionId);
+    offline.delete(sessionId);
+  }
+  function isLive(sessionId) {
+    return deps.liveSessions().some((session) => session.sessionId === sessionId);
+  }
+  function stalenessFor(tracked, agentVersion) {
+    return sessionLock.wrapperStaleness({
+      wrapperVersion: tracked.wrapperVersion,
+      daemonVersion: deps.daemonVersion,
+      agentVersion,
+      installedAgentVersion: tracked.flavor ? deps.installedAgentVersion(tracked.flavor) : null
+    });
+  }
+  async function run(sessionId, staleness) {
+    const since = statuses.get(sessionId)?.since ?? now();
+    setStatus(sessionId, { state: "restarting", since, target: staleness.target });
+    publish();
+    deps.log?.(`[auto-restart] restarting ${sessionId}: ${staleness.kind} ${staleness.from} \u2192 ${staleness.target}`);
+    try {
+      if (deps.turnActive(sessionId) || deps.backgroundTasks(sessionId) > 0 || deps.automationRunning(sessionId)) {
+        deps.log?.(`[auto-restart] ${sessionId} became busy before the stop; waiting`);
+        setStatus(sessionId, { state: "waiting", reason: "turn-active", since, target: staleness.target });
+        return;
+      }
+      let result;
+      try {
+        result = await deps.restart(sessionId, staleness);
+      } catch (error) {
+        result = { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+      const record = sessionLock.recordAttempt(attempts.get(sessionId) ?? null, staleness.target, result.ok, now(), result.ok ? void 0 : result.error);
+      if (record) attempts.set(sessionId, record);
+      else attempts.delete(sessionId);
+      if (result.ok) {
+        deps.log?.(`[auto-restart] ${sessionId} restarted on ${staleness.target}`);
+        clearSession(sessionId);
+        agentVersions.delete(sessionId);
+      } else {
+        deps.log?.(`[auto-restart] ${sessionId} restart failed (attempt ${record?.attempts}): ${result.error}`);
+        const gaveUp = (record?.attempts ?? 0) >= sessionLock.AUTO_RESTART_MAX_ATTEMPTS;
+        if (!isLive(sessionId)) {
+          offline.set(sessionId, staleness);
+          const retryAt = gaveUp || !record ? void 0 : record.notBefore;
+          setStatus(sessionId, { state: "failed", reason: result.error, since, target: staleness.target, offline: true, ...retryAt ? { retryAt } : {} });
+          if (retryAt) schedule(() => {
+            void retryOffline(sessionId);
+          }, Math.max(0, retryAt - now()));
+        } else {
+          setStatus(sessionId, gaveUp ? { state: "failed", reason: result.error, since, target: staleness.target } : { state: "waiting", reason: "backoff", since, target: staleness.target });
+        }
+      }
+    } finally {
+      inFlight -= 1;
+      publish();
+    }
+  }
+  async function retryOffline(sessionId) {
+    const staleness = offline.get(sessionId);
+    if (!staleness || statuses.get(sessionId)?.state !== "failed" || statuses.get(sessionId)?.retryAt === void 0) return;
+    const status = statuses.get(sessionId);
+    const handOver = (why) => {
+      deps.log?.(`[auto-restart] ${sessionId} offline retry skipped: ${why}`);
+      setStatus(sessionId, { state: "failed", reason: status.reason, since: status.since, target: status.target, offline: true });
+      publish();
+    };
+    if (!deps.enabled()) return handOver("switch off");
+    if (isLive(sessionId)) {
+      offline.delete(sessionId);
+      return;
+    }
+    const server = deps.serverSession ? await deps.serverSession(sessionId).catch(() => null) : null;
+    if (!server) return handOver("server state unknown");
+    if (server.archived || server.active) return handOver(server.archived ? "archived" : "active elsewhere");
+    if (isLive(sessionId) || offline.get(sessionId) !== staleness) return;
+    const t = now();
+    if (inFlight > 0 || lastStartedAt !== null && t - lastStartedAt < sessionLock.AUTO_RESTART_MIN_GAP_MS) {
+      schedule(() => {
+        void retryOffline(sessionId);
+      }, sessionLock.AUTO_RESTART_MIN_GAP_MS + Math.round(random() * sessionLock.AUTO_RESTART_MIN_GAP_MS));
+      return;
+    }
+    inFlight += 1;
+    lastStartedAt = t;
+    setStatus(sessionId, { state: "restarting", since: status.since, target: staleness.target });
+    await run(sessionId, staleness);
+  }
+  async function onCheckIn(request) {
+    let t = now();
+    const tracked = deps.tracked(request.sessionId, request.pid);
+    if (request.report.agentVersion) agentVersions.set(request.sessionId, request.report.agentVersion);
+    const staleness = tracked ? stalenessFor(tracked, request.report.agentVersion) : null;
+    if (!staleness) {
+      const had = statuses.has(request.sessionId);
+      clearSession(request.sessionId);
+      if (had) publish();
+      return { nextCheckMs: null, restarting: false };
+    }
+    offline.delete(request.sessionId);
+    const previous = statuses.get(request.sessionId);
+    if (previous?.state === "restarting") return { nextCheckMs: null, restarting: false };
+    const attempt = attempts.get(request.sessionId) ?? null;
+    let input = {
+      enabled: deps.enabled(),
+      now: t,
+      ...deps.quietMs !== void 0 ? { quietMs: deps.quietMs } : {},
+      staleness,
+      trackedLive: !!tracked?.live,
+      report: request.report,
+      turnActive: deps.turnActive(request.sessionId),
+      backgroundTasks: deps.backgroundTasks(request.sessionId),
+      automationRunning: deps.automationRunning(request.sessionId),
+      resumable: false,
+      attempt,
+      inFlight,
+      lastStartedAt
+    };
+    let verdict = sessionLock.decideAutoRestart({ ...input, resumable: true });
+    if (verdict.ok) {
+      const resumable = await deps.resumable(request.sessionId).catch(() => false);
+      t = now();
+      input = {
+        ...input,
+        now: t,
+        trackedLive: !!deps.tracked(request.sessionId, request.pid)?.live,
+        turnActive: deps.turnActive(request.sessionId),
+        backgroundTasks: deps.backgroundTasks(request.sessionId),
+        automationRunning: deps.automationRunning(request.sessionId),
+        resumable,
+        attempt: attempts.get(request.sessionId) ?? null,
+        inFlight,
+        lastStartedAt
+      };
+      verdict = statuses.get(request.sessionId)?.state === "restarting" ? { ok: false, reason: "machine-busy" } : sessionLock.decideAutoRestart(input);
+    }
+    if (verdict.ok) {
+      inFlight += 1;
+      lastStartedAt = t;
+      setStatus(request.sessionId, { state: "restarting", since: previous?.since ?? t, target: staleness.target });
+      setImmediate(() => {
+        void run(request.sessionId, staleness);
+      });
+      return { nextCheckMs: null, restarting: true };
+    }
+    if (input.enabled) setStatus(request.sessionId, sessionLock.statusFromVerdict(verdict, previous, staleness, t, attempt));
+    else {
+      statuses.delete(request.sessionId);
+      if (behindSince.get(request.sessionId)?.target !== staleness.target) behindSince.set(request.sessionId, { target: staleness.target, since: t });
+    }
+    publish();
+    return { nextCheckMs: sessionLock.autoRestartNextCheck(verdict, input, random()), restarting: false };
+  }
+  function sweep() {
+    const t = now();
+    const enabled = deps.enabled();
+    const seen = /* @__PURE__ */ new Set();
+    for (const session of deps.liveSessions()) {
+      seen.add(session.sessionId);
+      const staleness = stalenessFor(session, agentVersions.get(session.sessionId));
+      if (!staleness) {
+        clearSession(session.sessionId);
+        continue;
+      }
+      if (statuses.get(session.sessionId)?.state === "restarting") continue;
+      if (offline.delete(session.sessionId)) statuses.delete(session.sessionId);
+      if (!enabled) {
+        statuses.delete(session.sessionId);
+        if (behindSince.get(session.sessionId)?.target !== staleness.target) behindSince.set(session.sessionId, { target: staleness.target, since: t });
+        continue;
+      }
+      const previous = statuses.get(session.sessionId);
+      if (session.startedBy === "terminal") {
+        if (previous?.state !== "manual" || previous.reason !== "local-terminal" || previous.target !== staleness.target) {
+          setStatus(session.sessionId, { state: "manual", reason: "local-terminal", since: t, target: staleness.target });
+        }
+        continue;
+      }
+      if (previous && previous.target === staleness.target) continue;
+      const reports = sessionLock.wrapperReportsIdle({
+        flavor: session.flavor,
+        capabilities: session.capabilities,
+        spawnedBy: session.spawnedBy,
+        tags: session.tags,
+        variant: session.variant
+      });
+      setStatus(session.sessionId, reports ? { state: "waiting", reason: "awaiting-check-in", since: t, target: staleness.target } : { state: "manual", reason: "no-report", since: t, target: staleness.target });
+    }
+    for (const id of /* @__PURE__ */ new Set([...statuses.keys(), ...behindSince.keys()])) {
+      if (seen.has(id) || statuses.get(id)?.state === "restarting") continue;
+      if (offline.has(id)) continue;
+      clearSession(id);
+    }
+    publish();
+  }
+  return {
+    onCheckIn,
+    sweep,
+    forget(sessionId) {
+      agentVersions.delete(sessionId);
+      const state = statuses.get(sessionId)?.state;
+      if (state === "restarting" || offline.has(sessionId)) return;
+      behindSince.delete(sessionId);
+      if (statuses.delete(sessionId)) publish();
+    },
+    statuses() {
+      return Object.fromEntries(statuses);
+    },
+    /** For tests / diagnostics. */
+    inFlight() {
+      return inFlight;
+    }
+  };
+}
+
 const CLAUDE_AUTH_PROBE_INTERVAL_MS = 10 * 60 * 1e3;
 const CLAUDE_AUTH_REFRESH_INTERVAL_MS = 30 * 60 * 1e3;
 const PROBE_TIMEOUT_MS = 8e3;
@@ -7429,6 +7678,7 @@ async function startDaemon() {
   let lastHandoverHold = null;
   let claudeCredentialStoreSetting = (await persistence.readSettings()).claudeCredentialStore === "file" ? "file" : "auto";
   let agentHibernationSetting = (await persistence.readSettings()).agentHibernationIdleMs;
+  let autoRestartSetting = (await persistence.readSettings()).autoRestartSessions !== false;
   try {
     const homes = await index$1.refreshAgentHomes();
     logger.logger.debug(`[DAEMON RUN] Claude config dir: ${loginShellEnv.describeAgentHome(homes.claudeConfigDir)}; Codex home: ${loginShellEnv.describeAgentHome(homes.codexHome)}`);
@@ -7551,6 +7801,7 @@ async function startDaemon() {
     });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
+    let autoRestart;
     let automationRunner;
     let projectPresence;
     const persisted = persistence.readPersistedSessions();
@@ -8291,6 +8542,7 @@ async function startDaemon() {
       }
     };
     const restartCounts = /* @__PURE__ */ new Map();
+    const autoRestartExits = /* @__PURE__ */ new Set();
     const stopSessionAndWait = async (happySessionId, timeoutMs = 8e3) => {
       const targets = /* @__PURE__ */ new Set();
       for (const [pid, s] of pidToTrackedSession.entries()) {
@@ -8340,7 +8592,7 @@ async function startDaemon() {
     const restartSessionImpl = async (happySessionId, options) => {
       try {
         const prior = restartCounts.get(happySessionId) ?? 0;
-        const decision = decideRestart(prior, DEFAULT_MAX_RESTARTS);
+        const decision = options?.auto ? { allowed: true } : decideRestart(prior, DEFAULT_MAX_RESTARTS);
         if (!decision.allowed) {
           return { type: "error", errorMessage: `restart:${decision.reason}` };
         }
@@ -8391,7 +8643,7 @@ async function startDaemon() {
         if (model) args.push("--model", model);
         const permissionMode = spawnAgents.sanitizeSpawnPermissionMode(options?.permissionMode ?? (options?.keepPublishedPermissionMode ? publishedRelaunchPermissionMode(metadata) : void 0));
         if (permissionMode) args.push("--permission-mode", permissionMode);
-        restartCounts.set(happySessionId, recordRestartAttempt(prior));
+        if (!options?.auto) restartCounts.set(happySessionId, recordRestartAttempt(prior));
         const teamEnv = await teamRelaunchEnvFor(happySessionId, metadata);
         const result = await spawnTrackedHappyProcess({
           args,
@@ -8412,7 +8664,8 @@ async function startDaemon() {
             HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
             HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
             HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion),
-            ...teamEnv
+            ...teamEnv,
+            ...options?.auto ? { [sessionLock.AUTO_RESTARTED_ENV]: sessionLock.encodeAutoRestarted(options.auto.kind, options.auto.target) } : {}
           }
         });
         if (result.type === "success") {
@@ -8455,10 +8708,11 @@ async function startDaemon() {
     };
     const onChildExited = (pid) => {
       const session = pidToTrackedSession.get(pid);
-      if (session?.happySessionId && (session.spawnedBy === "teams" || teamWorker?.hasSession(session.happySessionId))) teamWorker?.report(session.happySessionId, "exited");
+      if (session?.happySessionId && !autoRestartExits.has(session.happySessionId) && (session.spawnedBy === "teams" || teamWorker?.hasSession(session.happySessionId))) teamWorker?.report(session.happySessionId, "exited");
       if (session?.happySessionId && automationRunner?.hasSession(session.happySessionId)) automationRunner.report(session.happySessionId, "exited");
       if (session?.happySessionId) turnActivity.forget(session.happySessionId);
       if (session?.happySessionId) backgroundTasks.forget(session.happySessionId);
+      if (session?.happySessionId) autoRestart?.forget(session.happySessionId);
       if (session?.happySessionId) peerCoordinator.forget(session.happySessionId);
       if (session?.happySessionId && daemonHibernation.consumeExit(session.happySessionId)) {
         const persisted2 = persistence.readPersistedSessions()[session.happySessionId];
@@ -8539,6 +8793,84 @@ async function startDaemon() {
       })();
     };
     let apiMachineRef = null;
+    let latestAgentVersions = null;
+    const trackedFacts = (tracked) => {
+      const metadata = tracked.happySessionMetadataFromLocalWebhook;
+      return {
+        live: isPidAlive(tracked.pid),
+        wrapperVersion: metadata?.version ?? null,
+        flavor: metadata?.flavor ?? "claude",
+        capabilities: metadata?.capabilities ?? null,
+        spawnedBy: tracked.spawnedBy ?? null,
+        tags: metadata?.tags ?? null,
+        variant: tracked.variant ?? metadata?.variant ?? null,
+        // The wrapper's own word: tracked.startedBy turns into "persisted" /
+        // "recovered" across the very daemon restart an upgrade does.
+        startedBy: metadata?.startedBy ?? null
+      };
+    };
+    const autoRestartScheduler = createAutoRestart({
+      enabled: () => autoRestartSetting,
+      quietMs: sessionLock.resolveQuietMs(),
+      daemonVersion: _package.packageJson.version,
+      installedAgentVersion: (flavor) => flavor === "codex" ? latestAgentVersions?.agents.find((agent) => agent.id === "codex")?.installed ?? null : null,
+      tracked: (sessionId, pid) => {
+        const tracked = pidToTrackedSession.get(pid);
+        if (!tracked || tracked.happySessionId !== sessionId) return null;
+        return trackedFacts(tracked);
+      },
+      liveSessions: () => [...pidToTrackedSession.values()].filter((tracked) => tracked.happySessionId && tracked.happySessionMetadataFromLocalWebhook && isPidAlive(tracked.pid)).map((tracked) => ({ sessionId: tracked.happySessionId, ...trackedFacts(tracked) })),
+      turnActive: (sessionId) => turnActivity.activeSessions().includes(sessionId),
+      backgroundTasks: (sessionId) => backgroundTasks.count(sessionId),
+      automationRunning: (sessionId) => automationRunner?.hasSession(sessionId) === true,
+      // The local copy may predate the agent's conversation id (it is the spawn
+      // webhook's); judge the server copy, exactly as restartSessionImpl will.
+      resumable: async (sessionId) => {
+        const tracked = findTrackedSessionById(sessionId);
+        const local = tracked?.happySessionMetadataFromLocalWebhook;
+        const encryption = tracked?.encryption;
+        if (!local || !encryption) return false;
+        const { metadata } = await resolveRelaunchMetadata(
+          local,
+          () => fetchServerSessionMetadata(sessionId, encryption.encryptionKey, encryption.encryptionVariant)
+        );
+        return resumePrecheck(metadata, {
+          cwdExists: (p) => require$$0.existsSync(p),
+          conversationExists: (cwd, claudeSessionId) => index$1.locateClaudeConversation(cwd, claudeSessionId) !== null
+        }).ok;
+      },
+      restart: async (sessionId, staleness) => {
+        autoRestartExits.add(sessionId);
+        try {
+          const result = await restartSession(sessionId, { keepPublishedPermissionMode: true, auto: { kind: staleness.kind, target: staleness.target } });
+          if (result.type !== "success") return { ok: false, error: result.type === "error" ? result.errorMessage : result.type };
+          const after = findTrackedSessionById(sessionId)?.happySessionMetadataFromLocalWebhook?.version;
+          if (staleness.kind === "cli" && after && (cliUpdate.compareExactVersions(after, staleness.target) ?? 0) < 0) {
+            return { ok: false, error: `still-behind: ${after}` };
+          }
+          return { ok: true };
+        } finally {
+          autoRestartExits.delete(sessionId);
+        }
+      },
+      // Offline-failure retry guard: nobody restored, archived or resumed it meanwhile.
+      serverSession: async (sessionId) => {
+        const response = await axios.get(`${configuration.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+          headers: { Authorization: `Bearer ${credentials.token}` },
+          timeout: 1e4
+        });
+        const row = response.data.session;
+        if (!row || typeof row.active !== "boolean") return null;
+        return { active: row.active, archived: row.archivedAt != null };
+      },
+      publish: (sessions) => {
+        void apiMachineRef?.setAutoRestartSessions(sessions);
+      },
+      log: (message) => logger.logger.debug(`[DAEMON RUN] ${message}`)
+    });
+    autoRestart = autoRestartScheduler;
+    const autoRestartSweep = setInterval(() => autoRestartScheduler.sweep(), 6e4);
+    autoRestartSweep.unref?.();
     let mirrorManagerRef = null;
     const controlToken = createDaemonControlToken();
     const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
@@ -8565,7 +8897,14 @@ async function startDaemon() {
       onRateLimits: (report) => {
         apiMachineRef?.reportRateLimits(report);
       },
-      onHibernateCheck: (body) => daemonHibernation.check(body),
+      // B-852: the same idle check-in also decides an automatic restart of a
+      // stale wrapper; hibernation (exit) wins when both say yes.
+      onHibernateCheck: async (body) => {
+        const reply = await daemonHibernation.check(body);
+        if (reply.hibernate) return reply;
+        const auto = await autoRestartScheduler.onCheckIn(body);
+        return { ...reply, nextCheckMs: Math.min(reply.nextCheckMs ?? sessionLock.AUTO_RESTART_RECHECK_CAP_MS, sessionLock.AUTO_RESTART_RECHECK_CAP_MS, auto.nextCheckMs ?? Infinity) };
+      },
       listPeers: () => peerCoordinator.list(),
       // B-505: `daemon list` shows which sessions have a turn in flight, so an
       // operator can check the WHOLE machine before a supervised restart.
@@ -8717,6 +9056,13 @@ async function startDaemon() {
       daemonHibernation.invalidateBindings();
       return persistence.resolveIdleMs(agentHibernationSetting);
     });
+    apiMachine.setAutoRestartHandlers(autoRestartSetting, async (enabled) => {
+      await persistence.updateSettings((current) => ({ ...current, autoRestartSessions: enabled }));
+      autoRestartSetting = enabled;
+      autoRestartScheduler.sweep();
+      return autoRestartSetting;
+    });
+    setTimeout(() => autoRestartScheduler.sweep(), 5e3).unref?.();
     const webPanelsSync = startWebPanelsSync({
       statMtime: async () => (await fs.stat(configuration.configuration.settingsFile).catch(() => null))?.mtimeMs ?? null,
       readRaw: async () => (await persistence.readSettings()).webPanels,
@@ -8807,7 +9153,10 @@ async function startDaemon() {
       if (delay !== null) logger.logger.warn(`[DAEMON RUN] CLI update policy announced; re-checking in ${Math.round(delay / 1e3)}s`);
     });
     const stopAgentVersionChecks = mirrorProtocol.startAgentVersionChecks(
-      (snapshot) => apiMachine.updateDaemonState((state) => ({ ...state, status: state?.status ?? "running", agentVersions: snapshot })),
+      (snapshot) => {
+        latestAgentVersions = snapshot;
+        return apiMachine.updateDaemonState((state) => ({ ...state, status: state?.status ?? "running", agentVersions: snapshot }));
+      },
       (error) => logger.logger.debug("[DAEMON RUN] Agent version check failed", error)
     );
     harnessInstaller = createHarnessInstaller({
@@ -8989,6 +9338,7 @@ async function startDaemon() {
         logger.logger.debug("[DAEMON RUN] Health check interval cleared");
       }
       clearInterval(cliUpdateInterval);
+      clearInterval(autoRestartSweep);
       policyAnnouncements.stop();
       stopAgentVersionChecks();
       await apiMachine.updateDaemonState((state) => ({