very-happy-cli 0.2.91 → 0.2.93

package/dist/{index-CB5H7YI6.mjs → index-D-U-7DAy.mjs}

@@ -1,10 +1,10 @@
-import { D as DefaultTransport, A as AcpBackend } from './AcpBackend-B5RRlzLU.mjs';
-export { a as DEFAULT_IDLE_TIMEOUT_MS, b as DEFAULT_TOOL_CALL_TIMEOUT_MS, e as extractErrorDetail, f as formatDuration, c as formatDurationMinutes, h as handleAgentMessageChunk, d as handleAgentThoughtChunk, g as handleLegacyMessageChunk, i as handlePlanUpdate, j as handleThinkingUpdate, k as handleToolCall, l as handleToolCallUpdate, p as parseArgsFromContent } from './AcpBackend-B5RRlzLU.mjs';
-import { h as connectionState, A as ApiClient, i as readSettings, j as encodeBase64, l as logger, p as projectPath } from './types-BKyjG23_.mjs';
-import { A as AcpSessionManager } from './AcpSessionManager-Ij1pI5Ex.mjs';
+import { D as DefaultTransport, A as AcpBackend } from './AcpBackend-C5507ePk.mjs';
+export { a as DEFAULT_IDLE_TIMEOUT_MS, b as DEFAULT_TOOL_CALL_TIMEOUT_MS, e as extractErrorDetail, f as formatDuration, c as formatDurationMinutes, h as handleAgentMessageChunk, d as handleAgentThoughtChunk, g as handleLegacyMessageChunk, i as handlePlanUpdate, j as handleThinkingUpdate, k as handleToolCall, l as handleToolCallUpdate, p as parseArgsFromContent } from './AcpBackend-C5507ePk.mjs';
+import { h as connectionState, A as ApiClient, i as readSettings, j as encodeBase64, l as logger, p as projectPath } from './types-Cx5wn5Hf.mjs';
+import { A as AcpSessionManager } from './AcpSessionManager-Bd1trXWx.mjs';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { i as initialMachineMetadata, d as createSessionMetadata, e as setupOfflineReconnection, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, f as startHappyServer, r as registerKillSessionHandler, B as BasePermissionHandler } from './index-UCYD5Wk3.mjs';
+import { i as initialMachineMetadata, d as createSessionMetadata, e as setupOfflineReconnection, n as notifyDaemonSessionStarted, M as MessageQueue2, h as hashObject, f as startHappyServer, r as registerKillSessionHandler, B as BasePermissionHandler } from './index-C00jxV83.mjs';
 import 'node:child_process';
 import '@agentclientprotocol/sdk';
 import 'axios';

package/dist/{index-FkXJNwiy.cjs → index-DaVhaBF2.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-ClDADuxP.cjs');
+var persistence = require('./types-BHVxYajT.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
@@ -46,24 +46,74 @@ var promises$1 = require('node:readline/promises');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
         });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
+    }
+    n.default = e;
+    return Object.freeze(n);
 }
 
 var tmp__namespace = /*#__PURE__*/_interopNamespaceDefault(tmp);
 
+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",
@@ -1570,6 +1620,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;
@@ -5315,6 +5368,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 (!persistence.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 node_crypto.randomBytes(CONTROL_TOKEN_BYTES).toString("base64url");
@@ -7132,6 +7224,7 @@ async function startDaemon() {
         tracked.pid = livePid;
         tracked.startedBy = "recovered after daemon restart";
         pidToTrackedSession.set(livePid, tracked);
+        persistence.persistSession(id, { ...s, savedAt: Date.now() });
       } else {
         sessionIdToFinishedSession.set(id, tracked);
       }
@@ -7560,6 +7653,13 @@ async function startDaemon() {
         const timeout = setTimeout(() => {
           pidToAwaiter.delete(happyProcess.pid);
           persistence.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}`
@@ -7582,6 +7682,19 @@ async function startDaemon() {
       return sessionIdToFinishedSession.get(happySessionId);
     };
     const fetchServerSessionMetadata = async (sessionId, encryptionKey, encryptionVariant) => {
+      try {
+        const byId = await axios.get(`${persistence.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 persistence.decrypt(encryptionKey, encryptionVariant, persistence.decodeBase64(row.metadata));
+        }
+      } catch (error) {
+        persistence.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(`${persistence.configuration.serverUrl}/v1/sessions`, {
           headers: { Authorization: `Bearer ${credentials.token}` },
@@ -7597,17 +7710,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)) {
+            persistence.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";
@@ -7619,18 +7753,24 @@ async function startDaemon() {
             tracked.happySessionMetadataFromLocalWebhook = serverMetadata;
           }
         }
+        const precheck = resumePrecheck(metadata, {
+          cwdExists: (p) => fs$1.existsSync(p),
+          conversationExists: (cwd, claudeSessionId) => fs$1.existsSync(path$1.join(persistence.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) persistence.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) persistence.logger.debug(`[DAEMON RUN] resume: ignoring invalid permission mode ${JSON.stringify(options.permissionMode)}`);
+        const result = await spawnTrackedHappyProcess({
           args: launch.args,
           cwd: launch.cwd,
           env: {
@@ -7643,6 +7783,18 @@ async function startDaemon() {
             HAPPY_RECONNECT_AGENT_STATE_VERSION: String(tracked.encryption.agentStateVersion)
           }
         });
+        if (result.type === "success") {
+          persistence.persistSession(happySessionId, {
+            encryptionKey: persistence.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);
         persistence.logger.debug(`[DAEMON RUN] Failed to resume session: ${errorMessage}`, error instanceof Error ? error.stack : void 0);
@@ -7652,6 +7804,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) => fs$1.existsSync(p),
+          conversationExists: (cwd2, claudeSessionId) => fs$1.existsSync(path$1.join(persistence.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 (!fs$1.existsSync(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: persistence.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") {
+          persistence.persistSession(happySessionId, {
+            encryptionKey: persistence.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);
+        persistence.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) => {
       persistence.logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
       for (const [pid, session] of pidToTrackedSession.entries()) {
@@ -7822,6 +8104,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")
@@ -8873,7 +9156,7 @@ const MAX_TITLE_CHARS = 60;
 const GENERATION_TIMEOUT_MS = 3e4;
 function resolveClaudeBinary() {
   try {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-FkXJNwiy.cjs', document.baseURI).href)));
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DaVhaBF2.cjs', document.baseURI).href)));
     const utilsPath = path.resolve(path.join(persistence.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
@@ -9413,6 +9696,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;
+      persistence.logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+    } else {
+      response = withoutServerSnapshot(response);
+      persistence.logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
+    }
+  }
   try {
     persistence.logger.debug(`[START] Reporting session ${response.id} to daemon`);
     const result = await notifyDaemonSessionStarted(response.id, metadata, {
@@ -9430,14 +9725,12 @@ async function runClaude(credentials, options = {}) {
   } catch (error) {
     persistence.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
@@ -11057,9 +11350,9 @@ function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, gene
   };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-FkXJNwiy.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DaVhaBF2.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-FkXJNwiy.cjs', document.baseURI).href)));
+const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DaVhaBF2.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -12148,7 +12441,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 };
   }
 }
@@ -12917,6 +13210,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;
+      persistence.logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+    } else {
+      response = withoutServerSnapshot(response);
+      persistence.logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
+    }
+  }
   let session;
   let permissionHandler;
   let client;
@@ -12928,6 +13233,7 @@ async function runCodex(opts) {
     metadata,
     state,
     response,
+    sessionClientOptions: reconnectSeeded && response ? { initialSeq: response.seq } : void 0,
     onSessionSwap: (newSession) => {
       session = newSession;
       if (permissionHandler) {
@@ -12938,12 +13244,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 {
@@ -13671,7 +13973,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 Promise.resolve().then(function () { return require('./installTerminalHooks-CoK5wNcA.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-CRjlRj9K.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -13688,7 +13990,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-DE7WhS8Y.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-OE9kENQi.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13700,7 +14002,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-DkKOPatx.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-PmtzSBVM.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13806,9 +14108,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 Promise.resolve().then(function () { return require('./config-C4NCw7Dz.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-ClDADuxP.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-ClDADuxP.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-SZEQWS8k.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-BHVxYajT.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-BHVxYajT.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -13839,7 +14141,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 Promise.resolve().then(function () { return require('./config-C4NCw7Dz.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-SZEQWS8k.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -13879,7 +14181,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-Dnvd2gWq.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-DapsCPLi.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -13901,7 +14203,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 Promise.resolve().then(function () { return require('./index-C1HIm7NY.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-17NbIAkU.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -13941,7 +14243,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-CnuTBNQW.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-C9dhyV4x.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -13992,7 +14294,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 Promise.resolve().then(function () { return require('./mcp-DcRvswVI.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-C-dDCrXm.cjs'); });
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}

package/dist/index.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
 require('chalk');
-require('./index-FkXJNwiy.cjs');
-require('./types-ClDADuxP.cjs');
+require('./index-DaVhaBF2.cjs');
+require('./types-BHVxYajT.cjs');
 require('zod');
 require('node:child_process');
 require('node:os');

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import 'chalk';
-import './index-UCYD5Wk3.mjs';
-import './types-BKyjG23_.mjs';
+import './index-C00jxV83.mjs';
+import './types-Cx5wn5Hf.mjs';
 import 'zod';
 import 'node:child_process';
 import 'node:os';