@skaile/workspaces 6.9.0 → 6.10.0

package/dist/chunk-HLFLET7S.js

@@ -0,0 +1,2443 @@
+import { CodexNativeStateUnavailable, CodexAppServerClient, CODEX_NATIVE_STATE_FORMAT } from './chunk-5KSGZP3E.js';
+import { freshBudget, decide, spend } from './chunk-7EKQDY2T.js';
+import { fetchProviderModels } from './chunk-3AIEJSQR.js';
+import { ReconfigureLedger, stripRunnerPrivateEnv, classifyGenericErrorMessage, RUNNER_AGENT_ENV_KEYS } from './chunk-5DE3DGVR.js';
+import { AgentHarness, TOOL_ALLOWLIST_UNSUPPORTED, getBridgeLogger, registryHarnessConfig } from './chunk-NFFBYG2W.js';
+import { BUILTIN_HARNESS_CATALOG, unresolvedProviderCredentials, registryCredentialEnv, entryCredentialValue, providerCredentialEnvName } from './chunk-KE5HDORU.js';
+import { getProviderPreset } from './chunk-6UP2EDFN.js';
+import { loadHarnessSdk } from './chunk-MEU2HHGV.js';
+import { globalSkaileDir } from './chunk-L5VSIPQD.js';
+import { registryEntries, parseModelRef, resolveEntryBaseUrl, isEntryEnabled, parseCredentialRef } from './chunk-RXGPFAMN.js';
+import { openSqlite } from './chunk-RZL4TOK3.js';
+import { join, isAbsolute, dirname, relative, resolve } from 'path';
+import { isDeepStrictEqual } from 'util';
+import * as z from 'zod';
+import { randomUUID, createHash } from 'crypto';
+import { lstatSync, rmSync, existsSync, readFileSync, mkdirSync, writeFileSync, realpathSync, chmodSync, renameSync, readdirSync, statSync, symlinkSync, copyFileSync } from 'fs';
+import { stringify } from 'smol-toml';
+import { homedir } from 'os';
+
+var identifier = z.string().min(1).max(4096);
+var timestamp = z.iso.datetime({ offset: true });
+var common = {
+  configId: identifier,
+  credentialVersion: z.number().int().nonnegative().safe(),
+  mintedAt: timestamp
+};
+var subscription = z.strictObject({
+  ...common,
+  kind: z.literal("codex-subscription"),
+  accessToken: z.string().min(1).max(65536),
+  chatgptAccountId: identifier,
+  chatgptPlanType: identifier.optional(),
+  expiresAt: timestamp
+});
+var delivery = z.discriminatedUnion("kind", [
+  subscription,
+  z.strictObject({
+    ...common,
+    kind: z.literal("openai-api-key"),
+    apiKey: z.string().min(1).max(65536)
+  })
+]);
+function parseCodexCredential(value, now = Date.now()) {
+  const parsed = delivery.safeParse(value);
+  if (!parsed.success) throw new Error("Invalid managed AI credential");
+  const credential = parsed.data;
+  const mintedAt = Date.parse(credential.mintedAt);
+  if (mintedAt > now + 6e4 || credential.kind === "codex-subscription" && (Date.parse(credential.expiresAt) <= now || Date.parse(credential.expiresAt) <= mintedAt))
+    throw new Error("Invalid managed AI credential timestamps");
+  return credential;
+}
+function parseCodexRefreshInput(value, pinned) {
+  const parsed = z.strictObject({
+    kind: z.literal("codex-subscription"),
+    configId: identifier,
+    credentialVersion: common.credentialVersion,
+    reason: z.enum(["initial", "refresh", "retry-401"])
+  }).safeParse(value);
+  if (!parsed.success || parsed.data.configId !== pinned.configId || parsed.data.credentialVersion !== pinned.credentialVersion)
+    throw new Error("Invalid managed AI refresh binding");
+  return parsed.data;
+}
+function parseCodexRefreshResult(value, pinned, now = Date.now()) {
+  const parsed = z.discriminatedUnion("ok", [
+    z.strictObject({ ok: z.literal(true), credential: subscription }),
+    z.strictObject({
+      ok: z.literal(false),
+      code: z.enum(["not-configured", "revoked", "provider-error", "backend-error"]),
+      message: z.string()
+    })
+  ]).safeParse(value);
+  if (!parsed.success) throw new Error("Invalid managed AI refresh result");
+  if (!parsed.data.ok) return { ...parsed.data, message: "Managed subscription refresh failed" };
+  const credential = parseCodexCredential(parsed.data.credential, now);
+  if (credential.kind !== "codex-subscription" || credential.configId !== pinned.configId || credential.chatgptAccountId !== pinned.chatgptAccountId || credential.credentialVersion < pinned.credentialVersion)
+    throw new Error("Invalid managed AI refresh binding");
+  return { ok: true, credential };
+}
+function managedCodexRegistryViolation(registry) {
+  if (!registry) return void 0;
+  const entries = registryEntries(registry);
+  if (entries.length === 0) return void 0;
+  if (entries.length > 1)
+    return `registry carries ${entries.length} entries; managed codex admits exactly one`;
+  const [id, entry] = entries[0];
+  if (!isEntryEnabled(entry)) return `entry '${id}' is disabled`;
+  if (entry.kind !== "llm") return `entry '${id}' is a '${entry.kind}' endpoint, not an llm one`;
+  const surface = entry.surface;
+  if (surface !== "openai-codex-responses")
+    return `entry '${id}' declares surface '${surface ?? "none"}'; managed codex admits only openai-codex-responses`;
+  const credential = entry.credential;
+  if (credential?.kind !== "oauth")
+    return `entry '${id}' carries a '${credential?.kind ?? "none"}' credential; managed codex admits only a platform-injected oauth credential`;
+  const ref = credential.ref ? parseCredentialRef(credential.ref) : void 0;
+  if (!ref || ref.form !== "platform")
+    return `entry '${id}' resolves its credential outside the control plane; managed codex admits only a 'platform:' reference`;
+  return void 0;
+}
+var invalid = () => new Error("AI_PROFILE_INVALID");
+var within = (path, root) => {
+  const rel = relative(root, path);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+};
+function directory(path) {
+  if (!existsSync(path)) mkdirSync(path, { mode: 448 });
+  const stat = lstatSync(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || stat.mode & 63) throw invalid();
+}
+function readRegular(path, limit2) {
+  const stat = lstatSync(path);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > limit2) throw invalid();
+  return readFileSync(path);
+}
+function prepareCodexInstance(config, options, credential) {
+  if (!isAbsolute(options.privateDirectory) || !isAbsolute(config.cwd) || !config.sessionId)
+    throw invalid();
+  directory(options.privateDirectory);
+  const root = realpathSync(options.privateDirectory);
+  const cwd = realpathSync(config.cwd);
+  if (within(root, cwd) || within(cwd, root)) throw invalid();
+  const lock = join(root, ".active");
+  const leasePath = join(root, "lease.db");
+  if (existsSync(leasePath) && !lstatSync(leasePath).isFile()) throw invalid();
+  const lease = openSqlite(leasePath);
+  try {
+    lease.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE");
+    chmodSync(leasePath, 384);
+    rmSync(lock, { force: true });
+    writeFileSync(lock, "active", { flag: "wx", mode: 384 });
+  } catch (error) {
+    lease.close();
+    throw error;
+  }
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    try {
+      rmSync(lock, { force: true });
+    } finally {
+      lease.close();
+    }
+  };
+  try {
+    const key = createHash("sha256").update(
+      JSON.stringify({
+        harness: "codex-app-server-v1",
+        session: config.sessionId,
+        config: credential.configId,
+        kind: credential.kind,
+        account: credential.kind === "codex-subscription" ? credential.chatgptAccountId : null
+      })
+    ).digest("hex");
+    const slots = join(root, CODEX_NATIVE_STATE_FORMAT);
+    directory(slots);
+    const stateRoot = join(slots, key);
+    directory(stateRoot);
+    for (const name of ["instructions.new", "binding.new"])
+      rmSync(join(stateRoot, name), { force: true });
+    const bindingPath = join(stateRoot, "binding.json");
+    if (config.resumeSessionId && !existsSync(bindingPath)) throw new CodexNativeStateUnavailable();
+    if (existsSync(bindingPath)) {
+      const bytes = readRegular(bindingPath, 4096);
+      if (config.resumeSessionId) {
+        let binding;
+        try {
+          binding = JSON.parse(bytes.toString("utf8"));
+        } catch {
+          throw new CodexNativeStateUnavailable();
+        }
+        if (!binding || typeof binding !== "object" || Array.isArray(binding) || Object.keys(binding).sort().join(",") !== "format,key,threadId" || binding.format !== CODEX_NATIVE_STATE_FORMAT || binding.key !== key || binding.threadId !== config.resumeSessionId)
+          throw new CodexNativeStateUnavailable();
+      }
+    }
+    const home = join(stateRoot, "home");
+    if (config.resumeSessionId && !existsSync(home)) throw new CodexNativeStateUnavailable();
+    directory(home);
+    for (const subdir of ["config", "cache", "data", "tmp"]) directory(join(home, subdir));
+    if (["auth.json", ".credentials.json"].some((name) => existsSync(join(home, name))))
+      throw invalid();
+    const instructionFile = join(stateRoot, "instructions.md");
+    const instructions = [
+      ...(options.instructionFiles ?? []).map(
+        (path) => readRegular(path, 1024 * 1024).toString("utf8")
+      ),
+      ...config.systemPrompt ? [config.systemPrompt] : []
+    ].join("\n\n---\n\n");
+    const temporary = join(stateRoot, "instructions.new");
+    writeFileSync(temporary, instructions, { mode: 384, flag: "wx" });
+    renameSync(temporary, instructionFile);
+    const target = join(home, "skills");
+    if (!options.skillsDirectory && existsSync(target)) rmSync(target, { recursive: true });
+    if (options.skillsDirectory) {
+      const source = realpathSync(options.skillsDirectory);
+      if (within(target, source) || within(source, target)) throw invalid();
+      if (existsSync(target)) rmSync(target, { recursive: true });
+      let files = 0;
+      let entries = 0;
+      let bytes = 0;
+      const copy = (source2, destination) => {
+        if (++entries > 1024) throw invalid();
+        if (lstatSync(source2).isSymbolicLink()) throw invalid();
+        mkdirSync(destination, { mode: 448 });
+        for (const entry of readdirSync(source2, { withFileTypes: true })) {
+          const src = join(source2, entry.name);
+          const dst = join(destination, entry.name);
+          if (entry.isSymbolicLink()) throw invalid();
+          if (entry.isDirectory()) copy(src, dst);
+          else {
+            const content = readRegular(src, 1024 * 1024);
+            bytes += content.byteLength;
+            if (++files > 512 || bytes > 8 * 1024 * 1024) throw invalid();
+            writeFileSync(dst, content, { mode: 384, flag: "wx" });
+          }
+        }
+      };
+      copy(options.skillsDirectory, target);
+    }
+    const bindThread = (threadId) => {
+      if (!threadId || threadId.length > 4096) throw invalid();
+      const next = join(stateRoot, "binding.new");
+      writeFileSync(next, JSON.stringify({ format: CODEX_NATIVE_STATE_FORMAT, key, threadId }), {
+        mode: 384,
+        flag: "wx"
+      });
+      renameSync(next, bindingPath);
+    };
+    const setToolInstructions = (text2) => {
+      writeFileSync(temporary, `${instructions}
+
+${text2}`, { mode: 384, flag: "wx" });
+      renameSync(temporary, instructionFile);
+    };
+    return {
+      root,
+      stateRoot,
+      cwd,
+      home,
+      instructionFile,
+      bindThread,
+      release,
+      setToolInstructions
+    };
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+function codexInstanceEnvironment(input, home) {
+  const allowed = /* @__PURE__ */ new Set([
+    "PATH",
+    "LANG",
+    "LC_ALL",
+    "TZ",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "HTTPS_PROXY",
+    "HTTP_PROXY",
+    "NO_PROXY"
+  ]);
+  if (!input || Object.entries(input).some(([key, value]) => !allowed.has(key) || typeof value !== "string"))
+    throw invalid();
+  return {
+    ...input,
+    HOME: home,
+    CODEX_HOME: home,
+    XDG_CONFIG_HOME: join(home, "config"),
+    XDG_CACHE_HOME: join(home, "cache"),
+    XDG_DATA_HOME: join(home, "data"),
+    TMPDIR: join(home, "tmp")
+  };
+}
+var invalid2 = () => new Error("CODEX_INPUT_INVALID");
+var inside = (root, path) => {
+  const rel = relative(root, path);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+};
+function codexPromptInput(input, cwd, skills) {
+  if (!input || typeof input.text !== "string" || input.text.length > 1024 * 1024 || input.attachments !== void 0 && !Array.isArray(input.attachments) || (input.attachments?.length ?? 0) > 32)
+    throw invalid2();
+  const result = [
+    { type: "text", text: input.text }
+  ];
+  for (const attachment of input.attachments ?? []) {
+    try {
+      if (!attachment || typeof attachment.path !== "string") throw invalid2();
+      const root = attachment.type === "skill" && skills ? realpathSync(skills.source) : realpathSync(cwd);
+      const path = realpathSync(
+        isAbsolute(attachment.path) ? attachment.path : join(root, attachment.path)
+      );
+      if (!inside(root, path) || !statSync(path).isFile()) throw invalid2();
+      if (attachment.type === "image") result.push({ type: "localImage", path });
+      else if (attachment.type === "file" || attachment.type === "skill") {
+        if (!attachment.name || [...attachment.name].some((char) => char.charCodeAt(0) < 32))
+          throw invalid2();
+        if (attachment.type === "skill") {
+          if (!skills) throw invalid2();
+          const copied = realpathSync(join(skills.target, relative(root, path)));
+          if (!inside(realpathSync(skills.target), copied) || !statSync(copied).isFile())
+            throw invalid2();
+          result.push({ type: "skill", name: attachment.name, path: copied });
+        } else result.push({ type: "mention", name: attachment.name, path });
+      } else throw invalid2();
+    } catch {
+      throw invalid2();
+    }
+  }
+  return result;
+}
+var invalid3 = () => new Error("AI_PROFILE_INVALID");
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var within2 = (child, parent) => {
+  const rel = relative(parent, child);
+  return rel === "" || !rel.startsWith("../") && rel !== ".." && !isAbsolute(rel);
+};
+var hasControl = (path) => [...path].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+var directory2 = (path) => {
+  if (!isAbsolute(path) || hasControl(path)) throw invalid3();
+  const stat = lstatSync(path);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) throw invalid3();
+  return realpathSync(path);
+};
+function prepareNativePolicy(input) {
+  const cwd = directory2(input.cwd);
+  const privateRoot = directory2(input.privateRoot);
+  const privateDirectory = directory2(input.privateDirectory);
+  if (within2(cwd, privateRoot) || within2(privateRoot, cwd) || !within2(privateDirectory, privateRoot) || privateDirectory === privateRoot || input.sandboxMode !== "read-only" && input.sandboxMode !== "workspace-write")
+    throw invalid3();
+  const stat = lstatSync(privateRoot);
+  if (stat.mode & 63 || process.getuid && stat.uid !== 0 && stat.uid !== process.getuid())
+    throw invalid3();
+  const filesystem = Object.freeze({
+    [cwd]: input.sandboxMode === "workspace-write" ? "write" : "read",
+    [privateRoot]: "deny"
+  });
+  const config = Object.freeze({
+    default_permissions: "managed",
+    features: Object.freeze({ use_legacy_landlock: false }),
+    permissions: Object.freeze({
+      managed: Object.freeze({
+        extends: ":read-only",
+        filesystem,
+        network: Object.freeze({ enabled: false })
+      })
+    })
+  });
+  const profile = `{ managed = { extends = ":read-only", filesystem = { ${Object.entries(filesystem).map(([path, access]) => `${JSON.stringify(path)} = ${JSON.stringify(access)}`).join(", ")} }, network = { enabled = false } } }`;
+  const policy = Object.freeze({
+    config,
+    cliArgs: Object.freeze([
+      "-c",
+      'default_permissions="managed"',
+      "-c",
+      "features.use_legacy_landlock=false",
+      "-c",
+      `permissions=${profile}`
+    ])
+  });
+  prepared.set(policy, { cwd, privateRoot, writable: input.sandboxMode === "workspace-write" });
+  return policy;
+}
+var prepared = /* @__PURE__ */ new WeakMap();
+var active = /* @__PURE__ */ new WeakMap();
+function activateNativeApprovalPolicy(policy, response, signal) {
+  const binding = prepared.get(policy);
+  if (!binding || signal.aborted || !record(response) || !record(response.thread) || typeof response.thread.id !== "string" || !response.thread.id || response.cwd !== binding.cwd || !record(response.activePermissionProfile) || response.activePermissionProfile.id !== "managed" || response.activePermissionProfile.extends !== ":read-only")
+    throw invalid3();
+  const token = Object.freeze({});
+  active.set(token, { ...binding, threadId: response.thread.id, signal });
+  return token;
+}
+function isNativeApprovalPolicyActive(policy, threadId) {
+  if (!record(policy)) return false;
+  const binding = active.get(policy);
+  return Boolean(binding && !binding.signal.aborted && binding.threadId === threadId);
+}
+function allowsNativeApprovalPath(policy, path, access) {
+  if (!policy) return false;
+  const binding = active.get(policy);
+  if (!binding || binding.signal.aborted || !isAbsolute(path) || hasControl(path) || access !== "read" && access !== "write" || access === "write" && !binding.writable)
+    return false;
+  try {
+    let existing = resolve(path);
+    const suffix = [];
+    while (true) {
+      try {
+        lstatSync(existing);
+        break;
+      } catch (error) {
+        if (error.code !== "ENOENT" || dirname(existing) === existing)
+          return false;
+        suffix.unshift(existing.slice(dirname(existing).length + 1));
+        existing = dirname(existing);
+      }
+    }
+    const canonical = resolve(realpathSync(existing), ...suffix);
+    return within2(canonical, binding.cwd) && !within2(canonical, binding.privateRoot);
+  } catch {
+    return false;
+  }
+}
+
+// bridge/src/codex/native-approvals.ts
+function createCodexNativeApprovalHandlers(options) {
+  const active2 = (signal, threadId) => !signal.aborted && isNativeApprovalPolicyActive(options.getPolicy(), threadId);
+  const text2 = (value) => typeof value === "string" && value.length > 0 && value.length <= 8192;
+  const scoped = async (path, access, signal, threadId) => active2(signal, threadId) && text2(path) && allowsNativeApprovalPath(options.getPolicy(), path, access) && active2(signal, threadId);
+  const permissions = async (value, signal, threadId) => {
+    if (value.network?.enabled || value.network != null && Object.keys(value.network).some((key) => key !== "enabled") || Object.keys(value).some((key) => !["network", "fileSystem"].includes(key)))
+      return false;
+    const fs = value.fileSystem;
+    if (!fs) return true;
+    if (fs.entries != null || fs.globScanMaxDepth != null || Object.keys(fs).some((key) => !["read", "write", "entries", "globScanMaxDepth"].includes(key)))
+      return false;
+    for (const access of ["read", "write"]) {
+      const paths = fs[access];
+      if (paths != null && (!Array.isArray(paths) || paths.length > 32)) return false;
+      for (const path of paths ?? [])
+        if (!await scoped(path, access, signal, threadId)) return false;
+    }
+    return active2(signal, threadId);
+  };
+  const consent = async (identity, approval, signal) => {
+    if (!active2(signal, identity.threadId) || approval.details.length > 64 || approval.details.some((detail) => detail.length > 8192) || approval.details.reduce((sum, detail) => sum + detail.length, 0) > 65536)
+      return false;
+    try {
+      return await options.questions.requestApproval(identity, approval, signal) && active2(signal, identity.threadId);
+    } catch {
+      return false;
+    }
+  };
+  return {
+    "item/commandExecution/requestApproval": async (input, signal) => {
+      const params = structuredClone(input);
+      const allowed = async () => active2(signal, params.threadId) && text2(params.command) && (params.kind == null || params.kind === "command") && !params.environmentId && !params.networkApprovalContext && (params.availableDecisions == null || params.availableDecisions.includes("accept")) && await scoped(params.cwd, "read", signal, params.threadId) && (!params.additionalPermissions || await permissions(params.additionalPermissions, signal, params.threadId));
+      if (!await allowed()) return { decision: "decline" };
+      const details = [`Command: ${params.command}`, `Directory: ${params.cwd}`];
+      for (const access of ["read", "write"])
+        for (const path of params.additionalPermissions?.fileSystem?.[access] ?? [])
+          details.push(`${access}: ${path}`);
+      const accepted = await consent(params, { kind: "command", details }, signal);
+      return { decision: accepted && await allowed() ? "accept" : "decline" };
+    },
+    "item/fileChange/requestApproval": async (input, signal) => {
+      const params = structuredClone(input);
+      if (!active2(signal, params.threadId)) return { decision: "decline" };
+      const original = options.getFileChanges(params);
+      if (!original?.length || original.length > 16) return { decision: "decline" };
+      const changes = structuredClone(original);
+      const snapshot = JSON.stringify(changes);
+      const allowed = async () => {
+        if (!active2(signal, params.threadId) || snapshot !== JSON.stringify(options.getFileChanges(params)))
+          return false;
+        if (params.grantRoot != null && !await scoped(params.grantRoot, "write", signal, params.threadId))
+          return false;
+        for (const change of changes) {
+          if (!text2(change.diff) || !await scoped(change.path, "write", signal, params.threadId))
+            return false;
+          if (!["add", "delete", "update"].includes(change.kind.type)) return false;
+          if (change.kind.type === "update" && change.kind.move_path != null && !await scoped(change.kind.move_path, "write", signal, params.threadId))
+            return false;
+        }
+        return active2(signal, params.threadId);
+      };
+      if (!await allowed()) return { decision: "decline" };
+      const details = changes.flatMap((change) => [
+        `${change.kind.type}: ${change.path}${change.kind.type === "update" && change.kind.move_path ? ` \u2192 ${change.kind.move_path}` : ""}`,
+        change.diff
+      ]);
+      const accepted = await consent(params, { kind: "file", details }, signal);
+      return { decision: accepted && await allowed() ? "accept" : "decline" };
+    },
+    "item/permissions/requestApproval": async (input, signal) => {
+      const params = structuredClone(input);
+      const allowed = async () => active2(signal, params.threadId) && !params.environmentId && await scoped(params.cwd, "read", signal, params.threadId) && await permissions(params.permissions, signal, params.threadId);
+      if (!await allowed()) return { permissions: {}, scope: "turn" };
+      const details = [`Directory: ${params.cwd}`];
+      for (const access of ["read", "write"])
+        for (const path of params.permissions.fileSystem?.[access] ?? [])
+          details.push(`${access}: ${path}`);
+      if (details.length === 1) return { permissions: {}, scope: "turn" };
+      const accepted = await consent(params, { kind: "permissions", details }, signal);
+      return {
+        permissions: accepted && await allowed() ? params.permissions : {},
+        scope: "turn"
+      };
+    }
+  };
+}
+
+// bridge/src/codex/native-mcp-approval.ts
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var text = (value) => typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 8192;
+function createCodexMcpApprovalHandler(options) {
+  return async (input, signal) => {
+    const decline = { action: "decline", content: null, _meta: null };
+    try {
+      const params = structuredClone(input);
+      const active2 = () => !signal.aborted && options.bindingActive() && isNativeApprovalPolicyActive(options.getPolicy(), params.threadId);
+      if (!active2() || !text(options.serverName) || params.serverName !== options.serverName || !text(params.threadId) || !text(params.turnId) || params.mode !== "form" || !text(params.message) || Object.keys(params).some(
+        (key) => ![
+          "threadId",
+          "turnId",
+          "serverName",
+          "mode",
+          "message",
+          "requestedSchema",
+          "_meta"
+        ].includes(key)
+      ) || !record2(params._meta) || params._meta.codex_approval_kind !== "mcp_tool_call" || !record2(params.requestedSchema) || params.requestedSchema.type !== "object" || !record2(params.requestedSchema.properties) || Object.keys(params.requestedSchema.properties).length !== 0 || Object.keys(params.requestedSchema).some(
+        (key) => !["type", "properties", "required"].includes(key)
+      ) || params.requestedSchema.required !== void 0 && (!Array.isArray(params.requestedSchema.required) || params.requestedSchema.required.length !== 0) || Buffer.byteLength(JSON.stringify(params._meta)) > 65536)
+        return decline;
+      const accepted = await options.questions.requestApproval(
+        void 0,
+        {
+          kind: "mcp",
+          details: [
+            `Configured MCP server: ${options.serverName}`,
+            params.message,
+            "This is native request presentation, not an independently verified tool identity. Tool permissions are checked again when dispatched."
+          ]
+        },
+        signal
+      );
+      return accepted && active2() ? { action: "accept", content: null, _meta: null } : decline;
+    } catch {
+      return decline;
+    }
+  };
+}
+var CodexQuestions = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  pending;
+  request = async (params, signal) => this.park(params, signal);
+  /** Park native consent; MCP uses only local correlation because it supplies no native item ID. */
+  async requestApproval(identity, approval, signal) {
+    const result = await this.park(
+      {
+        ...identity,
+        isBlocking: true,
+        questions: [
+          {
+            id: "native-approval",
+            header: "Approval",
+            question: approval.kind === "permissions" ? "Allow these permissions for the current turn?" : approval.kind === "mcp" ? "Allow this native MCP request once?" : "Allow this native action once?",
+            options: [
+              {
+                label: "Approve once",
+                description: approval.kind === "permissions" ? "Allow for the current turn." : "Allow only this request."
+              },
+              { label: "Deny", description: "Do not allow this request." }
+            ]
+          }
+        ]
+      },
+      signal,
+      approval
+    );
+    return result.answers["native-approval"]?.answers[0] === "Approve once";
+  }
+  async park(params, signal, approval) {
+    signal.throwIfAborted();
+    if (this.pending || !params.isBlocking || !Array.isArray(params.questions) || params.questions.length === 0 || params.questions.length > 16 || params.questions.some((q) => !q.id || !q.question || q.isSecret) || new Set(params.questions.map((q) => q.id)).size !== params.questions.length || new Set(params.questions.map((q) => q.question)).size !== params.questions.length)
+      throw new Error("CODEX_INPUT_UNSUPPORTED");
+    params = structuredClone(params);
+    approval = approval ? structuredClone(approval) : void 0;
+    const id = randomUUID();
+    const eventId = params.itemId ?? `local-consent:${id}`;
+    return new Promise((resolve3, reject) => {
+      const abort = () => finish();
+      const finish = (result) => {
+        if (this.pending?.id !== id) return;
+        this.pending = void 0;
+        signal.removeEventListener("abort", abort);
+        if (result && !signal.aborted) resolve3(result);
+        else reject(new Error("CODEX_INPUT_CANCELLED"));
+      };
+      this.pending = {
+        id,
+        questions: params.questions,
+        answers: /* @__PURE__ */ Object.create(null),
+        finish,
+        approval
+      };
+      const input = {
+        requestId: id,
+        questions: structuredClone(params.questions),
+        ...approval ? { approval: structuredClone(approval) } : {}
+      };
+      signal.addEventListener("abort", abort, { once: true });
+      if (signal.aborted) {
+        abort();
+        return;
+      }
+      this.emit({
+        type: "message_start",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "tool_use",
+              name: "AskUserQuestion",
+              id: eventId,
+              input
+            }
+          ]
+        }
+      });
+      if (this.pending?.id !== id || signal.aborted) return;
+      this.emit({
+        type: "tool_call",
+        name: "AskUserQuestion",
+        tool: { name: "AskUserQuestion" },
+        toolCallId: eventId,
+        input
+      });
+    });
+  }
+  get active() {
+    return Boolean(this.pending);
+  }
+  answer(answer, question, requestId) {
+    const pending = this.pending;
+    if (!pending || pending.id !== requestId || typeof answer !== "string") return false;
+    if (pending.approval && (question !== pending.questions[0]?.question || !["Approve once", "Deny"].includes(answer)))
+      return false;
+    const q = question === void 0 ? pending.questions.find((entry) => !Object.hasOwn(pending.answers, entry.id)) : pending.questions.find((entry) => entry.question === question);
+    if (!q || Object.hasOwn(pending.answers, q.id)) return false;
+    pending.answers[q.id] = { answers: [answer] };
+    if (pending.questions.every((entry) => Object.hasOwn(pending.answers, entry.id)))
+      pending.finish({ answers: pending.answers });
+    return true;
+  }
+};
+
+// bridge/src/codex/managed-harness.ts
+var record3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var failure = (code = "CODEX_RUNTIME_UNSUPPORTED") => new Error(code);
+var nativeUsage = (value) => ({
+  ...typeof value.inputTokens === "number" ? { inputTokens: value.inputTokens } : {},
+  ...typeof value.outputTokens === "number" ? { outputTokens: value.outputTokens } : {},
+  ...typeof value.cachedInputTokens === "number" ? { cacheReadTokens: value.cachedInputTokens } : {},
+  ...typeof value.reasoningOutputTokens === "number" ? { reasoningTokens: value.reasoningOutputTokens } : {},
+  ...typeof value.totalTokens === "number" ? { totalTokens: value.totalTokens } : {}
+});
+var subtractUsage = (total, baseline) => {
+  const delta = (value, before) => value === void 0 ? void 0 : Math.max(0, value - (before ?? 0));
+  return {
+    ...delta(total.inputTokens, baseline?.inputTokens) !== void 0 ? { inputTokens: delta(total.inputTokens, baseline?.inputTokens) } : {},
+    ...delta(total.outputTokens, baseline?.outputTokens) !== void 0 ? { outputTokens: delta(total.outputTokens, baseline?.outputTokens) } : {},
+    ...delta(total.cacheReadTokens, baseline?.cacheReadTokens) !== void 0 ? {
+      cacheReadTokens: delta(total.cacheReadTokens, baseline?.cacheReadTokens)
+    } : {},
+    ...delta(total.reasoningTokens, baseline?.reasoningTokens) !== void 0 ? {
+      reasoningTokens: delta(total.reasoningTokens, baseline?.reasoningTokens)
+    } : {},
+    ...delta(total.totalTokens, baseline?.totalTokens) !== void 0 ? { totalTokens: delta(total.totalTokens, baseline?.totalTokens) } : {}
+  };
+};
+var addUsage = (left, right) => {
+  const result = {};
+  for (const key of [
+    "inputTokens",
+    "outputTokens",
+    "cacheReadTokens",
+    "reasoningTokens",
+    "totalTokens"
+  ]) {
+    if (left?.[key] !== void 0 || right[key] !== void 0)
+      result[key] = (left?.[key] ?? 0) + (right[key] ?? 0);
+  }
+  return result;
+};
+var limit = (value, fallback) => {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result <= 0 || result > 18e5)
+    throw failure("AI_PROFILE_INVALID");
+  return result;
+};
+async function bounded(work, signal, ms) {
+  let timer;
+  let cancel = () => {
+  };
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_, reject) => {
+        cancel = () => reject(failure());
+        if (signal.aborted) cancel();
+        else signal.addEventListener("abort", cancel, { once: true });
+        timer = setTimeout(() => reject(failure()), ms);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", cancel);
+  }
+}
+var ManagedCodexHarness = class extends AgentHarness {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.desired = {
+      model: config.model,
+      modelRef: config.modelRef,
+      thinking: config.thinking,
+      effort: config.effort,
+      registry: config.registry,
+      roles: config.roles
+    };
+    this.reconfig = new ReconfigureLedger({
+      config: () => this.desired,
+      onDesired: ({ model, thinking, effort }) => {
+        const fields = {};
+        if (model !== void 0) fields.model = model;
+        if (thinking !== void 0) fields.thinking = thinking;
+        if (effort !== void 0) fields.effort = effort;
+        this.pendingPatch = { ...this.pendingPatch, ...fields };
+      }
+    });
+  }
+  config;
+  harnessInfo = {
+    id: "codex",
+    name: "OpenAI Codex",
+    modelAgnostic: false,
+    supportsInBandAbort: true,
+    capabilities: BUILTIN_HARNESS_CATALOG.codex?.capabilities
+  };
+  client;
+  connecting;
+  options;
+  credential;
+  nativeApprovalPolicy;
+  instance;
+  tools;
+  mcpStartup = "unknown";
+  pendingMcpStartup;
+  mcpDiagnostics = {
+    startupBeforeTurn: "unknown",
+    startupAtEnd: "unknown",
+    toolsListBeforeTurn: 0,
+    toolsListTotal: 0,
+    toolsCallTotal: 0,
+    nativeMcpToolItemCount: 0
+  };
+  controller = new AbortController();
+  generation = 0;
+  killed = false;
+  broken = false;
+  cleanupUncertain = false;
+  unexpectedClose = false;
+  starting;
+  closing = Promise.resolve();
+  threadId;
+  lastThreadId;
+  resetting;
+  pendingPatch;
+  active;
+  threadUsageTotal;
+  resumeUsageTurnIds = /* @__PURE__ */ new Set();
+  queue = Promise.resolve();
+  queued = 0;
+  admittedTurns = 0;
+  loginCompleted;
+  /** Recovery budget for the connection's startup (no active turn); reset on each start. */
+  startupRecovery = freshBudget();
+  startupAuthAttempted = false;
+  questions = new CodexQuestions((event) => this.event(event));
+  get acceptsReplyAsPrompt() {
+    return false;
+  }
+  hasPendingQuestion() {
+    return this.questions.active;
+  }
+  answerQuestion(answer, question, requestId) {
+    return this.questions.answer(answer, question, requestId);
+  }
+  /** The settings a later prompt will run on; `config` only takes them at the next turn. */
+  desired;
+  reconfig;
+  get runtimeSessionId() {
+    return this.threadId ?? this.lastThreadId;
+  }
+  get isRunning() {
+    return Boolean(this.client && this.threadId && !this.killed && !this.broken);
+  }
+  getModel() {
+    return this.config.model;
+  }
+  async start() {
+    if (this.killed || this.broken) throw failure();
+    if (this.threadId && this.client) return;
+    if (this.starting) return this.starting;
+    this.starting = this.initialize().catch(async (error) => {
+      this.broken = true;
+      await this.closeGeneration();
+      if (error instanceof CodexNativeStateUnavailable && (this.cleanupUncertain || this.unexpectedClose || this.killed || this.startupAuthAttempted))
+        throw failure();
+      const safe = error instanceof Error && /^(AI_PROFILE_INVALID|CODEX_[A-Z_]+)$/.test(error.message) ? error : failure();
+      throw safe;
+    }).finally(() => {
+      this.starting = void 0;
+    });
+    return this.starting;
+  }
+  async initialize() {
+    await this.closing;
+    if (this.killed) throw failure();
+    const options = this.config.harnessOptions?.codex?.managedRuntime;
+    const tuning = this.config.harnessOptions?.codex;
+    if (tuning?.authSource !== "managed" || !options || typeof options.prepareTools !== "function" || !isAbsolute(options.executable) || !this.config.model || !tuning.reasoningEffort || !tuning.approvalPolicy || tuning.approvalPolicy === "on-failure" || !tuning.sandboxMode || tuning.sandboxMode === "danger-full-access" || // A managed session runs on the platform-minted credential alone: an
+    // OpenAI key handed in through the child environment would be a second,
+    // unaudited authority.
+    this.config.env?.OPENAI_API_KEY || // Credential isolation, stated on the AI provider registry: one entry,
+    // codex's own OpenAI surface, a platform-injected oauth reference. See
+    // `managedCodexRegistryViolation`.
+    managedCodexRegistryViolation(this.config.registry) !== void 0 || options.nativeTurnBudget !== void 0 && options.nativeTurnBudget !== 1)
+      throw failure("AI_PROFILE_INVALID");
+    this.options = options;
+    const timeout = limit(options.requestTimeoutMs, 15e3);
+    limit(options.turnTimeoutMs, 3e5);
+    try {
+      this.credential = parseCodexCredential(this.credential ?? options.credential);
+    } catch {
+      throw failure("CODEX_AUTH_UNAVAILABLE");
+    }
+    if (this.credential.configId !== this.config.aiProviderConfigId)
+      throw failure("AI_PROFILE_INVALID");
+    const privatePolicy = prepareNativePolicy({
+      cwd: this.config.cwd,
+      privateRoot: options.privateRoot,
+      privateDirectory: options.privateDirectory,
+      sandboxMode: tuning.sandboxMode
+    });
+    this.instance = prepareCodexInstance(this.config, options, this.credential);
+    const generation = ++this.generation;
+    const mcpReplies = /* @__PURE__ */ new WeakMap();
+    this.controller = new AbortController();
+    this.startupRecovery = freshBudget();
+    this.startupAuthAttempted = false;
+    const handlers = {
+      "account/chatgptAuthTokens/refresh": async (params, signal) => {
+        const active2 = this.active;
+        if (!active2 && !this.starting) throw failure("CODEX_AUTH_UNAVAILABLE");
+        if (!active2) this.startupAuthAttempted = true;
+        const cancellation = AbortSignal.any([
+          signal,
+          this.controller.signal,
+          ...active2 ? [active2.controller.signal] : []
+        ]);
+        try {
+          return await this.refresh(params, cancellation);
+        } catch {
+          if (active2 && this.active === active2) active2.failureCode = "CODEX_AUTH_UNAVAILABLE";
+          throw failure("CODEX_AUTH_UNAVAILABLE");
+        }
+      }
+    };
+    const authMode = this.credential.kind === "codex-subscription" ? "chatgpt" : "api";
+    const nativePolicy = {
+      cli_auth_credentials_store: "ephemeral",
+      forced_login_method: authMode,
+      model_provider: "openai",
+      model: this.config.model,
+      model_instructions_file: this.instance.instructionFile,
+      shell_environment_policy: {
+        inherit: "none",
+        set: { PATH: options.environment.PATH ?? "/usr/bin:/bin" }
+      },
+      mcp_servers: {}
+    };
+    const overrides = Object.entries({
+      cli_auth_credentials_store: "ephemeral",
+      forced_login_method: authMode,
+      model_provider: "openai",
+      model: this.config.model,
+      model_instructions_file: this.instance.instructionFile,
+      "shell_environment_policy.inherit": "none",
+      "shell_environment_policy.set.PATH": options.environment.PATH ?? "/usr/bin:/bin"
+    }).flatMap(([key, value]) => ["-c", `${key}=${JSON.stringify(value)}`]);
+    overrides.push("-c", "mcp_servers={}");
+    const connecting = CodexAppServerClient.connect(
+      {
+        command: options.executable,
+        args: [
+          ...options.executableArgs ?? [],
+          ...overrides,
+          ...privatePolicy.cliArgs,
+          "app-server",
+          "--stdio"
+        ],
+        cwd: this.instance.root,
+        env: codexInstanceEnvironment(options.environment, this.instance.home),
+        clientInfo: { name: "skaile-managed-codex", version: "1" },
+        processGroup: true,
+        requestTimeoutMs: timeout,
+        serverRequestTimeoutMs: Math.min(limit(options.interactionTimeoutMs, 3e5), 3e5),
+        onServerRequest: handlers,
+        canReplyToServerRequest: (method, params) => {
+          if (method !== "mcpServer/elicitation/request") return true;
+          return record3(params) && (mcpReplies.get(params)?.() ?? false);
+        },
+        onNotification: (method, params) => {
+          if (generation === this.generation) this.notification(method, params);
+        },
+        onClose: () => {
+          if (generation !== this.generation) return;
+          this.unexpectedClose = true;
+          this.broken = true;
+          this.loginCompleted?.reject(failure());
+          this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
+          void this.closeGeneration();
+        }
+      },
+      this.controller.signal
+    );
+    this.connecting = connecting;
+    try {
+      this.client = await connecting;
+    } finally {
+      if (this.connecting === connecting) this.connecting = void 0;
+    }
+    if (generation !== this.generation || this.killed) throw failure();
+    await this.authenticate(timeout);
+    const toolsPromise = options.prepareTools(this.controller.signal).then(async (tools) => {
+      if (generation !== this.generation || this.controller.signal.aborted) {
+        await tools.dispose().catch(() => {
+        });
+        throw failure();
+      }
+      return tools;
+    });
+    try {
+      this.tools = await bounded(toolsPromise, this.controller.signal, timeout);
+    } catch {
+      throw failure("CODEX_REQUIRED_TOOL_UNAVAILABLE");
+    }
+    if (!this.tools || !record3(this.tools.mcpServers) || typeof this.tools.dispose !== "function" || Object.keys(this.tools.mcpServers).length === 0 && Object.keys(this.tools.onServerRequest ?? {}).length === 0)
+      throw failure("CODEX_REQUIRED_TOOL_UNAVAILABLE");
+    if (this.tools.onServerRequest?.["item/tool/requestUserInput"])
+      throw failure("AI_PROFILE_INVALID");
+    const nativeApprovals = createCodexNativeApprovalHandlers({
+      questions: this.questions,
+      getPolicy: () => tuning.approvalPolicy === "never" ? void 0 : this.nativeApprovalPolicy,
+      getFileChanges: ({ itemId, threadId, turnId }) => {
+        const active2 = this.active;
+        if (!active2 || active2.controller.signal.aborted || threadId !== this.threadId || turnId !== active2.id)
+          return void 0;
+        const snapshot = active2.fileChanges.get(itemId);
+        return snapshot ? JSON.parse(snapshot) : void 0;
+      }
+    });
+    const approvalTools = this.tools;
+    const approvalServerName = approvalTools.approvalServerName;
+    const approvalServer = approvalServerName ? approvalTools.mcpServers[approvalServerName] : void 0;
+    const approvalServerSnapshot = structuredClone(approvalServer);
+    const mcpBindingActive = () => this.tools === approvalTools && approvalTools.approvalServerName === approvalServerName && Boolean(approvalServerName) && Object.hasOwn(approvalTools.mcpServers, approvalServerName) && record3(approvalServer) && approvalTools.mcpServers[approvalServerName] === approvalServer && isDeepStrictEqual(approvalServer, approvalServerSnapshot);
+    const mcpPolicy = () => tuning.approvalPolicy === "never" ? void 0 : this.nativeApprovalPolicy;
+    const mcpApproval = createCodexMcpApprovalHandler({
+      serverName: approvalServerName,
+      questions: this.questions,
+      getPolicy: mcpPolicy,
+      bindingActive: mcpBindingActive
+    });
+    for (const [method, handler] of Object.entries({
+      ...this.tools.onServerRequest,
+      ...nativeApprovals,
+      "item/tool/requestUserInput": this.questions.request,
+      "mcpServer/elicitation/request": mcpApproval
+    })) {
+      if (method === "account/chatgptAuthTokens/refresh" || !handler)
+        throw failure("AI_PROFILE_INVALID");
+      handlers[method] = async (params, signal) => {
+        const active2 = this.active;
+        if (generation !== this.generation || !active2 || !record3(params)) throw failure();
+        await active2.ready;
+        if (generation !== this.generation || this.active !== active2 || params.threadId !== this.threadId || params.turnId !== active2.id)
+          throw failure();
+        const cancellation = AbortSignal.any([signal, active2.controller.signal]);
+        if (cancellation.aborted) throw failure();
+        if (method === "mcpServer/elicitation/request") {
+          mcpReplies.set(
+            params,
+            () => generation === this.generation && this.active === active2 && !cancellation.aborted && params.threadId === this.threadId && params.turnId === active2.id && mcpBindingActive() && isNativeApprovalPolicyActive(mcpPolicy(), this.threadId ?? "")
+          );
+        }
+        const result = await handler(params, cancellation);
+        if (generation !== this.generation || cancellation.aborted || this.active !== active2)
+          throw failure();
+        return result;
+      };
+    }
+    if (this.tools.instructions) this.instance.setToolInstructions(this.tools.instructions);
+    const threadParams = {
+      model: this.config.model,
+      modelProvider: "openai",
+      cwd: this.instance.cwd,
+      approvalPolicy: tuning.approvalPolicy,
+      permissions: "managed",
+      config: {
+        ...nativePolicy,
+        ...privatePolicy.config,
+        mcp_servers: this.tools.mcpServers,
+        model_reasoning_effort: this.config.effort ?? tuning.reasoningEffort
+      }
+    };
+    const resuming = Boolean(this.config.resumeSessionId);
+    this.threadUsageTotal = resuming ? this.threadUsageTotal ?? {} : {};
+    this.resumeUsageTurnIds.clear();
+    const response = resuming ? await this.client.request("thread/resume", {
+      ...threadParams,
+      threadId: this.config.resumeSessionId,
+      excludeTurns: false
+    }) : await this.client.request("thread/start", {
+      ...threadParams,
+      allowProviderModelFallback: false
+    });
+    if (!record3(response) || response.model !== this.config.model)
+      throw failure("CODEX_MODEL_UNAVAILABLE");
+    if (!record3(response.thread) || typeof response.thread.id !== "string" || resuming && response.thread.id !== this.config.resumeSessionId || resuming && !Array.isArray(response.thread.turns) || response.reasoningEffort !== (this.config.effort ?? tuning.reasoningEffort) || response.modelProvider !== "openai" || response.approvalPolicy !== tuning.approvalPolicy)
+      throw failure("AI_PROFILE_INVALID");
+    if (generation !== this.generation || this.killed) throw failure();
+    this.resumeUsageTurnIds = new Set(
+      resuming && Array.isArray(response.thread.turns) ? response.thread.turns.flatMap(
+        (turn) => record3(turn) && typeof turn.id === "string" ? [turn.id] : []
+      ) : []
+    );
+    this.nativeApprovalPolicy = activateNativeApprovalPolicy(
+      privatePolicy,
+      response,
+      this.controller.signal
+    );
+    this.threadId = response.thread.id;
+    this.mcpStartup = this.pendingMcpStartup?.threadId === this.threadId ? this.pendingMcpStartup.status : "unknown";
+    this.pendingMcpStartup = void 0;
+    this.lastThreadId = this.threadId;
+    this.instance.bindThread(this.threadId);
+  }
+  async authenticate(timeout) {
+    const credential = this.credential;
+    if (credential.kind === "openai-api-key") {
+      const result = await this.client.request("account/login/start", {
+        type: "apiKey",
+        apiKey: credential.apiKey
+      });
+      if (result.type !== "apiKey") throw failure("CODEX_AUTH_UNAVAILABLE");
+      return;
+    }
+    const completion = new Promise((resolve3, reject) => {
+      this.loginCompleted = { resolve: resolve3, reject };
+    });
+    const wait = bounded(completion, this.controller.signal, timeout);
+    void wait.catch(() => {
+    });
+    try {
+      const result = await this.client.request("account/login/start", {
+        type: "chatgptAuthTokens",
+        accessToken: credential.accessToken,
+        chatgptAccountId: credential.chatgptAccountId,
+        chatgptPlanType: credential.chatgptPlanType ?? null
+      });
+      if (result.type !== "chatgptAuthTokens") throw failure("CODEX_AUTH_UNAVAILABLE");
+      await wait;
+    } finally {
+      this.loginCompleted = void 0;
+    }
+  }
+  async refresh(params, signal) {
+    const credential = this.credential;
+    if (!record3(params) || params.reason !== "unauthorized" || !credential || credential.kind !== "codex-subscription" || params.previousAccountId != null && params.previousAccountId !== credential.chatgptAccountId || !this.options?.refreshCredential)
+      throw failure("CODEX_AUTH_UNAVAILABLE");
+    const active2 = this.active;
+    const budget = active2 ? active2.recovery : this.startupRecovery;
+    const decision = decide(
+      { message: "unauthorized", authError: true, limitRejected: false, queryEnded: false },
+      budget,
+      { onAuthError: true, onLimitBlocked: false, resumableSessionId: false }
+    );
+    if (!("attempt" in decision) || decision.attempt !== "auth_refresh")
+      throw failure("CODEX_AUTH_UNAVAILABLE");
+    const spent = spend(budget, "auth_refresh");
+    if (active2) active2.recovery = spent;
+    else this.startupRecovery = spent;
+    const result = await this.options.refreshCredential(
+      {
+        kind: "codex-subscription",
+        configId: credential.configId,
+        credentialVersion: credential.credentialVersion,
+        reason: "retry-401"
+      },
+      signal
+    );
+    if (signal.aborted) throw failure("CODEX_AUTH_UNAVAILABLE");
+    let parsed;
+    try {
+      parsed = parseCodexRefreshResult(result, credential);
+    } catch {
+      throw failure("CODEX_AUTH_UNAVAILABLE");
+    }
+    if (!parsed.ok) throw failure("CODEX_AUTH_UNAVAILABLE");
+    this.credential = parsed.credential;
+    return {
+      accessToken: parsed.credential.accessToken,
+      chatgptAccountId: parsed.credential.chatgptAccountId,
+      chatgptPlanType: parsed.credential.chatgptPlanType ?? null
+    };
+  }
+  prompt(message) {
+    return this.promptInput({ text: message });
+  }
+  promptInput(input) {
+    if (input.toolAllowlist !== void 0)
+      return Promise.reject(new Error(TOOL_ALLOWLIST_UNSUPPORTED));
+    const message = structuredClone(input);
+    const turnBudget = this.config.harnessOptions?.codex?.managedRuntime?.nativeTurnBudget;
+    if (this.killed || this.broken || this.resetting || this.queued >= 32 || turnBudget !== void 0 && this.admittedTurns >= turnBudget)
+      return Promise.reject(failure());
+    if (turnBudget !== void 0) this.admittedTurns++;
+    this.queued++;
+    const task = this.queue.then(() => this.runTurn(message));
+    this.queue = task.catch(() => {
+    }).finally(() => {
+      this.queued--;
+    });
+    return task;
+  }
+  async runTurn(message) {
+    if (this.resetting) throw failure();
+    await this.start();
+    if (this.killed || this.broken || this.resetting) throw failure();
+    if (this.pendingPatch) {
+      this.config = { ...this.config, ...this.pendingPatch };
+      this.pendingPatch = void 0;
+    }
+    if (!this.config.model) throw failure("AI_PROFILE_INVALID");
+    await this.tools?.validate?.();
+    if (this.tools?.needsReload?.()) {
+      this.config = { ...this.config, resumeSessionId: this.threadId };
+      await this.closeGeneration();
+      await this.start();
+    }
+    const input = codexPromptInput(
+      message,
+      this.instance.cwd,
+      this.options?.skillsDirectory ? {
+        source: this.options.skillsDirectory,
+        target: join(this.instance.home, "skills")
+      } : void 0
+    );
+    try {
+      parseCodexCredential(this.credential);
+    } catch {
+      throw failure("CODEX_AUTH_UNAVAILABLE");
+    }
+    let finish;
+    let readyNow;
+    const ready = new Promise((resolve3) => {
+      readyNow = resolve3;
+    });
+    const done = new Promise((resolve3) => {
+      finish = resolve3;
+    });
+    const active2 = {
+      controller: new AbortController(),
+      done,
+      finish,
+      ready,
+      readyNow,
+      timer: setTimeout(
+        () => {
+          this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
+          this.broken = true;
+          void this.closeGeneration();
+        },
+        limit(this.options?.turnTimeoutMs, 3e5)
+      ),
+      events: [],
+      messages: /* @__PURE__ */ new Map(),
+      fileChanges: /* @__PURE__ */ new Map(),
+      toolResults: [],
+      toolItems: /* @__PURE__ */ new Set(),
+      completedToolItems: /* @__PURE__ */ new Set(),
+      recovery: freshBudget(),
+      usageBaseline: this.threadUsageTotal,
+      actualModel: this.config.model
+    };
+    this.active = active2;
+    this.mcpDiagnostics.nativeMcpToolItemCount = 0;
+    this.observeMcp(true);
+    this.tools?.beginTurn?.(active2.controller.signal);
+    try {
+      const response = await this.client.request("turn/start", {
+        threadId: this.threadId,
+        permissions: "managed",
+        input,
+        model: this.config.model,
+        effort: this.config.effort ?? this.config.harnessOptions.codex.reasoningEffort
+      });
+      if (this.active !== active2) return;
+      if (!record3(response.turn) || typeof response.turn.id !== "string") throw failure();
+      active2.id = response.turn.id;
+      active2.readyNow();
+      for (const event of active2.events.splice(0)) this.notification(event.method, event.params);
+      if (this.active === active2 && response.turn.status !== "inProgress")
+        this.complete(response.turn);
+      await done;
+    } catch {
+      this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
+    }
+  }
+  async abort() {
+    const active2 = this.active;
+    if (!active2) return;
+    active2.controller.abort();
+    try {
+      if (!active2.id)
+        await bounded(
+          active2.ready,
+          this.controller.signal,
+          limit(this.options?.requestTimeoutMs, 15e3)
+        );
+      if (this.active !== active2) return;
+      await this.client.request("turn/interrupt", {
+        threadId: this.threadId,
+        turnId: active2.id
+      });
+      await bounded(
+        active2.done,
+        this.controller.signal,
+        limit(this.options?.requestTimeoutMs, 15e3)
+      );
+    } catch {
+      this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
+      this.broken = true;
+      await this.closeGeneration();
+    }
+  }
+  kill() {
+    if (this.killed) return;
+    this.killed = true;
+    this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
+    void this.closeGeneration();
+  }
+  async dispose() {
+    this.kill();
+    await this.starting?.catch(() => {
+    });
+    await this.closing;
+  }
+  async resetSession() {
+    if (this.killed || this.broken) throw failure();
+    if (this.resetting) return this.resetting;
+    this.resetting = Promise.resolve().then(async () => {
+      if (this.active) await this.abort();
+      await this.queue;
+      await this.starting;
+      await this.closeGeneration();
+      if (this.killed || this.broken) throw failure();
+      this.config = { ...this.config, resumeSessionId: void 0 };
+      this.lastThreadId = void 0;
+      this.threadUsageTotal = void 0;
+    }).finally(() => {
+      this.resetting = void 0;
+    });
+    return this.resetting;
+  }
+  /**
+   * Store a model / thinking / effort change; the next prompt merges it into the
+   * config before the turn starts, and a turn in flight keeps what it began with.
+   */
+  reconfigure(patch) {
+    return this.reconfig.reconfigure(patch);
+  }
+  closeGeneration() {
+    const generation = ++this.generation;
+    const finalMcp = { ...this.mcpDiagnostics };
+    this.mcpStartup = "unknown";
+    this.pendingMcpStartup = void 0;
+    this.controller.abort();
+    this.nativeApprovalPolicy = void 0;
+    this.loginCompleted?.reject(failure());
+    this.loginCompleted = void 0;
+    const client = this.client;
+    this.client = void 0;
+    const connecting = this.connecting;
+    this.connecting = void 0;
+    const tools = this.tools;
+    this.tools = void 0;
+    const instance = this.instance;
+    this.instance = void 0;
+    this.threadId = void 0;
+    this.closing = this.closing.then(async () => {
+      try {
+        const pendingClient = await connecting?.catch(() => void 0);
+        await client?.dispose();
+        if (pendingClient && pendingClient !== client) await pendingClient.dispose();
+        if (client && !client.terminationConfirmed || pendingClient && !pendingClient.terminationConfirmed)
+          this.cleanupUncertain = true;
+        if (tools) {
+          try {
+            await bounded(
+              Promise.resolve().then(() => tools.dispose()),
+              new AbortController().signal,
+              1e3
+            );
+            if (generation === this.generation && !this.cleanupUncertain)
+              this.observeClosedMcp(tools, finalMcp);
+          } catch {
+            this.cleanupUncertain = true;
+          }
+        }
+      } finally {
+        instance?.release();
+      }
+    }).catch(() => {
+      this.cleanupUncertain = true;
+    });
+    return this.closing;
+  }
+  notification(method, params) {
+    if (!record3(params)) return;
+    if (method === "mcpServer/startupStatus/updated") {
+      const serverName = this.tools?.diagnostics?.serverName;
+      if (!serverName || params.name !== serverName || typeof params.threadId !== "string" || params.threadId.length > 512 || typeof params.status !== "string" || !["starting", "ready", "failed", "cancelled"].includes(params.status))
+        return;
+      const status = params.status;
+      if (this.threadId) {
+        if (params.threadId === this.threadId) this.mcpStartup = status;
+      } else this.pendingMcpStartup = { threadId: params.threadId, status };
+      return;
+    }
+    if (method === "account/login/completed") {
+      if (params.success === true && params.loginId == null) this.loginCompleted?.resolve();
+      else this.loginCompleted?.reject(failure("CODEX_AUTH_UNAVAILABLE"));
+      return;
+    }
+    const active2 = this.active;
+    if ((!active2 || !active2.usageCursor && this.resumeUsageTurnIds.has(String(params.turnId))) && method === "thread/tokenUsage/updated" && params.threadId === (this.threadId ?? this.config.resumeSessionId) && record3(params.tokenUsage) && record3(params.tokenUsage.total)) {
+      this.threadUsageTotal = nativeUsage(params.tokenUsage.total);
+      if (active2) active2.usageBaseline = this.threadUsageTotal;
+      return;
+    }
+    if (!active2 || params.threadId !== this.threadId) return;
+    if (!active2.id) {
+      if (active2.events.length >= 256) {
+        this.broken = true;
+        this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
+        void this.closeGeneration();
+      } else active2.events.push({ method, params });
+      return;
+    }
+    const turnId = record3(params.turn) ? params.turn.id : params.turnId;
+    if (turnId !== active2.id) return;
+    if (method === "thread/tokenUsage/updated" && record3(params.tokenUsage)) {
+      const last = params.tokenUsage.last;
+      const total = params.tokenUsage.total;
+      const cumulativeUsage = record3(total) ? nativeUsage(total) : void 0;
+      if (cumulativeUsage) {
+        active2.usageBaseline ??= {};
+        this.resumeUsageTurnIds.clear();
+        const cursor = active2.usageCursor ?? active2.usageBaseline;
+        const reset = cursor?.totalTokens !== void 0 && cumulativeUsage.totalTokens !== void 0 && cumulativeUsage.totalTokens < cursor.totalTokens;
+        const increment = reset ? cumulativeUsage : subtractUsage(cumulativeUsage, cursor);
+        if (Object.values(increment).some((value) => typeof value === "number" && value > 0))
+          active2.usage = addUsage(active2.usage, increment);
+        active2.usageCursor = cumulativeUsage;
+        this.threadUsageTotal = cumulativeUsage;
+      }
+      if (record3(last)) {
+        if (typeof last.totalTokens === "number") active2.contextTokens = last.totalTokens;
+      }
+      if (typeof params.tokenUsage.modelContextWindow === "number")
+        active2.contextWindow = params.tokenUsage.modelContextWindow;
+    } else if (method === "model/rerouted") {
+      active2.actualModel = typeof params.toModel === "string" ? params.toModel : active2.actualModel;
+      active2.failureCode = "CODEX_MODEL_UNAVAILABLE";
+    } else if (method === "turn/completed" && record3(params.turn)) this.complete(params.turn);
+    else if (method === "error" && params.willRetry !== true)
+      active2.failureCode = this.nativeErrorCode(params.error);
+    else if (method === "item/agentMessage/delta" && typeof params.itemId === "string" && typeof params.delta === "string") {
+      const previous = active2.messages.get(params.itemId);
+      if (previous === void 0)
+        this.event({
+          type: "message_start",
+          message: { role: "assistant", content: [{ type: "text", text: "" }] }
+        });
+      const text2 = (previous ?? "") + params.delta;
+      active2.messages.set(params.itemId, text2);
+      this.event({
+        type: "message_update",
+        message: { role: "assistant", content: [{ type: "text", text: text2 }] },
+        _textDelta: params.delta
+      });
+    } else if ((method === "item/started" || method === "item/completed") && record3(params.item) && typeof params.item.id === "string") {
+      this.item(
+        params.item,
+        method === "item/completed"
+      );
+    }
+  }
+  item(item, completed) {
+    const active2 = this.active;
+    if (item.type === "fileChange") {
+      active2.fileChanges.delete(item.id);
+      if (!completed && Array.isArray(item.changes) && item.changes.length <= 16 && active2.fileChanges.size < 16) {
+        const snapshot = JSON.stringify(item.changes);
+        if (snapshot.length <= 65536) active2.fileChanges.set(item.id, snapshot);
+      }
+    }
+    if (item.type === "agentMessage") {
+      if (completed && typeof item.text === "string") {
+        const previous = active2.messages.get(item.id) ?? "";
+        if (!active2.messages.has(item.id))
+          this.event({
+            type: "message_start",
+            message: {
+              role: "assistant",
+              content: [{ type: "text", text: "" }]
+            }
+          });
+        if (item.text.startsWith(previous) && item.text.length > previous.length)
+          this.event({
+            type: "message_update",
+            message: {
+              role: "assistant",
+              content: [{ type: "text", text: item.text }]
+            },
+            _textDelta: item.text.slice(previous.length)
+          });
+        active2.messages.set(item.id, item.text);
+      }
+      return;
+    }
+    const name = item.type === "commandExecution" ? "Bash" : item.type === "fileChange" ? "ApplyPatch" : item.type === "mcpToolCall" ? `mcp__${item.server}__${item.tool}` : void 0;
+    if (!name) return;
+    if (!active2.toolItems.has(item.id)) {
+      if (item.type === "mcpToolCall" && item.server === this.tools?.diagnostics?.serverName)
+        this.mcpDiagnostics.nativeMcpToolItemCount = Math.min(
+          512,
+          this.mcpDiagnostics.nativeMcpToolItemCount + 1
+        );
+      active2.toolItems.add(item.id);
+      this.event({
+        type: "tool_call",
+        name,
+        tool: { name },
+        toolCallId: item.id,
+        input: item.type === "mcpToolCall" ? item.arguments : item.type === "commandExecution" ? { command: item.command } : item.type === "fileChange" ? { changes: item.changes } : {}
+      });
+    }
+    if (completed && !active2.completedToolItems.has(item.id)) {
+      active2.completedToolItems.add(item.id);
+      active2.toolResults.push({
+        role: "tool",
+        toolName: name,
+        content: "",
+        data: item.type === "mcpToolCall" ? {
+          content: item.result?.content,
+          structuredContent: item.result?.structuredContent,
+          status: item.status
+        } : item.type === "commandExecution" ? {
+          output: item.aggregatedOutput,
+          exitCode: item.exitCode,
+          status: item.status
+        } : item.type === "fileChange" ? { changes: item.changes, status: item.status } : {},
+        isError: "status" in item && item.status === "failed"
+      });
+      this.event({ type: "tool_execution_end", toolName: name });
+    }
+  }
+  complete(turn) {
+    if (turn.status === "completed") this.finishTurn(this.active?.failureCode);
+    else if (turn.status === "interrupted") this.finishTurn("CODEX_TURN_INTERRUPTED");
+    else if (turn.status === "failed")
+      this.finishTurn(this.active?.failureCode ?? this.nativeErrorCode(turn.error));
+  }
+  nativeErrorCode(error) {
+    const info = record3(error) ? error.codexErrorInfo : void 0;
+    if (info === "unauthorized") return "CODEX_RECONNECT_REQUIRED";
+    if (info === "usageLimitExceeded" || info === "rateLimitExceeded" || info === "serverOverloaded")
+      return "CODEX_RATE_LIMITED";
+    if (record3(info) && [
+      "httpConnectionFailed",
+      "responseStreamConnectionFailed",
+      "responseStreamDisconnected",
+      "responseTooManyFailedAttempts"
+    ].some((key) => key in info))
+      return "CODEX_NETWORK_UNAVAILABLE";
+    return "CODEX_RUNTIME_UNSUPPORTED";
+  }
+  observeMcp(beforeTurn) {
+    const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? Math.min(512, value) : 0;
+    let listed = 0;
+    let called = 0;
+    try {
+      const counts = this.tools?.diagnostics?.requestCounts();
+      listed = count(counts?.toolsListTotal);
+      called = count(counts?.toolsCallTotal);
+    } catch {
+    }
+    if (beforeTurn) {
+      this.mcpDiagnostics.startupBeforeTurn = this.mcpStartup;
+      this.mcpDiagnostics.toolsListBeforeTurn = listed;
+    }
+    this.mcpDiagnostics.startupAtEnd = this.mcpStartup;
+    this.mcpDiagnostics.toolsListTotal = Math.max(this.mcpDiagnostics.toolsListBeforeTurn, listed);
+    this.mcpDiagnostics.toolsCallTotal = beforeTurn ? called : Math.max(this.mcpDiagnostics.toolsCallTotal, called);
+    this.publishMcp(this.mcpDiagnostics);
+  }
+  observeClosedMcp(tools, snapshot) {
+    try {
+      const counts = tools.diagnostics?.requestCounts();
+      if (!counts || ![counts.toolsListTotal, counts.toolsCallTotal].every(
+        (value) => Number.isSafeInteger(value) && value >= 0
+      ))
+        return;
+      snapshot.toolsListTotal = Math.max(
+        snapshot.toolsListTotal,
+        Math.min(512, counts.toolsListTotal)
+      );
+      snapshot.toolsCallTotal = Math.max(
+        snapshot.toolsCallTotal,
+        Math.min(512, counts.toolsCallTotal)
+      );
+      this.publishMcp(snapshot);
+    } catch {
+    }
+  }
+  publishMcp(snapshot) {
+    try {
+      void Promise.resolve(
+        this.options?.onNativeMcpDiagnostics?.(Object.freeze({ ...snapshot }))
+      ).catch(() => {
+      });
+    } catch {
+    }
+  }
+  finishTurn(code) {
+    const active2 = this.active;
+    if (!active2) return;
+    this.active = void 0;
+    this.observeMcp(false);
+    clearTimeout(active2.timer);
+    active2.controller.abort();
+    active2.fileChanges.clear();
+    active2.readyNow();
+    for (const text2 of active2.messages.values())
+      this.event({
+        type: "message_end",
+        message: { role: "assistant", content: [{ type: "text", text: text2 }] }
+      });
+    this.event({ type: "turn_end", toolResults: active2.toolResults });
+    const modelUsage = active2.usage ? {
+      inputTokens: active2.usage.inputTokens,
+      outputTokens: active2.usage.outputTokens,
+      cacheReadTokens: active2.usage.cacheReadTokens,
+      ...typeof active2.contextWindow === "number" ? { contextWindow: active2.contextWindow } : {}
+    } : void 0;
+    const usage = {
+      ...active2.usage ? { tokens: active2.usage } : {},
+      ...modelUsage ? { modelUsage: { [active2.actualModel]: modelUsage } } : {},
+      ...typeof active2.contextTokens === "number" ? { contextTokens: active2.contextTokens } : {},
+      ...typeof active2.contextWindow === "number" ? { contextWindow: active2.contextWindow } : {}
+    };
+    if (code)
+      this.event({
+        type: "error",
+        error: code,
+        fatal: code !== "CODEX_TURN_INTERRUPTED",
+        detail: {
+          message: code,
+          category: code === "CODEX_TURN_INTERRUPTED" ? "process" : code === "CODEX_RATE_LIMITED" ? "rate_limit" : code === "CODEX_NETWORK_UNAVAILABLE" ? "network" : code === "CODEX_AUTH_UNAVAILABLE" || code === "CODEX_RECONNECT_REQUIRED" ? "auth" : "config",
+          retryable: false
+        },
+        ...usage
+      });
+    else
+      this.event({
+        type: "result",
+        subtype: "success",
+        summary: [...active2.messages.values()].join("\n"),
+        ...usage
+      });
+    this.event({ type: "agent_end" });
+    active2.finish();
+  }
+  event(event) {
+    try {
+      this.emit("agent-event", event);
+    } catch {
+    }
+  }
+};
+var CODEX_WIRE_API = {
+  "openai-codex-responses": "responses",
+  "openai-responses": "responses",
+  "azure-openai-responses": "responses"
+};
+var CODEX_RESERVED_PROVIDER_IDS = /* @__PURE__ */ new Set(["openai", "ollama", "lmstudio"]);
+function codexProviderTableId(id) {
+  return CODEX_RESERVED_PROVIDER_IDS.has(id) ? `skaile-${id}` : id;
+}
+var ENV_DELIVERED_CREDENTIALS = {
+  api_key_header: true,
+  bearer: true,
+  command: true
+};
+function selectionNamesEntry(input, selected, registry) {
+  if (selected.role && selected.modelId !== void 0) return true;
+  const selector = input.modelRef?.trim() || input.model?.trim() || "";
+  if (selector.startsWith(`${selected.providerId}/`)) return true;
+  const entry = registryEntries(registry).find(([id]) => id === selected.providerId)?.[1];
+  const modelId = selected.modelId;
+  return modelId !== void 0 && (entry?.model_map?.[modelId] !== void 0 || entry?.capabilities?.[modelId] !== void 0);
+}
+function renderCodexProviderTable(id, entry) {
+  if (!isEntryEnabled(entry)) return { skipped: "entry is disabled" };
+  if (entry.kind !== "llm" && entry.kind !== "embed")
+    return { skipped: `kind '${entry.kind}' is not a model endpoint` };
+  const llm = entry;
+  const preset = entry.preset ? getProviderPreset(entry.preset) : void 0;
+  const surface = llm.surface ?? preset?.surface;
+  const wireApi = surface ? CODEX_WIRE_API[surface] : void 0;
+  if (!wireApi)
+    return {
+      skipped: surface ? `codex has no wire_api for surface '${surface}'` : "entry declares no surface"
+    };
+  const credentialKind = entry.credential?.kind;
+  const table = { name: entry.label ?? id };
+  const baseUrl = resolveEntryBaseUrl(entry) ?? preset?.base_url;
+  if (baseUrl) table.base_url = baseUrl;
+  if (credentialKind && ENV_DELIVERED_CREDENTIALS[credentialKind])
+    table.env_key = providerCredentialEnvName(id);
+  table.wire_api = wireApi;
+  if (credentialKind === "oauth") table.requires_openai_auth = true;
+  if (llm.query_params && Object.keys(llm.query_params).length > 0)
+    table.query_params = { ...llm.query_params };
+  if (entry.headers && Object.keys(entry.headers).length > 0)
+    table.http_headers = { ...entry.headers };
+  return { table };
+}
+function buildCodexConfigDocument(input) {
+  const document = { model_providers: {} };
+  const skipped = [];
+  const entries = input.registry ? registryEntries(input.registry) : [];
+  for (const [id, entry] of entries) {
+    const rendered = renderCodexProviderTable(id, entry);
+    if ("skipped" in rendered) skipped.push({ id, reason: rendered.skipped });
+    else document.model_providers[codexProviderTableId(id)] = rendered.table;
+  }
+  if (!input.registry) return { document, skipped, warnings: [] };
+  const selected = parseModelRef(
+    input.modelRef?.trim() || input.model?.trim() || "",
+    input.registry,
+    input.roles
+  );
+  if (!selected) return { document, skipped, warnings: [] };
+  const warnings = selected.warnings;
+  const tableId = codexProviderTableId(selected.providerId);
+  if (!document.model_providers[tableId]) {
+    const reason = skipped.find((s) => s.id === selected.providerId)?.reason;
+    if (reason && selectionNamesEntry(input, selected, input.registry)) {
+      return {
+        document,
+        skipped,
+        warnings,
+        unaddressable: { id: selected.providerId, reason }
+      };
+    }
+    return { document, skipped, warnings };
+  }
+  document.model_provider = tableId;
+  if (selected.providerModelId) document.model = selected.providerModelId;
+  return {
+    document,
+    providerId: selected.providerId,
+    ...selected.providerModelId ? { model: selected.providerModelId } : {},
+    skipped,
+    warnings
+  };
+}
+function renderCodexConfigToml(document) {
+  const ordered = {};
+  if (document.model_provider) ordered.model_provider = document.model_provider;
+  if (document.model) ordered.model = document.model;
+  ordered.model_providers = document.model_providers;
+  return `${stringify(ordered)}
+`;
+}
+function codexSessionHome(config) {
+  const key = config.sessionId && /^[A-Za-z0-9._-]{1,128}$/.test(config.sessionId) ? config.sessionId : createHash("sha256").update(config.sessionId ?? config.cwd).digest("hex").slice(0, 32);
+  return join(globalSkaileDir(), "codex", key);
+}
+function writeCodexConfigToml(home, document) {
+  const path = join(home, "config.toml");
+  mkdirSync(home, { recursive: true, mode: 448 });
+  if (Object.keys(document.model_providers).length === 0) {
+    rmSync(path, { force: true });
+    return void 0;
+  }
+  const temporary = join(home, "config.toml.new");
+  rmSync(temporary, { force: true });
+  writeFileSync(temporary, renderCodexConfigToml(document), { mode: 384, flag: "wx" });
+  renameSync(temporary, path);
+  return path;
+}
+function isChatgptLogin(file) {
+  if (!file) return false;
+  try {
+    const doc = JSON.parse(readFileSync(file, "utf8"));
+    return doc.auth_mode === "chatgpt";
+  } catch {
+    return false;
+  }
+}
+function codexLoginFile(env) {
+  const home = env.CODEX_HOME?.trim() || join(env.HOME || homedir(), ".codex");
+  const file = join(home, "auth.json");
+  return existsSync(file) ? resolve(file) : void 0;
+}
+function usesCodexOwnAuth(build, env, loginFile) {
+  if (build.providerId !== "openai") return false;
+  const table = build.document.model_providers[codexProviderTableId("openai")];
+  if (!table?.env_key || table.requires_openai_auth || env[table.env_key]) return false;
+  return Boolean(env.OPENAI_API_KEY || env.CODEX_API_KEY || loginFile);
+}
+function codexLoginFallbackNotice(session, env) {
+  if (!session.registry) return void 0;
+  const build = buildCodexConfigDocument({
+    registry: session.registry,
+    ...session.modelRef ? { modelRef: session.modelRef } : {}
+  });
+  if (!usesCodexOwnAuth(build, env, codexLoginFile(env))) return void 0;
+  const unresolved = unresolvedProviderCredentials(session.registry, {
+    env,
+    providerId: "openai"
+  })[0];
+  return `provider 'openai' is not used: ${unresolved?.reason ?? "its credential is not set"}; codex uses its own login or OPENAI_API_KEY instead (check with \`skaile providers test openai\`)`;
+}
+
+// bridge/src/codex/friendly-error.ts
+function unwrapErrorBody(raw) {
+  const start = raw.indexOf("{");
+  if (start < 0) return raw;
+  try {
+    const body = JSON.parse(raw.slice(start));
+    const inner = typeof body.error === "object" ? body.error?.message : body.error;
+    const text2 = inner ?? body.message;
+    if (typeof text2 === "string" && text2.length > 0) return text2;
+  } catch {
+  }
+  return raw;
+}
+function nativeCause(raw) {
+  const reconnecting = /^Reconnecting\.\.\.\s*\d+\/\d+\s*\(([\s\S]*)\)\s*$/.exec(raw.trim());
+  const reason = reconnecting ? reconnecting[1] ?? "" : unwrapErrorBody(raw);
+  const line = reason.split(/[{\n]/, 1)[0]?.replace(/[\s:,.]+$/, "") ?? "";
+  return line.length > 160 ? `${line.slice(0, 157)}...` : line;
+}
+function friendlyCodexError(raw, context = {}) {
+  const text2 = unwrapErrorBody(raw);
+  const chatgpt = /'([^']+)' model is not supported when using Codex with a ChatGPT account/i.exec(
+    text2
+  );
+  if (chatgpt) {
+    return {
+      message: `codex harness: the model '${chatgpt[1]}' is not available with a ChatGPT login.`,
+      category: "model",
+      hint: "Update @openai/codex-sdk to the 0.16x line, pass --model with a model your login allows, or set OPENAI_API_KEY."
+    };
+  }
+  if (/newer version of codex|requires a newer version|update codex/i.test(text2)) {
+    return {
+      message: `codex harness: the selected model needs a newer Codex than the installed @openai/codex-sdk.`,
+      category: "model",
+      hint: "Update @openai/codex-sdk to the 0.16x line (npm i @openai/codex-sdk@latest)."
+    };
+  }
+  if (/invalid_api_key|incorrect api key|\b401\b[^.]*unauthorized|unauthorized[^.]*\b401\b/i.test(raw)) {
+    if (context.chatgptLogin) {
+      const cause = nativeCause(raw);
+      return {
+        message: `codex harness: the codex login was rejected (401)${cause ? `: ${cause}` : ""}.`,
+        category: "auth",
+        hint: "Run `codex login` to sign in again."
+      };
+    }
+    return {
+      message: "codex harness: the API key was rejected (401).",
+      category: "auth",
+      hint: "Check OPENAI_API_KEY (or sign in again with `codex login`)."
+    };
+  }
+  const reconnecting = /^Reconnecting\.\.\.\s*\d+\/\d+\s*\(([\s\S]*)\)\s*$/.exec(raw.trim());
+  if (reconnecting) {
+    const reason = (reconnecting[1] ?? "").split(/[{\n]/, 1)[0]?.replace(/[\s:,]+$/, "") ?? "";
+    return {
+      message: `codex harness: could not reach the model endpoint${reason ? ` (${reason})` : ""}.`,
+      category: "network",
+      hint: "Check the network and the provider's status, then run again."
+    };
+  }
+  return null;
+}
+
+// bridge/src/harnesses/codex.ts
+function buildCodexChildEnv(parent, codexHome) {
+  const out = {};
+  const explicit = [
+    "PATH",
+    "HOME",
+    "USER",
+    "HOSTNAME",
+    "SKAILE_SESSION_ID",
+    ...RUNNER_AGENT_ENV_KEYS
+  ];
+  for (const key of explicit) {
+    const v = parent[key];
+    if (v !== void 0) out[key] = v;
+  }
+  for (const [key, value] of Object.entries(parent)) {
+    if (key.startsWith("PI_") && typeof value === "string") out[key] = value;
+  }
+  for (const key of ["OPENAI_API_KEY", "CODEX_API_KEY"]) {
+    const v = parent[key];
+    if (v) out[key] = v;
+  }
+  out.CODEX_HOME = codexHome;
+  return out;
+}
+function linkCodexLogin(codexHome, loginFile) {
+  const target = join(codexHome, "auth.json");
+  mkdirSync(codexHome, { recursive: true, mode: 448 });
+  rmSync(target, { force: true });
+  try {
+    symlinkSync(loginFile, target);
+  } catch {
+    copyFileSync(loginFile, target);
+  }
+}
+function missingCodexCredential(build, env, loginFile, unresolved) {
+  const table = build.providerId ? build.document.model_providers[codexProviderTableId(build.providerId)] : void 0;
+  if (table) {
+    if (table.requires_openai_auth) return void 0;
+    if (!table.env_key || env[table.env_key]) return void 0;
+    return `codex harness: the AI provider entry '${build.providerId}' has no credential${unresolved ? ` (${unresolved})` : ""}; export the variable its credential names (see \`skaile providers test ${build.providerId}\`)`;
+  }
+  if (env.OPENAI_API_KEY || env.CODEX_API_KEY || loginFile) return void 0;
+  return "codex harness needs OPENAI_API_KEY, or the codex CLI's ChatGPT login (run `codex login`; ~/.codex/auth.json), or an AI provider entry with a credential";
+}
+function resolveCodexAuth(build, env, registry, loginEnv) {
+  const hasKey = Boolean(env.OPENAI_API_KEY || env.CODEX_API_KEY);
+  const loginFile = hasKey ? void 0 : codexLoginFile(loginEnv);
+  const ownAuth = usesCodexOwnAuth(build, env, loginFile);
+  if (ownAuth) {
+    delete build.document.model_provider;
+    delete build.document.model_providers[codexProviderTableId("openai")];
+  }
+  const unresolved = build.providerId && registry ? unresolvedProviderCredentials(registry, {
+    env: { ...process.env, ...env },
+    providerId: build.providerId
+  })[0]?.reason : void 0;
+  return { loginFile, missing: missingCodexCredential(build, env, loginFile, unresolved), ownAuth };
+}
+function checkCodexCredential(input) {
+  const build = buildCodexConfigDocument({
+    registry: input.registry,
+    ...input.model ? { modelRef: input.model, model: input.model } : {},
+    ...input.roles ? { roles: input.roles } : {}
+  });
+  if (build.unaddressable) return void 0;
+  const env = buildCodexChildEnv(process.env, "");
+  Object.assign(
+    env,
+    registryCredentialEnv(input.registry ?? {}, { env: { ...process.env, ...env } })
+  );
+  stripRunnerPrivateEnv(env);
+  return resolveCodexAuth(build, env, input.registry, process.env).missing;
+}
+var CodexHarness = class extends AgentHarness {
+  harnessInfo = {
+    id: "codex",
+    name: "OpenAI Codex",
+    modelAgnostic: false,
+    supportsInBandAbort: true,
+    capabilities: BUILTIN_HARNESS_CATALOG.codex?.capabilities
+  };
+  log = getBridgeLogger("codex");
+  config;
+  reconfig = new ReconfigureLedger({ config: () => this.config });
+  thread = null;
+  running = false;
+  abortController = null;
+  pendingToolResults = [];
+  /** The text of the last top-level `error` of the running turn: the cause when the stream ends with no `turn.*` event. */
+  lastStreamError = null;
+  activeAssistantItemId = null;
+  /** The run signs in with codex's ChatGPT login, not an API key: a 401 means the login lapsed. */
+  chatgptLogin = false;
+  activeAssistantText = "";
+  _runtimeSessionId;
+  /** Token usage from the most recent completed turn. */
+  _lastTokens = null;
+  constructor(config) {
+    super();
+    if (isManagedCodexConfig(config)) throw new Error("CODEX_MANAGED_REQUIRES_FACTORY");
+    this.config = config;
+  }
+  get runtimeSessionId() {
+    return this._runtimeSessionId;
+  }
+  async dispose() {
+    this.kill();
+  }
+  /**
+   * Store a model / thinking / effort change. The SDK thread is built from
+   * `config` in {@link start}, so the next thread start (first prompt, or after
+   * `resetSession()`) uses it; a thread already running keeps its options.
+   */
+  reconfigure(patch) {
+    return this.reconfig.reconfigure(patch);
+  }
+  getModel() {
+    return this.config.model;
+  }
+  async start() {
+    if (this.thread) return;
+    let sdk;
+    try {
+      sdk = await loadHarnessSdk(
+        "@openai/codex-sdk",
+        this.config.cwd,
+        () => import('@openai/codex-sdk'),
+        "Codex SDK"
+      );
+    } catch (err) {
+      this.log.error("codex SDK load failed", err);
+      throw err;
+    }
+    const codexHome = codexSessionHome(this.config);
+    const build = buildCodexConfigDocument({
+      registry: this.config.registry,
+      modelRef: this.config.modelRef,
+      model: this.config.model,
+      roles: this.config.roles
+    });
+    if (build.unaddressable) {
+      const { id, reason } = build.unaddressable;
+      const message = `AI provider '${id}' cannot be used with the codex harness: ${reason}. Pick a model of another provider.`;
+      this.log.error("codex cannot address the selected AI provider", { provider: id, reason });
+      throw Object.assign(new Error(message), { category: "config", hint: message });
+    }
+    for (const warning of build.warnings) this.log.warn("codex model selection", { warning });
+    for (const entry of build.skipped)
+      this.log.debug("codex cannot address an AI provider entry", {
+        provider: entry.id,
+        reason: entry.reason
+      });
+    const env = this.config.env ? { ...this.config.env, CODEX_HOME: codexHome } : buildCodexChildEnv(process.env, codexHome);
+    Object.assign(
+      env,
+      registryCredentialEnv(this.config.registry ?? {}, { env: { ...process.env, ...env } })
+    );
+    stripRunnerPrivateEnv(env);
+    const { loginFile, missing, ownAuth } = resolveCodexAuth(build, env, this.config.registry, {
+      ...process.env,
+      ...this.config.env
+    });
+    this.chatgptLogin = isChatgptLogin(loginFile);
+    if (ownAuth) this.log.debug("codex uses its own auth: the openai entry has no credential");
+    if (missing) {
+      this.log.error("codex credential missing", { reason: missing });
+      throw Object.assign(new Error(missing), { category: "config", hint: missing });
+    }
+    writeCodexConfigToml(codexHome, build.document);
+    if (loginFile) linkCodexLogin(codexHome, loginFile);
+    else rmSync(join(codexHome, "auth.json"), { force: true });
+    const instructionsFile = this.writeInstructionsFile();
+    const client = new sdk.Codex({
+      apiKey: env.OPENAI_API_KEY,
+      env: Object.fromEntries(Object.entries(env).filter(([, value]) => value != null)),
+      ...instructionsFile ? { config: { model_instructions_file: instructionsFile } } : {}
+    });
+    const codexOptions = this.config.harnessOptions?.codex;
+    const threadOptions = {
+      model: build.model ?? this.config.model,
+      sandboxMode: codexOptions?.sandboxMode ?? "workspace-write",
+      workingDirectory: this.config.cwd,
+      skipGitRepoCheck: true,
+      modelReasoningEffort: codexOptions?.reasoningEffort ?? "medium",
+      networkAccessEnabled: codexOptions?.networkAccessEnabled,
+      approvalPolicy: codexOptions?.approvalPolicy ?? "never",
+      additionalDirectories: codexOptions?.additionalDirectories
+    };
+    this.thread = this.config.resumeSessionId ? client.resumeThread(this.config.resumeSessionId, threadOptions) : client.startThread(threadOptions);
+    this._runtimeSessionId = this.thread.id ?? this.config.resumeSessionId;
+    this.log.info("codex harness started", {
+      model: this.config.model,
+      resumed: Boolean(this.config.resumeSessionId),
+      sessionId: this._runtimeSessionId
+    });
+  }
+  async prompt(message) {
+    await this.start();
+    if (!this.thread) throw new Error("Codex thread not initialized");
+    if (this.running) throw new Error("Codex turn already in progress");
+    this.running = true;
+    this.pendingToolResults = [];
+    this.activeAssistantItemId = null;
+    this.activeAssistantText = "";
+    this._lastTokens = null;
+    this.abortController = new AbortController();
+    let turnFinished = false;
+    this.lastStreamError = null;
+    this.log.debug("prompt issued", { length: message.length });
+    try {
+      const input = message;
+      const { events } = await this.thread.runStreamed(input, {
+        signal: this.abortController.signal
+      });
+      for await (const event of events) {
+        if (turnFinished) {
+          this.log.debug("codex event after the turn ended", { type: event.type });
+          continue;
+        }
+        turnFinished = this.handleThreadEvent(event);
+      }
+      if (!turnFinished && this.lastStreamError !== null) {
+        this.flushToolResults();
+        const detail = this.classifyErrorMessage(this.lastStreamError);
+        this.emit("agent-event", {
+          type: "error",
+          error: detail.message,
+          detail
+        });
+        this.emit("agent-event", { type: "agent_end" });
+        turnFinished = true;
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (error.name !== "AbortError") {
+        this.log.error("prompt failed", error);
+        if (!turnFinished) {
+          const detail = this.classifyErrorMessage(error.message);
+          this.emit("agent-event", {
+            type: "error",
+            error: detail.message,
+            detail
+          });
+          this.emit("agent-event", { type: "agent_end" });
+        }
+      }
+    } finally {
+      if (!turnFinished && this.activeAssistantItemId) {
+        this.emit("agent-event", {
+          type: "message_end",
+          message: this.buildAssistantMessage(this.activeAssistantText)
+        });
+      }
+      this.activeAssistantItemId = null;
+      this.activeAssistantText = "";
+      this.abortController = null;
+      this.running = false;
+    }
+  }
+  async abort() {
+    this.abortController?.abort();
+  }
+  get isRunning() {
+    return this.running;
+  }
+  kill() {
+    this.abortController?.abort();
+    this.running = false;
+    this.abortController = null;
+    this.log.info("codex harness killed");
+  }
+  /**
+   * Discover models from the endpoint this session actually addresses.
+   *
+   * The registry entry codex would talk to supplies both the base URL and the
+   * credential, so a session pointed at a gateway lists that gateway's models
+   * instead of api.openai.com's. A `platform:` reference the session boundary
+   * already resolved is picked up from `SKAILE_AIP_<ID>_KEY` in the session
+   * env. Without a registry entry codex can address, an ambient
+   * `OPENAI_API_KEY` is the last resort.
+   */
+  async listModels() {
+    const selected = this.selectedProviderEntry();
+    const sessionEnv = { ...process.env, ...this.config.env };
+    const apiKey = selected ? entryCredentialValue(selected.id, selected.entry, { env: sessionEnv }) : sessionEnv.OPENAI_API_KEY;
+    if (!apiKey) return [];
+    const baseUrl = selected ? resolveEntryBaseUrl(selected.entry) : void 0;
+    const result = await fetchProviderModels("openai", apiKey, baseUrl ? { baseUrl } : {});
+    return result.ok ? result.models : [];
+  }
+  /**
+   * The registry entry codex addresses this session — the same selection the
+   * rendered `config.toml` names in `model_provider`.
+   */
+  selectedProviderEntry() {
+    const registry = this.config.registry;
+    if (!registry) return void 0;
+    const { providerId } = buildCodexConfigDocument({
+      registry,
+      modelRef: this.config.modelRef,
+      model: this.config.model,
+      roles: this.config.roles
+    });
+    if (!providerId) return void 0;
+    const match = registryEntries(registry).find(([id]) => id === providerId);
+    return match ? { id: match[0], entry: match[1] } : void 0;
+  }
+  async resetSession() {
+    this.kill();
+    this.config = { ...this.config, resumeSessionId: void 0 };
+    this.thread = null;
+    this._runtimeSessionId = void 0;
+    this._lastTokens = null;
+  }
+  getTokenUsage() {
+    return this._lastTokens;
+  }
+  /**
+   * Write a combined instructions file for Codex CLI's `model_instructions_file` config.
+   * Combines the agent's pre-rendered identity (`.codex/skaile-agents/<agentName>.md`, written
+   * by `skaile install`, one file per agent instance) with runtime context
+   * (resources, environment, prompt-extensions).
+   */
+  writeInstructionsFile() {
+    const parts = [];
+    if (this.config.agentDir && this.config.agentName) {
+      const agentFile = join(
+        this.config.cwd,
+        ".codex",
+        "skaile-agents",
+        `${this.config.agentName}.md`
+      );
+      if (existsSync(agentFile)) {
+        parts.push(readFileSync(agentFile, "utf-8"));
+      }
+    }
+    if (this.config.systemPrompt) {
+      parts.push(this.config.systemPrompt);
+    }
+    if (parts.length === 0) return void 0;
+    const instrFile = join(this.config.cwd, ".codex", "skaile-session-instructions.md");
+    mkdirSync(dirname(instrFile), { recursive: true });
+    writeFileSync(instrFile, parts.join("\n\n---\n\n"));
+    return instrFile;
+  }
+  handleThreadEvent(event) {
+    switch (event.type) {
+      case "thread.started":
+        this._runtimeSessionId = event.thread_id;
+        return false;
+      case "turn.started":
+        return false;
+      case "item.started":
+      case "item.updated":
+      case "item.completed":
+        this.handleThreadItem(event.item, event.type === "item.completed", event.type);
+        return false;
+      case "turn.completed": {
+        this.flushToolResults();
+        const usage = event.usage;
+        const tokens = usage ? {
+          inputTokens: usage.input_tokens,
+          outputTokens: usage.output_tokens,
+          cacheReadTokens: usage.cached_input_tokens
+        } : null;
+        this._lastTokens = tokens;
+        this.emit("agent-event", {
+          type: "result",
+          subtype: "success",
+          summary: this.activeAssistantText || "Task completed",
+          // Codex SDK does not report per-turn cost. `0` signals "not
+          // reported" — pair with `tokens` to disambiguate from "free".
+          costUsd: 0,
+          ...tokens ? { tokens } : {}
+        });
+        this.emit("agent-event", { type: "agent_end" });
+        return true;
+      }
+      case "turn.failed": {
+        this.flushToolResults();
+        const detail = this.classifyErrorMessage(event.error.message);
+        this.emit("agent-event", {
+          type: "error",
+          error: detail.message,
+          detail
+        });
+        this.emit("agent-event", { type: "agent_end" });
+        return true;
+      }
+      case "error":
+        this.log.warn("codex stream error", { message: event.message });
+        this.lastStreamError = event.message;
+        return false;
+    }
+  }
+  handleThreadItem(item, completed, phase) {
+    switch (item.type) {
+      case "agent_message":
+        this.handleAgentMessage(item, completed);
+        break;
+      case "command_execution":
+        this.handleCommandExecution(item, completed, phase);
+        break;
+      case "mcp_tool_call":
+        this.handleMcpToolCall(item, completed, phase);
+        break;
+      case "file_change":
+        this.handleFileChange(item, completed, phase);
+        break;
+      case "web_search":
+        this.handleWebSearch(item, completed, phase);
+        break;
+      case "error":
+        if (completed) this.log.warn("codex reported", { message: item.message });
+        break;
+    }
+  }
+  handleAgentMessage(item, completed) {
+    if (this.activeAssistantItemId !== item.id) {
+      if (this.activeAssistantItemId) {
+        this.emit("agent-event", {
+          type: "message_end",
+          message: this.buildAssistantMessage(this.activeAssistantText)
+        });
+      }
+      this.activeAssistantItemId = item.id;
+      this.activeAssistantText = "";
+      this.emit("agent-event", {
+        type: "message_start",
+        message: this.buildAssistantMessage("")
+      });
+    }
+    const nextText = item.text ?? "";
+    const delta = nextText.startsWith(this.activeAssistantText) ? nextText.slice(this.activeAssistantText.length) : nextText;
+    this.activeAssistantText = nextText;
+    if (delta) {
+      this.emit("agent-event", {
+        type: "message_update",
+        message: this.buildAssistantMessage(nextText),
+        _textDelta: delta
+      });
+    }
+    if (completed) {
+      this.emit("agent-event", {
+        type: "message_end",
+        message: this.buildAssistantMessage(nextText)
+      });
+      this.activeAssistantItemId = null;
+    }
+  }
+  handleCommandExecution(item, completed, phase) {
+    if (phase === "item.started") {
+      this.emit("agent-event", {
+        type: "tool_call",
+        name: "Bash",
+        tool: { name: "Bash" },
+        input: { command: item.command }
+      });
+    }
+    if (completed) {
+      this.pendingToolResults.push({
+        role: "tool",
+        toolName: "Bash",
+        content: "",
+        data: {
+          stdout: item.aggregated_output,
+          stderr: "",
+          exitCode: item.exit_code,
+          status: item.status,
+          command: item.command
+        },
+        isError: item.status === "failed"
+      });
+      this.emit("agent-event", {
+        type: "tool_execution_end",
+        toolName: "Bash"
+      });
+    }
+  }
+  handleMcpToolCall(item, completed, phase) {
+    const toolName = `mcp__${item.server}__${item.tool}`;
+    if (phase === "item.started") {
+      this.emit("agent-event", {
+        type: "tool_call",
+        name: toolName,
+        tool: { name: toolName },
+        input: this.toObject(item.arguments)
+      });
+    }
+    if (completed) {
+      this.pendingToolResults.push({
+        role: "tool",
+        toolName,
+        content: "",
+        data: {
+          status: item.status,
+          content: item.result?.content,
+          structuredContent: item.result?.structured_content,
+          error: item.error?.message
+        },
+        isError: item.status === "failed"
+      });
+      this.emit("agent-event", {
+        type: "tool_execution_end",
+        toolName
+      });
+    }
+  }
+  handleFileChange(item, completed, phase) {
+    if (phase === "item.started") {
+      this.emit("agent-event", {
+        type: "tool_call",
+        name: "ApplyPatch",
+        tool: { name: "ApplyPatch" },
+        input: { changes: item.changes }
+      });
+    }
+    if (completed) {
+      this.pendingToolResults.push({
+        role: "tool",
+        toolName: "ApplyPatch",
+        content: "",
+        data: { status: item.status, changes: item.changes },
+        isError: item.status === "failed"
+      });
+      this.emit("agent-event", {
+        type: "tool_execution_end",
+        toolName: "ApplyPatch"
+      });
+    }
+  }
+  handleWebSearch(item, completed, phase) {
+    if (phase === "item.started") {
+      this.emit("agent-event", {
+        type: "tool_call",
+        name: "WebSearch",
+        tool: { name: "WebSearch" },
+        input: { query: item.query }
+      });
+    }
+    if (completed) {
+      this.pendingToolResults.push({
+        role: "tool",
+        toolName: "WebSearch",
+        content: "",
+        data: { query: item.query, status: "completed" }
+      });
+      this.emit("agent-event", {
+        type: "tool_execution_end",
+        toolName: "WebSearch"
+      });
+    }
+  }
+  flushToolResults() {
+    if (this.pendingToolResults.length === 0) return;
+    this.emit("agent-event", {
+      type: "turn_end",
+      toolResults: [...this.pendingToolResults]
+    });
+    this.pendingToolResults = [];
+  }
+  buildAssistantMessage(text2) {
+    return {
+      role: "assistant",
+      content: [{ type: "text", text: text2 }]
+    };
+  }
+  toObject(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      return value;
+    }
+    return { arguments: value };
+  }
+  classifyErrorMessage(rawMessage) {
+    const friendly = friendlyCodexError(rawMessage, { chatgptLogin: this.chatgptLogin });
+    if (friendly) {
+      return {
+        message: friendly.message,
+        category: friendly.category,
+        retryable: false,
+        hint: friendly.hint
+      };
+    }
+    const message = rawMessage;
+    const generic = classifyGenericErrorMessage(message);
+    if (generic) {
+      const hint = generic.category === "auth" ? "Check your OpenAI API key configuration in settings or environment." : generic.category === "rate_limit" ? "Codex hit an OpenAI rate limit. Wait briefly and try again." : generic.category === "model" ? "The selected Codex model is unavailable. Choose a different model." : "A network error occurred while talking to Codex.";
+      return { message, category: generic.category, retryable: generic.retryable, hint };
+    }
+    const lower = message.toLowerCase();
+    if (lower.includes("sandbox") || lower.includes("approval") || lower.includes("permission") || lower.includes("git repo")) {
+      return {
+        message,
+        category: "config",
+        retryable: false,
+        hint: "Check Codex sandbox, approval, and workspace configuration."
+      };
+    }
+    return {
+      message,
+      category: "unknown",
+      retryable: true,
+      hint: "An unexpected Codex error occurred. Try the prompt again."
+    };
+  }
+};
+function isManagedCodexConfig(config) {
+  const codex = config.harnessOptions?.codex;
+  return Boolean(
+    codex?.managedRuntime || codex?.authSource !== void 0 && codex.authSource !== "local"
+  );
+}
+var codexHarnessTarget = {
+  id: "codex",
+  displayName: BUILTIN_HARNESS_CATALOG.codex?.name ?? "OpenAI Codex",
+  apiVersion: 1,
+  // Harnesses take AgentConfig; passthrough — full schema validation is out of scope.
+  configSchema: z.custom(() => true),
+  create: async (config, _ctx) => isManagedCodexConfig(config) ? new ManagedCodexHarness(config) : new CodexHarness(config),
+  listModels: async (registry, options) => {
+    const config = {
+      cwd: process.cwd(),
+      sessionId: "model-list",
+      ...registryHarnessConfig(registry, options)
+    };
+    return (isManagedCodexConfig(config) ? new ManagedCodexHarness(config) : new CodexHarness(config)).listModels();
+  }
+};
+
+export { CodexHarness, buildCodexConfigDocument, checkCodexCredential, codexHarnessTarget, codexInstanceEnvironment, codexLoginFallbackNotice, isManagedCodexConfig, parseCodexCredential, parseCodexRefreshInput, parseCodexRefreshResult, prepareNativePolicy };
+//# sourceMappingURL=chunk-HLFLET7S.js.map
+//# sourceMappingURL=chunk-HLFLET7S.js.map