very-happy-cli 0.2.90 → 0.2.92

package/dist/{index-4YmVbx7j.cjs → index-B63Vjt4W.cjs}

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-BNGeiP1C.cjs');
+var persistence = require('./types-CjlB_fKT.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;
@@ -1655,6 +1708,12 @@ function resolveRemoteClaudePermissionMode(currentMode, incomingMode, sandboxEna
   }
   return nextMode;
 }
+function reconcilePublishedPermissionMode(input) {
+  if (!input.effective) return null;
+  const mismatch = input.effective !== input.intent;
+  if (input.effective === input.published) return mismatch ? { publish: input.effective, mismatch } : null;
+  return { publish: input.effective, mismatch };
+}
 
 function parseCompact(message) {
   const trimmed = message.trim();
@@ -1984,7 +2043,12 @@ async function claudeRemote(opts) {
             mcpServers: systemInit.mcp_servers?.map((s) => ({ name: s.name, status: s.status })),
             skills: systemInit.skills,
             model: systemInit.model,
-            modelIsDefault: initial.mode.model == null
+            modelIsDefault: initial.mode.model == null,
+            // The SDK's own verdict on the mode it will enforce —
+            // settings (permissions.deny/ask/defaultMode/
+            // disableBypassPermissionsMode) can override what we
+            // asked for. runClaude publishes THIS, not our intent.
+            permissionMode: systemInit.permissionMode
           });
         }
         if (systemInit.session_id) {
@@ -2002,6 +2066,10 @@ async function claudeRemote(opts) {
       if (message.type === "result") {
         updateThinking(false);
         persistence.logger.debug("[claudeRemote] Result received");
+        const denials = message.permission_denials;
+        if (denials && denials.length > 0) {
+          persistence.logger.warn(`[claudeRemote] ${denials.length} tool call(s) auto-denied by Claude Code policy: ${denials.map((d) => d.tool_name ?? "?").join(", ")}`);
+        }
         if (isCompactCommand) {
           const compactSucceeded = message.subtype === "success";
           persistence.logger.debug(`[claudeRemote] Compaction ${compactSucceeded ? "completed" : "failed"}`);
@@ -2212,16 +2280,9 @@ class PermissionHandler {
       }
     } else {
       if (response.approved && response.mode) {
-        try {
-          if (!this.setPermissionModeCallback) throw new Error("permission mode updater unavailable");
-          await this.setPermissionModeCallback(response.mode);
-          this.permissionMode = response.mode;
-          this.onModeChangedCallback?.(response.mode);
-        } catch (err) {
-          const reason = `Failed to switch permission mode: ${err instanceof Error ? err.message : String(err)}`;
-          pending.resolve({ behavior: "deny", message: reason });
-          return { ...response, approved: false, reason };
-        }
+        this.permissionMode = response.mode;
+        this.deferredPermissionMode = response.mode;
+        this.onModeChangedCallback?.(response.mode);
       }
       if (response.approved && !pending.suggestions?.length && response.allowTools?.length) {
         response.allowTools.forEach((tool) => {
@@ -2562,6 +2623,17 @@ class PermissionHandler {
   }
 }
 
+function rewriteQueuedPermissionMode(queue, hasher, permissionMode) {
+  let rewritten = 0;
+  for (const item of queue) {
+    if (item.mode.permissionMode === permissionMode) continue;
+    item.mode = { ...item.mode, permissionMode };
+    item.modeHash = hasher(item.mode);
+    rewritten += 1;
+  }
+  return rewritten;
+}
+
 function formatClaudeMessageForInk(message, messageBuffer, onAssistantResult) {
   persistence.logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
   switch (message.type) {
@@ -2816,7 +2888,13 @@ class SDKToLogConverter {
           type: "user",
           message: userMsg.message,
           ...userMsg.parent_tool_use_id ? { parent_tool_use_id: userMsg.parent_tool_use_id } : {},
-          ...meta ? { isMeta: true } : {}
+          ...meta ? { isMeta: true } : {},
+          // B-260-P2: structured tool output (Agent/Task final report +
+          // run totals, or the `async_launched` stub marker) and the
+          // message origin (task-notification). Both are consumed by
+          // sessionProtocolMapper; the raw-line schema is passthrough.
+          ...userMsg.tool_use_result !== void 0 ? { tool_use_result: userMsg.tool_use_result } : {},
+          ...userMsg.origin ? { origin: userMsg.origin } : {}
         };
         if (Array.isArray(userMsg.message.content)) {
           for (const content of userMsg.message.content) {
@@ -3327,7 +3405,7 @@ function createTurnSteeringController() {
   };
 }
 
-async function claudeRemoteLauncher(session, onPermissionModeChange) {
+async function claudeRemoteLauncher(session, onPermissionModeChange, onEffectivePermissionMode) {
   persistence.logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   persistence.logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
@@ -3561,6 +3639,10 @@ async function claudeRemoteLauncher(session, onPermissionModeChange) {
           mode = { ...mode, permissionMode: nextMode };
           modeHash = session.queue.modeHasher(mode);
         }
+        rewriteQueuedPermissionMode(session.queue.queue, session.queue.modeHasher, nextMode);
+        if (pending) {
+          pending = { ...pending, mode: { ...pending.mode, permissionMode: nextMode } };
+        }
         onPermissionModeChange?.(nextMode);
         return nextMode;
       };
@@ -3633,6 +3715,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange) {
               skillCount: metadata.skills?.length ?? 0
             });
             session.client.updateMetadata((currentMetadata) => applyClaudeSdkMetadata(currentMetadata, metadata));
+            if (metadata.permissionMode) onEffectivePermissionMode?.(metadata.permissionMode);
           },
           onQueryReady: (q) => {
             turnSteering.setInterrupt(q.interrupt);
@@ -3810,7 +3893,7 @@ async function loop(opts) {
         break;
       }
       case "remote": {
-        const reason = await claudeRemoteLauncher(session, opts.onPermissionModeChange);
+        const reason = await claudeRemoteLauncher(session, opts.onPermissionModeChange, opts.onEffectivePermissionMode);
         switch (reason) {
           case "exit":
             return 0;
@@ -5285,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");
@@ -7102,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);
       }
@@ -7530,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}`
@@ -7552,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}` },
@@ -7567,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";
@@ -7589,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: {
@@ -7613,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);
@@ -7622,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()) {
@@ -7792,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")
@@ -8843,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-4YmVbx7j.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-B63Vjt4W.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();
@@ -9383,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, {
@@ -9400,15 +9725,17 @@ 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,
-      queueCancellation: true
+      ...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
+      // process's value.
+      permissionMode: mapToClaudeMode(initialPermissionMode ?? "default")
     }));
   }
   const forkClaudeSessionId = process.env.HAPPY_FORK_CLAUDE_SESSION_ID;
@@ -9548,6 +9875,22 @@ async function runClaude(credentials, options = {}) {
     publishedPermissionMode = published;
     session.updateMetadata((meta) => ({ ...meta, permissionMode: published }));
   };
+  const publishEffectivePermissionMode = (effective) => {
+    const decision = reconcilePublishedPermissionMode({
+      intent: mapToClaudeMode(currentPermissionMode ?? "default"),
+      published: publishedPermissionMode,
+      effective
+    });
+    if (!decision) return;
+    if (decision.mismatch) {
+      persistence.logger.warn(`[loop] Claude Code enforces permission mode '${effective}' but this process asked for '${mapToClaudeMode(currentPermissionMode ?? "default")}' \u2014 check ~/.claude settings (permissions.deny/ask/defaultMode/disableBypassPermissionsMode). Publishing the effective mode.`);
+    }
+    if (decision.publish !== publishedPermissionMode) {
+      publishedPermissionMode = decision.publish;
+      session.updateMetadata((meta) => ({ ...meta, permissionMode: decision.publish }));
+    }
+  };
+  let lastExplicitModeSwitchAt = 0;
   let currentModel = options.model ?? DEFAULT_CLAUDE_MODEL;
   let currentFallbackModel = void 0;
   let currentCustomSystemPrompt = void 0;
@@ -9592,7 +9935,11 @@ async function runClaude(credentials, options = {}) {
     }
     const attachmentsForThisMessage = await session.drainAttachmentsForUserMessage();
     let messagePermissionMode = currentPermissionMode;
-    if (message.meta?.permissionMode) {
+    const messageCreatedAt = message.createdAt;
+    const staleModeSnapshot = message.meta?.permissionMode !== void 0 && typeof messageCreatedAt === "number" && messageCreatedAt < lastExplicitModeSwitchAt;
+    if (staleModeSnapshot) {
+      persistence.logger.debug(`[loop] Ignoring stale meta.permissionMode=${message.meta?.permissionMode} (message ${messageCreatedAt} predates explicit switch ${lastExplicitModeSwitchAt}); keeping ${currentPermissionMode}`);
+    } else if (message.meta?.permissionMode) {
       const previousPermissionMode = currentPermissionMode;
       messagePermissionMode = resolveRemoteClaudePermissionMode(
         currentPermissionMode,
@@ -9856,9 +10203,11 @@ async function runClaude(credentials, options = {}) {
     },
     onAbort: resetCurrentModeDefaults,
     onPermissionModeChange: (mode) => {
+      lastExplicitModeSwitchAt = Date.now();
       publishPermissionMode(mode);
       persistence.logger.debug(`[loop] Permission mode updated from session RPC / approval to: ${mode}`);
     },
+    onEffectivePermissionMode: (mode) => publishEffectivePermissionMode(mode),
     mcpServers: {
       "happy": {
         type: "http",
@@ -11001,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-4YmVbx7j.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-B63Vjt4W.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-4YmVbx7j.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-B63Vjt4W.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -12092,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 };
   }
 }
@@ -12861,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;
@@ -12872,6 +13233,7 @@ async function runCodex(opts) {
     metadata,
     state,
     response,
+    sessionClientOptions: reconnectSeeded && response ? { initialSeq: response.seq } : void 0,
     onSessionSwap: (newSession) => {
       session = newSession;
       if (permissionHandler) {
@@ -12882,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 {
@@ -13615,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-DDpVxk8-.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-BBc2nij4.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -13632,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-CH1Rq-LW.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-CK1ma_qc.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13644,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-Bjen1TUE.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-BEdGwmA-.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13750,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-CgXitj0f.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-BNGeiP1C.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-BNGeiP1C.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-B77vhdwT.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-CjlB_fKT.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CjlB_fKT.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -13783,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-CgXitj0f.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-B77vhdwT.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -13823,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-ChG7cGMC.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BDSWSID6.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -13845,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-B1wTVXjt.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-L3o5Gz-2.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -13885,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-D2jtVgpC.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-DC9gb1bd.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -13936,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-B6Nq-RUL.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-DbYXyw1U.cjs'); });
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}