very-happy-cli 0.2.138 → 0.2.140

package/dist/{types-D5EsIAOe.mjs → types-thyvQB2a.mjs}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { l as logger, i as encodeBase64, j as encrypt, k as decrypt, m as decodeBase64, c as configuration, o as decryptBlob, q as prepareClipboardText, g as readSettings, r as readPersistedSessions, s as credentialRelayProblem, p as packageJson, t as readTrackedClaudeSessionIds, u as libsodiumEncryptForPublicKey, v as libsodiumPublicKeyFromSecretKey, x as getRandomBytes, y as redactLogValue } from './limits-DEsg_gHi.mjs';
+import { l as logger, i as encodeBase64, j as encrypt, k as decrypt, m as decodeBase64, c as configuration, o as readDaemonState, q as clearDaemonState, s as decryptBlob, t as prepareClipboardText, g as readSettings, r as readPersistedSessions, u as credentialRelayProblem, p as packageJson, v as readTrackedClaudeSessionIds, x as readTrackedCodexThreadIds, y as libsodiumEncryptForPublicKey, z as libsodiumPublicKeyFromSecretKey, A as getRandomBytes, B as redactLogValue } from './limits-nhD0Wran.mjs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import * as z from 'zod';
@@ -982,6 +982,15 @@ z$1.object({
     rpcAvailable: z$1.boolean(),
     detectedAt: z$1.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$1.object({
+    rpcAvailable: z$1.boolean(),
+    detectedAt: z$1.number()
+  }).optional(),
   /** Relay-owned CLI compatibility/update policy last checked by this daemon. */
   cliUpdate: CliUpdateStateSchema.optional(),
   /**
@@ -2889,6 +2898,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 readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    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";
+    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}`;
+      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"}`;
+    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 readDaemonState();
+  if (!state) {
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch {
+    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 {
+      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() {
+  logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await readDaemonState();
+  if (!state) {
+    logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  const currentCliVersion = configuration.currentCliVersion;
+  logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+  return currentCliVersion === state.startedWithCliVersion;
+}
+async function cleanupDaemonState() {
+  try {
+    await clearDaemonState();
+    logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+async function stopDaemon() {
+  try {
+    const state = await readDaemonState();
+    if (!state) {
+      logger.debug("No daemon state found");
+      return;
+    }
+    logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      logger.debug("Force killed daemon");
+    } catch (error) {
+      logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    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 EventEmitter {
   token;
   sessionId;
@@ -3670,10 +3941,14 @@ class ApiSessionClient extends 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) => logger.debug("[API] Failed to report turn event to daemon:", error)));
   keepAlive(thinking, mode) {
     if (process.env.DEBUG) {
       logger.debug(`[API] Sending keep alive message: ${thinking}`);
     }
+    this.turnReporter.observe(thinking);
     this.socket.volatile.emit("session-alive", {
       sid: this.sessionId,
       time: Date.now(),
@@ -12362,7 +12637,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 {
@@ -12381,7 +12656,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;
@@ -12393,7 +12668,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 = join$1(dir, name);
       try {
         const s = await stat$1(path);
@@ -12412,7 +12687,7 @@ async function collectCandidates(projectDirs, exclude) {
     return true;
   });
 }
-async function readHead(path, bytes) {
+async function readHead$1(path, bytes) {
   const fh = await open(path, "r");
   try {
     const buffer = Buffer.alloc(bytes);
@@ -12422,11 +12697,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);
@@ -12453,7 +12728,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;
     }
@@ -12461,7 +12736,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;
@@ -12473,7 +12748,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;
       }
     }
@@ -12499,7 +12774,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;
@@ -12511,7 +12786,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;
     }
@@ -13950,6 +14225,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 || join$1(homedir(), ".codex");
+}
+function getCodexSessionsRoot(codexHome = getCodexHomeDir()) {
+  return join$1(codexHome, "sessions");
+}
+function getCodexSessionIndexPath(codexHome = getCodexHomeDir()) {
+  return join$1(codexHome, "session_index.jsonl");
+}
+async function collectCandidates(root, exclude) {
+  const out = [];
+  async function walk(dir, depth) {
+    let names;
+    try {
+      names = await readdir$1(dir);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const full = join$1(dir, name);
+      const match = ROLLOUT_RE.exec(name);
+      if (match) {
+        const id = match[1].toLowerCase();
+        if (exclude.has(id)) continue;
+        try {
+          const s = await stat$1(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 stat$1(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 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 readFile$1(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;
@@ -14667,6 +15171,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)) : [],
+        ...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;
+      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");
@@ -15015,6 +15558,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.
@@ -16371,4 +16916,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { CodexAppServerClient as $, ApiClient as A, BUILTIN_TODO_SKILL as B, tmuxArgs as C, scrubTmuxClientEnv as D, decideMirrorBinding as E, MIRROR_BACKFILL_LINES_DEFAULT as F, mirrorLineKey as G, mirrorLocalId as H, InvalidateSync as I, detectCLIAvailability as J, detectResumeSupport as K, summarizeSpawnSessionForLog as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, shellescape as N, fetchCliUpdateState as O, resolveCliUpdateCheckInterval as P, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, listVhTerminals as T, isValidTerminalId as U, readVhTerminal as V, sendToVhTerminal as W, ContextUsageSchema as X, TITLE_PROMPT_PREFIX as Y, BOARD_ANALYZER_PROMPT_PREFIX as Z, startOfflineReconnection as _, ApiSessionClient as a, api as a0, createBuiltinTodoClient as b, createEnvelope as c, contentLogMetadata as d, errorLogMetadata as e, connectionState as f, BUILTIN_TODO_DISCOVERY as g, delay as h, isValidSessionId as i, getProjectPath as j, initializeSandbox as k, AsyncLock as l, commandOnPath as m, deriveLocalCliUpdateSummary as n, AGENT_VERSION_SOURCES as o, projectPath as p, isClaudeSessionId as q, getLocalHappyAgentCredentialPath as r, streamKeyOf as s, readLocalHappyAgentCredentials as t, parseExactVersion as u, compareExactVersions as v, wrapCommand as w, extractCompleteLines as x, decideBackfill as y, parseTerminalHookPayload as z };
+export { shellescape as $, ApiClient as A, BUILTIN_TODO_SKILL as B, getLocalHappyAgentCredentialPath as C, readLocalHappyAgentCredentials as D, parseExactVersion as E, compareExactVersions as F, extractCompleteLines as G, decideBackfill as H, InvalidateSync as I, parseTerminalHookPayload as J, tmuxArgs as K, scrubTmuxClientEnv as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, decideMirrorBinding as N, MIRROR_BACKFILL_LINES_DEFAULT as O, mirrorLineKey as P, mirrorLocalId as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, listDaemonSessions as T, stopDaemonSession as U, detectCLIAvailability as V, detectResumeSupport as W, isDaemonRunningCurrentlyInstalledHappyVersion as X, stopDaemon as Y, TurnActivityTracker as Z, summarizeSpawnSessionForLog as _, ApiSessionClient as a, fetchCliUpdateState as a0, resolveCliUpdateCheckInterval as a1, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as a2, cleanupDaemonState as a3, listVhTerminals as a4, isValidTerminalId as a5, readVhTerminal as a6, sendToVhTerminal as a7, ContextUsageSchema as a8, TITLE_PROMPT_PREFIX as a9, BOARD_ANALYZER_PROMPT_PREFIX as aa, startOfflineReconnection as ab, CodexAppServerClient as ac, api as ad, streamKeyOf as b, checkIfDaemonRunningAndCleanupStaleState as c, createEnvelope as d, createBuiltinTodoClient as e, pushClipboardViaDaemon as f, setTerminalTitleViaDaemon as g, errorLogMetadata as h, isValidSessionId as i, contentLogMetadata as j, connectionState as k, BUILTIN_TODO_DISCOVERY as l, delay as m, notifyDaemonSessionStarted as n, notifyDaemonSessionEvent as o, projectPath as p, getProjectPath as q, initializeSandbox as r, spawnDaemonSession as s, AsyncLock as t, notifyDaemonClaudeAuthFailed as u, commandOnPath as v, wrapCommand as w, deriveLocalCliUpdateSummary as x, AGENT_VERSION_SOURCES as y, isClaudeSessionId as z };