@skaile/workspaces 3.16.2 → 3.18.0

package/dist/bridge/drivers/codex.js

@@ -1,14 +1,1108 @@
+import { CodexAppServerClient } from '../../chunk-XKSGEYZC.js';
+import { parseCodexCredential, prepareNativePolicy, prepareCodexInstance, codexInstanceEnvironment, activateNativeApprovalPolicy, parseCodexRefreshResult, isNativeApprovalPolicyActive, allowsNativeApprovalPath } from '../../chunk-T3YLZQS4.js';
+import { CodexNativeStateUnavailable } from '../../chunk-LOO5CB5M.js';
 import { fetchProviderModels } from '../../chunk-GURXUF2J.js';
 import { classifyGenericErrorMessage } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-FRER2PEN.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-J7VSUGGH.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-FTG7CRFD.js';
 import '../../chunk-W4IPN3DD.js';
 import '../../chunk-NSBPE2FW.js';
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, isAbsolute, relative } from 'path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, realpathSync, statSync } 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 text = (value) => typeof value === "string" && value.length > 0 && value.length <= 8192;
+  const scoped = async (path, access, signal, threadId) => active(signal, threadId) && text(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) && text(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 (!text(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"
+      };
+    }
+  };
+}
+var CodexQuestions = class {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  emit;
+  pending;
+  request = async (params, signal) => this.park(params, signal);
+  /** Park one explicit native consent request in the same slot as ordinary questions. */
+  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?" : "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");
+    const id = randomUUID();
+    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: params.questions,
+        ...approval ? { 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: params.itemId,
+              input
+            }
+          ]
+        }
+      });
+      this.emit({
+        type: "tool_call",
+        name: "AskUserQuestion",
+        tool: { name: "AskUserQuestion" },
+        toolCallId: params.itemId,
+        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-driver.ts
+var record = (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 ManagedCodexDriver = class extends AgentDriver {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  driverInfo = {
+    id: "codex",
+    name: "OpenAI Codex",
+    modelAgnostic: false,
+    supportsInBandAbort: true
+  };
+  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;
+  startupRefreshUsed = false;
+  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);
+  }
+  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.driverOptions?.codex?.managedRuntime;
+    const tuning = this.config.driverOptions?.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" || this.config.provider && this.config.provider !== "openai" || this.config.apiKeys?.openai || this.config.env?.OPENAI_API_KEY || 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;
+    this.controller = new AbortController();
+    this.startupRefreshUsed = false;
+    this.startupAuthAttempted = false;
+    const handlers = {
+      "account/chatgptAuthTokens/refresh": async (params, signal) => {
+        const active = this.active;
+        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,
+        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 || !record(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;
+      }
+    });
+    for (const [method, handler] of Object.entries({
+      ...this.tools.onServerRequest,
+      ...nativeApprovals,
+      "item/tool/requestUserInput": this.questions.request
+    })) {
+      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 || !record(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();
+        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 (!record(response) || response.model !== this.config.model)
+      throw failure("CODEX_MODEL_UNAVAILABLE");
+    if (!record(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) => record(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 (!record(params) || params.reason !== "unauthorized" || !credential || credential.kind !== "codex-subscription" || params.previousAccountId != null && params.previousAccountId !== credential.chatgptAccountId || !this.options?.refreshCredential || (this.active ? this.active.refreshUsed : this.startupRefreshUsed))
+      throw failure("CODEX_AUTH_UNAVAILABLE");
+    if (this.active) this.active.refreshUsed = true;
+    else this.startupRefreshUsed = true;
+    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) {
+    const message = structuredClone(input);
+    const turnBudget = this.config.driverOptions?.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(),
+      refreshUsed: false,
+      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.driverOptions.codex.reasoningEffort
+      });
+      if (this.active !== active) return;
+      if (!record(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;
+  }
+  reconfigure(patch) {
+    this.pendingPatch = { ...this.pendingPatch, ...patch };
+  }
+  closeGeneration() {
+    ++this.generation;
+    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)
+          await bounded(
+            Promise.resolve().then(() => tools.dispose()),
+            new AbortController().signal,
+            1e3
+          ).catch(() => {
+            this.cleanupUncertain = true;
+          });
+      } finally {
+        instance?.release();
+      }
+    }).catch(() => {
+      this.cleanupUncertain = true;
+    });
+    return this.closing;
+  }
+  notification(method, params) {
+    if (!record(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) && record(params.tokenUsage) && record(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 = record(params.turn) ? params.turn.id : params.turnId;
+    if (turnId !== active.id) return;
+    if (method === "thread/tokenUsage/updated" && record(params.tokenUsage)) {
+      const last = params.tokenUsage.last;
+      const total = params.tokenUsage.total;
+      const cumulativeUsage = record(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 (record(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" && record(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 text = (previous ?? "") + params.delta;
+      active.messages.set(params.itemId, text);
+      this.event({
+        type: "message_update",
+        message: { role: "assistant", content: [{ type: "text", text }] },
+        _textDelta: params.delta
+      });
+    } else if ((method === "item/started" || method === "item/completed") && record(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 = record(error) ? error.codexErrorInfo : void 0;
+    if (info === "unauthorized") return "CODEX_RECONNECT_REQUIRED";
+    if (info === "usageLimitExceeded" || info === "rateLimitExceeded" || info === "serverOverloaded")
+      return "CODEX_RATE_LIMITED";
+    if (record(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);
+    try {
+      void Promise.resolve(
+        this.options?.onNativeMcpDiagnostics?.(Object.freeze({ ...this.mcpDiagnostics }))
+      ).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 text of active.messages.values())
+      this.event({
+        type: "message_end",
+        message: { role: "assistant", content: [{ type: "text", text }] }
+      });
+    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 {
+    }
+  }
+};
 function buildCodexChildEnv(parent) {
   const out = {};
   const explicit = [
@@ -38,6 +1132,7 @@ var CodexDriver = class extends AgentDriver {
   };
   log = getBridgeLogger("codex");
   config;
+  managed;
   thread = null;
   running = false;
   abortController = null;
@@ -50,11 +1145,33 @@ var CodexDriver = class extends AgentDriver {
   constructor(config) {
     super();
     this.config = config;
+    const codex = config.driverOptions?.codex;
+    if (codex?.managedRuntime || codex?.authSource !== void 0 && codex.authSource !== "local") {
+      this.managed = new ManagedCodexDriver(config);
+      this.managed.on("agent-event", (event) => this.emit("agent-event", event));
+    }
   }
   get runtimeSessionId() {
-    return this._runtimeSessionId;
+    return this.managed ? this.managed.runtimeSessionId : this._runtimeSessionId;
+  }
+  get acceptsReplyAsPrompt() {
+    return !this.managed;
+  }
+  async dispose() {
+    if (this.managed) return this.managed.dispose();
+    this.kill();
+  }
+  hasPendingQuestion() {
+    return this.managed?.hasPendingQuestion() ?? false;
+  }
+  answerQuestion(answer, question, requestId) {
+    return this.managed?.answerQuestion(answer, question, requestId) ?? false;
+  }
+  promptInput(input) {
+    return this.managed ? this.managed.promptInput(input) : super.promptInput(input);
   }
   async start() {
+    if (this.managed) return this.managed.start();
     if (this.thread) return;
     let sdk;
     try {
@@ -90,6 +1207,7 @@ var CodexDriver = class extends AgentDriver {
     });
   }
   async prompt(message) {
+    if (this.managed) return this.managed.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");
@@ -135,32 +1253,47 @@ var CodexDriver = class extends AgentDriver {
     }
   }
   async abort() {
+    if (this.managed) return this.managed.abort();
     this.abortController?.abort();
   }
   get isRunning() {
+    if (this.managed) return this.managed.isRunning;
     return this.running;
   }
   kill() {
+    if (this.managed) {
+      this.managed.kill();
+      return;
+    }
     this.abortController?.abort();
     this.running = false;
     this.abortController = null;
     this.log.info("codex driver killed");
   }
   async listModels() {
+    if (this.managed) return this.managed.listModels();
     const apiKey = this.config.apiKeys?.openai || this.config.env?.OPENAI_API_KEY || process.env.OPENAI_API_KEY;
     if (!apiKey) return [];
     const result = await fetchProviderModels("openai", apiKey);
     return result.ok ? result.models : [];
   }
   async resetSession() {
+    if (this.managed) return this.managed.resetSession();
     this.kill();
     this.thread = null;
     this._runtimeSessionId = void 0;
     this._lastTokens = null;
   }
   getTokenUsage() {
+    if (this.managed) return this.managed.getTokenUsage();
     return this._lastTokens;
   }
+  reconfigure(patch) {
+    this.managed?.reconfigure(patch);
+  }
+  getModel() {
+    return this.managed?.getModel();
+  }
   /**
    * Write a combined instructions file for Codex CLI's `model_instructions_file` config.
    * Combines pre-rendered agent identity (from `skaile install`) with runtime context