very-happy-cli 0.2.133 → 0.2.135

package/dist/{index-6Xm0CgN_.cjs → index-DNbKbe23.cjs}

@@ -3,13 +3,13 @@
 var chalk = require('chalk');
 var os = require('node:os');
 var node_crypto = require('node:crypto');
-var api = require('./types-CcjVmS2i.cjs');
-var persistence = require('./limits-XRNzIlVm.cjs');
+var api = require('./types-DjAHWb4J.cjs');
+var persistence = require('./limits-K17AgMHD.cjs');
 var spawn = require('cross-spawn');
 var path = require('node:path');
 var node_readline = require('node:readline');
 var node_fs = require('node:fs');
-var agentGuidance = require('./agentGuidance-BItqIZTf.cjs');
+var agentGuidance = require('./agentGuidance-DlZM_YPV.cjs');
 var promises = require('node:fs/promises');
 var fs = require('fs/promises');
 var ink = require('ink');
@@ -1353,6 +1353,152 @@ async function claudeLocalLauncher(session) {
   return exitReason || { type: "exit", code: 0 };
 }
 
+const text = (value) => typeof value === "string" && value.length > 0 && value.length <= 1024 && !value.includes("\0") ? value : null;
+const publicMcpStatus = (servers) => servers.map(({ name, status, serverInfo, scope, tools }) => ({ name, status, serverInfo, scope, tools: tools?.map(({ name: name2 }) => ({ name: name2 })) }));
+const fingerprint = (result) => JSON.stringify([result.canRewind, [...result.filesChanged ?? []].sort(), result.insertions, result.deletions]);
+function isRuntimeCheckpointReplay(message) {
+  const m = message;
+  return m.type === "user" && m.isReplay === true && !m.parent_tool_use_id && !(Array.isArray(m.message?.content) && m.message.content.some((block) => block.type === "tool_result"));
+}
+function createRuntimeControls(isThinking) {
+  let query = null, generation = node_crypto.randomInt(0, 2 ** 40), activityRevision = 0;
+  const operations = /* @__PURE__ */ new Map();
+  const confirmations = /* @__PURE__ */ new Map();
+  const tasks = /* @__PURE__ */ new Map();
+  const checkpoints = /* @__PURE__ */ new Map();
+  let pending = false;
+  const setQuery = (next) => {
+    for (const operation of operations.values()) if (operation.status === "running") {
+      operation.status = "failed";
+      operation.error = "Claude query ended before this operation completed";
+    }
+    query = next;
+    generation++;
+    pending = false;
+    confirmations.clear();
+    tasks.clear();
+    checkpoints.clear();
+  };
+  function observe(message) {
+    const m = message;
+    if (m.type === "user" || m.type === "assistant") {
+      activityRevision++;
+      confirmations.clear();
+    }
+    const content = typeof m.message?.content === "string" ? m.message.content : Array.isArray(m.message?.content) ? m.message.content.filter((block) => block.type === "text").map((block) => block.text).join(" ") : "";
+    if (isRuntimeCheckpointReplay(message) && text(m.uuid) && content) {
+      checkpoints.set(m.uuid, { id: m.uuid, title: content.slice(0, 120) });
+      if (checkpoints.size > 100) checkpoints.delete(checkpoints.keys().next().value);
+    }
+    if (m.type === "system" && text(m.task_id) && ["task_started", "task_updated", "task_progress", "task_notification"].includes(m.subtype)) {
+      const previous = tasks.get(m.task_id);
+      if (m.subtype !== "task_notification" && ["completed", "failed", "stopped", "cancelled"].includes(String(previous?.status))) return;
+      tasks.set(m.task_id, {
+        ...previous,
+        id: m.task_id,
+        ...text(m.tool_use_id) ? { toolUseId: m.tool_use_id } : {},
+        ...text(m.description) ? { description: m.description } : {},
+        ...text(m.task_type) ? { type: m.task_type } : {},
+        status: m.subtype === "task_notification" ? m.status ?? "completed" : "running"
+      });
+      if (tasks.size > 100) tasks.delete(tasks.keys().next().value);
+    }
+  }
+  function request(input) {
+    const r = input && typeof input === "object" ? input : {};
+    if (r.action === "status") return { queryGeneration: generation, active: !!query, isRunning: isThinking(), canRewind: !!query && !isThinking() && !pending && query.canControl(), busy: pending || !!query && !query.canControl(), tasks: [...tasks.values()], checkpoints: [...checkpoints.values()], operations: [...operations.values()].filter((op2) => op2.queryGeneration === generation) };
+    if (r.action === "operation") {
+      const op2 = operations.get(String(r.operationId));
+      return op2 ? { ...op2 } : { error: "Operation not found" };
+    }
+    const q = query;
+    if (!q) return { error: "No active Claude SDK query" };
+    if (pending || !q.canControl()) return { error: "Claude is waiting for an interaction or another control operation; retry after it finishes" };
+    const action = String(r.action), server = text(r.serverName), task = text(r.taskId), target = text(r.userMessageId);
+    const runGeneration = generation, runRevision = activityRevision;
+    let execute;
+    switch (action) {
+      case "reload-skills":
+        execute = () => q.reloadSkills();
+        break;
+      case "reload-plugins":
+        execute = async () => {
+          const result = await q.reloadPlugins();
+          return { ...result, mcpServers: publicMcpStatus(result.mcpServers ?? []) };
+        };
+        break;
+      case "mcp-status":
+        execute = async () => publicMcpStatus(await q.mcpServerStatus());
+        break;
+      case "mcp-reconnect":
+        if (!server) return { error: "Invalid server name" };
+        execute = () => q.reconnectMcpServer(server);
+        break;
+      case "mcp-toggle":
+        if (!server || typeof r.enabled !== "boolean") return { error: "Invalid server or enabled flag" };
+        execute = () => q.toggleMcpServer(server, r.enabled);
+        break;
+      case "stop-task":
+        if (!task || !tasks.has(task)) return { error: "Unknown task in this query" };
+        execute = () => q.stopTask(task);
+        break;
+      case "background-tasks":
+        if (r.toolUseId !== void 0 && !text(r.toolUseId)) return { error: "Invalid tool use ID" };
+        execute = async () => ({ backgrounded: await q.backgroundTasks(r.toolUseId) });
+        break;
+      case "rewind-preview":
+        if (isThinking() || !target || !checkpoints.has(target)) return { error: "Rewind requires an idle query and a known user checkpoint" };
+        execute = async () => {
+          const result = await q.rewindFiles(target, { dryRun: true });
+          if (!result.canRewind) return result;
+          if (query !== q || generation !== runGeneration || activityRevision !== runRevision || isThinking() || !q.canControl()) throw Error("Query changed; preview again");
+          const token = node_crypto.randomUUID();
+          confirmations.set(token, { generation, revision: activityRevision, userMessageId: target, fingerprint: fingerprint(result), expires: Date.now() + 3e5 });
+          return { ...result, confirmationToken: token };
+        };
+        break;
+      case "rewind-apply": {
+        const confirmation = confirmations.get(String(r.confirmationToken));
+        if (isThinking() || !confirmation || confirmation.generation !== generation || confirmation.expires < Date.now()) return { error: "Preview expired or query is running; preview again" };
+        confirmations.delete(String(r.confirmationToken));
+        execute = async () => {
+          const fresh = await q.rewindFiles(confirmation.userMessageId, { dryRun: true });
+          if (query !== q || generation !== runGeneration || activityRevision !== confirmation.revision || isThinking() || !q.canControl() || fingerprint(fresh) !== confirmation.fingerprint) throw Error("Files or query changed; preview again");
+          return q.rewindFiles(confirmation.userMessageId, { dryRun: false });
+        };
+        break;
+      }
+      default:
+        return { error: "Unknown Claude control action" };
+    }
+    pending = true;
+    const op = { id: node_crypto.randomUUID(), queryGeneration: runGeneration, action, status: "running" };
+    operations.set(op.id, op);
+    if (operations.size > 50) for (const [id, old] of operations) {
+      if (old.status !== "running") {
+        operations.delete(id);
+        break;
+      }
+    }
+    void Promise.resolve().then(() => {
+      if (query !== q || generation !== runGeneration || !q.canControl()) throw Error("Claude query changed or is waiting for an interaction");
+      return execute();
+    }).then((result) => {
+      if (generation !== runGeneration || op.status !== "running") return;
+      op.status = "completed";
+      op.result = result ?? null;
+    }, (error) => {
+      if (generation !== runGeneration || op.status !== "running") return;
+      op.status = "failed";
+      op.error = error instanceof Error ? error.message : "Claude control failed";
+    }).finally(() => {
+      if (generation === runGeneration) pending = false;
+    });
+    return { operationId: op.id };
+  }
+  return { setQuery, observe, request };
+}
+
 class MessageBuffer {
   messages = [];
   listeners = [];
@@ -1622,6 +1768,9 @@ function query(params) {
     tools: opts?.tools,
     persistSession: opts?.persistSession,
     includePartialMessages: opts?.includePartialMessages,
+    forwardSubagentText: true,
+    enableFileCheckpointing: true,
+    extraArgs: { "replay-user-messages": null },
     onElicitation: opts?.onElicitation,
     onUserDialog: opts?.onUserDialog,
     supportedDialogKinds: opts?.onUserDialog ? opts.supportedDialogKinds : void 0
@@ -2064,6 +2213,20 @@ async function claudeRemote(opts) {
       content: initial.message
     }
   });
+  let callbackDepth = 0;
+  const guardCallback = (callback) => (async (...args) => {
+    callbackDepth++;
+    try {
+      return await callback(...args);
+    } finally {
+      setImmediate(() => {
+        callbackDepth--;
+      });
+    }
+  });
+  if (sdkOptions.canCallTool) sdkOptions.canCallTool = guardCallback(sdkOptions.canCallTool);
+  if (sdkOptions.onElicitation) sdkOptions.onElicitation = guardCallback(sdkOptions.onElicitation);
+  if (sdkOptions.onUserDialog) sdkOptions.onUserDialog = guardCallback(sdkOptions.onUserDialog);
   const response = query({
     prompt: messages,
     options: sdkOptions
@@ -2084,6 +2247,15 @@ async function claudeRemote(opts) {
   }
   if (opts.onQueryReady) {
     opts.onQueryReady({
+      canControl: () => callbackDepth === 0,
+      reloadSkills: () => response.reloadSkills(),
+      reloadPlugins: () => response.reloadPlugins(),
+      mcpServerStatus: () => response.mcpServerStatus(),
+      reconnectMcpServer: (name) => response.reconnectMcpServer(name),
+      toggleMcpServer: (name, enabled) => response.toggleMcpServer(name, enabled),
+      stopTask: (id) => response.stopTask(id),
+      backgroundTasks: (id) => response.backgroundTasks(id),
+      rewindFiles: (id, options) => response.rewindFiles(id, options),
       setPermissionMode: (mode2) => response.setPermissionMode(mode2),
       setModel: (model) => response.setModel(modelTarget(model)),
       interrupt: async () => {
@@ -2727,7 +2899,7 @@ class PermissionHandler {
       } else if (pending.kind === "elicitation") {
         pending.resolve(message.approved ? { action: "accept", content: elicitationContent(message.updatedInput) } : { action: message.decision === "abort" ? "cancel" : "decline" });
       } else {
-        pending.resolve(message.approved ? { behavior: "completed", result: message.updatedInput?.result ?? "retry_fallback" } : { behavior: "cancelled" });
+        pending.resolve(message.approved && pending.request.dialogKind === "refusal_fallback_prompt" && (message.updatedInput?.result === void 0 || message.updatedInput.result === "retry_fallback") ? { behavior: "completed", result: "retry_fallback" } : { behavior: "cancelled" });
       }
       this.recordCompletedRequest(id, effectiveResponse);
       this.scheduleDeferredPermissionModeUpdate();
@@ -3189,6 +3361,7 @@ class SDKToLogConverter {
   }
 }
 
+const transcriptSystemSubtypes = /* @__PURE__ */ new Set(["task_started", "task_updated", "task_progress", "task_notification"]);
 class OutgoingMessageQueue {
   constructor(sendFunction) {
     this.sendFunction = sendFunction;
@@ -3270,7 +3443,7 @@ class OutgoingMessageQueue {
         break;
       }
       if (!item.sent) {
-        if (item.logMessage.type !== "system") {
+        if (item.logMessage.type !== "system" || transcriptSystemSubtypes.has(item.logMessage.subtype)) {
           this.sendFunction(item.logMessage);
         }
         item.sent = true;
@@ -3898,6 +4071,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   let abortController = null;
   let abortFuture = null;
   const turnSteering = createTurnSteeringController();
+  const runtimeControls = createRuntimeControls(() => session.thinking);
+  session.client.rpcHandlerManager.registerHandler("claude-runtime-control", async (input) => runtimeControls.request(input));
   async function abort() {
     if (abortController && !abortController.signal.aborted) {
       abortController.abort();
@@ -3958,6 +4133,8 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
   let ongoingToolCalls = /* @__PURE__ */ new Map();
   let notifiedQuestionToolCalls = /* @__PURE__ */ new Set();
   function onMessage(message) {
+    runtimeControls.observe(message);
+    if (isRuntimeCheckpointReplay(message)) return;
     if (message.type === "user" && isClaudeInterruptSentinelContent(message.message.content)) {
       sdkToLogConverter.convert(message);
       return;
@@ -4180,6 +4357,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
             if (metadata.permissionMode) onEffectivePermissionMode?.(metadata.permissionMode);
           },
           onQueryReady: (q) => {
+            runtimeControls.setQuery(q);
             turnSteering.setInterrupt(q.interrupt);
             session.setSteerHandler(async (input) => {
               if (!modeGate.matches(input.mode)) return false;
@@ -4269,6 +4447,7 @@ async function claudeRemoteLauncher(session, onPermissionModeChange, onEffective
           continue;
         }
       } finally {
+        runtimeControls.setQuery(null);
         turnSteering.reset();
         session.setSteerHandler(null);
         livePermissionModeHandler = null;
@@ -5319,6 +5498,80 @@ ${typeLabels[type] || type}:`));
   console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
 }
 
+const AGENT_CHECK_INTERVAL = 6 * 60 * 60 * 1e3;
+function stableVersion(value) {
+  const match = value.trim().match(/(?:^|\s|v)(\d+\.\d+\.\d+)([-+][\w.-]+)?(?=\s|$)/);
+  return match && !match[2] ? match[1] : null;
+}
+function newerVersion(current, latest) {
+  const a = current.split(".").map(Number), b = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (b[i] !== a[i]) return b[i] > a[i];
+  }
+  return false;
+}
+const runVersionCommand = (command, args, shell) => new Promise((resolve, reject) => {
+  node_child_process.execFile(
+    command,
+    args,
+    { timeout: 5e3, maxBuffer: 32 * 1024, windowsHide: true, shell },
+    (error, stdout) => error ? reject(error) : resolve(stdout)
+  );
+});
+async function probeAgentVersion(command, platform = process.platform, run = runVersionCommand) {
+  if (platform === "win32") {
+    try {
+      await run("where.exe", [command], false);
+    } catch (error) {
+      return { version: null, missing: error.code === 1 };
+    }
+  }
+  try {
+    return { version: stableVersion(await run(command, ["--version"], platform === "win32")), missing: false };
+  } catch (error) {
+    return { version: null, missing: error.code === "ENOENT" };
+  }
+}
+async function registryVersion(name) {
+  const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(name)}/latest`, { signal: AbortSignal.timeout(5e3) });
+  if (!response.ok) throw new Error("Registry unavailable");
+  const data = await response.json();
+  return typeof data.version === "string" ? stableVersion(data.version) : null;
+}
+async function detectAgentVersions(deps = { probe: probeAgentVersion, registryVersion }, now = Date.now()) {
+  const agents = await Promise.all(api.AGENT_VERSION_SOURCES.map(async (source) => {
+    const local = source.command ? await deps.probe(source.command).catch(() => ({ version: null, missing: false })) : { version: stableVersion(persistence.packageJson.dependencies["@anthropic-ai/claude-agent-sdk"]), missing: false };
+    if (local.missing) return { id: source.id, installed: null, latest: null, status: "not-installed" };
+    const latest = await deps.registryVersion(source.package).catch(() => null);
+    const installed = local.version;
+    const status = !installed || !latest ? "unknown" : newerVersion(installed, latest) ? "update-available" : "current";
+    return { id: source.id, installed, latest, status };
+  }));
+  return { checkedAt: now, daemonPid: process.pid, agents };
+}
+function startAgentVersionChecks(publish, onError, detect = detectAgentVersions) {
+  let stopped = false, pending = false;
+  async function refresh() {
+    if (stopped || pending) return;
+    pending = true;
+    try {
+      const snapshot = await detect();
+      if (!stopped) await publish(snapshot);
+    } catch (error) {
+      onError(error);
+    } finally {
+      pending = false;
+    }
+  }
+  void refresh();
+  const timer = setInterval(() => void refresh(), AGENT_CHECK_INTERVAL);
+  timer.unref();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+
 function sanitizeSpawnModel(value) {
   if (typeof value !== "string") return null;
   return /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}(\[1m\])?$/i.test(value) ? value : null;
@@ -7750,7 +8003,7 @@ function parseJsonObject(text) {
     return null;
   }
 }
-function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-6Xm0CgN_.cjs', document.baseURI).href))).resolve(s)) {
+function resolveSdkClaudeBinary(platform = process.platform, arch = process.arch, resolver = (s) => node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DNbKbe23.cjs', document.baseURI).href))).resolve(s)) {
   const platformArch = `${platform}-${arch}`;
   const candidates = [
     `@anthropic-ai/claude-agent-sdk-${platformArch}/claude`,
@@ -10991,6 +11244,10 @@ async function startDaemon() {
       persistence.logger.warn(`[DAEMON RUN] Ignoring invalid HAPPY_CLI_UPDATE_CHECK_INTERVAL; using ${api.DEFAULT_CLI_UPDATE_CHECK_INTERVAL_MS}ms`);
     }
     const cliUpdateInterval = setInterval(() => void refreshCliUpdate(), cliUpdateIntervalMs);
+    const stopAgentVersionChecks = startAgentVersionChecks(
+      (snapshot) => apiMachine.updateDaemonState((state) => ({ ...state, status: state?.status ?? "running", agentVersions: snapshot })),
+      (error) => persistence.logger.debug("[DAEMON RUN] Agent version check failed", error)
+    );
     const heartbeatIntervalMs = parseInt(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL || "60000");
     const restartOnStaleVersionAndHeartbeat = setInterval(serialTask(async () => {
       try {
@@ -11031,6 +11288,7 @@ async function startDaemon() {
             teamWorker?.stop();
             clearInterval(restartOnStaleVersionAndHeartbeat);
             clearInterval(cliUpdateInterval);
+            stopAgentVersionChecks();
             claudeAuthService.stop();
             apiMachine.shutdown();
             await stopControlServer();
@@ -11092,6 +11350,7 @@ async function startDaemon() {
         persistence.logger.debug("[DAEMON RUN] Health check interval cleared");
       }
       clearInterval(cliUpdateInterval);
+      stopAgentVersionChecks();
       await apiMachine.updateDaemonState((state) => ({
         ...state,
         status: "shutting-down",
@@ -12040,7 +12299,7 @@ function cleanupHookSettingsFile(filepath) {
   }
 }
 
-function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEvents) {
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEvents, options) {
   let terminationStarted = false;
   const terminateOnce = () => {
     if (terminationStarted) return;
@@ -12048,6 +12307,10 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEve
     void killThisHappy();
   };
   archiveEvents.on("archived", terminateOnce);
+  if (options?.processSignals) {
+    process.on("SIGTERM", terminateOnce);
+    process.on("SIGINT", terminateOnce);
+  }
   rpcHandlerManager.registerHandler("killSession", async () => {
     persistence.logger.debug("Kill session request received");
     terminateOnce();
@@ -12056,6 +12319,13 @@ function registerKillSessionHandler(rpcHandlerManager, killThisHappy, archiveEve
       message: "Killing happy-cli process"
     };
   });
+  return () => {
+    archiveEvents.off?.("archived", terminateOnce);
+    if (options?.processSignals) {
+      process.off("SIGTERM", terminateOnce);
+      process.off("SIGINT", terminateOnce);
+    }
+  };
 }
 
 const SIDE_QUESTION_SYSTEM_PROMPT = [
@@ -12170,7 +12440,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 Promise.resolve().then(function () { return require('./index-CdH3ecC5.cjs'); });
+    const { query } = await Promise.resolve().then(function () { return require('./index-DHI6Y1xW.cjs'); });
     return runSideQuestion(query, input);
   });
   const slots = /* @__PURE__ */ new Map();
@@ -12272,7 +12542,7 @@ const MAX_TITLE_CHARS = 60;
 const GENERATION_TIMEOUT_MS = 3e4;
 function resolveClaudeBinary() {
   try {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-6Xm0CgN_.cjs', document.baseURI).href)));
+    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DNbKbe23.cjs', document.baseURI).href)));
     const utilsPath = path.resolve(path.join(api.projectPath(), "scripts", "claude_version_utils.cjs"));
     const { getClaudeCliPath } = require$1(utilsPath);
     const path$1 = getClaudeCliPath();
@@ -12733,7 +13003,7 @@ async function runClaude(credentials, options = {}) {
     // a brand-new session cannot pick a PDF until after sending once.
     attachmentKinds: [...CLAUDE_ATTACHMENT_KINDS],
     queueCancellation: true,
-    capabilities: ["claude-steer-v1", "claude-live-permission-v1", "claude-live-permission-v2", "claude-btw-v1"],
+    capabilities: ["claude-steer-v1", "claude-live-permission-v1", "claude-live-permission-v2", "claude-btw-v1", "claude-runtime-controls-v1"],
     // Effective mode this process enforces. Kept current by
     // publishPermissionMode below; the web renders it instead of guessing.
     permissionMode: mapToClaudeMode(initialPermissionMode ?? "default"),
@@ -14490,9 +14760,9 @@ function resolveLocalSignupBootstrap(configuredMode, configuredInviteCodes, gene
   };
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-6Xm0CgN_.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DNbKbe23.cjs', document.baseURI).href)));
 const __dirname$1 = path.dirname(__filename$1);
-const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-6Xm0CgN_.cjs', document.baseURI).href)));
+const require_ = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DNbKbe23.cjs', document.baseURI).href)));
 const PRISMA_QUERY_ENGINE_FILES = {
   "arm64-darwin": "libquery_engine-darwin-arm64.dylib.node",
   "x64-darwin": "libquery_engine-darwin.dylib.node",
@@ -14914,1269 +15184,1325 @@ async function ensureDaemonRunning() {
   persistence.logger.debug(`Happy background service did not become ready within ${DAEMON_READY_TIMEOUT_MS}ms; continuing anyway`);
 }
 
-function registerAgentAttachmentDownloads(session) {
-  session.onFileEvent((fileEvent) => {
-    const attachment = fileEvent.content.data.ev;
-    const download = (async () => {
-      try {
-        const data = await session.downloadAndDecryptAttachment(attachment.ref);
-        if (!data) throw new Error("Attachment decryption failed");
-        return { data, mimeType: attachment.mimeType ?? "image/jpeg", name: attachment.name };
-      } catch {
-        session.sendSessionEvent({ type: "message", message: `Could not download attachment: ${attachment.name}. Please attach it again.` });
-        return null;
-      }
-    })();
-    session.trackAttachmentDownload(download);
-  });
+function getStartedSubagents(state) {
+  return state.startedSubagents ?? /* @__PURE__ */ new Set();
 }
-
-class BasePermissionHandler {
-  pendingRequests = /* @__PURE__ */ new Map();
-  session;
-  isResetting = false;
-  constructor(session) {
-    this.session = session;
-    this.setupRpcHandler();
+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;
   }
-  /**
-   * Update the session reference (used after offline reconnection swaps sessions).
-   * This is critical for avoiding stale session references after onSessionSwap.
-   */
-  updateSession(newSession) {
-    persistence.logger.debug(`${this.getLogPrefix()} Session reference updated`);
-    this.session = newSession;
-    this.setupRpcHandler();
+  envelopes.push(api.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(api.createEnvelope("agent", { t: "stop" }, { ...opts, subagent }));
   }
-  /**
-   * Setup RPC handler for permission responses.
-   */
-  setupRpcHandler() {
-    this.session.rpcHandlerManager.registerHandler(
-      "permission",
-      async (response) => {
-        const pending = this.pendingRequests.get(response.id);
-        if (!pending) {
-          persistence.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
-          return;
-        }
-        this.pendingRequests.delete(response.id);
-        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
-        pending.resolve(result);
-        this.session.updateAgentState((currentState) => {
-          const request = currentState.requests?.[response.id];
-          if (!request) return currentState;
-          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
-          let res = {
-            ...currentState,
-            requests: remainingRequests,
-            completedRequests: {
-              ...currentState.completedRequests,
-              [response.id]: {
-                ...request,
-                completedAt: Date.now(),
-                status: response.approved ? "approved" : "denied",
-                decision: result.decision
-              }
-            }
-          };
-          return res;
-        });
-        persistence.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
-      }
-    );
+  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;
+    }
   }
-  /**
-   * Add a pending request to the agent state.
-   */
-  addPendingRequestToState(toolCallId, toolName, input) {
-    this.session.updateAgentState((currentState) => ({
-      ...currentState,
-      requests: {
-        ...currentState.requests,
-        [toolCallId]: {
-          tool: toolName,
-          arguments: input,
-          createdAt: Date.now()
-        }
-      }
-    }));
+  return void 0;
+}
+function resolveSessionSubagent(message, providerSubagentToSessionSubagent) {
+  const providerSubagent = pickProviderSubagent(message);
+  if (!providerSubagent) {
+    return void 0;
   }
-  /**
-   * Abort all pending permission requests.
-   * Unlike reset(), this resolves (not rejects) pending promises with { decision: 'abort' },
-   * causing the approval response to send 'cancel' to the provider. This is used when the
-   * user presses the abort/stop button — it unblocks any pending tool approval so the provider
-   * can process the turn cancellation.
-   */
-  abortAll() {
-    const pendingSnapshot = Array.from(this.pendingRequests.entries());
-    if (pendingSnapshot.length === 0) return;
-    this.pendingRequests.clear();
-    for (const [id, pending] of pendingSnapshot) {
-      try {
-        pending.resolve({ decision: "abort" });
-      } catch (err) {
-        persistence.logger.debug(`${this.getLogPrefix()} Error resolving aborted request ${id}:`, err);
-      }
-    }
-    this.session.updateAgentState((currentState) => {
-      const pendingRequests = currentState.requests || {};
-      const completedRequests = { ...currentState.completedRequests };
-      for (const [id, request] of Object.entries(pendingRequests)) {
-        completedRequests[id] = {
-          ...request,
-          completedAt: Date.now(),
-          status: "canceled",
-          reason: "Aborted by user"
-        };
-      }
-      return {
-        ...currentState,
-        requests: {},
-        completedRequests
-      };
-    });
-    persistence.logger.debug(`${this.getLogPrefix()} Aborted ${pendingSnapshot.length} pending permission(s)`);
-  }
-  /**
-   * Reset state for new sessions.
-   * This method is idempotent - safe to call multiple times.
-   */
-  reset(reason = "Session reset") {
-    if (this.isResetting) {
-      persistence.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
-      return;
-    }
-    this.isResetting = true;
-    try {
-      const pendingSnapshot = Array.from(this.pendingRequests.entries());
-      this.pendingRequests.clear();
-      for (const [id, pending] of pendingSnapshot) {
-        try {
-          pending.reject(new Error("Session reset"));
-        } catch (err) {
-          persistence.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
-        }
-      }
-      this.session.updateAgentState((currentState) => {
-        const pendingRequests = currentState.requests || {};
-        const completedRequests = { ...currentState.completedRequests };
-        for (const [id, request] of Object.entries(pendingRequests)) {
-          completedRequests[id] = {
-            ...request,
-            completedAt: Date.now(),
-            status: "canceled",
-            reason
-          };
-        }
-        return {
-          ...currentState,
-          requests: {},
-          completedRequests
-        };
-      });
-      persistence.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
-    } finally {
-      this.isResetting = false;
-    }
+  const existing = providerSubagentToSessionSubagent.get(providerSubagent);
+  if (existing) {
+    return existing;
   }
+  const created = cuid2.createId();
+  providerSubagentToSessionSubagent.set(providerSubagent, created);
+  return created;
 }
-
-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);
+function pickCallId(message) {
+  const callId = message.call_id ?? message.callId;
+  if (typeof callId === "string" && callId.length > 0) {
+    return callId;
   }
-  getLogPrefix() {
-    return "[Codex]";
+  return node_crypto.randomUUID();
+}
+function summarizeCommand(command) {
+  if (typeof command === "string" && command.trim().length > 0) {
+    return command;
   }
-  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;
+  if (Array.isArray(command)) {
+    const cmd = command.map((v) => String(v)).join(" ").trim();
+    return cmd.length > 0 ? cmd : null;
   }
-  /**
-   * 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)) {
-      persistence.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);
-      persistence.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})`);
-    });
+  return null;
+}
+function commandToTitle(command) {
+  if (!command) {
+    return "Run command";
   }
+  const short = command.length > 80 ? `${command.slice(0, 77)}...` : command;
+  return `Run \`${short}\``;
 }
-
-class BaseReasoningProcessor {
-  accumulator = "";
-  inTitleCapture = false;
-  titleBuffer = "";
-  contentBuffer = "";
-  hasTitle = false;
-  currentCallId = null;
-  toolCallStarted = false;
-  currentTitle = null;
-  onMessage = null;
-  constructor(onMessage) {
-    this.onMessage = onMessage || null;
-    this.reset();
+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;
   }
-  /**
-   * Set the message callback for sending messages directly.
-   */
-  setMessageCallback(callback) {
-    this.onMessage = callback;
+  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";
   }
-  /**
-   * Process a reasoning section break - indicates a new reasoning section is starting.
-   */
-  handleSectionBreak() {
-    this.finishCurrentToolCall("canceled");
-    this.resetState();
-    persistence.logger.debug(`${this.getLogPrefix()} Section break - reset state`);
+  if (status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted") {
+    return "cancelled";
   }
-  /**
-   * Process a reasoning delta/chunk and accumulate content.
-   */
-  processInput(input) {
-    this.accumulator += input;
-    if (!this.inTitleCapture && !this.hasTitle && !this.contentBuffer) {
-      if (this.accumulator.startsWith("**")) {
-        this.inTitleCapture = true;
-        this.titleBuffer = this.accumulator.substring(2);
-        persistence.logger.debug(`${this.getLogPrefix()} Started title capture`);
-      } else if (this.accumulator.length > 0) {
-        this.contentBuffer = this.accumulator;
-      }
-    } else if (this.inTitleCapture) {
-      this.titleBuffer = this.accumulator.substring(2);
-      const titleEndIndex = this.titleBuffer.indexOf("**");
-      if (titleEndIndex !== -1) {
-        const title = this.titleBuffer.substring(0, titleEndIndex);
-        const afterTitle = this.titleBuffer.substring(titleEndIndex + 2);
-        this.hasTitle = true;
-        this.inTitleCapture = false;
-        this.currentTitle = title;
-        this.contentBuffer = afterTitle;
-        this.currentCallId = node_crypto.randomUUID();
-        persistence.logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
-        this.sendToolCallStart(title);
-      }
-    } else if (this.hasTitle) {
-      const titleStartIndex = this.accumulator.indexOf("**");
-      if (titleStartIndex !== -1) {
-        this.contentBuffer = this.accumulator.substring(
-          titleStartIndex + 2 + this.currentTitle.length + 2
-        );
-      }
-    } else {
-      this.contentBuffer = this.accumulator;
-    }
+  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(api.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(api.createEnvelope("agent", {
+      t: "text",
+      text: output,
+      thinking: true
+    }, {
+      ...opts,
+      id: `${item.id}:output`
+    }));
   }
-  /**
-   * Send the tool call start message.
-   */
-  sendToolCallStart(title) {
-    if (!this.currentCallId || this.toolCallStarted) {
-      return;
-    }
-    const toolCall = {
-      type: "tool-call",
-      name: this.getToolName(),
-      callId: this.currentCallId,
-      input: {
-        title
-      },
-      id: node_crypto.randomUUID()
-    };
-    persistence.logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
-    this.onMessage?.(toolCall);
-    this.toolCallStarted = true;
+  if ("status" in item && (item.status === "inProgress" || item.status === "running")) return;
+  envelopes.push(api.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 = [api.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(api.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` }));
   }
-  /**
-   * Complete the reasoning section.
-   * Returns true if reasoning was completed, false if there was nothing to complete.
-   */
-  completeReasoning(fullText) {
-    const text = fullText ?? this.accumulator;
-    if (!text.trim() && !this.toolCallStarted) {
-      persistence.logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
-      return false;
-    }
-    let title;
-    let content = text;
-    if (text.startsWith("**")) {
-      const titleEndIndex = text.indexOf("**", 2);
-      if (titleEndIndex !== -1) {
-        title = text.substring(2, titleEndIndex);
-        content = text.substring(titleEndIndex + 2).trim();
+  return envelopes;
+}
+function mapCodexThreadToSessionEnvelopes(thread) {
+  const envelopes = [];
+  for (const turn of thread.turns ?? []) {
+    const startedAt = turnTimestampMs(turn);
+    const completedAt = completedTimestampMs(turn);
+    envelopes.push(api.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(api.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(api.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(api.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;
+        }
       }
     }
-    persistence.logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
-    if (title && !this.toolCallStarted) {
-      this.currentCallId = this.currentCallId || node_crypto.randomUUID();
-      this.sendToolCallStart(title);
-    }
-    if (this.toolCallStarted && this.currentCallId) {
-      const toolResult = {
-        type: "tool-call-result",
-        callId: this.currentCallId,
-        output: {
-          content,
-          status: "completed"
-        },
-        id: node_crypto.randomUUID()
-      };
-      persistence.logger.debug(`${this.getLogPrefix()} Sending tool call result`);
-      this.onMessage?.(toolResult);
-    } else if (content.trim()) {
-      const reasoningMessage = {
-        type: "reasoning",
-        message: content,
-        id: node_crypto.randomUUID()
-      };
-      persistence.logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
-      this.onMessage?.(reasoningMessage);
-    }
-    this.resetState();
-    return true;
-  }
-  /**
-   * Abort the current reasoning section.
-   */
-  abort() {
-    persistence.logger.debug(`${this.getLogPrefix()} Abort called`);
-    this.finishCurrentToolCall("canceled");
-    this.resetState();
-  }
-  /**
-   * Reset the processor state.
-   */
-  reset() {
-    this.finishCurrentToolCall("canceled");
-    this.resetState();
-  }
-  /**
-   * Finish current tool call if one is in progress.
-   */
-  finishCurrentToolCall(status) {
-    if (this.toolCallStarted && this.currentCallId) {
-      const toolResult = {
-        type: "tool-call-result",
-        callId: this.currentCallId,
-        output: {
-          content: this.contentBuffer || "",
-          status
-        },
-        id: node_crypto.randomUUID()
-      };
-      persistence.logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
-      this.onMessage?.(toolResult);
-    }
-  }
-  /**
-   * Reset internal state.
-   */
-  resetState() {
-    this.accumulator = "";
-    this.inTitleCapture = false;
-    this.titleBuffer = "";
-    this.contentBuffer = "";
-    this.hasTitle = false;
-    this.currentCallId = null;
-    this.toolCallStarted = false;
-    this.currentTitle = null;
+    envelopes.push(api.createEnvelope("agent", { t: "turn-end", status: turnStatus(turn) }, {
+      id: `${turn.id}:end`,
+      turn: turn.id,
+      time: completedAt
+    }));
   }
-  /**
-   * Get the current call ID for tool result matching.
-   */
-  getCurrentCallId() {
-    return this.currentCallId;
+  return envelopes;
+}
+function patchDescription(changes) {
+  if (!changes || typeof changes !== "object") {
+    return "Applying patch";
   }
-  /**
-   * Check if a tool call has been started.
-   */
-  hasStartedToolCall() {
-    return this.toolCallStarted;
+  const fileCount = Object.keys(changes).length;
+  if (fileCount === 1) {
+    return "Applying patch to 1 file";
   }
+  return `Applying patch to ${fileCount} files`;
 }
-
-class ReasoningProcessor extends BaseReasoningProcessor {
-  getToolName() {
-    return "CodexReasoning";
+function pickTurnEndStatus(message, type) {
+  const rawStatus = message.status;
+  if (rawStatus === "completed" || rawStatus === "failed" || rawStatus === "cancelled") {
+    return rawStatus;
   }
-  getLogPrefix() {
-    return "[ReasoningProcessor]";
+  if (rawStatus === "canceled") {
+    return "cancelled";
   }
-  /**
-   * Process a reasoning delta and accumulate content.
-   */
-  processDelta(delta) {
-    this.processInput(delta);
+  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";
   }
-  /**
-   * Complete the reasoning section with final text.
-   */
-  complete(fullText) {
-    this.completeReasoning(fullText);
+  if (message.error !== void 0 && message.error !== null) {
+    return "failed";
   }
+  return "completed";
 }
-
-class DiffProcessor {
-  previousDiff = null;
-  onMessage = null;
-  constructor(onMessage) {
-    this.onMessage = onMessage || null;
+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")
+    };
   }
-  /**
-   * Process a turn_diff message and check if the unified_diff has changed
-   */
-  processDiff(unifiedDiff) {
-    if (this.previousDiff !== unifiedDiff) {
-      persistence.logger.debug("[DiffProcessor] Unified diff changed, sending CodexDiff tool call");
-      const callId = node_crypto.randomUUID();
-      const toolCall = {
-        type: "tool-call",
-        name: "CodexDiff",
-        callId,
-        input: {
-          unified_diff: unifiedDiff
-        },
-        id: node_crypto.randomUUID()
+  if (type === "task_started") {
+    const turnId = cuid2.createId();
+    const turnStart = api.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: []
       };
-      this.onMessage?.(toolCall);
-      const toolResult = {
-        type: "tool-call-result",
-        callId,
-        output: {
-          status: "completed"
-        },
-        id: node_crypto.randomUUID()
+    }
+    const lifecycleOpts = { turn: state.currentTurnId };
+    providerSubagentToSessionSubagent.clear();
+    return {
+      currentTurnId: null,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes: [
+        ...emitSubagentStops(lifecycleOpts, startedSubagents, activeSubagents),
+        api.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: []
       };
-      this.onMessage?.(toolResult);
     }
-    this.previousDiff = unifiedDiff;
-    persistence.logger.debug("[DiffProcessor] Updated stored diff");
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(api.createEnvelope("agent", { t: "text", text: message.message }, opts));
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
   }
-  /**
-   * Reset the processor state (called on task_complete or turn_aborted)
-   */
-  reset() {
-    persistence.logger.debug("[DiffProcessor] Resetting diff state");
-    this.previousDiff = null;
+  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(api.createEnvelope("agent", { t: "text", text, thinking: true }, opts));
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
   }
-  /**
-   * Set the message callback for sending messages directly
-   */
-  setMessageCallback(callback) {
-    this.onMessage = callback;
+  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(
+      api.createEnvelope("agent", {
+        t: "tool-call-start",
+        call,
+        name: "CodexBash",
+        title: commandToTitle(command),
+        description,
+        args
+      }, opts)
+    );
+    return {
+      currentTurnId: state.currentTurnId,
+      startedSubagents,
+      activeSubagents,
+      providerSubagentToSessionSubagent,
+      envelopes
+    };
   }
-  /**
-   * Get the current diff value
-   */
-  getCurrentDiff() {
-    return this.previousDiff;
+  if (type === "exec_command_end") {
+    const call = pickCallId(message);
+    const envelopes = [];
+    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
+    envelopes.push(api.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(
+      api.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(api.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 [api.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 [api.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(api.createEnvelope("agent", {
+        t: "text",
+        text: content,
+        thinking: true
+      }, opts));
+    }
+    envelopes.push(api.createEnvelope("agent", {
+      t: "tool-call-end",
+      call: toolLikeMessage.callId
+    }, opts));
+    return envelopes;
   }
+  return [];
 }
 
-const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
-  const [messages, setMessages] = React.useState([]);
-  const [confirmationMode, setConfirmationMode] = React.useState(false);
-  const [actionInProgress, setActionInProgress] = React.useState(false);
-  const confirmationTimeoutRef = React.useRef(null);
-  const { stdout } = ink.useStdout();
-  const terminalWidth = stdout.columns || 80;
-  const terminalHeight = stdout.rows || 24;
-  React.useEffect(() => {
-    setMessages(messageBuffer.getMessages());
-    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
-      setMessages(newMessages);
-    });
-    return () => {
-      unsubscribe();
-      if (confirmationTimeoutRef.current) {
-        clearTimeout(confirmationTimeoutRef.current);
+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) };
+}
+
+function registerAgentAttachmentDownloads(session) {
+  session.onFileEvent((fileEvent) => {
+    const attachment = fileEvent.content.data.ev;
+    const download = (async () => {
+      try {
+        const data = await session.downloadAndDecryptAttachment(attachment.ref);
+        if (!data) throw new Error("Attachment decryption failed");
+        return { data, mimeType: attachment.mimeType ?? "image/jpeg", name: attachment.name };
+      } catch {
+        session.sendSessionEvent({ type: "message", message: `Could not download attachment: ${attachment.name}. Please attach it again.` });
+        return null;
       }
-    };
-  }, [messageBuffer]);
-  const resetConfirmation = React.useCallback(() => {
-    setConfirmationMode(false);
-    if (confirmationTimeoutRef.current) {
-      clearTimeout(confirmationTimeoutRef.current);
-      confirmationTimeoutRef.current = null;
-    }
-  }, []);
-  const setConfirmationWithTimeout = React.useCallback(() => {
-    setConfirmationMode(true);
-    if (confirmationTimeoutRef.current) {
-      clearTimeout(confirmationTimeoutRef.current);
-    }
-    confirmationTimeoutRef.current = setTimeout(() => {
-      resetConfirmation();
-    }, 15e3);
-  }, [resetConfirmation]);
-  ink.useInput(React.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();
+    })();
+    session.trackAttachmentDownload(download);
+  });
+}
+
+class BasePermissionHandler {
+  pendingRequests = /* @__PURE__ */ new Map();
+  session;
+  isResetting = false;
+  constructor(session) {
+    this.session = session;
+    this.setupRpcHandler();
+  }
+  /**
+   * Update the session reference (used after offline reconnection swaps sessions).
+   * This is critical for avoiding stale session references after onSessionSwap.
+   */
+  updateSession(newSession) {
+    persistence.logger.debug(`${this.getLogPrefix()} Session reference updated`);
+    this.session = newSession;
+    this.setupRpcHandler();
+  }
+  /**
+   * Setup RPC handler for permission responses.
+   */
+  setupRpcHandler() {
+    this.session.rpcHandlerManager.registerHandler(
+      "permission",
+      async (response) => {
+        const pending = this.pendingRequests.get(response.id);
+        if (!pending) {
+          persistence.logger.debug(`${this.getLogPrefix()} Permission request not found or already resolved`);
+          return;
+        }
+        this.pendingRequests.delete(response.id);
+        const result = response.approved ? { decision: response.decision === "approved_for_session" ? "approved_for_session" : "approved" } : { decision: response.decision === "denied" ? "denied" : "abort" };
+        pending.resolve(result);
+        this.session.updateAgentState((currentState) => {
+          const request = currentState.requests?.[response.id];
+          if (!request) return currentState;
+          const { [response.id]: _, ...remainingRequests } = currentState.requests || {};
+          let res = {
+            ...currentState,
+            requests: remainingRequests,
+            completedRequests: {
+              ...currentState.completedRequests,
+              [response.id]: {
+                ...request,
+                completedAt: Date.now(),
+                status: response.approved ? "approved" : "denied",
+                decision: result.decision
+              }
+            }
+          };
+          return res;
+        });
+        persistence.logger.debug(`${this.getLogPrefix()} Permission ${response.approved ? "approved" : "denied"} for ${pending.toolName}`);
       }
-      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));
+    );
+  }
+  /**
+   * Add a pending request to the agent state.
+   */
+  addPendingRequestToState(toolCallId, toolName, input) {
+    this.session.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [toolCallId]: {
+          tool: toolName,
+          arguments: input,
+          createdAt: Date.now()
+        }
       }
-      return chunks.join("\n");
-    }).join("\n");
-  };
-  return /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
-    ink.Box,
-    {
-      flexDirection: "column",
-      width: terminalWidth,
-      height: terminalHeight - 4,
-      borderStyle: "round",
-      borderColor: "gray",
-      paddingX: 1,
-      overflow: "hidden"
-    },
-    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "\u{1F916} Codex Agent Messages"), /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
-    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(ink.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(ink.Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
-    ))
-  ), /* @__PURE__ */ React.createElement(
-    ink.Box,
-    {
-      width: terminalWidth,
-      borderStyle: "round",
-      borderColor: actionInProgress ? "gray" : confirmationMode ? "red" : "green",
-      paddingX: 2,
-      justifyContent: "center",
-      alignItems: "center",
-      flexDirection: "column"
-    },
-    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
-  ));
-};
-
-function createOfflineSessionStub(sessionTag) {
-  return {
-    sessionId: `offline-${sessionTag}`,
-    sendCodexMessage: () => {
-    },
-    sendAgentMessage: () => {
-    },
-    sendAgentUsageSnapshot: () => false,
-    sendClaudeSessionMessage: () => {
-    },
-    keepAlive: () => {
-    },
-    sendSessionEvent: () => {
-    },
-    sendSessionDeath: () => {
-    },
-    updateLifecycleState: () => {
-    },
-    requestControlTransfer: async () => {
-    },
-    flush: async () => {
-    },
-    close: async () => {
-    },
-    updateMetadata: () => {
-    },
-    updateAgentState: () => {
-    },
-    onUserMessage: () => {
-    },
-    onFileEvent: () => {
-    },
-    trackAttachmentDownload: () => {
-    },
-    drainAttachmentsForUserMessage: async () => [],
-    rpcHandlerManager: {
-      registerHandler: () => {
+    }));
+  }
+  /**
+   * Abort all pending permission requests.
+   * Unlike reset(), this resolves (not rejects) pending promises with { decision: 'abort' },
+   * causing the approval response to send 'cancel' to the provider. This is used when the
+   * user presses the abort/stop button — it unblocks any pending tool approval so the provider
+   * can process the turn cancellation.
+   */
+  abortAll() {
+    const pendingSnapshot = Array.from(this.pendingRequests.entries());
+    if (pendingSnapshot.length === 0) return;
+    this.pendingRequests.clear();
+    for (const [id, pending] of pendingSnapshot) {
+      try {
+        pending.resolve({ decision: "abort" });
+      } catch (err) {
+        persistence.logger.debug(`${this.getLogPrefix()} Error resolving aborted request ${id}:`, err);
       }
     }
-  };
-}
-
-function setupOfflineReconnection(opts) {
-  const { api: api$1, sessionTag, metadata, state, response, onSessionSwap } = opts;
-  let session;
-  let reconnectionHandle = null;
-  if (!response) {
-    session = createOfflineSessionStub(sessionTag);
-    reconnectionHandle = api.startOfflineReconnection({
-      serverUrl: persistence.configuration.serverUrl,
-      onReconnected: async () => {
-        const resp = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
-        if (!resp) throw new Error("Server unavailable");
-        const realSession = api$1.sessionSyncClient(resp);
-        onSessionSwap(realSession);
-        return realSession;
-      },
-      onNotify: (msg) => {
-        console.log(msg);
+    this.session.updateAgentState((currentState) => {
+      const pendingRequests = currentState.requests || {};
+      const completedRequests = { ...currentState.completedRequests };
+      for (const [id, request] of Object.entries(pendingRequests)) {
+        completedRequests[id] = {
+          ...request,
+          completedAt: Date.now(),
+          status: "canceled",
+          reason: "Aborted by user"
+        };
       }
+      return {
+        ...currentState,
+        requests: {},
+        completedRequests
+      };
     });
-    return { session, reconnectionHandle, isOffline: true };
-  } else {
-    session = api$1.sessionSyncClient(response, opts.sessionClientOptions);
-    return { session, reconnectionHandle: null, isOffline: false };
-  }
-}
-
-function resolveCodexExecutionPolicy(permissionMode, sandboxManagedByHappy) {
-  if (sandboxManagedByHappy) {
-    return {
-      approvalPolicy: "never",
-      sandbox: "danger-full-access"
-    };
+    persistence.logger.debug(`${this.getLogPrefix()} Aborted ${pendingSnapshot.length} pending permission(s)`);
   }
-  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";
+  /**
+   * Reset state for new sessions.
+   * This method is idempotent - safe to call multiple times.
+   */
+  reset(reason = "Session reset") {
+    if (this.isResetting) {
+      persistence.logger.debug(`${this.getLogPrefix()} Reset already in progress, skipping`);
+      return;
     }
-  })();
-  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";
+    this.isResetting = true;
+    try {
+      const pendingSnapshot = Array.from(this.pendingRequests.entries());
+      this.pendingRequests.clear();
+      for (const [id, pending] of pendingSnapshot) {
+        try {
+          pending.reject(new Error("Session reset"));
+        } catch (err) {
+          persistence.logger.debug(`${this.getLogPrefix()} Error rejecting pending request ${id}:`, err);
+        }
+      }
+      this.session.updateAgentState((currentState) => {
+        const pendingRequests = currentState.requests || {};
+        const completedRequests = { ...currentState.completedRequests };
+        for (const [id, request] of Object.entries(pendingRequests)) {
+          completedRequests[id] = {
+            ...request,
+            completedAt: Date.now(),
+            status: "canceled",
+            reason
+          };
+        }
+        return {
+          ...currentState,
+          requests: {},
+          completedRequests
+        };
+      });
+      persistence.logger.debug(`${this.getLogPrefix()} Permission handler reset`);
+    } finally {
+      this.isResetting = false;
     }
-  })();
-  return { approvalPolicy, sandbox };
+  }
 }
 
-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;
+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);
   }
-  envelopes.push(api.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(api.createEnvelope("agent", { t: "stop" }, { ...opts, subagent }));
+  getLogPrefix() {
+    return "[Codex]";
   }
-  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;
+  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;
   }
-  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;
+  /**
+   * 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)) {
+      persistence.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);
+      persistence.logger.debug(`${this.getLogPrefix()} Permission request sent for tool: ${toolName} (${toolCallId})`);
+    });
   }
-  const created = cuid2.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;
+
+class BaseReasoningProcessor {
+  accumulator = "";
+  inTitleCapture = false;
+  titleBuffer = "";
+  contentBuffer = "";
+  hasTitle = false;
+  currentCallId = null;
+  toolCallStarted = false;
+  currentTitle = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
+    this.reset();
   }
-  return node_crypto.randomUUID();
-}
-function summarizeCommand(command) {
-  if (typeof command === "string" && command.trim().length > 0) {
-    return command;
+  /**
+   * Set the message callback for sending messages directly.
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
   }
-  if (Array.isArray(command)) {
-    const cmd = command.map((v) => String(v)).join(" ").trim();
-    return cmd.length > 0 ? cmd : null;
+  /**
+   * Process a reasoning section break - indicates a new reasoning section is starting.
+   */
+  handleSectionBreak() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
+    persistence.logger.debug(`${this.getLogPrefix()} Section break - reset state`);
   }
-  return null;
-}
-function commandToTitle(command) {
-  if (!command) {
-    return "Run command";
+  /**
+   * Process a reasoning delta/chunk and accumulate content.
+   */
+  processInput(input) {
+    this.accumulator += input;
+    if (!this.inTitleCapture && !this.hasTitle && !this.contentBuffer) {
+      if (this.accumulator.startsWith("**")) {
+        this.inTitleCapture = true;
+        this.titleBuffer = this.accumulator.substring(2);
+        persistence.logger.debug(`${this.getLogPrefix()} Started title capture`);
+      } else if (this.accumulator.length > 0) {
+        this.contentBuffer = this.accumulator;
+      }
+    } else if (this.inTitleCapture) {
+      this.titleBuffer = this.accumulator.substring(2);
+      const titleEndIndex = this.titleBuffer.indexOf("**");
+      if (titleEndIndex !== -1) {
+        const title = this.titleBuffer.substring(0, titleEndIndex);
+        const afterTitle = this.titleBuffer.substring(titleEndIndex + 2);
+        this.hasTitle = true;
+        this.inTitleCapture = false;
+        this.currentTitle = title;
+        this.contentBuffer = afterTitle;
+        this.currentCallId = node_crypto.randomUUID();
+        persistence.logger.debug(`${this.getLogPrefix()} Title captured: "${title}"`);
+        this.sendToolCallStart(title);
+      }
+    } else if (this.hasTitle) {
+      const titleStartIndex = this.accumulator.indexOf("**");
+      if (titleStartIndex !== -1) {
+        this.contentBuffer = this.accumulator.substring(
+          titleStartIndex + 2 + this.currentTitle.length + 2
+        );
+      }
+    } else {
+      this.contentBuffer = this.accumulator;
+    }
   }
-  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;
+  /**
+   * Send the tool call start message.
+   */
+  sendToolCallStart(title) {
+    if (!this.currentCallId || this.toolCallStarted) {
+      return;
+    }
+    const toolCall = {
+      type: "tool-call",
+      name: this.getToolName(),
+      callId: this.currentCallId,
+      input: {
+        title
+      },
+      id: node_crypto.randomUUID()
+    };
+    persistence.logger.debug(`${this.getLogPrefix()} Sending tool call start for: "${title}"`);
+    this.onMessage?.(toolCall);
+    this.toolCallStarted = true;
   }
-  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";
+  /**
+   * Complete the reasoning section.
+   * Returns true if reasoning was completed, false if there was nothing to complete.
+   */
+  completeReasoning(fullText) {
+    const text = fullText ?? this.accumulator;
+    if (!text.trim() && !this.toolCallStarted) {
+      persistence.logger.debug(`${this.getLogPrefix()} Complete called but no content accumulated, skipping`);
+      return false;
+    }
+    let title;
+    let content = text;
+    if (text.startsWith("**")) {
+      const titleEndIndex = text.indexOf("**", 2);
+      if (titleEndIndex !== -1) {
+        title = text.substring(2, titleEndIndex);
+        content = text.substring(titleEndIndex + 2).trim();
+      }
+    }
+    persistence.logger.debug(`${this.getLogPrefix()} Complete reasoning - Title: "${title}", Has content: ${content.length > 0}`);
+    if (title && !this.toolCallStarted) {
+      this.currentCallId = this.currentCallId || node_crypto.randomUUID();
+      this.sendToolCallStart(title);
+    }
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content,
+          status: "completed"
+        },
+        id: node_crypto.randomUUID()
+      };
+      persistence.logger.debug(`${this.getLogPrefix()} Sending tool call result`);
+      this.onMessage?.(toolResult);
+    } else if (content.trim()) {
+      const reasoningMessage = {
+        type: "reasoning",
+        message: content,
+        id: node_crypto.randomUUID()
+      };
+      persistence.logger.debug(`${this.getLogPrefix()} Sending reasoning message`);
+      this.onMessage?.(reasoningMessage);
+    }
+    this.resetState();
+    return true;
   }
-  if (status === "cancelled" || status === "canceled" || status === "aborted" || status === "interrupted") {
-    return "cancelled";
+  /**
+   * Abort the current reasoning section.
+   */
+  abort() {
+    persistence.logger.debug(`${this.getLogPrefix()} Abort called`);
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
   }
-  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(api.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(api.createEnvelope("agent", {
-      t: "text",
-      text: output,
-      thinking: true
-    }, {
-      ...opts,
-      id: `${item.id}:output`
-    }));
+  /**
+   * Reset the processor state.
+   */
+  reset() {
+    this.finishCurrentToolCall("canceled");
+    this.resetState();
   }
-  envelopes.push(api.createEnvelope("agent", {
-    t: "tool-call-end",
-    call: item.id
-  }, {
-    ...opts,
-    id: `${item.id}:end`,
-    time: completedTimestampMs(turn)
-  }));
-}
-function mapCodexThreadToSessionEnvelopes(thread) {
-  const envelopes = [];
-  for (const turn of thread.turns ?? []) {
-    const startedAt = turnTimestampMs(turn);
-    const completedAt = completedTimestampMs(turn);
-    envelopes.push(api.createEnvelope("agent", { t: "turn-start" }, {
-      id: `${turn.id}:start`,
-      turn: turn.id,
-      time: startedAt
-    }));
-    for (const item of turn.items ?? []) {
-      switch (item.type) {
-        case "userMessage": {
-          const text = textFromInputItems(item.content);
-          if (text) {
-            envelopes.push(api.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(api.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(api.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;
-        }
-      }
+  /**
+   * Finish current tool call if one is in progress.
+   */
+  finishCurrentToolCall(status) {
+    if (this.toolCallStarted && this.currentCallId) {
+      const toolResult = {
+        type: "tool-call-result",
+        callId: this.currentCallId,
+        output: {
+          content: this.contentBuffer || "",
+          status
+        },
+        id: node_crypto.randomUUID()
+      };
+      persistence.logger.debug(`${this.getLogPrefix()} Sending tool call result with status: ${status}`);
+      this.onMessage?.(toolResult);
     }
-    envelopes.push(api.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";
+  /**
+   * Reset internal state.
+   */
+  resetState() {
+    this.accumulator = "";
+    this.inTitleCapture = false;
+    this.titleBuffer = "";
+    this.contentBuffer = "";
+    this.hasTitle = false;
+    this.currentCallId = null;
+    this.toolCallStarted = false;
+    this.currentTitle = null;
   }
-  const fileCount = Object.keys(changes).length;
-  if (fileCount === 1) {
-    return "Applying patch to 1 file";
+  /**
+   * Get the current call ID for tool result matching.
+   */
+  getCurrentCallId() {
+    return this.currentCallId;
+  }
+  /**
+   * Check if a tool call has been started.
+   */
+  hasStartedToolCall() {
+    return this.toolCallStarted;
   }
-  return `Applying patch to ${fileCount} files`;
 }
-function pickTurnEndStatus(message, type) {
-  const rawStatus = message.status;
-  if (rawStatus === "completed" || rawStatus === "failed" || rawStatus === "cancelled") {
-    return rawStatus;
+
+class ReasoningProcessor extends BaseReasoningProcessor {
+  getToolName() {
+    return "CodexReasoning";
   }
-  if (rawStatus === "canceled") {
-    return "cancelled";
+  getLogPrefix() {
+    return "[ReasoningProcessor]";
   }
-  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";
+  /**
+   * Process a reasoning delta and accumulate content.
+   */
+  processDelta(delta) {
+    this.processInput(delta);
   }
-  if (message.error !== void 0 && message.error !== null) {
-    return "failed";
+  /**
+   * Complete the reasoning section with final text.
+   */
+  complete(fullText) {
+    this.completeReasoning(fullText);
   }
-  return "completed";
 }
-function mapCodexMcpMessageToSessionEnvelopes(message, state) {
-  const type = message.type;
-  const startedSubagents = getStartedSubagents(state);
-  const activeSubagents = getActiveSubagents(state);
-  const providerSubagentToSessionSubagent = getProviderSubagentToSessionSubagent(state);
-  if (type === "task_started") {
-    const turnId = cuid2.createId();
-    const turnStart = api.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),
-        api.createEnvelope("agent", {
-          t: "turn-end",
-          status: pickTurnEndStatus(message, type)
-        }, lifecycleOpts)
-      ]
-    };
-  }
-  if (type === "token_count") {
-    return {
-      currentTurnId: state.currentTurnId,
-      startedSubagents,
-      activeSubagents,
-      providerSubagentToSessionSubagent,
-      envelopes: []
-    };
+
+class DiffProcessor {
+  previousDiff = null;
+  onMessage = null;
+  constructor(onMessage) {
+    this.onMessage = onMessage || null;
   }
-  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: []
+  /**
+   * Process a turn_diff message and check if the unified_diff has changed
+   */
+  processDiff(unifiedDiff) {
+    if (this.previousDiff !== unifiedDiff) {
+      persistence.logger.debug("[DiffProcessor] Unified diff changed, sending CodexDiff tool call");
+      const callId = node_crypto.randomUUID();
+      const toolCall = {
+        type: "tool-call",
+        name: "CodexDiff",
+        callId,
+        input: {
+          unified_diff: unifiedDiff
+        },
+        id: node_crypto.randomUUID()
       };
-    }
-    const envelopes = [];
-    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(api.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: []
+      this.onMessage?.(toolCall);
+      const toolResult = {
+        type: "tool-call-result",
+        callId,
+        output: {
+          status: "completed"
+        },
+        id: node_crypto.randomUUID()
       };
+      this.onMessage?.(toolResult);
     }
-    const envelopes = [];
-    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(api.createEnvelope("agent", { t: "text", text, thinking: true }, opts));
-    return {
-      currentTurnId: state.currentTurnId,
-      startedSubagents,
-      activeSubagents,
-      providerSubagentToSessionSubagent,
-      envelopes
-    };
+    this.previousDiff = unifiedDiff;
+    persistence.logger.debug("[DiffProcessor] Updated stored diff");
   }
-  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(
-      api.createEnvelope("agent", {
-        t: "tool-call-start",
-        call,
-        name: "CodexBash",
-        title: commandToTitle(command),
-        description,
-        args
-      }, opts)
-    );
-    return {
-      currentTurnId: state.currentTurnId,
-      startedSubagents,
-      activeSubagents,
-      providerSubagentToSessionSubagent,
-      envelopes
-    };
+  /**
+   * Reset the processor state (called on task_complete or turn_aborted)
+   */
+  reset() {
+    persistence.logger.debug("[DiffProcessor] Resetting diff state");
+    this.previousDiff = null;
   }
-  if (type === "exec_command_end") {
-    const call = pickCallId(message);
-    const envelopes = [];
-    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(api.createEnvelope("agent", { t: "tool-call-end", call }, opts));
-    return {
-      currentTurnId: state.currentTurnId,
-      startedSubagents,
-      activeSubagents,
-      providerSubagentToSessionSubagent,
-      envelopes
-    };
+  /**
+   * Set the message callback for sending messages directly
+   */
+  setMessageCallback(callback) {
+    this.onMessage = callback;
   }
-  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(
-      api.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
-    };
+  /**
+   * Get the current diff value
+   */
+  getCurrentDiff() {
+    return this.previousDiff;
   }
-  if (type === "patch_apply_end") {
-    const call = pickCallId(message);
-    const envelopes = [];
-    maybeEmitSubagentStart(subagent, opts, startedSubagents, activeSubagents, envelopes);
-    envelopes.push(api.createEnvelope("agent", { t: "tool-call-end", call }, opts));
-    return {
-      currentTurnId: state.currentTurnId,
-      startedSubagents,
-      activeSubagents,
-      providerSubagentToSessionSubagent,
-      envelopes
+}
+
+const CodexDisplay = ({ messageBuffer, logPath, onExit }) => {
+  const [messages, setMessages] = React.useState([]);
+  const [confirmationMode, setConfirmationMode] = React.useState(false);
+  const [actionInProgress, setActionInProgress] = React.useState(false);
+  const confirmationTimeoutRef = React.useRef(null);
+  const { stdout } = ink.useStdout();
+  const terminalWidth = stdout.columns || 80;
+  const terminalHeight = stdout.rows || 24;
+  React.useEffect(() => {
+    setMessages(messageBuffer.getMessages());
+    const unsubscribe = messageBuffer.onUpdate((newMessages) => {
+      setMessages(newMessages);
+    });
+    return () => {
+      unsubscribe();
+      if (confirmationTimeoutRef.current) {
+        clearTimeout(confirmationTimeoutRef.current);
+      }
     };
-  }
+  }, [messageBuffer]);
+  const resetConfirmation = React.useCallback(() => {
+    setConfirmationMode(false);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+      confirmationTimeoutRef.current = null;
+    }
+  }, []);
+  const setConfirmationWithTimeout = React.useCallback(() => {
+    setConfirmationMode(true);
+    if (confirmationTimeoutRef.current) {
+      clearTimeout(confirmationTimeoutRef.current);
+    }
+    confirmationTimeoutRef.current = setTimeout(() => {
+      resetConfirmation();
+    }, 15e3);
+  }, [resetConfirmation]);
+  ink.useInput(React.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(ink.Box, { flexDirection: "column", width: terminalWidth, height: terminalHeight }, /* @__PURE__ */ React.createElement(
+    ink.Box,
+    {
+      flexDirection: "column",
+      width: terminalWidth,
+      height: terminalHeight - 4,
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      overflow: "hidden"
+    },
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "\u{1F916} Codex Agent Messages"), /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "\u2500".repeat(Math.min(terminalWidth - 4, 60)))),
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", height: terminalHeight - 10, overflow: "hidden" }, messages.length === 0 ? /* @__PURE__ */ React.createElement(ink.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(ink.Box, { key: msg.id, flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(ink.Text, { color: getMessageColor(msg.type), dimColor: true }, formatMessage(msg))))
+    ))
+  ), /* @__PURE__ */ React.createElement(
+    ink.Box,
+    {
+      width: terminalWidth,
+      borderStyle: "round",
+      borderColor: actionInProgress ? "gray" : confirmationMode ? "red" : "green",
+      paddingX: 2,
+      justifyContent: "center",
+      alignItems: "center",
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(ink.Box, { flexDirection: "column", alignItems: "center" }, actionInProgress ? /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", bold: true }, "Exiting agent...") : confirmationMode ? /* @__PURE__ */ React.createElement(ink.Text, { color: "red", bold: true }, "\u26A0\uFE0F  Press Ctrl-C again to exit the agent") : /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ink.Text, { color: "green", bold: true }, "\u{1F916} Codex Agent Running \u2022 Ctrl-C to exit")), process.env.DEBUG && logPath && /* @__PURE__ */ React.createElement(ink.Text, { color: "gray", dimColor: true }, "Debug logs: ", logPath))
+  ));
+};
+
+function createOfflineSessionStub(sessionTag) {
   return {
-    currentTurnId: state.currentTurnId,
-    startedSubagents,
-    activeSubagents,
-    providerSubagentToSessionSubagent,
-    envelopes: []
+    sessionId: `offline-${sessionTag}`,
+    sendCodexMessage: () => {
+    },
+    sendAgentMessage: () => {
+    },
+    sendAgentUsageSnapshot: () => false,
+    sendClaudeSessionMessage: () => {
+    },
+    keepAlive: () => {
+    },
+    sendSessionEvent: () => {
+    },
+    sendSessionDeath: () => {
+    },
+    updateLifecycleState: () => {
+    },
+    requestControlTransfer: async () => {
+    },
+    flush: async () => {
+    },
+    close: async () => {
+    },
+    updateMetadata: () => {
+    },
+    updateAgentState: () => {
+    },
+    onUserMessage: () => {
+    },
+    onFileEvent: () => {
+    },
+    trackAttachmentDownload: () => {
+    },
+    drainAttachmentsForUserMessage: async () => [],
+    rpcHandlerManager: {
+      registerHandler: () => {
+      }
+    }
   };
 }
-function mapCodexProcessorMessageToSessionEnvelopes(message, state) {
-  const toolLikeMessage = message;
-  const opts = buildEnvelopeOptions(state.currentTurnId);
-  if (message.type === "reasoning") {
-    return [api.createEnvelope("agent", {
-      t: "text",
-      text: message.message,
-      thinking: true
-    }, opts)];
+
+function setupOfflineReconnection(opts) {
+  const { api: api$1, sessionTag, metadata, state, response, onSessionSwap } = opts;
+  let session;
+  let reconnectionHandle = null;
+  if (!response) {
+    session = createOfflineSessionStub(sessionTag);
+    reconnectionHandle = api.startOfflineReconnection({
+      serverUrl: persistence.configuration.serverUrl,
+      onReconnected: async () => {
+        const resp = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
+        if (!resp) throw new Error("Server unavailable");
+        const realSession = api$1.sessionSyncClient(resp);
+        onSessionSwap(realSession);
+        return realSession;
+      },
+      onNotify: (msg) => {
+        console.log(msg);
+      }
+    });
+    return { session, reconnectionHandle, isOffline: true };
+  } else {
+    session = api$1.sessionSyncClient(response, opts.sessionClientOptions);
+    return { session, reconnectionHandle: null, isOffline: false };
   }
-  if (message.type === "tool-call") {
-    const title = typeof toolLikeMessage.input?.title === "string" ? toolLikeMessage.input.title : `${toolLikeMessage.name || "Tool"} call`;
-    return [api.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)];
+}
+
+function resolveCodexExecutionPolicy(permissionMode, sandboxManagedByHappy) {
+  if (sandboxManagedByHappy) {
+    return {
+      approvalPolicy: "never",
+      sandbox: "danger-full-access"
+    };
   }
-  if (message.type === "tool-call-result") {
-    const envelopes = [];
-    const content = toolLikeMessage.output?.content;
-    if (typeof content === "string" && content.trim().length > 0) {
-      envelopes.push(api.createEnvelope("agent", {
-        t: "text",
-        text: content,
-        thinking: true
-      }, opts));
+  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";
     }
-    envelopes.push(api.createEnvelope("agent", {
-      t: "tool-call-end",
-      call: toolLikeMessage.callId
-    }, opts));
-    return envelopes;
-  }
-  return [];
+  })();
+  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 };
 }
 
 async function resumeExistingThread(opts) {
@@ -16648,8 +16974,15 @@ async function runCodex(opts) {
       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);
-  registerKillSessionHandler(session.rpcHandlerManager, handleKillSession, session);
+  const disposeTermination = registerKillSessionHandler(session.rpcHandlerManager, handleKillSession, session, { processSignals: true });
   const messageBuffer = new MessageBuffer();
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
   let inkInstance = null;
@@ -16985,6 +17318,7 @@ async function runCodex(opts) {
       }
     }
   } finally {
+    disposeTermination?.();
     persistence.logger.debug("[codex]: Final cleanup start");
     logActiveHandles("cleanup-start");
     if (reconnectionHandle) {
@@ -17187,7 +17521,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 Promise.resolve().then(function () { return require('./installTerminalHooks-CKG0MYVK.cjs'); });
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await Promise.resolve().then(function () { return require('./installTerminalHooks-gmWKACNb.cjs'); });
       const command = parseTerminalHooksArgs(args.slice(1));
       if (command.action === "help") {
         console.log(TERMINAL_HOOKS_HELP);
@@ -17204,7 +17538,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     }
   } else if (subcommand === "spawn") {
     try {
-      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-C-XpSPLX.cjs'); });
+      const { handleSpawnCommand } = await Promise.resolve().then(function () { return require('./spawn-DVJtNwWN.cjs'); });
       await handleSpawnCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17216,7 +17550,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "sessions") {
     try {
-      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-SIFOOlGp.cjs'); });
+      const { handleSessionsCommand } = await Promise.resolve().then(function () { return require('./sessions-Cx_3cvN6.cjs'); });
       await handleSessionsCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17228,7 +17562,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "send") {
     try {
-      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-DKbumEcg.cjs'); });
+      const { handleSendCommand } = await Promise.resolve().then(function () { return require('./send-WlJ4r3U2.cjs'); });
       await handleSendCommand(args.slice(1));
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
@@ -17334,9 +17668,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 Promise.resolve().then(function () { return require('./config-uLywzv5t.cjs'); });
-        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-XRNzIlVm.cjs'); }).then(function (n) { return n.persistence; });
-        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-CcjVmS2i.cjs'); }).then(function (n) { return n.api; });
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-BO0ZHyoB.cjs'); });
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await Promise.resolve().then(function () { return require('./limits-K17AgMHD.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient: ApiClient2 } = await Promise.resolve().then(function () { return require('./types-DjAHWb4J.cjs'); }).then(function (n) { return n.api; });
         let userEmail = void 0;
         try {
           const credentials = await readCredentialsForConfiguredRelay2();
@@ -17367,7 +17701,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 Promise.resolve().then(function () { return require('./config-uLywzv5t.cjs'); });
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-BO0ZHyoB.cjs'); });
         const config = readGeminiLocalConfig();
         if (config.googleCloudProject) {
           console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
@@ -17407,7 +17741,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       process.exit(0);
     }
     try {
-      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-BIVHp0ST.cjs'); });
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-n0wD2Z9R.cjs'); });
       let startedBy = void 0;
       for (let i = 1; i < args.length; i++) {
         if (args[i] === "--started-by") {
@@ -17437,7 +17771,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
       }
     };
     try {
-      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-Daga0ztv.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-BEpZjXs4.cjs'); });
       const parsed = parsePiRunnerArgs(args.slice(1));
       const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
       const { credentials } = await authAndSetupMachineIfNeeded();
@@ -17465,7 +17799,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 Promise.resolve().then(function () { return require('./index-Daga0ztv.cjs'); });
+      const { runAcp, resolveAcpAgentConfig } = await Promise.resolve().then(function () { return require('./index-BEpZjXs4.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       const acpArgs = [];
@@ -17505,7 +17839,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "openclaw") {
     try {
-      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-a0f2pZZp.cjs'); });
+      const { runOpenClaw } = await Promise.resolve().then(function () { return require('./runOpenClaw-fYx1XweW.cjs'); });
       let startedBy = void 0;
       let verbose = false;
       let gatewayUrl;
@@ -17556,7 +17890,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "todo") {
     try {
-      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-o0clp-_I.cjs'); });
+      const { handleTodoCommand } = await Promise.resolve().then(function () { return require('./todo-DHY20tpD.cjs'); });
       await handleTodoCommand(args.slice(1));
     } catch (error) {
       console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
@@ -17565,7 +17899,7 @@ Conversation history is preserved on the server, but in-flight tool calls are in
     return;
   } else if (subcommand === "teams") {
     try {
-      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-ChFzXAqr.cjs'); });
+      const { handleTeamsCommand } = await Promise.resolve().then(function () { return require('./teams-BbYi0fWG.cjs'); });
       await handleTeamsCommand(args.slice(1));
     } catch (error) {
       console.error(error instanceof Error ? error.message : "Teams command failed");
@@ -17574,7 +17908,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 Promise.resolve().then(function () { return require('./mcp-CAMCuudA.cjs'); });
+      const { handleMcpCommand } = await Promise.resolve().then(function () { return require('./mcp-CK1NCZm0.cjs'); });
       await handleMcpCommand();
     } catch (error) {
       process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(error)}