very-happy-cli 0.2.90 → 0.2.92

package/dist/{index-an09rejO.mjs → index-8LDXVYWi.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-DS3i_5LV.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-B_8X_rZk.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;
@@ -1633,6 +1686,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();
@@ -1962,7 +2021,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) {
@@ -1980,6 +2044,10 @@ async function claudeRemote(opts) {
       if (message.type === "result") {
         updateThinking(false);
         logger.debug("[claudeRemote] Result received");
+        const denials = message.permission_denials;
+        if (denials && denials.length > 0) {
+          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";
           logger.debug(`[claudeRemote] Compaction ${compactSucceeded ? "completed" : "failed"}`);
@@ -2190,16 +2258,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) => {
@@ -2540,6 +2601,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) {
   logger.debugLargeJson("[CLAUDE INK] Message from remote mode:", message);
   switch (message.type) {
@@ -2794,7 +2866,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) {
@@ -3305,7 +3383,7 @@ function createTurnSteeringController() {
   };
 }
 
-async function claudeRemoteLauncher(session, onPermissionModeChange) {
+async function claudeRemoteLauncher(session, onPermissionModeChange, onEffectivePermissionMode) {
   logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
@@ -3539,6 +3617,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;
       };
@@ -3611,6 +3693,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);
@@ -3788,7 +3871,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;
@@ -5263,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");
@@ -7080,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);
       }
@@ -7508,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}`
@@ -7530,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}` },
@@ -7545,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";
@@ -7567,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: {
@@ -7591,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);
@@ -7600,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()) {
@@ -7770,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")
@@ -9361,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, {
@@ -9378,15 +9703,17 @@ 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,
-      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;
@@ -9526,6 +9853,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) {
+      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;
@@ -9570,7 +9913,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) {
+      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,
@@ -9834,9 +10181,11 @@ async function runClaude(credentials, options = {}) {
     },
     onAbort: resetCurrentModeDefaults,
     onPermissionModeChange: (mode) => {
+      lastExplicitModeSwitchAt = Date.now();
       publishPermissionMode(mode);
       logger.debug(`[loop] Permission mode updated from session RPC / approval to: ${mode}`);
     },
+    onEffectivePermissionMode: (mode) => publishEffectivePermissionMode(mode),
     mcpServers: {
       "happy": {
         type: "http",
@@ -12070,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 };
   }
 }
@@ -12839,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;
@@ -12850,6 +13211,7 @@ async function runCodex(opts) {
     metadata,
     state,
     response,
+    sessionClientOptions: reconnectSeeded && response ? { initialSeq: response.seq } : void 0,
     onSessionSwap: (newSession) => {
       session = newSession;
       if (permissionHandler) {
@@ -12860,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 {
@@ -13593,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-C-OgZr5k.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-DDRrUG_n.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -13610,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-JxaPHAoP.mjs');
+      const { handleSpawnCommand } = await import('./spawn-DS-Uz_Hw.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13622,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-BHliX59m.mjs');
+      const { handleSendCommand } = await import('./send-BQSaVz9r.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -13728,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-BEdyyciP.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-DS3i_5LV.mjs').then(function (n) { return n.ak; });
-        const { ApiClient: ApiClient2 } = await import('./types-DS3i_5LV.mjs').then(function (n) { return n.al; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-CJQw0z1o.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./types-B_8X_rZk.mjs').then(function (n) { return n.al; });
+        const { ApiClient: ApiClient2 } = await import('./types-B_8X_rZk.mjs').then(function (n) { return n.am; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -13761,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-BEdyyciP.mjs');
+        const { readGeminiLocalConfig } = await import('./config-CJQw0z1o.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -13801,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-DBr_TiTL.mjs');
+      const { runGemini } = await import('./runGemini-DHYs_Beq.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -13823,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-Dfu5uvjk.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BP9pfzdZ.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -13863,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-Cbde8t92.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-DTaXxvNd.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -13914,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-Du-N0qlK.mjs');
+      const { handleMcpCommand } = await import('./mcp-CYJAl5pk.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}