very-happy-cli 0.2.159 → 0.2.160

package/dist/codexCommand-Cc9gcbdX.mjs

@@ -0,0 +1,2086 @@
+import { a as authAndSetupMachineIfNeeded } from './auth-Cwutmdsa.mjs';
+import { e as createEnvelope, l as BUILTIN_TODO_DISCOVERY, P as PROMPT_QUEUE_CAPABILITY } from './index-qdS1friN.mjs';
+import { randomUUID } from 'node:crypto';
+import { createId } from '@paralleldrive/cuid2';
+import { r as registerAgentAttachmentDownloads } from './agentAttachments-M_B5qEF2.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-_kxRznNf.mjs';
+import { useStdout, useInput, Box, Text, render } from 'ink';
+import { c as claimSessionOrExit, a as applyServerSnapshot, w as withoutServerSnapshot, m as mergeReconnectMetadata } from './sessionLock-D-EG2CfG.mjs';
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { c as connectionState, A as ApiClient } from './api-CLMUr-SX.mjs';
+import { C as CodexAppServerClient } from './codexAppServerClient-I3teiV-N.mjs';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { B as BasePermissionHandler } from './BasePermissionHandler-m3WVholL.mjs';
+import { B as BaseReasoningProcessor } from './BaseReasoningProcessor-CYrKBXGm.mjs';
+import { execSync } from 'node:child_process';
+import { readSettings } from './persistence-HGW_ZVs9.mjs';
+import { g as getInitialMachineMetadata } from './machineMetadata-oOzBfDfs.mjs';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+import { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-GYvHdipX.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { join } from 'node:path';
+import { c as createSessionMetadata } from './createSessionMetadata-CVVkGjxV.mjs';
+import { h as hashObject, s as startHappyServer } from './deterministicJson-CzkFJWw1.mjs';
+import { M as MessageBuffer } from './messageBuffer-BWlGgR3A.mjs';
+import { n as notifyDaemonSessionStarted, g as reportSessionEditToDaemon } from './controlClient-BGbDcgWS.mjs';
+import { d as decodeBase64, e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import { s as setupOfflineReconnection } from './setupOfflineReconnection-DpvWTt69.mjs';
+import { t as trimIdent } from './trimIdent-BAjmv_TG.mjs';
+import { p as parseSpecialCommand } from './specialCommands-BSqhYg5X.mjs';
+import { C as CHANGE_TITLE_INSTRUCTION } from './constants-BC4St0xd.mjs';
+import { a as DEFAULT_CODEX_PERMISSION_MODE } from './defaultPermissionMode-BnxJPVHT.mjs';
+import { E as EditReportThrottle, a as extractCodexPatchPaths } from './editPaths-BVfS_FFL.mjs';
+import { a as extractNoSandboxFlag, e as ensureDaemonRunning } from './ensureDaemonRunning-Dqa2pOjY.mjs';
+import 'tweetnacl';
+import 'axios';
+import './time-D0XyHOid.mjs';
+import './browser-jh2P0UVZ.mjs';
+import 'open';
+import 'zod';
+import 'node:fs/promises';
+import './attachmentLimits-yba1uHFO.mjs';
+import 'node:fs';
+import 'node:events';
+import 'socket.io-client';
+import './limits-DIo7rEBR.mjs';
+import './lidState-CeEt442o.mjs';
+import 'os';
+import 'child_process';
+import './registerCommonHandlers-Ccvsz7Ou.mjs';
+import 'util';
+import 'fs/promises';
+import 'crypto';
+import 'path';
+import 'cross-spawn';
+import './sync-C8gyQFMc.mjs';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import './contentLogMetadata-BlWI0egu.mjs';
+import 'chalk';
+import 'node:readline';
+import './manager-BQ4flvQZ.mjs';
+import '@anthropic-ai/sandbox-runtime';
+import 'node:os';
+import './package-BhaKlnxz.mjs';
+import 'node:util';
+import './detectCLI-CSGMlV51.mjs';
+import 'fs';
+import './localHappyAgentAuth-C-HQyiv6.mjs';
+import './types-CkqAACXx.mjs';
+import 'url';
+import './client-CeGKqqcJ.mjs';
+import './context-H0Bcb9S_.mjs';
+import './sessionOps-SuHW8Dfe.mjs';
+import './resources-BdFBQi8r.mjs';
+import './tools-DkluDcG4.mjs';
+import './tools-BZtHF_qQ.mjs';
+import './client-ClR0K8zX.mjs';
+import './peerTools-BTqw97Gb.mjs';
+import './ids-DU6sLx4C.mjs';
+import './remoteSessionClient-CYnXRynE.mjs';
+import '@modelcontextprotocol/sdk/server/mcp.js';
+import 'node:http';
+import '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import './assistantTools-D6tuc6o4.mjs';
+import './terminals-Dlg0x3nY.mjs';
+import './terminalTitleSuggest-CeKsX_V6.mjs';
+import './tmuxSocket-B8Yx20sT.mjs';
+import './bootstrap-hxXPCFMx.mjs';
+import './agentGuidance-CQuNlNx8.mjs';
+import './previewPath-CXN4Vag0.mjs';
+import './spawnHappyCLI-B2H5s4B_.mjs';
+import './doctorReadiness-C208SMN9.mjs';
+
+function getStartedSubagents(state) {
+  return state.startedSubagents ?? /* @__PURE__ */ new Set();
+}
+function getActiveSubagents(state) {
+  return state.activeSubagents ?? /* @__PURE__ */ new Set();
+}
+function getProviderSubagentToSessionSubagent(state) {
+  return state.providerSubagentToSessionSubagent ?? /* @__PURE__ */ new Map();
+}
+function maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes) {
+  if (!subagent || startedSubagents.has(subagent)) {
+    return;
+  }
+  envelopes.push(createEnvelope("agent", { t: "start" }, { ...opts, subagent }));
+  startedSubagents.add(subagent);
+  activeSubagents.add(subagent);
+}
+function emitSubagentStops(opts, startedSubagents, activeSubagents) {
+  const envelopes = [];
+  for (const subagent of activeSubagents) {
+    envelopes.push(createEnvelope("agent", { t: "stop" }, { ...opts, subagent }));
+  }
+  activeSubagents.clear();
+  startedSubagents.clear();
+  return envelopes;
+}
+function buildEnvelopeOptions(currentTurnId, subagent) {
+  return {
+    ...currentTurnId ? { turn: currentTurnId } : {},
+    ...subagent ? { subagent } : {}
+  };
+}
+function pickProviderSubagent(message) {
+  const candidates = [message.subagent, message.parent_call_id, message.parentCallId];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveSessionSubagent(message, providerSubagentToSessionSubagent) {
+  const providerSubagent = pickProviderSubagent(message);
+  if (!providerSubagent) {
+    return void 0;
+  }
+  const existing = providerSubagentToSessionSubagent.get(providerSubagent);
+  if (existing) {
+    return existing;
+  }
+  const created = createId();
+  providerSubagentToSessionSubagent.set(providerSubagent, created);
+  return created;
+}
+function pickCallId(message) {
+  const callId = message.call_id ?? message.callId;
+  if (typeof callId === "string" && callId.length > 0) {
+    return callId;
+  }
+  return randomUUID();
+}
+function summarizeCommand(command) {
+  if (typeof command === "string" && command.trim().length > 0) {
+    return command;
+  }
+  if (Array.isArray(command)) {
+    const cmd = command.map((v) => String(v)).join(" ").trim();
+    return cmd.length > 0 ? cmd : null;
+  }
+  return null;
+}
+function commandToTitle(command) {
+  if (!command) {
+    return "Run command";
+  }
+  const short = command.length > 80 ? `${command.slice(0, 77)}...` : command;
+  return `Run \`${short}\``;
+}
+function turnTimestampMs(turn) {
+  const seconds = turn.startedAt ?? turn.completedAt;
+  return typeof seconds === "number" && Number.isFinite(seconds) ? seconds * 1e3 : Date.now();
+}
+function completedTimestampMs(turn) {
+  const seconds = turn.completedAt ?? turn.startedAt;
+  return typeof seconds === "number" && Number.isFinite(seconds) ? seconds * 1e3 : Date.now();
+}
+function textFromInputItems(items) {
+  if (!Array.isArray(items)) {
+    return null;
+  }
+  const text = items.filter((item) => Boolean(item) && typeof item === "object" && item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n").trim();
+  return text.length > 0 ? text : null;
+}
+function reasoningText(item) {
+  const summary = item.summary;
+  const content = item.content;
+  const parts = [
+    ...Array.isArray(summary) ? summary : [],
+    ...Array.isArray(content) ? content : []
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  const text = parts.join("\n").trim();
+  return text.length > 0 ? text : null;
+}
+function turnStatus(turn) {
+  const status = typeof turn.status === "string" ? turn.status : null;
+  if (status === "failed") {
+    return "failed";
+  }
+  if (status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted") {
+    return "cancelled";
+  }
+  return "completed";
+}
+function emitHistoricalToolCall(envelopes, turn, item, name, title, args, output) {
+  const time = turnTimestampMs(turn);
+  const opts = { turn: turn.id, time, codexItemId: item.id };
+  envelopes.push(createEnvelope("agent", {
+    t: "tool-call-start",
+    call: item.id,
+    name,
+    title,
+    description: title,
+    args
+  }, {
+    ...opts,
+    id: `${item.id}:start`
+  }));
+  if (output && output.trim().length > 0) {
+    envelopes.push(createEnvelope("agent", {
+      t: "text",
+      text: output,
+      thinking: true
+    }, {
+      ...opts,
+      id: `${item.id}:output`
+    }));
+  }
+  if ("status" in item && (item.status === "inProgress" || item.status === "running")) return;
+  envelopes.push(createEnvelope("agent", {
+    t: "tool-call-end",
+    call: item.id
+  }, {
+    ...opts,
+    id: `${item.id}:end`,
+    time: completedTimestampMs(turn)
+  }));
+}
+function mapCodexCollaborationItem(item, opts = {}, source = "history") {
+  if (item.type === "subAgentActivity" && typeof item.agentThreadId === "string") {
+    item = { ...item, type: "collabAgentToolCall", tool: item.kind, status: "completed", receiverThreadIds: [item.agentThreadId] };
+  }
+  if (item.type !== "collabAgentToolCall" || typeof item.id !== "string" || typeof item.tool !== "string") return [];
+  const args = {
+    operation: item.tool,
+    ...typeof item.prompt === "string" ? { prompt: item.prompt } : {},
+    ...typeof item.model === "string" ? { model: item.model } : {},
+    receiverThreadIds: Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds : [],
+    agentsStates: item.agentsStates ?? {}
+  };
+  const startId = source === "live" ? `${item.id}:${item.status ?? "unknown"}:start` : `${item.id}:start`;
+  const envelopes = [createEnvelope("agent", {
+    t: "tool-call-start",
+    call: item.id,
+    name: "CodexCollaboration",
+    title: `Codex \xB7 ${item.tool}`,
+    description: `Codex \xB7 ${item.tool}`,
+    args
+  }, { ...opts, id: startId })];
+  if (item.status === "completed" || item.status === "failed" || item.status === "interrupted") {
+    envelopes.push(createEnvelope("agent", {
+      t: "tool-call-end",
+      call: item.id,
+      result: { text: JSON.stringify(args, null, 2), isError: item.status !== "completed" }
+    }, { ...opts, id: `${item.id}:end` }));
+  }
+  return envelopes;
+}
+function mapCodexThreadToSessionEnvelopes(thread) {
+  const envelopes = [];
+  for (const turn of thread.turns ?? []) {
+    const startedAt = turnTimestampMs(turn);
+    const completedAt = completedTimestampMs(turn);
+    envelopes.push(createEnvelope("agent", { t: "turn-start" }, {
+      id: `${turn.id}:start`,
+      turn: turn.id,
+      time: startedAt
+    }));
+    for (const item of turn.items ?? []) {
+      switch (item.type) {
+        case "subAgentActivity":
+        case "collabAgentToolCall": {
+          envelopes.push(...mapCodexCollaborationItem(item, { turn: turn.id, time: startedAt, codexItemId: item.id }));
+          break;
+        }
+        case "userMessage": {
+          const text = textFromInputItems(item.content);
+          if (text) {
+            envelopes.push(createEnvelope("user", { t: "text", text }, {
+              id: item.id,
+              time: startedAt,
+              codexItemId: item.id
+            }));
+          }
+          break;
+        }
+        case "agentMessage": {
+          const text = typeof item.text === "string" ? item.text.trim() : "";
+          if (text.length > 0) {
+            envelopes.push(createEnvelope("agent", { t: "text", text }, {
+              id: item.id,
+              turn: turn.id,
+              time: completedAt,
+              codexItemId: item.id
+            }));
+          }
+          break;
+        }
+        case "reasoning": {
+          const text = reasoningText(item);
+          if (text) {
+            envelopes.push(createEnvelope("agent", { t: "text", text, thinking: true }, {
+              id: item.id,
+              turn: turn.id,
+              time: startedAt,
+              codexItemId: item.id
+            }));
+          }
+          break;
+        }
+        case "commandExecution": {
+          const command = typeof item.command === "string" ? item.command : "";
+          emitHistoricalToolCall(
+            envelopes,
+            turn,
+            item,
+            "CodexBash",
+            commandToTitle(command),
+            { command, cwd: item.cwd },
+            typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : null
+          );
+          break;
+        }
+        case "fileChange": {
+          const title = "Apply patch";
+          emitHistoricalToolCall(
+            envelopes,
+            turn,
+            item,
+            "CodexPatch",
+            title,
+            { changes: item.changes, status: item.status },
+            null
+          );
+          break;
+        }
+        case "mcpToolCall": {
+          const title = `${item.server}.${item.tool}`;
+          const output = item.error !== void 0 && item.error !== null ? String(item.error) : item.result !== void 0 && item.result !== null ? String(item.result) : null;
+          emitHistoricalToolCall(
+            envelopes,
+            turn,
+            item,
+            "McpTool",
+            title,
+            {
+              server: item.server,
+              tool: item.tool,
+              arguments: item.arguments
+            },
+            output
+          );
+          break;
+        }
+      }
+    }
+    envelopes.push(createEnvelope("agent", { t: "turn-end", status: turnStatus(turn) }, {
+      id: `${turn.id}:end`,
+      turn: turn.id,
+      time: completedAt
+    }));
+  }
+  return envelopes;
+}
+function patchDescription(changes) {
+  if (!changes || typeof changes !== "object") {
+    return "Applying patch";
+  }
+  const fileCount = Object.keys(changes).length;
+  if (fileCount === 1) {
+    return "Applying patch to 1 file";
+  }
+  return `Applying patch to ${fileCount} files`;
+}
+function pickTurnEndStatus(message, type) {
+  const rawStatus = message.status;
+  if (rawStatus === "completed" || rawStatus === "failed" || rawStatus === "cancelled") {
+    return rawStatus;
+  }
+  if (rawStatus === "canceled") {
+    return "cancelled";
+  }
+  if (type === "turn_aborted") {
+    const reason = message.reason;
+    const error = message.error;
+    if (typeof reason === "string" && /(fail|error)/i.test(reason) || typeof error === "string" && error.length > 0 || error !== void 0 && error !== null && typeof error === "object") {
+      return "failed";
+    }
+    return "cancelled";
+  }
+  if (message.error !== void 0 && message.error !== null) {
+    return "failed";
+  }
+  return "completed";
+}
+function mapCodexMcpMessageToSessionEnvelopes(message, state) {
+  const type = message.type;
+  const startedSubagents = getStartedSubagents(state);
+  const activeSubagents = getActiveSubagents(state);
+  const providerSubagentToSessionSubagent = getProviderSubagentToSessionSubagent(state);
+  if (type === "collab_agent_item") {
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes: mapCodexCollaborationItem(message.item, buildEnvelopeOptions(state.currentTurnId), "live")
+    };
+  }
+  if (type === "task_started") {
+    const turnId = createId();
+    const turnStart = createEnvelope("agent", { t: "turn-start" }, { turn: turnId });
+    startedSubagents.clear();
+    activeSubagents.clear();
+    providerSubagentToSessionSubagent.clear();
+    return {
+      currentTurnId: turnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes: [turnStart]
+    };
+  }
+  if (type === "task_complete" || type === "turn_aborted") {
+    if (!state.currentTurnId) {
+      return {
+        currentTurnId: null,
+        startedSubagents,
+        activeSubagents,
+        providerSubagentToSessionSubagent,
+        envelopes: []
+      };
+    }
+    const lifecycleOpts = { turn: state.currentTurnId };
+    providerSubagentToSessionSubagent.clear();
+    return {
+      currentTurnId: null,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes: [
+        ...emitSubagentStops(lifecycleOpts, startedSubagents, activeSubagents),
+        createEnvelope("agent", {
+          t: "turn-end",
+          status: pickTurnEndStatus(message, type)
+        }, lifecycleOpts)
+      ]
+    };
+  }
+  if (type === "token_count") {
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes: []
+    };
+  }
+  const subagent = resolveSessionSubagent(message, providerSubagentToSessionSubagent);
+  const opts = buildEnvelopeOptions(state.currentTurnId, subagent);
+  if (type === "agent_message") {
+    if (typeof message.message !== "string") {
+      return {
+        currentTurnId: state.currentTurnId,
+        startedSubagents,
+        activeSubagents,
+        providerSubagentToSessionSubagent,
+        envelopes: []
+      };
+    }
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(createEnvelope("agent", { t: "text", text: message.message }, opts));
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
+  }
+  if (type === "agent_reasoning" || type === "agent_reasoning_delta") {
+    const text = typeof message.text === "string" ? message.text : typeof message.delta === "string" ? message.delta : null;
+    if (!text) {
+      return {
+        currentTurnId: state.currentTurnId,
+        startedSubagents,
+        activeSubagents,
+        providerSubagentToSessionSubagent,
+        envelopes: []
+      };
+    }
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(createEnvelope("agent", { t: "text", text, thinking: true }, opts));
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
+  }
+  if (type === "exec_command_begin") {
+    const call = pickCallId(message);
+    const { call_id: _callIdSnake, callId: _callIdCamel, type: _type, ...args } = message;
+    const command = summarizeCommand(args.command);
+    const description = typeof args.description === "string" ? args.description : command ?? "Execute command";
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(
+      createEnvelope("agent", {
+        t: "tool-call-start",
+        call,
+        name: "CodexBash",
+        title: commandToTitle(command),
+        description,
+        args
+      }, opts)
+    );
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
+  }
+  if (type === "exec_command_end") {
+    const call = pickCallId(message);
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(createEnvelope("agent", { t: "tool-call-end", call }, opts));
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
+  }
+  if (type === "patch_apply_begin") {
+    const call = pickCallId(message);
+    const autoApproved = message.auto_approved;
+    const changes = message.changes;
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(
+      createEnvelope("agent", {
+        t: "tool-call-start",
+        call,
+        name: "CodexPatch",
+        title: "Apply patch",
+        description: patchDescription(changes),
+        args: {
+          auto_approved: autoApproved,
+          changes
+        }
+      }, opts)
+    );
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
+  }
+  if (type === "patch_apply_end") {
+    const call = pickCallId(message);
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(createEnvelope("agent", { t: "tool-call-end", call }, opts));
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
+  }
+  return {
+    currentTurnId: state.currentTurnId,
+    startedSubagents,
+    activeSubagents,
+    providerSubagentToSessionSubagent,
+    envelopes: []
+  };
+}
+function mapCodexProcessorMessageToSessionEnvelopes(message, state) {
+  const toolLikeMessage = message;
+  const opts = buildEnvelopeOptions(state.currentTurnId);
+  if (message.type === "reasoning") {
+    return [createEnvelope("agent", {
+      t: "text",
+      text: message.message,
+      thinking: true
+    }, opts)];
+  }
+  if (message.type === "tool-call") {
+    const title = typeof toolLikeMessage.input?.title === "string" ? toolLikeMessage.input.title : `${toolLikeMessage.name || "Tool"} call`;
+    return [createEnvelope("agent", {
+      t: "tool-call-start",
+      call: toolLikeMessage.callId,
+      name: toolLikeMessage.name || "unknown",
+      title,
+      description: title,
+      args: toolLikeMessage.input && typeof toolLikeMessage.input === "object" ? toolLikeMessage.input : {}
+    }, opts)];
+  }
+  if (message.type === "tool-call-result") {
+    const envelopes = [];
+    const content = toolLikeMessage.output?.content;
+    if (typeof content === "string" && content.trim().length > 0) {
+      envelopes.push(createEnvelope("agent", {
+        t: "text",
+        text: content,
+        thinking: true
+      }, opts));
+    }
+    envelopes.push(createEnvelope("agent", {
+      t: "tool-call-end",
+      call: toolLikeMessage.callId
+    }, opts));
+    return envelopes;
+  }
+  return [];
+}
+
+async function readChildThread(client, childId) {
+  if (!client.threadId || typeof childId !== "string" || !childId) throw new Error("Invalid child thread");
+  const parentId = client.threadId;
+  const { thread: parent } = await client.readThread({ threadId: parentId, includeTurns: true });
+  const belongs = parent.id === parentId && parent.turns?.some((turn) => turn.items.some((item) => item.type === "collabAgentToolCall" && Array.isArray(item.receiverThreadIds) && item.receiverThreadIds.includes(childId) || item.type === "subAgentActivity" && item.agentThreadId === childId));
+  if (!belongs) throw new Error("Thread is not a child of this session");
+  const { thread } = await client.readThread({ threadId: childId, includeTurns: true });
+  if (thread.id !== childId) throw new Error("Child thread mismatch");
+  return { envelopes: mapCodexThreadToSessionEnvelopes(thread) };
+}
+
+class CodexPermissionHandler extends BasePermissionHandler {
+  // Exact tool names that should always be auto-approved. Include the bare
+  // form (used by Codex elicitation messages like `tool "change_title"`)
+  // and the MCP-qualified form for defense in depth.
+  static ALWAYS_AUTO_APPROVE_NAMES = /* @__PURE__ */ new Set([
+    "change_title",
+    "mcp__happy__change_title"
+  ]);
+  // Tool-call IDs that should auto-approve when they exactly match one of
+  // these values or start with `<name>-` (e.g. `change_title-1765385846663`).
+  // Substring matching was a bypass vector — any tool whose ID happened to
+  // contain `change_title` as a substring would be silently approved.
+  static ALWAYS_AUTO_APPROVE_ID_PREFIXES = [
+    "change_title"
+  ];
+  constructor(session) {
+    super(session);
+  }
+  getLogPrefix() {
+    return "[Codex]";
+  }
+  shouldAutoApprove(toolName, toolCallId) {
+    if (CodexPermissionHandler.ALWAYS_AUTO_APPROVE_NAMES.has(toolName)) {
+      return true;
+    }
+    for (const prefix of CodexPermissionHandler.ALWAYS_AUTO_APPROVE_ID_PREFIXES) {
+      if (toolCallId === prefix || toolCallId.startsWith(`${prefix}-`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Handle a tool permission request
+   * @param toolCallId - The unique ID of the tool call
+   * @param toolName - The name of the tool being called
+   * @param input - The input parameters for the tool
+   * @returns Promise resolving to permission result
+   */
+  async handleToolCall(toolCallId, toolName, input) {
+    if (this.shouldAutoApprove(toolName, toolCallId)) {
+      logger.debug(`${this.getLogPrefix()} Auto-approving tool ${toolName} (${toolCallId})`);
+      this.session.updateAgentState((currentState) => ({
+        ...currentState,
+        completedRequests: {
+          ...currentState.completedRequests,
+          [toolCallId]: {
+            tool: toolName,
+            arguments: input,
+            createdAt: Date.now(),
+            completedAt: Date.now(),
+            status: "approved",
+            decision: "approved"
+          }
+        }
+      }));
+      return { decision: "approved" };
+    }
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(toolCallId, {
+        resolve,
+        reject,
+        toolName,
+        input
+      });
+      this.addPendingRequestToState(toolCallId, toolName, input);
+      logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})`);
+    });
+  }
+}
+
+class ReasoningProcessor extends BaseReasoningProcessor {
+  getToolName() {
+    return "CodexReasoning";
+  }
+  getLogPrefix() {
+    return "[ReasoningProcessor]";
+  }
+  /**
+   * Process a reasoning delta and accumulate content.
+   */
+  processDelta(delta) {
+    this.processInput(delta);
+  }
+  /**
+   * Complete the reasoning section with final text.
+   */
+  complete(fullText) {
+    this.completeReasoning(fullText);
+  }
+}
+
+class DiffProcessor {
+  previousDiff = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+  }
+  /**
+   * Process a turn_diff message and check if the unified_diff has changed
+   */
+  processDiff(unifiedDiff) {
+    if (this.previousDiff !== unifiedDiff) {
+      logger.debug("[DiffProcessor] Unified diff changed, sending CodexDiff tool call");
+      const callId = randomUUID();
+      const toolCall = {
+        type: "tool-call",
+        name: "CodexDiff",
+        callId,
+        input: {
+          unified_diff: unifiedDiff
+        },
+        id: randomUUID()
+      };
+      this.onMessage?.(toolCall);
+      const toolResult = {
+        type: "tool-call-result",
+        callId,
+        output: {
+          status: "completed"
+        },
+        id: randomUUID()
+      };
+      this.onMessage?.(toolResult);
+    }
+    this.previousDiff = unifiedDiff;
+    logger.debug("[DiffProcessor] Updated stored diff");
+  }
+  /**
+   * Reset the processor state (called on task_complete or turn_aborted)
+   */
+  reset() {
+    logger.debug("[DiffProcessor] Resetting diff state");
+    this.previousDiff = null;
+  }
+  /**
+   * Set the message callback for sending messages directly
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
+  }
+  /**
+   * Get the current diff value
+   */
+  getCurrentDiff() {
+    return this.previousDiff;
+  }
+}
+
+const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
+  const [messages, setMessages] = useState([]);
+  const [confirmationMode, setConfirmationMode] = useState(false);
+  const [actionInProgress, setActionInProgress] = useState(false);
+  const confirmationTimeoutRef = useRef(null);
+  const { stdout } = useStdout();
+  const terminalWidth = stdout.columns || 80;
+  const terminalHeight = stdout.rows || 24;
+  useEffect(() => {
+    setMessages(messageBuffer.getMessages());
+    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
+      setMessages(newMessages);
+    });
+    return () => {
+      unsubscribe();
+      if (confirmationTimeoutRef.current) {
+        clearTimeout(confirmationTimeoutRef.current);
+      }
+    };
+  }, [messageBuffer]);
+  const resetConfirmation = useCallback(() => {
+    setConfirmationMode(false);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+      confirmationTimeoutRef.current = null;
+    }
+  }, []);
+  const setConfirmationWithTimeout = useCallback(() => {
+    setConfirmationMode(true);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+    }
+    confirmationTimeoutRef.current = setTimeout(() => {
+      resetConfirmation();
+    }, 15e3);
+  }, [resetConfirmation]);
+  useInput(useCallback(async (input, key) => {
+    if (actionInProgress) return;
+    if (key.ctrl && input === "c") {
+      if (confirmationMode) {
+        resetConfirmation();
+        setActionInProgress(true);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        onExit?.();
+      } else {
+        setConfirmationWithTimeout();
+      }
+      return;
+    }
+    if (confirmationMode) {
+      resetConfirmation();
+    }
+  }, [confirmationMode, actionInProgress, onExit, setConfirmationWithTimeout, resetConfirmation]));
+  const getMessageColor = (type) => {
+    switch (type) {
+      case "user":
+        return "magenta";
+      case "assistant":
+        return "cyan";
+      case "system":
+        return "blue";
+      case "tool":
+        return "yellow";
+      case "result":
+        return "green";
+      case "status":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+  const formatMessage = (msg) => {
+    const lines = msg.content.split("\n");
+    const maxLineLength = terminalWidth - 10;
+    return lines.map((line) => {
+      if (line.length <= maxLineLength) return line;
+      const chunks = [];
+      for (let i = 0; i < line.length; i += maxLineLength) {
+        chunks.push(line.slice(i, i + maxLineLength));
+      }
+      return chunks.join("\n");
+    }).join("\n");
+  };
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "\u{1F916} Codex Agent Messages"), /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Waiting for messages...") : (
+      // Show only the last messages that fit in the available space
+      messages.slice(-Math.max(1, terminalHeight - 10)).map((msg) => /* @__PURE__ */ React.createElement(Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode ? "red" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+function resolveCodexExecutionPolicy(permissionMode, sandboxManagedByHappy) {
+  if (sandboxManagedByHappy) {
+    return {
+      approvalPolicy: "never",
+      sandbox: "danger-full-access"
+    };
+  }
+  const approvalPolicy = (() => {
+    switch (permissionMode) {
+      // Codex native modes
+      case "default":
+        return "untrusted";
+      // Ask for non-trusted commands
+      case "read-only":
+        return "never";
+      // Never ask, read-only enforced by sandbox
+      case "safe-yolo":
+        return "on-request";
+      // Workspace auto-run; request approval for escalation (0.153 removed on-failure)
+      case "yolo":
+        return "never";
+      // Full YOLO: never interrupt for approvals
+      // Defensive fallback for Claude-specific modes (backward compatibility)
+      case "bypassPermissions":
+        return "never";
+      // Full access: map to yolo behavior
+      case "acceptEdits":
+        return "on-request";
+      // Let model decide (closest to auto-approve edits)
+      case "plan":
+        return "untrusted";
+      // Conservative: ask for non-trusted
+      default:
+        return "untrusted";
+    }
+  })();
+  const sandbox = (() => {
+    switch (permissionMode) {
+      // Codex native modes
+      case "default":
+        return "workspace-write";
+      // Can write in workspace
+      case "read-only":
+        return "read-only";
+      // Read-only filesystem
+      case "safe-yolo":
+        return "workspace-write";
+      // Can write in workspace
+      case "yolo":
+        return "danger-full-access";
+      // Full system access
+      // Defensive fallback for Claude-specific modes
+      case "bypassPermissions":
+        return "danger-full-access";
+      // Full access: map to yolo
+      case "acceptEdits":
+        return "workspace-write";
+      // Can edit files in workspace
+      case "plan":
+        return "workspace-write";
+      // Can write for planning
+      default:
+        return "workspace-write";
+    }
+  })();
+  return { approvalPolicy, sandbox };
+}
+
+function unsupportedEffortReason(catalog, model, effort) {
+  if (!effort) return null;
+  const selected = catalog.find((entry) => model ? entry.model === model : entry.isDefault);
+  if (!selected) return null;
+  if (selected.supportedReasoningEfforts.some((option) => option.reasoningEffort === effort)) return null;
+  return `Reasoning effort "${effort}" is not supported by ${model ?? "the default model"}. Choose a supported level.`;
+}
+
+function readableCodexErrorText(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{")) return trimmed;
+  try {
+    const body = JSON.parse(trimmed);
+    const inner = typeof body.error === "object" && body.error ? body.error.message : void 0;
+    const message = typeof inner === "string" && inner.trim() ? inner : typeof body.error === "string" && body.error.trim() ? body.error : typeof body.message === "string" && body.message.trim() ? body.message : null;
+    return message ? message.trim() : trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function describeCodexFailure(msg) {
+  const hasFailure = msg?.status === "failed" || msg?.error !== void 0 && msg?.error !== null;
+  if (!hasFailure) return null;
+  const err = msg.error;
+  if (typeof err === "string" && err.length > 0) return readableCodexErrorText(err);
+  if (err && typeof err === "object" && typeof err.message === "string" && err.message.length > 0) {
+    return readableCodexErrorText(err.message);
+  }
+  return "Unknown error";
+}
+const TRANSPORT_LOSS = /^Codex process (exited|disconnected)\b|stdin not writable| timed out after \d+ms/;
+function describeThrownTurnError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!message.trim() || TRANSPORT_LOSS.test(message)) return null;
+  return readableCodexErrorText(message);
+}
+
+async function resumeExistingThread(opts) {
+  try {
+    const resumedThread = await opts.client.resumeThread({
+      threadId: opts.threadId,
+      cwd: opts.cwd,
+      mcpServers: opts.mcpServers
+    });
+    opts.session.updateMetadata((currentMetadata) => ({
+      ...currentMetadata,
+      codexThreadId: resumedThread.threadId
+    }));
+    opts.messageBuffer.addMessage(`Resumed thread ${trimIdent(resumedThread.threadId)}`, "status");
+    opts.session.sendSessionEvent({
+      type: "message",
+      message: `Resumed Codex thread ${resumedThread.threadId}`
+    });
+    return resumedThread;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to resume Codex thread ${opts.threadId}: ${reason}`);
+  }
+}
+
+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;
+  }
+  if (pending) {
+    return false;
+  }
+  if (queueSize() > 0) {
+    return false;
+  }
+  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";
+}
+function enqueueCodexUserText(opts) {
+  if (isCodexClearText(opts.text)) {
+    opts.queue.pushIsolateAndClear(opts.text, opts.mode, opts.attachments, opts.sourceId);
+    return "clear";
+  }
+  opts.queue.push(opts.text, opts.mode, opts.attachments, opts.sourceId);
+  return "queued";
+}
+
+function hashCodexEnhancedMode(mode) {
+  return hashObject({
+    permissionMode: mode.permissionMode,
+    model: mode.model,
+    appendSystemPrompt: mode.appendSystemPrompt,
+    effort: mode.effort
+  });
+}
+function buildCodexTurnPrompt(opts) {
+  const parts = [];
+  if (opts.includeAppendSystemPrompt && opts.mode.appendSystemPrompt) {
+    parts.push(opts.mode.appendSystemPrompt);
+  }
+  parts.push(opts.message);
+  if (opts.includeTitleInstruction) {
+    parts.push(CHANGE_TITLE_INSTRUCTION);
+    parts.push(BUILTIN_TODO_DISCOVERY);
+  }
+  return parts.join("\n\n");
+}
+
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+function safeTypeToken(value) {
+  if (typeof value !== "string") return typeof value;
+  return /^[a-z][a-z0-9_.-]{0,63}$/i.test(value) ? value : "unknown";
+}
+function logValueMetadata(value) {
+  return typeof value === "string" ? { valueType: "string", valueBytes: byteLength(value) } : { valueType: value === null ? "null" : typeof value };
+}
+function codexEventLogMetadata(value) {
+  const event = value && typeof value === "object" ? value : {};
+  let payloadBytes;
+  try {
+    const encoded = JSON.stringify(value);
+    if (encoded !== void 0) payloadBytes = byteLength(encoded);
+  } catch {
+  }
+  return {
+    eventType: safeTypeToken(event.type),
+    ...payloadBytes === void 0 ? {} : { payloadBytes },
+    hasId: typeof event.id === "string" || typeof event.turn_id === "string" || typeof event.callId === "string"
+  };
+}
+function safeCodexErrorMetadata(value) {
+  if (!value || typeof value !== "object") return { errorType: typeof value };
+  const error = value;
+  const status = error.status ?? error.response?.status;
+  const safeCode = typeof error.code === "string" && /^[a-z0-9_.-]{1,64}$/i.test(error.code) ? { code: error.code } : typeof error.code === "number" ? { code: error.code } : typeof error.code === "string" ? { codeBytes: byteLength(error.code) } : {};
+  return {
+    errorType: safeTypeToken(error.name ?? value.constructor?.name),
+    ...safeCode,
+    ...typeof status === "number" ? { status } : {}
+  };
+}
+
+const DEFAULT_CODEX_MODEL = "gpt-5.5";
+const DEFAULT_CODEX_EFFORT = "medium";
+async function runCodex(opts) {
+  try {
+    execSync("codex --version", { encoding: "utf8", stdio: "pipe", windowsHide: true });
+  } catch {
+    console.error("\n\x1B[1m\x1B[33mCodex CLI is not installed\x1B[0m\n");
+    console.error("Please install Codex CLI using one of these methods:\n");
+    console.error("\x1B[1mOption 1 - npm (recommended):\x1B[0m");
+    console.error("  \x1B[36mnpm install -g @openai/codex\x1B[0m\n");
+    console.error("\x1B[1mOption 2 - Homebrew (macOS):\x1B[0m");
+    console.error("  \x1B[36mbrew install --cask codex\x1B[0m\n");
+    console.error("Alternatively, use Claude Code:");
+    console.error("  \x1B[36mvery-happy claude\x1B[0m\n");
+    process.exit(1);
+  }
+  const sessionTag = randomUUID();
+  connectionState.setBackend("Codex");
+  const api = await ApiClient.create(opts.credentials);
+  logger.debug(`[codex] Starting with options: startedBy=${opts.startedBy || "terminal"}`);
+  const settings = await readSettings();
+  let machineId = settings?.machineId;
+  const sandboxConfig = opts.noSandbox ? void 0 : settings?.sandboxConfig;
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings, which is unexpected since authAndSetupMachineIfNeeded should have created it. Please report this issue on https://github.com/Mereithhh/very-happy/issues`);
+    process.exit(1);
+  }
+  logger.debug(`Using machineId: ${machineId}`);
+  await api.getOrCreateMachine({
+    machineId,
+    metadata: getInitialMachineMetadata()
+  });
+  const initialPermissionMode = opts.permissionMode ?? DEFAULT_CODEX_PERMISSION_MODE;
+  const forkedFromSessionId = process.env.HAPPY_FORKED_FROM_SESSION_ID;
+  const forkedFromMessageId = process.env.HAPPY_FORKED_FROM_MESSAGE_ID;
+  const { state, metadata } = createSessionMetadata({
+    flavor: "codex",
+    ...process.env.VH_TEAM_OPERATION_ID ? { teamOperationId: process.env.VH_TEAM_OPERATION_ID } : {},
+    machineId,
+    startedBy: opts.startedBy,
+    sandbox: sandboxConfig,
+    dangerouslySkipPermissions: initialPermissionMode === "yolo" || initialPermissionMode === "bypassPermissions",
+    ...forkedFromSessionId ? { parentSessionId: forkedFromSessionId } : {},
+    ...forkedFromMessageId ? { forkedFromMessageId } : {},
+    capabilities: [PROMPT_QUEUE_CAPABILITY]
+  });
+  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;
+  const reconnectSeq = process.env.HAPPY_RECONNECT_SEQ;
+  const reconnectMetadataVersion = process.env.HAPPY_RECONNECT_METADATA_VERSION;
+  const reconnectAgentStateVersion = process.env.HAPPY_RECONNECT_AGENT_STATE_VERSION;
+  let response;
+  if (reconnectSessionId && reconnectKeyBase64 && reconnectVariant) {
+    logger.debug(`[START] Reconnecting to existing session ${reconnectSessionId}`);
+    response = {
+      id: reconnectSessionId,
+      seq: parseInt(reconnectSeq || "0", 10),
+      encryptionKey: decodeBase64(reconnectKeyBase64),
+      encryptionVariant: reconnectVariant,
+      metadata,
+      metadataVersion: parseInt(reconnectMetadataVersion || "0", 10),
+      agentState: state,
+      agentStateVersion: parseInt(reconnectAgentStateVersion || "0", 10)
+    };
+  } else {
+    response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  }
+  if (response) {
+    await claimSessionOrExit(response.id, { takeover: !!reconnectSessionId, flavor: "codex" });
+  }
+  if (reconnectSessionId && response && !await api.reactivateSession(response.id)) {
+    throw new Error(`Failed to reactivate archived session ${response.id}`);
+  }
+  let reconnectSeeded = false;
+  if (reconnectSessionId && response) {
+    const snapshot = await api.getSession(response.id, response.encryptionKey, response.encryptionVariant);
+    if (snapshot.ok) {
+      response = applyServerSnapshot(response, snapshot.session);
+      reconnectSeeded = true;
+      logger.debug(`[START] Reconnect seeded from server: seq=${snapshot.session.seq} metadataVersion=${snapshot.session.metadataVersion}`);
+    } else {
+      response = withoutServerSnapshot(response);
+      logger.debug(`[START] Reconnect without server snapshot (${snapshot.reason}); skipping existing messages`);
+    }
+  }
+  let session;
+  let permissionHandler;
+  let client;
+  let reasoningProcessor;
+  let abortInProgress = null;
+  let turnActive = false;
+  const { session: initialSession, reconnectionHandle } = setupOfflineReconnection({
+    api,
+    sessionTag,
+    metadata,
+    state,
+    response,
+    sessionClientOptions: reconnectSeeded && response ? { initialSeq: response.seq } : void 0,
+    onSessionSwap: (newSession) => {
+      session = newSession;
+      if (permissionHandler) {
+        permissionHandler.updateSession(newSession);
+      }
+      attachPromptQueueDrain(newSession);
+    }
+  });
+  session = initialSession;
+  if (reconnectSessionId) {
+    session.suppressNextArchiveSignal();
+    if (!reconnectSeeded) session.skipExistingMessages();
+    void session.cancelUndeliveredQueuedInputs();
+    session.updateMetadata((meta) => mergeReconnectMetadata(meta, metadata, Date.now()));
+  }
+  if (response) {
+    try {
+      logger.debug(`[START] Reporting session ${response.id} to daemon`);
+      const result = await notifyDaemonSessionStarted(response.id, metadata, {
+        encryptionKey: encodeBase64(response.encryptionKey),
+        encryptionVariant: response.encryptionVariant,
+        seq: response.seq,
+        metadataVersion: response.metadataVersion,
+        agentStateVersion: response.agentStateVersion
+      });
+      if (result.error) {
+        logger.debug("[START] Failed to report to daemon (may not be running)", safeCodexErrorMetadata(result.error));
+      } else {
+        logger.debug(`[START] Reported session ${response.id} to daemon`);
+      }
+    } catch (error) {
+      logger.debug("[START] Failed to report to daemon (may not be running)", safeCodexErrorMetadata(error));
+    }
+  }
+  const messageQueue = new MessageQueue2(hashCodexEnhancedMode);
+  function attachPromptQueueDrain(client2) {
+    const drain = client2.attachPromptQueueDrain({
+      isIdle: () => messageQueue.size() === 0 && messageQueue.isWaiting()
+    });
+    messageQueue.setOnWait(() => drain.onIdle());
+  }
+  attachPromptQueueDrain(session);
+  messageQueue.setOnDiscard((entries) => {
+    const keys = entries.map((entry) => entry.sourceId).filter((key) => typeof key === "string");
+    if (keys.length > 0) session.sendQueueCancelReason(keys, entries[0].reason);
+  });
+  let currentPermissionMode = initialPermissionMode;
+  let currentModel = DEFAULT_CODEX_MODEL;
+  let currentEffort = DEFAULT_CODEX_EFFORT;
+  let currentAppendSystemPrompt = void 0;
+  const resetCurrentModeDefaults = () => {
+    currentPermissionMode = DEFAULT_CODEX_PERMISSION_MODE;
+    currentModel = DEFAULT_CODEX_MODEL;
+    currentEffort = DEFAULT_CODEX_EFFORT;
+    currentAppendSystemPrompt = void 0;
+    logger.debug("[Codex] Reset current mode defaults after abort");
+  };
+  const VALID_REMOTE_PERMISSION_MODES = [
+    "default",
+    "read-only",
+    "safe-yolo",
+    "yolo"
+  ];
+  let discoveredModels = [];
+  registerAgentAttachmentDownloads(session);
+  let userMessageDelivery = Promise.resolve();
+  session.onUserMessage((message) => {
+    const downloads = session.drainAttachmentsForUserMessage();
+    userMessageDelivery = userMessageDelivery.then(async () => {
+      const attachments = await downloads;
+      let messagePermissionMode = currentPermissionMode;
+      if (message.meta?.permissionMode) {
+        const incoming = message.meta.permissionMode;
+        if (VALID_REMOTE_PERMISSION_MODES.includes(incoming)) {
+          messagePermissionMode = incoming;
+          currentPermissionMode = messagePermissionMode;
+          logger.debug("[Codex] Valid permission mode override applied");
+        } else {
+          logger.debug("[Codex] Ignoring invalid permission mode override", logValueMetadata(message.meta.permissionMode));
+        }
+      } else {
+        logger.debug("[Codex] User message received without a permission mode override");
+      }
+      let messageModel = currentModel;
+      if (message.meta?.hasOwnProperty("model")) {
+        messageModel = message.meta.model || void 0;
+        currentModel = messageModel;
+        logger.debug("[Codex] Model override updated", logValueMetadata(message.meta.model));
+      } else {
+        logger.debug("[Codex] User message received without a model override");
+      }
+      let messageEffort = currentEffort;
+      if (message.meta?.hasOwnProperty("effort")) {
+        const incoming = message.meta.effort;
+        if (incoming === null || incoming === void 0) {
+          messageEffort = void 0;
+          currentEffort = void 0;
+          logger.debug(`[Codex] Effort reset to default`);
+        } else if (typeof incoming === "string") {
+          messageEffort = incoming;
+          currentEffort = messageEffort;
+          logger.debug("[Codex] Valid effort override applied");
+        } else {
+          logger.debug("[Codex] Ignoring invalid effort override", logValueMetadata(incoming));
+        }
+      } else {
+        logger.debug("[Codex] User message received without an effort override");
+      }
+      let messageAppendSystemPrompt = currentAppendSystemPrompt;
+      if (message.meta?.hasOwnProperty("appendSystemPrompt")) {
+        messageAppendSystemPrompt = message.meta.appendSystemPrompt || void 0;
+        currentAppendSystemPrompt = messageAppendSystemPrompt;
+        logger.debug("[Codex] Append system prompt override updated", logValueMetadata(message.meta.appendSystemPrompt));
+      } else {
+        logger.debug("[Codex] User message received without an append system prompt override");
+      }
+      const enhancedMode = {
+        permissionMode: messagePermissionMode || "default",
+        model: messageModel,
+        appendSystemPrompt: messageAppendSystemPrompt,
+        effort: messageEffort
+      };
+      const enqueueResult = enqueueCodexUserText({
+        text: message.content.text,
+        mode: enhancedMode,
+        queue: messageQueue,
+        attachments,
+        sourceId: message.localKey
+      });
+      if (enqueueResult === "clear") {
+        logger.debug("[Codex] /clear command pushed to isolated queue");
+      }
+    }).catch((error) => {
+      logger.warn("[Codex] Failed to prepare user attachments", safeCodexErrorMetadata(error));
+      session.sendSessionEvent({ type: "message", message: "Could not prepare this message. Please send it again." });
+    });
+  });
+  let thinking = false;
+  let currentTurnId = null;
+  let codexStartedSubagents = /* @__PURE__ */ new Set();
+  let codexActiveSubagents = /* @__PURE__ */ new Set();
+  let codexProviderSubagentToSessionSubagent = /* @__PURE__ */ new Map();
+  session.keepAlive(thinking, "remote");
+  const keepAliveInterval = setInterval(() => {
+    session.keepAlive(thinking, "remote");
+  }, 2e3);
+  const sendReady = () => {
+    session.sendSessionEvent({ type: "ready" });
+    try {
+      api.push().sendSessionNotification({
+        kind: "done",
+        metadata: session.getMetadata(),
+        data: {
+          sessionId: session.sessionId,
+          type: "ready",
+          provider: "codex"
+        }
+      });
+    } catch (pushError) {
+      logger.debug("[Codex] Failed to send ready push", safeCodexErrorMetadata(pushError));
+    }
+  };
+  function logActiveHandles(tag) {
+    if (!process.env.DEBUG) return;
+    const anyProc = process;
+    const handles = typeof anyProc._getActiveHandles === "function" ? anyProc._getActiveHandles() : [];
+    const requests = typeof anyProc._getActiveRequests === "function" ? anyProc._getActiveRequests() : [];
+    logger.debug(`[codex][handles] ${tag}: handles=${handles.length} requests=${requests.length}`);
+    try {
+      const kinds = handles.map((h) => h && h.constructor ? h.constructor.name : typeof h);
+      logger.debug(`[codex][handles] kinds=${JSON.stringify(kinds)}`);
+    } catch {
+    }
+  }
+  let abortController = new AbortController();
+  let shouldExit = false;
+  async function handleAbort() {
+    if (abortInProgress) {
+      await abortInProgress;
+      return;
+    }
+    logger.debug("[Codex] Abort requested - stopping current task");
+    abortInProgress = (async () => {
+      try {
+        if (permissionHandler) {
+          permissionHandler.abortAll();
+        }
+        if (client) {
+          const abortResult = await client.abortTurnWithFallback({
+            gracePeriodMs: 3e3,
+            forceRestartOnTimeout: true
+          });
+          if (abortResult.forcedRestart) {
+            logger.warn("[Codex] Forced app-server restart after interrupt timeout");
+            session.sendSessionEvent({
+              type: "message",
+              message: abortResult.resumedThread ? "Force-stopped active task after interrupt timeout. Codex backend was restarted and the previous thread was resumed." : "Force-stopped active task after interrupt timeout. Codex backend was restarted, but the previous thread could not be resumed."
+            });
+          }
+        }
+        if (reasoningProcessor) {
+          reasoningProcessor.abort();
+        }
+        logger.debug("[Codex] Abort completed - session remains active");
+      } catch (error) {
+        logger.debug("[Codex] Error during abort", safeCodexErrorMetadata(error));
+      } finally {
+        resetCurrentModeDefaults();
+        abortController.abort();
+        abortController = new AbortController();
+      }
+    })();
+    await abortInProgress;
+    abortInProgress = null;
+  }
+  const handleKillSession = async () => {
+    logger.debug("[Codex] Kill session requested - terminating process");
+    await handleAbort();
+    logger.debug("[Codex] Abort completed, proceeding with termination");
+    try {
+      if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      try {
+        await client.disconnect();
+      } catch (e) {
+        logger.debug("[Codex] Error disconnecting Codex during termination", safeCodexErrorMetadata(e));
+      }
+      happyServer.stop();
+      logger.debug("[Codex] Session termination complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      logger.debug("[Codex] Error during session termination", safeCodexErrorMetadata(error));
+      process.exit(1);
+    }
+  };
+  session.rpcHandlerManager.registerHandler("codex-child-read", async (args) => {
+    try {
+      return await readChildThread(client, args?.threadId);
+    } catch (error) {
+      return { error: error instanceof Error ? error.message : "Child read failed" };
+    }
+  });
+  session.rpcHandlerManager.registerHandler("abort", handleAbort);
+  const disposeTermination = registerKillSessionHandler(session.rpcHandlerManager, handleKillSession, session, { processSignals: true });
+  const messageBuffer = new MessageBuffer();
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  let inkInstance = null;
+  if (hasTTY) {
+    console.clear();
+    inkInstance = render(React.createElement(CodexDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? logger.getLogPath() : void 0,
+      onExit: async () => {
+        logger.debug("[codex]: Exiting agent via Ctrl-C");
+        shouldExit = true;
+        await handleAbort();
+      }
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    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) => {
+    const envelopes = mapCodexProcessorMessageToSessionEnvelopes(message, { currentTurnId });
+    for (const envelope of envelopes) {
+      session.sendSessionProtocolMessage(envelope);
+    }
+  });
+  const diffProcessor = new DiffProcessor((message) => {
+    const envelopes = mapCodexProcessorMessageToSessionEnvelopes(message, { currentTurnId });
+    for (const envelope of envelopes) {
+      session.sendSessionProtocolMessage(envelope);
+    }
+  });
+  client.setApprovalHandler(async (params) => {
+    const toolName = params.type === "exec" ? "CodexBash" : params.type === "patch" ? "CodexPatch" : params.toolName ?? "McpTool";
+    const input = params.type === "exec" ? { command: params.command, cwd: params.cwd } : params.type === "patch" ? { changes: params.fileChanges } : params.input ?? {};
+    try {
+      const result = await permissionHandler.handleToolCall(params.callId, toolName, input);
+      logger.debug("[Codex] Permission request resolved");
+      return result.decision;
+    } catch (error) {
+      logger.debug("[Codex] Error handling permission", safeCodexErrorMetadata(error));
+      return "denied";
+    }
+  });
+  const editThrottle = new EditReportThrottle();
+  client.setEventHandler((msg) => {
+    if (msg.type === "token_count") {
+      session.sendAgentUsageSnapshot("codex", msg);
+    }
+    logger.debug("[Codex] Event metadata", codexEventLogMetadata(msg));
+    if (msg.type === "agent_message") {
+      messageBuffer.addMessage(msg.message, "assistant");
+    } else if (msg.type === "agent_reasoning_delta") ; else if (msg.type === "agent_reasoning") {
+      messageBuffer.addMessage(`[Thinking] ${msg.text.substring(0, 100)}...`, "system");
+    } else if (msg.type === "exec_command_begin") {
+      messageBuffer.addMessage(`Executing: ${msg.command}`, "tool");
+    } else if (msg.type === "exec_command_end") {
+      const output = msg.output || msg.error || "Command completed";
+      const truncatedOutput = output.substring(0, 200);
+      messageBuffer.addMessage(
+        `Result: ${truncatedOutput}${output.length > 200 ? "..." : ""}`,
+        "result"
+      );
+    } else if (msg.type === "task_started") {
+      messageBuffer.addMessage("Starting task...", "status");
+    } else if (msg.type === "task_complete") {
+      const failure = describeCodexFailure(msg);
+      if (failure) {
+        messageBuffer.addMessage(`Task failed: ${failure}`, "status");
+        session.sendSessionEvent({ type: "message", message: `Codex error: ${failure}` });
+      } else {
+        messageBuffer.addMessage("Task completed", "status");
+      }
+    } else if (msg.type === "turn_aborted") {
+      const failure = describeCodexFailure(msg);
+      if (failure) {
+        messageBuffer.addMessage(`Turn aborted: ${failure}`, "status");
+        session.sendSessionEvent({ type: "message", message: `Codex error: ${failure}` });
+      } else {
+        messageBuffer.addMessage("Turn aborted", "status");
+      }
+    }
+    if (msg.type === "task_started") {
+      if (!thinking) {
+        logger.debug("thinking started");
+        thinking = true;
+        session.keepAlive(thinking, "remote");
+      }
+    }
+    if (msg.type === "task_complete" || msg.type === "turn_aborted") {
+      if (thinking) {
+        logger.debug("thinking completed");
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+      }
+      diffProcessor.reset();
+    }
+    if (msg.type === "agent_reasoning_section_break") {
+      reasoningProcessor.handleSectionBreak();
+    }
+    if (msg.type === "agent_reasoning_delta") {
+      reasoningProcessor.processDelta(msg.delta);
+    }
+    if (msg.type === "agent_reasoning") {
+      reasoningProcessor.complete(msg.text);
+    }
+    if (msg.type === "patch_apply_begin") {
+      const { changes } = msg;
+      for (const edit of editThrottle.take(extractCodexPatchPaths(changes))) {
+        reportSessionEditToDaemon({ sessionId: session.sessionId, path: edit.path, tool: edit.tool, cwd: process.cwd() });
+      }
+      const changeCount = Object.keys(changes).length;
+      const filesMsg = changeCount === 1 ? "1 file" : `${changeCount} files`;
+      messageBuffer.addMessage(`Modifying ${filesMsg}...`, "tool");
+    }
+    if (msg.type === "patch_apply_end") {
+      const { stdout, stderr, success } = msg;
+      if (success) {
+        const message = stdout || "Files modified successfully";
+        messageBuffer.addMessage(message.substring(0, 200), "result");
+      } else {
+        const errorMsg = stderr || "Failed to modify files";
+        messageBuffer.addMessage(`Error: ${errorMsg.substring(0, 200)}`, "result");
+      }
+    }
+    if (msg.type === "turn_diff") {
+      if (msg.unified_diff) {
+        diffProcessor.processDiff(msg.unified_diff);
+      }
+    }
+    if (msg.type !== "agent_reasoning_delta" && msg.type !== "agent_reasoning" && msg.type !== "agent_reasoning_section_break" && msg.type !== "turn_diff") {
+      const mapped = mapCodexMcpMessageToSessionEnvelopes(msg, {
+        currentTurnId,
+        startedSubagents: codexStartedSubagents,
+        activeSubagents: codexActiveSubagents,
+        providerSubagentToSessionSubagent: codexProviderSubagentToSessionSubagent
+      });
+      currentTurnId = mapped.currentTurnId;
+      codexStartedSubagents = mapped.startedSubagents;
+      codexActiveSubagents = mapped.activeSubagents;
+      codexProviderSubagentToSessionSubagent = mapped.providerSubagentToSessionSubagent;
+      for (const envelope of mapped.envelopes) {
+        session.sendSessionProtocolMessage(envelope);
+      }
+    }
+  });
+  const happyServer = await startHappyServer(session);
+  const bridgeEntrypoint = join(projectPath(), "bin", "very-happy-mcp.mjs");
+  const mcpServers = {
+    happy: {
+      command: process.execPath,
+      args: ["--no-warnings", "--no-deprecation", bridgeEntrypoint, "--url", happyServer.url]
+    }
+  };
+  let first = true;
+  let appendSystemPromptInjected = false;
+  process.env.VH_PEER_SESSION_ID = session.sessionId;
+  try {
+    logger.debug("[codex]: client.connect begin");
+    await client.connect();
+    logger.debug("[codex]: client.connect done");
+    try {
+      discoveredModels = await client.listModels();
+      if (discoveredModels.length > 0) {
+        session.updateMetadata((metadata2) => ({
+          ...metadata2,
+          models: discoveredModels.map((model) => ({
+            code: model.model,
+            value: model.displayName,
+            description: model.description,
+            reasoningEfforts: model.supportedReasoningEfforts.map((option) => option.reasoningEffort),
+            defaultReasoningEffort: model.defaultReasoningEffort
+          })),
+          defaultModelCode: discoveredModels.find((model) => model.isDefault)?.model
+        }));
+      }
+    } catch (error) {
+      logger.debug("[Codex] Model discovery unavailable; using compatibility fallback", safeCodexErrorMetadata(error));
+    }
+    if (opts.resumeThreadId) {
+      await resumeExistingThread({
+        client,
+        session,
+        messageBuffer,
+        threadId: opts.resumeThreadId,
+        cwd: process.cwd(),
+        mcpServers
+      });
+      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 {
+        const { thread } = await client.readThread({
+          threadId: forkCodexThreadId,
+          includeTurns: true
+        });
+        const envelopes = mapCodexThreadToSessionEnvelopes(thread);
+        for (const envelope of envelopes) {
+          session.sendSessionProtocolMessage(envelope);
+        }
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          codexThreadId: forkCodexThreadId
+        }));
+        logger.debug(`[CODEX FORK BACKFILL] Replayed ${envelopes.length} historical envelopes from thread ${forkCodexThreadId}`);
+      } catch (error) {
+        logger.debug(`[CODEX FORK BACKFILL] Failed to read thread ${forkCodexThreadId}`, safeCodexErrorMetadata(error));
+      }
+    }
+    let pending = null;
+    idleRelease.arm();
+    while (!shouldExit) {
+      logActiveHandles("loop-top");
+      let message = pending;
+      pending = null;
+      if (!message) {
+        const waitSignal = abortController.signal;
+        const batch = await messageQueue.waitForMessagesAndGetAsString(waitSignal);
+        if (!batch) {
+          if (waitSignal.aborted && !shouldExit) {
+            logger.debug("[codex]: Wait aborted while idle; ignoring and continuing");
+            continue;
+          }
+          logger.debug(`[codex]: batch=${!!batch}, shouldExit=${shouldExit}`);
+          break;
+        }
+        message = batch;
+      }
+      if (!message) {
+        break;
+      }
+      idleRelease.cancel();
+      turnActive = true;
+      if (isCodexClearText(message.message)) {
+        logger.debug("[Codex] Handling /clear command - resetting Codex thread state");
+        client.clearThreadState();
+        currentTurnId = null;
+        codexStartedSubagents = /* @__PURE__ */ new Set();
+        codexActiveSubagents = /* @__PURE__ */ new Set();
+        codexProviderSubagentToSessionSubagent = /* @__PURE__ */ new Map();
+        permissionHandler.reset();
+        reasoningProcessor.abort();
+        diffProcessor.reset();
+        appendSystemPromptInjected = false;
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+        messageBuffer.addMessage("Context was reset", "status");
+        session.sendSessionEvent({ type: "message", message: "Context was reset" });
+        session.updateMetadata((currentMetadata) => {
+          const nextMetadata = { ...currentMetadata };
+          delete nextMetadata.codexThreadId;
+          return nextMetadata;
+        });
+        emitReadyIfIdle({
+          pending,
+          // B-509: server-queued prompts count as pending input (no ready/push per item).
+          queueSize: () => messageQueue.size() + (session.promptQueueHasPending() ? 1 : 0),
+          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,
+          sandboxManagedByHappy
+        );
+        const effortRefusal = unsupportedEffortReason(discoveredModels, message.mode.model, message.mode.effort);
+        if (effortRefusal) {
+          throw new Error(effortRefusal);
+        }
+        if (!client.hasActiveThread()) {
+          const startedThread = await client.startThread({
+            model: message.mode.model,
+            cwd: process.cwd(),
+            approvalPolicy: executionPolicy.approvalPolicy,
+            sandbox: executionPolicy.sandbox,
+            mcpServers
+          });
+          session.updateMetadata((currentMetadata) => ({
+            ...currentMetadata,
+            codexThreadId: startedThread.threadId
+          }));
+        }
+        const includeAppendSystemPrompt = Boolean(
+          message.mode.appendSystemPrompt && !appendSystemPromptInjected
+        );
+        const turnPrompt = buildCodexTurnPrompt({
+          message: message.message,
+          mode: message.mode,
+          includeAppendSystemPrompt,
+          includeTitleInstruction: first
+        });
+        const staged = message.attachments?.length ? await stageClaudeAttachments(message.attachments, {
+          happyHomeDir: configuration.happyHomeDir,
+          sessionId: session.sessionId
+        }) : [];
+        const result = await client.sendTurnAndWait(appendStagedAttachmentsToPrompt(turnPrompt, staged), {
+          images: staged.filter((file) => ["image/jpeg", "image/png", "image/gif", "image/webp"].includes(file.mimeType)).map((file) => file.path),
+          model: message.mode.model,
+          approvalPolicy: executionPolicy.approvalPolicy,
+          sandbox: executionPolicy.sandbox,
+          effort: message.mode.effort
+        });
+        first = false;
+        if (includeAppendSystemPrompt) {
+          appendSystemPromptInjected = true;
+        }
+        if (result.aborted) {
+          logger.debug("[Codex] Turn aborted");
+        }
+      } catch (error) {
+        logger.warn("Error in codex session", safeCodexErrorMetadata(error));
+        const reason = describeThrownTurnError(error);
+        if (reason) {
+          messageBuffer.addMessage(`Task failed: ${reason}`, "status");
+          session.sendSessionEvent({ type: "message", message: `Codex error: ${reason}` });
+        } else {
+          messageBuffer.addMessage("Process exited unexpectedly", "status");
+          session.sendSessionEvent({ type: "message", message: "Process exited unexpectedly" });
+        }
+      } finally {
+        permissionHandler.reset();
+        reasoningProcessor.abort();
+        diffProcessor.reset();
+        thinking = false;
+        session.keepAlive(thinking, "remote");
+        emitReadyIfIdle({
+          pending,
+          // B-509: server-queued prompts count as pending input (no ready/push per item).
+          queueSize: () => messageQueue.size() + (session.promptQueueHasPending() ? 1 : 0),
+          shouldExit,
+          sendReady
+        });
+        turnActive = false;
+        idleRelease.arm();
+        logActiveHandles("after-turn");
+      }
+    }
+  } finally {
+    disposeTermination?.();
+    session.closePromptQueueDrain();
+    logger.debug("[codex]: Final cleanup start");
+    logActiveHandles("cleanup-start");
+    if (reconnectionHandle) {
+      logger.debug("[codex]: Cancelling offline reconnection");
+      reconnectionHandle.cancel();
+    }
+    try {
+      logger.debug("[codex]: sendSessionDeath");
+      session.sendSessionDeath();
+      logger.debug("[codex]: flush begin");
+      await session.flush();
+      logger.debug("[codex]: flush done");
+      logger.debug("[codex]: session.close begin");
+      await session.close();
+      logger.debug("[codex]: session.close done");
+    } 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");
+    logger.debug("[codex]: happyServer.stop");
+    happyServer.stop();
+    if (process.stdin.isTTY) {
+      logger.debug("[codex]: setRawMode(false)");
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+    }
+    if (hasTTY) {
+      logger.debug("[codex]: stdin.pause()");
+      try {
+        process.stdin.pause();
+      } catch {
+      }
+    }
+    logger.debug("[codex]: clearInterval(keepAlive)");
+    clearInterval(keepAliveInterval);
+    if (inkInstance) {
+      logger.debug("[codex]: inkInstance.unmount()");
+      inkInstance.unmount();
+    }
+    messageBuffer.clear();
+    logActiveHandles("cleanup-end");
+    logger.debug("[codex]: Final cleanup completed");
+  }
+}
+
+function extractCodexResumeFlag(args) {
+  const remainingArgs = [];
+  let resumeThreadId = null;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--resume" || arg === "-r") {
+      if (resumeThreadId !== null) {
+        throw new Error("Codex resume flag can only be provided once.");
+      }
+      const nextArg = args[i + 1];
+      if (!nextArg || nextArg.startsWith("-")) {
+        throw new Error("Codex resume requires a thread ID: very-happy codex --resume <thread-id>");
+      }
+      resumeThreadId = nextArg;
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--resume=")) {
+      if (resumeThreadId !== null) {
+        throw new Error("Codex resume flag can only be provided once.");
+      }
+      const value = arg.slice("--resume=".length).trim();
+      if (!value) {
+        throw new Error("Codex resume requires a thread ID: very-happy codex --resume <thread-id>");
+      }
+      resumeThreadId = value;
+      continue;
+    }
+    remainingArgs.push(arg);
+  }
+  return {
+    resumeThreadId,
+    args: remainingArgs
+  };
+}
+
+async function handleCodexCommand(args) {
+  let startedBy = void 0;
+  let permissionMode = void 0;
+  const sandboxArgs = extractNoSandboxFlag(args);
+  const codexArgs = extractCodexResumeFlag(sandboxArgs.args);
+  for (let i = 0; i < codexArgs.args.length; i++) {
+    if (codexArgs.args[i] === "--started-by") {
+      startedBy = codexArgs.args[++i];
+    } else if (codexArgs.args[i] === "--permission-mode") {
+      permissionMode = codexArgs.args[++i];
+    } else if (codexArgs.args[i] === "--yolo") {
+      permissionMode = "yolo";
+    }
+  }
+  const { credentials } = await authAndSetupMachineIfNeeded();
+  await ensureDaemonRunning();
+  await runCodex({
+    credentials,
+    startedBy,
+    noSandbox: sandboxArgs.noSandbox,
+    resumeThreadId: codexArgs.resumeThreadId ?? void 0,
+    permissionMode
+  });
+}
+
+export { handleCodexCommand };