very-happy-cli 0.2.189 → 0.2.191

package/dist/{run-DSfNcR62.mjs → run-Bt0AklUU.mjs}

@@ -1,25 +1,25 @@
-import { i as isClaudeSessionId, g as extractCompleteLines, h as decideBackfill, j as parseTerminalHookPayload, k as decideMirrorBinding, M as MIRROR_BACKFILL_LINES_DEFAULT, m as mirrorLineKey, n as mirrorLocalId, o as initializeOwnedWorktree, e as summarizeSpawnSessionForLog, q as startAgentVersionChecks, W as WORKTREE_CAPABILITY_VERSION, t as currentWorktreeService } from './mirrorProtocol-D2vTWteS.mjs';
+import { i as isClaudeSessionId, g as extractCompleteLines, h as decideBackfill, j as parseTerminalHookPayload, k as decideMirrorBinding, M as MIRROR_BACKFILL_LINES_DEFAULT, m as mirrorLineKey, n as mirrorLocalId, o as initializeOwnedWorktree, e as summarizeSpawnSessionForLog, q as startAgentVersionChecks, W as WORKTREE_CAPABILITY_VERSION, t as currentWorktreeService } from './mirrorProtocol-Lcx20Oby.mjs';
 import { F as FS_MKDIR_CAPABILITY_VERSION } from './fsMkdir-DumgLTzR.mjs';
-import { P as PI_ADAPTER_INSTALL_HINT, s as sanitizeSpawnModel } from './piRunnerArgs-DRuxMlX1.mjs';
+import { P as PI_ADAPTER_INSTALL_HINT, s as sanitizeSpawnModel } from './piRunnerArgs-Bqmu16He.mjs';
 import fs from 'fs/promises';
 import os from 'os';
 import * as tmp from 'tmp';
 import axios from 'axios';
 import { readFileSync, openSync, fsyncSync, closeSync, renameSync, existsSync, readdirSync, statSync, unlinkSync, realpathSync, promises, constants as constants$1, writeFileSync, mkdirSync, accessSync, readSync, rmdirSync } from 'node:fs';
 import { join, isAbsolute, resolve, dirname, sep, basename, relative } from 'node:path';
-import { f as ensurePrivateDirectorySync, w as writePrivateFileSync, c as configuration } from './configuration-1FabKklB.mjs';
-import { T as TurnActivityTracker, A as ApiClient } from './api-B0yN68XH.mjs';
-import { S as SPAWN_AGENTS, i as isSpawnAgent, s as sanitizeSpawnPermissionMode, r as resolveSpawnPermissionMode, a as resolveFirstMessageMeta, j as joinProject } from './spawnAgents-Bh1RPShN.mjs';
-import { l as logger } from './logger-DOKH3Zbh.mjs';
-import { p as pruneStaleCompileCaches } from './index-CKd20r1W.mjs';
-import { a as authAndSetupMachineIfNeeded } from './auth-CyrVvWHF.mjs';
+import { f as ensurePrivateDirectorySync, w as writePrivateFileSync, c as configuration } from './configuration-ECqXu34R.mjs';
+import { T as TurnActivityTracker, A as ApiClient } from './api-jfeMRg5R.mjs';
+import { S as SPAWN_AGENTS, i as isSpawnAgent, s as sanitizeSpawnPermissionMode, r as resolveSpawnPermissionMode, a as resolveFirstMessageMeta, j as joinProject } from './spawnAgents-CjoU6ZOS.mjs';
+import { l as logger } from './logger-GcbI0eg2.mjs';
+import { p as pruneStaleCompileCaches } from './index-BjZnpGWX.mjs';
+import { a as authAndSetupMachineIfNeeded } from './auth-DC6rg8lJ.mjs';
 import { spawn, execSync } from 'child_process';
-import { p as packageJson } from './package-DTcaIhjW.mjs';
-import { a as globalPrefixForPackage, N as NPM_SAFE_ARG, g as getEnvironmentInfo } from './doctor-D16hySse.mjs';
-import { s as spawnHappyCLI } from './spawnHappyCLI-CEsXwz5V.mjs';
-import { c as readPersistedSessions, r as readSettings, l as latchKeepAwake, q as reportSignature, s as decideDaemonHibernation, t as nextCheckDelay, v as persistSession, d as readDaemonState, x as acquireDaemonLock, a as resolveCheckMs, y as resolveIdleMs, z as deletePersistedSessions, A as writeDaemonState, B as writeSettings, C as settingIdleMs, u as updateSettings, D as rewriteCredentialsForRelay, g as readCredentials, E as releaseDaemonLock } from './persistence-0INrP3aB.mjs';
-import { i as isDaemonRunningCurrentlyInstalledHappyVersion, s as stopDaemon, u as cleanupDaemonState } from './controlClient-DwNnNAUx.mjs';
-import { e as sendUserMessage, f as readSessionMetadata, r as readSessionTranscript, l as listAccountSessions, a as listSessions, M as MAX_READ_LIMIT, s as sessionWebUrl, g as waitForSessionKey, d as archiveSession, j as analyzeLatestTurn, k as readSessionLog, m as TURN_WINDOW, n as userPromptText } from './sessionOps-CljctDs5.mjs';
+import { p as packageJson } from './package-BsUHyqWe.mjs';
+import { a as globalPrefixForPackage, N as NPM_SAFE_ARG, g as getEnvironmentInfo } from './doctor-lsxmAK4o.mjs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-CIA9Sc_5.mjs';
+import { c as readPersistedSessions, r as readSettings, l as latchKeepAwake, s as reportSignature, t as decideDaemonHibernation, v as nextCheckDelay, x as persistSession, d as readDaemonState, y as acquireDaemonLock, a as resolveCheckMs, z as resolveIdleMs, A as deletePersistedSessions, B as writeDaemonState, C as writeSettings, D as settingIdleMs, u as updateSettings, E as rewriteCredentialsForRelay, g as readCredentials, F as releaseDaemonLock } from './persistence-Cpw4yJs8.mjs';
+import { i as isDaemonRunningCurrentlyInstalledHappyVersion, s as stopDaemon, u as cleanupDaemonState } from './controlClient-ClI7A0qE.mjs';
+import { e as sendUserMessage, f as readSessionMetadata, r as readSessionTranscript, l as listAccountSessions, a as listSessions, M as MAX_READ_LIMIT, s as sessionWebUrl, j as lineageOf, g as waitForSessionKey, d as archiveSession, k as analyzeLatestTurn, m as readSessionLog, n as TURN_WINDOW, p as userPromptText } from './sessionOps-DPw5k8vV.mjs';
 import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
@@ -27,63 +27,63 @@ import { d as decodeBase64, s as sameRelay, e as encodeBase64, h as decrypt } fr
 import { randomBytes, createHash, timingSafeEqual, randomUUID } from 'node:crypto';
 import { c as checkPreviewPath } from './previewPath-CXN4Vag0.mjs';
 import { a as BACKGROUND_TASKS_MAX, d as BACKGROUND_TASK_DESCRIPTION_MAX, e as BackgroundTaskTracker } from './backgroundTaskActivity-8PdPxrvy.mjs';
-import { b as sanitizeRateLimitReport } from './rateLimitWindows-5vIuNjko.mjs';
-import { f as formatEditConflictNotice, b as SESSION_PEER_SENT_FROM, s as sendPeerMessage, l as listPeerSessions, C as CLI_PEER_SENDER_ID } from './peerTools-BtrUnSwz.mjs';
+import { b as sanitizeRateLimitReport } from './rateLimitWindows-j_qQk0KY.mjs';
+import { f as formatEditConflictNotice, b as SESSION_PEER_SENT_FROM, s as sendPeerMessage, l as listPeerSessions, C as CLI_PEER_SENDER_ID } from './peerTools-CwCe6tmJ.mjs';
 import os$1, { hostname, homedir, tmpdir } from 'node:os';
-import { c as RemoteCallBudget, e as REMOTE_WRITE_CALLS_PER_MINUTE, d as deliverToSession, g as guardRemoteSessionOpsRequest, h as remoteError, i as REMOTE_OP_DEADLINE_MS, j as formatRemoteAuditLine, k as REMOTE_SEND_COMMIT_DEADLINE_MS, m as REMOTE_RESUME_WAIT_MS, n as capRemoteTranscript, o as capRemoteText, p as REMOTE_ANSWER_MAX_BYTES, q as REMOTE_TITLE_MAX_BYTES } from './remoteSessionClient-Vfj_5g2-.mjs';
-import { assistantHome, bootstrapAssistantHome } from './bootstrap-DfXwkUQb.mjs';
-import { refreshAgentHomes, locateClaudeConversation, agentHomeSpawnEnv } from './index-Df0bc_et.mjs';
+import { c as RemoteCallBudget, e as REMOTE_WRITE_CALLS_PER_MINUTE, d as deliverToSession, g as guardRemoteSessionOpsRequest, h as remoteError, i as REMOTE_OP_DEADLINE_MS, j as formatRemoteAuditLine, k as REMOTE_SEND_COMMIT_DEADLINE_MS, m as REMOTE_RESUME_WAIT_MS, n as capRemoteTranscript, o as capRemoteText, p as REMOTE_ANSWER_MAX_BYTES, q as REMOTE_TITLE_MAX_BYTES } from './remoteSessionClient-BdnJ_n8C.mjs';
+import { assistantHome, bootstrapAssistantHome } from './bootstrap-rLaL3kTa.mjs';
+import { refreshAgentHomes, locateClaudeConversation, agentHomeSpawnEnv } from './index-DuK9XYbZ.mjs';
 import require$$0, { existsSync as existsSync$1, statSync as statSync$1, mkdtempSync, rmSync } from 'fs';
 import require$$1, { join as join$1 } from 'path';
 import { spawn as spawn$1, execFile, spawnSync } from 'node:child_process';
 import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { d as daemonEndpointsMatch, r as resolveClaudeCredentialReadiness } from './doctorReadiness-C208SMN9.mjs';
-import { o as ownerRetryPending, c as consumeOwnerRetry, s as spawnGate, a as afterStartupFailure, b as startupFailureMessage, T as TEAM_SPAWN_MAX_ATTEMPTS, d as TEAM_CLEANUP_RETRY_MS, g as getInitialMachineMetadata, e as getStartupCliAvailability, f as TEAM_RETRY_CAPABILITY_VERSION, w as withRunningCliFacts } from './machineMetadata-D-5qeIqd.mjs';
+import { o as ownerRetryPending, c as consumeOwnerRetry, s as spawnGate, a as afterStartupFailure, b as startupFailureMessage, T as TEAM_SPAWN_MAX_ATTEMPTS, d as TEAM_CLEANUP_RETRY_MS, g as getInitialMachineMetadata, e as getStartupCliAvailability, f as TEAM_RETRY_CAPABILITY_VERSION, w as withRunningCliFacts } from './machineMetadata-CXRmFNOV.mjs';
 import { M as ModelConfigError, B as BackupStore, r as readConfigFile, s as sha256, a as atomicWriteFile } from './fileStore-5qpetZS0.mjs';
 import { c as collectSecretValues, a as parseJsonObject, b as childObject, s as setOrDelete, d as changedPaths, e as stringifyLike, f as fail, n as normalizeModelList, g as normalizeModelId, h as normalizeSecret, i as normalizeBaseUrl, u as uniq, j as baseUrlWarnings, m as maskSecret, k as getPath$1, l as normalizeProviderId, o as piAdapter, r as redactText } from './pi-CqyoZMjI.mjs';
 import require$$3 from 'crypto';
 import { c as commandOnPath } from './detectCLI-CSGMlV51.mjs';
-import { buildResumeLaunch } from './handleResumeCommand-BNnD7EuD.mjs';
+import { buildResumeLaunch } from './handleResumeCommand-BK9XKH_l.mjs';
 import { n as normalizeWebPanels } from './webPanels-B2_C2-3g.mjs';
-import { M as ServerMigrateNoticeSchema, N as isHarnessInstallId, e as AUTOMATION_SUMMARY_MAX_CHARS, Q as AUTOMATION_PRECHECK_OUTPUT_MAX_CHARS, T as AUTOMATION_PRECHECK_DEFAULT_TIMEOUT_MS, b as AUTOMATION_PRECHECK_MAX_TIMEOUT_MS, U as AUTOMATION_CLAIM_MAX_RUNS, V as AUTOMATION_DAEMON_CAPABILITY_PRECHECK, W as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal, X as HARNESS_INSTALL_CAPABILITY_VERSION } from './index-WKyN-bNy.mjs';
+import { $ as ServerMigrateNoticeSchema, a0 as isHarnessInstallId, a1 as MODEL_INTENT_CONFIG, f as AUTOMATION_SUMMARY_MAX_CHARS, a2 as AUTOMATION_PRECHECK_OUTPUT_MAX_CHARS, a3 as AUTOMATION_PRECHECK_DEFAULT_TIMEOUT_MS, c as AUTOMATION_PRECHECK_MAX_TIMEOUT_MS, a4 as AUTOMATION_CLAIM_MAX_RUNS, a5 as AUTOMATION_DAEMON_CAPABILITY_PRECHECK, a6 as AUTOMATION_DEFAULT_LEASE_MS, i as isAutomationRunTerminal, a7 as HARNESS_INSTALL_CAPABILITY_VERSION } from './index-Bq8NKSCF.mjs';
 import { access, symlink, readFile, rm, unlink, readlink, lstat, constants, rename, mkdir, copyFile, readdir, stat, open } from 'node:fs/promises';
 import { p as parseExactVersion, c as compareExactVersions, f as fetchCliUpdateState, r as resolveCliUpdateCheckInterval, D as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS } from './cliUpdate-Y34VGe9Y.mjs';
-import { P as ProjectsUnsupportedError, c as createProjectsClient } from './client-B161HwAk.mjs';
-import { c as createAutomationsClient, i as isAutomationsUnavailable, d as AutomationsRequestError } from './client-CvjjadIE.mjs';
+import { P as ProjectsUnsupportedError, c as createProjectsClient } from './client-Bi20Ka0h.mjs';
+import { d as wrapperReportsIdle, f as decideAutoRestart, s as statusFromVerdict, g as autoRestartNextCheck, h as wrapperStaleness, r as recordAttempt, i as AUTO_RESTART_MAX_ATTEMPTS, j as AUTO_RESTART_MIN_GAP_MS, p as processIdentityFields, k as readSessionLock, l as terminateProcess, n as terminateProcessTree, o as AUTO_RESTARTED_ENV, q as encodeAutoRestarted, u as resolveQuietMs, v as AUTO_RESTART_RECHECK_CAP_MS } from './sessionLock-G2PMqvsh.mjs';
+import { c as createAutomationsClient, i as isAutomationsUnavailable, d as AutomationsRequestError } from './client-BXD66ZF5.mjs';
 import { w as withKeychainOffPath, a as keychainIdentityFor, i as interpretSecurityRead, s as securityReadArgs, b as securityDeleteArgs, c as keychainOffShimDir, d as interpretCredentialsFile, C as CREDENTIALS_REJECTED_DETAIL, e as buildClaudeAuthState, f as claudeAuthStateChanged, r as resolveSdkClaudeBinary, g as classifyAuthStatus, h as diagnoseStores, p as parseLaunchctlPid, H as HAPPY_DAEMON_LAUNCHD_LABEL, j as classifyLineage, l as probeLaunchdJob, m as detectDaemonSupervisor, n as daemonLineage, o as probeSystemdKillMode, q as wrappersSurviveHandover, t as handoverWaitsForSessions } from './daemonSupervisor-BxohggqN.mjs';
 import { g as getProjectPath } from './path-D2wdaNSk.mjs';
 import { b as extractClaudeEditPaths } from './editPaths-BVfS_FFL.mjs';
-import { s as startFileWatcher } from './startFileWatcher-DkEeeAtL.mjs';
-import { I as InvalidateSync } from './sync-BvDMkKAN.mjs';
+import { s as startFileWatcher } from './startFileWatcher-CDO6fb2m.mjs';
+import { I as InvalidateSync } from './sync-C0PRuTMj.mjs';
 import { R as RawJSONLinesSchema } from './types-CkqAACXx.mjs';
 import { t as tmuxArgs, a as scrubTmuxClientEnv, s as shellescape } from './tmuxSocket-B8Yx20sT.mjs';
-import { p as processIdentityFields, r as readSessionLock, t as terminateProcess, d as terminateProcessTree } from './sessionLock-tEFvFXLD.mjs';
 import { findAllHappyProcesses } from './doctor-BPkYWSuq.mjs';
 import { T as TEAM_SKILL, a as TEAM_LEAD_PLAYBOOK, b as TEAM_MEMBER_RULES } from './resources-CLP_MpK4.mjs';
 import { promisify } from 'node:util';
-import { b as clipText, r as renderAction, c as clipAutomationReport, e as renderTemplate } from './template-CEK8MEjo.mjs';
+import { b as clipText, r as renderAction, c as clipAutomationReport, e as renderTemplate } from './template-DLR_0hfj.mjs';
 import { d as describeAgentHome } from './loginShellEnv-Dw8M7tkI.mjs';
-import './acpSessionResume-Dxl1LRAT.mjs';
-import './lidState-q5Its2Hm.mjs';
+import './acpSessionResume-Bi7pA1n_.mjs';
+import './lidState-CD81ryTy.mjs';
 import 'node:events';
 import 'socket.io-client';
-import './pushNotifications-Cq1s8YVK.mjs';
+import './pushNotifications-XAM8__Pg.mjs';
 import './contentLogMetadata-BlWI0egu.mjs';
 import './limits-DIo7rEBR.mjs';
-import './time-CUK37wiV.mjs';
-import './registerCommonHandlers-DWkTysjD.mjs';
+import './time-D0jvDRhn.mjs';
+import './registerCommonHandlers-DRRfinzK.mjs';
 import 'util';
 import 'cross-spawn';
 import '@paralleldrive/cuid2';
 import 'chalk';
 import 'node:module';
 import 'tweetnacl';
-import './browser-vb0k1zfI.mjs';
+import './browser-CHpVgyni.mjs';
 import 'open';
 import './specialCommands-MXUN0wfI.mjs';
 import './ids-DU6sLx4C.mjs';
 import 'url';
-import './localHappyAgentAuth-C_G5u5lY.mjs';
+import './localHappyAgentAuth-Cg-m1lwm.mjs';
 import './processTreeSnapshot-CuLJDNC-.mjs';
 import 'ps-list';
 
@@ -548,7 +548,8 @@ const WrapperIdleSnapshotSchema = z.object({
   backgroundTasks: z.number().int().nonnegative(),
   scheduledWakeups: z.number().int().nonnegative().optional(),
   lastActivityAt: z.number(),
-  exiting: z.boolean().optional()
+  exiting: z.boolean().optional(),
+  agentVersion: z.string().max(64).optional()
 }).passthrough();
 const HibernateCheckBodySchema = z.object({
   sessionId: z.string().min(1).max(200),
@@ -1516,6 +1517,7 @@ function summaryFromPersisted(id, persisted) {
     ...meta?.flavor ? { flavor: meta.flavor } : {},
     ...meta?.tags?.length ? { tags: [...meta.tags] } : {},
     ...meta?.variant ? { variant: meta.variant } : {},
+    ...lineageOf(meta),
     ...persisted?.savedAt !== void 0 ? { savedAt: persisted.savedAt } : {},
     url: sessionWebUrl(id)
   };
@@ -5274,6 +5276,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 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 = 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) >= 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 < AUTO_RESTART_MIN_GAP_MS) {
+      schedule(() => {
+        void retryOffline(sessionId);
+      }, AUTO_RESTART_MIN_GAP_MS + Math.round(random() * 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 = 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" } : 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, 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: 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 = 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;
@@ -6348,6 +6597,9 @@ async function removeTeamWorktree(resource) {
   if (ownBranch) await git(repository, ["branch", "-D", branch]);
 }
 
+function teamInitialModelMeta(model) {
+  return model ? { model, modelIntent: model } : { modelIntent: MODEL_INTENT_CONFIG };
+}
 function refusalCode(error) {
   const code = axios.isAxiosError(error) ? error.response?.data?.error : void 0;
   return typeof code === "string" && /^[a-z_]{1,64}$/.test(code) ? ` (${code})` : "";
@@ -6464,7 +6716,7 @@ function createTeamWorker(deps) {
             return;
           }
           const key = await waitForSessionKey(receipt.sessionId, 1e4);
-          await sendUserMessage(receipt.sessionId, key, teamInitialPrompt(op.prompt, bot?.root === true, receipt.directory), "teams", { localId: `teams-initial-${op.id}`, sentFrom: "team", ...op.model ? { model: op.model } : {} });
+          await sendUserMessage(receipt.sessionId, key, teamInitialPrompt(op.prompt, bot?.root === true, receipt.directory), "teams", { localId: `teams-initial-${op.id}`, sentFrom: "team", ...teamInitialModelMeta(op.model) });
           receipt = { ...receipt, phase: "delivered" };
           writeReceipt$1(home, receipt);
         }
@@ -7408,6 +7660,7 @@ async function startDaemon() {
   let lastHandoverHold = null;
   let claudeCredentialStoreSetting = (await readSettings()).claudeCredentialStore === "file" ? "file" : "auto";
   let agentHibernationSetting = (await readSettings()).agentHibernationIdleMs;
+  let autoRestartSetting = (await readSettings()).autoRestartSessions !== false;
   try {
     const homes = await refreshAgentHomes();
     logger.debug(`[DAEMON RUN] Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}; Codex home: ${describeAgentHome(homes.codexHome)}`);
@@ -7530,6 +7783,7 @@ async function startDaemon() {
     });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
+    let autoRestart;
     let automationRunner;
     let projectPresence;
     const persisted = readPersistedSessions();
@@ -8270,6 +8524,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()) {
@@ -8319,7 +8574,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}` };
         }
@@ -8370,7 +8625,7 @@ async function startDaemon() {
         if (model) args.push("--model", model);
         const permissionMode = 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,
@@ -8391,7 +8646,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 ? { [AUTO_RESTARTED_ENV]: encodeAutoRestarted(options.auto.kind, options.auto.target) } : {}
           }
         });
         if (result.type === "success") {
@@ -8434,10 +8690,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 = readPersistedSessions()[session.happySessionId];
@@ -8518,6 +8775,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: resolveQuietMs(),
+      daemonVersion: 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) => existsSync$1(p),
+          conversationExists: (cwd, claudeSessionId) => 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 && (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.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.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({
@@ -8544,7 +8879,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 ?? AUTO_RESTART_RECHECK_CAP_MS, 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.
@@ -8696,6 +9038,13 @@ async function startDaemon() {
       daemonHibernation.invalidateBindings();
       return resolveIdleMs(agentHibernationSetting);
     });
+    apiMachine.setAutoRestartHandlers(autoRestartSetting, async (enabled) => {
+      await 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.settingsFile).catch(() => null))?.mtimeMs ?? null,
       readRaw: async () => (await readSettings()).webPanels,
@@ -8786,7 +9135,10 @@ async function startDaemon() {
       if (delay !== null) logger.warn(`[DAEMON RUN] CLI update policy announced; re-checking in ${Math.round(delay / 1e3)}s`);
     });
     const stopAgentVersionChecks = 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.debug("[DAEMON RUN] Agent version check failed", error)
     );
     harnessInstaller = createHarnessInstaller({
@@ -8968,6 +9320,7 @@ async function startDaemon() {
         logger.debug("[DAEMON RUN] Health check interval cleared");
       }
       clearInterval(cliUpdateInterval);
+      clearInterval(autoRestartSweep);
       policyAnnouncements.stop();
       stopAgentVersionChecks();
       await apiMachine.updateDaemonState((state) => ({