very-happy-cli 0.2.166 → 0.2.167

package/dist/{run-Bh66Xs40.cjs → run-BC8jzq_h.cjs}

@@ -1,25 +1,25 @@
 'use strict';
 
-var mirrorProtocol = require('./mirrorProtocol-BEGk2--0.cjs');
-var piRunnerArgs = require('./piRunnerArgs-DI29dDNo.cjs');
+var mirrorProtocol = require('./mirrorProtocol-BdcN6QlN.cjs');
+var piRunnerArgs = require('./piRunnerArgs-DpbvstUX.cjs');
 var fs = require('fs/promises');
 var tmp = require('tmp');
 var axios = require('axios');
-var api = require('./api-DnNL5fLw.cjs');
+var api = require('./api-BZYLRDM9.cjs');
 var spawnAgents = require('./spawnAgents-vglexX9N.cjs');
-var logger = require('./logger-JTcJU-uL.cjs');
+var logger = require('./logger-B_MWPbZz.cjs');
 var node_fs = require('node:fs');
 var path = require('node:path');
-var index$2 = require('./index-CaFCAlX8.cjs');
-var auth = require('./auth-ietHtvwu.cjs');
-var configuration = require('./configuration-B0cb3xA3.cjs');
+var index$2 = require('./index-BjhKqDa0.cjs');
+var auth = require('./auth-VzWpbo5P.cjs');
+var configuration = require('./configuration-C3piBtxY.cjs');
 var child_process = require('child_process');
-var _package = require('./package-C1XvUQFy.cjs');
-var doctor = require('./doctor-CkJmdPbi.cjs');
-var spawnHappyCLI = require('./spawnHappyCLI-DyaldIe5.cjs');
-var persistence = require('./persistence-2Xp_o6x6.cjs');
-var controlClient = require('./controlClient-CmnHGcyl.cjs');
-var sessionOps = require('./sessionOps-DOyy4gkY.cjs');
+var _package = require('./package-C9ZP9bpX.cjs');
+var doctor = require('./doctor-BykBaMTr.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-J4iEhfyZ.cjs');
+var persistence = require('./persistence-BYGl0QYw.cjs');
+var controlClient = require('./controlClient-BI6Fw3fQ.cjs');
+var sessionOps = require('./sessionOps-DzbZI3Eq.cjs');
 var fastify = require('fastify');
 var z = require('zod');
 var fastifyTypeProviderZod = require('fastify-type-provider-zod');
@@ -27,45 +27,45 @@ var authRelay = require('./authRelay-BdYkC1Po.cjs');
 var node_crypto = require('node:crypto');
 var previewPath = require('./previewPath-B0rBdhy1.cjs');
 var backgroundTaskActivity = require('./backgroundTaskActivity-CBvUdj39.cjs');
-var rateLimitWindows = require('./rateLimitWindows-C2Jk3Ih7.cjs');
-var peerTools = require('./peerTools-DPvbcs8V.cjs');
+var rateLimitWindows = require('./rateLimitWindows-CusGIqlq.cjs');
+var peerTools = require('./peerTools-Dkbu7gag.cjs');
 var os = require('node:os');
-var remoteSessionClient = require('./remoteSessionClient-BwI8rpQw.cjs');
-var bootstrap = require('./bootstrap-BpXIc2wn.cjs');
-var index$1 = require('./index-DEKIgZUo.cjs');
+var remoteSessionClient = require('./remoteSessionClient-PyUAIhwK.cjs');
+var bootstrap = require('./bootstrap-Dj8WBiR2.cjs');
+var index$1 = require('./index-PNMQPKhz.cjs');
 var fs$1 = require('fs');
 var path$2 = require('path');
 var node_child_process = require('node:child_process');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
 var doctorReadiness = require('./doctorReadiness-BCZGcN0a.cjs');
-var machineMetadata = require('./machineMetadata-BBg_Njw3.cjs');
-var handleResumeCommand = require('./handleResumeCommand-6KzBGDnl.cjs');
+var machineMetadata = require('./machineMetadata-BafS4JY8.cjs');
+var handleResumeCommand = require('./handleResumeCommand-yPdDQHqz.cjs');
 var promises = require('node:fs/promises');
 var cliUpdate = require('./cliUpdate-DsKXPFYp.cjs');
+var client = require('./client-D0T5-6Ds.cjs');
 var module$1 = require('node:module');
 var path$1 = require('./path-B7zW-WwE.cjs');
 var editPaths = require('./editPaths-Bqp4OFPw.cjs');
-var startFileWatcher = require('./startFileWatcher-DQbbypJv.cjs');
-var sync = require('./sync-x_lI_3j_.cjs');
+var startFileWatcher = require('./startFileWatcher-xKo8AoYl.cjs');
+var sync = require('./sync-Bvc-vh6C.cjs');
 var types = require('./types-CRS-srZK.cjs');
 var tmuxSocket = require('./tmuxSocket-D-Xt6Vn-.cjs');
-var sessionLock = require('./sessionLock-DfhNICyS.cjs');
+var sessionLock = require('./sessionLock-LBWNjpHf.cjs');
 var doctor$1 = require('./doctor-u46qYYKX.cjs');
 var resources = require('./resources-JDPugcDq.cjs');
 var node_util = require('node:util');
 var index = require('./index-C9hI8a10.cjs');
-var client = require('./client-DJ0kX_8M.cjs');
 var template = require('./template-BaHAmH2K.cjs');
 var loginShellEnv = require('./loginShellEnv-BkuYtExZ.cjs');
-require('./sessionModeFile-CIznKD7O.cjs');
-require('./lidState-D8BmnJV1.cjs');
+require('./sessionModeFile-CyPuZRIU.cjs');
+require('./lidState-Bc2K9H9l.cjs');
 require('os');
 require('node:events');
 require('socket.io-client');
-require('./attachmentLimits-BfgKV5iE.cjs');
+require('./attachmentLimits-BEYEEBm8.cjs');
 require('./limits-C-a7gr04.cjs');
-require('./time-T0YmeOhS.cjs');
-require('./registerCommonHandlers-Aha_KfM3.cjs');
+require('./time-BXvtjhe9.cjs');
+require('./registerCommonHandlers-DVYB3iVn.cjs');
 require('util');
 require('crypto');
 require('cross-spawn');
@@ -73,12 +73,12 @@ require('@paralleldrive/cuid2');
 require('./contentLogMetadata-ZSFk_NjQ.cjs');
 require('chalk');
 require('tweetnacl');
-require('./browser-CcG8GLRV.cjs');
+require('./browser-BoCV40yC.cjs');
 require('open');
 require('./ids-B6ZC0HGt.cjs');
 require('url');
 require('./detectCLI-DR9ZaN6B.cjs');
-require('./localHappyAgentAuth-d7B6S_o7.cjs');
+require('./localHappyAgentAuth-T5GOvRha.cjs');
 require('ps-list');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -418,6 +418,29 @@ function isAuthorizedDaemonControlRequest(authorization, controlToken) {
   return configuredTokenIsUsable && node_crypto.timingSafeEqual(expectedDigest, candidateDigest);
 }
 
+const WrapperIdleSnapshotSchema = z.z.object({
+  flavor: z.z.string().max(64),
+  resumable: z.z.boolean(),
+  uiSession: z.z.boolean(),
+  variant: z.z.string().max(64).optional(),
+  spawnedBy: z.z.string().max(64).optional(),
+  tags: z.z.array(z.z.string().max(128)).max(64).optional(),
+  keepAwake: z.z.boolean(),
+  keepAwakeSetting: z.z.boolean().optional(),
+  thinking: z.z.boolean(),
+  queuedInputs: z.z.number().int().nonnegative(),
+  waitingForInput: z.z.boolean(),
+  pendingRequests: z.z.number().int().nonnegative(),
+  backgroundTasks: z.z.number().int().nonnegative(),
+  scheduledWakeups: z.z.number().int().nonnegative().optional(),
+  lastActivityAt: z.z.number(),
+  exiting: z.z.boolean().optional()
+}).passthrough();
+const HibernateCheckBodySchema = z.z.object({
+  sessionId: z.z.string().min(1).max(200),
+  pid: z.z.number().int().positive(),
+  report: WrapperIdleSnapshotSchema
+});
 const BackgroundTaskInfoSchema = z.z.object({
   id: z.z.string().min(1).max(200),
   type: z.z.string().max(64),
@@ -451,7 +474,8 @@ function startDaemonControlServer({
   onSessionEdit,
   listPeers,
   isTurnActive,
-  onRateLimits
+  onRateLimits,
+  onHibernateCheck
 }) {
   return new Promise((resolve) => {
     const app = fastify({
@@ -534,6 +558,29 @@ function startDaemonControlServer({
       onSessionStateEvent?.(sessionId, event, spawnedBy);
       return { status: "ok" };
     });
+    if (onHibernateCheck) {
+      typed.post("/session-hibernate-check", {
+        schema: {
+          body: HibernateCheckBodySchema,
+          response: {
+            200: z.z.object({
+              hibernate: z.z.boolean(),
+              reason: z.z.string().optional(),
+              idleMs: z.z.number().optional(),
+              nextCheckMs: z.z.number().optional(),
+              keepAwake: z.z.boolean().optional()
+            })
+          }
+        }
+      }, async (request) => {
+        try {
+          return await onHibernateCheck(request.body);
+        } catch (error) {
+          logger.logger.debug("[CONTROL SERVER] hibernate check failed:", error);
+          return { hibernate: false, reason: "error" };
+        }
+      });
+    }
     typed.post("/list", {
       schema: {
         response: {
@@ -2413,6 +2460,133 @@ function createUpdateController(deps) {
   return { refresh, retry, request, tick, withHandover, holdHandover, isRunning: () => running };
 }
 
+const AUTOMATION_BINDINGS_TTL_MS = 10 * 60 * 1e3;
+const HIBERNATION_IN_FLIGHT_MS = 6e4;
+const HIBERNATION_EXIT_WAIT_MS = 15e3;
+async function waitForPidsToExit(pids, isAlive, timeoutMs = HIBERNATION_EXIT_WAIT_MS, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now) {
+  const deadline = now() + timeoutMs;
+  while (pids.some(isAlive)) {
+    if (now() >= deadline) return false;
+    await sleep(100);
+  }
+  return true;
+}
+function createDaemonHibernation(deps) {
+  const now = () => (deps.now ?? Date.now)();
+  const signatures = /* @__PURE__ */ new Map();
+  const approved = /* @__PURE__ */ new Map();
+  let bindings = null;
+  let bindingsInFlight = null;
+  async function automationBound(fresh = false) {
+    if (!fresh && bindings && now() - bindings.at < AUTOMATION_BINDINGS_TTL_MS) return bindings.ids;
+    if (fresh && bindingsInFlight) await bindingsInFlight;
+    if (!bindingsInFlight) {
+      bindingsInFlight = deps.loadAutomationBindings().then((ids) => {
+        bindings = { at: now(), ids: new Set(ids) };
+        return bindings.ids;
+      }).catch((error) => {
+        deps.log?.(`[hibernate] automation bindings unknown: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+      }).finally(() => {
+        bindingsInFlight = null;
+      });
+    }
+    return bindingsInFlight;
+  }
+  function inFlight(except) {
+    const t = now();
+    for (const [id, at] of approved) {
+      if (t - at > HIBERNATION_IN_FLIGHT_MS) approved.delete(id);
+      else if (id !== except) return true;
+    }
+    return false;
+  }
+  async function check(request) {
+    const idleMs = deps.idleMs();
+    const t = now();
+    const tracked = deps.tracked(request.sessionId, request.pid);
+    const latchedBefore = deps.readKeepAwake?.(request.sessionId) ?? false;
+    const latched = persistence.latchKeepAwake(request.report.keepAwakeSetting, latchedBefore || request.report.keepAwake);
+    if (latched !== latchedBefore) deps.writeKeepAwake?.(request.sessionId, latched);
+    if (latched && !request.report.keepAwake) request = { ...request, report: { ...request.report, keepAwake: true } };
+    const signature = persistence.reportSignature(request.report);
+    const previousSignature = signatures.get(request.sessionId);
+    signatures.set(request.sessionId, signature);
+    const base = {
+      idleMs,
+      now: t,
+      sessionId: request.sessionId,
+      pid: request.pid,
+      report: request.report,
+      trackedLive: !!tracked?.live,
+      trackedSpawnedBy: tracked?.spawnedBy,
+      teamsMember: deps.teamsMember(request.sessionId),
+      turnActive: deps.turnActive(request.sessionId),
+      backgroundTasks: deps.backgroundTasks(request.sessionId),
+      previousSignature,
+      hibernationInFlight: inFlight(request.sessionId)
+    };
+    let verdict = persistence.decideDaemonHibernation({ ...base, automationBound: /* @__PURE__ */ new Set() });
+    if (verdict.ok || verdict.reason === "unconfirmed" || verdict.reason === "busy") {
+      verdict = persistence.decideDaemonHibernation({ ...base, automationBound: await automationBound() });
+    }
+    if (verdict.ok) {
+      verdict = persistence.decideDaemonHibernation({ ...base, automationBound: await automationBound(true) });
+    }
+    if (verdict.ok) {
+      approved.set(request.sessionId, t);
+      signatures.delete(request.sessionId);
+      deps.log?.(`[hibernate] approved ${request.sessionId} (pid ${request.pid}, idle ${Math.round((t - request.report.lastActivityAt) / 1e3)}s)`);
+      return { hibernate: true, idleMs, ...latched ? { keepAwake: true } : {} };
+    }
+    const next = verdict.reason === "unconfirmed" ? deps.checkMs : persistence.nextCheckDelay(verdict, request.report, idleMs, deps.checkMs, t);
+    return { hibernate: false, reason: verdict.reason, idleMs, nextCheckMs: next, ...latched ? { keepAwake: true } : {} };
+  }
+  return {
+    check,
+    /** Called when the wrapper exits: true when this exit is the hibernation we approved. */
+    consumeExit(sessionId) {
+      const at = approved.get(sessionId);
+      approved.delete(sessionId);
+      signatures.delete(sessionId);
+      return at !== void 0 && now() - at <= HIBERNATION_IN_FLIGHT_MS * 5;
+    },
+    /** Review P1-2: an approved hibernation whose wrapper has not exited yet. */
+    pendingExit(sessionId) {
+      const at = approved.get(sessionId);
+      return at !== void 0 && now() - at <= HIBERNATION_IN_FLIGHT_MS * 5;
+    },
+    forget(sessionId) {
+      signatures.delete(sessionId);
+    },
+    /** Drop the cached Automations bindings (e.g. after the setting changed). */
+    invalidateBindings() {
+      bindings = null;
+    }
+  };
+}
+async function collectAutomationBindings(client, machineId) {
+  const ids = /* @__PURE__ */ new Set();
+  const automations = await client.list(machineId);
+  for (const automation of automations) {
+    const action = automation.action;
+    if (action?.kind === "send" && typeof action.sessionId === "string") ids.add(action.sessionId);
+    if (action?.kind === "spawn" && action.sticky) {
+      for (const sticky of await client.stickies(automation.id)) ids.add(sticky.sessionId);
+    }
+  }
+  return [...ids];
+}
+const AUTOMATION_WAKE_TIMEOUT_MS = 6e4;
+async function waitForSessionLive(sessionId, live, timeoutMs = AUTOMATION_WAKE_TIMEOUT_MS, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now) {
+  const deadline = now() + timeoutMs;
+  while (!live(sessionId)) {
+    if (now() >= deadline) return false;
+    await sleep(250);
+  }
+  return true;
+}
+
 const CLAUDE_KEYCHAIN_SERVICE_PREFIX = "Claude Code";
 function keychainIdentity(env = process.env, deps = {}) {
   const home = deps.home ?? os.homedir();
@@ -2476,7 +2650,7 @@ function parseJsonObject(text) {
     return null;
   }
 }
-function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('run-Bh66Xs40.cjs', document.baseURI).href))).resolve(s)) {
+function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('run-BC8jzq_h.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -3558,7 +3732,7 @@ function writeReceipt$1(home, receipt) {
 
 const exec = node_util.promisify(node_child_process.execFile);
 const git = async (directory, args) => (await exec("git", ["-C", directory, ...args], { timeout: 3e4, maxBuffer: 2 * 1024 * 1024 })).stdout.trim();
-async function prepareTeamWorktree(home, repository, id) {
+async function prepareTeamWorktree(home, repository, id, origin = "teams") {
   if (repository === "~") repository = os.homedir();
   else if (repository.startsWith("~/") || process.platform === "win32" && repository.startsWith("~\\")) repository = path.join(os.homedir(), repository.slice(2));
   if (!path.isAbsolute(repository) || !/^[a-zA-Z0-9_-]{1,128}$/.test(id)) throw new Error("A team task requires an absolute repository path and valid operation id");
@@ -3575,6 +3749,7 @@ async function prepareTeamWorktree(home, repository, id) {
     if (path.resolve(common) !== path.resolve(expected)) throw new Error("Team worktree belongs to another repository");
   } else {
     await git(repository, ["worktree", "add", "-b", branch, directory, "HEAD"]);
+    await mirrorProtocol.initializeOwnedWorktree({ source: repository, worktree: directory, branch, origin });
   }
   return { directory, repository, branch };
 }
@@ -4222,6 +4397,35 @@ function createAutomationRunner(deps) {
       }
     })();
   }
+  function wakeThenSend(claimed, sessionId, text, stickyKey) {
+    const { run, automation } = claimed;
+    const item = track(claimed, "send", sessionId);
+    item.waking = true;
+    gating++;
+    void (async () => {
+      try {
+        const woke = await deps.wakeHibernated(sessionId).catch(() => false);
+        if (!tracked.has(run.id) || closed) return;
+        item.waking = false;
+        if (!woke || !deps.live(sessionId)) {
+          await finish(item, { claimId: run.claimId, status: "failed", sessionId, error: `Session ${sessionId} was hibernated and could not be woken in time`, needsAttention: true, attentionReason: "session_wake_failed" });
+          return;
+        }
+        persist({ runId: run.id, automationId: automation.id, kind: "send", phase: "running", claimId: run.claimId, sessionId, ...stickyKey ? { stickyKey } : {} });
+        try {
+          await send(sessionId, text, { localId: `automation-${run.id}` });
+        } catch (error) {
+          await finish(item, { claimId: run.claimId, status: "failed", sessionId, error: template.clipText(`Message delivery failed: ${error instanceof Error ? error.message : String(error)}`, index.AUTOMATION_SUMMARY_MAX_CHARS), needsAttention: true, attentionReason: "send_failed" });
+          return;
+        }
+        await reportRunning(item, sessionId, stickyKey);
+      } finally {
+        item.waking = false;
+        gating--;
+      }
+    })();
+  }
+  const wakeable = (sessionId) => !deps.live(sessionId) && !!deps.wakeHibernated && deps.isHibernated?.(sessionId) === true;
   async function perform(claimed, action, context, env) {
     const { run, automation } = claimed;
     const header = automationPromptHeader(automation.name, run.id);
@@ -4249,6 +4453,11 @@ function createAutomationRunner(deps) {
       return;
     }
     if (action.kind === "send") {
+      if (wakeable(action.sessionId)) {
+        wakeThenSend(claimed, action.sessionId, `${header}
+${action.prompt}`);
+        return;
+      }
       if (!deps.live(action.sessionId)) {
         await failNow(claimed, "send", `Session ${action.sessionId} is not running on this machine`, "session_not_live", action.sessionId);
         return;
@@ -4277,6 +4486,11 @@ ${action.prompt}`, { localId: `automation-${run.id}` });
     const stickyKey = action.sticky ? template.renderTemplate(action.sticky.key, context) : void 0;
     if (stickyKey) {
       const bound = claimed.stickies.find((sticky) => sticky.key === stickyKey);
+      if (bound && wakeable(bound.sessionId)) {
+        wakeThenSend(claimed, bound.sessionId, `${header}
+${action.prompt}`, stickyKey);
+        return;
+      }
       if (bound && deps.live(bound.sessionId)) {
         persist({ runId: run.id, automationId: automation.id, kind: "send", phase: "running", claimId: run.claimId, sessionId: bound.sessionId, stickyKey });
         try {
@@ -4298,7 +4512,7 @@ ${action.prompt}`, { localId: `automation-${run.id}` });
     }
     if (action.worktree) {
       try {
-        directory = (await prepareWorktree(home, directory, `auto-${run.id}`)).directory;
+        directory = (await prepareWorktree(home, directory, `auto-${run.id}`, "automation")).directory;
       } catch (error) {
         await failNow(claimed, "spawn", `Worktree preparation failed: ${error instanceof Error ? error.message : String(error)}`, "worktree_failed");
         return;
@@ -4330,7 +4544,7 @@ ${action.prompt}`, { localId: `automation-${run.id}`, ...meta });
         await finish(item, item.pendingFinal);
         continue;
       }
-      if (item.kind === "script") continue;
+      if (item.kind === "script" || item.waking) continue;
       const sessionId = item.sessionId;
       const active = deps.turnActive(sessionId);
       if (active) item.sawTurn = true;
@@ -4548,6 +4762,7 @@ async function startDaemon() {
   let cliUpdateStateRef = null;
   let lastHandoverHold = null;
   let claudeCredentialStoreSetting = (await persistence.readSettings()).claudeCredentialStore === "file" ? "file" : "auto";
+  let agentHibernationSetting = (await persistence.readSettings()).agentHibernationIdleMs;
   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)}`);
@@ -4634,6 +4849,40 @@ async function startDaemon() {
     const turnActivity = new api.TurnActivityTracker();
     const backgroundTasks = new backgroundTaskActivity.BackgroundTaskTracker();
     const peerCoordinator = createPeerCoordinator({ getChildren: () => Array.from(pidToTrackedSession.values()) });
+    const hibernationAutomations = client.createAutomationsClient({ serverUrl: configuration.configuration.serverUrl, token: credentials.token, client: "daemon-hibernate" });
+    const daemonHibernation = createDaemonHibernation({
+      idleMs: () => persistence.resolveIdleMs(agentHibernationSetting),
+      checkMs: persistence.resolveCheckMs(),
+      tracked: (sessionId, pid) => {
+        const tracked = pidToTrackedSession.get(pid);
+        if (!tracked || tracked.happySessionId !== sessionId) return null;
+        let live = false;
+        try {
+          process.kill(pid, 0);
+          live = true;
+        } catch {
+          live = false;
+        }
+        return { live, ...tracked.spawnedBy ? { spawnedBy: tracked.spawnedBy } : {} };
+      },
+      teamsMember: (sessionId) => teamWorker?.hasSession(sessionId) === true,
+      turnActive: (sessionId) => turnActivity.activeSessions().includes(sessionId),
+      backgroundTasks: (sessionId) => backgroundTasks.count(sessionId),
+      loadAutomationBindings: async () => {
+        try {
+          return await collectAutomationBindings(hibernationAutomations, machineId);
+        } catch (error) {
+          if (client.isAutomationsUnavailable(error)) return [];
+          throw error;
+        }
+      },
+      log: (message) => logger.logger.debug(`[DAEMON RUN] ${message}`),
+      readKeepAwake: (sessionId) => persistence.readPersistedSessions()[sessionId]?.keepAwake === true,
+      writeKeepAwake: (sessionId, value) => {
+        const record = persistence.readPersistedSessions()[sessionId];
+        if (record) persistence.persistSession(sessionId, { ...record, keepAwake: value || void 0 });
+      }
+    });
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
     let automationRunner;
@@ -5247,6 +5496,13 @@ async function startDaemon() {
     };
     const resumeSessionImpl = async (happySessionId, options) => {
       try {
+        if (daemonHibernation.pendingExit(happySessionId)) {
+          const dying = [...pidToTrackedSession.entries()].filter(([, s]) => s.happySessionId === happySessionId).map(([pid]) => pid);
+          const exited = await waitForPidsToExit(dying, isPidAlive);
+          logger.logger.debug(`[DAEMON RUN] resume ${happySessionId}: waited for hibernating wrapper(s) ${dying.join(", ")} \u2192 ${exited ? "exited" : "still alive after timeout"}`);
+          if (!exited) return { type: "error", errorMessage: `Session ${happySessionId} is still going to sleep; try again in a few seconds.` };
+          for (const pid of dying) if (pidToTrackedSession.has(pid)) onChildExited(pid);
+        }
         for (const [pid, live] of pidToTrackedSession.entries()) {
           if (live.happySessionId !== happySessionId) continue;
           if (isPidAlive(pid)) {
@@ -5507,6 +5763,14 @@ async function startDaemon() {
       if (session?.happySessionId) turnActivity.forget(session.happySessionId);
       if (session?.happySessionId) backgroundTasks.forget(session.happySessionId);
       if (session?.happySessionId) peerCoordinator.forget(session.happySessionId);
+      if (session?.happySessionId && daemonHibernation.consumeExit(session.happySessionId)) {
+        const persisted2 = persistence.readPersistedSessions()[session.happySessionId];
+        if (persisted2) {
+          const at = Date.now();
+          persistence.persistSession(session.happySessionId, { ...persisted2, savedAt: at, hibernatedAt: at });
+        }
+        logger.logger.debug(`[DAEMON RUN] Session ${session.happySessionId} hibernated (PID ${pid} exited)`);
+      }
       if (session?.happySessionId && session.encryption) {
         sessionIdToFinishedSession.set(session.happySessionId, session);
         logger.logger.debug(`[DAEMON RUN] Process PID ${pid} exited, preserved session ${session.happySessionId} for resume`);
@@ -5602,6 +5866,7 @@ async function startDaemon() {
       onRateLimits: (report) => {
         apiMachineRef?.reportRateLimits(report);
       },
+      onHibernateCheck: (body) => daemonHibernation.check(body),
       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.
@@ -5723,6 +5988,13 @@ async function startDaemon() {
       setStore: (store) => claudeAuthService.setStore(store)
     });
     claudeAuthService.start();
+    apiMachine.setAgentHibernationHandlers(persistence.resolveIdleMs(agentHibernationSetting), async (requested) => {
+      const value = requested <= 0 ? 0 : persistence.settingIdleMs(requested);
+      await persistence.updateSettings((current) => ({ ...current, agentHibernationIdleMs: value }));
+      agentHibernationSetting = value;
+      daemonHibernation.invalidateBindings();
+      return persistence.resolveIdleMs(agentHibernationSetting);
+    });
     apiMachine.connect();
     if (identityConflict?.confidence === "weak") {
       void apiMachine.updateMachineMetadata((current) => ({
@@ -5870,18 +6142,32 @@ async function startDaemon() {
       live: (id) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === id && isPidAlive(s.pid)),
       turnActive: (id) => turnActivity.activeSessions().includes(id),
       backgroundTasks: (id) => backgroundTasks.count(id),
+      // B-587 review P2-5: a hibernated target is woken (resume) and the send
+      // waits until its wrapper is back; anything else stays session_not_live.
+      isHibernated: (id) => {
+        const record = persistence.readPersistedSessions()[id];
+        return !!record && typeof record.hibernatedAt === "number" && record.hibernatedAt >= record.savedAt;
+      },
+      wakeHibernated: async (id) => {
+        const result = await resumeSession(id);
+        if (result.type !== "success") return false;
+        return waitForSessionLive(id, (sid) => [...pidToTrackedSession.values()].some((s) => s.happySessionId === sid && isPidAlive(s.pid)));
+      },
       log: (message) => logger.logger.debug(`[DAEMON RUN] ${message}`)
     });
     void apiMachine.updateMachineMetadata((current) => ({
       ...current ?? initialMachineMetadata,
       teamsVersion: 1,
-      teamLaunchVersion: 1
+      teamLaunchVersion: 1,
+      // B-586: this daemon serves the worktree-* RPCs (web gates 「在新 worktree 中」 on it).
+      worktreeVersion: mirrorProtocol.WORKTREE_CAPABILITY_VERSION
     })).catch(() => logger.logger.debug("[DAEMON RUN] Teams capability publication will retry on reconnect"));
     const cleanupAndShutdown = async (source, errorMessage) => {
       logger.logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
       const scrollbackFlush = apiMachine.flushTerminalScrollback();
       teamWorker?.stop();
       automationRunner?.stop({ killScripts: true });
+      mirrorProtocol.currentWorktreeService()?.stopAll();
       if (restartOnStaleVersionAndHeartbeat) {
         clearInterval(restartOnStaleVersionAndHeartbeat);
         logger.logger.debug("[DAEMON RUN] Health check interval cleared");