@skaile/workspaces 6.9.1 → 6.10.0

package/dist/bridge/harnesses/codex.js

@@ -1,1943 +1,32 @@
-import { CodexAppServerClient } from '../../chunk-KNY356I3.js';
-import { freshBudget, decide, spend } from '../../chunk-7EKQDY2T.js';
-import { managedCodexRegistryViolation, parseCodexCredential, prepareNativePolicy, prepareCodexInstance, codexInstanceEnvironment, isNativeApprovalPolicyActive, activateNativeApprovalPolicy, parseCodexRefreshResult, allowsNativeApprovalPath } from '../../chunk-GYPPVANR.js';
-import { codexSessionHome, buildCodexConfigDocument, codexLoginFile, isChatgptLogin, usesCodexOwnAuth, codexProviderTableId, writeCodexConfigToml } from '../../chunk-C324IAXI.js';
-import { CodexNativeStateUnavailable } from '../../chunk-LOO5CB5M.js';
-import { fetchProviderModels } from '../../chunk-3AIEJSQR.js';
-import { ReconfigureLedger, stripRunnerPrivateEnv, classifyGenericErrorMessage, RUNNER_AGENT_ENV_KEYS } from '../../chunk-5DE3DGVR.js';
+export { CodexHarness, checkCodexCredential, codexHarnessTarget, isManagedCodexConfig } from '../../chunk-HLFLET7S.js';
+import '../../chunk-5KSGZP3E.js';
+import '../../chunk-7EKQDY2T.js';
+import '../../chunk-3AIEJSQR.js';
+import '../../chunk-5DE3DGVR.js';
 import '../../chunk-7DN6JKP2.js';
-import { AgentHarness, TOOL_ALLOWLIST_UNSUPPORTED, getBridgeLogger, registryHarnessConfig } from '../../chunk-5J6N6LHL.js';
-import { BUILTIN_HARNESS_CATALOG, registryCredentialEnv, unresolvedProviderCredentials, entryCredentialValue } from '../../chunk-7TF5MNFK.js';
+import '../../chunk-NFFBYG2W.js';
+import '../../chunk-KE5HDORU.js';
 import '../../chunk-G5SUWZEU.js';
 import '../../chunk-6UP2EDFN.js';
 import '../../chunk-WS3BOCAT.js';
-import { loadHarnessSdk } from '../../chunk-4KPQ6ILH.js';
+import '../../chunk-MEU2HHGV.js';
 import '../../chunk-4GY63JU6.js';
-import '../../chunk-4ROXSQEG.js';
+import '../../chunk-CJO3XKO7.js';
 import '../../chunk-5KRMNUL4.js';
 import '../../chunk-C5HFK34M.js';
 import '../../chunk-MWXYN6NY.js';
-import '../../chunk-FZO64PLQ.js';
+import '../../chunk-BNLXZXZN.js';
 import '../../chunk-L5VSIPQD.js';
 import '../../chunk-VTETQCR6.js';
-import '../../chunk-QC5BYUED.js';
-import '../../chunk-GNUA7XT2.js';
+import '../../chunk-MS2IXLTC.js';
+import '../../chunk-VS6XC5JE.js';
 import '../../chunk-RVRB27AN.js';
-import '../../chunk-V5KG6CCV.js';
+import '../../chunk-7HRZACI4.js';
 import '../../chunk-VSX2G7LA.js';
-import { resolveEntryBaseUrl, registryEntries } from '../../chunk-RXGPFAMN.js';
-import '../../chunk-MDCI4RSG.js';
+import '../../chunk-RXGPFAMN.js';
+import '../../chunk-RZL4TOK3.js';
 import '../../chunk-C3CAXQMA.js';
 import '../../chunk-BOFL7GIF.js';
 import '../../chunk-NSBPE2FW.js';
-import { isAbsolute, join, dirname, relative } from 'path';
-import { isDeepStrictEqual } from 'util';
-import { rmSync, existsSync, readFileSync, mkdirSync, writeFileSync, realpathSync, statSync, symlinkSync, copyFileSync } from 'fs';
-import { randomUUID } from 'crypto';
-import * as z from 'zod';
-
-var invalid = () => 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 invalid();
-  const result = [
-    { type: "text", text: input.text }
-  ];
-  for (const attachment of input.attachments ?? []) {
-    try {
-      if (!attachment || typeof attachment.path !== "string") throw invalid();
-      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 invalid();
-      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 invalid();
-        if (attachment.type === "skill") {
-          if (!skills) throw invalid();
-          const copied = realpathSync(join(skills.target, relative(root, path)));
-          if (!inside(realpathSync(skills.target), copied) || !statSync(copied).isFile())
-            throw invalid();
-          result.push({ type: "skill", name: attachment.name, path: copied });
-        } else result.push({ type: "mention", name: attachment.name, path });
-      } else throw invalid();
-    } catch {
-      throw invalid();
-    }
-  }
-  return result;
-}
-
-// bridge/src/codex/native-approvals.ts
-function createCodexNativeApprovalHandlers(options) {
-  const active = (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) => active(signal, threadId) && text2(path) && allowsNativeApprovalPath(options.getPolicy(), path, access) && active(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 active(signal, threadId);
-  };
-  const consent = async (identity, approval, signal) => {
-    if (!active(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) && active(signal, identity.threadId);
-    } catch {
-      return false;
-    }
-  };
-  return {
-    "item/commandExecution/requestApproval": async (input, signal) => {
-      const params = structuredClone(input);
-      const allowed = async () => active(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 (!active(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 (!active(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 active(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 () => active(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 record = (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 active = () => !signal.aborted && options.bindingActive() && isNativeApprovalPolicyActive(options.getPolicy(), params.threadId);
-      if (!active() || !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)
-      ) || !record(params._meta) || params._meta.codex_approval_kind !== "mcp_tool_call" || !record(params.requestedSchema) || params.requestedSchema.type !== "object" || !record(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 && active() ? { 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((resolve, 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) resolve(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 record2 = (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 active = this.active;
-        if (!active && !this.starting) throw failure("CODEX_AUTH_UNAVAILABLE");
-        if (!active) this.startupAuthAttempted = true;
-        const cancellation = AbortSignal.any([
-          signal,
-          this.controller.signal,
-          ...active ? [active.controller.signal] : []
-        ]);
-        try {
-          return await this.refresh(params, cancellation);
-        } catch {
-          if (active && this.active === active) active.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 record2(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 || !record2(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 active = this.active;
-        if (!active || active.controller.signal.aborted || threadId !== this.threadId || turnId !== active.id)
-          return void 0;
-        const snapshot = active.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) && record2(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 active = this.active;
-        if (generation !== this.generation || !active || !record2(params)) throw failure();
-        await active.ready;
-        if (generation !== this.generation || this.active !== active || params.threadId !== this.threadId || params.turnId !== active.id)
-          throw failure();
-        const cancellation = AbortSignal.any([signal, active.controller.signal]);
-        if (cancellation.aborted) throw failure();
-        if (method === "mcpServer/elicitation/request") {
-          mcpReplies.set(
-            params,
-            () => generation === this.generation && this.active === active && !cancellation.aborted && params.threadId === this.threadId && params.turnId === active.id && mcpBindingActive() && isNativeApprovalPolicyActive(mcpPolicy(), this.threadId ?? "")
-          );
-        }
-        const result = await handler(params, cancellation);
-        if (generation !== this.generation || cancellation.aborted || this.active !== active)
-          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 (!record2(response) || response.model !== this.config.model)
-      throw failure("CODEX_MODEL_UNAVAILABLE");
-    if (!record2(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) => record2(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((resolve, reject) => {
-      this.loginCompleted = { resolve, 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 (!record2(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 active = this.active;
-    const budget = active ? active.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 (active) active.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((resolve) => {
-      readyNow = resolve;
-    });
-    const done = new Promise((resolve) => {
-      finish = resolve;
-    });
-    const active = {
-      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 = active;
-    this.mcpDiagnostics.nativeMcpToolItemCount = 0;
-    this.observeMcp(true);
-    this.tools?.beginTurn?.(active.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 !== active) return;
-      if (!record2(response.turn) || typeof response.turn.id !== "string") throw failure();
-      active.id = response.turn.id;
-      active.readyNow();
-      for (const event of active.events.splice(0)) this.notification(event.method, event.params);
-      if (this.active === active && response.turn.status !== "inProgress")
-        this.complete(response.turn);
-      await done;
-    } catch {
-      this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
-    }
-  }
-  async abort() {
-    const active = this.active;
-    if (!active) return;
-    active.controller.abort();
-    try {
-      if (!active.id)
-        await bounded(
-          active.ready,
-          this.controller.signal,
-          limit(this.options?.requestTimeoutMs, 15e3)
-        );
-      if (this.active !== active) return;
-      await this.client.request("turn/interrupt", {
-        threadId: this.threadId,
-        turnId: active.id
-      });
-      await bounded(
-        active.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 (!record2(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 active = this.active;
-    if ((!active || !active.usageCursor && this.resumeUsageTurnIds.has(String(params.turnId))) && method === "thread/tokenUsage/updated" && params.threadId === (this.threadId ?? this.config.resumeSessionId) && record2(params.tokenUsage) && record2(params.tokenUsage.total)) {
-      this.threadUsageTotal = nativeUsage(params.tokenUsage.total);
-      if (active) active.usageBaseline = this.threadUsageTotal;
-      return;
-    }
-    if (!active || params.threadId !== this.threadId) return;
-    if (!active.id) {
-      if (active.events.length >= 256) {
-        this.broken = true;
-        this.finishTurn("CODEX_RUNTIME_UNSUPPORTED");
-        void this.closeGeneration();
-      } else active.events.push({ method, params });
-      return;
-    }
-    const turnId = record2(params.turn) ? params.turn.id : params.turnId;
-    if (turnId !== active.id) return;
-    if (method === "thread/tokenUsage/updated" && record2(params.tokenUsage)) {
-      const last = params.tokenUsage.last;
-      const total = params.tokenUsage.total;
-      const cumulativeUsage = record2(total) ? nativeUsage(total) : void 0;
-      if (cumulativeUsage) {
-        active.usageBaseline ??= {};
-        this.resumeUsageTurnIds.clear();
-        const cursor = active.usageCursor ?? active.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))
-          active.usage = addUsage(active.usage, increment);
-        active.usageCursor = cumulativeUsage;
-        this.threadUsageTotal = cumulativeUsage;
-      }
-      if (record2(last)) {
-        if (typeof last.totalTokens === "number") active.contextTokens = last.totalTokens;
-      }
-      if (typeof params.tokenUsage.modelContextWindow === "number")
-        active.contextWindow = params.tokenUsage.modelContextWindow;
-    } else if (method === "model/rerouted") {
-      active.actualModel = typeof params.toModel === "string" ? params.toModel : active.actualModel;
-      active.failureCode = "CODEX_MODEL_UNAVAILABLE";
-    } else if (method === "turn/completed" && record2(params.turn)) this.complete(params.turn);
-    else if (method === "error" && params.willRetry !== true)
-      active.failureCode = this.nativeErrorCode(params.error);
-    else if (method === "item/agentMessage/delta" && typeof params.itemId === "string" && typeof params.delta === "string") {
-      const previous = active.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;
-      active.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") && record2(params.item) && typeof params.item.id === "string") {
-      this.item(
-        params.item,
-        method === "item/completed"
-      );
-    }
-  }
-  item(item, completed) {
-    const active = this.active;
-    if (item.type === "fileChange") {
-      active.fileChanges.delete(item.id);
-      if (!completed && Array.isArray(item.changes) && item.changes.length <= 16 && active.fileChanges.size < 16) {
-        const snapshot = JSON.stringify(item.changes);
-        if (snapshot.length <= 65536) active.fileChanges.set(item.id, snapshot);
-      }
-    }
-    if (item.type === "agentMessage") {
-      if (completed && typeof item.text === "string") {
-        const previous = active.messages.get(item.id) ?? "";
-        if (!active.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)
-          });
-        active.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 (!active.toolItems.has(item.id)) {
-      if (item.type === "mcpToolCall" && item.server === this.tools?.diagnostics?.serverName)
-        this.mcpDiagnostics.nativeMcpToolItemCount = Math.min(
-          512,
-          this.mcpDiagnostics.nativeMcpToolItemCount + 1
-        );
-      active.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 && !active.completedToolItems.has(item.id)) {
-      active.completedToolItems.add(item.id);
-      active.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 = record2(error) ? error.codexErrorInfo : void 0;
-    if (info === "unauthorized") return "CODEX_RECONNECT_REQUIRED";
-    if (info === "usageLimitExceeded" || info === "rateLimitExceeded" || info === "serverOverloaded")
-      return "CODEX_RATE_LIMITED";
-    if (record2(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 active = this.active;
-    if (!active) return;
-    this.active = void 0;
-    this.observeMcp(false);
-    clearTimeout(active.timer);
-    active.controller.abort();
-    active.fileChanges.clear();
-    active.readyNow();
-    for (const text2 of active.messages.values())
-      this.event({
-        type: "message_end",
-        message: { role: "assistant", content: [{ type: "text", text: text2 }] }
-      });
-    this.event({ type: "turn_end", toolResults: active.toolResults });
-    const modelUsage = active.usage ? {
-      inputTokens: active.usage.inputTokens,
-      outputTokens: active.usage.outputTokens,
-      cacheReadTokens: active.usage.cacheReadTokens,
-      ...typeof active.contextWindow === "number" ? { contextWindow: active.contextWindow } : {}
-    } : void 0;
-    const usage = {
-      ...active.usage ? { tokens: active.usage } : {},
-      ...modelUsage ? { modelUsage: { [active.actualModel]: modelUsage } } : {},
-      ...typeof active.contextTokens === "number" ? { contextTokens: active.contextTokens } : {},
-      ...typeof active.contextWindow === "number" ? { contextWindow: active.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: [...active.messages.values()].join("\n"),
-        ...usage
-      });
-    this.event({ type: "agent_end" });
-    active.finish();
-  }
-  event(event) {
-    try {
-      this.emit("agent-event", event);
-    } catch {
-    }
-  }
-};
-
-// 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";
-}
-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 = [];
-  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 hasKey = Boolean(env.OPENAI_API_KEY || env.CODEX_API_KEY);
-    const loginFile = hasKey ? void 0 : codexLoginFile({ ...process.env, ...this.config.env });
-    this.chatgptLogin = isChatgptLogin(loginFile);
-    if (usesCodexOwnAuth(build, env, loginFile)) {
-      delete build.document.model_provider;
-      delete build.document.model_providers[codexProviderTableId("openai")];
-      this.log.debug("codex uses its own auth: the openai entry has no credential");
-    }
-    const unresolved = build.providerId && this.config.registry ? unresolvedProviderCredentials(this.config.registry, {
-      env: { ...process.env, ...env },
-      providerId: build.providerId
-    })[0]?.reason : void 0;
-    const missing = missingCodexCredential(build, env, loginFile, unresolved);
-    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.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) {
-        turnFinished = this.handleThreadEvent(event) || turnFinished;
-      }
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (error.name !== "AbortError") {
-        this.log.error("prompt failed", error);
-        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": {
-        const detail = this.classifyErrorMessage(event.message);
-        this.emit("agent-event", {
-          type: "error",
-          error: detail.message,
-          detail
-        });
-        this.emit("agent-event", { type: "agent_end" });
-        return true;
-      }
-    }
-  }
-  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.pendingToolResults.push({
-            role: "tool",
-            toolName: "CodexError",
-            content: "",
-            data: { message: item.message },
-            isError: true
-          });
-        }
-        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, codexHarnessTarget, isManagedCodexConfig };
 //# sourceMappingURL=codex.js.map
 //# sourceMappingURL=codex.js.map