thinkpool-pair 0.7.364 → 0.7.366

package/codex-session.mjs

@@ -1,1295 +1 @@
-// codex-session.mjs — a structured Codex CLI session for the ThinkPool bridge.
-// Sibling to claude-session.mjs: SAME interface (startCodexSession →
-// { sendTurn, abort, end, sessionId }) and SAME room-event contract, so the
-// bridge can spawn either runtime per lane (spec §"the seam"). Uses
-// `codex exec --json` (OpenAI's openai-native agent loop) by default, with a
-// version-gated App Server path for streaming + interactive control.
-//
-// WHY NOT a translator: Codex IS the agent loop (tools + sandbox); we spawn it
-// and map its --json event stream (codex-event-mapper.mjs). No API translation,
-// no tool_use↔function-call loss. Auth = the HOST's `codex login` (ChatGPT,
-// flat sub) by default; BYOK via env CODEX_API_KEY works too (exec-only).
-//
-// `codex exec` is non-interactive, so ThinkPool maps its shared permission modes
-// onto Codex's native sandbox + approval policy. A mode change starts a fresh
-// Codex thread so the new sandbox actually takes effect; the visible transcript
-// remains in ThinkPool.
-//
-// DEFAULT ONE-SHOT-PER-TURN model: unlike Claude's long-lived query(), `codex
-// exec` is one prompt → run → exit. Continuity uses the exact thread id captured
-// for this lane. Compatible CLIs use one long-lived process by default;
-// TP_CODEX_APP_SERVER=0 or initialization failure falls back to this path.
-//
-// GOTCHA (spike): `codex exec` blocks reading stdin when backgrounded
-// ("Reading additional input from stdin…"). Spawn with stdin set to /dev/null.
-import { execFileSync, spawn } from 'node:child_process'
-import fs from 'node:fs'
-import os from 'node:os'
-import path from 'node:path'
-import readline from 'node:readline'
-import { buildCodexAppServerArgs, codexAppServerGate, createCodexAppServer } from './codex-app-server.mjs'
-import { CodexEventMapper } from './codex-event-mapper.mjs'
-import { startCodexMcpHttp } from './codex-mcp-http.mjs'
-import { CODEX_THINKPOOL_FIRST_TURN_PREAMBLE, buildThinkPoolTurnGuidance, createRoomContextSelector, usesFullThinkPoolReminder } from './thinkpool-room-prompt.mjs'
-import { questionAnswerResponse } from './question-response.mjs'
-import { codexReviewTarget, isCodexCompactCommand } from './codex-commands.mjs'
-import { createCumulativeEventRelay } from './cumulative-event-relay.mjs'
-import { stallDecision, stallEvent } from './turn-stall.mjs'
-
-const DEFAULT_SANDBOX = 'workspace-write'
-const SAFE_SANDBOXES = new Set(['read-only', 'workspace-write', 'danger-full-access'])
-export const EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max'])
-export const CODEX_MODE_CONFIG = {
-  default:           { sandbox: 'workspace-write', approvalPolicy: 'untrusted' },
-  acceptEdits:       { sandbox: 'workspace-write', approvalPolicy: 'on-request' },
-  plan:              { sandbox: 'read-only',       approvalPolicy: 'never' },
-  // Reviewer authority is structural, not a prompt convention. It may inspect
-  // the pinned snapshot and call the bridge-owned verdict/check tools, but it
-  // cannot mutate even its own worktree as an escape hatch.
-  review:            { sandbox: 'read-only',       approvalPolicy: 'never' },
-  bypassPermissions: { sandbox: 'danger-full-access', approvalPolicy: 'never' },
-}
-
-export function codexConfigForMode(mode) {
-  return CODEX_MODE_CONFIG[mode] || CODEX_MODE_CONFIG.default
-}
-
-export function codexDefaultCollaborationMode(model, effort) {
-  if (!model) return null
-  return {
-    mode: 'default',
-    settings: {
-      model: String(model),
-      reasoning_effort: EFFORT_LEVELS.has(effort) ? effort : null,
-      developer_instructions: null,
-    },
-  }
-}
-
-/**
- * The permission mode a FRESHLY-OPENED terminal gets when none was specified
- * (the person clicked "+ New terminal" without picking a mode). Codex defaults
- * to bypassPermissions: its workspace-write sandbox has NO network, so a
- * default-mode codex lane can't fetch / advance git metadata / push / publish
- * (the 2026-07-13 "sandbox won't let it advance Git metadata" wall) and is
- * hobbled out-of-the-box. bypass gives a person-opened codex terminal parity
- * with how Claude lanes run. Claude keeps 'default' — its permission modes don't
- * gate network. Explicit modes (a person's pick, resume's persisted entry.mode,
- * a flow lane) always override this. spawn_terminal separately pins every worker
- * to bypassPermissions as part of the autonomous-worker contract.
- */
-export function defaultModeForRuntime(runtime) {
-  return runtime === 'codex' ? 'bypassPermissions' : 'default'
-}
-
-export function codexWritableDirsForSandbox(sandbox, writableDirs = []) {
-  return normalizeCodexSandbox(sandbox) === 'read-only' ? [] : writableDirs
-}
-
-export function codexExtraWritableDirsForMode(mode, sandbox, writableDirs = []) {
-  if (mode === 'review') return []
-  return codexWritableDirsForSandbox(sandbox, writableDirs)
-}
-
-export function readCodexDefaultModel({ home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), fsImpl = fs } = {}) {
-  try {
-    const text = fsImpl.readFileSync(path.join(home, 'config.toml'), 'utf8')
-    // Only the top-level model controls the default runtime. Stop at the first
-    // table so a profile/provider's nested `model` cannot impersonate it.
-    const top = text.split(/^\s*\[/m, 1)[0]
-    const m = top.match(/^\s*model\s*=\s*["']([^"']+)["']\s*(?:#.*)?$/m)
-    return m?.[1]?.trim() || null
-  } catch { return null }
-}
-
-export function readCodexModels({ home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), fsImpl = fs } = {}) {
-  try {
-    const data = JSON.parse(fsImpl.readFileSync(path.join(home, 'models_cache.json'), 'utf8'))
-    return (Array.isArray(data?.models) ? data.models : [])
-      .filter((m) => m?.slug && m.visibility !== 'hide')
-      .sort((a, b) => (Number(a.priority) || 999) - (Number(b.priority) || 999))
-      .map((m) => ({ value: m.slug, displayName: m.display_name || m.slug, description: m.description || '' }))
-  } catch { return [] }
-}
-
-const rolloutPathCache = new Map()
-
-function codexRolloutPath(sessionId, { home, fsImpl }) {
-  if (!sessionId) return null
-  const cacheKey = `${home}\0${sessionId}`
-  const cached = rolloutPathCache.get(cacheKey)
-  if (cached) return cached
-  const root = path.join(home, 'sessions')
-  try {
-    const suffix = `${sessionId}.jsonl`
-    const hit = fsImpl.readdirSync(root, { recursive: true, withFileTypes: true })
-      .find((entry) => entry.isFile() && entry.name.endsWith(suffix))
-    if (!hit) return null
-    const found = path.join(hit.parentPath || hit.path || root, hit.name)
-    rolloutPathCache.set(cacheKey, found)
-    return found
-  } catch { return null }
-}
-
-// A stopped App Server turn can publish its thread id before Codex has written
-// even the session_meta row. If the bridge restarts in that window, both
-// thread/resume and `codex exec resume` reject the zero-byte rollout. Missing
-// files remain "unknown" (Codex may resolve them through another store), but a
-// rollout we can prove is empty is never resumable.
-export function codexThreadCanResume(sessionId, {
-  home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'),
-  fsImpl = fs,
-} = {}) {
-  if (!sessionId) return false
-  const file = codexRolloutPath(sessionId, { home, fsImpl })
-  if (!file) return true
-  try { return Number(fsImpl.statSync(file).size) > 0 }
-  catch { return true }
-}
-
-// `codex exec --json` exposes lifetime thread totals on `turn.completed`. Those
-// totals are useful for billing, but they are NOT context occupancy: an agentic
-// turn can make hundreds of cached model calls and process many context windows.
-// The native rollout's final token_count record carries both the exact last
-// request and Codex's usable window, so read only a bounded tail of that file.
-export function readCodexThreadUsage(sessionId, {
-  home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'),
-  fsImpl = fs,
-  tailBytes = 4 * 1024 * 1024,
-} = {}) {
-  const file = codexRolloutPath(sessionId, { home, fsImpl })
-  if (!file) return null
-  let fd
-  try {
-    const size = Number(fsImpl.statSync(file).size) || 0
-    const length = Math.min(size, Math.max(64 * 1024, tailBytes))
-    const buf = Buffer.alloc(length)
-    fd = fsImpl.openSync(file, 'r')
-    fsImpl.readSync(fd, buf, 0, length, size - length)
-    const lines = buf.toString('utf8').split('\n')
-    for (let i = lines.length - 1; i >= 0; i--) {
-      let row
-      try { row = JSON.parse(lines[i]) } catch { continue }
-      if (row?.payload?.type !== 'token_count' || !row.payload.info) continue
-      const info = row.payload.info
-      const last = info.last_token_usage || {}
-      const total = info.total_token_usage || {}
-      const used = Number(last.total_tokens)
-      const max = Number(info.model_context_window)
-      if (!Number.isFinite(used) || used < 0 || !Number.isFinite(max) || max <= 0) return null
-      return {
-        context: { used: Math.floor(used), max: Math.floor(max) },
-        total: {
-          input_tokens: Math.max(0, Number(total.input_tokens) || 0),
-          cached_input_tokens: Math.max(0, Number(total.cached_input_tokens) || 0),
-          output_tokens: Math.max(0, Number(total.output_tokens) || 0),
-        },
-        rateLimits: row.payload.rate_limits || null,
-      }
-    }
-  } catch { return null }
-  finally { if (fd != null) { try { fsImpl.closeSync(fd) } catch { /* noop */ } } }
-  return null
-}
-
-// App Server publishes the authoritative current-window count during native
-// compaction (and while turns run). Its field names differ from the rollout
-// token_count rows, so normalize both sources to the one snapshot shape used by
-// CodexEventMapper and the bridge context meter.
-export function codexUsageSnapshotFromAppServer(tokenUsage) {
-  const used = Number(tokenUsage?.last?.totalTokens)
-  const max = Number(tokenUsage?.modelContextWindow)
-  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(max) || max <= 0) return null
-  const total = tokenUsage?.total || {}
-  return {
-    context: { used: Math.floor(used), max: Math.floor(max) },
-    total: {
-      input_tokens: Math.max(0, Number(total.inputTokens) || 0),
-      cached_input_tokens: Math.max(0, Number(total.cachedInputTokens) || 0),
-      output_tokens: Math.max(0, Number(total.outputTokens) || 0),
-    },
-  }
-}
-
-export function normalizeCodexSandbox(value) {
-  return SAFE_SANDBOXES.has(value) ? value : DEFAULT_SANDBOX
-}
-
-export function codexPublishAccess({ cwd, env = process.env, tmpdir = os.tmpdir(), execFile = execFileSync } = {}) {
-  const writableDirs = []
-  try {
-    const raw = String(execFile('git', ['rev-parse', '--git-common-dir'], { cwd, encoding: 'utf8' }) || '').trim()
-    if (raw) {
-      const commonDir = path.resolve(cwd, raw)
-      const workspace = path.resolve(cwd)
-      if (commonDir !== workspace && !commonDir.startsWith(workspace + path.sep)) writableDirs.push(commonDir)
-    }
-  } catch { /* non-git cwd: Codex already uses --skip-git-repo-check */ }
-  return {
-    writableDirs,
-    env: {
-      ...env,
-      // Auth still comes read-only from ~/.npmrc; only cache writes move to a
-      // lane-safe temp location.
-      NPM_CONFIG_CACHE: path.join(tmpdir, 'thinkpool-npm-cache'),
-    },
-  }
-}
-
-export const CODEX_ROOM_CASCADE_REMINDER = [
-  'THINKPOOL ROOM ROLE ENFORCEMENT: obey the authoritative TERMINAL ROLE above. A person-authored request for a new, separate, independent, top-level, or main terminal uses open_main_terminal — NEVER spawn_terminal — even for ordinary work or a handoff. If the wording includes new or separate terminal, main-terminal routing wins. Use spawn_terminal only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. If open_main_terminal is unavailable, say so; never substitute an Ensemble child. Leaf, worker, Side, and managed Flow lanes work directly and must not delegate. Never use hidden in-process subagents.',
-].join(' ')
-
-export function buildCodexPrompt({ text, terminalRolePrompt, rolePrompt, roomContext, firstTurn = false, promptIndex = 0, forceFullReminder = false }) {
-  const context = typeof roomContext === 'function' ? roomContext() : roomContext
-  const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull: forceFullReminder })
-  const additions = [
-    firstTurn ? CODEX_THINKPOOL_FIRST_TURN_PREAMBLE : '',
-    fullReminder ? terminalRolePrompt : '',
-    buildThinkPoolTurnGuidance({ text, promptIndex, forceFull: forceFullReminder }),
-    fullReminder ? (rolePrompt || CODEX_ROOM_CASCADE_REMINDER) : '',
-    context,
-  ].map((v) => String(v || '').trim()).filter(Boolean)
-  if (!additions.length) return String(text ?? '')
-  return `<thinkpool-context>\n${additions.join('\n\n')}\n</thinkpool-context>\n\n${String(text ?? '')}`
-}
-
-export function buildCodexExecArgs({ sessionId, model, effort, sandbox, approvalPolicy = 'untrusted', providerConfig, mcpUrl, writableDirs = [], images = [], prompt }) {
-  const safeSandbox = normalizeCodexSandbox(sandbox)
-  const args = sessionId
-    // `codex exec resume` has no --sandbox option and does NOT retain the fresh
-    // exec's sandbox: without an explicit override Codex falls back to its
-    // workspace profile (network=false). That silently removes the loopback
-    // ThinkPool MCP and blocks git metadata/network on turn two. Reassert the
-    // selected posture on every resume. Codex exposes a dedicated resume flag
-    // for full access; restricted modes ride the equivalent config override.
-    ? [
-        'exec', 'resume', '--json', '--skip-git-repo-check',
-        ...(safeSandbox === 'danger-full-access'
-          ? ['--dangerously-bypass-approvals-and-sandbox']
-          : ['-c', `sandbox_mode="${safeSandbox}"`]),
-      ]
-    : ['exec', '--json', '--sandbox', safeSandbox, '--skip-git-repo-check']
-  if (model) args.push('-m', model)
-  args.push('-c', `approval_policy="${approvalPolicy}"`)
-  if (EFFORT_LEVELS.has(effort)) args.push('-c', `model_reasoning_effort="${effort}"`)
-  if (providerConfig) args.push('-c', providerConfig)
-  // `resume` retains the roots selected by the fresh rollout and does not
-  // accept --add-dir itself. Supply these only when creating the thread.
-  if (!sessionId) for (const dir of writableDirs) args.push('--add-dir', dir)
-  // Per-lane override only: never mutate the person's global Codex config.
-  if (mcpUrl) {
-    args.push('-c', `mcp_servers.thinkpool.url=${JSON.stringify(mcpUrl)}`)
-    // Room tools are part of the ThinkPool execution contract, not optional
-    // enrichment. A failed handshake must abort this invocation so Codex
-    // cannot continue after spawn_terminal vanished from its callable set.
-    args.push('-c', 'mcp_servers.thinkpool.required=true')
-  }
-  // Both fresh `exec` and `exec resume` accept repeatable --image flags. Only
-  // bridge-derived absolute paths reach this layer; relative values are ignored
-  // so a future caller cannot silently change the child's path interpretation.
-  let hasNativeImages = false
-  for (const imagePath of images) {
-    if (!path.isAbsolute(String(imagePath || ''))) continue
-    args.push('--image', String(imagePath))
-    hasNativeImages = true
-  }
-  // Codex CLI 0.144.1 defines --image as a variadic option. Without an option
-  // terminator it consumes the positional prompt (and, on resume, the thread
-  // id), then exits because stdin is intentionally /dev/null in the bridge.
-  if (hasNativeImages) args.push('--')
-  if (sessionId) args.push(sessionId)
-  args.push(String(prompt ?? ''))
-  return args
-}
-
-// `codex exec` can fail before it has created or resumed a native turn when a
-// required MCP client loses the App Server -> exec handoff race. Retrying is
-// safe only when stderr proves session initialization failed AND the JSONL
-// stream contains no turn/item activity. A silent process or a generic exit is
-// delivery-uncertain and must never replay the person's prompt automatically.
-export function codexExecFailedBeforeTurn({ stderr = '', eventTypes = [] } = {}) {
-  const types = Array.isArray(eventTypes) ? eventTypes.map((type) => String(type || '')) : []
-  if (types.some((type) => type && type !== 'thread.started')) return false
-  const message = String(stderr || '')
-  return /timed out handshaking with MCP server/i.test(message)
-    || (/thread\/resume failed/i.test(message) && /failed to initialize session/i.test(message))
-}
-
-const CODEX_DESTRUCTIVE = /\brm\s+\S|\brmdir\s+\S|\bgit\s+(push\s+(-f|--force)|reset\s+--hard|clean\s+-[a-z]*f)|\bdrop\s+(table|database)\b|\b(mkfs|dd)\b|\bsudo\b|>\s*\/dev\/|\bchmod\s+-R|\bchown\s+-R|\bkillall\b|\btruncate\b/i
-
-export function codexApprovalCard(method, params = {}, item = null) {
-  const id = String(params.approvalId || params.itemId || `${params.turnId || 'turn'}:${method}`)
-  if (method === 'item/tool/requestUserInput') {
-    const questions = Array.isArray(params.questions) ? params.questions : []
-    return {
-      id,
-      toolName: 'AskUserQuestion',
-      input: { questions },
-      risk: 'ask',
-      questions,
-      asker: 'Codex',
-      answerFormat: 'codex',
-      ...(Number.isFinite(params.autoResolutionMs) && params.autoResolutionMs > 0
-        ? { autoResolutionMs: params.autoResolutionMs }
-        : {}),
-    }
-  }
-  if (method === 'item/commandExecution/requestApproval') {
-    const command = params.command || item?.command || ''
-    return {
-      id,
-      toolName: 'Bash',
-      input: { command, cwd: params.cwd || item?.cwd || '', ...(params.reason ? { reason: params.reason } : {}) },
-      risk: CODEX_DESTRUCTIVE.test(command) ? 'high' : 'medium',
-    }
-  }
-  if (method === 'item/fileChange/requestApproval') {
-    const changes = Array.isArray(item?.changes) ? item.changes : []
-    const first = changes[0] || {}
-    const toolName = changes.length > 1 ? 'MultiEdit' : first.kind === 'add' ? 'Write' : 'Edit'
-    return {
-      id,
-      toolName,
-      input: changes.length > 1
-        ? { edits: changes.map((change) => ({ file_path: change.path || '', path: change.path || '', kind: change.kind || 'update' })), ...(params.reason ? { reason: params.reason } : {}) }
-        : { file_path: first.path || params.grantRoot || '', path: first.path || params.grantRoot || '', kind: first.kind || 'update', ...(params.reason ? { reason: params.reason } : {}) },
-      risk: 'medium',
-    }
-  }
-  return null
-}
-
-export function codexApprovalResponse(decision) {
-  return { decision: decision === 'always' ? 'acceptForSession' : decision === 'allow' ? 'accept' : 'decline' }
-}
-
-export function codexUserInputResponse(result, questions = []) {
-  return questionAnswerResponse(result, questions)
-}
-
-function appServerItemForMapper(item) {
-  if (!item || typeof item !== 'object') return item
-  const common = { ...item }
-  switch (item.type) {
-    case 'agentMessage': return { ...common, type: 'agent_message' }
-    case 'commandExecution': return { ...common, type: 'command_execution', aggregated_output: item.aggregatedOutput || '', exit_code: item.exitCode }
-    case 'fileChange': return { ...common, type: 'file_change' }
-    case 'webSearch': return { ...common, type: 'web_search' }
-    case 'mcpToolCall': return { ...common, type: 'mcp_tool_call', arguments: item.arguments || {}, result: item.result, error: item.error }
-    case 'reasoning': return { ...common, type: 'reasoning', text: [...(item.summary || []), ...(item.content || [])].join('\n') }
-    default: return common
-  }
-}
-
-/**
- * Start a structured Codex session. Mirrors startClaudeSession's contract.
- * @param {object} o
- * @param {string} o.cwd           work directory for the codex exec (a git repo)
- * @param {string} [o.model]       model id (e.g. 'gpt-5.6-sol'); passed via -m
- * @param {string} [o.resume]      captured Codex thread id to resume after bridge restart
- * @param {object} [o.env]         env for the child (e.g. CODEX_API_KEY for BYOK)
- * @param {string} [o.sandbox]     'read-only' | 'workspace-write' | 'danger-full-access' (default workspace-write)
- * @param {(evt)=>void} o.onEvent  receives normalized room-events
- * @param {(req)=>Promise<string>} [o.requestPermission] shared room permission-card callback
- * @param {string} [o.providerConfig] optional -c overrides / provider block (M2: from the provider registry)
- * @returns {{ sendTurn(text, options?), abort(), end(), readonly sessionId }}
- */
-export function startCodexSession({ cwd, model, effort: initialEffort = 'high', resume, env, sandbox, mode = 'default', onEvent, providerConfig, terminalRolePrompt, rolePrompt, roomContext, mcpServers, prepareCwd = null, requestPermission, appServerGate = codexAppServerGate, appServerFactory = createCodexAppServer, mcpHttpFactory = startCodexMcpHttp, spawnImpl = spawn, admitStart = null, stallOptions = {} }) {
-  let activeMode = CODEX_MODE_CONFIG[mode] ? mode : 'default'
-  let modeConfig = codexConfigForMode(activeMode)
-  sandbox = normalizeCodexSandbox(sandbox || modeConfig.sandbox)
-  const publishAccess = codexPublishAccess({ cwd, env: { ...process.env, ...(env || {}) } })
-  const childEnv = publishAccess.env
-  const requestedResume = resume || null
-  const resumeUsable = !requestedResume || codexThreadCanResume(requestedResume, {
-    home: childEnv.CODEX_HOME || path.join(os.homedir(), '.codex'),
-  })
-  let sessionId = resumeUsable ? requestedResume : null
-  let turnNo = sessionId ? 1 : 0
-  let userPromptNo = 0
-  let forceFullReminder = true
-  const selectRoomContext = createRoomContextSelector(roomContext)
-  let child = null
-  let aborted = false
-  let ended = false
-  let turnActive = false
-  // Codex can accept a room turn and then emit nothing while App Server is
-  // booting or an upstream model call is retrying. The room's generic roster
-  // clock can label that lane "stalled", but only the owning transport can
-  // surface an honest in-pane status and safely interrupt/replay the exact
-  // logical prompt. Keep this lifecycle parallel to Claude's shared watchdog.
-  const stallNow = typeof stallOptions.now === 'function' ? stallOptions.now : Date.now
-  const stallSetInterval = typeof stallOptions.setInterval === 'function' ? stallOptions.setInterval : setInterval
-  const stallClearInterval = typeof stallOptions.clearInterval === 'function' ? stallOptions.clearInterval : clearInterval
-  const STALL_MS = Number.isFinite(stallOptions.stallMs)
-    ? Math.max(1, Number(stallOptions.stallMs))
-    : Math.max(30000, parseInt(childEnv.TP_STALL_MS, 10) || 90000)
-  const FORCE_STOP_MS = Number.isFinite(stallOptions.forceStopMs)
-    ? Math.max(STALL_MS, Number(stallOptions.forceStopMs))
-    : Math.max(STALL_MS * 3, parseInt(childEnv.TP_FORCE_STOP_MS, 10) || 300000)
-  const STALL_INTERVAL_MS = Number.isFinite(stallOptions.intervalMs)
-    ? Math.max(1, Number(stallOptions.intervalMs))
-    : 5000
-  let lastEvtTs = stallNow()
-  let stalledSent = false
-  let stallRetried = false
-  let stallRetryRequested = false
-  let stallGiveupRequested = false
-  // True only while the current logical attempt is still in bridge-owned
-  // bootstrap. It flips before writing a turn/start request or spawning exec.
-  // Absence of provider output is not proof that a prompt was not delivered.
-  let stallReplaySafe = true
-  let awaitingUser = 0
-  let stallTimer = null
-  let activeModel = model || null
-  let activeEffort = EFFORT_LEVELS.has(initialEffort) ? initialEffort : 'high'
-  let latestUsageSnapshot = sessionId ? readCodexThreadUsage(sessionId) : null
-  let mcpHttpPromise = null
-  const appServerGateResult = appServerGate({ env: childEnv })
-  let appServerDisabled = !appServerGateResult.enabled
-  let appServer = null
-  let appServerThreadReady = false
-  let activeTurnId = null
-  let compactStartWaiter = null
-  let compactActive = false
-  // App Server notifications are asynchronous to turn/completed. In production a
-  // stopped turn emitted its durable `aborted` boundary, then delivered a queued
-  // item/started 89ms later and a Bash result 159.9s after that. Without a native
-  // turn fence those late rows resurrected the lane after Stop. Keep a bounded set
-  // of closed native turns and accept turn-scoped traffic only for the one active id.
-  const closedAppServerTurnIds = new Set()
-  const appServerItems = new Map()
-  const streamedAgentItems = new Map() // item id → { cid, text }
-  let steerChain = Promise.resolve()
-  // serialize turns: one exec at a time
-  let chain = Promise.resolve()
-  const queue = []
-
-  // Synthetic watchdog chrome must not count as provider activity, otherwise
-  // its 90s status would reset the silence clock and postpone the 5m recovery.
-  // Everything on the normal relay path is real transport/session activity and
-  // immediately clears the one-shot stalled banner.
-  const emitRaw = createCumulativeEventRelay((event) => { try { onEvent?.(event) } catch { /* consumer isolation */ } })
-  const touchActivity = () => { lastEvtTs = stallNow(); stalledSent = false }
-  const relayEvent = (event) => { touchActivity(); emitRaw(event) }
-  relayEvent.cancel = () => emitRaw.cancel()
-  const mapper = new CodexEventMapper({
-    onEvent: relayEvent,
-    model: model || null,
-    usageSnapshotForSession: (id) => {
-      const snapshot = readCodexThreadUsage(id)
-      if (snapshot) latestUsageSnapshot = snapshot
-      return snapshot || latestUsageSnapshot
-    },
-  })
-
-  // The bridge samples `session.turnActive` synchronously inside onEvent to
-  // announce the roster's busy edge. Codex transports report their terminal
-  // boundary before their surrounding promise/process cleanup runs, so clearing
-  // turnActive only in `finally`/`close` publishes one last stale `busy: true`
-  // announce with no later event to correct it. A tab refocus re-announcement
-  // eventually healed the roster, but until then the room stayed on "thinking".
-  // Settle at the event boundary itself for every Codex transport.
-  const pushMappedEvent = (event) => {
-    if (event?.type === 'turn.completed' || event?.type === 'turn.failed') turnActive = false
-    mapper.push(event)
-  }
-  const emitTurnBoundary = (event) => {
-    turnActive = false
-    relayEvent(event)
-  }
-
-  const armTurnLiveness = ({ retry = false } = {}) => {
-    turnActive = true
-    lastEvtTs = stallNow()
-    stalledSent = false
-    stallRetryRequested = false
-    stallGiveupRequested = false
-    stallReplaySafe = true
-    if (!retry) stallRetried = false
-  }
-
-  const note = (text) => relayEvent({ kind: 'note', text })
-
-  const closeAppServerTurn = (turnId = activeTurnId) => {
-    const id = String(turnId || '')
-    if (!id) return
-    closedAppServerTurnIds.add(id)
-    while (closedAppServerTurnIds.size > 64) closedAppServerTurnIds.delete(closedAppServerTurnIds.values().next().value)
-  }
-
-  const appServerTurnIsCurrent = (params = {}) => {
-    const turnId = String(params.turnId || '')
-    return !!turnId && !ended && !aborted && !closedAppServerTurnIds.has(turnId) && turnId === String(activeTurnId || '')
-  }
-  if (requestedResume && !resumeUsable) {
-    queueMicrotask(() => note('The stopped Codex turn had no resumable context; continuing in a fresh thread.'))
-  }
-  if (!['0', 'false', 'off'].includes(String(childEnv.TP_CODEX_APP_SERVER || '').trim().toLowerCase()) && !appServerGateResult.enabled) {
-    queueMicrotask(() => note(`Codex App Server disabled: ${appServerGateResult.reason}`))
-  }
-
-  async function ensureMcpHttp() {
-    const thinkpool = mcpServers?.thinkpool
-    if (!thinkpool) return null
-    if (!mcpHttpPromise) mcpHttpPromise = mcpHttpFactory({ sdkServer: thinkpool })
-    return mcpHttpPromise
-  }
-
-  function appServerNotification(method, params = {}) {
-    if (method === 'thread/tokenUsage/updated') {
-      if (params.threadId && sessionId && String(params.threadId) !== String(sessionId)) return
-      const snapshot = codexUsageSnapshotFromAppServer(params.tokenUsage)
-      if (!snapshot) return
-      latestUsageSnapshot = snapshot
-      // Ordinary turns publish one settled meter at turn/completed. Native
-      // compaction is not an ordinary sendTurn, so this notification is its only
-      // immediate post-summary meter and must reach every connected room client.
-      if (compactActive) {
-        const { used, max } = snapshot.context
-        relayEvent({ kind: 'usage', ctx: { used, max, pct: Math.min(100, Math.max(0, Math.round((used / max) * 100))), over: used > max, model: activeModel } })
-      }
-      return
-    }
-    if (method === 'turn/started' && params.turn?.id) {
-      const turnId = String(params.turn.id)
-      if (ended || aborted) { closeAppServerTurn(turnId); return }
-      if (compactStartWaiter) {
-        const waiter = compactStartWaiter
-        compactStartWaiter = null
-        waiter.resolve(turnId)
-        return
-      }
-      if (!activeTurnId) activeTurnId = turnId
-      touchActivity()
-      return
-    }
-    // Every mapped App Server notification below is turn-scoped in the tested
-    // protocol and carries turnId. Fail closed on missing, stale, completed, or
-    // interrupted ids so a provider's buffered stdout cannot reopen a closed turn.
-    if ((method === 'turn/plan/updated' || method === 'item/agentMessage/delta' || method === 'item/started' || method === 'item/completed' || method === 'error') && !appServerTurnIsCurrent(params)) return
-    touchActivity()
-    if (method === 'turn/plan/updated') {
-      const todos = (Array.isArray(params.plan) ? params.plan : []).map(({ step, status }) => ({
-        content: step || '',
-        activeForm: step || '',
-        status: status === 'inProgress' ? 'in_progress' : status === 'completed' ? 'completed' : 'pending',
-      })).filter((todo) => todo.content)
-      relayEvent({ kind: 'assistant', blocks: [{ type: 'tool_use', id: `codex-plan:${params.turnId || 'active'}`, name: 'TodoWrite', input: { todos } }], parentToolUseId: null })
-      return
-    }
-    if (method === 'item/agentMessage/delta') {
-      if (!params.delta) return
-      const itemId = params.itemId || `turn:${params.turnId || activeTurnId || 'active'}`
-      const state = streamedAgentItems.get(itemId) || { cid: `codex-stream:${sessionId || 'thread'}:${itemId}`, text: '' }
-      state.text += String(params.delta)
-      streamedAgentItems.set(itemId, state)
-      // Cumulative transient snapshot. The bridge broadcasts this chrome event
-      // without assigning transcript seq/archive rows; room.jsx replaces the
-      // stable cid in place. item/completed emits one durable assistant row.
-      relayEvent({ kind: 'assistant_stream', cid: state.cid, text: state.text, itemId, streaming: true })
-      return
-    }
-    if (method === 'item/started' || method === 'item/completed') {
-      const raw = params.item
-      if (!raw) return
-      if (method === 'item/started') appServerItems.set(raw.id, raw)
-      if (method === 'item/completed') {
-        appServerItems.set(raw.id, raw)
-        if (raw.type === 'agentMessage' && streamedAgentItems.has(raw.id)) {
-          const state = streamedAgentItems.get(raw.id)
-          streamedAgentItems.delete(raw.id)
-          relayEvent({ kind: 'assistant', blocks: [{ type: 'text', text: raw.text || state.text }], parentToolUseId: null, replacesCid: state.cid })
-          return
-        }
-      }
-      pushMappedEvent({ type: method === 'item/started' ? 'item.started' : 'item.completed', item: appServerItemForMapper(raw) })
-      return
-    }
-    if (method === 'error') {
-      const message = params.error?.message || params.message || 'codex app-server error'
-      pushMappedEvent({ type: 'error', message })
-    }
-  }
-
-  async function appServerRequest(method, params = {}) {
-    // A request racing Stop must never raise a fresh room card after the turn's
-    // durable boundary. Respond with the protocol's ordinary denial shape so the
-    // native runtime can settle without reopening any ThinkPool state.
-    if (!appServerTurnIsCurrent(params)) {
-      if (method === 'item/tool/requestUserInput') return { answers: {} }
-      return { decision: 'decline' }
-    }
-    const card = codexApprovalCard(method, params, appServerItems.get(params.itemId))
-    if (!card) throw new Error(`Unsupported Codex App Server request: ${method}`)
-    // Missing/broken room permission plumbing denies safely. App Server expects
-    // an ordinary response even for denial; an RPC error can strand the turn.
-    let decision = 'deny'
-    awaitingUser++
-    try { decision = await requestPermission?.(card) } catch { /* deny */ }
-    finally {
-      awaitingUser = Math.max(0, awaitingUser - 1)
-      // Give the resumed model call a fresh watchdog window. Human think time
-      // is intentionally excluded and must not force-stop the turn next tick.
-      touchActivity()
-    }
-    if (method === 'item/tool/requestUserInput') return codexUserInputResponse(decision, card.questions)
-    return codexApprovalResponse(decision)
-  }
-
-  async function ensureAppServer() {
-    if (appServerDisabled) return false
-    if (appServer?.alive === false) {
-      appServerThreadReady = false
-      appServerDisabled = true
-      return false
-    }
-    if (appServer && appServerThreadReady) return true
-    let peer
-    try { peer = await ensureMcpHttp() }
-    catch (error) { note(`Thinkpool peer tools unavailable: ${error?.message || error}`) }
-    try {
-      if (!appServer) {
-        appServer = appServerFactory({
-          cwd,
-          env: childEnv,
-          args: buildCodexAppServerArgs({ providerConfig, mcpUrl: peer?.url, writableDirs: codexExtraWritableDirsForMode(activeMode, sandbox, publishAccess.writableDirs) }),
-          onNotification: appServerNotification,
-          onServerRequest: appServerRequest,
-          onClose: (error) => {
-            if (ended || appServerDisabled) return
-            appServerThreadReady = false
-            appServerDisabled = true
-            note(`Codex App Server closed; later turns will use codex exec: ${error?.message || error}`)
-          },
-        })
-        await appServer.start()
-        touchActivity()
-      }
-      sessionId = await appServer.startThread({
-        threadId: turnNo > 0 ? sessionId : null,
-        cwd,
-        model: activeModel,
-        sandbox,
-        approvalPolicy: modeConfig.approvalPolicy,
-        // Codex 0.144.1 gates request_user_input by INTERNAL collaboration
-        // mode. Enable it for Default mode on this thread without changing the
-        // independent ThinkPool sandbox / approval posture above.
-        config: { 'features.default_mode_request_user_input': true },
-      })
-      touchActivity()
-      // App Server reports thread/start before its per-thread MCP clients finish
-      // initializing. Starting the first turn in that gap snapshots a toolset
-      // without ThinkPool even though the server becomes ready milliseconds later.
-      // Hold the turn boundary until the room MCP is actually ready; a timeout or
-      // startup failure drops into the required-MCP codex exec fallback below.
-      if (peer?.url) {
-        await appServer.waitForMcpServer({ threadId: sessionId, name: 'thinkpool' })
-        touchActivity()
-      }
-      appServerThreadReady = true
-      pushMappedEvent({ type: 'thread.started', thread_id: sessionId })
-      return true
-    } catch {
-      // Fallback is safe only here: no turn/start request has been accepted, so
-      // there is no possibility of running the same prompt twice.
-      appServerDisabled = true
-      try { appServer?.end() } catch { /* noop */ }
-      appServer = null
-      appServerThreadReady = false
-      return false
-    }
-  }
-
-  function stopStalledTransport({ force = false } = {}) {
-    const server = appServer
-    const turnId = activeTurnId
-
-    if (server && force) {
-      // A second stall is terminal. End the resident process, not merely its
-      // turn: an interrupt whose completion notification is itself wedged would
-      // otherwise leave `chain` unresolved and silently queue every later send.
-      closeAppServerTurn(turnId)
-      appServerDisabled = true
-      appServerThreadReady = false
-      try { server.end() } catch { /* noop */ }
-      if (appServer === server) appServer = null
-    } else if (server && turnId) {
-      // Fence the old native id before interrupting so buffered deltas/tool rows
-      // cannot cross into the retried logical turn.
-      closeAppServerTurn(turnId)
-      Promise.resolve(server.interrupt({ threadId: sessionId, turnId })).catch(() => {
-        // An interrupt rejected before delivery: tear down the uncertain control
-        // channel. The current pump will use the exec fallback for its one retry.
-        appServerDisabled = true
-        appServerThreadReady = false
-        try { server.end() } catch { /* noop */ }
-        if (appServer === server) appServer = null
-      })
-    } else if (server) {
-      // The stall happened during cold App Server / MCP bootstrap, before a
-      // native turn id existed. Closing that process makes the pending startup
-      // reject; ensureAppServer then returns false and the same prompt gets its
-      // bounded retry through codex exec.
-      appServerDisabled = true
-      appServerThreadReady = false
-      try { server.end() } catch { /* noop */ }
-      if (appServer === server) appServer = null
-    }
-
-    if (child) {
-      const stalledChild = child
-      try { stalledChild.kill('SIGTERM') } catch { /* noop */ }
-      setTimeout(() => {
-        if (child === stalledChild) { try { stalledChild.kill('SIGKILL') } catch { /* noop */ } }
-      }, 1500)
-    }
-  }
-
-  stallTimer = stallSetInterval(() => {
-    const quietMs = stallNow() - lastEvtTs
-    const action = stallDecision({
-      turnActive,
-      awaitingUser,
-      quietMs,
-      stallMs: STALL_MS,
-      forceStopMs: FORCE_STOP_MS,
-      stalledSent,
-      stallRetried,
-    })
-    if (action === 'none') return
-
-    // Do not emit the generic "retrying the turn" copy when native delivery is
-    // already uncertain; that would promise the exact unsafe action we refuse.
-    if (action === 'retry' && !stallReplaySafe) {
-      stallGiveupRequested = true
-      stallRetryRequested = false
-      emitRaw({ kind: 'error', recoverable: true, message: 'Codex stopped responding after the turn began. The transport was stopped, but the prompt was not replayed automatically.' })
-      emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
-      stopStalledTransport({ force: true })
-      return
-    }
-
-    const event = stallEvent(action, quietMs)
-    if (event) emitRaw(event)
-    if (action === 'status') {
-      stalledSent = true
-      return
-    }
-    if (action === 'retry') {
-      // Preserve the prompt and retry budget in pump(); do not use the public
-      // abort flag because that intentionally discards queued work and emits a
-      // terminal aborted boundary.
-      stallRetried = true
-      stallRetryRequested = true
-      lastEvtTs = stallNow()
-      stalledSent = false
-      stopStalledTransport()
-      return
-    }
-
-    // The retry also went silent. Surface the durable terminal boundary now so
-    // the lane cannot remain busy if the native interrupt itself is wedged.
-    stallGiveupRequested = true
-    stallRetryRequested = false
-    queue.length = 0
-    emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
-    stopStalledTransport({ force: true })
-  }, STALL_INTERVAL_MS)
-  stallTimer.unref?.()
-
-  async function runAppServer(prompt, options = {}) {
-    // Stop can win before the queued pump enters native startup. Do not launch a
-    // fresh App Server merely to discover the accepted room turn was cancelled.
-    if (ended || aborted || stallGiveupRequested) return true
-    if (!await ensureAppServer()) return false
-    // Stop can land while the cold App Server / MCP bootstrap is still awaiting.
-    // The accepted turn was already closed at the room boundary; never start it
-    // after bootstrap finally resolves.
-    if (ended || aborted || stallGiveupRequested) return true
-    mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
-    turnActive = true
-    try {
-      // startTurn writes the prompt-bearing RPC. From this edge onward delivery
-      // is at least uncertain, even if the response or first event never lands.
-      stallReplaySafe = false
-      activeTurnId = await appServer.startTurn({
-        threadId: sessionId,
-        input: prompt,
-        images: Array.isArray(options.images) ? options.images : [],
-        model: activeModel,
-        effort: activeEffort,
-        approvalPolicy: modeConfig.approvalPolicy,
-        collaborationMode: codexDefaultCollaborationMode(activeModel, activeEffort),
-      })
-      touchActivity()
-      // Stop may land after the RPC was written but before startTurn returns its
-      // id. abort() already closed the room boundary; interrupt the now-known
-      // native turn before waiting, and never let it continue invisibly.
-      if (aborted || ended) {
-        closeAppServerTurn(activeTurnId)
-        try { await appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }) } catch { /* boundary is already closed */ }
-        return true
-      }
-      const completed = await appServer.waitForTurn(activeTurnId)
-      closeAppServerTurn(completed?.turn?.id || activeTurnId)
-      const status = completed?.turn?.status
-      if (aborted) {
-        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
-      } else if (status === 'interrupted' && (stallRetryRequested || stallGiveupRequested)) {
-        // The watchdog owns this lifecycle: retry is re-armed by pump(), while
-        // giveup already emitted the one terminal boundary synchronously.
-      } else if (status === 'interrupted') {
-        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
-      } else if (status === 'failed') {
-        stallRetryRequested = false
-        pushMappedEvent({ type: 'turn.failed', message: completed?.turn?.error?.message || 'codex turn failed' })
-      } else {
-        stallRetryRequested = false
-        pushMappedEvent({ type: 'turn.completed' })
-      }
-    } catch (error) {
-      // Once a started turn's transport fails we must not replay that prompt via
-      // exec (the model may already have acted). Disable App Server for later
-      // turns only; they can safely resume this thread through the stable driver.
-      appServerDisabled = true
-      appServerThreadReady = false
-      closeAppServerTurn(activeTurnId)
-      try { appServer?.end() } catch { /* noop */ }
-      appServer = null
-      if (!ended && !stallRetryRequested && !stallGiveupRequested) pushMappedEvent({ type: 'turn.failed', message: `codex app-server turn failed: ${error?.message || error}` })
-    } finally {
-      // A transport failure or interrupt can land after prose deltas but before
-      // item/completed. Preserve that partial prose as one durable row rather
-      // than leaving a replay-less streaming shell behind.
-      for (const state of streamedAgentItems.values()) {
-        if (!state.text) continue
-        relayEvent({ kind: 'assistant', blocks: [{ type: 'text', text: state.text }], parentToolUseId: null, replacesCid: state.cid })
-      }
-      activeTurnId = null
-      turnActive = false
-      appServerItems.clear()
-      streamedAgentItems.clear()
-    }
-    return true
-  }
-
-  async function runAppServerReview(commandText) {
-    if (ended || aborted || stallGiveupRequested) return true
-    if (!await ensureAppServer()) return false
-    if (ended || aborted || stallGiveupRequested) return true
-    mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
-    turnActive = true
-    try {
-      stallReplaySafe = false
-      const started = await appServer.startReview({ threadId: sessionId, target: codexReviewTarget(commandText) })
-      activeTurnId = started?.turn?.id || started?.turnId
-      if (!activeTurnId) throw new Error('Codex review/start returned no turn id')
-      touchActivity()
-      if (aborted || ended) {
-        closeAppServerTurn(activeTurnId)
-        try { await appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }) } catch { /* boundary is already closed */ }
-        return true
-      }
-      const completed = await appServer.waitForTurn(activeTurnId)
-      closeAppServerTurn(completed?.turn?.id || activeTurnId)
-      const status = completed?.turn?.status
-      if (aborted) {
-        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
-      } else if (status === 'interrupted' && (stallRetryRequested || stallGiveupRequested)) {
-        // Watchdog-owned interruption; pump decides retry vs terminal giveup.
-      } else if (status === 'interrupted') {
-        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: completed?.turn?.durationMs, denials: 0, resultText: null })
-      } else if (status === 'failed') {
-        stallRetryRequested = false
-        pushMappedEvent({ type: 'turn.failed', message: completed?.turn?.error?.message || 'codex review failed' })
-      } else {
-        stallRetryRequested = false
-        pushMappedEvent({ type: 'turn.completed' })
-      }
-    } catch (error) {
-      appServerDisabled = true
-      appServerThreadReady = false
-      closeAppServerTurn(activeTurnId)
-      try { appServer?.end() } catch { /* noop */ }
-      appServer = null
-      if (!ended && !stallRetryRequested && !stallGiveupRequested) pushMappedEvent({ type: 'turn.failed', message: `codex review failed: ${error?.message || error}` })
-    } finally {
-      for (const state of streamedAgentItems.values()) {
-        if (!state.text) continue
-        relayEvent({ kind: 'assistant', blocks: [{ type: 'text', text: state.text }], parentToolUseId: null, replacesCid: state.cid })
-      }
-      activeTurnId = null
-      turnActive = false
-      appServerItems.clear()
-      streamedAgentItems.clear()
-    }
-    return true
-  }
-
-  async function runExec(prompt, options = {}) {
-    if (ended || aborted || stallGiveupRequested) return
-    // First turn: fresh exec. Later turns: resume THIS lane's captured thread.
-    // `--last` is process-global and can cross-wire two concurrently-active Codex
-    // lanes, so it is never safe in a multi-lane bridge.
-    let peer
-    try { peer = await ensureMcpHttp() }
-    catch (e) { note(`Thinkpool peer tools unavailable: ${e?.message || e}`) }
-    // Detach any App Server-owned MCP session before exec initializes its own.
-    // Cleanup of the old transport is deliberately asynchronous so a wedged
-    // close cannot consume Codex's 30-second required-MCP handshake window.
-    try { await peer?.handoff?.() }
-    catch (e) { note(`Thinkpool peer handoff failed: ${e?.message || e}`) }
-    const args = buildCodexExecArgs({
-      sessionId: turnNo === 0 ? null : sessionId,
-      model: activeModel,
-      effort: activeEffort,
-      sandbox,
-      approvalPolicy: modeConfig.approvalPolicy,
-      providerConfig,
-      mcpUrl: peer?.url,
-      writableDirs: codexExtraWritableDirsForMode(activeMode, sandbox, publishAccess.writableDirs),
-      images: Array.isArray(options.images) ? options.images : [],
-      prompt,
-    })
-
-    // Snapshot lifetime totals before the turn. The mapper subtracts this from
-    // the post-turn totals so result/accounting events contain this turn only.
-    mapper.setUsageBaseline(sessionId ? readCodexThreadUsage(sessionId) : null)
-
-    return new Promise((resolve) => {
-      // stdin: /dev/null (spike gotcha — codex blocks on stdin otherwise)
-      let stdinFd
-      try { stdinFd = fs.openSync('/dev/null', 'r') } catch { /* will inherit; best effort */ }
-      const opts = { cwd, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] }
-      if (stdinFd != null) opts.stdio = [stdinFd, 'pipe', 'pipe']
-
-      turnActive = true
-      stallReplaySafe = false
-      child = spawnImpl('codex', args, opts)
-      if (stdinFd != null) { try { fs.closeSync(stdinFd) } catch { /* child owns its duplicated fd */ } }
-
-      const nativeEventTypes = []
-      const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity })
-      rl.on('line', (line) => {
-        if (!line.trim()) return
-        let ev
-        try { ev = JSON.parse(line) } catch { return /* non-JSON progress line */
-        }
-        nativeEventTypes.push(ev.type)
-        if (ev.type === 'thread.started' && ev.thread_id) sessionId = sessionId || ev.thread_id
-        if (ev.type === 'turn.completed' || ev.type === 'turn.failed') {
-          sawTerminalResult = true
-          stallRetryRequested = false
-        }
-        pushMappedEvent(ev)
-      })
-      // stderr is codex's human progress channel; surface tail on failure only.
-      let stderrTail = ''
-      let sawTerminalResult = false
-      let settled = false
-      child.stderr.on('data', (d) => { stderrTail += d.toString(); if (stderrTail.length > 800) stderrTail = stderrTail.slice(-800) })
-
-      const finish = (code) => {
-        if (settled) return
-        settled = true
-        child = null
-        turnActive = false
-        const failureMessage = `codex exec exited ${code}${stderrTail ? ': ' + stderrTail.trim().slice(-300) : ''}`
-        const preTurnInitFailure = code !== 0 && code != null && !sawTerminalResult && codexExecFailedBeforeTurn({
-          stderr: stderrTail,
-          eventTypes: nativeEventTypes,
-        })
-        if (preTurnInitFailure && !aborted && !stallGiveupRequested) {
-          resolve({ preTurnInitFailure: true, message: failureMessage })
-          return
-        } else if ((stallRetryRequested || stallGiveupRequested) && !sawTerminalResult && !aborted) {
-          // Watchdog interruption: pump either replays once or has already
-          // published the terminal giveup boundary.
-        } else if (aborted && !sawTerminalResult) {
-          emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 1, durationMs: undefined, denials: 0, resultText: null })
-        } else if (!aborted && !sawTerminalResult && code !== 0 && code != null) {
-          emitTurnBoundary({ kind: 'error', message: failureMessage, recoverable: true })
-        }
-        resolve({ preTurnInitFailure: false })
-      }
-      child.on('error', (e) => {
-        if (settled) return
-        settled = true
-        child = null
-        if (!stallRetryRequested && !stallGiveupRequested) emitTurnBoundary({ kind: 'error', message: `codex failed to start: ${e.message}`, recoverable: true })
-        resolve({ preTurnInitFailure: false })
-      })
-      child.on('close', finish)
-    })
-  }
-
-  function pump() {
-    if (ended) return
-    const next = queue.shift()
-    if (!next) return
-    chain = chain.then(async () => {
-      armTurnLiveness()
-      // runExec sees turnNo===0 on the FIRST turn (fresh exec); increment only
-      // after, so subsequent turns resume this lane's captured thread id.
-      // Claude receives these through the Agent SDK's system-reminder path.
-      // Codex is one-shot per turn, so give it the same lane identity and live
-      // room awareness in a compact envelope before the person's text.
-      const fullReminder = usesFullThinkPoolReminder({ promptIndex: next.promptIndex, forceFull: next.forceFullReminder })
-      const prompt = buildCodexPrompt({
-        text: next.text,
-        terminalRolePrompt,
-        rolePrompt,
-        roomContext: () => selectRoomContext({ force: fullReminder }),
-        firstTurn: turnNo === 0,
-        promptIndex: next.promptIndex,
-        forceFullReminder: next.forceFullReminder,
-      })
-      const review = /^\s*\/review(?:\s|$)/i.test(String(next.text || ''))
-      let retryAttempt = false
-      let execInitRetryUsed = false
-      while (!ended && !aborted && !stallGiveupRequested) {
-        const usedAppServer = review
-          ? await runAppServerReview(next.text)
-          : await runAppServer(prompt, next.options)
-        if (!usedAppServer) {
-          if (review) {
-            stallRetryRequested = false
-            emitTurnBoundary({ kind: 'error', message: 'Codex review is unavailable without the tested App Server runtime.', recoverable: true })
-          } else {
-            // A watchdog interruption during cold App Server startup has no
-            // native turn to wait on. Treat the exec fallback itself as the one
-            // retry rather than accidentally granting a third attempt.
-            if (stallRetryRequested) {
-              stallRetryRequested = false
-              retryAttempt = true
-              armTurnLiveness({ retry: true })
-              emitRaw({ kind: 'note', text: 'retrying the stalled turn on a fresh connection' })
-            }
-            const outcome = await runExec(prompt, next.options)
-            if (outcome?.preTurnInitFailure) {
-              if (!execInitRetryUsed && !ended && !aborted && !stallGiveupRequested) {
-                execInitRetryUsed = true
-                armTurnLiveness({ retry: true })
-                emitRaw({ kind: 'note', text: 'Codex initialization failed before the turn started; retrying once with a fresh ThinkPool connection.' })
-                continue
-              }
-              emitTurnBoundary({ kind: 'error', message: outcome.message, recoverable: true })
-            }
-          }
-        }
-        if (stallRetryRequested && !retryAttempt && !stallGiveupRequested && !ended && !aborted) {
-          stallRetryRequested = false
-          retryAttempt = true
-          armTurnLiveness({ retry: true })
-          emitRaw({ kind: 'note', text: 'retrying the stalled turn on a fresh connection' })
-          continue
-        }
-        break
-      }
-      turnNo++
-      pump()
-    })
-  }
-
-  return {
-    get sessionId() { return sessionId },
-    get usageSnapshot() { return latestUsageSnapshot },
-    get turnActive() { return turnActive || compactActive },
-    get canSteer() { return !!(appServer && appServer.alive !== false && appServerThreadReady && !appServerDisabled) },
-    get started() { return turnNo > 0 || turnActive },
-    sendTurn(text, options = {}) {
-      if (ended) return false
-      // App Server stays resident between turns. Only gate when an idle turn
-      // would have to create a new host process (fresh/resumed cold lane or
-      // exec fallback after App Server failure). Steering an existing process
-      // and reading a restored transcript remain available under pressure.
-      if (!turnActive && queue.length === 0 && !appServerThreadReady && !child) {
-        const gate = typeof admitStart === 'function' ? admitStart() : { ok: true }
-        if (gate?.ok === false) {
-          relayEvent({ kind: 'error', message: gate.reason || 'Host memory is critically low. This Codex runtime was not started.', recoverable: true })
-          return false
-        }
-      }
-      const promptIndex = userPromptNo++
-      const thisTurnForceFull = forceFullReminder
-      forceFullReminder = isCodexCompactCommand(text) || /^\s*\/(?:reset|clear)\b/i.test(String(text || ''))
-      if (!turnActive && turnNo === 0 && prepareCwd) {
-        try { cwd = prepareCwd() || cwd } catch { /* keep original cwd */ }
-      }
-      if (turnActive && appServer && activeTurnId) {
-        // A delivered human steer is new work for the active model call; give it
-        // a fresh quiet window before declaring the transport stalled.
-        touchActivity()
-        const fullReminder = usesFullThinkPoolReminder({ promptIndex, forceFull: thisTurnForceFull })
-        const prompt = buildCodexPrompt({
-          text,
-          terminalRolePrompt,
-          rolePrompt,
-          roomContext: () => selectRoomContext({ force: fullReminder }),
-          promptIndex,
-          forceFullReminder: thisTurnForceFull,
-        })
-        const targetTurnId = activeTurnId
-        // Serialize authored follow-ups: parallel RPCs can complete out of order.
-        steerChain = steerChain.then(() => appServer.steer({ threadId: sessionId, turnId: targetTurnId, input: prompt, images: Array.isArray(options.images) ? options.images : [] }))
-          .catch((error) => {
-            // Retry only after an explicit server rejection or a synchronous
-            // pre-write failure. Timeout/close after write is delivery-uncertain;
-            // replaying it as a new turn can execute the same instruction twice.
-            if (error?.delivery === 'rejected' || error?.delivery === 'not_sent') {
-              queue.push({ text, options, promptIndex, forceFullReminder: thisTurnForceFull })
-              if (!turnActive && queue.length === 1) pump()
-            } else {
-              relayEvent({ kind: 'error', message: 'Codex steering delivery is uncertain; the message was not replayed automatically.', recoverable: true })
-            }
-          })
-        return true
-      }
-      queue.push({ text, options, promptIndex, forceFullReminder: thisTurnForceFull })
-      // Match Claude and Hermes: accepting an idle turn claims the lane before
-      // any cold App Server, MCP, or exec bootstrap. bridge.mjs announces
-      // synchronously after sendTurn(), so this is the edge that makes Thinking,
-      // Stop, and the tab spinner appear at dispatch time rather than at the
-      // first provider event many seconds later.
-      // Native compaction already owns that public busy edge. A human turn
-      // accepted during it stays queued without flipping the ordinary-turn
-      // latch; otherwise compactContext's post-bootstrap recheck mistakes the
-      // queued turn for an active one and abandons a compaction it already owns.
-      if (!turnActive && !compactActive) {
-        aborted = false
-        armTurnLiveness()
-      }
-      // start the pump if idle
-      if (queue.length === 1 && !compactActive) pump()
-      return true
-    },
-    abort() {
-      const activeChain = chain
-      const bootstrapOnly = turnActive && !activeTurnId && !child
-      aborted = true
-      stallRetryRequested = false
-      stallGiveupRequested = false
-      queue.length = 0
-      closeAppServerTurn(activeTurnId)
-      let interrupt = Promise.resolve()
-      if (appServer && activeTurnId) interrupt = appServer.interrupt({ threadId: sessionId, turnId: activeTurnId }).catch(() => {})
-      if (child) { try { child.kill('SIGTERM') } catch { /* noop */ } ; setTimeout(() => { try { child?.kill('SIGKILL') } catch { /* noop */ } }, 1500) }
-      else if (bootstrapOnly) {
-        // No native turn exists to produce a boundary. Close the optimistic
-        // accepted turn exactly once and let runAppServer's post-bootstrap
-        // aborted check discard the delayed startup.
-        emitTurnBoundary({ kind: 'result', subtype: 'aborted', sessionId, model: activeModel, costUsd: null, usage: null, numTurns: 0, durationMs: undefined, denials: 0, resultText: null })
-      }
-      // `code-turn` may already be queued behind Stop in Realtime. Resolve only
-      // after the interrupted native turn's chain has fully unwound; accepting a
-      // new turn earlier lets the old finally/result close the new lifecycle.
-      return interrupt.then(() => activeChain).catch(() => activeChain).then(() => {})
-    },
-    end() {
-      ended = true
-      turnActive = false
-      if (stallTimer) stallClearInterval(stallTimer)
-      relayEvent.cancel()
-      queue.length = 0
-      closeAppServerTurn(activeTurnId)
-      if (child) { try { child.kill() } catch { /* noop */ } }
-      try { appServer?.end() } catch { /* noop */ }
-      void mcpHttpPromise?.then((h) => h.close()).catch(() => {})
-    },
-    setModel(nextModel) {
-      if (!nextModel || turnActive) return false
-      activeModel = String(nextModel)
-      mapper.setModel(activeModel)
-      return true
-    },
-    setMode(nextMode) {
-      if (turnActive || !CODEX_MODE_CONFIG[nextMode]) return false
-      activeMode = nextMode
-      modeConfig = codexConfigForMode(activeMode)
-      sandbox = modeConfig.sandbox
-      // A mode change deliberately starts a fresh native thread so no prior
-      // rollout can carry stale permission state; ThinkPool keeps the lane log.
-      sessionId = null
-      turnNo = 0
-      latestUsageSnapshot = null
-      appServerThreadReady = false
-      return true
-    },
-    setEffort(nextEffort) {
-      if (turnActive || !EFFORT_LEVELS.has(nextEffort)) return false
-      activeEffort = nextEffort
-      relayEvent({ kind: 'effort', level: activeEffort })
-      return true
-    },
-    clearContext() {
-      if (turnActive) return false
-      sessionId = null
-      turnNo = 0
-      latestUsageSnapshot = null
-      appServerThreadReady = false
-      return true
-    },
-    async compactContext() {
-      if (turnActive || compactActive) return false
-      // A Stop latch belongs to the turn it cancelled. sendTurn clears it when
-      // accepting new work, but /compact enters through this direct control path.
-      // Leaving it set makes appServerNotification discard the real
-      // turn/started event, then the five-second waiter falsely declares failure
-      // while Codex continues compacting the old thread in the background.
-      aborted = false
-      compactActive = true
-      let startTimer = null
-      let compactAccepted = false
-      try {
-        const readyAppServer = await ensureAppServer()
-        // compactActive claims the lane before bootstrap, so sendTurn queues
-        // behind us. An independently active ordinary turn still wins safely.
-        if (!readyAppServer || turnActive) return false
-        const compactTurn = new Promise((resolve, reject) => {
-          startTimer = setTimeout(() => {
-            compactStartWaiter = null
-            reject(new Error('Codex did not start the compaction turn'))
-          }, 5000)
-          compactStartWaiter = { resolve, reject }
-        })
-        await appServer.compact({ threadId: sessionId })
-        compactAccepted = true
-        const turnId = await compactTurn
-        if (startTimer) clearTimeout(startTimer)
-        const completed = await appServer.waitForTurn(turnId)
-        closeAppServerTurn(completed?.turn?.id || turnId)
-        const status = completed?.turn?.status
-        if (status === 'completed') return true
-        throw new Error(completed?.turn?.error?.message || `compaction ${status || 'failed'}`)
-      } catch (error) {
-        // Once thread/compact/start was accepted, replaying via a bounded-recap
-        // reset is unsafe: the native compaction may still complete (the exact
-        // production failure this guard closes). Preserve the existing thread
-        // and report uncertainty instead of executing a second compaction path.
-        if (compactAccepted || !['rejected', 'not_sent'].includes(error?.delivery)) {
-          note(`Native Codex compaction status is uncertain; existing context was preserved: ${error?.message || error}`)
-          return null
-        }
-        note(`Native Codex compaction unavailable; using bounded recap fallback: ${error?.message || error}`)
-        return false
-      } finally {
-        if (startTimer) clearTimeout(startTimer)
-        compactStartWaiter = null
-        compactActive = false
-        // A human turn accepted while compaction owned the App Server is queued,
-        // not started concurrently. Hand it to the ordinary serialized pump now.
-        if (queue.length) pump()
-      }
-    },
-    async accountUsage() {
-      if (!await ensureAppServer()) return null
-      const [usage, limits] = await Promise.all([
-        appServer.accountUsage().catch(() => null),
-        appServer.accountRateLimits().catch(() => null),
-      ])
-      return { usage, limits }
-    },
-  }
-}
+import{execFileSync as e,spawn as t}from"node:child_process";import r from"node:fs";import n from"node:os";import o from"node:path";import s from"node:readline";import{buildCodexAppServerArgs as a,codexAppServerGate as i,createCodexAppServer as l}from"./codex-app-server.mjs";import{CodexEventMapper as u}from"./codex-event-mapper.mjs";import{startCodexMcpHttp as d}from"./codex-mcp-http.mjs";import{CODEX_THINKPOOL_FIRST_TURN_PREAMBLE as c,buildThinkPoolTurnGuidance as p,createRoomContextSelector as m,usesFullThinkPoolReminder as f}from"./thinkpool-room-prompt.mjs";import{questionAnswerResponse as h}from"./question-response.mjs";import{codexReviewTarget as x,isCodexCompactCommand as g}from"./codex-commands.mjs";import{createCumulativeEventRelay as y}from"./cumulative-event-relay.mjs";import{stallDecision as v,stallEvent as b}from"./turn-stall.mjs";const w=new Set(["read-only","workspace-write","danger-full-access"]);export const EFFORT_LEVELS=new Set(["low","medium","high","xhigh","max"]);export const CODEX_MODE_CONFIG={default:{sandbox:"workspace-write",approvalPolicy:"untrusted"},acceptEdits:{sandbox:"workspace-write",approvalPolicy:"on-request"},plan:{sandbox:"read-only",approvalPolicy:"never"},review:{sandbox:"read-only",approvalPolicy:"never"},bypassPermissions:{sandbox:"danger-full-access",approvalPolicy:"never"}};export function codexConfigForMode(e){return CODEX_MODE_CONFIG[e]||CODEX_MODE_CONFIG.default}export function codexDefaultCollaborationMode(e,t){return e?{mode:"default",settings:{model:String(e),reasoning_effort:EFFORT_LEVELS.has(t)?t:null,developer_instructions:null}}:null}export function defaultModeForRuntime(e){return"codex"===e?"bypassPermissions":"default"}export function codexWritableDirsForSandbox(e,t=[]){return"read-only"===normalizeCodexSandbox(e)?[]:t}export function codexExtraWritableDirsForMode(e,t,r=[]){return"review"===e?[]:codexWritableDirsForSandbox(t,r)}export function readCodexDefaultModel({home:e=process.env.CODEX_HOME||o.join(n.homedir(),".codex"),fsImpl:t=r}={}){try{const r=t.readFileSync(o.join(e,"config.toml"),"utf8").split(/^\s*\[/m,1)[0].match(/^\s*model\s*=\s*["']([^"']+)["']\s*(?:#.*)?$/m);return r?.[1]?.trim()||null}catch{return null}}export function readCodexModels({home:e=process.env.CODEX_HOME||o.join(n.homedir(),".codex"),fsImpl:t=r}={}){try{const r=JSON.parse(t.readFileSync(o.join(e,"models_cache.json"),"utf8"));return(Array.isArray(r?.models)?r.models:[]).filter(e=>e?.slug&&"hide"!==e.visibility).sort((e,t)=>(Number(e.priority)||999)-(Number(t.priority)||999)).map(e=>({value:e.slug,displayName:e.display_name||e.slug,description:e.description||""}))}catch{return[]}}const k=new Map;function I(e,{home:t,fsImpl:r}){if(!e)return null;const n=`${t}\0${e}`,s=k.get(n);if(s)return s;const a=o.join(t,"sessions");try{const t=`${e}.jsonl`,s=r.readdirSync(a,{recursive:!0,withFileTypes:!0}).find(e=>e.isFile()&&e.name.endsWith(t));if(!s)return null;const i=o.join(s.parentPath||s.path||a,s.name);return k.set(n,i),i}catch{return null}}export function codexThreadCanResume(e,{home:t=process.env.CODEX_HOME||o.join(n.homedir(),".codex"),fsImpl:s=r}={}){if(!e)return!1;const a=I(e,{home:t,fsImpl:s});if(!a)return!0;try{return Number(s.statSync(a).size)>0}catch{return!0}}export function readCodexThreadUsage(e,{home:t=process.env.CODEX_HOME||o.join(n.homedir(),".codex"),fsImpl:s=r,tailBytes:a=4194304}={}){const i=I(e,{home:t,fsImpl:s});if(!i)return null;let l;try{const e=Number(s.statSync(i).size)||0,t=Math.min(e,Math.max(65536,a)),r=Buffer.alloc(t);l=s.openSync(i,"r"),s.readSync(l,r,0,t,e-t);const n=r.toString("utf8").split("\n");for(let e=n.length-1;e>=0;e--){let t;try{t=JSON.parse(n[e])}catch{continue}if("token_count"!==t?.payload?.type||!t.payload.info)continue;const r=t.payload.info,o=r.last_token_usage||{},s=r.total_token_usage||{},a=Number(o.total_tokens),i=Number(r.model_context_window);return!Number.isFinite(a)||a<0||!Number.isFinite(i)||i<=0?null:{context:{used:Math.floor(a),max:Math.floor(i)},total:{input_tokens:Math.max(0,Number(s.input_tokens)||0),cached_input_tokens:Math.max(0,Number(s.cached_input_tokens)||0),output_tokens:Math.max(0,Number(s.output_tokens)||0)},rateLimits:t.payload.rate_limits||null}}}catch{return null}finally{if(null!=l)try{s.closeSync(l)}catch{}}return null}export function codexUsageSnapshotFromAppServer(e){const t=Number(e?.last?.totalTokens),r=Number(e?.modelContextWindow);if(!Number.isFinite(t)||t<0||!Number.isFinite(r)||r<=0)return null;const n=e?.total||{};return{context:{used:Math.floor(t),max:Math.floor(r)},total:{input_tokens:Math.max(0,Number(n.inputTokens)||0),cached_input_tokens:Math.max(0,Number(n.cachedInputTokens)||0),output_tokens:Math.max(0,Number(n.outputTokens)||0)}}}export function normalizeCodexSandbox(e){return w.has(e)?e:"workspace-write"}export function codexPublishAccess({cwd:t,env:r=process.env,tmpdir:s=n.tmpdir(),execFile:a=e}={}){const i=[];try{const e=String(a("git",["rev-parse","--git-common-dir"],{cwd:t,encoding:"utf8"})||"").trim();if(e){const r=o.resolve(t,e),n=o.resolve(t);r===n||r.startsWith(n+o.sep)||i.push(r)}}catch{}return{writableDirs:i,env:{...r,NPM_CONFIG_CACHE:o.join(s,"thinkpool-npm-cache")}}}export const CODEX_ROOM_CASCADE_REMINDER=["THINKPOOL ROOM ROLE ENFORCEMENT: obey the authoritative TERMINAL ROLE above. A person-authored request for a new, separate, independent, top-level, or main terminal uses open_main_terminal — NEVER spawn_terminal — even for ordinary work or a handoff. If the wording includes new or separate terminal, main-terminal routing wins. Use spawn_terminal only for agent-decided bounded worker slices or when the person explicitly asks for a worker, sub-terminal, Ensemble lane, or delegated slice. If open_main_terminal is unavailable, say so; never substitute an Ensemble child. Leaf, worker, Side, and managed Flow lanes work directly and must not delegate. Never use hidden in-process subagents."].join(" ");export function buildCodexPrompt({text:e,terminalRolePrompt:t,rolePrompt:r,roomContext:n,firstTurn:o=!1,promptIndex:s=0,forceFullReminder:a=!1}){const i="function"==typeof n?n():n,l=f({promptIndex:s,forceFull:a}),u=[o?c:"",l?t:"",p({text:e,promptIndex:s,forceFull:a}),l?r||CODEX_ROOM_CASCADE_REMINDER:"",i].map(e=>String(e||"").trim()).filter(Boolean);return u.length?`<thinkpool-context>\n${u.join("\n\n")}\n</thinkpool-context>\n\n${String(e??"")}`:String(e??"")}export function buildCodexExecArgs({sessionId:e,model:t,effort:r,sandbox:n,approvalPolicy:s="untrusted",providerConfig:a,mcpUrl:i,writableDirs:l=[],images:u=[],prompt:d}){const c=normalizeCodexSandbox(n),p=e?["exec","resume","--json","--skip-git-repo-check",..."danger-full-access"===c?["--dangerously-bypass-approvals-and-sandbox"]:["-c",`sandbox_mode="${c}"`]]:["exec","--json","--sandbox",c,"--skip-git-repo-check"];if(t&&p.push("-m",t),p.push("-c",`approval_policy="${s}"`),EFFORT_LEVELS.has(r)&&p.push("-c",`model_reasoning_effort="${r}"`),a&&p.push("-c",a),!e)for(const e of l)p.push("--add-dir",e);i&&(p.push("-c",`mcp_servers.thinkpool.url=${JSON.stringify(i)}`),p.push("-c","mcp_servers.thinkpool.required=true"));let m=!1;for(const e of u)o.isAbsolute(String(e||""))&&(p.push("--image",String(e)),m=!0);return m&&p.push("--"),e&&p.push(e),p.push(String(d??"")),p}export function codexExecFailedBeforeTurn({stderr:e="",eventTypes:t=[]}={}){if((Array.isArray(t)?t.map(e=>String(e||"")):[]).some(e=>e&&"thread.started"!==e))return!1;const r=String(e||"");return/timed out handshaking with MCP server/i.test(r)||/thread\/resume failed/i.test(r)&&/failed to initialize session/i.test(r)}const _=/\brm\s+\S|\brmdir\s+\S|\bgit\s+(push\s+(-f|--force)|reset\s+--hard|clean\s+-[a-z]*f)|\bdrop\s+(table|database)\b|\b(mkfs|dd)\b|\bsudo\b|>\s*\/dev\/|\bchmod\s+-R|\bchown\s+-R|\bkillall\b|\btruncate\b/i;export function codexApprovalCard(e,t={},r=null){const n=String(t.approvalId||t.itemId||`${t.turnId||"turn"}:${e}`);if("item/tool/requestUserInput"===e){const e=Array.isArray(t.questions)?t.questions:[];return{id:n,toolName:"AskUserQuestion",input:{questions:e},risk:"ask",questions:e,asker:"Codex",answerFormat:"codex",...Number.isFinite(t.autoResolutionMs)&&t.autoResolutionMs>0?{autoResolutionMs:t.autoResolutionMs}:{}}}if("item/commandExecution/requestApproval"===e){const e=t.command||r?.command||"";return{id:n,toolName:"Bash",input:{command:e,cwd:t.cwd||r?.cwd||"",...t.reason?{reason:t.reason}:{}},risk:_.test(e)?"high":"medium"}}if("item/fileChange/requestApproval"===e){const e=Array.isArray(r?.changes)?r.changes:[],o=e[0]||{};return{id:n,toolName:e.length>1?"MultiEdit":"add"===o.kind?"Write":"Edit",input:e.length>1?{edits:e.map(e=>({file_path:e.path||"",path:e.path||"",kind:e.kind||"update"})),...t.reason?{reason:t.reason}:{}}:{file_path:o.path||t.grantRoot||"",path:o.path||t.grantRoot||"",kind:o.kind||"update",...t.reason?{reason:t.reason}:{}},risk:"medium"}}return null}export function codexApprovalResponse(e){return{decision:"always"===e?"acceptForSession":"allow"===e?"accept":"decline"}}export function codexUserInputResponse(e,t=[]){return h(e,t)}function M(e){if(!e||"object"!=typeof e)return e;const t={...e};switch(e.type){case"agentMessage":return{...t,type:"agent_message"};case"commandExecution":return{...t,type:"command_execution",aggregated_output:e.aggregatedOutput||"",exit_code:e.exitCode};case"fileChange":return{...t,type:"file_change"};case"webSearch":return{...t,type:"web_search"};case"mcpToolCall":return{...t,type:"mcp_tool_call",arguments:e.arguments||{},result:e.result,error:e.error};case"reasoning":return{...t,type:"reasoning",text:[...e.summary||[],...e.content||[]].join("\n")};default:return t}}export function startCodexSession({cwd:e,model:c,effort:p="high",resume:h,env:w,sandbox:k,mode:I="default",onEvent:_,providerConfig:S,terminalRolePrompt:C,rolePrompt:E,roomContext:T,mcpServers:F,prepareCwd:O=null,requestPermission:R,appServerGate:N=i,appServerFactory:P=l,mcpHttpFactory:A=d,spawnImpl:U=t,admitStart:D=null,stallOptions:$={}}){let j=CODEX_MODE_CONFIG[I]?I:"default",L=codexConfigForMode(j);k=normalizeCodexSandbox(k||L.sandbox);const q=codexPublishAccess({cwd:e,env:{...process.env,...w||{}}}),X=q.env,G=h||null,z=!G||codexThreadCanResume(G,{home:X.CODEX_HOME||o.join(n.homedir(),".codex")});let W=z?G:null,B=W?1:0,H=0,V=!0;const J=m(T);let K=null,Q=!1,Y=!1,Z=!1;const ee="function"==typeof $.now?$.now:Date.now,te="function"==typeof $.setInterval?$.setInterval:setInterval,re="function"==typeof $.clearInterval?$.clearInterval:clearInterval,ne=Number.isFinite($.stallMs)?Math.max(1,Number($.stallMs)):Math.max(3e4,parseInt(X.TP_STALL_MS,10)||9e4),oe=Number.isFinite($.forceStopMs)?Math.max(ne,Number($.forceStopMs)):Math.max(3*ne,parseInt(X.TP_FORCE_STOP_MS,10)||3e5),se=Number.isFinite($.intervalMs)?Math.max(1,Number($.intervalMs)):5e3;let ae=ee(),ie=!1,le=!1,ue=!1,de=!1,ce=!0,pe=0,me=null,fe=c||null,he=EFFORT_LEVELS.has(p)?p:"high",xe=W?readCodexThreadUsage(W):null,ge=null;const ye=N({env:X});let ve=!ye.enabled,be=null,we=!1,ke=null,Ie=null,_e=!1;const Me=new Set,Se=new Map,Ce=new Map;let Ee=Promise.resolve(),Te=Promise.resolve();const Fe=[],Oe=y(e=>{try{_?.(e)}catch{}}),Re=()=>{ae=ee(),ie=!1},Ne=e=>{Re(),Oe(e)};Ne.cancel=()=>Oe.cancel();const Pe=new u({onEvent:Ne,model:c||null,usageSnapshotForSession:e=>{const t=readCodexThreadUsage(e);return t&&(xe=t),t||xe}}),Ae=e=>{"turn.completed"!==e?.type&&"turn.failed"!==e?.type||(Z=!1),Pe.push(e)},Ue=e=>{Z=!1,Ne(e)},De=({retry:e=!1}={})=>{Z=!0,ae=ee(),ie=!1,ue=!1,de=!1,ce=!0,e||(le=!1)},$e=e=>Ne({kind:"note",text:e}),je=(e=ke)=>{const t=String(e||"");if(t)for(Me.add(t);Me.size>64;)Me.delete(Me.values().next().value)},Le=(e={})=>{const t=String(e.turnId||"");return!(!t||Y||Q||Me.has(t)||t!==String(ke||""))};async function qe(){const e=F?.thinkpool;return e?(ge||(ge=A({sdkServer:e})),ge):null}function Xe(e,t={}){if("thread/tokenUsage/updated"===e){if(t.threadId&&W&&String(t.threadId)!==String(W))return;const e=codexUsageSnapshotFromAppServer(t.tokenUsage);if(!e)return;if(xe=e,_e){const{used:t,max:r}=e.context;Ne({kind:"usage",ctx:{used:t,max:r,pct:Math.min(100,Math.max(0,Math.round(t/r*100))),over:t>r,model:fe}})}return}if("turn/started"===e&&t.turn?.id){const e=String(t.turn.id);if(Y||Q)return void je(e);if(Ie){const t=Ie;return Ie=null,void t.resolve(e)}return ke||(ke=e),void Re()}if("turn/plan/updated"!==e&&"item/agentMessage/delta"!==e&&"item/started"!==e&&"item/completed"!==e&&"error"!==e||Le(t)){if(Re(),"turn/plan/updated"===e){const e=(Array.isArray(t.plan)?t.plan:[]).map(({step:e,status:t})=>({content:e||"",activeForm:e||"",status:"inProgress"===t?"in_progress":"completed"===t?"completed":"pending"})).filter(e=>e.content);return void Ne({kind:"assistant",blocks:[{type:"tool_use",id:`codex-plan:${t.turnId||"active"}`,name:"TodoWrite",input:{todos:e}}],parentToolUseId:null})}if("item/agentMessage/delta"===e){if(!t.delta)return;const e=t.itemId||`turn:${t.turnId||ke||"active"}`,r=Ce.get(e)||{cid:`codex-stream:${W||"thread"}:${e}`,text:""};return r.text+=String(t.delta),Ce.set(e,r),void Ne({kind:"assistant_stream",cid:r.cid,text:r.text,itemId:e,streaming:!0})}if("item/started"===e||"item/completed"===e){const r=t.item;if(!r)return;if("item/started"===e&&Se.set(r.id,r),"item/completed"===e&&(Se.set(r.id,r),"agentMessage"===r.type&&Ce.has(r.id))){const e=Ce.get(r.id);return Ce.delete(r.id),void Ne({kind:"assistant",blocks:[{type:"text",text:r.text||e.text}],parentToolUseId:null,replacesCid:e.cid})}return void Ae({type:"item/started"===e?"item.started":"item.completed",item:M(r)})}if("error"===e){const e=t.error?.message||t.message||"codex app-server error";Ae({type:"error",message:e})}}}async function Ge(e,t={}){if(!Le(t))return"item/tool/requestUserInput"===e?{answers:{}}:{decision:"decline"};const r=codexApprovalCard(e,t,Se.get(t.itemId));if(!r)throw new Error(`Unsupported Codex App Server request: ${e}`);let n="deny";pe++;try{n=await(R?.(r))}catch{}finally{pe=Math.max(0,pe-1),Re()}return"item/tool/requestUserInput"===e?codexUserInputResponse(n,r.questions):codexApprovalResponse(n)}async function ze(){if(ve)return!1;if(!1===be?.alive)return we=!1,ve=!0,!1;if(be&&we)return!0;let t;try{t=await qe()}catch(e){$e(`Thinkpool peer tools unavailable: ${e?.message||e}`)}try{return be||(be=P({cwd:e,env:X,args:a({providerConfig:S,mcpUrl:t?.url,writableDirs:codexExtraWritableDirsForMode(j,k,q.writableDirs)}),onNotification:Xe,onServerRequest:Ge,onClose:e=>{Y||ve||(we=!1,ve=!0,$e(`Codex App Server closed; later turns will use codex exec: ${e?.message||e}`))}}),await be.start(),Re()),W=await be.startThread({threadId:B>0?W:null,cwd:e,model:fe,sandbox:k,approvalPolicy:L.approvalPolicy,config:{"features.default_mode_request_user_input":!0}}),Re(),t?.url&&(await be.waitForMcpServer({threadId:W,name:"thinkpool"}),Re()),we=!0,Ae({type:"thread.started",thread_id:W}),!0}catch{ve=!0;try{be?.end()}catch{}return be=null,we=!1,!1}}function We({force:e=!1}={}){const t=be,r=ke;if(t&&e){je(r),ve=!0,we=!1;try{t.end()}catch{}be===t&&(be=null)}else if(t&&r)je(r),Promise.resolve(t.interrupt({threadId:W,turnId:r})).catch(()=>{ve=!0,we=!1;try{t.end()}catch{}be===t&&(be=null)});else if(t){ve=!0,we=!1;try{t.end()}catch{}be===t&&(be=null)}if(K){const e=K;try{e.kill("SIGTERM")}catch{}setTimeout(()=>{if(K===e)try{e.kill("SIGKILL")}catch{}},1500)}}async function Be(e,t={}){if(Y||Q||de)return!0;if(!await ze())return!1;if(Y||Q||de)return!0;Pe.setUsageBaseline(W?readCodexThreadUsage(W):null),Z=!0;try{if(ce=!1,ke=await be.startTurn({threadId:W,input:e,images:Array.isArray(t.images)?t.images:[],model:fe,effort:he,approvalPolicy:L.approvalPolicy,collaborationMode:codexDefaultCollaborationMode(fe,he)}),Re(),Q||Y){je(ke);try{await be.interrupt({threadId:W,turnId:ke})}catch{}return!0}const r=await be.waitForTurn(ke);je(r?.turn?.id||ke);const n=r?.turn?.status;Q?Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:r?.turn?.durationMs,denials:0,resultText:null}):"interrupted"===n&&(ue||de)||("interrupted"===n?Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:r?.turn?.durationMs,denials:0,resultText:null}):"failed"===n?(ue=!1,Ae({type:"turn.failed",message:r?.turn?.error?.message||"codex turn failed"})):(ue=!1,Ae({type:"turn.completed"})))}catch(e){ve=!0,we=!1,je(ke);try{be?.end()}catch{}be=null,Y||ue||de||Ae({type:"turn.failed",message:`codex app-server turn failed: ${e?.message||e}`})}finally{for(const e of Ce.values())e.text&&Ne({kind:"assistant",blocks:[{type:"text",text:e.text}],parentToolUseId:null,replacesCid:e.cid});ke=null,Z=!1,Se.clear(),Ce.clear()}return!0}async function He(e){if(Y||Q||de)return!0;if(!await ze())return!1;if(Y||Q||de)return!0;Pe.setUsageBaseline(W?readCodexThreadUsage(W):null),Z=!0;try{ce=!1;const t=await be.startReview({threadId:W,target:x(e)});if(ke=t?.turn?.id||t?.turnId,!ke)throw new Error("Codex review/start returned no turn id");if(Re(),Q||Y){je(ke);try{await be.interrupt({threadId:W,turnId:ke})}catch{}return!0}const r=await be.waitForTurn(ke);je(r?.turn?.id||ke);const n=r?.turn?.status;Q?Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:r?.turn?.durationMs,denials:0,resultText:null}):"interrupted"===n&&(ue||de)||("interrupted"===n?Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:r?.turn?.durationMs,denials:0,resultText:null}):"failed"===n?(ue=!1,Ae({type:"turn.failed",message:r?.turn?.error?.message||"codex review failed"})):(ue=!1,Ae({type:"turn.completed"})))}catch(e){ve=!0,we=!1,je(ke);try{be?.end()}catch{}be=null,Y||ue||de||Ae({type:"turn.failed",message:`codex review failed: ${e?.message||e}`})}finally{for(const e of Ce.values())e.text&&Ne({kind:"assistant",blocks:[{type:"text",text:e.text}],parentToolUseId:null,replacesCid:e.cid});ke=null,Z=!1,Se.clear(),Ce.clear()}return!0}async function Ve(t,n={}){if(Y||Q||de)return;let o;try{o=await qe()}catch(e){$e(`Thinkpool peer tools unavailable: ${e?.message||e}`)}try{await(o?.handoff?.())}catch(e){$e(`Thinkpool peer handoff failed: ${e?.message||e}`)}const a=buildCodexExecArgs({sessionId:0===B?null:W,model:fe,effort:he,sandbox:k,approvalPolicy:L.approvalPolicy,providerConfig:S,mcpUrl:o?.url,writableDirs:codexExtraWritableDirsForMode(j,k,q.writableDirs),images:Array.isArray(n.images)?n.images:[],prompt:t});return Pe.setUsageBaseline(W?readCodexThreadUsage(W):null),new Promise(t=>{let n;try{n=r.openSync("/dev/null","r")}catch{}const o={cwd:e,env:X,stdio:["ignore","pipe","pipe"]};if(null!=n&&(o.stdio=[n,"pipe","pipe"]),Z=!0,ce=!1,K=U("codex",a,o),null!=n)try{r.closeSync(n)}catch{}const i=[];s.createInterface({input:K.stdout,crlfDelay:1/0}).on("line",e=>{if(!e.trim())return;let t;try{t=JSON.parse(e)}catch{return}i.push(t.type),"thread.started"===t.type&&t.thread_id&&(W=W||t.thread_id),"turn.completed"!==t.type&&"turn.failed"!==t.type||(u=!0,ue=!1),Ae(t)});let l="",u=!1,d=!1;K.stderr.on("data",e=>{l+=e.toString(),l.length>800&&(l=l.slice(-800))}),K.on("error",e=>{d||(d=!0,K=null,ue||de||Ue({kind:"error",message:`codex failed to start: ${e.message}`,recoverable:!0}),t({preTurnInitFailure:!1}))}),K.on("close",e=>{if(d)return;d=!0,K=null,Z=!1;const r=`codex exec exited ${e}${l?": "+l.trim().slice(-300):""}`;0===e||null==e||u||!codexExecFailedBeforeTurn({stderr:l,eventTypes:i})||Q||de?((!ue&&!de||u||Q)&&(Q&&!u?Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:void 0,denials:0,resultText:null}):Q||u||0===e||null==e||Ue({kind:"error",message:r,recoverable:!0})),t({preTurnInitFailure:!1})):t({preTurnInitFailure:!0,message:r})})})}function Je(){if(Y)return;const e=Fe.shift();e&&(Te=Te.then(async()=>{De();const t=f({promptIndex:e.promptIndex,forceFull:e.forceFullReminder}),r=buildCodexPrompt({text:e.text,terminalRolePrompt:C,rolePrompt:E,roomContext:()=>J({force:t}),firstTurn:0===B,promptIndex:e.promptIndex,forceFullReminder:e.forceFullReminder}),n=/^\s*\/review(?:\s|$)/i.test(String(e.text||""));let o=!1,s=!1;for(;!Y&&!Q&&!de;){if(!(n?await He(e.text):await Be(r,e.options)))if(n)ue=!1,Ue({kind:"error",message:"Codex review is unavailable without the tested App Server runtime.",recoverable:!0});else{ue&&(ue=!1,o=!0,De({retry:!0}),Oe({kind:"note",text:"retrying the stalled turn on a fresh connection"}));const t=await Ve(r,e.options);if(t?.preTurnInitFailure){if(!(s||Y||Q||de)){s=!0,De({retry:!0}),Oe({kind:"note",text:"Codex initialization failed before the turn started; retrying once with a fresh ThinkPool connection."});continue}Ue({kind:"error",message:t.message,recoverable:!0})}}if(!ue||o||de||Y||Q)break;ue=!1,o=!0,De({retry:!0}),Oe({kind:"note",text:"retrying the stalled turn on a fresh connection"})}B++,Je()}))}return G&&!z&&queueMicrotask(()=>$e("The stopped Codex turn had no resumable context; continuing in a fresh thread.")),["0","false","off"].includes(String(X.TP_CODEX_APP_SERVER||"").trim().toLowerCase())||ye.enabled||queueMicrotask(()=>$e(`Codex App Server disabled: ${ye.reason}`)),me=te(()=>{const e=ee()-ae,t=v({turnActive:Z,awaitingUser:pe,quietMs:e,stallMs:ne,forceStopMs:oe,stalledSent:ie,stallRetried:le});if("none"===t)return;if("retry"===t&&!ce)return de=!0,ue=!1,Oe({kind:"error",recoverable:!0,message:"Codex stopped responding after the turn began. The transport was stopped, but the prompt was not replayed automatically."}),Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:void 0,denials:0,resultText:null}),void We({force:!0});const r=b(t,e);if(r&&Oe(r),"status"!==t){if("retry"===t)return le=!0,ue=!0,ae=ee(),ie=!1,void We();de=!0,ue=!1,Fe.length=0,Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:1,durationMs:void 0,denials:0,resultText:null}),We({force:!0})}else ie=!0},se),me.unref?.(),{get sessionId(){return W},get usageSnapshot(){return xe},get turnActive(){return Z||_e},get canSteer(){return!(!be||!1===be.alive||!we||ve)},get started(){return B>0||Z},sendTurn(t,r={}){if(Y)return!1;if(!Z&&0===Fe.length&&!we&&!K){const e="function"==typeof D?D():{ok:!0};if(!1===e?.ok)return Ne({kind:"error",message:e.reason||"Host memory is critically low. This Codex runtime was not started.",recoverable:!0}),!1}const n=H++,o=V;if(V=g(t)||/^\s*\/(?:reset|clear)\b/i.test(String(t||"")),!Z&&0===B&&O)try{e=O()||e}catch{}if(Z&&be&&ke){Re();const e=f({promptIndex:n,forceFull:o}),s=buildCodexPrompt({text:t,terminalRolePrompt:C,rolePrompt:E,roomContext:()=>J({force:e}),promptIndex:n,forceFullReminder:o}),a=ke;return Ee=Ee.then(()=>be.steer({threadId:W,turnId:a,input:s,images:Array.isArray(r.images)?r.images:[]})).catch(e=>{"rejected"===e?.delivery||"not_sent"===e?.delivery?(Fe.push({text:t,options:r,promptIndex:n,forceFullReminder:o}),Z||1!==Fe.length||Je()):Ne({kind:"error",message:"Codex steering delivery is uncertain; the message was not replayed automatically.",recoverable:!0})}),!0}return Fe.push({text:t,options:r,promptIndex:n,forceFullReminder:o}),Z||_e||(Q=!1,De()),1!==Fe.length||_e||Je(),!0},abort(){const e=Te,t=Z&&!ke&&!K;Q=!0,ue=!1,de=!1,Fe.length=0,je(ke);let r=Promise.resolve();if(be&&ke&&(r=be.interrupt({threadId:W,turnId:ke}).catch(()=>{})),K){try{K.kill("SIGTERM")}catch{}setTimeout(()=>{try{K?.kill("SIGKILL")}catch{}},1500)}else t&&Ue({kind:"result",subtype:"aborted",sessionId:W,model:fe,costUsd:null,usage:null,numTurns:0,durationMs:void 0,denials:0,resultText:null});return r.then(()=>e).catch(()=>e).then(()=>{})},end(){if(Y=!0,Z=!1,me&&re(me),Ne.cancel(),Fe.length=0,je(ke),K)try{K.kill()}catch{}try{be?.end()}catch{}ge?.then(e=>e.close()).catch(()=>{})},setModel:e=>!(!e||Z||(fe=String(e),Pe.setModel(fe),0)),setMode:e=>!(Z||!CODEX_MODE_CONFIG[e]||(j=e,L=codexConfigForMode(j),k=L.sandbox,W=null,B=0,xe=null,we=!1,0)),setEffort:e=>!(Z||!EFFORT_LEVELS.has(e)||(he=e,Ne({kind:"effort",level:he}),0)),clearContext:()=>!Z&&(W=null,B=0,xe=null,we=!1,!0),async compactContext(){if(Z||_e)return!1;Q=!1,_e=!0;let e=null,t=!1;try{if(!await ze()||Z)return!1;const r=new Promise((t,r)=>{e=setTimeout(()=>{Ie=null,r(new Error("Codex did not start the compaction turn"))},5e3),Ie={resolve:t,reject:r}});await be.compact({threadId:W}),t=!0;const n=await r;e&&clearTimeout(e);const o=await be.waitForTurn(n);je(o?.turn?.id||n);const s=o?.turn?.status;if("completed"===s)return!0;throw new Error(o?.turn?.error?.message||`compaction ${s||"failed"}`)}catch(e){return t||!["rejected","not_sent"].includes(e?.delivery)?($e(`Native Codex compaction status is uncertain; existing context was preserved: ${e?.message||e}`),null):($e(`Native Codex compaction unavailable; using bounded recap fallback: ${e?.message||e}`),!1)}finally{e&&clearTimeout(e),Ie=null,_e=!1,Fe.length&&Je()}},async accountUsage(){if(!await ze())return null;const[e,t]=await Promise.all([be.accountUsage().catch(()=>null),be.accountRateLimits().catch(()=>null)]);return{usage:e,limits:t}}}}