ticlawk 0.1.12-dev.0

package/src/runtimes/codex/session.mjs

@@ -0,0 +1,750 @@
+/**
+ * Codex local session helpers.
+ *
+ * Codex sessions are jsonl files in `~/.codex/sessions/**`. The first line
+ * of each file is a `session_meta` record with the canonical sessionId and
+ * working directory. Spawning `codex exec` (with or without `resume`)
+ * creates or continues a session; the new session id appears as a
+ * `thread.started` event on stdout.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { debugLog, debugError } from '../../core/logger.mjs';
+import { buildRuntimeEnv } from '../../core/runtime-env.mjs';
+import { getRuntimeExecutableConfig } from '../../core/config.mjs';
+import { getExecutableVersion, isExecutablePath, resolveExecutable } from '../../core/executables.mjs';
+
+export const CODEX_SESSIONS_DIR = process.env.CODEX_SESSIONS_DIR || `${homedir()}/.codex/sessions`;
+export const CODEX_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_CODEX_EXEC_TIMEOUT_MS = 7200 * 1000;
+export const DEFAULT_CODEX_COMMAND = 'codex';
+
+export function resolveCodexPath(preferredPath = null) {
+  return resolveExecutable({
+    command: DEFAULT_CODEX_COMMAND,
+    preferredPath,
+    configuredPath: getRuntimeExecutableConfig('codex'),
+    envKey: 'CODEX_BIN',
+  });
+}
+
+export function requireCodexPath(preferredPath = null) {
+  const requested = String(preferredPath || '').trim();
+  if (requested && requested.includes('/') && !isExecutablePath(requested)) {
+    throw new Error(`Codex CLI is no longer available at: ${requested}. Reconnect this Codex agent or set CODEX_BIN / \`ticlawk config set runtimes.codex.path <path>\`.`);
+  }
+  const codexPath = resolveCodexPath(preferredPath);
+  if (codexPath) return codexPath;
+  throw new Error('Codex CLI not found. Install Codex, ensure it is on PATH, or set CODEX_BIN / `ticlawk config set runtimes.codex.path <path>`.');
+}
+
+export function getCodexRuntimeHealth(preferredPath = null) {
+  const codexPath = resolveCodexPath(preferredPath);
+  return {
+    available: Boolean(codexPath),
+    path: codexPath,
+    version: getExecutableVersion(codexPath),
+  };
+}
+
+function walkJsonlFiles(rootDir) {
+  if (!existsSync(rootDir)) return [];
+
+  const files = [];
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries = [];
+    try {
+      entries = readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+
+function readFirstJsonLine(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const firstLine = content.split('\n').find(line => line.trim());
+    return firstLine ? JSON.parse(firstLine) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function discoverCodexSessions(rootDir = CODEX_SESSIONS_DIR) {
+  return walkJsonlFiles(rootDir)
+    .map((filePath) => {
+      const first = readFirstJsonLine(filePath);
+      if (!first || first.type !== 'session_meta') return null;
+      const sessionId = first.payload?.id;
+      const cwd = first.payload?.cwd;
+      if (!sessionId || !cwd) return null;
+      return {
+        sessionId,
+        cwd,
+        path: filePath,
+      };
+    })
+    .filter(Boolean);
+}
+
+export async function waitForCodexSessionById(sessionId, timeoutMs = 10000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const sessions = discoverCodexSessions(CODEX_SESSIONS_DIR);
+    const found = sessions.find(session => session.sessionId === sessionId);
+    if (found) return found;
+    await new Promise(resolve => setTimeout(resolve, 250));
+  }
+  return null;
+}
+
+// Try to recover a human-readable error string from `codex exec resume
+// --json` stdout. Codex prints a stream of jsonl events; on failure
+// the most useful one is `{type:"error", message}` or
+// `{type:"turn.failed", error:{message}}`.
+function extractCodexError(stdout) {
+  if (!stdout) return null;
+  const lines = stdout.split('\n').map(l => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let parsed;
+    try { parsed = JSON.parse(lines[i]); } catch { continue; }
+    if (parsed?.type === 'turn.failed' && typeof parsed.error?.message === 'string') {
+      return parsed.error.message;
+    }
+    if (parsed?.type === 'error' && typeof parsed.message === 'string') {
+      return parsed.message;
+    }
+    if (parsed?.type === 'item.completed' && parsed.item?.type === 'error' && typeof parsed.item.message === 'string') {
+      return parsed.item.message;
+    }
+  }
+  return null;
+}
+
+function buildCodexExecArgs({ sessionId, message }) {
+  return sessionId
+    ? [
+        'exec',
+        'resume',
+        sessionId,
+        '--json',
+        '--skip-git-repo-check',
+        '--dangerously-bypass-approvals-and-sandbox',
+        message,
+      ]
+    : [
+        'exec',
+        '--json',
+        '--skip-git-repo-check',
+        '--dangerously-bypass-approvals-and-sandbox',
+        message,
+      ];
+}
+
+function parseCodexExecStream({ stdout, onLine }) {
+  return (bufferState, chunk) => {
+    bufferState.raw += chunk.toString('utf8');
+    bufferState.buffer += chunk.toString('utf8');
+    const lines = bufferState.buffer.split('\n');
+    bufferState.buffer = lines.pop() || '';
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let parsed;
+      try { parsed = JSON.parse(trimmed); } catch { continue; }
+      onLine(parsed);
+    }
+  };
+}
+
+function buildCodexTurnError(message, info) {
+  const wrapped = new Error(message);
+  wrapped.info = info;
+  return wrapped;
+}
+
+function buildJsonRpcResponseError(error, method) {
+  const message = error?.message || `codex app-server ${method || 'request'} failed`;
+  const wrapped = new Error(message);
+  wrapped.rpcError = error || null;
+  wrapped.rpcMethod = method || null;
+  return wrapped;
+}
+
+function extractCodexErrorInfo(error) {
+  return error?.codexErrorInfo
+    || error?.data?.codexErrorInfo
+    || error?.rpcError?.data?.codexErrorInfo
+    || null;
+}
+
+function buildGatewayErrorInfo({ startedAt, messageText, source, method, params, err, activeThreadId, activeTurnId }) {
+  const rawError = params?.error || params?.data || err?.rpcError || null;
+  return {
+    ok: false,
+    code: null,
+    signal: null,
+    durationMs: Date.now() - startedAt,
+    kind: 'gateway-error',
+    errorMessage: messageText,
+    gatewaySource: source,
+    gatewayMethod: method || null,
+    rpcCode: err?.rpcError?.code ?? null,
+    rpcMethod: err?.rpcMethod || null,
+    willRetry: typeof params?.willRetry === 'boolean' ? params.willRetry : null,
+    threadId: params?.threadId || activeThreadId || null,
+    turnId: params?.turnId || activeTurnId || null,
+    codexErrorInfo: extractCodexErrorInfo(rawError || err) || null,
+    additionalDetails: params?.additionalDetails || rawError?.additionalDetails || null,
+    rawError,
+  };
+}
+
+function isSubAgentThread(thread) {
+  const source = thread?.source;
+  if (!source || typeof source !== 'object') return false;
+  return Boolean(source.subAgent || source.sub_agent);
+}
+
+export function runCodexPrompt({ sessionId, cwd, message, codexPath = null, timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS) }) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const codexCommand = requireCodexPath(codexPath);
+    const child = spawn(codexCommand, buildCodexExecArgs({ sessionId, message }), {
+      cwd,
+      env: buildRuntimeEnv(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+
+    let stdout = '';
+    let buffer = '';
+    let activeSessionId = sessionId || null;
+    let finalText = '';
+    let settled = false;
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      fn(value);
+    };
+
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString('utf8');
+      buffer += chunk.toString('utf8');
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let event;
+        try { event = JSON.parse(trimmed); } catch { continue; }
+        if (event?.type === 'thread.started' && typeof event.thread_id === 'string') {
+          activeSessionId = event.thread_id;
+        }
+        if (event?.type === 'item.completed' && event.item?.type === 'agent_message' && typeof event.item?.text === 'string') {
+          finalText = event.item.text;
+        }
+      }
+    });
+
+    let timeout = null;
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => { child.kill('SIGTERM'); }, timeoutMs);
+      timeout.unref();
+    }
+
+    child.on('error', (err) => {
+      settle(reject, buildCodexTurnError(err.message || 'codex spawn failed', {
+        ok: false,
+        code: null,
+        signal: null,
+        durationMs: Date.now() - startedAt,
+        kind: 'spawn-failed',
+        error: err.message,
+        codexCommand,
+      }));
+    });
+
+    child.on('exit', async (code, signal) => {
+      const durationMs = Date.now() - startedAt;
+      if (signal) {
+        settle(reject, buildCodexTurnError(extractCodexError(stdout) || `codex killed by ${signal}`, {
+          ok: false,
+          code: null,
+          signal,
+          durationMs,
+          kind: 'killed',
+          errorMessage: extractCodexError(stdout),
+        }));
+        return;
+      }
+      if (code !== 0) {
+        settle(reject, buildCodexTurnError(extractCodexError(stdout) || `codex exited with code ${code}`, {
+          ok: false,
+          code,
+          signal: null,
+          durationMs,
+          kind: 'exit-error',
+          errorMessage: extractCodexError(stdout),
+        }));
+        return;
+      }
+      if (!activeSessionId) {
+        settle(reject, buildCodexTurnError('codex session_id missing from output', {
+          ok: false,
+          code: 0,
+          signal: null,
+          durationMs,
+          kind: 'invalid-output',
+          errorMessage: 'codex session_id missing from output',
+        }));
+        return;
+      }
+      const session = await waitForCodexSessionById(activeSessionId, 10000);
+      if (!finalText) {
+        settle(reject, buildCodexTurnError('codex final agent message missing from output', {
+          ok: false,
+          code: 0,
+          signal: null,
+          durationMs,
+          kind: 'invalid-output',
+          errorMessage: 'codex final agent message missing from output',
+        }));
+        return;
+      }
+      settle(resolve, {
+        sessionId: activeSessionId,
+        cwd: session?.cwd || cwd,
+        path: session?.path || null,
+        text: finalText,
+        durationMs,
+      });
+    });
+  });
+}
+
+export function streamCodexPrompt({
+  sessionId,
+  cwd,
+  message,
+  codexPath = null,
+  input = null,
+  timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS),
+  onEvent,
+}) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const codexCommand = requireCodexPath(codexPath);
+    const child = spawn(codexCommand, ['app-server'], {
+      cwd,
+      env: buildRuntimeEnv(),
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+
+    let settled = false;
+    let lineBuffer = '';
+    let nextId = 1;
+    const pending = new Map();
+    let rootThreadId = sessionId || null;
+    let rootTurnId = null;
+    let finalText = '';
+    let threadPath = null;
+    const ignoredChildEventsLogged = new Set();
+    let eventChain = Promise.resolve();
+
+    const emit = (event) => {
+      if (typeof onEvent !== 'function') return;
+      eventChain = eventChain
+        .then(() => onEvent(event))
+        .catch(() => {});
+      return eventChain;
+    };
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      for (const { reject: rejectPending } of pending.values()) {
+        try { rejectPending(new Error('codex app-server closed')); } catch {}
+      }
+      pending.clear();
+      try { child.kill('SIGTERM'); } catch {}
+      eventChain
+        .catch(() => {})
+        .finally(() => fn(value));
+    };
+
+    const send = (method, params = {}) => {
+      const id = nextId++;
+      child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+      return new Promise((resolvePending, rejectPending) => {
+        pending.set(id, { resolve: resolvePending, reject: rejectPending, method });
+      });
+    };
+
+    const isRootContext = (params) => {
+      if (!rootThreadId || !rootTurnId) return false;
+      return params?.threadId === rootThreadId && params?.turnId === rootTurnId;
+    };
+
+    const logIgnoredChildEvent = (event, params = {}) => {
+      const threadId = params?.threadId || null;
+      const turnId = params?.turnId || params?.turn?.id || null;
+      const key = `${event}:${threadId || ''}:${turnId || ''}`;
+      if (ignoredChildEventsLogged.has(key)) return;
+      ignoredChildEventsLogged.add(key);
+      debugLog('codex', event, {
+        rootThreadId,
+        rootTurnId,
+        threadId,
+        turnId,
+      });
+    };
+
+    const handleNotification = (msg) => {
+      const method = msg?.method;
+      const params = msg?.params || {};
+      if (method === 'thread/started') {
+        const thread = params?.thread || null;
+        if (!rootThreadId && thread?.id && !isSubAgentThread(thread)) {
+          rootThreadId = thread.id;
+        }
+        if (thread?.id === rootThreadId) {
+          threadPath = thread?.path || threadPath;
+        }
+        return;
+      }
+      if (method === 'turn/started') {
+        const turnId = params?.turn?.id || null;
+        const threadId = params?.threadId || null;
+        if (threadId === rootThreadId && turnId) {
+          if (!rootTurnId) {
+            rootTurnId = turnId;
+          }
+          if (turnId === rootTurnId) {
+            emit({ type: 'turn.started', sessionId: rootThreadId, turnId: rootTurnId });
+          }
+        } else {
+          logIgnoredChildEvent('codex.non-root-turn-started', params);
+        }
+        return;
+      }
+      if (method === 'item/agentMessage/delta') {
+        const delta = params?.delta;
+        if (typeof delta === 'string' && delta && isRootContext(params)) {
+          finalText += delta;
+          emit({
+            type: 'message.delta',
+            sessionId: rootThreadId,
+            turnId: rootTurnId,
+            text: delta,
+          });
+        } else if (typeof delta === 'string' && delta) {
+          logIgnoredChildEvent('codex.non-root-agent-delta', params);
+        }
+        return;
+      }
+      if (method === 'item/completed' && params?.item?.type === 'agentMessage' && typeof params?.item?.text === 'string') {
+        if (isRootContext(params)) {
+          finalText = params.item.text;
+        } else {
+          logIgnoredChildEvent('codex.non-root-agent-message-completed', params);
+        }
+        return;
+      }
+      if (method === 'error') {
+        const messageText = params?.message
+          || params?.error?.message
+          || params?.data?.message
+          || (params && Object.keys(params).length > 0 ? JSON.stringify(params) : null)
+          || 'codex app-server error';
+        settle(reject, buildCodexTurnError(messageText, buildGatewayErrorInfo({
+          startedAt,
+          messageText,
+          source: 'notification',
+          method,
+          params,
+          activeThreadId: rootThreadId,
+          activeTurnId: rootTurnId,
+        })));
+        return;
+      }
+      if (method === 'turn/completed') {
+        const completedThreadId = params?.threadId || null;
+        const completedTurnId = params?.turn?.id || null;
+        if (completedThreadId !== rootThreadId || completedTurnId !== rootTurnId) {
+          logIgnoredChildEvent('codex.non-root-turn-completed', params);
+          return;
+        }
+        if (params?.turn?.error) {
+          const turnErr = params.turn.error;
+          const messageText = turnErr?.message
+            || turnErr?.data?.message
+            || (turnErr && typeof turnErr === 'object' ? JSON.stringify(turnErr) : null)
+            || 'codex turn failed';
+          settle(reject, buildCodexTurnError(messageText, buildGatewayErrorInfo({
+            startedAt,
+            messageText,
+            source: 'turn-completed',
+            method,
+            params: { ...params, error: turnErr },
+            activeThreadId: rootThreadId,
+            activeTurnId: rootTurnId,
+          })));
+          return;
+        }
+        settle(resolve, {
+          sessionId: rootThreadId,
+          turnId: rootTurnId,
+          cwd,
+          path: threadPath,
+          text: finalText,
+          durationMs: Date.now() - startedAt,
+        });
+      }
+    };
+
+    child.stdout.on('data', (chunk) => {
+      lineBuffer += chunk.toString('utf8');
+      const lines = lineBuffer.split('\n');
+      lineBuffer = lines.pop() || '';
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let msg;
+        try { msg = JSON.parse(trimmed); } catch { continue; }
+        if (msg.id && pending.has(msg.id)) {
+          const pendingRequest = pending.get(msg.id);
+          pending.delete(msg.id);
+          if (msg.error) {
+            pendingRequest.reject(buildJsonRpcResponseError(msg.error, pendingRequest.method));
+          } else {
+            if (pendingRequest.method === 'thread/start') {
+              rootThreadId = msg.result?.thread?.id || rootThreadId;
+              threadPath = msg.result?.thread?.path || threadPath;
+            }
+            if (pendingRequest.method === 'turn/start') {
+              rootTurnId = msg.result?.turn?.id || rootTurnId;
+            }
+            pendingRequest.resolve(msg.result);
+          }
+          continue;
+        }
+        if (msg.method) handleNotification(msg);
+      }
+    });
+
+    let timeout = null;
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        settle(reject, buildCodexTurnError('codex turn timed out', {
+          ok: false,
+          code: null,
+          signal: 'SIGTERM',
+          durationMs: Date.now() - startedAt,
+          kind: 'killed',
+          errorMessage: 'codex turn timed out',
+        }));
+      }, timeoutMs);
+      timeout.unref();
+    }
+
+    child.on('error', (err) => {
+      settle(reject, buildCodexTurnError(err.message || 'codex app-server spawn failed', {
+        ok: false,
+        code: null,
+        signal: null,
+        durationMs: Date.now() - startedAt,
+        kind: 'spawn-failed',
+        error: err.message,
+        codexCommand,
+      }));
+    });
+
+    child.on('exit', (code, signal) => {
+      if (settled) return;
+      settle(reject, buildCodexTurnError(`codex app-server exited before turn completion${code !== null ? ` (code ${code})` : ''}${signal ? ` (${signal})` : ''}`, {
+        ok: false,
+        code,
+        signal,
+        durationMs: Date.now() - startedAt,
+        kind: signal ? 'killed' : 'exit-error',
+        errorMessage: 'codex app-server exited before turn completion',
+      }));
+    });
+
+    (async () => {
+      try {
+        await send('initialize', { protocolVersion: 2, clientInfo: { name: 'ticlawk', version: '0.1.0' } });
+        if (rootThreadId) {
+          await send('thread/resume', {
+            threadId: rootThreadId,
+            cwd,
+            approvalPolicy: 'never',
+            sandbox: 'danger-full-access',
+          });
+        } else {
+          const started = await send('thread/start', {
+            cwd,
+            model: process.env.CODEX_MODEL || null,
+            approvalPolicy: 'never',
+            sandbox: 'danger-full-access',
+          });
+          rootThreadId = started?.thread?.id || rootThreadId;
+          threadPath = started?.thread?.path || threadPath;
+        }
+        const turnInput = Array.isArray(input) && input.length > 0
+          ? input
+          : [{ type: 'text', text: message }];
+        const startedTurn = await send('turn/start', {
+          threadId: rootThreadId,
+          input: turnInput,
+          approvalPolicy: 'never',
+          sandboxPolicy: { type: 'dangerFullAccess' },
+        });
+        rootTurnId = startedTurn?.turn?.id || rootTurnId;
+      } catch (err) {
+        const messageText = err.message || 'codex app-server request failed';
+        settle(reject, buildCodexTurnError(messageText, buildGatewayErrorInfo({
+          startedAt,
+          messageText,
+          source: 'request',
+          method: err?.rpcMethod || null,
+          params: {},
+          err,
+          activeThreadId: rootThreadId,
+          activeTurnId: rootTurnId,
+        })));
+      }
+    })();
+  });
+}
+
+export function createCodexSession({ cwd, message, codexPath = null, timeoutMs = Number(process.env.CODEX_EXEC_TIMEOUT_MS || DEFAULT_CODEX_EXEC_TIMEOUT_MS) }) {
+  return new Promise((resolve, reject) => {
+    const startedAt = Date.now();
+    const codexCommand = requireCodexPath(codexPath);
+    const child = spawn(
+      codexCommand,
+      [
+        'exec',
+        '--json',
+        '--skip-git-repo-check',
+        '--dangerously-bypass-approvals-and-sandbox',
+        message,
+      ],
+      {
+        cwd,
+        env: buildRuntimeEnv(),
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }
+    );
+
+    debugLog('codex', 'session.spawned', {
+      pid: child.pid,
+      cwd,
+      timeoutMs,
+      textLength: message.length,
+      codexCommand,
+    });
+
+    let settled = false;
+    let timeout = null;
+    let buffer = '';
+
+    const settle = (fn, value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      fn(value);
+    };
+
+    if (timeoutMs > 0) {
+      timeout = setTimeout(() => {
+        debugError('codex', 'session.timeout', {
+          pid: child.pid,
+          durationMs: Date.now() - startedAt,
+          timeoutMs,
+        });
+        child.kill('SIGTERM');
+        settle(reject, new Error('codex session creation timed out'));
+      }, timeoutMs);
+      timeout.unref();
+    }
+
+    child.stdout.on('data', (chunk) => {
+      buffer += chunk.toString('utf8');
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (event.type === 'thread.started' && event.thread_id) {
+          debugLog('codex', 'session.started', {
+            pid: child.pid,
+            sessionId: String(event.thread_id).slice(0, 8),
+            cwd,
+          });
+          settle(resolve, String(event.thread_id));
+          return;
+        }
+      }
+    });
+
+    child.on('error', (err) => {
+      debugError('codex', 'session.spawn-failed', {
+        pid: child.pid,
+        durationMs: Date.now() - startedAt,
+        error: err.message,
+        codexCommand,
+      });
+      settle(reject, err);
+    });
+
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        debugError('codex', 'session.exit-signal', {
+          pid: child.pid,
+          durationMs: Date.now() - startedAt,
+          signal,
+        });
+        settle(reject, new Error(`codex session exited via ${signal}`));
+        return;
+      }
+      if (code !== 0) {
+        debugError('codex', 'session.exit-error', {
+          pid: child.pid,
+          durationMs: Date.now() - startedAt,
+          code,
+        });
+        settle(reject, new Error(`codex session exited with code ${code}`));
+        return;
+      }
+      debugLog('codex', 'session.exit-ok', {
+        pid: child.pid,
+        durationMs: Date.now() - startedAt,
+      });
+    });
+  });
+}