very-happy-cli 0.2.137 → 0.2.139

package/dist/{types-BAhQF6Xp.cjs → types-CxGm_YJ-.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var axios = require('axios');
-var persistence = require('./limits-CJrrAhB4.cjs');
+var persistence = require('./limits-C_RGzva6.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
@@ -1004,6 +1004,15 @@ z.z.object({
     rpcAvailable: z.z.boolean(),
     detectedAt: z.z.number()
   }).optional(),
+  /**
+   * B-464 capability flag: this daemon answers `codex-list-history` /
+   * `codex-import-session` (import a Codex CLI / desktop thread that was never
+   * started through very-happy). Same trust rule (`detectedAt >= startedAt`).
+   */
+  codexHistory: z.z.object({
+    rpcAvailable: z.z.boolean(),
+    detectedAt: z.z.number()
+  }).optional(),
   /** Relay-owned CLI compatibility/update policy last checked by this daemon. */
   cliUpdate: CliUpdateStateSchema.optional(),
   /**
@@ -1369,7 +1378,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-BAhQF6Xp.cjs', document.baseURI).href))));
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-CxGm_YJ-.cjs', document.baseURI).href))));
 function projectPath() {
   const path$1 = path.resolve(__dirname$1, "..");
   return path$1;
@@ -2911,6 +2920,268 @@ const MAX_CHAT_ATTACHMENT_SOURCE_BYTES = 50 * 1024 * 1024;
 const CHAT_ATTACHMENT_ENCRYPTION_OVERHEAD_BYTES = 40;
 const MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES = MAX_CHAT_ATTACHMENT_SOURCE_BYTES + CHAT_ATTACHMENT_ENCRYPTION_OVERHEAD_BYTES;
 
+const TURN_LEASE_MS = 6e4;
+const TURN_BUSY_TTL_MS = 15e4;
+class TurnActivityTracker {
+  constructor(ttlMs = TURN_BUSY_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  busy = /* @__PURE__ */ new Map();
+  apply(sessionId, event, now = Date.now()) {
+    if (event === "turn_started") this.busy.set(sessionId, now);
+    else this.busy.delete(sessionId);
+  }
+  /** The wrapper is gone: whatever it reported no longer holds. */
+  forget(sessionId) {
+    this.busy.delete(sessionId);
+  }
+  /** Sessions whose last renewal is still inside the TTL. */
+  activeSessions(now = Date.now()) {
+    const out = [];
+    for (const [id, at] of this.busy) {
+      if (now - at <= this.ttlMs) out.push(id);
+      else this.busy.delete(id);
+    }
+    return out;
+  }
+  hasActiveTurn(now = Date.now()) {
+    return this.activeSessions(now).length > 0;
+  }
+}
+class TurnReporter {
+  constructor(send, leaseMs = TURN_LEASE_MS) {
+    this.send = send;
+    this.leaseMs = leaseMs;
+  }
+  thinking = false;
+  lastStartedAt = 0;
+  /** Called on every keepAlive tick; emits only on an edge or a due renewal. */
+  observe(thinking, now = Date.now()) {
+    if (thinking) {
+      const due = !this.thinking || now - this.lastStartedAt >= this.leaseMs;
+      this.thinking = true;
+      if (!due) return null;
+      this.lastStartedAt = now;
+      this.send("turn_started");
+      return "turn_started";
+    }
+    if (!this.thinking) return null;
+    this.thinking = false;
+    this.lastStartedAt = 0;
+    this.send("turn_ended");
+    return "turn_ended";
+  }
+}
+
+function daemonControlHeaders(controlToken) {
+  return {
+    "Content-Type": "application/json",
+    ...controlToken ? { Authorization: `Bearer ${controlToken}` } : {}
+  };
+}
+async function daemonPost(path, body) {
+  const state = await persistence.readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    persistence.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch (error) {
+    const errorMessage = "Daemon is not running, file is stale";
+    persistence.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+  try {
+    const timeout = process.env.HAPPY_DAEMON_HTTP_TIMEOUT ? parseInt(process.env.HAPPY_DAEMON_HTTP_TIMEOUT) : 1e4;
+    const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
+      method: "POST",
+      // A state written by an old daemon has no token and must remain callable;
+      // a new daemon always writes one and rejects requests without it.
+      headers: daemonControlHeaders(state.controlToken),
+      body: JSON.stringify(body || {}),
+      // Mostly increased for stress test
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const failure = await response.json().catch(() => null);
+      const reason = typeof failure?.error === "string" && failure.error ? failure.error : `HTTP ${response.status}`;
+      const errorMessage = `Request failed: ${path}, ${reason}`;
+      persistence.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+      return {
+        error: errorMessage
+      };
+    }
+    return await response.json();
+  } catch (error) {
+    const errorMessage = `Request failed: ${path}, ${error instanceof Error ? error.message : "Unknown error"}`;
+    persistence.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+}
+const SESSION_STARTED_RETRY_TIMEOUT_MS = 3e3;
+const SESSION_STARTED_RETRY_INTERVAL_MS = 100;
+async function notifyDaemonSessionStarted(sessionId, metadata, encryption) {
+  const payload = { sessionId, metadata, encryption };
+  const deadline = Date.now() + SESSION_STARTED_RETRY_TIMEOUT_MS;
+  let result;
+  while (true) {
+    result = await daemonPost("/session-started", payload);
+    if (!result?.error) {
+      return result;
+    }
+    if (Date.now() >= deadline) {
+      return result;
+    }
+    await new Promise((resolve) => setTimeout(resolve, SESSION_STARTED_RETRY_INTERVAL_MS));
+  }
+}
+async function listDaemonSessions() {
+  const result = await daemonPost("/list");
+  return result.children || [];
+}
+async function stopDaemonSession(sessionId) {
+  const result = await daemonPost("/stop-session", { sessionId });
+  return result.success || false;
+}
+async function spawnDaemonSession(directory, sessionId, opts) {
+  const result = await daemonPost("/spawn-session", {
+    directory,
+    sessionId,
+    spawnedBy: opts?.spawnedBy,
+    permissionMode: opts?.permissionMode,
+    agent: opts?.agent,
+    environmentVariables: opts?.environmentVariables
+  });
+  return result;
+}
+async function notifyDaemonSessionEvent(sessionId, event, spawnedBy) {
+  return daemonPost("/session-event", { sessionId, event, spawnedBy });
+}
+async function notifyDaemonClaudeAuthFailed(sessionId) {
+  return daemonPost("/session-event", { sessionId, event: "auth_failed" });
+}
+async function notifyDaemonTurnEvent(sessionId, event) {
+  return daemonPost("/session-event", { sessionId, event });
+}
+async function stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+async function pushClipboardViaDaemon(text) {
+  const result = await daemonPost("/clipboard", { text });
+  if (result?.error && result.delivered === void 0) {
+    return { delivered: false, error: result.error };
+  }
+  return result;
+}
+async function setTerminalTitleViaDaemon(terminalId, title, ifAbsent = false) {
+  const result = await daemonPost("/terminal-title", { terminalId, title, ifAbsent });
+  if (result?.error) {
+    return { ok: false, error: result.error };
+  }
+  return { ok: result?.status === "ok", error: result?.status === "ok" ? void 0 : "unexpected daemon response" };
+}
+async function checkIfDaemonRunningAndCleanupStaleState() {
+  const state = await persistence.readDaemonState();
+  if (!state) {
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch {
+    persistence.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+  if (state.httpPort) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${state.httpPort}/list`, {
+        method: "POST",
+        headers: daemonControlHeaders(state.controlToken),
+        body: "{}",
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+      persistence.logger.debug(`[DAEMON RUN] PID ${state.pid} is alive but HTTP health check failed on port ${state.httpPort}, cleaning up stale state`);
+      await cleanupDaemonState();
+      return false;
+    }
+  }
+  return true;
+}
+async function isDaemonRunningCurrentlyInstalledHappyVersion() {
+  persistence.logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    persistence.logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await persistence.readDaemonState();
+  if (!state) {
+    persistence.logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  const currentCliVersion = persistence.configuration.currentCliVersion;
+  persistence.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+  return currentCliVersion === state.startedWithCliVersion;
+}
+async function cleanupDaemonState() {
+  try {
+    await persistence.clearDaemonState();
+    persistence.logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    persistence.logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+async function stopDaemon() {
+  try {
+    const state = await persistence.readDaemonState();
+    if (!state) {
+      persistence.logger.debug("No daemon state found");
+      return;
+    }
+    persistence.logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      persistence.logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      persistence.logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      persistence.logger.debug("Force killed daemon");
+    } catch (error) {
+      persistence.logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    persistence.logger.debug("Error stopping daemon", error);
+  }
+}
+async function waitForProcessDeath(pid, timeout) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } catch {
+      return;
+    }
+  }
+  throw new Error("Process did not die within timeout");
+}
+
 class ApiSessionClient extends node_events.EventEmitter {
   token;
   sessionId;
@@ -3692,10 +3963,14 @@ class ApiSessionClient extends node_events.EventEmitter {
   /**
    * Send a ping message to keep the connection alive
    */
+  /** B-466: turn edges (and a periodic lease) reported to the local daemon so
+   *  auto-update waits for "no turn in flight" instead of "no sessions". */
+  turnReporter = new TurnReporter((event) => void notifyDaemonTurnEvent(this.sessionId, event).catch((error) => persistence.logger.debug("[API] Failed to report turn event to daemon:", error)));
   keepAlive(thinking, mode) {
     if (process.env.DEBUG) {
       persistence.logger.debug(`[API] Sending keep alive message: ${thinking}`);
     }
+    this.turnReporter.observe(thinking);
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
       time: Date.now(),
@@ -12384,7 +12659,7 @@ function isVeryHappyOneShotPrompt(firstPrompt) {
   return VERY_HAPPY_ONE_SHOT_PROMPT_PREFIXES.some((prefix) => text.startsWith(prefix));
 }
 
-const UUID_RE$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_RE$2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function listClaudeProjectDirs(projectsRoot) {
   let names;
   try {
@@ -12403,7 +12678,7 @@ async function listClaudeProjectDirs(projectsRoot) {
   }
   return dirs;
 }
-async function collectCandidates(projectDirs, exclude) {
+async function collectCandidates$1(projectDirs, exclude) {
   const out = [];
   for (const dir of projectDirs) {
     let names;
@@ -12415,7 +12690,7 @@ async function collectCandidates(projectDirs, exclude) {
     for (const name of names) {
       if (!name.endsWith(".jsonl")) continue;
       const id = name.slice(0, -".jsonl".length);
-      if (!UUID_RE$1.test(id) || exclude.has(id.toLowerCase())) continue;
+      if (!UUID_RE$2.test(id) || exclude.has(id.toLowerCase())) continue;
       const path = path$1.join(dir, name);
       try {
         const s = await promises.stat(path);
@@ -12434,7 +12709,7 @@ async function collectCandidates(projectDirs, exclude) {
     return true;
   });
 }
-async function readHead(path, bytes) {
+async function readHead$1(path, bytes) {
   const fh = await promises.open(path, "r");
   try {
     const buffer = Buffer.alloc(bytes);
@@ -12444,11 +12719,11 @@ async function readHead(path, bytes) {
     await fh.close();
   }
 }
-function oneLine(text, max) {
+function oneLine$1(text, max) {
   const collapsed = text.replace(/\s+/g, " ").trim();
   return collapsed.length > max ? `${collapsed.slice(0, max - 1)}\u2026` : collapsed;
 }
-function parseTimestamp(raw) {
+function parseTimestamp$1(raw) {
   if (typeof raw === "number" && Number.isFinite(raw)) return raw;
   if (typeof raw === "string") {
     const t = Date.parse(raw);
@@ -12475,7 +12750,7 @@ function parseClaudeHistoryHead(head, promptChars) {
     }
     if (!parsed || typeof parsed !== "object") continue;
     if (parsed.type === "summary" && typeof parsed.summary === "string" && !summary) {
-      const s = oneLine(parsed.summary, promptChars);
+      const s = oneLine$1(parsed.summary, promptChars);
       if (s) summary = s;
       continue;
     }
@@ -12483,7 +12758,7 @@ function parseClaudeHistoryHead(head, promptChars) {
     if (typeof parsed.entrypoint === "string" && parsed.entrypoint && !entrypoint) entrypoint = parsed.entrypoint;
     if (typeof parsed.gitBranch === "string" && parsed.gitBranch && !gitBranch) gitBranch = parsed.gitBranch;
     if (typeof parsed.version === "string" && parsed.version && !version) version = parsed.version;
-    if (startedAt === null) startedAt = parseTimestamp(parsed.timestamp);
+    if (startedAt === null) startedAt = parseTimestamp$1(parsed.timestamp);
     if (!firstPrompt && parsed.type === "user" && !parsed.isSidechain) {
       const content = parsed.message?.content;
       let text = null;
@@ -12495,7 +12770,7 @@ function parseClaudeHistoryHead(head, promptChars) {
       }
       if (text) {
         if (isVeryHappyOneShotPrompt(text)) return null;
-        const cleaned = oneLine(stripHarnessTags(text), promptChars);
+        const cleaned = oneLine$1(stripHarnessTags(text), promptChars);
         if (cleaned) firstPrompt = cleaned;
       }
     }
@@ -12521,7 +12796,7 @@ async function listClaudeSessionHistory(options) {
   const headBytes = Math.max(4096, options.headBytes ?? 64 * 1024);
   const promptChars = Math.max(20, options.promptChars ?? 200);
   const exclude = new Set(Array.from(options.exclude ?? [], (id) => id.toLowerCase()));
-  const candidates = await collectCandidates(options.projectDirs, exclude);
+  const candidates = await collectCandidates$1(options.projectDirs, exclude);
   const entries = [];
   let scanned = 0;
   let truncated = false;
@@ -12533,7 +12808,7 @@ async function listClaudeSessionHistory(options) {
     scanned += 1;
     let head;
     try {
-      head = await readHead(candidate.path, headBytes);
+      head = await readHead$1(candidate.path, headBytes);
     } catch {
       continue;
     }
@@ -12980,6 +13255,9 @@ class CodexAppServerClient {
   // Tracks in-flight interruptTurn() RPCs so sendTurnAndWait can wait for them
   // before starting a new turn (prevents stale turn/interrupt from aborting the next turn).
   pendingInterrupt = null;
+  // In-flight idle release (B-461); ensureConnected() waits for it so a message
+  // arriving mid-release cannot spawn a second app-server against a dying one.
+  idleRelease = null;
   notificationProtocol = "unknown";
   completedTurnIds = /* @__PURE__ */ new Set();
   rawFileChangesByItemId = /* @__PURE__ */ new Map();
@@ -13313,6 +13591,53 @@ class CodexAppServerClient {
   async disconnect() {
     await this.disconnectInternal();
   }
+  /** True while an app-server child process is owned by this client. */
+  get hasProcess() {
+    return this.process !== null;
+  }
+  /**
+   * Drop the app-server process while the session is idle, keeping the thread
+   * id and defaults so the next turn can `thread/resume` it (B-461). Refuses —
+   * returning false — whenever anything is still in flight: an active turn, a
+   * pending interrupt, or any outstanding RPC. See codexIdleRelease.ts.
+   */
+  async releaseIdleProcess() {
+    if (this.idleRelease) return this.idleRelease;
+    if (!this.connected && !this.process) return false;
+    if (this.pendingTurnCompletion || this.pendingInterrupt || this.pending.size > 0) {
+      persistence.logger.debug("[CodexAppServer] Idle release skipped: work still in flight");
+      return false;
+    }
+    const run = (async () => {
+      const threadId = this._threadId;
+      persistence.logger.debug(`[CodexAppServer] Releasing idle app-server; thread=${threadId ?? "none"} kept for resume`);
+      await this.disconnectInternal({ preserveThreadState: !!threadId });
+      return true;
+    })();
+    this.idleRelease = run;
+    try {
+      return await run;
+    } finally {
+      if (this.idleRelease === run) this.idleRelease = null;
+    }
+  }
+  /**
+   * Make sure an app-server is running and, if a thread is remembered, resumed
+   * in it. Cheap no-op while connected. Covers both the idle release above and
+   * an app-server that exited on its own between turns.
+   */
+  async ensureConnected() {
+    if (this.idleRelease) await this.idleRelease;
+    if (this.connected) return;
+    const threadId = this._threadId;
+    if (this.process) {
+      await this.disconnectInternal({ preserveThreadState: !!threadId });
+    }
+    await this.connect();
+    if (threadId) {
+      await this.resumeThread({ threadId });
+    }
+  }
   buildThreadConfig(mcpServers) {
     return mcpServers ? { mcp_servers: mcpServers } : null;
   }
@@ -13327,6 +13652,7 @@ class CodexAppServerClient {
   }
   // ─── Thread management ──────────────────────────────────────
   async startThread(opts) {
+    await this.ensureConnected();
     const params = {
       model: opts.model ?? null,
       modelProvider: null,
@@ -13354,6 +13680,7 @@ class CodexAppServerClient {
     if (!threadId) {
       throw new Error("No thread available to resume.");
     }
+    await this.ensureConnected();
     const defaults = this.threadDefaults ?? {};
     const params = {
       threadId,
@@ -13381,6 +13708,7 @@ class CodexAppServerClient {
     return { threadId: result.thread.id, model: result.model };
   }
   async forkThread(opts) {
+    await this.ensureConnected();
     const defaults = this.threadDefaults ?? {};
     const params = {
       threadId: opts.threadId,
@@ -13409,6 +13737,7 @@ class CodexAppServerClient {
     return { threadId: result.thread.id, model: result.model, thread: result.thread };
   }
   async readThread(opts) {
+    await this.ensureConnected();
     const params = {
       threadId: opts.threadId,
       includeTurns: opts.includeTurns ?? true
@@ -13416,6 +13745,7 @@ class CodexAppServerClient {
     return await this.request("thread/read", params);
   }
   async rollbackThread(opts) {
+    await this.ensureConnected();
     const params = {
       threadId: opts.threadId,
       numTurns: opts.numTurns
@@ -13423,6 +13753,7 @@ class CodexAppServerClient {
     return await this.request("thread/rollback", params);
   }
   async injectItems(opts) {
+    await this.ensureConnected();
     const params = {
       threadId: opts.threadId,
       items: opts.items
@@ -13527,6 +13858,7 @@ class CodexAppServerClient {
     if (!this._threadId) {
       throw new Error("No active thread. Call startThread first.");
     }
+    await this.ensureConnected();
     const input = [
       { type: "text", text: prompt },
       ...(opts?.images ?? []).map((path) => ({ type: "localImage", path }))
@@ -13572,6 +13904,7 @@ class CodexAppServerClient {
       await this.pendingInterrupt;
       await new Promise((resolve) => setTimeout(resolve, 0));
     }
+    await this.ensureConnected();
     const timeoutMs = opts?.turnTimeoutMs ?? CodexAppServerClient.TURN_TIMEOUT_MS;
     let timer = null;
     const completion = new Promise((resolve) => {
@@ -13914,6 +14247,235 @@ class CodexAppServerClient {
   }
 }
 
+const UUID_RE$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const ROLLOUT_RE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+const VERY_HAPPY_CODEX_ORIGINATOR = "happy-codex";
+function getCodexHomeDir() {
+  return process.env.CODEX_HOME || path$1.join(os$1.homedir(), ".codex");
+}
+function getCodexSessionsRoot(codexHome = getCodexHomeDir()) {
+  return path$1.join(codexHome, "sessions");
+}
+function getCodexSessionIndexPath(codexHome = getCodexHomeDir()) {
+  return path$1.join(codexHome, "session_index.jsonl");
+}
+async function collectCandidates(root, exclude) {
+  const out = [];
+  async function walk(dir, depth) {
+    let names;
+    try {
+      names = await promises.readdir(dir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const full = path$1.join(dir, name);
+      const match = ROLLOUT_RE.exec(name);
+      if (match) {
+        const id = match[1].toLowerCase();
+        if (exclude.has(id)) continue;
+        try {
+          const s = await promises.stat(full);
+          if (!s.isFile() || s.size === 0) continue;
+          out.push({ path: full, id, updatedAt: s.mtimeMs, sizeBytes: s.size });
+        } catch {
+        }
+        continue;
+      }
+      if (name.endsWith(".jsonl") || depth >= 4) continue;
+      try {
+        if ((await promises.stat(full)).isDirectory()) await walk(full, depth + 1);
+      } catch {
+      }
+    }
+  }
+  await walk(root, 0);
+  out.sort((a, b) => b.updatedAt - a.updatedAt);
+  const seen = /* @__PURE__ */ new Set();
+  return out.filter((c) => {
+    if (seen.has(c.id)) return false;
+    seen.add(c.id);
+    return true;
+  });
+}
+async function readHead(path, bytes) {
+  const fh = await promises.open(path, "r");
+  try {
+    const buffer = Buffer.alloc(bytes);
+    const { bytesRead } = await fh.read(buffer, 0, bytes, 0);
+    return buffer.subarray(0, bytesRead).toString("utf-8");
+  } finally {
+    await fh.close();
+  }
+}
+function oneLine(text, max) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.length > max ? `${collapsed.slice(0, max - 1)}\u2026` : collapsed;
+}
+function parseTimestamp(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (typeof raw === "string") {
+    const t = Date.parse(raw);
+    if (Number.isFinite(t)) return t;
+  }
+  return null;
+}
+function isHarnessUserText(text) {
+  const t = text.trimStart();
+  return t.startsWith("# AGENTS.md instructions") || t.startsWith("<environment_context>") || t.startsWith("<user_instructions>") || t.startsWith("<INSTRUCTIONS>");
+}
+function stripHarnessBlocks(text) {
+  return text.replace(/<(environment_context|user_instructions|INSTRUCTIONS|turn_aborted|system-reminder)>[\s\S]*?<\/\1>/g, " ").replace(/^# AGENTS\.md instructions[^\n]*\n/m, " ");
+}
+function textFromUserContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  const parts = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const type = part.type;
+    const text = part.text;
+    if ((type === "input_text" || type === "text") && typeof text === "string") parts.push(text);
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+function parseCodexHistoryHead(head, promptChars) {
+  let id;
+  let cwd;
+  let firstPrompt;
+  let fallbackPrompt;
+  let startedAt = null;
+  let entrypoint;
+  let originator;
+  let gitBranch;
+  let version;
+  let sawMeta = false;
+  for (const line of head.split("\n")) {
+    if (line.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object") continue;
+    const payload = parsed.payload;
+    if (parsed.type === "session_meta" && payload && typeof payload === "object") {
+      sawMeta = true;
+      if (typeof payload.id === "string" && UUID_RE$1.test(payload.id)) id = payload.id.toLowerCase();
+      if (typeof payload.cwd === "string" && payload.cwd) cwd = payload.cwd;
+      if (typeof payload.source === "string" && payload.source) entrypoint = payload.source;
+      if (typeof payload.originator === "string" && payload.originator) originator = payload.originator;
+      if (typeof payload.cli_version === "string" && payload.cli_version) version = payload.cli_version;
+      const branch = payload.git && typeof payload.git === "object" ? payload.git.branch : void 0;
+      if (typeof branch === "string" && branch) gitBranch = branch;
+      startedAt = parseTimestamp(payload.timestamp) ?? parseTimestamp(parsed.timestamp);
+      continue;
+    }
+    if (!sawMeta) return null;
+    if (firstPrompt) break;
+    if (!payload || typeof payload !== "object") continue;
+    if (parsed.type === "event_msg") {
+      if (payload.type === "user_message" && typeof payload.message === "string") {
+        const cleaned = oneLine(stripHarnessBlocks(payload.message), promptChars);
+        if (cleaned) firstPrompt = cleaned;
+      } else if (payload.type === "item_completed" && payload.item && payload.item.type === "UserMessage") {
+        const text = textFromUserContent(payload.item.content);
+        const cleaned = text ? oneLine(stripHarnessBlocks(text), promptChars) : "";
+        if (cleaned) firstPrompt = cleaned;
+      }
+      continue;
+    }
+    if (parsed.type === "response_item" && payload.type === "message" && payload.role === "user" && !fallbackPrompt) {
+      const text = textFromUserContent(payload.content);
+      if (text && !isHarnessUserText(text)) {
+        const cleaned = oneLine(stripHarnessBlocks(text), promptChars);
+        if (cleaned) fallbackPrompt = cleaned;
+      }
+    }
+  }
+  if (!sawMeta || !cwd) return null;
+  const prompt = firstPrompt ?? fallbackPrompt;
+  if (!prompt) return null;
+  return {
+    ...id ? { id } : {},
+    cwd,
+    firstPrompt: prompt,
+    startedAt: startedAt ?? 0,
+    ...entrypoint ? { entrypoint } : {},
+    ...originator ? { originator } : {},
+    ...gitBranch ? { gitBranch } : {},
+    ...version ? { version } : {}
+  };
+}
+function parseCodexSessionIndex(text) {
+  const names = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object") continue;
+    if (typeof parsed.id !== "string" || !UUID_RE$1.test(parsed.id)) continue;
+    if (typeof parsed.thread_name !== "string" || !parsed.thread_name.trim()) continue;
+    names.set(parsed.id.toLowerCase(), parsed.thread_name.trim());
+  }
+  return names;
+}
+async function readSessionIndex(path) {
+  if (!path) return /* @__PURE__ */ new Map();
+  try {
+    return parseCodexSessionIndex(await promises.readFile(path, "utf-8"));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function listCodexSessionHistory(options) {
+  const limit = Math.max(1, Math.min(options.limit ?? 60, 500));
+  const headBytes = Math.max(4096, options.headBytes ?? 256 * 1024);
+  const promptChars = Math.max(20, options.promptChars ?? 200);
+  const exclude = new Set(Array.from(options.exclude ?? [], (id) => id.toLowerCase()));
+  const [candidates, names] = await Promise.all([
+    collectCandidates(options.sessionsRoot, exclude),
+    readSessionIndex(options.sessionIndexPath)
+  ]);
+  const entries = [];
+  let scanned = 0;
+  let truncated = false;
+  for (const candidate of candidates) {
+    if (entries.length >= limit) {
+      truncated = true;
+      break;
+    }
+    scanned += 1;
+    let head;
+    try {
+      head = await readHead(candidate.path, headBytes);
+    } catch {
+      continue;
+    }
+    const parsed = parseCodexHistoryHead(head, promptChars);
+    if (!parsed) continue;
+    if (parsed.originator === VERY_HAPPY_CODEX_ORIGINATOR) continue;
+    if (options.directory && parsed.cwd !== options.directory) continue;
+    const codexThreadId = parsed.id ?? candidate.id;
+    if (exclude.has(codexThreadId)) continue;
+    const { id: _id, ...rest } = parsed;
+    const summary = names.get(codexThreadId);
+    entries.push({
+      codexThreadId,
+      updatedAt: Math.round(candidate.updatedAt),
+      sizeBytes: candidate.sizeBytes,
+      ...rest,
+      ...summary ? { summary: oneLine(summary, promptChars) } : {}
+    });
+  }
+  return { entries, truncated, scanned };
+}
+
 function selectLowestLatencyRelay(candidates, probes) {
   const rttById = new Map(probes.map((probe) => [probe.relayId, probe.rttMs]));
   let selected = null;
@@ -14631,6 +15193,45 @@ class ApiMachineClient {
       });
       return { type: "success", ...result };
     });
+    this.rpcHandlerManager.registerHandler("codex-list-history", async (params) => {
+      const { directory, limit, exclude } = params || {};
+      if (directory !== void 0 && (typeof directory !== "string" || directory.length === 0)) {
+        throw new Error("directory must be a non-empty string when provided");
+      }
+      const excludeIds = [
+        ...Array.isArray(exclude) ? exclude.filter((id) => typeof id === "string" && UUID_RE.test(id)) : [],
+        ...persistence.readTrackedCodexThreadIds()
+      ];
+      const result = await listCodexSessionHistory({
+        sessionsRoot: getCodexSessionsRoot(),
+        sessionIndexPath: getCodexSessionIndexPath(),
+        ...typeof directory === "string" ? { directory } : {},
+        limit: typeof limit === "number" && Number.isFinite(limit) ? Math.max(1, Math.min(Math.floor(limit), 200)) : 60,
+        exclude: excludeIds
+      });
+      return { type: "success", ...result };
+    });
+    this.rpcHandlerManager.registerHandler("codex-import-session", async (params) => {
+      const { directory, codexThreadId, approvedNewDirectoryCreation, permissionMode, title } = params || {};
+      if (typeof directory !== "string" || directory.length === 0) {
+        throw new Error("directory is required");
+      }
+      if (typeof codexThreadId !== "string" || !UUID_RE.test(codexThreadId)) {
+        throw new Error("codexThreadId must be a valid UUID");
+      }
+      const result = await spawnSession({
+        directory,
+        machineId: this.machine.id,
+        approvedNewDirectoryCreation: approvedNewDirectoryCreation === true,
+        agent: "codex",
+        importCodexThreadId: codexThreadId.toLowerCase(),
+        permissionMode: typeof permissionMode === "string" ? permissionMode : void 0,
+        importTitle: typeof title === "string" ? title : void 0
+      });
+      if (result.type !== "success") return result;
+      persistence.logger.debug(`[API MACHINE] Importing Codex thread ${codexThreadId} as session ${result.sessionId}`);
+      return { type: "success", sessionId: result.sessionId };
+    });
     this.rpcHandlerManager.registerHandler("codex-fork-thread", async (params) => {
       const directory = requireNonEmptyString(params?.directory, "directory");
       const codexThreadId = requireNonEmptyString(params?.codexThreadId, "codexThreadId");
@@ -14979,6 +15580,8 @@ class ApiMachineClient {
         tmuxSessions: { rpcAvailable: true, detectedAt: now, killAttached: true },
         // B-290 capability flag: `claude-list-history` (same restamp discipline).
         claudeHistory: { rpcAvailable: true, detectedAt: now },
+        // B-464 capability flag: `codex-list-history` / `codex-import-session`.
+        codexHistory: { rpcAvailable: true, detectedAt: now },
         // B-084: closed records survive daemon restarts (persisted
         // in closed-terminals.json), so the connect snapshot ships
         // them too — not just the incremental pushes.
@@ -16351,7 +16954,10 @@ exports.MIRROR_BACKFILL_LINES_DEFAULT = MIRROR_BACKFILL_LINES_DEFAULT;
 exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.STREAM_DELTA_MAX_CHARS = STREAM_DELTA_MAX_CHARS;
 exports.TITLE_PROMPT_PREFIX = TITLE_PROMPT_PREFIX;
+exports.TurnActivityTracker = TurnActivityTracker;
 exports.api = api;
+exports.checkIfDaemonRunningAndCleanupStaleState = checkIfDaemonRunningAndCleanupStaleState;
+exports.cleanupDaemonState = cleanupDaemonState;
 exports.commandOnPath = commandOnPath;
 exports.compareExactVersions = compareExactVersions;
 exports.connectionState = connectionState;
@@ -16371,21 +16977,31 @@ exports.getLocalHappyAgentCredentialPath = getLocalHappyAgentCredentialPath;
 exports.getProjectPath = getProjectPath;
 exports.initializeSandbox = initializeSandbox;
 exports.isClaudeSessionId = isClaudeSessionId;
+exports.isDaemonRunningCurrentlyInstalledHappyVersion = isDaemonRunningCurrentlyInstalledHappyVersion;
 exports.isValidSessionId = isValidSessionId;
 exports.isValidTerminalId = isValidTerminalId;
+exports.listDaemonSessions = listDaemonSessions;
 exports.listVhTerminals = listVhTerminals;
 exports.mirrorLineKey = mirrorLineKey;
 exports.mirrorLocalId = mirrorLocalId;
+exports.notifyDaemonClaudeAuthFailed = notifyDaemonClaudeAuthFailed;
+exports.notifyDaemonSessionEvent = notifyDaemonSessionEvent;
+exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
 exports.parseExactVersion = parseExactVersion;
 exports.parseTerminalHookPayload = parseTerminalHookPayload;
 exports.projectPath = projectPath;
+exports.pushClipboardViaDaemon = pushClipboardViaDaemon;
 exports.readLocalHappyAgentCredentials = readLocalHappyAgentCredentials;
 exports.readVhTerminal = readVhTerminal;
 exports.resolveCliUpdateCheckInterval = resolveCliUpdateCheckInterval;
 exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
 exports.sendToVhTerminal = sendToVhTerminal;
+exports.setTerminalTitleViaDaemon = setTerminalTitleViaDaemon;
 exports.shellescape = shellescape;
+exports.spawnDaemonSession = spawnDaemonSession;
 exports.startOfflineReconnection = startOfflineReconnection;
+exports.stopDaemon = stopDaemon;
+exports.stopDaemonSession = stopDaemonSession;
 exports.streamKeyOf = streamKeyOf;
 exports.summarizeSpawnSessionForLog = summarizeSpawnSessionForLog;
 exports.tmuxArgs = tmuxArgs;