very-happy-cli 0.2.91 → 0.2.93

package/dist/{AcpBackend-B5RRlzLU.mjs → AcpBackend-C5507ePk.mjs}

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
 import { randomUUID } from 'node:crypto';
-import { l as logger, d as contentLogMetadata, e as errorLogMetadata, f as packageJson, g as delay } from './types-BKyjG23_.mjs';
+import { l as logger, d as contentLogMetadata, e as errorLogMetadata, f as packageJson, g as delay } from './types-Cx5wn5Hf.mjs';
 
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */

package/dist/{AcpBackend-GqveWg8u.cjs → AcpBackend-COv_3umE.cjs}

@@ -3,7 +3,7 @@
 var node_child_process = require('node:child_process');
 var sdk = require('@agentclientprotocol/sdk');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-ClDADuxP.cjs');
+var persistence = require('./types-BHVxYajT.cjs');
 
 const DEFAULT_TIMEOUTS = {
   /** Default initialization timeout: 60 seconds */

package/dist/{AcpSessionManager-Ij1pI5Ex.mjs → AcpSessionManager-Bd1trXWx.mjs}

@@ -1,5 +1,5 @@
 import { createId } from '@paralleldrive/cuid2';
-import { b as createEnvelope } from './types-BKyjG23_.mjs';
+import { b as createEnvelope } from './types-Cx5wn5Hf.mjs';
 
 function turnOptions(turnId, time) {
   return turnId ? { turn: turnId, time } : { time };

package/dist/{AcpSessionManager-YcrSZwvq.cjs → AcpSessionManager-vm4rIcH0.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var cuid2 = require('@paralleldrive/cuid2');
-var persistence = require('./types-ClDADuxP.cjs');
+var persistence = require('./types-BHVxYajT.cjs');
 
 function turnOptions(turnId, time) {
   return turnId ? { turn: turnId, time } : { time };

package/dist/{config-ra8iKxdU.mjs → config-BJjvra5x.mjs}

@@ -2,8 +2,8 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { execSync } from 'child_process';
-import { l as logger } from './types-BKyjG23_.mjs';
-import { D as DEFAULT_GEMINI_MODEL, G as GEMINI_MODEL_ENV } from './index-UCYD5Wk3.mjs';
+import { l as logger } from './types-Cx5wn5Hf.mjs';
+import { D as DEFAULT_GEMINI_MODEL, G as GEMINI_MODEL_ENV } from './index-C00jxV83.mjs';
 import 'axios';
 import 'chalk';
 import 'node:util';

package/dist/{config-C4NCw7Dz.cjs → config-SZEQWS8k.cjs}

@@ -4,8 +4,8 @@ var fs = require('fs');
 var path = require('path');
 var os = require('os');
 var child_process = require('child_process');
-var persistence = require('./types-ClDADuxP.cjs');
-var index = require('./index-FkXJNwiy.cjs');
+var persistence = require('./types-BHVxYajT.cjs');
+var index = require('./index-DaVhaBF2.cjs');
 require('axios');
 require('chalk');
 require('node:util');

package/dist/{index-C1HIm7NY.cjs → index-17NbIAkU.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-var AcpBackend = require('./AcpBackend-GqveWg8u.cjs');
-var persistence = require('./types-ClDADuxP.cjs');
-var AcpSessionManager = require('./AcpSessionManager-YcrSZwvq.cjs');
+var AcpBackend = require('./AcpBackend-COv_3umE.cjs');
+var persistence = require('./types-BHVxYajT.cjs');
+var AcpSessionManager = require('./AcpSessionManager-vm4rIcH0.cjs');
 var node_crypto = require('node:crypto');
 var path = require('node:path');
-var index = require('./index-FkXJNwiy.cjs');
+var index = require('./index-DaVhaBF2.cjs');
 require('node:child_process');
 require('@agentclientprotocol/sdk');
 require('axios');

package/dist/{index-UCYD5Wk3.mjs → index-C00jxV83.mjs}

@@ -1,7 +1,7 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir } from 'node:os';
 import { randomUUID, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { n as readDaemonState, l as logger, c as configuration, o as clearDaemonState, q as getProjectPath, p as projectPath, s as initializeSandbox, t as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, u as AsyncLock, v as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, x as hardenPrivateFile, f as packageJson, i as readSettings, y as readCredentials, z as credentialRelayProblem, B as deriveLocalCliUpdateSummary, j as encodeBase64, C as updateSettings, D as encodeBase64Url, E as decodeBase64, F as writeCredentialsLegacy, G as writeCredentialsDataKey, H as readCredentialsForConfiguredRelay, J as encrypt, r as readPersistedSessions, K as getLocalHappyAgentCredentialPath, L as readLocalHappyAgentCredentials, N as decryptWithDataKey, O as decryptLegacy, P as extractCompleteLines, Q as decideBackfill, S as parseTerminalHookPayload, T as tmuxArgs, U as scrubTmuxClientEnv, V as decideMirrorBinding, W as persistSession, X as MIRROR_BACKFILL_LINES_DEFAULT, Y as mirrorLineKey, Z as mirrorLocalId, _ as detectResumeSupport, $ as detectCLIAvailability, a0 as acquireDaemonLock, a1 as summarizeSpawnSessionForLog, a2 as deletePersistedSessions, a3 as decrypt, a4 as writeDaemonState, A as ApiClient, a5 as fetchCliUpdateState, a6 as resolveCliUpdateCheckInterval, a7 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a8 as releaseDaemonLock, a9 as isValidSessionId, aa as listVhTerminals, ab as isValidTerminalId, ac as readVhTerminal, ad as sendToVhTerminal, h as connectionState, ae as startOfflineReconnection, af as clearCredentials, ag as clearMachineId, k as ensurePrivateDirectorySync, w as writePrivateFileSync, ah as SandboxConfigSchema, b as createEnvelope, ai as CodexAppServerClient, aj as getLatestDaemonLog } from './types-BKyjG23_.mjs';
+import { n as readDaemonState, l as logger, c as configuration, o as clearDaemonState, q as getProjectPath, p as projectPath, s as initializeSandbox, t as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, g as delay, u as AsyncLock, v as ensurePrivateDirectory, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, x as hardenPrivateFile, f as packageJson, i as readSettings, y as readCredentials, z as credentialRelayProblem, B as deriveLocalCliUpdateSummary, j as encodeBase64, C as updateSettings, D as encodeBase64Url, E as decodeBase64, F as writeCredentialsLegacy, G as writeCredentialsDataKey, H as readCredentialsForConfiguredRelay, J as encrypt, r as readPersistedSessions, K as isClaudeSessionId, L as getLocalHappyAgentCredentialPath, N as readLocalHappyAgentCredentials, O as decryptWithDataKey, P as decryptLegacy, Q as extractCompleteLines, S as decideBackfill, T as parseTerminalHookPayload, U as tmuxArgs, V as scrubTmuxClientEnv, W as decideMirrorBinding, X as persistSession, Y as MIRROR_BACKFILL_LINES_DEFAULT, Z as mirrorLineKey, _ as mirrorLocalId, $ as detectResumeSupport, a0 as detectCLIAvailability, a1 as acquireDaemonLock, a2 as summarizeSpawnSessionForLog, a3 as deletePersistedSessions, a4 as decrypt, a5 as writeDaemonState, A as ApiClient, a6 as fetchCliUpdateState, a7 as resolveCliUpdateCheckInterval, a8 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a9 as releaseDaemonLock, aa as isValidSessionId, ab as listVhTerminals, ac as isValidTerminalId, ad as readVhTerminal, ae as sendToVhTerminal, h as connectionState, af as startOfflineReconnection, ag as clearCredentials, ah as clearMachineId, k as ensurePrivateDirectorySync, w as writePrivateFileSync, ai as SandboxConfigSchema, b as createEnvelope, aj as CodexAppServerClient, ak as getLatestDaemonLog } from './types-Cx5wn5Hf.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, isAbsolute, normalize, sep, dirname } from 'node:path';
 import { createInterface } from 'node:readline';
@@ -42,6 +42,56 @@ import inquirer from 'inquirer';
 import { fileURLToPath } from 'node:url';
 import { createInterface as createInterface$1 } from 'node:readline/promises';
 
+const PROCESS_IDENTITY_FIELDS = [
+  "hostPid",
+  "version",
+  "startedBy",
+  "startedFromDaemon",
+  "happyHomeDir",
+  "happyLibDir",
+  "happyToolsDir",
+  "capabilities",
+  "attachmentKinds",
+  "queueCancellation",
+  "sandbox",
+  "dangerouslySkipPermissions",
+  "os",
+  "host",
+  "homeDir",
+  "permissionMode"
+];
+function processIdentityFields(local) {
+  const out = {};
+  for (const key of PROCESS_IDENTITY_FIELDS) {
+    const value = local[key];
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function mergeReconnectMetadata(server, local, now) {
+  return {
+    ...server,
+    ...processIdentityFields(local),
+    lifecycleState: "running",
+    lifecycleStateSince: now,
+    archivedBy: void 0,
+    archiveReason: void 0
+  };
+}
+function applyServerSnapshot(response, snapshot) {
+  return {
+    ...response,
+    seq: snapshot.seq,
+    metadata: snapshot.metadata,
+    metadataVersion: snapshot.metadataVersion,
+    agentState: snapshot.agentState,
+    agentStateVersion: snapshot.agentStateVersion
+  };
+}
+function withoutServerSnapshot(response) {
+  return { ...response, metadataVersion: 0, agentStateVersion: 0 };
+}
+
 function daemonControlHeaders(controlToken) {
   return {
     "Content-Type": "application/json",
@@ -1548,6 +1598,9 @@ function query(params) {
   if (opts?.mcpServers && Object.keys(opts.mcpServers).length > 0) {
     ensureLocalProxyBypass(env);
   }
+  if (sdkOptions.allowDangerouslySkipPermissions && typeof process.getuid === "function" && process.getuid() === 0 && env.IS_SANDBOX === void 0) {
+    env.IS_SANDBOX = "1";
+  }
   sdkOptions.env = env;
   if (opts?.canCallTool) {
     const callback = opts.canCallTool;
@@ -5293,6 +5346,45 @@ function sanitizeSpawnPermissionMode(value) {
   return ALLOWED_SPAWN_PERMISSION_MODES.includes(value) ? value : null;
 }
 
+function resumePrecheck(metadata, fs) {
+  const flavor = metadata.flavor ?? "claude";
+  if (flavor !== "claude" && flavor !== "codex") {
+    return { ok: false, reason: "unsupported-flavor", detail: `flavor "${flavor}" cannot be resumed` };
+  }
+  if (!metadata.path || !fs.cwdExists(metadata.path)) {
+    return { ok: false, reason: "missing-cwd", detail: `working directory ${metadata.path ?? "(none)"} does not exist` };
+  }
+  if (flavor === "codex") {
+    if (!metadata.codexThreadId) return { ok: false, reason: "no-backend-id", detail: "session has no Codex thread id" };
+    return { ok: true };
+  }
+  if (!isClaudeSessionId(metadata.claudeSessionId)) {
+    return { ok: false, reason: "no-backend-id", detail: "session has no Claude session id" };
+  }
+  if (!fs.conversationExists(metadata.path, metadata.claudeSessionId)) {
+    return { ok: false, reason: "conversation-missing", detail: `conversation ${metadata.claudeSessionId} is not on disk` };
+  }
+  return { ok: true };
+}
+function sanitizeResumeModel(value) {
+  if (typeof value !== "string") return null;
+  return /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(value) ? value : null;
+}
+
+const DEFAULT_MAX_RESTARTS = 3;
+function decideRestart(priorAttempts, max = DEFAULT_MAX_RESTARTS) {
+  if (priorAttempts >= max) {
+    return {
+      allowed: false,
+      reason: `restart-limit: this session has already been restarted ${priorAttempts} time(s) this daemon session (max ${max}). Start a new session instead.`
+    };
+  }
+  return { allowed: true, attempt: priorAttempts + 1 };
+}
+function recordRestartAttempt(priorAttempts) {
+  return priorAttempts + 1;
+}
+
 const CONTROL_TOKEN_BYTES = 32;
 function createDaemonControlToken() {
   return randomBytes(CONTROL_TOKEN_BYTES).toString("base64url");
@@ -7110,6 +7202,7 @@ async function startDaemon() {
         tracked.pid = livePid;
         tracked.startedBy = "recovered after daemon restart";
         pidToTrackedSession.set(livePid, tracked);
+        persistSession(id, { ...s, savedAt: Date.now() });
       } else {
         sessionIdToFinishedSession.set(id, tracked);
       }
@@ -7538,6 +7631,13 @@ async function startDaemon() {
         const timeout = setTimeout(() => {
           pidToAwaiter.delete(happyProcess.pid);
           logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
+          if (happyProcess.pid) {
+            try {
+              terminateProcess(happyProcess.pid, () => {
+              });
+            } catch {
+            }
+          }
           resolve({
             type: "error",
             errorMessage: `Session webhook timeout for PID ${happyProcess.pid}`
@@ -7560,6 +7660,19 @@ async function startDaemon() {
       return sessionIdToFinishedSession.get(happySessionId);
     };
     const fetchServerSessionMetadata = async (sessionId, encryptionKey, encryptionVariant) => {
+      try {
+        const byId = await axios.get(`${configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
+          headers: { Authorization: `Bearer ${credentials.token}` },
+          timeout: 1e4,
+          validateStatus: (status) => status >= 200 && status < 300 || status === 404
+        });
+        if (byId.status !== 404) {
+          const row = byId.data.session;
+          if (row?.metadata) return decrypt(encryptionKey, encryptionVariant, decodeBase64(row.metadata));
+        }
+      } catch (error) {
+        logger.debug(`[DAEMON RUN] by-id session metadata fetch failed, falling back to list: ${error instanceof Error ? error.message : error}`);
+      }
       try {
         const response = await axios.get(`${configuration.serverUrl}/v1/sessions`, {
           headers: { Authorization: `Bearer ${credentials.token}` },
@@ -7575,17 +7688,38 @@ async function startDaemon() {
         return null;
       }
     };
+    const resumeGates = /* @__PURE__ */ new Map();
     const resumeSession = async (happySessionId, options) => {
+      let gate = resumeGates.get(happySessionId);
+      if (!gate) {
+        gate = createSpawnGate();
+        resumeGates.set(happySessionId, gate);
+      }
+      try {
+        return await gate.join(() => resumeSessionImpl(happySessionId, options));
+      } finally {
+        if (!gate.inFlight()) resumeGates.delete(happySessionId);
+      }
+    };
+    const resumeSessionImpl = async (happySessionId, options) => {
       try {
+        for (const [pid, live] of pidToTrackedSession.entries()) {
+          if (live.happySessionId !== happySessionId) continue;
+          if (isPidAlive(pid)) {
+            logger.debug(`[DAEMON RUN] resume ${happySessionId}: process ${pid} already alive \u2014 idempotent success`);
+            return { type: "success", sessionId: happySessionId };
+          }
+          onChildExited(pid);
+        }
         const tracked = findTrackedSessionById(happySessionId);
         if (!tracked) {
-          return { type: "error", errorMessage: `Session ${happySessionId} is not tracked by this daemon. It may have been started before the daemon or on another machine.` };
+          return { type: "error", errorMessage: `resume-precheck:not-tracked: Session ${happySessionId} is not tracked by this daemon. It may have been started before the daemon, more than 14 days ago, or on another machine.` };
         }
         if (!tracked.happySessionMetadataFromLocalWebhook) {
-          return { type: "error", errorMessage: `Session ${happySessionId} has no metadata. Cannot resume.` };
+          return { type: "error", errorMessage: `resume-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot resume.` };
         }
         if (!tracked.encryption) {
-          return { type: "error", errorMessage: `Session ${happySessionId} has no stored encryption data. It was likely started before this feature was available. Restart the daemon and start a new session to enable resume.` };
+          return { type: "error", errorMessage: `resume-precheck:no-encryption: Session ${happySessionId} has no stored encryption data. It was likely started before this feature was available. Restart the daemon and start a new session to enable resume.` };
         }
         let metadata = tracked.happySessionMetadataFromLocalWebhook;
         const needsFetch = !metadata.claudeSessionId && (!metadata.flavor || metadata.flavor === "claude") || !metadata.codexThreadId && metadata.flavor === "codex";
@@ -7597,18 +7731,24 @@ async function startDaemon() {
             tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
           }
         }
+        const precheck = resumePrecheck(metadata, {
+          cwdExists: (p) => existsSync$1(p),
+          conversationExists: (cwd, claudeSessionId) => existsSync$1(join$1(getProjectPath(cwd), `${claudeSessionId}.jsonl`))
+        });
+        if (!precheck.ok) {
+          return { type: "error", errorMessage: `resume-precheck:${precheck.reason}: ${precheck.detail}` };
+        }
         const launch = buildResumeLaunch(
           { id: happySessionId, active: true, metadata },
           { startedBy: "daemon", claudeStartingMode: "remote" }
         );
-        if (options?.model) {
-          launch.args.push("--model", options.model);
-        }
-        if (options?.permissionMode) {
-          launch.args.push("--permission-mode", options.permissionMode);
-        }
-        await fs.access(launch.cwd);
-        return spawnTrackedHappyProcess({
+        const model = sanitizeResumeModel(options?.model);
+        if (model) launch.args.push("--model", model);
+        else if (options?.model !== void 0) logger.debug(`[DAEMON RUN] resume: ignoring invalid model ${JSON.stringify(options.model)}`);
+        const permissionMode = sanitizeSpawnPermissionMode(options?.permissionMode);
+        if (permissionMode) launch.args.push("--permission-mode", permissionMode);
+        else if (options?.permissionMode !== void 0) logger.debug(`[DAEMON RUN] resume: ignoring invalid permission mode ${JSON.stringify(options.permissionMode)}`);
+        const result = await spawnTrackedHappyProcess({
           args: launch.args,
           cwd: launch.cwd,
           env: {
@@ -7621,6 +7761,18 @@ async function startDaemon() {
             HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
           }
         });
+        if (result.type === "success") {
+          persistSession(happySessionId, {
+            encryptionKey: encodeBase64(tracked.encryption.encryptionKey),
+            encryptionVariant: tracked.encryption.encryptionVariant,
+            seq: tracked.encryption.seq,
+            metadataVersion: tracked.encryption.metadataVersion,
+            agentStateVersion: tracked.encryption.agentStateVersion,
+            metadata,
+            savedAt: Date.now()
+          });
+        }
+        return result;
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : error && typeof error === "object" ? JSON.stringify(error) : String(error);
         logger.debug(`[DAEMON RUN] Failed to resume session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
@@ -7630,6 +7782,136 @@ async function startDaemon() {
         };
       }
     };
+    const restartCounts = /* @__PURE__ */ new Map();
+    const stopSessionAndWait = (happySessionId, timeoutMs = 8e3) => {
+      let targetPid = null;
+      for (const [pid2, s] of pidToTrackedSession.entries()) {
+        if (s.happySessionId === happySessionId && isPidAlive(pid2)) {
+          targetPid = pid2;
+          break;
+        }
+      }
+      if (targetPid === null) return Promise.resolve();
+      const pid = targetPid;
+      return new Promise((resolve) => {
+        let settled = false;
+        const done = () => {
+          if (!settled) {
+            settled = true;
+            resolve();
+          }
+        };
+        const requested = terminateProcess(pid, () => {
+          const tracked = pidToTrackedSession.get(pid);
+          if (tracked) {
+            if (tracked.happySessionId && tracked.encryption) {
+              sessionIdToFinishedSession.set(tracked.happySessionId, tracked);
+            }
+            pidToTrackedSession.delete(pid);
+          }
+          done();
+        });
+        if (!requested) done();
+        setTimeout(done, timeoutMs).unref?.();
+      });
+    };
+    const restartSession = async (happySessionId, options) => {
+      let gate = resumeGates.get(happySessionId);
+      if (!gate) {
+        gate = createSpawnGate();
+        resumeGates.set(happySessionId, gate);
+      }
+      try {
+        return await gate.replace(() => restartSessionImpl(happySessionId, options));
+      } finally {
+        if (!gate.inFlight()) resumeGates.delete(happySessionId);
+      }
+    };
+    const restartSessionImpl = async (happySessionId, options) => {
+      try {
+        const prior = restartCounts.get(happySessionId) ?? 0;
+        const decision = decideRestart(prior, DEFAULT_MAX_RESTARTS);
+        if (!decision.allowed) {
+          return { type: "error", errorMessage: `restart:${decision.reason}` };
+        }
+        await stopSessionAndWait(happySessionId);
+        const tracked = findTrackedSessionById(happySessionId);
+        if (!tracked) {
+          return { type: "error", errorMessage: `restart-precheck:not-tracked: Session ${happySessionId} is not tracked by this daemon.` };
+        }
+        if (!tracked.happySessionMetadataFromLocalWebhook) {
+          return { type: "error", errorMessage: `restart-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot restart.` };
+        }
+        if (!tracked.encryption) {
+          return { type: "error", errorMessage: `restart-precheck:no-encryption: Session ${happySessionId} has no stored encryption data. Restart the daemon and start a new session.` };
+        }
+        let metadata = tracked.happySessionMetadataFromLocalWebhook;
+        const needsFetch = !metadata.claudeSessionId && (!metadata.flavor || metadata.flavor === "claude") || !metadata.codexThreadId && metadata.flavor === "codex";
+        if (needsFetch) {
+          const serverMetadata = await fetchServerSessionMetadata(happySessionId, tracked.encryption.encryptionKey, tracked.encryption.encryptionVariant);
+          if (serverMetadata) {
+            metadata = serverMetadata;
+            tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
+          }
+        }
+        const precheck = resumePrecheck(metadata, {
+          cwdExists: (p) => existsSync$1(p),
+          conversationExists: (cwd2, claudeSessionId) => existsSync$1(join$1(getProjectPath(cwd2), `${claudeSessionId}.jsonl`))
+        });
+        let args;
+        let cwd;
+        if (precheck.ok) {
+          const launch = buildResumeLaunch(
+            { id: happySessionId, active: true, metadata },
+            { startedBy: "daemon", claudeStartingMode: "remote" }
+          );
+          args = launch.args;
+          cwd = launch.cwd;
+        } else if ((metadata.flavor ?? "claude") === "claude" && typeof metadata.path === "string" && metadata.path.length > 0) {
+          cwd = metadata.path;
+          if (!existsSync$1(cwd)) {
+            return { type: "error", errorMessage: `restart-precheck:cwd-missing: ${cwd}` };
+          }
+          args = ["claude", "--happy-starting-mode", "remote", "--started-by", "daemon"];
+        } else {
+          return { type: "error", errorMessage: `restart-precheck:${precheck.ok ? "unknown" : precheck.reason}: ${precheck.ok ? "" : precheck.detail}` };
+        }
+        const model = sanitizeResumeModel(options?.model);
+        if (model) args.push("--model", model);
+        const permissionMode = sanitizeSpawnPermissionMode(options?.permissionMode);
+        if (permissionMode) args.push("--permission-mode", permissionMode);
+        restartCounts.set(happySessionId, recordRestartAttempt(prior));
+        const result = await spawnTrackedHappyProcess({
+          args,
+          cwd,
+          env: {
+            ...process.env,
+            HAPPY_RECONNECT_SESSION_ID: happySessionId,
+            HAPPY_RECONNECT_ENCRYPTION_KEY: encodeBase64(tracked.encryption.encryptionKey),
+            HAPPY_RECONNECT_ENCRYPTION_VARIANT: tracked.encryption.encryptionVariant,
+            HAPPY_RECONNECT_SEQ: String(tracked.encryption.seq),
+            HAPPY_RECONNECT_METADATA_VERSION: String(tracked.encryption.metadataVersion),
+            HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
+          }
+        });
+        if (result.type === "success") {
+          persistSession(happySessionId, {
+            encryptionKey: encodeBase64(tracked.encryption.encryptionKey),
+            encryptionVariant: tracked.encryption.encryptionVariant,
+            seq: tracked.encryption.seq,
+            metadataVersion: tracked.encryption.metadataVersion,
+            agentStateVersion: tracked.encryption.agentStateVersion,
+            metadata,
+            savedAt: Date.now()
+          });
+        }
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.debug(`[DAEMON RUN] Failed to restart session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
+        return { type: "error", errorMessage: `Failed to restart session: ${errorMessage}` };
+      }
+    };
     const stopSession = (sessionId) => {
       logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
       for (const [pid, session] of pidToTrackedSession.entries()) {
@@ -7800,6 +8082,7 @@ async function startDaemon() {
     apiMachine.setRPCHandlers({
       spawnSession,
       resumeSession,
+      restartSession,
       stopSession,
       listTrackedSessionIds: () => [...pidToTrackedSession.values()].map((session) => session.happySessionId).filter((sessionId) => typeof sessionId === "string"),
       requestShutdown: () => requestShutdown("happy-app")
@@ -9391,6 +9674,18 @@ async function runClaude(credentials, options = {}) {
   if (reconnectSessionId && !await api.reactivateSession(response.id)) {
     throw new Error(`Failed to reactivate archived session ${response.id}`);
   }
+  let reconnectSeeded = false;
+  if (reconnectSessionId) {
+    const snapshot = await api.getSession(response.id, response.encryptionKey, response.encryptionVariant);
+    if (snapshot.ok) {
+      response = applyServerSnapshot(response, snapshot.session);
+      reconnectSeeded = true;
+      logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+    } else {
+      response = withoutServerSnapshot(response);
+      logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
+    }
+  }
   try {
     logger.debug(`[START] Reporting session ${response.id} to daemon`);
     const result = await notifyDaemonSessionStarted(response.id, metadata, {
@@ -9408,14 +9703,12 @@ async function runClaude(credentials, options = {}) {
   } catch (error) {
     logger.debug("[START] Failed to report to daemon (may not be running):", error);
   }
-  const session = api.sessionSyncClient(response);
+  const session = api.sessionSyncClient(response, reconnectSeeded ? { initialSeq: response.seq } : void 0);
   if (reconnectSessionId) {
     session.suppressNextArchiveSignal();
-    session.skipExistingMessages();
+    if (!reconnectSeeded) session.skipExistingMessages();
     session.updateMetadata((meta) => ({
-      ...meta,
-      lifecycleState: "running",
-      archivedBy: void 0,
+      ...mergeReconnectMetadata(meta, metadata, Date.now()),
       queueCancellation: true,
       // B-262 batch 2 (B5): a reconnected process re-publishes the mode
       // IT enforces; the server copy may still carry the previous
@@ -12126,7 +12419,7 @@ function setupOfflineReconnection(opts) {
     });
     return { session, reconnectionHandle, isOffline: true };
   } else {
-    session = api.sessionSyncClient(response);
+    session = api.sessionSyncClient(response, opts.sessionClientOptions);
     return { session, reconnectionHandle: null, isOffline: false };
   }
 }
@@ -12895,6 +13188,18 @@ async function runCodex(opts) {
   if (reconnectSessionId && response && !await api.reactivateSession(response.id)) {
     throw new Error(`Failed to reactivate archived session ${response.id}`);
   }
+  let reconnectSeeded = false;
+  if (reconnectSessionId && response) {
+    const snapshot = await api.getSession(response.id, response.encryptionKey, response.encryptionVariant);
+    if (snapshot.ok) {
+      response = applyServerSnapshot(response, snapshot.session);
+      reconnectSeeded = true;
+      logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+    } else {
+      response = withoutServerSnapshot(response);
+      logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
+    }
+  }
   let session;
   let permissionHandler;
   let client;
@@ -12906,6 +13211,7 @@ async function runCodex(opts) {
     metadata,
     state,
     response,
+    sessionClientOptions: reconnectSeeded && response ? { initialSeq: response.seq } : void 0,
     onSessionSwap: (newSession) => {
       session = newSession;
       if (permissionHandler) {
@@ -12916,12 +13222,8 @@ async function runCodex(opts) {
   session = initialSession;
   if (reconnectSessionId) {
     session.suppressNextArchiveSignal();
-    session.skipExistingMessages();
-    session.updateMetadata((meta) => ({
-      ...meta,
-      lifecycleState: "running",
-      archivedBy: void 0
-    }));
+    if (!reconnectSeeded) session.skipExistingMessages();
+    session.updateMetadata((meta) => mergeReconnectMetadata(meta, metadata, Date.now()));
   }
   if (response) {
     try {
@@ -13649,7 +13951,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-TkkGzzbI.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-DsECLFy3.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -13666,7 +13968,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-CRW4ioms.mjs');
+      const { handleSpawnCommand } = await import('./spawn-DgZUVvT2.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13678,7 +13980,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-9nJxn09Y.mjs');
+      const { handleSendCommand } = await import('./send-DlHES1EO.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13784,9 +14086,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await import('./config-ra8iKxdU.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-BKyjG23_.mjs').then(function (n) { return n.ak; });
-        const { ApiClient: ApiClient2 } = await import('./types-BKyjG23_.mjs').then(function (n) { return n.al; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-BJjvra5x.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-Cx5wn5Hf.mjs').then(function (n) { return n.al; });
+        const { ApiClient: ApiClient2 } = await import('./types-Cx5wn5Hf.mjs').then(function (n) { return n.am; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -13817,7 +14119,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await import('./config-ra8iKxdU.mjs');
+        const { readGeminiLocalConfig } = await import('./config-BJjvra5x.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -13857,7 +14159,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-BbC0uwUj.mjs');
+      const { runGemini } = await import('./runGemini-CrSCxKqI.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -13879,7 +14181,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-CB5H7YI6.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-D-U-7DAy.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -13919,7 +14221,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw--nbqTW3K.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-Cnagj-hv.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -13970,7 +14272,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await import('./mcp-C3MiqObi.mjs');
+      const { handleMcpCommand } = await import('./mcp-Bs6R9P7q.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}