very-happy-cli 0.2.93 → 0.2.95

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

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

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

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

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

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

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

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

package/dist/{config-BJjvra5x.mjs → config-2GD21yg_.mjs}

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

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

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

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

@@ -3,7 +3,7 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var persistence = require('./types-BHVxYajT.cjs');
+var persistence = require('./types-HRuZ13LS.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
@@ -6788,10 +6788,20 @@ function createMirrorScanner(opts) {
 }
 
 const TERMINAL_MIRROR_FLAVOR = "terminal-mirror";
+const RECONCILE_HYSTERESIS_MS = 2e4;
 function createMirrorManager(deps) {
   const backfillLines = deps.backfillLines ?? persistence.MIRROR_BACKFILL_LINES_DEFAULT;
   const bindings = /* @__PURE__ */ new Map();
+  const lastEndedAt = /* @__PURE__ */ new Map();
   let chain = Promise.resolve();
+  const reactivate = async (binding) => {
+    try {
+      const ok = await deps.api.reactivateSession(binding.happySessionId);
+      binding.needsReactivate = !ok;
+    } catch {
+      binding.needsReactivate = true;
+    }
+  };
   const isTerminalAlive = deps.isTerminalAlive ?? ((terminalId) => {
     try {
       return node_child_process.spawnSync("tmux", persistence.tmuxArgs(["has-session", "-t", `=vh-${terminalId}:`]), { stdio: "ignore", timeout: 3e3, env: persistence.scrubTmuxClientEnv({ ...process.env }) }).status === 0;
@@ -6843,6 +6853,8 @@ function createMirrorManager(deps) {
   const endBinding = async (binding, reason) => {
     if (binding.status === "ended") return;
     binding.status = "ended";
+    lastEndedAt.set(binding.terminalId, Date.now());
+    binding.needsReactivate = false;
     persistence.logger.debug(`[MIRROR] ending binding for terminal ${binding.terminalId} (${reason})`);
     await binding.scanner?.cleanup();
     binding.scanner = null;
@@ -6870,6 +6882,76 @@ function createMirrorManager(deps) {
     }
     await binding.client.close();
   };
+  const adoptPersisted = async (terminalId, persisted) => {
+    if (bindings.has(terminalId)) return;
+    let best = null;
+    for (const [sessionId2, entry2] of Object.entries(persisted)) {
+      const meta2 = entry2.metadata;
+      if (meta2?.flavor !== TERMINAL_MIRROR_FLAVOR) continue;
+      if (meta2.machineId !== deps.machineId) continue;
+      if (meta2.terminalId !== terminalId) continue;
+      if (!meta2.claudeSessionId) continue;
+      if (!best || entry2.savedAt > best.entry.savedAt) best = { sessionId: sessionId2, entry: entry2 };
+    }
+    if (!best) return;
+    const { sessionId, entry } = best;
+    const meta = entry.metadata;
+    const session = {
+      id: sessionId,
+      seq: entry.seq,
+      metadata: meta,
+      metadataVersion: entry.metadataVersion,
+      agentState: null,
+      agentStateVersion: entry.agentStateVersion,
+      encryptionKey: persistence.decodeBase64(entry.encryptionKey),
+      encryptionVariant: entry.encryptionVariant
+    };
+    const client = deps.api.sessionSyncClient(session);
+    client.skipExistingMessages();
+    const binding = {
+      terminalId,
+      happySessionId: sessionId,
+      claudeSessionId: meta.claudeSessionId,
+      status: "active",
+      client,
+      scanner: null,
+      persist: {
+        encryptionKey: entry.encryptionKey,
+        encryptionVariant: entry.encryptionVariant,
+        seq: entry.seq,
+        metadataVersion: entry.metadataVersion,
+        agentStateVersion: entry.agentStateVersion
+      },
+      metadata: meta
+    };
+    bindings.set(terminalId, binding);
+    await reactivate(binding);
+    updateBindingMetadata(binding, {
+      lifecycleState: "running",
+      lifecycleStateSince: Date.now(),
+      archivedBy: void 0,
+      archiveReason: void 0
+    });
+    const scanner = attachScanner(binding, { withTruncationNotice: false });
+    scanner.addFile(path.join(persistence.getProjectPath(meta.path), `${meta.claudeSessionId}.jsonl`), "backfill-tail");
+    persistence.logger.debug(`[MIRROR] reconcile adopted terminal ${terminalId} \u2192 ${sessionId}`);
+    deps.onBindingsChanged?.();
+  };
+  const reactivateInPlace = async (binding) => {
+    if (binding.status !== "ended") return;
+    binding.status = "active";
+    await reactivate(binding);
+    updateBindingMetadata(binding, {
+      lifecycleState: "running",
+      lifecycleStateSince: Date.now(),
+      archivedBy: void 0,
+      archiveReason: void 0
+    });
+    const scanner = binding.scanner ?? attachScanner(binding, { withTruncationNotice: false });
+    scanner.addFile(path.join(persistence.getProjectPath(binding.metadata.path), `${binding.claudeSessionId}.jsonl`), "backfill-tail");
+    persistence.logger.debug(`[MIRROR] reconcile reactivated (in place) terminal ${binding.terminalId}`);
+    deps.onBindingsChanged?.();
+  };
   const createBinding = async (event, replaces) => {
     if (replaces) {
       await teardownBinding(replaces, "superseded by a fresh conversation");
@@ -6930,6 +7012,7 @@ function createMirrorManager(deps) {
     binding.claudeSessionId = event.claudeSessionId;
     if (binding.status === "ended") {
       binding.status = "active";
+      await reactivate(binding);
       updateBindingMetadata(binding, {
         lifecycleState: "running",
         lifecycleStateSince: Date.now(),
@@ -6999,6 +7082,43 @@ function createMirrorManager(deps) {
         }
       }
     },
+    reconcile(list) {
+      let persisted = null;
+      const now = Date.now();
+      for (const item of list) {
+        const binding = bindings.get(item.id) ?? null;
+        if (item.agentState === "shell") {
+          if (binding && binding.status === "active") {
+            chain = chain.then(() => {
+              const b = bindings.get(item.id);
+              return b && b.status === "active" ? endBinding(b, "claude exited (pane observation)") : void 0;
+            }).catch((e) => persistence.logger.debug(`[MIRROR] reconcile end failed for ${item.id}:`, e));
+          }
+          continue;
+        }
+        if (binding && binding.status === "active" && binding.needsReactivate) {
+          chain = chain.then(() => {
+            const b = bindings.get(item.id);
+            return b && b.status === "active" && b.needsReactivate ? reactivate(b) : void 0;
+          }).catch((e) => persistence.logger.debug(`[MIRROR] reconcile reactivate-retry failed for ${item.id}:`, e));
+        }
+        if (!item.claudeConfident) continue;
+        const endedAt = lastEndedAt.get(item.id);
+        if (endedAt !== void 0 && now - endedAt < RECONCILE_HYSTERESIS_MS) continue;
+        if (binding && binding.status === "ended") {
+          chain = chain.then(() => {
+            const b = bindings.get(item.id);
+            return b && b.status === "ended" ? reactivateInPlace(b) : void 0;
+          }).catch((e) => persistence.logger.debug(`[MIRROR] reconcile in-place reactivate failed for ${item.id}:`, e));
+        } else if (!binding) {
+          persisted ??= persistence.readPersistedSessions();
+          const p = persisted;
+          chain = chain.then(() => {
+            return bindings.has(item.id) ? void 0 : adoptPersisted(item.id, p);
+          }).catch((e) => persistence.logger.debug(`[MIRROR] reconcile adopt failed for ${item.id}:`, e));
+        }
+      }
+    },
     resolveMirrorSessionId(terminalId) {
       return bindings.get(terminalId)?.happySessionId;
     },
@@ -7113,6 +7233,144 @@ function recoverableSessionPid(metadata, liveHappyPids) {
   const pid = metadata?.hostPid;
   return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && liveHappyPids.has(pid) ? pid : null;
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sessionAgentConversationId(metadata) {
+  if (!metadata) return null;
+  if (metadata.flavor === "codex") return metadata.codexThreadId ?? null;
+  return metadata.claudeSessionId ?? metadata.codexThreadId ?? null;
+}
+function isDaemonWrapperForConversation(command, conversationId) {
+  if (!command || !conversationId) return false;
+  const startedByDaemon = /(?:^|\s)--started-by\s+daemon(?:\s|$)/.test(command);
+  if (!startedByDaemon) return false;
+  const resume = new RegExp(`(?:^|\\s)--resume(?:\\s+|=)${escapeRegExp(conversationId)}(?:\\s|$)`);
+  return resume.test(command);
+}
+function findSessionWrapperPids(metadata, liveHappyProcesses, options = {}) {
+  const out = [];
+  const livePids = new Set(liveHappyProcesses.map((p) => p.pid));
+  const lockPid = options.lockPid ?? null;
+  if (lockPid !== null && lockPid !== options.excludePid && livePids.has(lockPid)) out.push(lockPid);
+  const persisted = recoverableSessionPid(metadata, livePids);
+  if (persisted !== null && persisted !== options.excludePid && !out.includes(persisted)) out.push(persisted);
+  const conversationId = sessionAgentConversationId(metadata);
+  if (conversationId) {
+    for (const proc of liveHappyProcesses) {
+      if (proc.pid === options.excludePid || out.includes(proc.pid)) continue;
+      if (isDaemonWrapperForConversation(proc.command, conversationId)) out.push(proc.pid);
+    }
+  }
+  return out;
+}
+function mergeRestoreMetadata(stale, reported) {
+  if (!reported) return stale;
+  return { ...stale, ...processIdentityFields(reported) };
+}
+
+const SESSION_LOCK_DIR = "session-locks";
+const defaultRuntime = () => ({
+  dir: path.join(persistence.configuration.happyHomeDir, SESSION_LOCK_DIR),
+  selfPid: process.pid,
+  now: () => Date.now(),
+  signal: (pid, signal) => process.kill(pid, signal),
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  schedule: (callback, delayMs) => {
+    setTimeout(callback, delayMs);
+  }
+});
+function sessionLockPath(happySessionId, dir = path.join(persistence.configuration.happyHomeDir, SESSION_LOCK_DIR)) {
+  return path.join(dir, `${happySessionId}.json`);
+}
+function readSessionLock(happySessionId, dir) {
+  try {
+    const path = sessionLockPath(happySessionId, dir);
+    if (!node_fs.existsSync(path)) return null;
+    const parsed = JSON.parse(node_fs.readFileSync(path, "utf-8"));
+    if (typeof parsed?.pid !== "number" || !Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+    return {
+      pid: parsed.pid,
+      startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : 0,
+      version: typeof parsed.version === "string" ? parsed.version : "",
+      ...typeof parsed.flavor === "string" ? { flavor: parsed.flavor } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function liveSessionLockHolder(happySessionId, runtime = defaultRuntime()) {
+  const record = readSessionLock(happySessionId, runtime.dir);
+  if (!record || record.pid === runtime.selfPid) return null;
+  return runtime.isAlive(record.pid) ? record : null;
+}
+function writeSessionLock(happySessionId, record, dir) {
+  node_fs.mkdirSync(dir, { recursive: true, mode: 448 });
+  const path = sessionLockPath(happySessionId, dir);
+  const tmp = `${path}.${record.pid}.tmp`;
+  persistence.writePrivateFileSync(tmp, JSON.stringify(record));
+  node_fs.renameSync(tmp, path);
+}
+function acquireSessionLock(happySessionId, options, runtime = defaultRuntime()) {
+  const record = () => ({
+    pid: runtime.selfPid,
+    startedAt: runtime.now(),
+    version: options.version,
+    ...options.flavor ? { flavor: options.flavor } : {}
+  });
+  const holder = liveSessionLockHolder(happySessionId, runtime);
+  if (!holder) {
+    writeSessionLock(happySessionId, record(), runtime.dir);
+    return Promise.resolve({ ok: true, replaced: null });
+  }
+  if (!options.takeover) {
+    return Promise.resolve({ ok: false, holder });
+  }
+  return new Promise((resolve) => {
+    const requested = terminateProcess(holder.pid, (stopped) => {
+      if (!stopped) {
+        resolve({ ok: false, holder });
+        return;
+      }
+      writeSessionLock(happySessionId, record(), runtime.dir);
+      resolve({ ok: true, replaced: holder });
+    }, runtime, options.graceMs ?? 2e3);
+    if (!requested) resolve({ ok: false, holder });
+  });
+}
+function releaseSessionLock(happySessionId, runtime = defaultRuntime()) {
+  try {
+    const record = readSessionLock(happySessionId, runtime.dir);
+    if (record && record.pid === runtime.selfPid) {
+      node_fs.unlinkSync(sessionLockPath(happySessionId, runtime.dir));
+    }
+  } catch {
+  }
+}
+async function claimSessionOrExit(happySessionId, options) {
+  const result = await acquireSessionLock(happySessionId, {
+    takeover: options.takeover,
+    version: persistence.configuration.currentCliVersion,
+    flavor: options.flavor
+  });
+  if (!result.ok) {
+    const message = `Session ${happySessionId} is already run by very-happy pid ${result.holder.pid} (v${result.holder.version || "?"}); this process yields.`;
+    persistence.logger.debug(`[SESSION LOCK] ${message}`);
+    console.error(message);
+    process.exit(0);
+  }
+  if (result.replaced) {
+    persistence.logger.debug(`[SESSION LOCK] Took over session ${happySessionId} from pid ${result.replaced.pid} (v${result.replaced.version || "?"})`);
+  }
+  process.on("exit", () => releaseSessionLock(happySessionId));
+}
 
 function shellescape(s) {
   return "'" + s.replace(/'/g, "'\\''") + "'";
@@ -7204,7 +7462,7 @@ async function startDaemon() {
     const pidToTrackedSession = /* @__PURE__ */ new Map();
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     const persisted = persistence.readPersistedSessions();
-    const liveHappyPids = new Set((await findAllHappyProcesses()).map((entry) => entry.pid));
+    const liveHappyProcesses = await findAllHappyProcesses();
     for (const [id, s] of Object.entries(persisted)) {
       const tracked = {
         startedBy: "persisted",
@@ -7219,12 +7477,20 @@ async function startDaemon() {
         },
         pid: 0
       };
-      const livePid = recoverableSessionPid(s.metadata, liveHappyPids);
-      if (livePid !== null) {
+      const livePids = findSessionWrapperPids(s.metadata, liveHappyProcesses, { excludePid: process.pid, lockPid: readSessionLock(id)?.pid });
+      if (livePids.length > 0) {
+        const [livePid, ...duplicates] = livePids;
         tracked.pid = livePid;
         tracked.startedBy = "recovered after daemon restart";
         pidToTrackedSession.set(livePid, tracked);
-        persistence.persistSession(id, { ...s, savedAt: Date.now() });
+        if (livePid !== s.metadata?.hostPid) {
+          persistence.logger.debug(`[DAEMON RUN] Session ${id}: persisted hostPid ${s.metadata?.hostPid} is stale; adopted live wrapper ${livePid} by its --resume command line`);
+        }
+        for (const dup of duplicates) {
+          persistence.logger.warn(`[DAEMON RUN] Session ${id} has a duplicate live wrapper ${dup} (kept ${livePid}); restart the session to collapse them`);
+          pidToTrackedSession.set(dup, { ...tracked, pid: dup, startedBy: "recovered after daemon restart (duplicate wrapper)" });
+        }
+        persistence.persistSession(id, { ...s, metadata: { ...s.metadata, hostPid: livePid }, savedAt: Date.now() });
       } else {
         sessionIdToFinishedSession.set(id, tracked);
       }
@@ -7254,6 +7520,11 @@ async function startDaemon() {
           savedAt: Date.now()
         });
       }
+      for (const [otherPid, other] of pidToTrackedSession.entries()) {
+        if (other.happySessionId === sessionId && otherPid !== pid && isPidAlive(otherPid)) {
+          persistence.logger.warn(`[DAEMON RUN] Session ${sessionId} now has two live wrappers (${otherPid} and ${pid}); restart the session to collapse them`);
+        }
+      }
       const existingSession = pidToTrackedSession.get(pid);
       if (existingSession && existingSession.startedBy === "daemon") {
         existingSession.happySessionId = sessionId;
@@ -7681,6 +7952,21 @@ async function startDaemon() {
       }
       return sessionIdToFinishedSession.get(happySessionId);
     };
+    const persistRestoreRecord = (happySessionId, fallback, metadata) => {
+      const candidates = [...pidToTrackedSession.values()].filter((s) => s.happySessionId === happySessionId && isPidAlive(s.pid));
+      const live = candidates.find((s) => s.childProcess) ?? candidates[0];
+      const encryption = live?.encryption ?? fallback.encryption;
+      if (!encryption) return;
+      persistence.persistSession(happySessionId, {
+        encryptionKey: persistence.encodeBase64(encryption.encryptionKey),
+        encryptionVariant: encryption.encryptionVariant,
+        seq: encryption.seq,
+        metadataVersion: encryption.metadataVersion,
+        agentStateVersion: encryption.agentStateVersion,
+        metadata: mergeRestoreMetadata(metadata, live?.happySessionMetadataFromLocalWebhook),
+        savedAt: Date.now()
+      });
+    };
     const fetchServerSessionMetadata = async (sessionId, encryptionKey, encryptionVariant) => {
       try {
         const byId = await axios.get(`${persistence.configuration.serverUrl}/v1/sessions/${encodeURIComponent(sessionId)}`, {
@@ -7737,6 +8023,14 @@ async function startDaemon() {
         if (!tracked) {
           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.` };
         }
+        const orphans = findSessionWrapperPids(tracked.happySessionMetadataFromLocalWebhook, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(happySessionId)?.pid }).filter((pid) => isPidAlive(pid) && !pidToTrackedSession.has(pid));
+        if (orphans.length > 0) {
+          for (const pid of orphans) {
+            pidToTrackedSession.set(pid, { ...tracked, pid, startedBy: "adopted untracked wrapper" });
+          }
+          persistence.logger.debug(`[DAEMON RUN] resume ${happySessionId}: adopted untracked live wrapper(s) ${orphans.join(", ")} \u2014 idempotent success`);
+          return { type: "success", sessionId: happySessionId };
+        }
         if (!tracked.happySessionMetadataFromLocalWebhook) {
           return { type: "error", errorMessage: `resume-precheck:no-metadata: Session ${happySessionId} has no metadata. Cannot resume.` };
         }
@@ -7784,15 +8078,7 @@ async function startDaemon() {
           }
         });
         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()
-          });
+          persistRestoreRecord(happySessionId, tracked, metadata);
         }
         return result;
       } catch (error) {
@@ -7805,17 +8091,18 @@ 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) => {
+    const stopSessionAndWait = async (happySessionId, timeoutMs = 8e3) => {
+      const targets = /* @__PURE__ */ new Set();
+      for (const [pid, s] of pidToTrackedSession.entries()) {
+        if (s.happySessionId === happySessionId && isPidAlive(pid)) targets.add(pid);
+      }
+      const known = findTrackedSessionById(happySessionId)?.happySessionMetadataFromLocalWebhook;
+      for (const pid of findSessionWrapperPids(known, await findAllHappyProcesses(), { excludePid: process.pid, lockPid: readSessionLock(happySessionId)?.pid })) {
+        if (isPidAlive(pid)) targets.add(pid);
+      }
+      if (targets.size === 0) return;
+      persistence.logger.debug(`[DAEMON RUN] restart ${happySessionId}: stopping live wrapper(s) ${[...targets].join(", ")}`);
+      await Promise.all([...targets].map((pid) => new Promise((resolve) => {
         let settled = false;
         const done = () => {
           if (!settled) {
@@ -7835,7 +8122,7 @@ async function startDaemon() {
         });
         if (!requested) done();
         setTimeout(done, timeoutMs).unref?.();
-      });
+      })));
     };
     const restartSession = async (happySessionId, options) => {
       let gate = resumeGates.get(happySessionId);
@@ -7917,15 +8204,7 @@ async function startDaemon() {
           }
         });
         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()
-          });
+          persistRestoreRecord(happySessionId, tracked, metadata);
         }
         return result;
       } catch (error) {
@@ -8096,6 +8375,7 @@ async function startDaemon() {
       resolveMirrorSessionId: (terminalId) => mirrorManager.resolveMirrorSessionId(terminalId),
       onTerminalClosed: (terminalId) => mirrorManager.onTerminalClosed(terminalId),
       onTerminalList: (terminals) => mirrorManager.observeTerminalList(terminals),
+      onTerminalListTick: (terminals) => mirrorManager.reconcile(terminals),
       isMirrorInputAllowed: (terminalId) => mirrorManager.isMirrorInputAllowed(terminalId)
     });
     mirrorManager.restore().catch((error) => {
@@ -9156,7 +9436,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-DaVhaBF2.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-BzbaMrIa.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();
@@ -9693,6 +9973,7 @@ async function runClaude(credentials, options = {}) {
     process.exit(0);
   }
   persistence.logger.debug(`Session created: ${response.id}`);
+  await claimSessionOrExit(response.id, { takeover: !!reconnectSessionId, flavor: "claude" });
   if (reconnectSessionId && !await api.reactivateSession(response.id)) {
     throw new Error(`Failed to reactivate archived session ${response.id}`);
   }
@@ -11350,9 +11631,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-DaVhaBF2.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-BzbaMrIa.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-DaVhaBF2.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-BzbaMrIa.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -13207,6 +13488,9 @@ async function runCodex(opts) {
   } else {
     response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   }
+  if (response) {
+    await claimSessionOrExit(response.id, { takeover: !!reconnectSessionId, flavor: "codex" });
+  }
   if (reconnectSessionId && response && !await api.reactivateSession(response.id)) {
     throw new Error(`Failed to reactivate archived session ${response.id}`);
   }
@@ -13973,7 +14257,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-CRjlRj9K.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-BrrsyTMd.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -13990,7 +14274,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-OE9kENQi.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-Dian7x_g.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -14002,7 +14286,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-PmtzSBVM.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-DgK6MtgT.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -14108,9 +14392,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-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; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-BVOE0pni.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./types-HRuZ13LS.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-HRuZ13LS.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -14141,7 +14425,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-SZEQWS8k.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-BVOE0pni.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -14181,7 +14465,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-DapsCPLi.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-C91O1oxi.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -14203,7 +14487,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-17NbIAkU.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-CbPc1iVx.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -14243,7 +14527,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-C9dhyV4x.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-B1RRfA1V.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -14294,7 +14578,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-C-dDCrXm.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-ziyMk3eS.cjs'); });
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}