very-happy-cli 0.2.142 → 0.2.144

package/dist/{todo-DeauuUd6.cjs → todo-EffYAnre.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-var persistence = require('./limits-B3hngubn.cjs');
-var api = require('./types-Xd_LJRJN.cjs');
-var agentGuidance = require('./agentGuidance-Bi8iBjy3.cjs');
+var persistence = require('./limits-C_Sklt--.cjs');
+var index = require('./types-DZ5c-9f3.cjs');
+var agentGuidance = require('./agentGuidance-D1PDVswF.cjs');
 require('node:fs/promises');
 require('node:fs');
 require('node:os');
@@ -42,7 +42,7 @@ async function authenticatedBuiltinTodoClient() {
   }
   const credentials = await persistence.readCredentialsForConfiguredRelay();
   if (!credentials) throw new Error("Sign in to Very Happy with `very-happy auth login` before accessing Todos.");
-  return api.createBuiltinTodoClient(credentials, { serverUrl: persistence.configuration.serverUrl, clientId: "very-happy-cli-todo" });
+  return index.createBuiltinTodoClient(credentials, { serverUrl: persistence.configuration.serverUrl, clientId: "very-happy-cli-todo" });
 }
 
 const TODO_HELP = `very-happy todo \u2014 account-owned built-in Todos (JSON output)
@@ -106,7 +106,7 @@ async function handleTodoCommand(args) {
     return;
   }
   if (command.action === "skill") {
-    console.log(api.BUILTIN_TODO_SKILL);
+    console.log(index.BUILTIN_TODO_SKILL);
     return;
   }
   const client = await authenticatedBuiltinTodoClient();

package/dist/{types-Dnoxgb7G.mjs → types-D6YKR7wo.mjs}

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { l as logger, g 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, u as prepareClipboardHistoryText, f as readSettings, r as readPersistedSessions, v as credentialRelayProblem, p as packageJson, x as readTrackedClaudeSessionIds, y as readTrackedCodexThreadIds, z as libsodiumEncryptForPublicKey, A as libsodiumPublicKeyFromSecretKey, B as getRandomBytes, D as redactLogValue } from './limits-CHsz3Ba-.mjs';
+import { l as logger, g 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, v as prepareClipboardHistoryText, r as readSettings, d as readPersistedSessions, x as credentialRelayProblem, p as packageJson, y as readTrackedClaudeSessionIds, z as readTrackedCodexThreadIds, A as libsodiumEncryptForPublicKey, B as libsodiumPublicKeyFromSecretKey, D as getRandomBytes, E as redactLogValue } from './limits-DxArdmkZ.mjs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import * as z from 'zod';
@@ -19,7 +19,7 @@ import { join as join$1, isAbsolute, resolve as resolve$1 } from 'node:path';
 import os$1, { homedir } from 'node:os';
 import { spawn as spawn$2, spawnSync, execSync as execSync$1 } from 'node:child_process';
 import * as pty from 'node-pty';
-import { existsSync, statSync, writeFileSync, unlinkSync, readFileSync, mkdirSync, accessSync, constants, createReadStream, createWriteStream } from 'node:fs';
+import { statSync, readdirSync, existsSync, writeFileSync, unlinkSync, readFileSync, mkdirSync, accessSync, constants, createReadStream, createWriteStream } from 'node:fs';
 import { existsSync as existsSync$1 } from 'fs';
 import tweetnacl from 'tweetnacl';
 import { createInterface } from 'node:readline';
@@ -1356,6 +1356,40 @@ class RpcHandlerManager {
   }
 }
 
+function describeSocketAckDrop(drop) {
+  switch (drop.reason) {
+    case "no-ack":
+      return "no ack callback on the frame (re-delivered after a transport close?); response dropped";
+    case "handler-threw":
+      return `handler threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+    case "ack-threw":
+      return `ack callback threw: ${drop.error instanceof Error ? drop.error.message : String(drop.error)}`;
+  }
+}
+function safeAck(ack, onDrop) {
+  return (value) => {
+    if (typeof ack !== "function") {
+      onDrop({ reason: "no-ack" });
+      return;
+    }
+    try {
+      ack(value);
+    } catch (error) {
+      onDrop({ reason: "ack-threw", error });
+    }
+  };
+}
+async function answerSocketRequest(ack, run, onDrop) {
+  let value;
+  try {
+    value = await run();
+  } catch (error) {
+    onDrop({ reason: "handler-threw", error });
+    return;
+  }
+  safeAck(ack, onDrop)(value);
+}
+
 function run$1(args, options) {
   const RUNNER_PATH = resolve(join(projectPath(), "scripts", "ripgrep_launcher.cjs"));
   return new Promise((resolve2, reject) => {
@@ -3258,7 +3292,11 @@ class ApiSessionClient extends EventEmitter {
       void this.connectSessionRelay();
     });
     this.socket.on("rpc-request", async (data, callback) => {
-      callback(await this.rpcHandlerManager.handleRequest(data));
+      await answerSocketRequest(
+        callback,
+        () => this.rpcHandlerManager.handleRequest(data),
+        (drop) => logger.debug(`[API] RPC ${data?.method} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+      );
     });
     this.socket.on("disconnect", (reason) => {
       logger.debug(`[API] Socket disconnected: ${reason}`);
@@ -3694,9 +3732,14 @@ class ApiSessionClient extends EventEmitter {
         logger.debug(`[API] Session connected to regional relay ${assignment.relayId}`);
       });
       relaySocket.on("rpc-request", async (data, callback) => {
-        callback(await this.rpcHandlerManager.handleRequest(data));
+        await answerSocketRequest(
+          callback,
+          () => this.rpcHandlerManager.handleRequest(data),
+          (drop) => logger.debug(`[API] Relay RPC ${data?.method} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+        );
       });
-      relaySocket.on("session-message-deliver", async (data, callback) => {
+      relaySocket.on("session-message-deliver", async (data, rawCallback) => {
+        const callback = safeAck(rawCallback, (drop) => logger.debug(`[API] session-message-deliver unanswered \u2014 ${describeSocketAckDrop(drop)}`));
         if (data?.sessionId !== this.sessionId || !Array.isArray(data.messages) || data.messages.length === 0 || data.messages.length > 50) {
           callback({ ok: false, error: "Invalid session message request" });
           return;
@@ -4907,17 +4950,315 @@ function scrubTmuxClientEnv(env) {
   return env;
 }
 
-function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join$1(homedir(), ".claude");
+const CLAUDE_CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+const CODEX_HOME_ENV = "CODEX_HOME";
+const AGENT_HOME_ENV_NAMES = [CLAUDE_CONFIG_DIR_ENV, CODEX_HOME_ENV];
+function expandHomePath(value, homeDir) {
+  const trimmed = value.trim();
+  if (trimmed === "~") return homeDir;
+  if (trimmed.startsWith("~/")) return join$1(homeDir, trimmed.slice(2));
+  return isAbsolute(trimmed) ? trimmed : resolve$1(homeDir, trimmed);
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function pick(envName, settingValue, input, defaultRelative) {
+  const fromSettings = nonEmpty(settingValue);
+  if (fromSettings) return { path: expandHomePath(fromSettings, input.homeDir), source: "settings" };
+  const fromShell = nonEmpty(input.loginShellEnv?.[envName]);
+  if (fromShell) return { path: expandHomePath(fromShell, input.homeDir), source: "login-shell" };
+  const fromDaemon = nonEmpty(input.daemonEnv[envName]);
+  if (fromDaemon) return { path: expandHomePath(fromDaemon, input.homeDir), source: "daemon-env" };
+  return { path: join$1(input.homeDir, defaultRelative), source: "default" };
+}
+function resolveAgentHomes(input) {
+  return {
+    claudeConfigDir: pick(CLAUDE_CONFIG_DIR_ENV, input.settings.claudeConfigDir, input, ".claude"),
+    codexHome: pick(CODEX_HOME_ENV, input.settings.codexHome, input, ".codex")
+  };
 }
-function getClaudeProjectsRoot() {
-  return join$1(getClaudeConfigDir(), "projects");
+function agentHomeEnv(homes) {
+  const env = {};
+  if (homes.claudeConfigDir.source !== "default") env[CLAUDE_CONFIG_DIR_ENV] = homes.claudeConfigDir.path;
+  if (homes.codexHome.source !== "default") env[CODEX_HOME_ENV] = homes.codexHome.path;
+  return env;
 }
-function getProjectPath(workingDirectory) {
-  const projectId = resolve$1(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
-  return join$1(getClaudeProjectsRoot(), projectId);
+function claudeProjectDirName(workingDirectory) {
+  return resolve$1(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function claudeConversationPath(configDir, workingDirectory, claudeSessionId) {
+  return join$1(configDir, "projects", claudeProjectDirName(workingDirectory), `${claudeSessionId}.jsonl`);
+}
+function agentHomeCandidates(kind, input, homes = resolveAgentHomes(input)) {
+  const envName = kind === "claude" ? CLAUDE_CONFIG_DIR_ENV : CODEX_HOME_ENV;
+  const resolved = kind === "claude" ? homes.claudeConfigDir : homes.codexHome;
+  const raw = [
+    resolved.path,
+    nonEmpty(kind === "claude" ? input.settings.claudeConfigDir : input.settings.codexHome),
+    nonEmpty(input.loginShellEnv?.[envName]),
+    nonEmpty(input.daemonEnv[envName]),
+    join$1(input.homeDir, kind === "claude" ? ".claude" : ".codex")
+  ];
+  const out = [];
+  for (const value of raw) {
+    if (!value) continue;
+    const expanded = expandHomePath(value, input.homeDir);
+    if (!out.includes(expanded)) out.push(expanded);
+  }
+  return out;
+}
+function findClaudeConversation(claudeSessionId, workingDirectory, candidates, fileSize) {
+  let best = null;
+  let bestSize = -1;
+  for (let i = 0; i < candidates.length; i++) {
+    const file = claudeConversationPath(candidates[i], workingDirectory, claudeSessionId);
+    const size = fileSize(file);
+    if (size === null || size <= bestSize) continue;
+    best = { home: candidates[i], file, resolved: i === 0 };
+    bestSize = size;
+  }
+  return best;
+}
+function codexRolloutFileMatches(fileName, threadId) {
+  return fileName.startsWith("rollout-") && fileName.endsWith(`-${threadId}.jsonl`);
+}
+function findCodexThread(threadId, candidates, listDir) {
+  const digits = /^\d+$/;
+  for (let i = 0; i < candidates.length; i++) {
+    const sessions = join$1(candidates[i], "sessions");
+    for (const year of listDir(sessions).filter((name) => digits.test(name)).sort().reverse()) {
+      for (const month of listDir(join$1(sessions, year)).filter((name) => digits.test(name)).sort().reverse()) {
+        for (const day of listDir(join$1(sessions, year, month)).filter((name) => digits.test(name)).sort().reverse()) {
+          const dayDir = join$1(sessions, year, month, day);
+          const hit = listDir(dayDir).find((name) => codexRolloutFileMatches(name, threadId));
+          if (hit) return { home: candidates[i], file: join$1(dayDir, hit), resolved: i === 0 };
+        }
+      }
+    }
+  }
+  return null;
+}
+function describeAgentHome(choice) {
+  const source = {
+    settings: "settings.json",
+    "login-shell": "login shell",
+    "daemon-env": "daemon environment",
+    default: "default"
+  };
+  return `${choice.path} (${source[choice.source]})`;
 }
 
+const LOGIN_SHELL_ENV_MARKER = "__VH_ENV__";
+const LOGIN_SHELL_PROBE_TIMEOUT_MS = 3e3;
+function loginShellProbeScript(names) {
+  const pairs = names.map((name) => `${name} "$${name}"`).join(" ");
+  return `printf '${LOGIN_SHELL_ENV_MARKER}%s=%s\\n' ${pairs}`;
+}
+function parseLoginShellEnv(output, names) {
+  const wanted = new Set(names);
+  const env = {};
+  for (const rawLine of output.split(/\r?\n/)) {
+    const at = rawLine.indexOf(LOGIN_SHELL_ENV_MARKER);
+    if (at < 0) continue;
+    const line = rawLine.slice(at + LOGIN_SHELL_ENV_MARKER.length);
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const name = line.slice(0, eq);
+    if (!wanted.has(name)) continue;
+    const value = line.slice(eq + 1).trim();
+    env[name] = value ? value : void 0;
+  }
+  return env;
+}
+function probeLoginShellEnv(names, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") return Promise.resolve(null);
+  const shell = (options.shell ?? process.env.SHELL ?? "").trim() || "/bin/sh";
+  const timeoutMs = options.timeoutMs ?? LOGIN_SHELL_PROBE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    let child;
+    try {
+      child = spawn$2(shell, ["-l", "-i", "-c", loginShellProbeScript(names)], {
+        stdio: ["ignore", "pipe", "ignore"],
+        env: options.env ?? process.env,
+        windowsHide: true
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish(null);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => finish(null));
+    child.on("close", () => {
+      finish(stdout.includes(LOGIN_SHELL_ENV_MARKER) ? parseLoginShellEnv(stdout, names) : null);
+    });
+  });
+}
+
+const AGENT_HOME_CACHE_MS = 6e4;
+const AGENT_HOME_FAILURE_CACHE_MS = 5 * 6e4;
+let cache = null;
+let inFlight = null;
+let originalDaemonEnv = null;
+function snapshotDaemonEnv() {
+  if (!originalDaemonEnv) {
+    originalDaemonEnv = {};
+    for (const name of AGENT_HOME_ENV_NAMES) originalDaemonEnv[name] = process.env[name];
+  }
+  return originalDaemonEnv;
+}
+async function load(now) {
+  const settings = await readSettings();
+  const loginShellEnv = await probeLoginShellEnv(AGENT_HOME_ENV_NAMES);
+  const input = {
+    settings: { claudeConfigDir: settings.claudeConfigDir, codexHome: settings.codexHome },
+    daemonEnv: snapshotDaemonEnv(),
+    loginShellEnv,
+    homeDir: homedir()
+  };
+  const homes = resolveAgentHomes(input);
+  return {
+    input,
+    homes,
+    expiresAt: now + (loginShellEnv ? AGENT_HOME_CACHE_MS : AGENT_HOME_FAILURE_CACHE_MS)
+  };
+}
+async function refreshAgentHomes(now = Date.now()) {
+  if (cache && cache.expiresAt > now) return cache.homes;
+  if (!inFlight) {
+    inFlight = load(now).finally(() => {
+      inFlight = null;
+    });
+  }
+  let entry;
+  try {
+    entry = await inFlight;
+  } catch (error) {
+    logger.debug("[AGENT HOME] resolve failed, falling back", error);
+    if (cache) return cache.homes;
+    const input = { settings: {}, daemonEnv: snapshotDaemonEnv(), loginShellEnv: null, homeDir: homedir() };
+    return resolveAgentHomes(input);
+  }
+  const previous = cache?.homes;
+  cache = entry;
+  applyAgentHomesToProcessEnv(entry.homes);
+  if (!previous || previous.claudeConfigDir.path !== entry.homes.claudeConfigDir.path || previous.codexHome.path !== entry.homes.codexHome.path) {
+    logger.debug(`[AGENT HOME] Claude config dir: ${describeAgentHome(entry.homes.claudeConfigDir)}; Codex home: ${describeAgentHome(entry.homes.codexHome)}`);
+  }
+  return entry.homes;
+}
+function currentAgentHomes() {
+  return cache?.homes ?? null;
+}
+function resetAgentHomesCache() {
+  cache = null;
+  inFlight = null;
+  originalDaemonEnv = null;
+}
+function applyAgentHomesToProcessEnv(homes) {
+  const overlay = agentHomeEnv(homes);
+  for (const name of AGENT_HOME_ENV_NAMES) {
+    const next = overlay[name];
+    if (next === void 0) {
+      const original = snapshotDaemonEnv()[name];
+      if (original === void 0) delete process.env[name];
+      else process.env[name] = original;
+    } else if (process.env[name] !== next) {
+      process.env[name] = next;
+    }
+  }
+}
+function listDirSafe(path) {
+  try {
+    return readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+function fileSizeSafe(path) {
+  try {
+    const st = statSync(path);
+    return st.isFile() ? st.size : null;
+  } catch {
+    return null;
+  }
+}
+function locateClaudeConversation(workingDirectory, claudeSessionId) {
+  const entry = cache;
+  if (!entry) {
+    const input = { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: homedir() };
+    return findClaudeConversation(claudeSessionId, workingDirectory, agentHomeCandidates("claude", input), fileSizeSafe);
+  }
+  return findClaudeConversation(claudeSessionId, workingDirectory, agentHomeCandidates("claude", entry.input, entry.homes), fileSizeSafe);
+}
+function locateCodexThread(codexThreadId) {
+  const entry = cache;
+  const input = entry?.input ?? { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: homedir() };
+  return findCodexThread(codexThreadId, agentHomeCandidates("codex", input, entry?.homes), listDirSafe);
+}
+function agentHomeSpawnEnv(input) {
+  const env = {};
+  if (input.claudeSessionId) {
+    const hit = locateClaudeConversation(input.workingDirectory, input.claudeSessionId);
+    if (hit && !hit.resolved) {
+      env[CLAUDE_CONFIG_DIR_ENV] = hit.home;
+      logger.debug(`[AGENT HOME] Claude conversation ${input.claudeSessionId} found under ${hit.home}; overriding ${CLAUDE_CONFIG_DIR_ENV} for this spawn`);
+    }
+  }
+  if (input.codexThreadId) {
+    const hit = locateCodexThread(input.codexThreadId);
+    if (hit && !hit.resolved) {
+      env[CODEX_HOME_ENV] = hit.home;
+      logger.debug(`[AGENT HOME] Codex thread ${input.codexThreadId} found under ${hit.home}; overriding ${CODEX_HOME_ENV} for this spawn`);
+    }
+  }
+  return env;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AGENT_HOME_CACHE_MS: AGENT_HOME_CACHE_MS,
+  AGENT_HOME_ENV_NAMES: AGENT_HOME_ENV_NAMES,
+  AGENT_HOME_FAILURE_CACHE_MS: AGENT_HOME_FAILURE_CACHE_MS,
+  CLAUDE_CONFIG_DIR_ENV: CLAUDE_CONFIG_DIR_ENV,
+  CODEX_HOME_ENV: CODEX_HOME_ENV,
+  agentHomeCandidates: agentHomeCandidates,
+  agentHomeEnv: agentHomeEnv,
+  agentHomeSpawnEnv: agentHomeSpawnEnv,
+  claudeConversationPath: claudeConversationPath,
+  claudeProjectDirName: claudeProjectDirName,
+  codexRolloutFileMatches: codexRolloutFileMatches,
+  currentAgentHomes: currentAgentHomes,
+  describeAgentHome: describeAgentHome,
+  expandHomePath: expandHomePath,
+  findClaudeConversation: findClaudeConversation,
+  findCodexThread: findCodexThread,
+  locateClaudeConversation: locateClaudeConversation,
+  locateCodexThread: locateCodexThread,
+  probeLoginShellEnv: probeLoginShellEnv,
+  refreshAgentHomes: refreshAgentHomes,
+  resetAgentHomesCache: resetAgentHomesCache,
+  resolveAgentHomes: resolveAgentHomes
+});
+
 var xtermHeadless = {};
 
 var hasRequiredXtermHeadless;
@@ -11278,7 +11619,8 @@ class WebTerminalManager {
           return false;
         }
       },
-      conversationExists: (cwd, claudeSessionId) => existsSync(join$1(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
+      // B-478: every Claude config dir the user might have pointed a shell at.
+      conversationExists: (cwd, claudeSessionId) => locateClaudeConversation(cwd, claudeSessionId) !== null,
       // B-273: only consulted for records that were attach terminals.
       // Unbounded: the panel's 50-row cap must not hide a restore target.
       userSessions: record.attachTmux ? this.listUserTmuxSessions(Infinity) : [],
@@ -12628,6 +12970,17 @@ function detectResumeSupport(happyHomeDir = configuration.happyHomeDir) {
   };
 }
 
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join$1(homedir(), ".claude");
+}
+function getClaudeProjectsRoot() {
+  return join$1(getClaudeConfigDir(), "projects");
+}
+function getProjectPath(workingDirectory) {
+  const projectId = resolve$1(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  return join$1(getClaudeProjectsRoot(), projectId);
+}
+
 const TITLE_PROMPT_PREFIX = "Summarize the SPECIFIC topic/request of this message into a 3-6 word title";
 const BOARD_ANALYZER_PROMPT_PREFIX = "You are a status analyzer for a task board of coding-agent sessions.";
 const VERY_HAPPY_ONE_SHOT_PROMPT_PREFIXES = [
@@ -15729,7 +16082,11 @@ class ApiMachineClient {
   bindRpcRequestHandler(socket, transport) {
     socket.on("rpc-request", async (data, callback) => {
       logger.debugLargeJson(`[API MACHINE] Received RPC request via ${transport}:`, data);
-      callback(await this.rpcHandlerManager.handleRequest(data));
+      await answerSocketRequest(
+        callback,
+        () => this.rpcHandlerManager.handleRequest(data),
+        (drop) => logger.debug(`[API MACHINE] RPC ${data?.method} via ${transport} unanswered \u2014 ${describeSocketAckDrop(drop)}`)
+      );
     });
   }
   bindMachineCommandHandlers(socket) {
@@ -16933,4 +17290,4 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-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, pushFilePreviewViaDaemon as f, setTerminalTitleViaDaemon as g, connectionState as h, isValidSessionId as i, BUILTIN_TODO_DISCOVERY as j, errorLogMetadata as k, contentLogMetadata as l, delay as m, notifyDaemonSessionStarted as n, notifyDaemonSessionEvent as o, pushClipboardViaDaemon 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 };
+export { detectResumeSupport as $, ApiClient as A, BUILTIN_TODO_SKILL as B, notifyDaemonClaudeAuthFailed as C, commandOnPath as D, deriveLocalCliUpdateSummary as E, AGENT_VERSION_SOURCES as F, isClaudeSessionId as G, getLocalHappyAgentCredentialPath as H, InvalidateSync as I, readLocalHappyAgentCredentials as J, parseExactVersion as K, compareExactVersions as L, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, extractCompleteLines as N, decideBackfill as O, parseTerminalHookPayload as P, tmuxArgs as Q, RawJSONLinesSchema as R, STREAM_DELTA_MAX_CHARS as S, scrubTmuxClientEnv as T, decideMirrorBinding as U, MIRROR_BACKFILL_LINES_DEFAULT as V, mirrorLineKey as W, mirrorLocalId as X, listDaemonSessions as Y, stopDaemonSession as Z, detectCLIAvailability as _, ApiSessionClient as a, refreshAgentHomes as a0, isDaemonRunningCurrentlyInstalledHappyVersion as a1, stopDaemon as a2, TurnActivityTracker as a3, summarizeSpawnSessionForLog as a4, locateClaudeConversation as a5, agentHomeSpawnEnv as a6, shellescape as a7, fetchCliUpdateState as a8, resolveCliUpdateCheckInterval as a9, DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS as aa, cleanupDaemonState as ab, listVhTerminals as ac, isValidTerminalId as ad, readVhTerminal as ae, sendToVhTerminal as af, ContextUsageSchema as ag, TITLE_PROMPT_PREFIX as ah, BOARD_ANALYZER_PROMPT_PREFIX as ai, startOfflineReconnection as aj, CodexAppServerClient as ak, index as al, api as am, AGENT_HOME_ENV_NAMES as b, checkIfDaemonRunningAndCleanupStaleState as c, describeAgentHome as d, expandHomePath as e, streamKeyOf as f, createEnvelope as g, createBuiltinTodoClient as h, isValidSessionId as i, pushClipboardViaDaemon as j, pushFilePreviewViaDaemon as k, setTerminalTitleViaDaemon as l, connectionState as m, notifyDaemonSessionStarted as n, BUILTIN_TODO_DISCOVERY as o, probeLoginShellEnv as p, errorLogMetadata as q, resolveAgentHomes as r, spawnDaemonSession as s, contentLogMetadata as t, delay as u, notifyDaemonSessionEvent as v, getProjectPath as w, initializeSandbox as x, wrapCommand as y, AsyncLock as z };