very-happy-cli 0.2.137 → 0.2.139

package/dist/{index-D5MRxCHs.mjs → index-BZr5l8TH.mjs}

@@ -1,13 +1,13 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
 import os, { homedir, userInfo, tmpdir } from 'node:os';
 import { randomUUID, randomInt, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
-import { j as getProjectPath, g as BUILTIN_TODO_DISCOVERY, p as projectPath, k as initializeSandbox, w as wrapCommand, d as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, h as delay, l as AsyncLock, S as STREAM_DELTA_MAX_CHARS, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, m as commandOnPath, n as deriveLocalCliUpdateSummary, o as AGENT_VERSION_SOURCES, q as isClaudeSessionId, r as getLocalHappyAgentCredentialPath, t as readLocalHappyAgentCredentials, u as parseExactVersion, v as compareExactVersions, x as extractCompleteLines, y as decideBackfill, z as parseTerminalHookPayload, C as tmuxArgs, D as scrubTmuxClientEnv, E as decideMirrorBinding, F as MIRROR_BACKFILL_LINES_DEFAULT, G as mirrorLineKey, H as mirrorLocalId, J as detectCLIAvailability, K as detectResumeSupport, L as summarizeSpawnSessionForLog, N as shellescape, A as ApiClient, O as fetchCliUpdateState, P as resolveCliUpdateCheckInterval, Q as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, i as isValidSessionId, T as listVhTerminals, U as isValidTerminalId, V as readVhTerminal, W as sendToVhTerminal, X as ContextUsageSchema, Y as TITLE_PROMPT_PREFIX, Z as BOARD_ANALYZER_PROMPT_PREFIX, f as connectionState, _ as startOfflineReconnection, c as createEnvelope, $ as CodexAppServerClient } from './types-B8g_V-LQ.mjs';
-import { z as readDaemonState, l as logger, c as configuration, A as clearDaemonState, B as ensurePrivateDirectory, D as hardenPrivateFile, p as packageJson, g as readSettings, E as readCredentials, s as credentialRelayProblem, i as encodeBase64, F as readSettingsOutcome, G as updateSettings, H as encodeBase64Url, m as decodeBase64, I as writeCredentialsLegacy, J as writeCredentialsDataKey, d as readCredentialsForConfiguredRelay, j as encrypt, r as readPersistedSessions, w as writePrivateFileSync, K as decryptWithDataKey, L as decryptLegacy, M as persistSession, k as decrypt, f as ensurePrivateDirectorySync, N as acquireDaemonLock, O as deletePersistedSessions, P as writeDaemonState, Q as writeSettings, R as releaseDaemonLock, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, e as CLIPBOARD_MAX_BYTES, S as clearCredentials, T as clearMachineId, U as SandboxConfigSchema, V as getLatestDaemonLog } from './limits-CAD4UF8w.mjs';
+import { o as notifyDaemonSessionEvent, q as getProjectPath, l as BUILTIN_TODO_DISCOVERY, p as projectPath, r as initializeSandbox, w as wrapCommand, j as contentLogMetadata, I as InvalidateSync, R as RawJSONLinesSchema, m as delay, t as AsyncLock, S as STREAM_DELTA_MAX_CHARS, M as MAX_CHAT_ATTACHMENT_SOURCE_BYTES, u as notifyDaemonClaudeAuthFailed, v as commandOnPath, c as checkIfDaemonRunningAndCleanupStaleState, x as deriveLocalCliUpdateSummary, y as AGENT_VERSION_SOURCES, z as isClaudeSessionId, C as getLocalHappyAgentCredentialPath, D as readLocalHappyAgentCredentials, E as parseExactVersion, F as compareExactVersions, G as extractCompleteLines, H as decideBackfill, J as parseTerminalHookPayload, K as tmuxArgs, L as scrubTmuxClientEnv, N as decideMirrorBinding, O as MIRROR_BACKFILL_LINES_DEFAULT, P as mirrorLineKey, Q as mirrorLocalId, T as listDaemonSessions, U as stopDaemonSession, V as detectCLIAvailability, W as detectResumeSupport, X as isDaemonRunningCurrentlyInstalledHappyVersion, Y as stopDaemon, Z as TurnActivityTracker, _ as summarizeSpawnSessionForLog, $ as shellescape, A as ApiClient, a0 as fetchCliUpdateState, a1 as resolveCliUpdateCheckInterval, a2 as DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS, a3 as cleanupDaemonState, i as isValidSessionId, s as spawnDaemonSession, a4 as listVhTerminals, a5 as isValidTerminalId, a6 as readVhTerminal, a7 as sendToVhTerminal, a8 as ContextUsageSchema, a9 as TITLE_PROMPT_PREFIX, aa as BOARD_ANALYZER_PROMPT_PREFIX, k as connectionState, ab as startOfflineReconnection, n as notifyDaemonSessionStarted, d as createEnvelope, ac as CodexAppServerClient } from './types-CrKeJuyF.mjs';
+import { l as logger, D as ensurePrivateDirectory, E as hardenPrivateFile, c as configuration, p as packageJson, g as readSettings, F as readCredentials, u as credentialRelayProblem, o as readDaemonState, i as encodeBase64, G as readSettingsOutcome, H as updateSettings, I as encodeBase64Url, m as decodeBase64, J as writeCredentialsLegacy, K as writeCredentialsDataKey, d as readCredentialsForConfiguredRelay, j as encrypt, r as readPersistedSessions, w as writePrivateFileSync, L as decryptWithDataKey, M as decryptLegacy, N as persistSession, k as decrypt, f as ensurePrivateDirectorySync, O as acquireDaemonLock, P as deletePersistedSessions, Q as writeDaemonState, R as writeSettings, S as releaseDaemonLock, C as CLIPBOARD_TOOL_NAME, a as CLIPBOARD_TOOL_TITLE, b as CLIPBOARD_TOOL_DESCRIPTION, e as CLIPBOARD_MAX_BYTES, T as clearCredentials, U as clearMachineId, V as SandboxConfigSchema, W as getLatestDaemonLog } from './limits-DefXc1TL.mjs';
 import spawn$1, { spawn } from 'cross-spawn';
 import path, { join, resolve, basename, isAbsolute, dirname, sep, delimiter, normalize } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, unlinkSync, renameSync, writeFileSync, accessSync, constants, openSync, fsyncSync, closeSync, rmSync as rmSync$1, chmodSync as chmodSync$1 } from 'node:fs';
-import { f as trimIdent, A as AGENT_GUIDANCE, t as teamScopePath, T as TeamConnectionPreflightError, e as createTeamsClient, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, g as TEAM_TOOL_NAMES, r as registerTeamsTools, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, h as REPORT_PROGRESS_TOOL_TITLE, i as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-DulugsMk.mjs';
+import { f as trimIdent, A as AGENT_GUIDANCE, t as teamScopePath, T as TeamConnectionPreflightError, e as createTeamsClient, P as PREVIEW_TOOL_NAME, R as REPORT_PROGRESS_TOOL_NAME, g as TEAM_TOOL_NAMES, r as registerTeamsTools, a as PREVIEW_TOOL_TITLE, b as PREVIEW_TOOL_DESCRIPTION, h as REPORT_PROGRESS_TOOL_TITLE, i as REPORT_PROGRESS_TOOL_DESCRIPTION } from './agentGuidance-DRnXdFAY.mjs';
 import { readFile, writeFile, rename, unlink, mkdir, symlink, rm, readlink, lstat, stat, open as open$1, appendFile } from 'node:fs/promises';
 import fs, { watch, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
@@ -93,212 +93,6 @@ function withoutServerSnapshot(response) {
   return { ...response, metadataVersion: 0, agentStateVersion: 0 };
 }
 
-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 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 Session {
   path;
   logPath;
@@ -6259,6 +6053,7 @@ function startDaemonControlServer({
   onHappySessionWebhook,
   onSessionStateEvent,
   onClaudeAuthFailed,
+  onSessionTurnEvent,
   pushClipboard,
   onTerminalHook,
   setTerminalTitle
@@ -6315,7 +6110,7 @@ function startDaemonControlServer({
       schema: {
         body: z.object({
           sessionId: z.string(),
-          event: z.enum(["completed", "needs_input", "auth_failed"]),
+          event: z.enum(["completed", "needs_input", "auth_failed", "turn_started", "turn_ended"]),
           spawnedBy: z.string().optional()
         }),
         response: {
@@ -6331,6 +6126,10 @@ function startDaemonControlServer({
         onClaudeAuthFailed?.(sessionId);
         return { status: "ok" };
       }
+      if (event === "turn_started" || event === "turn_ended") {
+        onSessionTurnEvent?.(sessionId, event);
+        return { status: "ok" };
+      }
       onSessionStateEvent?.(sessionId, event, spawnedBy);
       return { status: "ok" };
     });
@@ -10225,6 +10024,7 @@ async function startDaemon() {
     const { credentials, machineId } = await authAndSetupMachineIfNeeded();
     logger.debug("[DAEMON RUN] Auth and machine setup complete");
     const pidToTrackedSession = /* @__PURE__ */ new Map();
+    const turnActivity = new TurnActivityTracker();
     const sessionIdToFinishedSession = /* @__PURE__ */ new Map();
     let teamWorker;
     const persisted = readPersistedSessions();
@@ -10496,6 +10296,9 @@ async function startDaemon() {
         if (options.resumeCodexThreadId) {
           extraEnv.HAPPY_FORK_CODEX_THREAD_ID = options.resumeCodexThreadId;
         }
+        if (options.importCodexThreadId && UUID_RE.test(options.importCodexThreadId)) {
+          extraEnv.HAPPY_IMPORT_CODEX_THREAD_ID = options.importCodexThreadId;
+        }
         if (options.variant === "assistant") {
           extraEnv.HAPPY_SESSION_VARIANT = "assistant";
         }
@@ -11060,6 +10863,7 @@ async function startDaemon() {
     const onChildExited = (pid) => {
       const session = pidToTrackedSession.get(pid);
       if (session?.happySessionId && (session.spawnedBy === "teams" || teamWorker?.hasSession(session.happySessionId))) teamWorker?.report(session.happySessionId, "exited");
+      if (session?.happySessionId) turnActivity.forget(session.happySessionId);
       if (session?.happySessionId && session.encryption) {
         sessionIdToFinishedSession.set(session.happySessionId, session);
         logger.debug(`[DAEMON RUN] Process PID ${pid} exited, preserved session ${session.happySessionId} for resume`);
@@ -11141,6 +10945,7 @@ async function startDaemon() {
       onHappySessionWebhook,
       onSessionStateEvent,
       onClaudeAuthFailed: (sessionId) => claudeAuthServiceRef?.signalAuthFailed(sessionId),
+      onSessionTurnEvent: (sessionId, event) => turnActivity.apply(sessionId, event),
       pushClipboard: (text) => {
         if (!apiMachineRef) {
           return { delivered: false, truncated: false, totalBytes: 0, error: "daemon is still starting up" };
@@ -11253,7 +11058,10 @@ async function startDaemon() {
     const updateController = createUpdateController({
       policy: () => fetchCliUpdateState(configuration.serverUrl, packageJson.version),
       enabled: async () => ((await readSettings()).cliAutoUpdate ?? "idle") !== "off",
-      idle: () => pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals(),
+      // B-466: "idle" = no agent turn in flight. Idle wrappers survive a
+      // handover (they talk to the server themselves) and web terminals live
+      // in tmux, so neither is a reason to hold an update.
+      idle: () => !turnActivity.hasActiveTurn(),
       install: installCliSafely,
       publish: (state) => {
         cliUpdateStateRef = state;
@@ -11308,7 +11116,7 @@ async function startDaemon() {
             } catch {
             }
           }
-          if (bundleReplaced && !teamWorker?.busy && !updateController.isRunning() && pidToTrackedSession.size === 0 && !apiMachine.hasLiveTerminals()) {
+          if (bundleReplaced && !teamWorker?.busy && !updateController.isRunning() && !turnActivity.hasActiveTurn()) {
             const preflight = await preflightNewBundle(bundlePath);
             if (preflight.action === "hold") {
               if (lastHandoverHold !== preflight.reason) {
@@ -11318,7 +11126,7 @@ async function startDaemon() {
               updateController.holdHandover(preflight.reason);
               return;
             }
-            if (teamWorker?.busy || updateController.isRunning() || pidToTrackedSession.size > 0 || apiMachine.hasLiveTerminals()) return;
+            if (teamWorker?.busy || updateController.isRunning() || turnActivity.hasActiveTurn()) return;
             lastHandoverHold = null;
             logger.debug("[DAEMON RUN] Daemon bundle replaced on disk and verified, handing off to new daemon");
             teamWorker?.stop();
@@ -12476,7 +12284,7 @@ function registerSideQuestionHandler(rpc, deps) {
   const retainMs = deps.retainMs ?? SIDE_QUESTION_RETAIN_MS;
   const maxRunMs = deps.maxRunMs ?? SIDE_QUESTION_MAX_RUN_MS;
   const run = deps.run ?? (async (input) => {
-    const { query } = await import('./index-C3agc8KT.mjs');
+    const { query } = await import('./index-CTemcNko.mjs');
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -16572,6 +16380,43 @@ async function resumeExistingThread(opts) {
   }
 }
 
+const IMPORT_CODEX_THREAD_ENV = "HAPPY_IMPORT_CODEX_THREAD_ID";
+async function importCodexThread(opts) {
+  let forked;
+  try {
+    forked = await opts.client.forkThread({
+      threadId: opts.threadId,
+      cwd: opts.cwd,
+      mcpServers: opts.mcpServers
+    });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to import Codex thread ${opts.threadId}: ${reason}`);
+  }
+  if (!forked.threadId || forked.threadId === opts.threadId) {
+    throw new Error(`Failed to import Codex thread ${opts.threadId}: Codex did not create an independent copy`);
+  }
+  opts.session.updateMetadata((currentMetadata) => ({
+    ...currentMetadata,
+    codexThreadId: forked.threadId,
+    importedFromCodexThreadId: opts.threadId
+  }));
+  let thread = forked.thread;
+  if (!Array.isArray(thread?.turns)) {
+    thread = (await opts.client.readThread({ threadId: forked.threadId, includeTurns: true })).thread;
+  }
+  const envelopes = mapCodexThreadToSessionEnvelopes(thread);
+  for (const envelope of envelopes) {
+    opts.session.sendSessionProtocolMessage(envelope);
+  }
+  opts.messageBuffer.addMessage(`Imported thread ${trimIdent(opts.threadId)} as ${trimIdent(forked.threadId)}`, "status");
+  opts.session.sendSessionEvent({
+    type: "message",
+    message: `Imported Codex thread ${opts.threadId} (continuing as ${forked.threadId})`
+  });
+  return { threadId: forked.threadId, model: forked.model, replayed: envelopes.length };
+}
+
 function emitReadyIfIdle({ pending, queueSize, shouldExit, sendReady, notify }) {
   if (shouldExit) {
     return false;
@@ -16587,6 +16432,72 @@ function emitReadyIfIdle({ pending, queueSize, shouldExit, sendReady, notify })
   return true;
 }
 
+const DEFAULT_CODEX_IDLE_RELEASE_MS = 5 * 60 * 1e3;
+const CODEX_IDLE_RELEASE_ENV = "HAPPY_CODEX_IDLE_RELEASE_MS";
+function resolveCodexIdleReleaseMs(raw) {
+  if (raw === void 0 || raw.trim() === "") return DEFAULT_CODEX_IDLE_RELEASE_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_CODEX_IDLE_RELEASE_MS;
+  return Math.floor(parsed);
+}
+function shouldReleaseIdleCodex(state) {
+  if (state.shouldExit) return false;
+  if (state.turnActive) return false;
+  if (state.abortInProgress) return false;
+  if (state.queueSize > 0) return false;
+  return true;
+}
+class CodexIdleReleaseTimer {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  timer = null;
+  releasing = null;
+  get enabled() {
+    return this.opts.delayMs > 0;
+  }
+  get armed() {
+    return this.timer !== null;
+  }
+  arm() {
+    this.cancel();
+    if (!this.enabled) return;
+    const timer = setTimeout(() => {
+      if (this.timer !== timer) return;
+      this.timer = null;
+      void this.fire();
+    }, this.opts.delayMs);
+    timer.unref?.();
+    this.timer = timer;
+  }
+  cancel() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Resolves once an in-flight release (if any) has finished. Test hook. */
+  async settle() {
+    await this.releasing;
+  }
+  async fire() {
+    if (!this.opts.isIdle()) return;
+    const run = (async () => {
+      try {
+        await this.opts.release();
+      } catch (error) {
+        this.opts.onError?.(error);
+      }
+    })();
+    this.releasing = run;
+    try {
+      await run;
+    } finally {
+      if (this.releasing === run) this.releasing = null;
+    }
+  }
+}
+
 function isCodexClearText(text) {
   return parseSpecialCommand(text).type === "clear";
 }
@@ -16720,6 +16631,12 @@ async function runCodex(opts) {
     ...forkedFromMessageId ? { forkedFromMessageId } : {}
   });
   metadata.attachmentKinds = [...CLAUDE_ATTACHMENT_KINDS];
+  const importCodexThreadId = process.env[IMPORT_CODEX_THREAD_ENV];
+  if (importCodexThreadId) {
+    metadata.importedFromCodexThreadId = importCodexThreadId;
+    const importTitle = process.env.HAPPY_IMPORT_TITLE;
+    if (importTitle) metadata.summary = { text: importTitle, updatedAt: Date.now() };
+  }
   const reconnectSessionId = process.env.HAPPY_RECONNECT_SESSION_ID;
   const reconnectKeyBase64 = process.env.HAPPY_RECONNECT_ENCRYPTION_KEY;
   const reconnectVariant = process.env.HAPPY_RECONNECT_ENCRYPTION_VARIANT;
@@ -16765,6 +16682,7 @@ async function runCodex(opts) {
   let client;
   let reasoningProcessor;
   let abortInProgress = null;
+  let turnActive = false;
   const { session: initialSession, reconnectionHandle } = setupOfflineReconnection({
     api,
     sessionTag,
@@ -17053,6 +16971,22 @@ async function runCodex(opts) {
     process.stdin.setEncoding("utf8");
   }
   client = new CodexAppServerClient(sandboxConfig);
+  const idleRelease = new CodexIdleReleaseTimer({
+    delayMs: resolveCodexIdleReleaseMs(process.env[CODEX_IDLE_RELEASE_ENV]),
+    isIdle: () => shouldReleaseIdleCodex({
+      turnActive,
+      queueSize: messageQueue.size(),
+      shouldExit,
+      abortInProgress: abortInProgress !== null
+    }),
+    release: async () => {
+      const released = await client.releaseIdleProcess();
+      if (released) {
+        logger.debug("[Codex] Released idle app-server; thread kept for resume on next message");
+      }
+    },
+    onError: (error) => logger.debug("[Codex] Idle app-server release failed", safeCodexErrorMetadata(error))
+  });
   permissionHandler = new CodexPermissionHandler(session);
   permissionHandler.reset("Previous CLI process exited before responding");
   reasoningProcessor = new ReasoningProcessor((message) => {
@@ -17221,6 +17155,18 @@ async function runCodex(opts) {
       first = false;
       appendSystemPromptInjected = true;
     }
+    if (!reconnectSessionId && !opts.resumeThreadId && importCodexThreadId) {
+      await importCodexThread({
+        client,
+        session,
+        messageBuffer,
+        threadId: importCodexThreadId,
+        cwd: process.cwd(),
+        mcpServers
+      });
+      first = false;
+      appendSystemPromptInjected = true;
+    }
     const forkCodexThreadId = process.env.HAPPY_FORK_CODEX_THREAD_ID;
     if (!reconnectSessionId && forkCodexThreadId) {
       try {
@@ -17242,6 +17188,7 @@ async function runCodex(opts) {
       }
     }
     let pending = null;
+    idleRelease.arm();
     while (!shouldExit) {
       logActiveHandles("loop-top");
       let message = pending;
@@ -17262,6 +17209,8 @@ async function runCodex(opts) {
       if (!message) {
         break;
       }
+      idleRelease.cancel();
+      turnActive = true;
       if (isCodexClearText(message.message)) {
         logger.debug("[Codex] Handling /clear command - resetting Codex thread state");
         client.clearThreadState();
@@ -17288,10 +17237,13 @@ async function runCodex(opts) {
           shouldExit,
           sendReady
         });
+        turnActive = false;
+        idleRelease.arm();
         continue;
       }
       messageBuffer.addMessage(message.message, "user");
       try {
+        await client.ensureConnected();
         const sandboxManagedByHappy = client.sandboxEnabled;
         const executionPolicy = resolveCodexExecutionPolicy(
           message.mode.permissionMode,
@@ -17358,6 +17310,8 @@ async function runCodex(opts) {
           shouldExit,
           sendReady
         });
+        turnActive = false;
+        idleRelease.arm();
         logActiveHandles("after-turn");
       }
     }
@@ -17381,6 +17335,7 @@ async function runCodex(opts) {
     } catch (e) {
       logger.debug("[codex]: Error while closing session", safeCodexErrorMetadata(e));
     }
+    idleRelease.cancel();
     logger.debug("[codex]: client.disconnect begin");
     await client.disconnect();
     logger.debug("[codex]: client.disconnect done");
@@ -17565,7 +17520,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     process.exit(0);
   } else if (subcommand === "install-terminal-hooks") {
     try {
-      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-DfZTXVWO.mjs');
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-8CHTgUC-.mjs');
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -17582,7 +17537,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await import('./spawn-D3P8wJ_r.mjs');
+      const { handleSpawnCommand } = await import('./spawn-DFIyobCt.mjs');
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17594,7 +17549,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await import('./sessions-TLUfYdLX.mjs');
+      const { handleSessionsCommand } = await import('./sessions-Dh0Lg-5z.mjs');
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17606,7 +17561,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await import('./send-BN2PncAH.mjs');
+      const { handleSendCommand } = await import('./send-BT32Jiel.mjs');
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17712,9 +17667,9 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
       const projectId = args[3];
       try {
-        const { saveGoogleCloudProjectToConfig } = await import('./config-C1gQprK_.mjs');
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-CAD4UF8w.mjs').then(function (n) { return n.W; });
-        const { ApiClient: ApiClient2 } = await import('./types-B8g_V-LQ.mjs').then(function (n) { return n.a0; });
+        const { saveGoogleCloudProjectToConfig } = await import('./config-o9NFsj8x.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./limits-DefXc1TL.mjs').then(function (n) { return n.X; });
+        const { ApiClient: ApiClient2 } = await import('./types-CrKeJuyF.mjs').then(function (n) { return n.ad; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -17745,7 +17700,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
     if (geminiSubcommand === "project" && args[2] === "get") {
       try {
-        const { readGeminiLocalConfig } = await import('./config-C1gQprK_.mjs');
+        const { readGeminiLocalConfig } = await import('./config-o9NFsj8x.mjs');
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -17785,7 +17740,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await import('./runGemini-CwWEorS7.mjs');
+      const { runGemini } = await import('./runGemini-CDUObQTD.mjs');
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -17815,7 +17770,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-B11rFE7f.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BkmfJyCf.mjs');
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -17843,7 +17798,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "acp") {
     try {
-      const { runAcp, resolveAcpAgentConfig } = await import('./index-B11rFE7f.mjs');
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-BkmfJyCf.mjs');
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -17883,7 +17838,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await import('./runOpenClaw-BZHHy9T7.mjs');
+      const { runOpenClaw } = await import('./runOpenClaw-B6KMCsVB.mjs');
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -17934,7 +17889,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await import('./todo-BblDgT77.mjs');
+      const { handleTodoCommand } = await import('./todo-jL3ttna3.mjs');
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -17943,7 +17898,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await import('./teams-WSjEXh4d.mjs');
+      const { handleTeamsCommand } = await import('./teams-CZ9ICWeB.mjs');
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
@@ -17952,7 +17907,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "mcp" && args.length === 1) {
     try {
-      const { handleMcpCommand } = await import('./mcp-CdnZbYKV.mjs');
+      const { handleMcpCommand } = await import('./mcp-8DcunR0J.mjs');
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}
@@ -18314,4 +18269,4 @@ ${chalk.bold("Examples:")}
   }
 }
 
-export { ALLOWED_SPAWN_PERMISSION_MODES as A, hashObject as B, startHappyServer as C, DEFAULT_RECENT_LIMIT as D, registerAgentAttachmentDownloads as E, TitleGenerator as F, GEMINI_MODEL_ENV as G, CLAUDE_ATTACHMENT_KINDS as H, stageClaudeAttachments as I, appendStagedAttachmentsToPrompt as J, BasePermissionHandler as K, writeSessionModeFile as L, MAX_READ_LIMIT as M, normalizeAcpPermissionMode as N, removeSessionModeFile as O, PI_TEAMS_EXTENSION as P, GEMINI_API_KEY_ENV as Q, GOOGLE_API_KEY_ENV as R, SPAWN_AGENTS as S, TEAM_SKILL as T, BaseReasoningProcessor as U, MessageBuffer as V, CHANGE_TITLE_INSTRUCTION as W, sessionWebUrl as a, sanitizeSpawnPermissionMode as b, checkIfDaemonRunningAndCleanupStaleState as c, sendUserMessage as d, listSessions as e, stopSession as f, resolvePermissionRequest as g, archiveSession as h, isValidSpawnOrigin as i, DEFAULT_GEMINI_MODEL as j, setTerminalTitleViaDaemon as k, listAccountSessions as l, registerAssistantSessionTools as m, initialMachineMetadata as n, createSessionMetadata as o, pushClipboardViaDaemon as p, query as q, readSessionTranscript as r, spawnDaemonSession as s, tmuxSupportsSessionEnv as t, setupOfflineReconnection as u, notifyDaemonSessionStarted as v, waitForSessionKey as w, MessageQueue2 as x, registerKillSessionHandler as y, StreamRelay as z };
+export { ALLOWED_SPAWN_PERMISSION_MODES as A, appendStagedAttachmentsToPrompt as B, CLAUDE_ATTACHMENT_KINDS as C, DEFAULT_RECENT_LIMIT as D, BasePermissionHandler as E, writeSessionModeFile as F, GEMINI_MODEL_ENV as G, normalizeAcpPermissionMode as H, removeSessionModeFile as I, GEMINI_API_KEY_ENV as J, GOOGLE_API_KEY_ENV as K, BaseReasoningProcessor as L, MAX_READ_LIMIT as M, MessageBuffer as N, CHANGE_TITLE_INSTRUCTION as O, PI_TEAMS_EXTENSION as P, SPAWN_AGENTS as S, TEAM_SKILL as T, sanitizeSpawnPermissionMode as a, sendUserMessage as b, listSessions as c, stopSession as d, resolvePermissionRequest as e, archiveSession as f, DEFAULT_GEMINI_MODEL as g, registerAssistantSessionTools as h, isValidSpawnOrigin as i, initialMachineMetadata as j, createSessionMetadata as k, listAccountSessions as l, setupOfflineReconnection as m, MessageQueue2 as n, registerKillSessionHandler as o, StreamRelay as p, query as q, readSessionTranscript as r, sessionWebUrl as s, tmuxSupportsSessionEnv as t, hashObject as u, startHappyServer as v, waitForSessionKey as w, registerAgentAttachmentDownloads as x, TitleGenerator as y, stageClaudeAttachments as z };