@vtxmacro/cli 2026.9.59 → 2026.9.61

package/bin/vtx-managed-codex.js

@@ -0,0 +1,3125 @@
+#!/usr/bin/env node
+
+// lib/inference-host/managed-codex-wrapper.ts
+import { spawn as spawn3 } from "node:child_process";
+import { createInterface as createInterface2 } from "node:readline";
+import { isAbsolute as isAbsolute3 } from "node:path";
+
+// lib/inference-host/codex-app-server.ts
+import { spawn as spawn2 } from "node:child_process";
+import { chmod, lstat as lstat2, open as open2, readFile as readFile2, rename as rename2, rm as rm2, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join2, resolve as resolve2, sep } from "node:path";
+import { createInterface } from "node:readline";
+
+// lib/inference-host/config.ts
+import { spawn } from "node:child_process";
+import { lstat, mkdir, open, readFile, realpath, rename, rm } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, win32 as windowsPath } from "node:path";
+var MAX_INFERENCE_PRIVATE_FILE_BYTES = 16 * 1024 * 1024;
+var WINDOWS_PRIVATE_ACL_BROKER_SCRIPT = `$ErrorActionPreference='Stop'
+$ProgressPreference='SilentlyContinue'
+while(($line=[Console]::In.ReadLine()) -ne $null) {
+  $requestId=$null
+  $failureStage='request_validation'
+  try {
+    if($line.Length -lt 2 -or $line.Length -gt 65536) { throw 'invalid request size' }
+    $request=$line | ConvertFrom-Json
+    $names=@($request.PSObject.Properties.Name | Sort-Object)
+    if(($names -join ',') -ne 'id,kind,mode,path_b64') { throw 'invalid request shape' }
+    if($request.id -isnot [long] -and $request.id -isnot [int]) { throw 'invalid request id' }
+    $requestId=[long]$request.id
+    if($requestId -lt 1) { throw 'invalid request id' }
+    $kind=[string]$request.kind
+    $mode=[string]$request.mode
+    if($kind -ne 'directory' -and $kind -ne 'file') { throw 'invalid path kind' }
+    if($mode -ne 'harden' -and $mode -ne 'verify' -and $mode -ne 'verify-owner') { throw 'invalid ACL mode' }
+    $path=[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String([string]$request.path_b64))
+    if([string]::IsNullOrWhiteSpace($path) -or $path.Length -gt 32767 -or $path.Contains([char]0)) { throw 'invalid path' }
+    $failureStage='path_lookup'
+    if(-not (Test-Path -LiteralPath $path)) {
+      [Console]::Out.WriteLine((@{id=$requestId;status='missing'} | ConvertTo-Json -Compress))
+      continue
+    }
+    $failureStage='principal_resolution'
+    $currentIdentity=[Security.Principal.WindowsIdentity]::GetCurrent()
+    $current=$currentIdentity.User
+    $system=New-Object Security.Principal.SecurityIdentifier('S-1-5-18')
+    $admins=New-Object Security.Principal.SecurityIdentifier('S-1-5-32-544')
+    $currentIsAdmin=(New-Object Security.Principal.WindowsPrincipal($currentIdentity)).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
+    $allowed=@($current.Value,$system.Value,$admins.Value)
+    if($mode -eq 'harden') {
+      $failureStage='acl_read'
+      $acl=Get-Acl -LiteralPath $path
+      $originalAccess=$acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)
+      $failureStage='owner_validation'
+      $existingOwner=(New-Object Security.Principal.NTAccount($acl.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+      if($existingOwner -ne $current.Value -and ($existingOwner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+      $failureStage='acl_mutation'
+      $acl.SetAccessRuleProtection($true,$false)
+      foreach($existingRule in @($acl.Access)) { [void]$acl.RemoveAccessRuleSpecific($existingRule) }
+      $inherit=if($kind -eq 'directory') {
+        [Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
+      } else { [Security.AccessControl.InheritanceFlags]::None }
+      foreach($sid in @($current,$system,$admins)) {
+        $rule=New-Object Security.AccessControl.FileSystemAccessRule(
+          $sid,
+          [Security.AccessControl.FileSystemRights]::FullControl,
+          $inherit,
+          [Security.AccessControl.PropagationFlags]::None,
+          [Security.AccessControl.AccessControlType]::Allow
+        )
+        [void]$acl.AddAccessRule($rule)
+      }
+      $failureStage='acl_write'
+      if($originalAccess -ne $acl.GetSecurityDescriptorSddlForm([Security.AccessControl.AccessControlSections]::Access)) {
+        (Get-Item -LiteralPath $path).SetAccessControl($acl)
+      }
+    }
+    $failureStage='acl_readback'
+    $actual=Get-Acl -LiteralPath $path
+    $failureStage='acl_verification'
+    $owner=(New-Object Security.Principal.NTAccount($actual.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value
+    if($owner -ne $current.Value -and ($owner -ne $admins.Value -or -not $currentIsAdmin)) { throw 'private ACL owner is invalid' }
+    if($mode -ne 'verify-owner') {
+      if(-not $actual.AreAccessRulesProtected) { throw 'private ACL inheritance is invalid' }
+      $userFull=$false
+      foreach($rule in $actual.Access) {
+        $sid=$rule.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value
+        if($rule.IsInherited -or $allowed -notcontains $sid -or $rule.AccessControlType -ne [Security.AccessControl.AccessControlType]::Allow) {
+          throw 'private ACL contains an unauthorized access rule'
+        }
+        if($sid -eq $current.Value -and (($rule.FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -eq [Security.AccessControl.FileSystemRights]::FullControl)) { $userFull=$true }
+      }
+      if(-not $userFull) { throw 'private ACL does not grant the current user full control' }
+    }
+    [Console]::Out.WriteLine((@{id=$requestId;status='ok'} | ConvertTo-Json -Compress))
+  } catch {
+    [Console]::Out.WriteLine((@{id=$requestId;status='error';error_code=$failureStage} | ConvertTo-Json -Compress))
+  }
+}`;
+var WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS = 15e3;
+var WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS = 9e4;
+var SMALL_IDENTITY_COMMAND_TIMEOUT_MS = 5e3;
+var windowsPowerShellEnvironment = (extra = {}) => {
+  const sanitizedExtra = { ...extra };
+  delete sanitizedExtra.PSModulePath;
+  const windowsRoot = process.env.SystemRoot ?? process.env.WINDIR;
+  return {
+    ...sanitizedExtra,
+    NODE_ENV: process.env.NODE_ENV,
+    SystemRoot: process.env.SystemRoot,
+    WINDIR: process.env.WINDIR,
+    ComSpec: process.env.ComSpec,
+    PATHEXT: process.env.PATHEXT,
+    PSModulePath: windowsRoot ? windowsPath.join(windowsRoot, "System32", "WindowsPowerShell", "v1.0", "Modules") : void 0,
+    TEMP: process.env.TEMP,
+    TMP: process.env.TMP
+  };
+};
+var windowsPrivateAclBrokerInvocation = () => ({
+  args: [
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-EncodedCommand",
+    Buffer.from(WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, "utf16le").toString("base64")
+  ],
+  env: windowsPowerShellEnvironment()
+});
+var WindowsPrivateAclBroker = class {
+  constructor(dependencies = {}) {
+    this.child = null;
+    this.requestSequence = 0;
+    this.queue = Promise.resolve();
+    this.pending = null;
+    this.outputBuffer = "";
+    this.idleTimer = null;
+    this.run = async (path, kind, mode) => {
+      const operation = this.queue.then(
+        () => this.dispatch(path, kind, mode),
+        () => this.dispatch(path, kind, mode)
+      );
+      this.queue = operation.then(() => void 0, () => void 0);
+      await operation;
+    };
+    this.requestTimeoutMs = dependencies.requestTimeoutMs ?? 15e3;
+    this.startupRequestTimeoutMs = dependencies.startupRequestTimeoutMs ?? WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS;
+    this.idleShutdownMs = dependencies.idleShutdownMs ?? 3e4;
+    this.spawnProcess = dependencies.spawnProcess ?? (() => {
+      const invocation = windowsPrivateAclBrokerInvocation();
+      return spawn("powershell.exe", [...invocation.args], {
+        env: invocation.env,
+        windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    });
+  }
+  scheduleIdleShutdown() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      const child = this.child;
+      if (!child || this.pending) return;
+      this.child = null;
+      this.outputBuffer = "";
+      child.stdin.end();
+      const force = setTimeout(() => child.kill("SIGKILL"), 1e3);
+      force.unref();
+      child.once("exit", () => clearTimeout(force));
+    }, this.idleShutdownMs);
+    this.idleTimer.unref();
+  }
+  failChild(child, error) {
+    if (this.child !== child) return;
+    this.child = null;
+    this.outputBuffer = "";
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const pending = this.pending;
+    this.pending = null;
+    if (pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    child.kill("SIGKILL");
+  }
+  acceptLine(child, line) {
+    const pending = this.pending;
+    if (!pending || !line || line.length > 4096) {
+      this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+      return;
+    }
+    let response;
+    try {
+      const parsed = JSON.parse(line);
+      const status = String(parsed.status);
+      const expectedKeys = status === "error" ? "error_code\0id\0status" : "id\0status";
+      if (Object.keys(parsed).sort().join("\0") !== expectedKeys || parsed.id !== pending.id || !["ok", "missing", "error"].includes(status) || status === "error" && ![
+        "request_validation",
+        "path_lookup",
+        "principal_resolution",
+        "acl_read",
+        "owner_validation",
+        "acl_mutation",
+        "acl_write",
+        "acl_readback",
+        "acl_verification"
+      ].includes(String(parsed.error_code))) throw new Error("invalid response");
+      response = parsed;
+    } catch {
+      this.failChild(child, new Error("Windows private ACL broker returned malformed output."));
+      return;
+    }
+    this.pending = null;
+    clearTimeout(pending.timer);
+    if (response.status === "ok") {
+      pending.resolve();
+    } else if (response.status === "missing") {
+      const error = new Error("Windows private path no longer exists.");
+      error.code = "ENOENT";
+      pending.reject(error);
+    } else {
+      pending.reject(new Error(
+        `Windows private ACL ${pending.mode} failed (${response.error_code}).`
+      ));
+    }
+    this.scheduleIdleShutdown();
+  }
+  ensureChild() {
+    if (this.child && this.child.exitCode === null && !this.child.killed) {
+      return { child: this.child, startedNow: false };
+    }
+    const child = this.spawnProcess();
+    this.child = child;
+    this.outputBuffer = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      if (this.child !== child) return;
+      this.outputBuffer += chunk;
+      if (this.outputBuffer.length > 65536) {
+        this.failChild(child, new Error("Windows private ACL broker exceeded its output limit."));
+        return;
+      }
+      while (this.child === child) {
+        const newline = this.outputBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = this.outputBuffer.slice(0, newline).trim();
+        this.outputBuffer = this.outputBuffer.slice(newline + 1);
+        this.acceptLine(child, line);
+      }
+    });
+    child.stderr.on("data", () => void 0);
+    child.once("error", () => {
+      this.failChild(child, new Error("Windows private ACL broker failed to start."));
+    });
+    child.once("exit", () => {
+      this.failChild(child, new Error("Windows private ACL broker exited before confirmation."));
+    });
+    child.unref();
+    for (const stream of [child.stdin, child.stdout, child.stderr]) {
+      stream.unref?.();
+    }
+    return { child, startedNow: true };
+  }
+  async dispatch(path, kind, mode) {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const id = ++this.requestSequence;
+    const request = `${JSON.stringify({
+      id,
+      kind,
+      mode,
+      path_b64: Buffer.from(path, "utf8").toString("base64")
+    })}
+`;
+    if (Buffer.byteLength(request, "utf8") > 65536) {
+      throw new Error("Windows private ACL broker request exceeds its input limit.");
+    }
+    const { child, startedNow } = this.ensureChild();
+    const timeoutMs = startedNow ? this.startupRequestTimeoutMs : this.requestTimeoutMs;
+    await new Promise((resolvePromise, reject) => {
+      const timer = setTimeout(() => {
+        this.failChild(child, new Error("Windows private ACL broker request timed out."));
+      }, timeoutMs);
+      this.pending = { id, mode, resolve: resolvePromise, reject, timer };
+      child.stdin.write(request, "utf8", (error) => {
+        if (error) {
+          this.failChild(child, new Error("Windows private ACL broker request failed."));
+        }
+      });
+    });
+  }
+  close() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+    const child = this.child;
+    this.child = null;
+    this.outputBuffer = "";
+    if (child) child.stdin.end();
+  }
+};
+var defaultWindowsPrivateAclBroker = new WindowsPrivateAclBroker();
+var windowsBootIdentityInvocation = () => {
+  const script = `$ErrorActionPreference='Stop';$s=[System.Management.ManagementObjectSearcher]::new('SELECT LastBootUpTime FROM Win32_OperatingSystem');try{$c=$s.Get();$e=$c.GetEnumerator();if(-not $e.MoveNext()){throw 'boot identity unavailable'};$raw=[string]$e.Current['LastBootUpTime'];$v=[System.Management.ManagementDateTimeConverter]::ToDateTime($raw).ToUniversalTime().ToFileTimeUtc();[Console]::Out.Write($v)}finally{if($c){$c.Dispose()};$s.Dispose()}`;
+  return {
+    args: [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ],
+    env: windowsPowerShellEnvironment(),
+    timeoutMs: WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS
+  };
+};
+var runSmallIdentityCommand = async (command, args, env, timeoutMs = SMALL_IDENTITY_COMMAND_TIMEOUT_MS) => await new Promise((resolvePromise) => {
+  const child = spawn(command, [...args], {
+    windowsHide: true,
+    stdio: ["ignore", "pipe", "ignore"],
+    env
+  });
+  const output = [];
+  let bytes = 0;
+  let settled = false;
+  const settle = (value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolvePromise(value);
+  };
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    settle(null);
+  }, timeoutMs);
+  child.stdout.on("data", (chunk) => {
+    bytes += Buffer.byteLength(chunk);
+    if (bytes > 4096) {
+      child.kill("SIGKILL");
+      settle(null);
+      return;
+    }
+    output.push(Buffer.from(chunk));
+  });
+  child.once("error", () => settle(null));
+  child.once("exit", (code) => settle(
+    code === 0 ? Buffer.concat(output).toString("utf8").trim() || null : null
+  ));
+});
+var cachedSystemBootIdentity = null;
+var readInferenceSystemBootIdentity = async (platform = process.platform) => {
+  if (platform === process.platform && cachedSystemBootIdentity) {
+    return await cachedSystemBootIdentity;
+  }
+  const read = async () => {
+    let identity = null;
+    if (platform === "linux") {
+      try {
+        identity = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+      } catch {
+        identity = null;
+      }
+    } else if (platform === "win32") {
+      const invocation = windowsBootIdentityInvocation();
+      identity = await runSmallIdentityCommand(
+        "powershell.exe",
+        invocation.args,
+        invocation.env,
+        invocation.timeoutMs
+      );
+    } else if (platform === "darwin") {
+      identity = await runSmallIdentityCommand("sysctl", ["-n", "kern.boottime"], void 0);
+    }
+    if (!identity || /[\r\n\0]/u.test(identity)) {
+      throw new Error("Inference host could not establish the current system boot identity.");
+    }
+    return `${platform}:${identity}`;
+  };
+  const pending = read();
+  if (platform === process.platform) cachedSystemBootIdentity = pending;
+  try {
+    return await pending;
+  } catch (error) {
+    if (platform === process.platform) cachedSystemBootIdentity = null;
+    throw error;
+  }
+};
+
+// lib/inference-host/codex-app-server.ts
+var CODEX_INFERENCE_PERMISSION_PROFILE = "vtx_inference_readonly";
+var CODEX_AGENT_PERMISSION_PROFILE = "vtx_inference_agent";
+var CODEX_REASONING_CONTENT_MAX_UTF8_BYTES = 32768;
+var CODEX_ACCOUNT_PLAN_TYPES = [
+  "free",
+  "go",
+  "plus",
+  "pro",
+  "prolite",
+  "team",
+  "self_serve_business_prolite",
+  "self_serve_business_usage_based",
+  "business",
+  "ent26",
+  "enterprise_cbp_automation",
+  "enterprise_cbp_usage_based",
+  "enterprise",
+  "edu",
+  "unknown"
+];
+var CODEX_AGENT_DYNAMIC_TOOLS = [
+  "vtx_set_schedule",
+  "vtx_get_data",
+  "vtx_submit_decision",
+  "vtx_decision_status"
+];
+var CodexAppServerError = class extends Error {
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "CodexAppServerError";
+    this.category = options.category;
+    this.code = options.code;
+    this.retryable = options.retryable;
+    this.dispatchOutcome = options.dispatchOutcome ?? "not_dispatched";
+    this.httpStatusCode = options.httpStatusCode ?? null;
+    this.retryAtMs = options.retryAtMs ?? null;
+    this.usage = options.usage ?? null;
+    this.terminalEvidence = options.terminalEvidence ?? null;
+    this.rateLimits = options.rateLimits ?? null;
+    this.processExit = options.processExit ?? null;
+    this.grokToolValidation = options.grokToolValidation ?? null;
+    this.grokResponseIdentity = options.grokResponseIdentity ?? null;
+  }
+};
+var objectOrNull = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+var finiteToken = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+var tokenUsageFromBreakdown = (value) => {
+  const candidate = objectOrNull(value);
+  if (!candidate) return null;
+  const inputTokens = finiteToken(candidate.inputTokens ?? candidate.input_tokens);
+  const cachedInputTokens = finiteToken(
+    candidate.cachedInputTokens ?? candidate.cached_input_tokens ?? objectOrNull(candidate.input_tokens_details)?.cached_tokens
+  );
+  const outputTokens = finiteToken(candidate.outputTokens ?? candidate.output_tokens);
+  const reasoningOutputTokens = finiteToken(
+    candidate.reasoningOutputTokens ?? candidate.reasoning_output_tokens ?? objectOrNull(candidate.output_tokens_details)?.reasoning_tokens
+  );
+  const totalTokens = finiteToken(candidate.totalTokens ?? candidate.total_tokens);
+  if (inputTokens === null || cachedInputTokens === null || outputTokens === null || reasoningOutputTokens === null || totalTokens === null || cachedInputTokens > inputTokens || reasoningOutputTokens > outputTokens || totalTokens !== inputTokens + outputTokens) return null;
+  const rawCacheWrite = candidate.cacheWriteInputTokens ?? candidate.cache_write_input_tokens;
+  const cacheWrite = rawCacheWrite === void 0 ? null : finiteToken(rawCacheWrite);
+  if (rawCacheWrite !== void 0 && cacheWrite === null) return null;
+  return {
+    inputTokens,
+    cachedInputTokens,
+    outputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+    cacheWriteInputTokens: cacheWrite,
+    cacheWriteSupported: rawCacheWrite !== void 0
+  };
+};
+var usageFromNotification = (method, params) => {
+  if (method === "thread/tokenUsage/updated") {
+    const tokenUsage = objectOrNull(params.tokenUsage);
+    return tokenUsageFromBreakdown(tokenUsage?.last) ?? tokenUsageFromBreakdown(tokenUsage?.total);
+  }
+  if (method === "rawResponse/completed") {
+    return tokenUsageFromBreakdown(params.usage);
+  }
+  return null;
+};
+var validPlanType = (value) => typeof value === "string" && CODEX_ACCOUNT_PLAN_TYPES.includes(value);
+var nonnegativeSafeIntegerOrNull = (value) => Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : null;
+var nonnegativeFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+var parseRateLimitWindow = (value) => {
+  if (value === null) return null;
+  const candidate = objectOrNull(value);
+  if (!candidate) throw new Error("invalid rate-limit window");
+  const usedPercent = nonnegativeFiniteNumberOrNull(candidate.usedPercent);
+  const windowDurationMins = candidate.windowDurationMins == null ? null : nonnegativeSafeIntegerOrNull(candidate.windowDurationMins);
+  const resetsAt = candidate.resetsAt == null ? null : nonnegativeSafeIntegerOrNull(candidate.resetsAt);
+  if (usedPercent === null || windowDurationMins === null && candidate.windowDurationMins != null || resetsAt === null && candidate.resetsAt != null) {
+    throw new Error("invalid rate-limit window");
+  }
+  return { usedPercent, windowDurationMins, resetsAt };
+};
+var RATE_LIMIT_REACHED_TYPES = [
+  "rate_limit_reached",
+  "workspace_owner_credits_depleted",
+  "workspace_member_credits_depleted",
+  "workspace_owner_usage_limit_reached",
+  "workspace_member_usage_limit_reached"
+];
+var DEFAULT_CODEX_QUOTA_COOLDOWN_MS = 5 * 60 * 1e3;
+var MAX_CODEX_QUOTA_COOLDOWN_MS = 8 * 24 * 60 * 60 * 1e3;
+var CODEX_TRANSIENT_RATE_LIMIT_COOLDOWN_MS = 30 * 1e3;
+var parseRateLimitSnapshot = (value) => {
+  const candidate = objectOrNull(value);
+  if (!candidate) throw new Error("invalid rate-limit snapshot");
+  const limitId = candidate.limitId === null || candidate.limitId === void 0 ? null : typeof candidate.limitId === "string" && candidate.limitId.trim() ? candidate.limitId.trim() : void 0;
+  const limitName = candidate.limitName === null || candidate.limitName === void 0 ? null : typeof candidate.limitName === "string" && candidate.limitName.trim() ? candidate.limitName.trim() : void 0;
+  const planType = candidate.planType === null || candidate.planType === void 0 ? null : validPlanType(candidate.planType) ? candidate.planType : void 0;
+  const reached = candidate.rateLimitReachedType === null || candidate.rateLimitReachedType === void 0 ? null : typeof candidate.rateLimitReachedType === "string" && RATE_LIMIT_REACHED_TYPES.includes(candidate.rateLimitReachedType) ? candidate.rateLimitReachedType : void 0;
+  const spendControlReached = candidate.spendControlReached === null || candidate.spendControlReached === void 0 ? null : typeof candidate.spendControlReached === "boolean" ? candidate.spendControlReached : void 0;
+  if (limitId === void 0 || limitName === void 0 || planType === void 0 || reached === void 0 || spendControlReached === void 0) throw new Error("invalid rate-limit snapshot");
+  return {
+    limitId,
+    limitName,
+    planType,
+    primary: parseRateLimitWindow(candidate.primary ?? null),
+    secondary: parseRateLimitWindow(candidate.secondary ?? null),
+    rateLimitReachedType: reached,
+    spendControlReached
+  };
+};
+var codexRateLimitRetryAtMs = (accountRateLimits) => {
+  const snapshots = [accountRateLimits.rateLimits];
+  const exhaustedResets = [];
+  const reachedResets = [];
+  for (const snapshot of snapshots) {
+    const windows = [snapshot.primary, snapshot.secondary].filter(
+      (window) => window !== null
+    );
+    for (const window of windows) {
+      if (window.resetsAt === null) continue;
+      const resetAtMs = window.resetsAt * 1e3;
+      if (!Number.isSafeInteger(resetAtMs)) continue;
+      if (window.usedPercent >= 100) exhaustedResets.push(resetAtMs);
+      if (snapshot.rateLimitReachedType !== null || snapshot.spendControlReached === true) {
+        reachedResets.push(resetAtMs);
+      }
+    }
+  }
+  const candidates = exhaustedResets.length > 0 ? exhaustedResets : reachedResets.length > 0 ? reachedResets : [];
+  return candidates.length > 0 ? Math.max(...candidates) : null;
+};
+var codexAccountRateLimitReached = (accountRateLimits) => [accountRateLimits.rateLimits].some((snapshot) => snapshot.rateLimitReachedType !== null || snapshot.spendControlReached === true || snapshot.primary?.usedPercent !== void 0 && snapshot.primary.usedPercent >= 100 || snapshot.secondary?.usedPercent !== void 0 && snapshot.secondary.usedPercent >= 100);
+var forbiddenMethod = (method) => method.startsWith("mcpServer/") || method.startsWith("serverRequest/") || method.startsWith("item/mcpToolCall") || method.startsWith("item/commandExecution") || method.startsWith("item/fileChange") || method.startsWith("item/dynamicToolCall") || method.startsWith("item/collabAgentToolCall");
+var forbiddenTerminalItem = (item) => ![
+  "userMessage",
+  "agentMessage",
+  "reasoning"
+].includes(String(item.type || ""));
+var forbiddenAgentMethod = (method) => method.startsWith("mcpServer/") || method.startsWith("serverRequest/") || method.startsWith("item/mcpToolCall") || method.startsWith("item/commandExecution") || method.startsWith("item/fileChange") || method.startsWith("item/collabAgentToolCall");
+var forbiddenAgentTerminalItem = (item) => ![
+  "userMessage",
+  "agentMessage",
+  "reasoning",
+  "dynamicToolCall",
+  "webSearch",
+  "contextCompaction"
+].includes(String(item.type || ""));
+var createCodexAgentToolSpecs = (dataContract, decisionSchema) => {
+  if (dataContract.length === 0 || Object.keys(decisionSchema).length === 0) {
+    throw new CodexAppServerError({
+      message: "Codex Agent data contract is unavailable.",
+      category: "schema",
+      code: "invalid_agent_data_contract",
+      retryable: false
+    });
+  }
+  const dataRequestBranches = dataContract.map((descriptor) => ({
+    type: "object",
+    additionalProperties: false,
+    required: ["capability", "arguments"],
+    description: descriptor.description,
+    properties: {
+      capability: {
+        type: "string",
+        const: descriptor.id,
+        title: descriptor.title
+      },
+      arguments: descriptor.input_schema
+    }
+  }));
+  return [
+    {
+      type: "function",
+      name: "vtx_get_data",
+      description: "Request assignment-scoped VTX data using one exact canonical capability schema.",
+      inputSchema: {
+        oneOf: dataRequestBranches
+      }
+    },
+    {
+      type: "function",
+      name: "vtx_submit_decision",
+      description: "Submit one VTX structured trading decision candidate using the assignment decision schema.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["candidate"],
+        properties: { candidate: decisionSchema }
+      }
+    },
+    {
+      type: "function",
+      name: "vtx_decision_status",
+      description: "Resolve the durable status of a previously attempted decision operation.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["operation_id"],
+        properties: { operation_id: { type: "string", minLength: 1 } }
+      }
+    },
+    {
+      type: "function",
+      name: "vtx_set_schedule",
+      description: "Configure or cancel recurring market observations for this assignment. This never submits a trading decision.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["schedule"],
+        properties: { schedule: { anyOf: [{ type: "null" }, {
+          type: "object",
+          additionalProperties: false,
+          required: ["interval_seconds", "objective", "observation"],
+          properties: {
+            interval_seconds: { type: "integer", minimum: 1 },
+            objective: { type: "string", minLength: 1, maxLength: 4e3 },
+            observation: { type: "object", additionalProperties: false, required: ["capability", "arguments"], properties: {
+              capability: { const: "market.snapshot", type: "string" },
+              arguments: dataContract.find((descriptor) => descriptor.id === "market.snapshot")?.input_schema ?? { type: "object" }
+            } }
+          }
+        }] } }
+      }
+    }
+  ];
+};
+var classifyCodexTurnFailure = (codexErrorInfo, terminalStatus) => {
+  if (terminalStatus === "interrupted") {
+    return { code: "cancelled", category: "cancelled", retryable: false, httpStatusCode: null };
+  }
+  if (codexErrorInfo === "usageLimitExceeded") {
+    return { code: "quota_exceeded", category: "model", retryable: false, httpStatusCode: null };
+  }
+  if (codexErrorInfo === "unauthorized") {
+    return { code: "auth_expired", category: "auth", retryable: false, httpStatusCode: null };
+  }
+  const stableStringCodes = {
+    badRequest: "codex_bad_request",
+    contextWindowExceeded: "context_window_exceeded",
+    cyberPolicy: "codex_policy_rejected",
+    internalServerError: "codex_internal_error",
+    sandboxError: "codex_sandbox_error",
+    serverOverloaded: "codex_server_overloaded",
+    sessionBudgetExceeded: "session_budget_exceeded",
+    threadRollbackFailed: "codex_thread_rollback_failed"
+  };
+  if (typeof codexErrorInfo === "string" && stableStringCodes[codexErrorInfo]) {
+    const code = stableStringCodes[codexErrorInfo];
+    return {
+      code,
+      category: "adapter",
+      retryable: code === "codex_internal_error" || code === "codex_server_overloaded",
+      httpStatusCode: null
+    };
+  }
+  const structured = objectOrNull(codexErrorInfo);
+  if (structured) {
+    const variants = [
+      ["httpConnectionFailed", "codex_http_connection_failed"],
+      ["responseStreamConnectionFailed", "codex_response_stream_connection_failed"],
+      ["responseStreamDisconnected", "codex_response_stream_disconnected"],
+      ["responseTooManyFailedAttempts", "codex_provider_retry_exhausted"]
+    ];
+    for (const [variant, code] of variants) {
+      if (!(variant in structured)) continue;
+      const details = objectOrNull(structured[variant]);
+      const rawStatus = details?.httpStatusCode;
+      const httpStatusCode = Number.isSafeInteger(rawStatus) && Number(rawStatus) >= 100 && Number(rawStatus) <= 599 ? Number(rawStatus) : null;
+      if (httpStatusCode === 401) {
+        return {
+          code: "auth_expired",
+          category: "auth",
+          retryable: false,
+          httpStatusCode
+        };
+      }
+      if (httpStatusCode === 429) {
+        return {
+          code: "codex_rate_limited",
+          category: "adapter",
+          retryable: true,
+          httpStatusCode
+        };
+      }
+      if (httpStatusCode !== null && httpStatusCode >= 400 && httpStatusCode < 500 && httpStatusCode !== 408 && httpStatusCode !== 425) {
+        const semanticText = JSON.stringify(details || {}).toLowerCase();
+        if (httpStatusCode === 402 || /(quota|credit|spend|payment|subscription.*limit)/u.test(semanticText)) {
+          return {
+            code: "quota_exceeded",
+            category: "model",
+            retryable: false,
+            httpStatusCode
+          };
+        }
+        if (httpStatusCode === 403 && /(auth|account|workspace|billing|entitlement)/u.test(semanticText)) {
+          return {
+            code: "auth_expired",
+            category: "auth",
+            retryable: false,
+            httpStatusCode
+          };
+        }
+        if (httpStatusCode === 403 && /(policy|safety|cyber)/u.test(semanticText)) {
+          return {
+            code: "codex_policy_rejected",
+            category: "adapter",
+            retryable: false,
+            httpStatusCode
+          };
+        }
+        return {
+          code: httpStatusCode === 400 ? "codex_bad_request" : "codex_http_client_error",
+          category: "adapter",
+          retryable: false,
+          httpStatusCode
+        };
+      }
+      return {
+        code,
+        category: "adapter",
+        retryable: httpStatusCode === null ? true : httpStatusCode === 408 || httpStatusCode === 425 || httpStatusCode >= 500,
+        httpStatusCode
+      };
+    }
+  }
+  return { code: "turn_failed", category: "adapter", retryable: false, httpStatusCode: null };
+};
+var scrubbedCodexEnvironment = (codexHome) => {
+  if (process.platform === "win32") {
+    const systemRoot = String(process.env.SystemRoot || "C:\\Windows");
+    return {
+      CODEX_HOME: codexHome,
+      HOME: codexHome,
+      USERPROFILE: codexHome,
+      NODE_ENV: "production",
+      LANG: "C.UTF-8",
+      PATH: `${systemRoot}\\System32`,
+      SystemRoot: systemRoot,
+      WINDIR: String(process.env.WINDIR || systemRoot),
+      TEMP: tmpdir(),
+      TMP: tmpdir(),
+      TZ: "America/New_York"
+    };
+  }
+  return {
+    CODEX_HOME: codexHome,
+    HOME: codexHome,
+    NODE_ENV: "production",
+    LANG: "C.UTF-8",
+    LC_ALL: "C.UTF-8",
+    PATH: "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+    SHELL: "/bin/bash",
+    SSL_CERT_DIR: "/etc/ssl/certs",
+    TMPDIR: "/tmp",
+    TZ: "America/New_York",
+    XDG_RUNTIME_DIR: codexHome
+  };
+};
+var killWindowsProcessTree = async (pid) => {
+  await new Promise((resolve3, reject) => {
+    const child = spawn2(
+      "taskkill.exe",
+      ["/PID", String(pid), "/T", "/F"],
+      {
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore"],
+        env: {
+          NODE_ENV: "production",
+          SystemRoot: String(process.env.SystemRoot || "C:\\Windows"),
+          WINDIR: String(process.env.WINDIR || process.env.SystemRoot || "C:\\Windows"),
+          PATH: `${String(process.env.SystemRoot || "C:\\Windows")}\\System32`
+        }
+      }
+    );
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error("Windows Codex process-tree cleanup timed out."));
+    }, 5e3);
+    child.once("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0 || code === 128) resolve3();
+      else reject(new Error("Windows Codex process-tree cleanup failed."));
+    });
+  });
+};
+var appServerArgs = (enableAgentCodeModeHost = false) => {
+  const args = [
+    "app-server",
+    "--stdio",
+    "--strict-config",
+    "-c",
+    'approval_policy="never"',
+    "-c",
+    'shell_environment_policy.inherit="none"',
+    "-c",
+    'shell_environment_policy.include_only=["PATH","LANG","LC_ALL","SHELL","TMPDIR","TZ","SSL_CERT_DIR"]'
+  ];
+  for (const feature of [
+    "fast_mode",
+    "plugins",
+    "unified_exec",
+    "apps",
+    "browser_use",
+    "in_app_browser",
+    "computer_use",
+    "memories",
+    "image_generation",
+    "multi_agent",
+    ...enableAgentCodeModeHost ? [] : ["code_mode_host"]
+  ]) args.push("--disable", feature);
+  if (enableAgentCodeModeHost) args.push("--enable", "code_mode_host");
+  return args;
+};
+var GUARDIAN_SCRIPT = String.raw`
+import { spawn } from 'node:child_process';
+import { chmod, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+const input = JSON.parse(Buffer.from(process.argv[1], 'base64url').toString('utf8'));
+// The guardian owns the process boundary for every attempt. Apply a private
+// umask before writing receipts or starting Codex so a lost thread/start reply
+// still leaves traversable 0700 directories and removable 0600 rollout files.
+process.umask(0o077);
+const replaceReceipt = async (temporary) => {
+  const retryableWindowsCodes = new Set(['EACCES', 'EBUSY', 'EEXIST', 'ENOTEMPTY', 'EPERM']);
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    try {
+      await rename(temporary, input.receiptPath);
+      return;
+    } catch (error) {
+      if (
+        process.platform !== 'win32'
+        || !retryableWindowsCodes.has(String(error?.code || ''))
+        || attempt === 39
+      ) throw error;
+      try {
+        await rm(input.receiptPath, { force: true });
+      } catch (removeError) {
+        if (!retryableWindowsCodes.has(String(removeError?.code || ''))) throw removeError;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+  }
+};
+let receiptWriteSequence = 0;
+let receiptWriteChain = Promise.resolve();
+const writeReceipt = (state, childPid, termination = null) => {
+  const write = async () => {
+    const body = JSON.stringify({
+      schema_version: 'vtx_codex_guardian_v1',
+      process_token: input.processToken,
+      state,
+      guardian_pid: process.pid,
+      child_pid: childPid ?? null,
+      boot_identity: input.bootIdentity,
+      termination,
+      updated_at: new Date().toISOString(),
+    }) + '\n';
+    receiptWriteSequence += 1;
+    const temporary = input.receiptPath + '.tmp-' + process.pid + '-' + receiptWriteSequence;
+    try {
+      await writeFile(temporary, body, { mode: 0o600 });
+      await chmod(temporary, 0o600).catch(() => undefined);
+      const file = await open(temporary, 'r+');
+      try { await file.sync(); } finally { await file.close(); }
+      await replaceReceipt(temporary);
+      if (process.platform !== 'win32') {
+        const directory = await open(dirname(input.receiptPath), 'r');
+        try { await directory.sync(); } finally { await directory.close(); }
+      }
+    } finally {
+      await rm(temporary, { force: true }).catch(() => undefined);
+    }
+  };
+  const scheduled = receiptWriteChain.then(write, write);
+  receiptWriteChain = scheduled.catch(() => undefined);
+  return scheduled;
+};
+let child = null;
+let shuttingDown = false;
+let shutdownRequested = false;
+let childStartedAt = null;
+let forceTimer = null;
+const stopChild = (expected) => {
+  if (expected) shutdownRequested = true;
+  if (shuttingDown) return;
+  shuttingDown = true;
+  if (!child) return;
+  child.stdin.end();
+  forceTimer = setTimeout(() => {
+    if (child.exitCode === null) child.kill('SIGKILL');
+  }, input.shutdownGraceMs);
+  forceTimer.unref();
+};
+let shutdownStarted = false;
+const shutdown = async () => {
+  if (shutdownStarted) return;
+  shutdownStarted = true;
+  let expected = false;
+  try {
+    expected = (await readFile(input.shutdownIntentPath, 'utf8')) === input.processToken;
+    await rm(input.shutdownIntentPath, { force: true });
+  } catch {
+    expected = false;
+  }
+  stopChild(expected);
+};
+process.stdin.once('end', shutdown);
+process.stdin.once('close', shutdown);
+process.stdout.on('error', () => undefined);
+process.stderr.on('error', () => undefined);
+await writeReceipt('starting', null);
+if (shuttingDown) {
+  await writeReceipt('terminated', null);
+  process.exit(0);
+}
+child = spawn(input.binary, input.args, {
+  env: process.env,
+  stdio: ['pipe', 'pipe', 'pipe'],
+  windowsHide: true,
+  detached: false,
+});
+childStartedAt = Date.now();
+child.stdin.on('error', () => undefined);
+process.stdin.pipe(child.stdin, { end: false });
+child.stdout.pipe(process.stdout);
+child.stderr.pipe(process.stderr);
+child.once('spawn', async () => {
+  try {
+    await writeReceipt('running', child.pid ?? null);
+  } catch {
+    stopChild(false);
+  }
+});
+child.once('error', () => stopChild(false));
+child.once('close', async (code, signal) => {
+  if (forceTimer) clearTimeout(forceTimer);
+  // A pending promise alone does not keep Node's event loop alive after the
+  // child and parent stdin have both closed. Hold one local handle until the
+  // serialized terminal tombstone is durably replaced.
+  const receiptKeepAlive = setInterval(() => undefined, 1_000);
+  try {
+    const normalizedSignal = typeof signal === 'string' && /^SIG[A-Z0-9]{1,28}$/.test(signal)
+      ? signal.toLowerCase()
+      : null;
+    const normalizedCode = normalizedSignal === null && Number.isInteger(code)
+      && code >= -(2 ** 31) && code <= (2 ** 31) - 1
+      ? code
+      : null;
+    await writeReceipt('terminated', child.pid ?? null, {
+      exit_code: normalizedCode,
+      signal: normalizedSignal,
+      expected: shutdownRequested,
+      uptime_ms: Math.min(
+        Math.max(0, Date.now() - (childStartedAt ?? Date.now())),
+        Number.MAX_SAFE_INTEGER,
+      ),
+    });
+  } finally {
+    clearInterval(receiptKeepAlive);
+    process.exit(0);
+  }
+});
+`;
+var WINDOWS_RECEIPT_REPLACE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EACCES",
+  "EBUSY",
+  "EEXIST",
+  "ENOTEMPTY",
+  "EPERM"
+]);
+var MAX_RETIRED_RESPONSE_IDS = 256;
+var LATE_RESPONSE_SAFE_METHODS = /* @__PURE__ */ new Set([
+  "account/rateLimits/read",
+  "turn/start",
+  "turn/interrupt"
+]);
+var replaceCodexGuardianReceiptFile = async (temporaryPath, receiptPath, options = {}) => {
+  const platform = options.platform ?? process.platform;
+  const renameFile = options.renameFile ?? rename2;
+  const removeFile = options.removeFile ?? ((path) => rm2(path, { force: true }));
+  const sleep = options.sleep ?? ((milliseconds) => new Promise((resolve3) => setTimeout(resolve3, milliseconds)));
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 40);
+  const retryDelayMs = Math.max(0, options.retryDelayMs ?? 25);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      await renameFile(temporaryPath, receiptPath);
+      return;
+    } catch (error) {
+      const code = String(error.code ?? "");
+      if (platform !== "win32" || !WINDOWS_RECEIPT_REPLACE_ERROR_CODES.has(code) || attempt === maxAttempts - 1) {
+        throw error;
+      }
+      try {
+        await removeFile(receiptPath);
+      } catch (removeError) {
+        const removeCode = String(removeError.code ?? "");
+        if (!WINDOWS_RECEIPT_REPLACE_ERROR_CODES.has(removeCode)) {
+          throw removeError;
+        }
+      }
+      await sleep(retryDelayMs);
+    }
+  }
+};
+var writeCodexGuardianSpawnIntent = async (guardian) => {
+  const body = `${JSON.stringify({
+    schema_version: "vtx_codex_guardian_v1",
+    process_token: guardian.processToken,
+    state: "spawn_intent",
+    guardian_pid: null,
+    child_pid: null,
+    boot_identity: guardian.bootIdentity ?? null,
+    termination: null,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  })}
+`;
+  const temporary = `${guardian.receiptPath}.intent-${process.pid}`;
+  await writeFile(temporary, body, { mode: 384 });
+  await chmod(temporary, 384).catch(() => void 0);
+  const handle = await open2(temporary, "r+");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await replaceCodexGuardianReceiptFile(temporary, guardian.receiptPath);
+  if (process.platform !== "win32") {
+    const directory = await open2(dirname2(guardian.receiptPath), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  }
+};
+var parseGuardianReceipt = (raw) => {
+  const value = JSON.parse(raw);
+  const rawTermination = value.termination;
+  const termination = rawTermination === null || rawTermination === void 0 ? null : objectOrNull(rawTermination);
+  if (value.schema_version !== "vtx_codex_guardian_v1" || typeof value.process_token !== "string" || !/^[0-9a-f]{64}$/u.test(value.process_token) || !["spawn_intent", "starting", "running", "terminated"].includes(String(value.state)) || value.guardian_pid !== null && !Number.isSafeInteger(value.guardian_pid) || value.state === "spawn_intent" && value.guardian_pid !== null || value.state !== "spawn_intent" && !Number.isSafeInteger(value.guardian_pid) || value.child_pid !== null && !Number.isSafeInteger(value.child_pid) || value.boot_identity !== null && value.boot_identity !== void 0 && typeof value.boot_identity !== "string" || typeof value.updated_at !== "string" || !Number.isFinite(Date.parse(value.updated_at)) || rawTermination !== null && rawTermination !== void 0 && termination === null || termination !== null && (value.state !== "terminated" || termination.exit_code !== null && (!Number.isInteger(termination.exit_code) || Number(termination.exit_code) < -(2 ** 31) || Number(termination.exit_code) > 2 ** 31 - 1) || termination.signal !== null && (typeof termination.signal !== "string" || !/^sig[a-z0-9]{1,28}$/u.test(termination.signal)) || termination.signal !== null && termination.exit_code !== null || typeof termination.expected !== "boolean" || !Number.isSafeInteger(termination.uptime_ms) || Number(termination.uptime_ms) < 0)) {
+    throw new Error("Codex guardian receipt is invalid.");
+  }
+  return {
+    ...value,
+    boot_identity: typeof value.boot_identity === "string" ? value.boot_identity : null,
+    termination
+  };
+};
+var readCodexGuardianReceipt = async (path) => {
+  try {
+    const state = await lstat2(path);
+    if (!state.isFile() || state.isSymbolicLink() || process.platform !== "win32" && ((state.mode & 63) !== 0 || typeof process.getuid === "function" && state.uid !== process.getuid())) {
+      throw new Error("Codex guardian receipt is not private.");
+    }
+    return parseGuardianReceipt(await readFile2(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+};
+var waitForCodexGuardianState = async (guardian, expectedState, deadlineAtMs) => {
+  while (Date.now() < deadlineAtMs) {
+    const receipt = await readCodexGuardianReceipt(guardian.receiptPath);
+    if (receipt) {
+      if (receipt.process_token !== guardian.processToken) {
+        throw new Error("Codex guardian receipt crossed process scope.");
+      }
+      if (receipt.state === expectedState) return receipt;
+      if (receipt.state === "terminated" && expectedState === "running") {
+        throw new Error("Codex guardian terminated before app-server initialization.");
+      }
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, 25));
+  }
+  throw new Error(`Codex guardian ${expectedState} state was not confirmed.`);
+};
+var defaultSpawn = (binary, args, options) => {
+  if (!options.guardian) {
+    const { guardian: _guardian, ...spawnOptions } = options;
+    return spawn2(binary, args, {
+      ...spawnOptions,
+      detached: options.detached
+    });
+  }
+  const payload = Buffer.from(JSON.stringify({
+    binary,
+    args,
+    processToken: options.guardian.processToken,
+    receiptPath: options.guardian.receiptPath,
+    shutdownIntentPath: `${options.guardian.receiptPath}.shutdown-intent`,
+    shutdownGraceMs: Math.max(25, options.guardian.shutdownGraceMs ?? 2e3),
+    bootIdentity: options.guardian.bootIdentity
+  }), "utf8").toString("base64url");
+  return spawn2(process.execPath, ["--input-type=module", "--eval", GUARDIAN_SCRIPT, payload], {
+    env: options.env,
+    stdio: options.stdio,
+    windowsHide: options.windowsHide,
+    detached: true
+  });
+};
+var CodexAppServerSession = class _CodexAppServerSession {
+  constructor(options) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.retiredResponseIds = /* @__PURE__ */ new Map();
+    this.notificationListeners = /* @__PURE__ */ new Set();
+    this.fatalListeners = /* @__PURE__ */ new Set();
+    this.agentToolHandlers = /* @__PURE__ */ new Map();
+    this.accountLoginCompletions = /* @__PURE__ */ new Map();
+    this.threads = /* @__PURE__ */ new Map();
+    this.nextRequestId = 1;
+    this.fatalError = null;
+    this.closed = false;
+    this.processCloseObserved = false;
+    this.shutdownRequested = false;
+    this.stderrBytesObserved = 0;
+    this.stderrNonempty = false;
+    this.stderrTruncated = false;
+    this.stderrTail = "";
+    this.stderrClass = "none";
+    this.process = options.process;
+    this.codexHome = options.codexHome;
+    this.sessionGeneration = options.sessionGeneration;
+    this.startedAtMs = Date.now();
+    this.guardian = options.guardian;
+    this.onProcessExit = options.onProcessExit;
+    this.onLateResponse = options.onLateResponse;
+    this.process.stderr.on("data", (chunk) => this.observeStderr(chunk));
+    const lines = createInterface({ input: this.process.stdout, crlfDelay: Infinity });
+    lines.on("line", (line) => this.handleLine(line));
+    this.process.once("error", () => {
+    });
+    this.process.once("close", (code, signal) => {
+      void this.handleProcessClose(code, signal);
+    });
+  }
+  static {
+    this.STDERR_OBSERVATION_CAP_BYTES = 65536;
+  }
+  static {
+    this.STDERR_CLASSIFICATION_TAIL_CHARS = 1024;
+  }
+  static async start(options) {
+    const spawnProcess = options.spawnProcess ?? defaultSpawn;
+    const guardian = options.guardian ? {
+      ...options.guardian,
+      bootIdentity: options.guardian.bootIdentity ?? await readInferenceSystemBootIdentity()
+    } : void 0;
+    if (guardian) {
+      try {
+        await writeCodexGuardianSpawnIntent(guardian);
+      } catch (error) {
+        throw new CodexAppServerError({
+          message: "Codex guardian spawn intent could not be persisted.",
+          category: "transport",
+          code: "codex_guardian_intent_unconfirmed",
+          retryable: false,
+          cause: error
+        });
+      }
+    }
+    const child = spawnProcess(options.binary.path, appServerArgs(
+      options.enableAgentCodeModeHost === true
+    ), {
+      env: scrubbedCodexEnvironment(options.codexHome),
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      detached: true,
+      guardian
+    });
+    if (guardian) {
+      try {
+        await waitForCodexGuardianState(
+          guardian,
+          "running",
+          Math.min(options.deadlineAtMs, Date.now() + 1e4)
+        );
+      } catch (error) {
+        child.stdin.end();
+        try {
+          await waitForCodexGuardianState(
+            guardian,
+            "terminated",
+            Date.now() + 5e3
+          );
+        } catch (terminationError) {
+          throw new CodexAppServerError({
+            message: "Codex guardian startup failed and termination was not confirmed.",
+            category: "transport",
+            code: "codex_guardian_termination_unconfirmed",
+            retryable: false,
+            cause: terminationError
+          });
+        }
+        throw new CodexAppServerError({
+          message: "Codex guardian startup could not be confirmed.",
+          category: "transport",
+          code: "codex_guardian_start_unconfirmed",
+          retryable: false,
+          cause: error
+        });
+      }
+    }
+    const session = new _CodexAppServerSession({
+      process: child,
+      codexHome: options.codexHome,
+      sessionGeneration: options.sessionGeneration ?? 1,
+      guardian: guardian ?? null,
+      onProcessExit: options.onProcessExit ?? null,
+      onLateResponse: options.onLateResponse ?? null
+    });
+    try {
+      const initialized = await session.request("initialize", {
+        clientInfo: {
+          name: "vtx_external_inference_host",
+          title: "VTX External Inference Host",
+          version: "external_inference.v1"
+        },
+        capabilities: {
+          experimentalApi: true,
+          optOutNotificationMethods: ["thread/started"]
+        }
+      }, {
+        timeoutMs: Math.max(1, options.deadlineAtMs - Date.now()),
+        signal: options.signal
+      });
+      if (String(initialized.codexHome || "") !== options.codexHome || !String(initialized.userAgent || "").trim()) {
+        throw new CodexAppServerError({
+          message: "Codex initialization provenance was invalid.",
+          category: "adapter",
+          code: "invalid_initialize_provenance",
+          retryable: false
+        });
+      }
+      session.notify("initialized", {});
+      return session;
+    } catch (error) {
+      await session.close().catch(() => void 0);
+      if (guardian) {
+        try {
+          await waitForCodexGuardianState(
+            guardian,
+            "terminated",
+            Date.now() + 5e3
+          );
+        } catch (terminationError) {
+          throw new CodexAppServerError({
+            message: "Codex app-server failed and guardian termination was not confirmed.",
+            category: "transport",
+            code: "codex_guardian_termination_unconfirmed",
+            retryable: false,
+            cause: terminationError
+          });
+        }
+      }
+      throw error;
+    }
+  }
+  handleLine(line) {
+    let message;
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("protocol message is not an object");
+      }
+      message = parsed;
+    } catch {
+      this.failTransport("invalid_protocol_json");
+      return;
+    }
+    const id = message.id;
+    if (typeof id === "number" && Number.isSafeInteger(id) && !("method" in message)) {
+      const pending = this.pending.get(id);
+      if (!pending) {
+        const retiredMethod = this.retiredResponseIds.get(id);
+        this.retiredResponseIds.delete(id);
+        if (retiredMethod && LATE_RESPONSE_SAFE_METHODS.has(retiredMethod)) {
+          try {
+            this.onLateResponse?.(retiredMethod);
+          } catch {
+          }
+          return;
+        }
+        this.failTransport("unexpected_response_id");
+        return;
+      }
+      this.pending.delete(id);
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.abortCleanup?.();
+      const error = objectOrNull(message.error);
+      if (error) {
+        pending.reject(new CodexAppServerError({
+          message: "Codex app-server rejected a request.",
+          category: "adapter",
+          code: "rpc_rejected",
+          retryable: false
+        }));
+        return;
+      }
+      const result = objectOrNull(message.result);
+      if (!result) {
+        pending.reject(new CodexAppServerError({
+          message: "Codex app-server returned an invalid result.",
+          category: "adapter",
+          code: "invalid_rpc_result",
+          retryable: false
+        }));
+        return;
+      }
+      pending.resolve(result);
+      return;
+    }
+    const method = typeof message.method === "string" ? message.method : "";
+    const params = objectOrNull(message.params);
+    if (method === "item/tool/call" && params && "id" in message) {
+      const requestId = message.id;
+      if (!(typeof requestId === "string" || typeof requestId === "number" && Number.isSafeInteger(requestId))) {
+        this.failTransport("invalid_dynamic_tool_request_id");
+        return;
+      }
+      void this.handleAgentToolRequest(requestId, params);
+      return;
+    }
+    if (!method || !params || "id" in message) {
+      this.failTransport("unexpected_server_request");
+      return;
+    }
+    if (method === "account/login/completed") {
+      const loginId = typeof params.loginId === "string" ? params.loginId.trim() : "";
+      if (!loginId || typeof params.success !== "boolean") {
+        this.failTransport("invalid_account_login_completion");
+        return;
+      }
+      this.accountLoginCompletions.set(loginId, {
+        success: params.success,
+        error: typeof params.error === "string" ? params.error : null
+      });
+    }
+    for (const listener of this.notificationListeners) listener({ method, params });
+  }
+  async handleAgentToolRequest(requestId, params) {
+    const threadId = typeof params.threadId === "string" ? params.threadId.trim() : "";
+    const requestTurnId = typeof params.turnId === "string" ? params.turnId.trim() : "";
+    const callId = typeof params.callId === "string" ? params.callId.trim() : "";
+    const tool = typeof params.tool === "string" ? params.tool : "";
+    const args = objectOrNull(params.arguments);
+    const handler = this.agentToolHandlers.get(threadId);
+    if (!threadId || !requestTurnId || !callId || params.namespace !== null || !CODEX_AGENT_DYNAMIC_TOOLS.includes(tool) || !args || !handler || !handler.acceptTurnId(requestTurnId)) {
+      this.failTransport("invalid_dynamic_tool_request");
+      return;
+    }
+    try {
+      const signature = JSON.stringify({ tool, arguments: args });
+      const existing = handler.calls.get(callId);
+      if (existing && existing.signature !== signature) {
+        this.failTransport("dynamic_tool_call_identity_reused");
+        return;
+      }
+      const promise = existing?.promise ?? handler.execute({
+        callId,
+        tool,
+        arguments: args
+      });
+      if (!existing) handler.calls.set(callId, { signature, promise });
+      const result = await promise;
+      this.write({
+        id: requestId,
+        result: {
+          contentItems: [{ type: "inputText", text: JSON.stringify(result.value ?? null) }],
+          success: result.success
+        }
+      });
+    } catch {
+      this.write({
+        id: requestId,
+        result: {
+          contentItems: [{
+            type: "inputText",
+            text: JSON.stringify({ error: "vtx_agent_tool_failed" })
+          }],
+          success: false
+        }
+      });
+    }
+  }
+  failTransport(code, processExit = null) {
+    if (this.fatalError) return;
+    this.fatalError = new CodexAppServerError({
+      message: "Codex app-server transport became unavailable.",
+      category: "transport",
+      code,
+      retryable: true,
+      processExit
+    });
+    for (const pending of this.pending.values()) {
+      if (pending.timer) clearTimeout(pending.timer);
+      pending.abortCleanup?.();
+      pending.reject(this.fatalError);
+    }
+    this.pending.clear();
+    for (const listener of this.fatalListeners) listener(this.fatalError);
+  }
+  retireResponseId(id, method) {
+    this.retiredResponseIds.set(id, method);
+    while (this.retiredResponseIds.size > MAX_RETIRED_RESPONSE_IDS) {
+      const oldest = this.retiredResponseIds.keys().next().value;
+      if (typeof oldest !== "number") break;
+      this.retiredResponseIds.delete(oldest);
+    }
+  }
+  write(message) {
+    if (this.closed || this.fatalError || this.process.exitCode !== null) {
+      throw this.fatalError ?? new CodexAppServerError({
+        message: "Codex app-server is closed.",
+        category: "transport",
+        code: "transport_closed",
+        retryable: true
+      });
+    }
+    this.process.stdin.write(`${JSON.stringify(message)}
+`);
+  }
+  notify(method, params) {
+    this.write({ method, params });
+  }
+  async request(method, params, options = { timeoutMs: 3e4 }) {
+    if (options.signal?.aborted) {
+      throw new CodexAppServerError({
+        message: "Codex request was cancelled before dispatch.",
+        category: "cancelled",
+        code: "rpc_cancelled_before_write",
+        retryable: false,
+        dispatchOutcome: "not_dispatched"
+      });
+    }
+    const id = this.nextRequestId++;
+    await options.beforeWrite?.(id);
+    if (options.signal?.aborted) {
+      throw new CodexAppServerError({
+        message: "Codex request was cancelled before dispatch.",
+        category: "cancelled",
+        code: "rpc_cancelled_before_write",
+        retryable: false,
+        dispatchOutcome: "not_dispatched"
+      });
+    }
+    if (options.notAfterMs !== void 0 && Date.now() > options.notAfterMs) {
+      throw new CodexAppServerError({
+        message: "Server account context expired before provider dispatch.",
+        category: "adapter",
+        code: "server_account_context_expired_before_provider_dispatch",
+        retryable: false,
+        dispatchOutcome: "not_dispatched"
+      });
+    }
+    return await new Promise((resolve3, reject) => {
+      const pending = { resolve: resolve3, reject, timer: null, abortCleanup: null };
+      pending.timer = setTimeout(() => {
+        this.pending.delete(id);
+        this.retireResponseId(id, method);
+        pending.abortCleanup?.();
+        reject(new CodexAppServerError({
+          message: "Codex app-server request timed out.",
+          category: "timeout",
+          code: "rpc_timeout",
+          retryable: true
+        }));
+      }, Math.max(1, options.timeoutMs));
+      if (options.signal && !options.retainResponseOnAbort) {
+        const onAbort = () => {
+          this.pending.delete(id);
+          this.retireResponseId(id, method);
+          if (pending.timer) clearTimeout(pending.timer);
+          pending.abortCleanup?.();
+          reject(new CodexAppServerError({
+            message: "Codex request was cancelled.",
+            category: "cancelled",
+            code: "cancelled",
+            retryable: false
+          }));
+        };
+        options.signal.addEventListener("abort", onAbort, { once: true });
+        pending.abortCleanup = () => options.signal?.removeEventListener("abort", onAbort);
+      }
+      this.pending.set(id, pending);
+      try {
+        this.write(params === void 0 ? { id, method } : { id, method, params });
+        options.onWritten?.(id);
+      } catch (error) {
+        this.pending.delete(id);
+        if (pending.timer) clearTimeout(pending.timer);
+        pending.abortCleanup?.();
+        reject(error);
+      }
+    });
+  }
+  subscribe(listener) {
+    this.notificationListeners.add(listener);
+    return () => this.notificationListeners.delete(listener);
+  }
+  subscribeFatal(listener) {
+    this.fatalListeners.add(listener);
+    return () => this.fatalListeners.delete(listener);
+  }
+  observeStderr(chunk) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
+    if (bytes.length === 0) return;
+    this.stderrNonempty = true;
+    const remaining = Math.max(
+      0,
+      _CodexAppServerSession.STDERR_OBSERVATION_CAP_BYTES - this.stderrBytesObserved
+    );
+    if (remaining === 0) {
+      this.stderrTruncated = true;
+      return;
+    }
+    const observed = bytes.subarray(0, remaining);
+    this.stderrBytesObserved += observed.length;
+    if (bytes.length > remaining) this.stderrTruncated = true;
+    this.stderrTail = `${this.stderrTail}${observed.toString("utf8")}`.slice(-_CodexAppServerSession.STDERR_CLASSIFICATION_TAIL_CHARS).toLowerCase();
+    const classified = /heap out of memory|allocation failed|out of memory/u.test(this.stderrTail) ? "out_of_memory" : /fatal runtime error|fatal error|\bpanic(?:ked)?\b/u.test(this.stderrTail) ? "runtime_fatal" : /access violation|segmentation fault|\bsegfault\b/u.test(this.stderrTail) ? "memory_fault" : /broken pipe|econnreset|connection reset/u.test(this.stderrTail) ? "pipe_or_connection" : null;
+    if (classified) this.stderrClass = classified;
+    else if (this.stderrClass === "none") this.stderrClass = "unclassified";
+  }
+  async handleProcessClose(rawCode, rawSignal) {
+    this.processCloseObserved = true;
+    let termination = null;
+    if (this.guardian) {
+      try {
+        const receipt = await readCodexGuardianReceipt(this.guardian.receiptPath);
+        if (receipt?.process_token === this.guardian.processToken && receipt.state === "terminated") {
+          termination = receipt.termination;
+        }
+      } catch {
+      }
+    }
+    const diagnostics = this.processExitDiagnostics(rawCode, rawSignal, termination);
+    if (this.guardian) {
+      await rm2(`${this.guardian.receiptPath}.shutdown-intent`, { force: true }).catch(() => void 0);
+    }
+    try {
+      this.onProcessExit?.(diagnostics);
+    } catch {
+    }
+    this.failTransport("codex_process_closed", diagnostics);
+  }
+  processExitDiagnostics(rawCode, rawSignal, termination) {
+    const source = termination ? "child_receipt" : this.guardian ? "guardian_process" : "direct_process";
+    const reportedCode = termination?.exit_code ?? rawCode;
+    const reportedSignal = termination?.signal ?? rawSignal;
+    const signal = typeof reportedSignal === "string" && /^(?:SIG[A-Z0-9]{1,28}|sig[a-z0-9]{1,28})$/u.test(reportedSignal) ? reportedSignal.toLowerCase() : null;
+    const exitCode = signal === null && typeof reportedCode === "number" && Number.isInteger(reportedCode) && reportedCode >= -(2 ** 31) && reportedCode <= 2 ** 31 - 1 ? reportedCode : null;
+    const diagnostics = {
+      schema_version: "external_inference_process_exit_v1",
+      runtime: "codex_app_server",
+      source,
+      session_generation: this.sessionGeneration,
+      expected_shutdown: termination?.expected ?? this.shutdownRequested,
+      exit_class: signal !== null ? "signal" : exitCode === null ? "unknown" : exitCode === 0 ? "zero" : "nonzero",
+      exit_code: exitCode,
+      signal,
+      uptime_ms: termination?.uptime_ms ?? Math.min(
+        Math.max(0, Date.now() - this.startedAtMs),
+        Number.MAX_SAFE_INTEGER
+      ),
+      pending_request_count: this.pending.size,
+      active_thread_count: this.threads.size,
+      stderr_nonempty: this.stderrNonempty,
+      stderr_bytes_observed: this.stderrBytesObserved,
+      stderr_truncated: this.stderrTruncated,
+      stderr_class: this.stderrNonempty ? this.stderrClass : "none"
+    };
+    this.stderrTail = "";
+    return diagnostics;
+  }
+  isUsable() {
+    return !this.closed && this.fatalError === null && this.process.exitCode === null;
+  }
+  async readAccountSnapshot(deadlineAtMs, signal, refreshToken = false) {
+    const result = await this.request("account/read", { refreshToken }, {
+      timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
+      signal
+    });
+    const account = objectOrNull(result.account);
+    if (typeof result.requiresOpenaiAuth !== "boolean") {
+      throw new CodexAppServerError({
+        message: "Codex returned invalid account metadata.",
+        category: "auth",
+        code: "invalid_account_metadata",
+        retryable: false
+      });
+    }
+    if (account?.type === "chatgpt") {
+      const email = account.email === null ? null : typeof account.email === "string" && account.email.trim() ? account.email.trim() : void 0;
+      if (email === void 0 || !validPlanType(account.planType)) {
+        throw new CodexAppServerError({
+          message: "Codex returned invalid managed ChatGPT account metadata.",
+          category: "auth",
+          code: "invalid_account_metadata",
+          retryable: false
+        });
+      }
+      return {
+        requiresOpenaiAuth: result.requiresOpenaiAuth,
+        authenticatedChatGptAccount: { email, planType: account.planType }
+      };
+    }
+    if (account !== null && account?.type !== "apiKey" && account?.type !== "amazonBedrock") {
+      throw new CodexAppServerError({
+        message: "Codex returned an unsupported account type.",
+        category: "auth",
+        code: "invalid_account_metadata",
+        retryable: false
+      });
+    }
+    return {
+      requiresOpenaiAuth: result.requiresOpenaiAuth,
+      authenticatedChatGptAccount: null
+    };
+  }
+  async hasManagedChatGptAuth(deadlineAtMs, signal, refreshToken = false) {
+    const snapshot = await this.readAccountSnapshot(deadlineAtMs, signal, refreshToken);
+    return snapshot.authenticatedChatGptAccount !== null && snapshot.requiresOpenaiAuth;
+  }
+  async readAccountRateLimits(deadlineAtMs, signal) {
+    const result = await this.request("account/rateLimits/read", void 0, {
+      timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
+      signal
+    });
+    try {
+      const rateLimits = parseRateLimitSnapshot(result.rateLimits);
+      const rawByLimitId = result.rateLimitsByLimitId;
+      let rateLimitsByLimitId = null;
+      if (rawByLimitId !== null && rawByLimitId !== void 0) {
+        const byLimitId = objectOrNull(rawByLimitId);
+        if (!byLimitId) throw new Error("invalid rate-limit bucket map");
+        rateLimitsByLimitId = {};
+        for (const [limitId, snapshot] of Object.entries(byLimitId)) {
+          if (!limitId.trim()) throw new Error("invalid rate-limit bucket identity");
+          rateLimitsByLimitId[limitId] = parseRateLimitSnapshot(snapshot);
+        }
+      }
+      return { rateLimits, rateLimitsByLimitId };
+    } catch (error) {
+      throw new CodexAppServerError({
+        message: "Codex returned invalid account rate-limit metadata.",
+        category: "adapter",
+        code: "invalid_rate_limit_metadata",
+        retryable: false,
+        cause: error
+      });
+    }
+  }
+  async requireManagedChatGptAuth(deadlineAtMs, signal, refreshToken = false) {
+    if (!await this.hasManagedChatGptAuth(deadlineAtMs, signal, refreshToken)) {
+      throw new CodexAppServerError({
+        message: "Codex managed ChatGPT authentication is required.",
+        category: "auth",
+        code: "managed_chatgpt_auth_required",
+        retryable: false
+      });
+    }
+  }
+  async startChatGptDeviceCodeLogin(deadlineAtMs, signal) {
+    const result = await this.request("account/login/start", { type: "chatgptDeviceCode" }, {
+      timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
+      signal
+    });
+    const loginId = typeof result.loginId === "string" ? result.loginId.trim() : "";
+    const verificationUrl = typeof result.verificationUrl === "string" ? result.verificationUrl.trim() : "";
+    const userCode = typeof result.userCode === "string" ? result.userCode.trim() : "";
+    if (result.type !== "chatgptDeviceCode" || !loginId || !verificationUrl.startsWith("https://") || !userCode) {
+      throw new CodexAppServerError({
+        message: "Codex returned an invalid device-code login challenge.",
+        category: "auth",
+        code: "invalid_device_code_challenge",
+        retryable: false
+      });
+    }
+    return { loginId, verificationUrl, userCode };
+  }
+  async waitForChatGptLogin(loginId, deadlineAtMs, signal) {
+    const settle = (completion, resolveCompletion, rejectCompletion) => {
+      this.accountLoginCompletions.delete(loginId);
+      if (completion.success) {
+        resolveCompletion();
+        return;
+      }
+      rejectCompletion(new CodexAppServerError({
+        message: "Codex ChatGPT device-code login failed.",
+        category: "auth",
+        code: "chatgpt_login_failed",
+        retryable: false
+      }));
+    };
+    const existing = this.accountLoginCompletions.get(loginId);
+    if (existing) {
+      await new Promise((resolveCompletion, rejectCompletion) => {
+        settle(existing, resolveCompletion, rejectCompletion);
+      });
+      return;
+    }
+    await new Promise((resolveCompletion, rejectCompletion) => {
+      let timer = null;
+      let abortCleanup = null;
+      let unsubscribe = null;
+      let unsubscribeFatal = null;
+      const cleanup = () => {
+        if (timer) clearTimeout(timer);
+        abortCleanup?.();
+        unsubscribe?.();
+        unsubscribeFatal?.();
+      };
+      const fail = (error) => {
+        cleanup();
+        rejectCompletion(error);
+      };
+      unsubscribe = this.subscribe(({ method, params }) => {
+        if (method !== "account/login/completed" || params.loginId !== loginId) return;
+        const completion = this.accountLoginCompletions.get(loginId);
+        if (!completion) {
+          fail(new CodexAppServerError({
+            message: "Codex returned an invalid device-code login completion.",
+            category: "auth",
+            code: "invalid_device_code_completion",
+            retryable: false
+          }));
+          return;
+        }
+        cleanup();
+        settle(completion, resolveCompletion, rejectCompletion);
+      });
+      unsubscribeFatal = this.subscribeFatal(fail);
+      timer = setTimeout(() => fail(new CodexAppServerError({
+        message: "Codex ChatGPT device-code login timed out.",
+        category: "timeout",
+        code: "chatgpt_login_timeout",
+        retryable: false
+      })), Math.max(1, deadlineAtMs - Date.now()));
+      if (signal) {
+        const onAbort = () => fail(new CodexAppServerError({
+          message: "Codex ChatGPT device-code login was cancelled.",
+          category: "cancelled",
+          code: "cancelled",
+          retryable: false
+        }));
+        signal.addEventListener("abort", onAbort, { once: true });
+        abortCleanup = () => signal.removeEventListener("abort", onAbort);
+        if (signal.aborted) onAbort();
+      }
+      const racedCompletion = this.accountLoginCompletions.get(loginId);
+      if (racedCompletion) {
+        cleanup();
+        settle(racedCompletion, resolveCompletion, rejectCompletion);
+      }
+    });
+  }
+  async cancelChatGptLogin(loginId, deadlineAtMs, signal) {
+    const result = await this.request("account/login/cancel", { loginId }, {
+      timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
+      signal
+    });
+    if (result.status !== "canceled" && result.status !== "notFound") {
+      throw new CodexAppServerError({
+        message: "Codex device-code login cancellation was not confirmed.",
+        category: "auth",
+        code: "device_code_cancel_unconfirmed",
+        retryable: false
+      });
+    }
+  }
+  async logoutManagedChatGptAuth(deadlineAtMs, signal) {
+    const result = await this.request("account/logout", void 0, {
+      timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
+      signal
+    });
+    if (Object.keys(result).length !== 0) {
+      throw new CodexAppServerError({
+        message: "Codex ChatGPT logout was not confirmed.",
+        category: "auth",
+        code: "chatgpt_logout_unconfirmed",
+        retryable: false
+      });
+    }
+  }
+  async readModelCapabilities(deadlineAtMs, signal) {
+    let cursor = null;
+    const seen = /* @__PURE__ */ new Set();
+    const capabilities = [];
+    do {
+      if (signal?.aborted) {
+        throw new CodexAppServerError({
+          message: "Codex model catalog request was cancelled before dispatch.",
+          category: "cancelled",
+          code: "cancelled",
+          retryable: false
+        });
+      }
+      if (Date.now() >= deadlineAtMs) {
+        throw new CodexAppServerError({
+          message: "Codex model catalog request exceeded the immutable deadline before dispatch.",
+          category: "timeout",
+          code: "deadline_exceeded",
+          retryable: false
+        });
+      }
+      const result = await this.request("model/list", {
+        includeHidden: false,
+        ...cursor ? { cursor } : {}
+      }, {
+        timeoutMs: Math.max(1, deadlineAtMs - Date.now()),
+        signal
+      });
+      const data = Array.isArray(result.data) ? result.data : [];
+      for (const raw of data) {
+        const candidate = objectOrNull(raw);
+        if (!candidate) continue;
+        const id = typeof candidate.id === "string" ? candidate.id.trim() : "";
+        const model = typeof candidate.model === "string" ? candidate.model.trim() : "";
+        const displayName = typeof candidate.displayName === "string" ? candidate.displayName.trim() : "";
+        const hidden = candidate.hidden === true;
+        const supportedReasoningEfforts = Array.isArray(candidate.supportedReasoningEfforts) ? candidate.supportedReasoningEfforts.flatMap((item) => {
+          const reasoningEffort = objectOrNull(item)?.reasoningEffort;
+          return typeof reasoningEffort === "string" && reasoningEffort.trim() ? [reasoningEffort.trim()] : [];
+        }) : [];
+        const defaultReasoningEffort = typeof candidate.defaultReasoningEffort === "string" ? candidate.defaultReasoningEffort.trim() : "";
+        if (!id || !model || !displayName || hidden || supportedReasoningEfforts.length === 0 || new Set(supportedReasoningEfforts).size !== supportedReasoningEfforts.length || !supportedReasoningEfforts.includes(defaultReasoningEffort)) continue;
+        capabilities.push(Object.freeze({
+          id,
+          model,
+          displayName,
+          hidden,
+          supportedReasoningEfforts: Object.freeze(supportedReasoningEfforts),
+          defaultReasoningEffort,
+          isDefault: candidate.isDefault === true
+        }));
+      }
+      cursor = typeof result.nextCursor === "string" && result.nextCursor ? result.nextCursor : null;
+      if (cursor && seen.has(cursor)) {
+        throw new CodexAppServerError({
+          message: "Codex model catalog repeated a cursor.",
+          category: "adapter",
+          code: "model_catalog_cursor_repeated",
+          retryable: false
+        });
+      }
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+    return Object.freeze(capabilities);
+  }
+  requireModelCapability(capabilities, modelName, reasoningEffort) {
+    const match = capabilities.find((candidate) => candidate.model === modelName || candidate.id === modelName);
+    if (!match) {
+      throw new CodexAppServerError({
+        message: "The requested Codex model is unavailable.",
+        category: "model",
+        code: "model_unavailable",
+        retryable: false
+      });
+    }
+    if (!match.supportedReasoningEfforts.includes(reasoningEffort)) {
+      throw new CodexAppServerError({
+        message: "The requested Codex reasoning effort is unavailable.",
+        category: "model",
+        code: "reasoning_effort_unavailable",
+        retryable: false
+      });
+    }
+  }
+  async requireModel(modelName, reasoningEffort, deadlineAtMs, signal) {
+    this.requireModelCapability(
+      await this.readModelCapabilities(deadlineAtMs, signal),
+      modelName,
+      reasoningEffort
+    );
+  }
+  async startThread(options) {
+    if (options.signal?.aborted) {
+      throw new CodexAppServerError({
+        message: "Codex thread request was cancelled before dispatch.",
+        category: "cancelled",
+        code: "cancelled",
+        retryable: false
+      });
+    }
+    if (Date.now() >= options.deadlineAtMs) {
+      throw new CodexAppServerError({
+        message: "Codex thread request exceeded the immutable deadline before dispatch.",
+        category: "timeout",
+        code: "deadline_exceeded",
+        retryable: false
+      });
+    }
+    const result = await this.request("thread/start", {
+      model: options.requestedModel,
+      modelProvider: "openai",
+      allowProviderModelFallback: false,
+      serviceTier: "default",
+      cwd: options.workspacePath,
+      runtimeWorkspaceRoots: [options.workspacePath],
+      approvalPolicy: "never",
+      permissions: CODEX_INFERENCE_PERMISSION_PROFILE,
+      ephemeral: false,
+      historyMode: "legacy",
+      environments: [],
+      dynamicTools: [],
+      selectedCapabilityRoots: [],
+      experimentalRawEvents: false,
+      developerInstructions: options.systemPrompt,
+      config: {
+        model_reasoning_effort: options.requestedReasoningEffort,
+        model_reasoning_summary: "none",
+        show_raw_agent_reasoning: true,
+        hide_agent_reasoning: false,
+        web_search: "disabled",
+        features: {
+          apps: false,
+          code_mode: false,
+          code_mode_buffered_exec: false,
+          code_mode_host: false,
+          code_mode_only: false,
+          in_app_browser: false,
+          js_repl: false,
+          js_repl_tools_only: false,
+          multi_agent: false,
+          multi_agent_v2: false,
+          plugin_sharing: false,
+          plugins: false,
+          remote_plugin: false,
+          shell_tool: false,
+          skill_mcp_dependency_install: false,
+          standalone_web_search: false,
+          web_search_cached: false,
+          web_search_request: false
+        }
+      }
+    }, {
+      timeoutMs: Math.max(1, options.deadlineAtMs - Date.now()),
+      signal: options.signal,
+      // Thread creation does not dispatch inference, but it can persist prompt
+      // bytes. Keep its exact reply correlated after cancellation so we can
+      // validate and delete the thread before reporting cleanup. The original
+      // RPC deadline still bounds setup; turn/start keeps normal cancellation.
+      retainResponseOnAbort: true
+    });
+    const thread = objectOrNull(result.thread);
+    const permission = objectOrNull(result.activePermissionProfile);
+    const sandbox = objectOrNull(result.sandbox);
+    const threadId = String(thread?.id || "");
+    const threadPath = String(thread?.path || "");
+    const resolvedHome = resolve2(this.codexHome);
+    const resolvedThreadPath = resolve2(threadPath);
+    const resolvedSessionsRoot = join2(resolvedHome, "sessions");
+    if (!threadId || !threadPath || !isAbsolute2(threadPath) || !resolvedThreadPath.startsWith(`${resolvedSessionsRoot}${sep}`) || !resolvedThreadPath.endsWith(".jsonl") || thread?.ephemeral !== false || thread?.modelProvider !== "openai" || !Array.isArray(thread?.turns) || thread.turns.length !== 0 || result.model !== options.requestedModel || result.modelProvider !== "openai" || result.serviceTier !== "default" || result.reasoningEffort !== options.requestedReasoningEffort || String(result.cwd || "") !== options.workspacePath || !Array.isArray(result.runtimeWorkspaceRoots) || result.runtimeWorkspaceRoots.length !== 0 || !Array.isArray(result.instructionSources) || result.instructionSources.length !== 0 || result.approvalPolicy !== "never" || result.approvalsReviewer !== "user" || sandbox?.type !== "readOnly" || sandbox.networkAccess !== false || permission?.id !== CODEX_INFERENCE_PERMISSION_PROFILE || permission.extends !== null) {
+      throw new CodexAppServerError({
+        message: "Codex thread isolation or effective settings were invalid.",
+        category: "adapter",
+        code: "invalid_thread_provenance",
+        retryable: false
+      });
+    }
+    this.threads.set(threadId, resolvedThreadPath);
+    if (options.signal?.aborted || Date.now() >= options.deadlineAtMs) {
+      await this.deleteThread(threadId);
+      throw new CodexAppServerError({
+        message: "Codex thread setup ended before inference dispatch.",
+        category: options.signal?.aborted ? "cancelled" : "timeout",
+        code: options.signal?.aborted ? "cancelled" : "deadline_exceeded",
+        retryable: false
+      });
+    }
+    return {
+      threadId,
+      threadPath: resolvedThreadPath,
+      effectiveModel: options.requestedModel,
+      effectiveReasoningEffort: options.requestedReasoningEffort
+    };
+  }
+  async startAgentThread(options) {
+    if (options.signal?.aborted || Date.now() >= options.deadlineAtMs) {
+      throw new CodexAppServerError({
+        message: "Codex Agent thread request was cancelled before dispatch.",
+        category: options.signal?.aborted ? "cancelled" : "timeout",
+        code: options.signal?.aborted ? "cancelled" : "deadline_exceeded",
+        retryable: false
+      });
+    }
+    const result = await this.request("thread/start", {
+      model: options.requestedModel,
+      modelProvider: "openai",
+      allowProviderModelFallback: false,
+      serviceTier: "default",
+      cwd: options.workspacePath,
+      runtimeWorkspaceRoots: [options.workspacePath],
+      approvalPolicy: "never",
+      permissions: CODEX_AGENT_PERMISSION_PROFILE,
+      ephemeral: false,
+      historyMode: "legacy",
+      environments: [],
+      dynamicTools: createCodexAgentToolSpecs(options.dataContract, options.decisionSchema),
+      selectedCapabilityRoots: [],
+      experimentalRawEvents: false,
+      developerInstructions: options.systemPrompt,
+      config: {
+        model_reasoning_effort: options.requestedReasoningEffort,
+        model_reasoning_summary: "none",
+        show_raw_agent_reasoning: true,
+        hide_agent_reasoning: false,
+        web_search: "live",
+        features: {
+          apps: false,
+          code_mode: true,
+          code_mode_buffered_exec: false,
+          code_mode_host: true,
+          code_mode_only: false,
+          in_app_browser: false,
+          js_repl: false,
+          js_repl_tools_only: false,
+          multi_agent: false,
+          multi_agent_v2: false,
+          plugin_sharing: false,
+          plugins: false,
+          remote_plugin: false,
+          shell_tool: false,
+          skill_mcp_dependency_install: false,
+          standalone_web_search: true,
+          web_search_cached: false,
+          web_search_request: true
+        }
+      }
+    }, {
+      timeoutMs: Math.max(1, options.deadlineAtMs - Date.now()),
+      signal: options.signal
+    });
+    return this.validateAgentThreadReceipt(result, options, false);
+  }
+  async resumeAgentThread(options) {
+    const expectedPath = resolve2(options.threadPath);
+    const sessionsRoot = join2(resolve2(this.codexHome), "sessions");
+    if (!options.threadId.trim() || !isAbsolute2(options.threadPath) || !expectedPath.startsWith(`${sessionsRoot}${sep}`) || !expectedPath.endsWith(".jsonl")) {
+      throw new CodexAppServerError({
+        message: "Codex Agent durable thread receipt was invalid.",
+        category: "adapter",
+        code: "invalid_agent_thread_receipt",
+        retryable: false
+      });
+    }
+    const result = await this.request("thread/resume", {
+      threadId: options.threadId,
+      model: options.requestedModel,
+      modelProvider: "openai",
+      serviceTier: "default",
+      cwd: options.workspacePath,
+      approvalPolicy: "never",
+      permissions: CODEX_AGENT_PERMISSION_PROFILE,
+      developerInstructions: options.systemPrompt,
+      config: {
+        model_reasoning_effort: options.requestedReasoningEffort,
+        model_reasoning_summary: "none",
+        web_search: "live"
+      }
+    }, {
+      timeoutMs: Math.max(1, options.deadlineAtMs - Date.now()),
+      signal: options.signal
+    });
+    const receipt = this.validateAgentThreadReceipt(result, options, true);
+    if (receipt.threadId !== options.threadId || receipt.threadPath !== expectedPath) {
+      throw new CodexAppServerError({
+        message: "Codex Agent resumed a different durable thread.",
+        category: "adapter",
+        code: "agent_thread_identity_changed",
+        retryable: false
+      });
+    }
+    return receipt;
+  }
+  validateAgentThreadReceipt(result, options, resumed) {
+    const thread = objectOrNull(result.thread);
+    const permission = objectOrNull(result.activePermissionProfile);
+    const sandbox = objectOrNull(result.sandbox);
+    const threadId = String(thread?.id || "");
+    const threadPath = String(thread?.path || "");
+    const resolvedThreadPath = resolve2(threadPath);
+    const sessionsRoot = join2(resolve2(this.codexHome), "sessions");
+    if (!threadId || !threadPath || !isAbsolute2(threadPath) || !resolvedThreadPath.startsWith(`${sessionsRoot}${sep}`) || !resolvedThreadPath.endsWith(".jsonl") || thread?.ephemeral !== false || thread?.modelProvider !== "openai" || !Array.isArray(thread?.turns) || !resumed && thread.turns.length !== 0 || result.model !== options.requestedModel || result.modelProvider !== "openai" || result.serviceTier !== "default" || result.reasoningEffort !== options.requestedReasoningEffort || String(result.cwd || "") !== options.workspacePath || !Array.isArray(result.instructionSources) || result.instructionSources.length !== 0 || result.approvalPolicy !== "never" || result.approvalsReviewer !== "user" || sandbox?.type !== "readOnly" || sandbox.networkAccess !== false || permission?.id !== CODEX_AGENT_PERMISSION_PROFILE || permission.extends !== null) {
+      throw new CodexAppServerError({
+        message: "Codex Agent thread isolation or effective settings were invalid.",
+        category: "adapter",
+        code: "invalid_agent_thread_provenance",
+        retryable: false
+      });
+    }
+    this.threads.set(threadId, resolvedThreadPath);
+    return {
+      threadId,
+      threadPath: resolvedThreadPath,
+      effectiveModel: options.requestedModel,
+      effectiveReasoningEffort: options.requestedReasoningEffort
+    };
+  }
+  async executeTurn(request) {
+    return await this.executeTurnWithPolicy(request, false);
+  }
+  async executeAgentTurn(request) {
+    return await this.executeTurnWithPolicy(request, true);
+  }
+  async executeTurnWithPolicy(request, agentMode) {
+    if (request.signal?.aborted || request.deadlineAtMs <= Date.now()) {
+      throw new CodexAppServerError({
+        message: "Codex turn was cancelled before dispatch.",
+        category: request.signal?.aborted ? "cancelled" : "timeout",
+        code: request.signal?.aborted ? "cancelled" : "deadline_exceeded",
+        retryable: false
+      });
+    }
+    let requestWritten = false;
+    let requestId = null;
+    let turnId = null;
+    let rerouted = false;
+    let rawResponseUsage = null;
+    let threadUsage = null;
+    let adapterResponseId = null;
+    let firstTokenAt = null;
+    let terminal = null;
+    let completedReasoningObserved = false;
+    let completedReasoningSequence = 0;
+    const completedReasoningContent = /* @__PURE__ */ new Map();
+    const agentToolCalls = [];
+    const agentWebSearches = [];
+    let terminalResolve;
+    let terminalReject;
+    const terminalPromise = new Promise((resolve3, reject) => {
+      terminalResolve = resolve3;
+      terminalReject = reject;
+    });
+    void terminalPromise.catch(() => void 0);
+    const unsubscribeFatal = this.subscribeFatal((error) => {
+      terminalReject(new CodexAppServerError({
+        message: error.message,
+        category: error.category,
+        code: error.code,
+        retryable: error.retryable,
+        dispatchOutcome: requestWritten ? "outcome_unknown" : "not_dispatched",
+        processExit: error.processExit,
+        cause: error
+      }));
+    });
+    const startedAt = Date.now();
+    const unsubscribe = this.subscribe(({ method, params }) => {
+      if (method === "thread/started") {
+        const startedThread = objectOrNull(params.thread);
+        if (!String(startedThread?.id || "")) {
+          terminalReject(new CodexAppServerError({
+            message: "Codex returned an invalid thread lifecycle notification.",
+            category: "adapter",
+            code: "invalid_thread_started_notification",
+            retryable: false,
+            dispatchOutcome: requestWritten ? turnId ? "confirmed_dispatched" : "outcome_unknown" : "not_dispatched"
+          }));
+        }
+        return;
+      }
+      const eventThreadId = String(params.threadId || "");
+      const scopedMethod = method.startsWith("thread/") || method.startsWith("turn/") || method.startsWith("item/") || method.startsWith("rawResponse") || method === "model/rerouted";
+      if (eventThreadId && eventThreadId !== request.thread.threadId) {
+        if (!this.threads.has(eventThreadId)) {
+          terminalReject(new CodexAppServerError({
+            message: "Codex notification crossed thread scope.",
+            category: "adapter",
+            code: "cross_thread_notification",
+            retryable: false,
+            dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+          }));
+        }
+        return;
+      }
+      if (scopedMethod && !eventThreadId) {
+        terminalReject(new CodexAppServerError({
+          message: "Codex notification omitted its thread scope.",
+          category: "adapter",
+          code: "missing_thread_notification_scope",
+          retryable: false,
+          dispatchOutcome: requestWritten ? turnId ? "confirmed_dispatched" : "outcome_unknown" : "not_dispatched"
+        }));
+        return;
+      }
+      if (agentMode ? forbiddenAgentMethod(method) : forbiddenMethod(method)) {
+        terminalReject(new CodexAppServerError({
+          message: "Codex attempted to use forbidden child authority.",
+          category: "adapter",
+          code: "forbidden_child_authority",
+          retryable: false,
+          dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+        }));
+        return;
+      }
+      if (method === "model/rerouted") {
+        rerouted = true;
+        terminalReject(new CodexAppServerError({
+          message: "Codex rerouted the requested model.",
+          category: "model",
+          code: "model_rerouted",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched"
+        }));
+        return;
+      }
+      if (method === "thread/settings/updated") {
+        const settings = objectOrNull(params.threadSettings);
+        const permission = objectOrNull(settings?.activePermissionProfile);
+        if (!settings || settings.model !== request.requestedModel || settings.modelProvider !== "openai" || settings.effort !== request.requestedReasoningEffort || settings.summary !== "none" || String(settings.cwd || "") !== request.workspacePath || settings.approvalPolicy !== "never" || permission?.id !== (agentMode ? CODEX_AGENT_PERMISSION_PROFILE : CODEX_INFERENCE_PERMISSION_PROFILE) || permission.extends !== null) {
+          terminalReject(new CodexAppServerError({
+            message: "Codex effective turn settings changed after dispatch.",
+            category: "adapter",
+            code: "effective_settings_changed",
+            retryable: false,
+            dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+          }));
+          return;
+        }
+      }
+      const eventTurn = objectOrNull(params.turn);
+      const eventTurnId = String(params.turnId || eventTurn?.id || "");
+      if (eventTurnId && !eventThreadId) {
+        terminalReject(new CodexAppServerError({
+          message: "Codex turn notification omitted its thread scope.",
+          category: "adapter",
+          code: "missing_thread_notification_scope",
+          retryable: false,
+          dispatchOutcome: requestWritten ? turnId ? "confirmed_dispatched" : "outcome_unknown" : "not_dispatched"
+        }));
+        return;
+      }
+      const turnScopedMethod = method.startsWith("turn/") || method.startsWith("item/") || method.startsWith("rawResponse") || method === "model/rerouted";
+      if (turnScopedMethod && !eventTurnId) {
+        terminalReject(new CodexAppServerError({
+          message: "Codex notification omitted its turn scope.",
+          category: "adapter",
+          code: "missing_turn_notification_scope",
+          retryable: false,
+          dispatchOutcome: requestWritten ? turnId ? "confirmed_dispatched" : "outcome_unknown" : "not_dispatched"
+        }));
+        return;
+      }
+      if (eventTurnId) {
+        if (turnId && turnId !== eventTurnId) {
+          terminalReject(new CodexAppServerError({
+            message: "Codex notification crossed turn scope.",
+            category: "adapter",
+            code: "cross_turn_notification",
+            retryable: false,
+            dispatchOutcome: "confirmed_dispatched"
+          }));
+          return;
+        }
+        turnId = eventTurnId;
+      }
+      if (method === "item/agentMessage/delta" && String(params.delta || "").length > 0 && firstTokenAt === null) {
+        firstTokenAt = Date.now();
+      }
+      if (method === "item/started" || method === "item/completed") {
+        const item = objectOrNull(params.item);
+        if (!item || (agentMode ? forbiddenAgentTerminalItem(item) : forbiddenTerminalItem(item))) {
+          terminalReject(new CodexAppServerError({
+            message: "Codex attempted forbidden tool activity.",
+            category: "adapter",
+            code: "forbidden_child_authority",
+            retryable: false,
+            dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+          }));
+          return;
+        }
+        if (method === "item/completed" && item.type === "reasoning") {
+          completedReasoningObserved = true;
+          const itemId = String(item.id || params.itemId || "").trim();
+          const itemKey = itemId ? `id:${itemId}` : `sequence:${completedReasoningSequence++}`;
+          completedReasoningContent.set(
+            itemKey,
+            Array.isArray(item.content) ? item.content : []
+          );
+        }
+        if (agentMode && method === "item/completed" && item.type === "dynamicToolCall") {
+          const tool = String(item.tool || "");
+          const callArguments = objectOrNull(item.arguments);
+          const callId = String(item.id || "").trim();
+          if (!callId || !CODEX_AGENT_DYNAMIC_TOOLS.includes(tool) || !callArguments || typeof item.success !== "boolean") {
+            terminalReject(new CodexAppServerError({
+              message: "Codex Agent returned invalid dynamic-tool evidence.",
+              category: "adapter",
+              code: "invalid_dynamic_tool_evidence",
+              retryable: false,
+              dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+            }));
+            return;
+          }
+          agentToolCalls.push({
+            callId,
+            tool,
+            arguments: callArguments,
+            success: item.success
+          });
+        }
+        if (agentMode && method === "item/completed" && item.type === "webSearch") {
+          const query = typeof item.query === "string" ? item.query.trim() : "";
+          if (!query) {
+            terminalReject(new CodexAppServerError({
+              message: "Codex Agent returned invalid web-search evidence.",
+              category: "adapter",
+              code: "invalid_web_search_evidence",
+              retryable: false,
+              dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+            }));
+            return;
+          }
+          agentWebSearches.push({ query, action: objectOrNull(item.action) });
+        }
+      }
+      const observedUsage = usageFromNotification(method, params);
+      if (method === "rawResponse/completed") {
+        const responseId = String(params.responseId || "").trim();
+        if (!responseId || !observedUsage || adapterResponseId !== null) {
+          terminalReject(new CodexAppServerError({
+            message: "Codex raw response evidence was invalid or ambiguous.",
+            category: "adapter",
+            code: "invalid_raw_response_evidence",
+            retryable: false,
+            dispatchOutcome: turnId ? "confirmed_dispatched" : "outcome_unknown"
+          }));
+          return;
+        }
+        adapterResponseId = responseId;
+        rawResponseUsage = observedUsage;
+      } else if (method === "thread/tokenUsage/updated" && observedUsage) {
+        threadUsage = observedUsage;
+      }
+      if (method === "turn/completed" && eventTurn) {
+        terminal = eventTurn;
+        terminalResolve(eventTurn);
+      }
+    });
+    if (agentMode) {
+      if (this.agentToolHandlers.has(request.thread.threadId)) {
+        unsubscribe();
+        unsubscribeFatal();
+        throw new CodexAppServerError({
+          message: "Codex Agent thread already has an active turn.",
+          category: "adapter",
+          code: "agent_thread_turn_already_active",
+          retryable: false
+        });
+      }
+      this.agentToolHandlers.set(
+        request.thread.threadId,
+        {
+          execute: request.executeTool,
+          acceptTurnId: (candidate) => {
+            if (turnId && turnId !== candidate) return false;
+            turnId = candidate;
+            return true;
+          },
+          calls: /* @__PURE__ */ new Map()
+        }
+      );
+    }
+    try {
+      const remaining = () => Math.max(1, request.deadlineAtMs - Date.now());
+      let startResult;
+      try {
+        startResult = await this.request("turn/start", {
+          threadId: request.thread.threadId,
+          input: [{ type: "text", text: request.userPrompt, text_elements: [] }],
+          environments: [],
+          cwd: request.workspacePath,
+          runtimeWorkspaceRoots: [request.workspacePath],
+          approvalPolicy: "never",
+          permissions: agentMode ? CODEX_AGENT_PERMISSION_PROFILE : CODEX_INFERENCE_PERMISSION_PROFILE,
+          model: request.requestedModel,
+          serviceTier: "default",
+          effort: request.requestedReasoningEffort,
+          summary: "none",
+          outputSchema: request.outputSchema
+        }, {
+          timeoutMs: remaining(),
+          signal: request.signal,
+          notAfterMs: "providerDispatchNotAfterMs" in request ? request.providerDispatchNotAfterMs : void 0,
+          beforeWrite: async (id) => {
+            requestId = id;
+            try {
+              await request.onDispatchState?.({
+                requestId: String(id),
+                turnId,
+                dispatchOutcome: "outcome_unknown"
+              });
+            } catch (error) {
+              throw new CodexAppServerError({
+                message: "Codex pre-dispatch recovery evidence could not be persisted.",
+                category: "adapter",
+                code: "recovery_checkpoint_failed",
+                retryable: false,
+                dispatchOutcome: "not_dispatched",
+                cause: error
+              });
+            }
+          },
+          onWritten: (id) => {
+            requestWritten = true;
+            requestId = id;
+            if ("onProviderDispatch" in request) request.onProviderDispatch?.();
+          }
+        });
+      } catch (error) {
+        if (error instanceof CodexAppServerError && requestWritten) {
+          throw new CodexAppServerError({
+            message: error.message,
+            category: error.category,
+            code: error.code,
+            retryable: error.retryable,
+            dispatchOutcome: "outcome_unknown",
+            processExit: error.processExit,
+            cause: error
+          });
+        }
+        throw error;
+      }
+      const startedTurn = objectOrNull(startResult.turn);
+      const responseTurnId = String(startedTurn?.id || "");
+      if (!responseTurnId || turnId && turnId !== responseTurnId) {
+        throw new CodexAppServerError({
+          message: "Codex turn start response was invalid.",
+          category: "adapter",
+          code: "invalid_turn_start",
+          retryable: false,
+          dispatchOutcome: "outcome_unknown"
+        });
+      }
+      turnId = responseTurnId;
+      try {
+        await request.onDispatchState?.({
+          requestId: String(requestId),
+          turnId,
+          dispatchOutcome: "confirmed_dispatched"
+        });
+      } catch (error) {
+        try {
+          await this.interrupt(request.thread.threadId, turnId, Math.min(5e3, remaining()));
+        } catch {
+        }
+        throw new CodexAppServerError({
+          message: "Codex confirmed-dispatch evidence could not be persisted.",
+          category: "adapter",
+          code: "recovery_checkpoint_failed",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched",
+          cause: error
+        });
+      }
+      if (rerouted) {
+        throw new CodexAppServerError({
+          message: "Codex rerouted the requested model.",
+          category: "model",
+          code: "model_rerouted",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched"
+        });
+      }
+      let deadlineTimer = null;
+      let abortHandler = null;
+      const abortPromise = new Promise((_, reject) => {
+        const abort = () => reject(new CodexAppServerError({
+          message: "Codex turn was cancelled.",
+          category: "cancelled",
+          code: "cancelled",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched"
+        }));
+        if (request.signal?.aborted) {
+          abort();
+          return;
+        }
+        abortHandler = abort;
+        request.signal?.addEventListener("abort", abort, { once: true });
+      });
+      const deadlinePromise = new Promise((_, reject) => {
+        deadlineTimer = setTimeout(() => reject(new CodexAppServerError({
+          message: "Codex turn exceeded its immutable deadline.",
+          category: "timeout",
+          code: "deadline_exceeded",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched"
+        })), remaining());
+      });
+      try {
+        try {
+          terminal = terminal ?? await Promise.race([terminalPromise, abortPromise, deadlinePromise]);
+        } catch (error) {
+          try {
+            await this.interrupt(request.thread.threadId, turnId, Math.min(5e3, remaining()));
+          } catch {
+          }
+          throw error;
+        }
+      } finally {
+        if (deadlineTimer) clearTimeout(deadlineTimer);
+        if (request.signal && abortHandler) request.signal.removeEventListener("abort", abortHandler);
+      }
+      if (terminal.status !== "completed") {
+        const turnError = objectOrNull(terminal.error);
+        let failure = classifyCodexTurnFailure(
+          turnError?.codexErrorInfo,
+          String(terminal.status)
+        );
+        const observedUsage = threadUsage ?? rawResponseUsage;
+        let retryAtMs = null;
+        let observedRateLimits = null;
+        if (failure.code === "quota_exceeded" || failure.httpStatusCode === 429) {
+          const observedAtMs = Date.now();
+          let accountLimitReached = failure.code === "quota_exceeded";
+          try {
+            const metadataDeadlineAtMs = Math.min(
+              request.deadlineAtMs,
+              observedAtMs + 5e3
+            );
+            if (metadataDeadlineAtMs <= observedAtMs) throw new Error("rate-limit deadline elapsed");
+            observedRateLimits = await this.readAccountRateLimits(
+              metadataDeadlineAtMs,
+              request.signal
+            );
+            accountLimitReached = accountLimitReached || codexAccountRateLimitReached(observedRateLimits);
+            retryAtMs = codexRateLimitRetryAtMs(observedRateLimits);
+          } catch {
+          }
+          if (accountLimitReached) {
+            failure = {
+              ...failure,
+              code: "quota_exceeded",
+              category: "model",
+              retryable: false
+            };
+            if (retryAtMs === null || retryAtMs <= observedAtMs) {
+              retryAtMs = observedAtMs + DEFAULT_CODEX_QUOTA_COOLDOWN_MS;
+            } else {
+              retryAtMs = Math.min(
+                retryAtMs,
+                observedAtMs + MAX_CODEX_QUOTA_COOLDOWN_MS
+              );
+            }
+          } else {
+            retryAtMs = observedAtMs + CODEX_TRANSIENT_RATE_LIMIT_COOLDOWN_MS;
+          }
+        }
+        throw new CodexAppServerError({
+          message: "Codex turn did not complete successfully.",
+          category: failure.category,
+          code: failure.code,
+          retryable: failure.retryable,
+          dispatchOutcome: "confirmed_dispatched",
+          httpStatusCode: failure.httpStatusCode,
+          retryAtMs,
+          usage: observedUsage,
+          rateLimits: observedRateLimits
+        });
+      }
+      const items = Array.isArray(terminal.items) ? terminal.items.map(objectOrNull) : [];
+      if (items.some((item) => !item || (agentMode ? forbiddenAgentTerminalItem(item) : forbiddenTerminalItem(item)))) {
+        throw new CodexAppServerError({
+          message: "Codex terminal output contained forbidden tool activity.",
+          category: "adapter",
+          code: "forbidden_child_authority",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched"
+        });
+      }
+      const finalMessages = items.filter((item) => item?.type === "agentMessage" && item.phase === "final_answer");
+      const fallbackMessages = items.filter((item) => item?.type === "agentMessage" && item.phase == null);
+      const answerItem = finalMessages.at(-1) ?? fallbackMessages.at(-1);
+      const text = typeof answerItem?.text === "string" ? answerItem.text : "";
+      const reasoningContentSections = completedReasoningObserved ? [...completedReasoningContent.values()] : items.flatMap((item) => item?.type === "reasoning" && Array.isArray(item.content) ? [item.content] : []);
+      const reasoningContentParts = reasoningContentSections.flatMap((content) => content.filter((part) => typeof part === "string" && part.trim().length > 0));
+      const reasoningContentCandidate = reasoningContentParts.length > 0 ? reasoningContentParts.join("\n\n") : null;
+      const reasoningContent = reasoningContentCandidate !== null && Buffer.byteLength(reasoningContentCandidate, "utf8") <= CODEX_REASONING_CONTENT_MAX_UTF8_BYTES ? reasoningContentCandidate : null;
+      const usage = threadUsage ?? rawResponseUsage;
+      const responseIdentity = adapterResponseId ?? turnId;
+      if (!text || !usage || !responseIdentity) {
+        throw new CodexAppServerError({
+          message: !text ? "Codex returned no terminal answer." : !usage ? "Codex returned no valid token usage." : "Codex returned no response identity.",
+          category: "adapter",
+          code: !text ? "missing_terminal_answer" : !usage ? "missing_token_usage" : "missing_response_identity",
+          retryable: false,
+          dispatchOutcome: "confirmed_dispatched"
+        });
+      }
+      const result = {
+        text,
+        reasoningContent,
+        reasoningSummary: null,
+        requestedModel: request.requestedModel,
+        effectiveModel: request.thread.effectiveModel,
+        requestedReasoningEffort: request.requestedReasoningEffort,
+        effectiveReasoningEffort: request.thread.effectiveReasoningEffort,
+        adapterRequestId: String(requestId),
+        adapterResponseId: responseIdentity,
+        usage,
+        latencyMs: Math.max(0, Date.now() - startedAt),
+        timeToFirstTokenMs: firstTokenAt === null ? null : Math.max(0, firstTokenAt - startedAt),
+        terminalStatus: "completed"
+      };
+      return agentMode ? {
+        ...result,
+        toolCalls: agentToolCalls,
+        webSearches: agentWebSearches
+      } : result;
+    } finally {
+      if (agentMode) this.agentToolHandlers.delete(request.thread.threadId);
+      unsubscribe();
+      unsubscribeFatal();
+    }
+  }
+  async interrupt(threadId, turnId, timeoutMs = 5e3) {
+    const result = await this.request("turn/interrupt", { threadId, turnId }, { timeoutMs });
+    if (Object.keys(result).length !== 0) {
+      throw new CodexAppServerError({
+        message: "Codex interrupt response was invalid.",
+        category: "adapter",
+        code: "invalid_interrupt_response",
+        retryable: false,
+        dispatchOutcome: "confirmed_dispatched"
+      });
+    }
+  }
+  async deleteThread(threadId) {
+    const threadPath = this.threads.get(threadId);
+    if (!threadPath) {
+      throw new CodexAppServerError({
+        message: "Codex thread cleanup identity was unavailable.",
+        category: "adapter",
+        code: "thread_cleanup_identity_missing",
+        retryable: false
+      });
+    }
+    const result = await this.request("thread/delete", { threadId }, { timeoutMs: 3e4 });
+    if (Object.keys(result).length !== 0) {
+      throw new CodexAppServerError({
+        message: "Codex thread deletion was not confirmed.",
+        category: "adapter",
+        code: "thread_delete_unconfirmed",
+        retryable: false
+      });
+    }
+    const loaded = await this.request("thread/loaded/list", {}, { timeoutMs: 3e4 });
+    const data = Array.isArray(loaded.data) ? loaded.data : null;
+    if (data === null || loaded.nextCursor != null || data.some((item) => String(objectOrNull(item)?.id ?? item) === threadId)) {
+      throw new CodexAppServerError({
+        message: "Codex thread remained loaded after deletion.",
+        category: "adapter",
+        code: "thread_delete_unconfirmed",
+        retryable: false
+      });
+    }
+    try {
+      await lstat2(threadPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        this.threads.delete(threadId);
+        return;
+      }
+      throw error;
+    }
+    throw new CodexAppServerError({
+      message: "Codex persisted thread remained after deletion.",
+      category: "adapter",
+      code: "thread_delete_unconfirmed",
+      retryable: false
+    });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.processCloseObserved || this.process.exitCode !== null) {
+      if (this.guardian) {
+        await rm2(`${this.guardian.receiptPath}.shutdown-intent`, { force: true }).catch(() => void 0);
+      }
+      return;
+    }
+    this.shutdownRequested = true;
+    if (this.guardian) {
+      await writeFile(
+        `${this.guardian.receiptPath}.shutdown-intent`,
+        this.guardian.processToken,
+        { mode: 384 }
+      ).catch(() => void 0);
+    }
+    this.process.stdin.end();
+    const exited = await new Promise((resolve3) => {
+      if (this.process.exitCode !== null) {
+        resolve3(true);
+        return;
+      }
+      const timer = setTimeout(() => resolve3(false), 5e3);
+      this.process.once("close", () => {
+        clearTimeout(timer);
+        resolve3(true);
+      });
+    });
+    if (exited) return;
+    const pid = this.process.pid;
+    try {
+      if (pid && process.platform === "win32") await killWindowsProcessTree(pid);
+      else if (pid) process.kill(-pid, "SIGTERM");
+      else this.process.kill("SIGTERM");
+    } catch {
+    }
+    const terminated = await new Promise((resolve3) => {
+      const timer = setTimeout(() => resolve3(false), 1e3);
+      this.process.once("close", () => {
+        clearTimeout(timer);
+        resolve3(true);
+      });
+    });
+    if (!terminated) {
+      try {
+        if (pid && process.platform === "win32") await killWindowsProcessTree(pid);
+        else if (pid) process.kill(-pid, "SIGKILL");
+        else this.process.kill("SIGKILL");
+      } catch {
+      }
+      await new Promise((resolve3) => {
+        if (this.process.exitCode !== null) {
+          resolve3();
+          return;
+        }
+        const timer = setTimeout(resolve3, 1e3);
+        this.process.once("close", () => {
+          clearTimeout(timer);
+          resolve3();
+        });
+      });
+      if (this.process.exitCode === null) {
+        throw new CodexAppServerError({
+          message: "Codex process-tree cleanup could not be confirmed.",
+          category: "adapter",
+          code: "process_tree_cleanup_unconfirmed",
+          retryable: false
+        });
+      }
+    }
+  }
+};
+
+// lib/inference-host/managed-codex-wrapper.ts
+var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var nonnegative = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+var ManagedCodexWrapperFailure = class extends Error {
+  constructor(code, dispatchOutcome) {
+    super(code);
+    this.dispatchOutcome = dispatchOutcome;
+  }
+};
+async function runManagedCodexWrapper(binary) {
+  if (!isAbsolute3(binary) || binary.includes("\0")) throw new ManagedCodexWrapperFailure("codex_binary_must_be_absolute", "not_dispatched");
+  const host = createInterface2({ input: process.stdin, crlfDelay: Infinity });
+  const frames = host[Symbol.asyncIterator]();
+  const first = await frames.next();
+  if (first.done) throw new ManagedCodexWrapperFailure("missing_turn", "not_dispatched");
+  let turn;
+  try {
+    turn = object(JSON.parse(first.value));
+  } catch {
+    host.close();
+    throw new ManagedCodexWrapperFailure("invalid_turn", "not_dispatched");
+  }
+  if (turn.schema_version !== "vtx_managed_harness_turn_v1" || turn.type !== "turn" || typeof turn.requested_model !== "string" || typeof turn.requested_reasoning_effort !== "string" || typeof turn.system_prompt !== "string" || typeof turn.user_prompt !== "string" || !Array.isArray(turn.data_contract)) {
+    host.close();
+    throw new ManagedCodexWrapperFailure("invalid_turn", "not_dispatched");
+  }
+  const deadline = Date.parse(String(turn.deadline_at));
+  if (!Number.isFinite(deadline) || deadline <= Date.now()) {
+    host.close();
+    throw new ManagedCodexWrapperFailure("expired_turn", "not_dispatched");
+  }
+  const child = spawn3(binary, ["app-server", "--stdio"], {
+    cwd: process.cwd(),
+    env: process.env,
+    shell: false,
+    windowsHide: true,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const nativeClosed = new Promise((resolve3) => {
+    child.once("close", () => resolve3());
+  });
+  let nativeDispatchAttempted = false;
+  let terminalError = null;
+  const native = createInterface2({ input: child.stdout, crlfDelay: Infinity });
+  child.stderr.on("data", () => void 0);
+  const sendHost = (frame) => {
+    process.stdout.write(`${JSON.stringify(frame)}
+`);
+  };
+  const sendNative = (frame) => {
+    child.stdin.write(`${JSON.stringify(frame)}
+`);
+  };
+  let requestId = 0;
+  const pending = /* @__PURE__ */ new Map();
+  const tools = /* @__PURE__ */ new Map();
+  let failed = null;
+  let failTurn;
+  const failure = new Promise((_resolve, reject) => {
+    failTurn = reject;
+  });
+  void failure.catch(() => void 0);
+  const fail = (code) => {
+    if (failed) return;
+    failed = new Error(code);
+    for (const item of pending.values()) item.reject(failed);
+    pending.clear();
+    failTurn(failed);
+  };
+  const request = (method, params) => {
+    if (failed) return Promise.reject(failed);
+    const id = ++requestId;
+    return new Promise((resolve3, reject) => {
+      pending.set(id, { resolve: resolve3, reject });
+      sendNative({ id, method, params });
+    });
+  };
+  let threadId = null;
+  let nativeTurnId = null;
+  let nativeTurnRequestId = null;
+  let nativeResponseId = null;
+  let acknowledged = false;
+  let finalText = "";
+  let usage = null;
+  let completed;
+  const terminal = new Promise((resolve3) => {
+    completed = resolve3;
+  });
+  const timer = setTimeout(() => fail("codex_deadline_exceeded"), deadline - Date.now());
+  child.on("error", () => fail("codex_process_start_failed"));
+  child.stdin.on("error", () => fail("codex_input_failed"));
+  child.on("close", () => {
+    if (!finalText) fail("codex_process_exited");
+  });
+  const scoped = (params) => !params.threadId || threadId === null || params.threadId === threadId;
+  native.on("line", (line) => {
+    try {
+      const message = object(JSON.parse(line));
+      if (typeof message.id === "number" && !message.method) {
+        const waiter = pending.get(message.id);
+        if (!waiter) {
+          fail("codex_unknown_response");
+          return;
+        }
+        pending.delete(message.id);
+        if (message.error) waiter.reject(new Error("codex_request_failed"));
+        else waiter.resolve(object(message.result));
+        return;
+      }
+      const params = object(message.params);
+      if (!scoped(params)) {
+        fail("codex_thread_scope_changed");
+        return;
+      }
+      if (message.method === "item/tool/call" && message.id !== void 0) {
+        if (!acknowledged || !threadId || params.threadId !== threadId || typeof params.callId !== "string" || tools.has(params.callId) || !CODEX_AGENT_DYNAMIC_TOOLS.includes(params.tool) || nativeTurnId && params.turnId !== nativeTurnId || !(typeof message.id === "number" || typeof message.id === "string")) {
+          fail("codex_invalid_tool_request");
+          return;
+        }
+        tools.set(params.callId, message.id);
+        sendHost({ type: "tool_call", call_id: params.callId, tool: params.tool, arguments: params.arguments });
+        return;
+      }
+      if (message.id !== void 0) {
+        fail("codex_interactive_request_required");
+        return;
+      }
+      if (message.method === "model/rerouted") {
+        fail("codex_model_rerouted");
+        return;
+      }
+      if (message.method === "thread/settings/updated") {
+        const settings = object(params.threadSettings);
+        if (settings.model !== turn.requested_model || settings.effort !== turn.requested_reasoning_effort || settings.modelProvider !== "openai") {
+          fail("codex_effective_selection_changed");
+          return;
+        }
+      }
+      if (message.method === "turn/started") {
+        const started = object(params.turn);
+        if (typeof started.id === "string") nativeTurnId = started.id;
+      }
+      if (message.method === "item/completed") {
+        const item = object(params.item);
+        if (item.type === "agentMessage" && typeof item.text === "string") finalText = item.text;
+      }
+      if (message.method === "thread/tokenUsage/updated") {
+        const tokens = object(object(params.tokenUsage).last);
+        const names = ["inputTokens", "cachedInputTokens", "outputTokens", "reasoningOutputTokens", "totalTokens"];
+        if (!names.every((key) => nonnegative(tokens[key])) || Number(tokens.cachedInputTokens) > Number(tokens.inputTokens) || Number(tokens.reasoningOutputTokens) > Number(tokens.outputTokens) || Number(tokens.totalTokens) !== Number(tokens.inputTokens) + Number(tokens.outputTokens)) {
+          fail("codex_usage_unavailable");
+          return;
+        }
+        usage = Object.fromEntries(names.map((key) => [key, tokens[key]]));
+        usage.cacheWriteInputTokens = null;
+        usage.cacheWriteSupported = false;
+      }
+      if (message.method === "rawResponse/completed" && typeof params.responseId === "string") nativeResponseId = params.responseId;
+      if (message.method === "turn/completed") {
+        const result = object(params.turn);
+        if (result.status !== "completed") {
+          const info = object(result.error).codexErrorInfo;
+          const categories = {
+            contextWindowExceeded: "context_window_exceeded",
+            sessionBudgetExceeded: "session_budget_exceeded",
+            usageLimitExceeded: "usage_limit_exceeded",
+            serverOverloaded: "server_overloaded",
+            cyberPolicy: "policy_rejected",
+            internalServerError: "internal_server_error",
+            unauthorized: "unauthorized",
+            badRequest: "bad_request",
+            sandboxError: "sandbox_error",
+            other: "other"
+          };
+          const category = typeof info === "string" ? categories[info] : [
+            "httpConnectionFailed",
+            "responseStreamConnectionFailed",
+            "responseStreamDisconnected",
+            "responseTooManyFailedAttempts"
+          ].find((key) => key in object(info))?.replace(/[A-Z]/gu, (letter) => `_${letter.toLowerCase()}`);
+          fail(`codex_turn_${category ?? "failed"}`);
+        } else if (!nativeTurnId || result.id !== nativeTurnId) fail("codex_turn_identity_unverified");
+        else completed();
+      }
+    } catch {
+      fail("codex_protocol_invalid");
+    }
+  });
+  try {
+    await request("initialize", {
+      clientInfo: { name: "vtx_managed_agent", version: "1" },
+      capabilities: { experimentalApi: true }
+    });
+    sendNative({ method: "initialized", params: {} });
+    let selected;
+    let cursor;
+    const seenCursors = /* @__PURE__ */ new Set();
+    do {
+      const catalog = await request("model/list", { ...cursor ? { cursor } : {} });
+      selected = Array.isArray(catalog.data) ? catalog.data.map(object).find((model) => model.model === turn.requested_model || model.id === turn.requested_model) : void 0;
+      cursor = typeof catalog.nextCursor === "string" && catalog.nextCursor ? catalog.nextCursor : void 0;
+      if (cursor && seenCursors.has(cursor)) throw new Error("codex_catalog_cursor_repeated");
+      if (cursor) seenCursors.add(cursor);
+    } while (!selected && cursor);
+    if (!selected || !Array.isArray(selected.supportedReasoningEfforts) || !selected.supportedReasoningEfforts.some((entry) => object(entry).reasoningEffort === turn.requested_reasoning_effort)) {
+      throw new Error("codex_selection_not_available");
+    }
+    const threadParams = {
+      model: turn.requested_model,
+      modelProvider: "openai",
+      allowProviderModelFallback: false,
+      cwd: process.cwd(),
+      developerInstructions: turn.system_prompt,
+      config: { model_reasoning_effort: turn.requested_reasoning_effort }
+    };
+    const started = turn.resume_id ? await request("thread/resume", { ...threadParams, threadId: turn.resume_id }) : await request("thread/start", {
+      ...threadParams,
+      experimentalRawEvents: false,
+      dynamicTools: createCodexAgentToolSpecs(turn.data_contract, object(turn.decision_schema))
+    });
+    const nativeThread = object(started.thread);
+    if (started.model !== turn.requested_model || started.reasoningEffort !== turn.requested_reasoning_effort || started.modelProvider !== "openai" || typeof nativeThread.id !== "string" || turn.resume_id && nativeThread.id !== turn.resume_id) throw new Error("codex_thread_selection_unverified");
+    threadId = nativeThread.id;
+    sendHost({
+      type: "thread_ready",
+      resume_id: threadId,
+      effective_model: started.model,
+      effective_reasoning_effort: started.reasoningEffort
+    });
+    const ack = await Promise.race([frames.next(), failure]);
+    if (ack.done) throw new Error("host_disconnected");
+    const acknowledgement = object(JSON.parse(ack.value));
+    if (acknowledgement.type !== "thread_ready" || acknowledgement.acknowledged !== true || acknowledgement.resume_id !== threadId) throw new Error("thread_not_checkpointed");
+    acknowledged = true;
+    const hostReplies = (async () => {
+      while (true) {
+        const next = await frames.next();
+        if (next.done) return;
+        const result = object(JSON.parse(next.value));
+        const id = tools.get(String(result.call_id));
+        if (result.type !== "tool_result" || id === void 0) {
+          fail("host_tool_result_invalid");
+          return;
+        }
+        tools.delete(String(result.call_id));
+        sendNative({ id, result: {
+          contentItems: [{ type: "inputText", text: JSON.stringify(result.value ?? null) }],
+          success: result.success === true
+        } });
+      }
+    })();
+    void hostReplies.catch(() => fail("host_protocol_failed"));
+    nativeTurnRequestId = requestId + 1;
+    nativeDispatchAttempted = true;
+    const begun = await request("turn/start", {
+      threadId,
+      input: [{ type: "text", text: turn.user_prompt, text_elements: [] }],
+      model: turn.requested_model,
+      effort: turn.requested_reasoning_effort,
+      outputSchema: turn.output_schema
+    });
+    const returnedTurnId = object(begun.turn).id;
+    if (typeof returnedTurnId !== "string" || nativeTurnId && returnedTurnId !== nativeTurnId) throw new Error("codex_turn_identity_unverified");
+    nativeTurnId = returnedTurnId;
+    await Promise.race([terminal, failure]);
+    if (!usage) throw new Error("codex_usage_unavailable");
+    if (!finalText) throw new Error("codex_final_text_unavailable");
+    if (tools.size) throw new Error("codex_tool_outcome_unresolved");
+    sendHost({
+      type: "complete",
+      text: finalText,
+      requested_model: turn.requested_model,
+      effective_model: started.model,
+      requested_reasoning_effort: turn.requested_reasoning_effort,
+      effective_reasoning_effort: started.reasoningEffort,
+      adapter_request_id: String(nativeTurnRequestId),
+      adapter_response_id: nativeResponseId ?? nativeTurnId,
+      usage
+    });
+  } catch (error) {
+    terminalError = error;
+  } finally {
+    clearTimeout(timer);
+    host.close();
+    native.close();
+    child.stdin.end();
+    child.kill("SIGTERM");
+    const waitForClose = async () => {
+      let timeout;
+      try {
+        return await Promise.race([
+          nativeClosed.then(() => true),
+          new Promise((resolve3) => {
+            timeout = setTimeout(() => resolve3(false), 1e3);
+          })
+        ]);
+      } finally {
+        clearTimeout(timeout);
+      }
+    };
+    let closed = await waitForClose();
+    if (!closed) {
+      child.kill("SIGKILL");
+      closed = await waitForClose();
+    }
+    if (!closed) throw new ManagedCodexWrapperFailure("codex_teardown_unconfirmed", "outcome_unknown");
+  }
+  if (terminalError !== null) {
+    const code = terminalError instanceof Error && /^[a-z_]{1,80}$/u.test(terminalError.message) ? terminalError.message : "native_terminal_evidence_unconfirmed";
+    throw new ManagedCodexWrapperFailure(code, nativeDispatchAttempted ? "outcome_unknown" : "not_dispatched");
+  }
+}
+
+// bin/vtx-managed-codex.ts
+runManagedCodexWrapper(process.argv[2] ?? "").catch((error) => {
+  const code = error instanceof Error && /^[a-z_]{1,80}$/u.test(error.message) ? error.message : "native_terminal_evidence_unconfirmed";
+  process.stdout.write(`${JSON.stringify({
+    type: "failed",
+    code,
+    ...error instanceof ManagedCodexWrapperFailure ? { dispatch_outcome: error.dispatchOutcome } : {}
+  })}
+`);
+  process.stderr.write(`VTX managed Codex turn failed: ${code}.
+`);
+  process.exitCode = 1;
+});
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/