@jacobbd/relay-ai 0.9.4 → 0.9.6

package/dist/cli.js

@@ -12,7 +12,6 @@ import {
   GLOBAL_OPENCODE_KEYRING_ACCOUNT,
   MAX_MODEL_CATALOG,
   PREVIEW_PROXY_PORT,
-  UNSUPPORTED_VOICE_MESSAGE,
   VERSION,
   VERTEX_ANTHROPIC_NPM,
   addCustomEndpointProvider,
@@ -85,6 +84,7 @@ import {
   getCodexProxyDebugLogPath,
   getConfigPath,
   getGeminiProxyDebugLogPath,
+  getLogsPath,
   getProvidersPath,
   getProxyDebugLogPath,
   getReasoningCapabilities,
@@ -169,8 +169,9 @@ import {
   resolveRelayCatalogSlots,
   routableModelsForTarget,
   routeLookupIds,
+  runCodexCommand,
+  runCodexCommandSync,
   runServerCommand,
-  sanitizeUnsupportedInlineData,
   savePreferences,
   saveProviderCredential,
   saveRegistry,
@@ -186,20 +187,18 @@ import {
   startProxy,
   startProxyCatalog,
   startServer,
-  summarizeSdkRequestForTrace,
   supportsClaudeTransparentMode,
   supportsMultiAgentV2,
   supportsNativeOAuth,
   syntheticTemplate,
   thinkingProviderOptions,
   toggleProviderEnabled,
-  translateRequest,
   updateCustomEndpointProvider,
   upstreamHttpStatus,
   validateCustomEndpointUrl,
   writeSecureLogLine,
   zenRegistryStub
-} from "./chunk-KDIY732Q.js";
+} from "./chunk-PYJQMEJD.js";
 import {
   filterTemplates,
   getTemplateById,
@@ -1297,7 +1296,7 @@ ${pc4.bold("Subcommands:")}
   (none)      Provider hub wizard ${pc4.dim("[Phase 1.1]")}
   add         Add a provider (Groq, Mistral, Together AI, \u2026) ${pc4.dim("[Phase 1.1]")}
   import      Optional one-time import from OpenCode CLI ${pc4.dim("[Phase 1.0]")}
-  auth        Sign in with OAuth (GitHub Copilot, xAI, OpenAI, ClinePass)
+  auth        Sign in with OAuth (Antigravity, GitHub Copilot, xAI, OpenAI, ClinePass)
   list        Show configured providers ${pc4.dim("[Phase 1.0]")}
   remove      Remove a provider by id ${pc4.dim("[Phase 1.1]")}
   refresh-models  Update cached model lists ${pc4.dim("[Phase 1.2]")}`;
@@ -2235,8 +2234,7 @@ async function runProvidersCommand(args) {
 // src/codex.ts
 import pc7 from "picocolors";
 import * as p8 from "@clack/prompts";
-import { execFileSync as execFileSync2 } from "child_process";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/codex-proxy.ts
 import { createHash as createHash2 } from "crypto";
@@ -3041,18 +3039,18 @@ async function writeResponsesStream(fullStream, modelId, write, onDone, onProgre
     });
     outputItems.unshift(reasoningItem);
   }
-  for (const tool3 of toolStates) {
-    const normalizedArgs = normalizeCodexSubagentArguments(tool3.name, tool3.args);
+  for (const tool4 of toolStates) {
+    const normalizedArgs = normalizeCodexSubagentArguments(tool4.name, tool4.args);
     emit("response.function_call_arguments.done", {
       type: "response.function_call_arguments.done",
-      item_id: tool3.itemId,
-      output_index: tool3.outputIndex,
+      item_id: tool4.itemId,
+      output_index: tool4.outputIndex,
       arguments: normalizedArgs
     });
-    const fcItem = buildFinalToolItem(resolveOutputKind(tool3.name, options?.toolContext), tool3.name, tool3.callId, tool3.itemId, normalizedArgs);
+    const fcItem = buildFinalToolItem(resolveOutputKind(tool4.name, options?.toolContext), tool4.name, tool4.callId, tool4.itemId, normalizedArgs);
     emit("response.output_item.done", {
       type: "response.output_item.done",
-      output_index: tool3.outputIndex,
+      output_index: tool4.outputIndex,
       item: fcItem
     });
     outputItems.push(fcItem);
@@ -3180,7 +3178,7 @@ function decodeCompactionContent(encrypted) {
   if (!encrypted) return null;
   try {
     const obj = JSON.parse(Buffer.from(encrypted, "base64").toString("utf8"));
-    return typeof obj?.summary === "string" ? obj.summary : null;
+    return obj?.v === 1 && typeof obj.summary === "string" ? obj.summary : null;
   } catch {
     return null;
   }
@@ -3464,6 +3462,41 @@ function allowlistedNativeHeaders(inboundHeaders) {
   }
   return out;
 }
+function prepareNativeCodexBody(body) {
+  if (!Array.isArray(body.input)) return body;
+  let changed = false;
+  const input = body.input.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+    const record = item;
+    if (record.type !== "compaction" && record.type !== "context_compaction") return item;
+    const summary = decodeCompactionContent(
+      typeof record.encrypted_content === "string" ? record.encrypted_content : void 0
+    );
+    if (summary === null) return item;
+    changed = true;
+    return {
+      type: "message",
+      role: "user",
+      content: [{
+        type: "input_text",
+        text: `[Summary of earlier conversation]
+${summary}`
+      }]
+    };
+  });
+  return changed ? { ...body, input } : body;
+}
+function prepareNativeHttpBody(body) {
+  const text5 = typeof body === "string" ? body : Buffer.from(body).toString("utf8");
+  try {
+    const parsed = JSON.parse(text5);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return body;
+    const prepared = prepareNativeCodexBody(parsed);
+    return prepared === parsed ? body : JSON.stringify(prepared);
+  } catch {
+    return body;
+  }
+}
 async function forwardNativeCodexHttp(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const headers = allowlistedNativeHeaders(options.inboundHeaders);
@@ -3471,7 +3504,7 @@ async function forwardNativeCodexHttp(options) {
   return fetchImpl(options.nativeUrl ?? NATIVE_CODEX_RESPONSES_URL, {
     method: "POST",
     headers,
-    body: options.body,
+    body: prepareNativeHttpBody(options.body),
     signal: options.signal,
     redirect: "manual"
   });
@@ -3549,17 +3582,17 @@ var COLLABORATION_TOOL_NAMES = /* @__PURE__ */ new Set([
 ]);
 function isCollaborationTool(value) {
   if (!value || typeof value !== "object") return false;
-  const tool3 = value;
-  const name = typeof tool3.name === "string" ? tool3.name : "";
-  if (tool3.type === "namespace") return name === "collaboration" || name === "multi_agent_v1";
+  const tool4 = value;
+  const name = typeof tool4.name === "string" ? tool4.name : "";
+  if (tool4.type === "namespace") return name === "collaboration" || name === "multi_agent_v1";
   return COLLABORATION_TOOL_NAMES.has(name) || name.startsWith("collaboration__") || name.startsWith("multi_agent_v1__");
 }
 function stripCollaborationToolList(value) {
   if (!Array.isArray(value)) return value;
-  return value.filter((tool3) => !isCollaborationTool(tool3)).map((tool3) => {
-    if (!tool3 || typeof tool3 !== "object") return tool3;
-    const record = tool3;
-    if (!Array.isArray(record.tools)) return tool3;
+  return value.filter((tool4) => !isCollaborationTool(tool4)).map((tool4) => {
+    if (!tool4 || typeof tool4 !== "object") return tool4;
+    const record = tool4;
+    if (!Array.isArray(record.tools)) return tool4;
     return { ...record, tools: stripCollaborationToolList(record.tools) };
   });
 }
@@ -3738,6 +3771,53 @@ async function resolveRoutedCollaborationInput(input, context) {
   return normalizePlaintextCollaborationForExternal(out);
 }
 
+// src/codex/route-audit.ts
+import { chmodSync, mkdirSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var CODEX_ROUTE_AUDIT_LOG = "codex-route-audit.jsonl";
+function safeIdentifier(value) {
+  if (value === void 0) return void 0;
+  return value.replace(/[\u0000-\u001f\u007f]/g, "_").slice(0, 300);
+}
+function sanitizeCodexRouteAuditEvent(event) {
+  return {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    transport: event.transport,
+    requestedModel: safeIdentifier(event.requestedModel),
+    dispatch: event.dispatch,
+    phase: event.phase,
+    ...event.provider ? { provider: safeIdentifier(event.provider) } : {},
+    ...event.routeModel ? { routeModel: safeIdentifier(event.routeModel) } : {},
+    ...event.upstreamModel ? { upstreamModel: safeIdentifier(event.upstreamModel) } : {},
+    ...event.outcome ? { outcome: event.outcome } : {},
+    ...event.status !== void 0 ? { status: typeof event.status === "string" ? safeIdentifier(event.status) : event.status } : {}
+  };
+}
+function getCodexRouteAuditLogPath() {
+  const dir = getLogsPath();
+  mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+  try {
+    chmodSync(dir, DIR_MODE);
+  } catch {
+  }
+  return join2(dir, CODEX_ROUTE_AUDIT_LOG);
+}
+function prepareCodexRouteAuditLog(path3 = getCodexRouteAuditLogPath()) {
+  writeFileSync(path3, "", { mode: FILE_MODE });
+  chmodSync(path3, FILE_MODE);
+  return path3;
+}
+function appendCodexRouteAudit(path3, event) {
+  try {
+    writeFileSync(path3, `${JSON.stringify(sanitizeCodexRouteAuditEvent(event))}
+`, { flag: "a", mode: FILE_MODE });
+    chmodSync(path3, FILE_MODE);
+  } catch {
+  }
+}
+
 // src/codex-proxy.ts
 function captureCompletedResponse(sseText) {
   if (!sseText.includes("response.completed")) return void 0;
@@ -3745,11 +3825,34 @@ function captureCompletedResponse(sseText) {
   if (!dataLine) return void 0;
   try {
     const obj = JSON.parse(dataLine.slice(5).trim());
-    if (obj && obj.type === "response.completed") return obj.response;
+    if (obj && obj.type === "response.completed" && obj.response && typeof obj.response === "object") {
+      return obj.response;
+    }
   } catch {
   }
   return void 0;
 }
+var MAX_EXTERNAL_RESPONSE_STATES = 8;
+var EXTERNAL_TOOL_OUTPUT_TYPES = /* @__PURE__ */ new Set([
+  "function_call_output",
+  "custom_tool_call_output",
+  "tool_search_output"
+]);
+function responsesInputItems(input) {
+  if (Array.isArray(input)) return input;
+  if (typeof input === "string") {
+    return [{ type: "message", role: "user", content: input }];
+  }
+  return [];
+}
+function isExternalToolOutputItem(item) {
+  if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+  const type = item.type;
+  return typeof type === "string" && EXTERNAL_TOOL_OUTPUT_TYPES.has(type);
+}
+function isExternalToolContinuation(input) {
+  return Array.isArray(input) && input.length > 0 && input.every(isExternalToolOutputItem);
+}
 function estimateCodexRequestChars(params) {
   let chars = (params.system ?? "").length;
   for (const msg of params.messages) {
@@ -3881,6 +3984,18 @@ function codexRouteLookupIds(requestedModel) {
   return [...new Set(ids)];
 }
 function findCodexProxyRoute(routes, requestedModel) {
+  const bareRequestedModel = parseCodexAppModelSlug(requestedModel);
+  const providerSeparator = bareRequestedModel.indexOf("__");
+  if (providerSeparator > 0) {
+    const requestedProvider = bareRequestedModel.slice(0, providerSeparator);
+    const requestedIds = codexRouteLookupIds(bareRequestedModel.slice(providerSeparator + 2));
+    const providerRoute = routes.find((route) => {
+      if (route.providerId !== requestedProvider) return false;
+      const routeIds = codexRouteLookupIds(route.modelId);
+      return requestedIds.some((id) => routeIds.includes(id));
+    });
+    if (providerRoute) return providerRoute;
+  }
   const ids = codexRouteLookupIds(requestedModel);
   for (const id of ids) {
     const route = routes.find(
@@ -3936,11 +4051,32 @@ async function prepareExternalCodexBody(body, context) {
   );
   return { ...externalBody, input: resolvedInput };
 }
+function applyExternalCodexRuntimeIdentity(params, route) {
+  const selectedModel = route.auditUpstreamModelId ?? route.upstreamModelId ?? route.modelId;
+  const provider = route.providerId ?? "relay";
+  const identity = [
+    "<external-model-identity>",
+    `The selected model for this turn is ${JSON.stringify(selectedModel)} through provider ${JSON.stringify(provider)}.`,
+    "Codex is the host application and agent environment, not the model identity.",
+    "Follow Codex host and tool instructions normally, but do not infer that you are an OpenAI or GPT model from host names, tool names, documentation, or conversation context.",
+    "If asked what model you are, report the selected model and provider above; do not use self-identification as evidence of the network route.",
+    "</external-model-identity>"
+  ].join("\n");
+  return {
+    ...params,
+    system: params.system?.trim() ? `${identity}
+
+${params.system}` : identity
+  };
+}
 async function startCodexProxy(routes, options = {}) {
   const opts = typeof options === "boolean" ? { debug: options } : options;
   const debug = opts.debug ?? false;
   const requireAuth = opts.requireAuth ?? true;
   const mixedNative = opts.mixedNative;
+  const audit = (event) => {
+    if (opts.routeAuditPath) appendCodexRouteAudit(opts.routeAuditPath, event);
+  };
   const nativePayloadRelay = mixedNative ? createNativePayloadRelay({}) : void 0;
   silenceSdkWarnings();
   const models = /* @__PURE__ */ new Map();
@@ -4114,6 +4250,7 @@ async function startCodexProxy(routes, options = {}) {
           log14(`subagent dispatch: requested=${modelId} route=${subagentRoute?.modelId ?? "(none)"}`);
         }
         if (mixedNative && markedSubagent && !subagentRoute) {
+          audit({ transport: "http", requestedModel: modelId, dispatch: "relay-subagent", phase: "complete", outcome: "error", status: 503 });
           sendJson(res, 503, {
             error: {
               message: "Codex marked this request as a Sub-agent, but no configured Codex Sub-agent route is available.",
@@ -4126,10 +4263,20 @@ async function startCodexProxy(routes, options = {}) {
           if (!markedSubagent) {
             const dispatch = classifyCodexDispatch(modelId, routes, mixedNative.nativeModelIds);
             if (dispatch.kind === "unknown") {
+              audit({ transport: "http", requestedModel: modelId, dispatch: "unknown", phase: "complete", outcome: "error", status: 404 });
               sendJson(res, 404, { error: { message: `Unknown model: ${modelId}`, type: "invalid_request_error" } });
               return;
             }
             if (dispatch.kind === "native") {
+              audit({
+                transport: "http",
+                requestedModel: modelId,
+                dispatch: "native",
+                phase: "dispatch",
+                provider: "openai-native",
+                routeModel: modelId,
+                upstreamModel: modelId
+              });
               const controller = new AbortController();
               req.once("aborted", () => controller.abort());
               try {
@@ -4143,7 +4290,29 @@ async function startCodexProxy(routes, options = {}) {
                 const contentType = nativeResponse.headers.get("content-type");
                 res.writeHead(nativeResponse.status, contentType ? { "content-type": contentType } : void 0);
                 res.end(Buffer.from(await nativeResponse.arrayBuffer()));
+                audit({
+                  transport: "http",
+                  requestedModel: modelId,
+                  dispatch: "native",
+                  phase: "complete",
+                  provider: "openai-native",
+                  routeModel: modelId,
+                  upstreamModel: modelId,
+                  outcome: nativeResponse.ok ? "ok" : "error",
+                  status: nativeResponse.status
+                });
               } catch (err) {
+                audit({
+                  transport: "http",
+                  requestedModel: modelId,
+                  dispatch: "native",
+                  phase: "complete",
+                  provider: "openai-native",
+                  routeModel: modelId,
+                  upstreamModel: modelId,
+                  outcome: "error",
+                  status: "forward-failed"
+                });
                 if (!res.writableEnded) sendJson(res, 502, { error: { message: "Native Codex request failed", type: "upstream_error" } });
               }
               return;
@@ -4168,13 +4337,23 @@ async function startCodexProxy(routes, options = {}) {
           }
         }
         const { route, languageModel } = resolved;
+        const relayDispatch = markedSubagent ? "relay-subagent" : "relay";
+        audit({
+          transport: "http",
+          requestedModel: modelId,
+          dispatch: relayDispatch,
+          phase: "dispatch",
+          provider: route.providerId ?? "relay",
+          routeModel: route.modelId,
+          upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId
+        });
         try {
           const routedBody = await prepareExternalCodexBody(body, {
             relay: nativePayloadRelay,
             mixedNative,
             headers: req.headers
           });
-          let params = applyClaudeCodeOAuthIdentity(route, translateResponsesRequest(
+          let params = applyClaudeCodeOAuthIdentity(route, applyExternalCodexRuntimeIdentity(translateResponsesRequest(
             routedBody,
             route.npm,
             {
@@ -4186,7 +4365,7 @@ async function startCodexProxy(routes, options = {}) {
               upstreamModelId: route.upstreamModelId
             },
             { maxTools: maxToolsForNpm(route.npm) }
-          ));
+          ), route));
           if (route.contextWindow && route.contextWindow > 0) {
             const before = params.messages.length;
             const estimatedChars = estimateCodexRequestChars(params);
@@ -4241,9 +4420,31 @@ async function startCodexProxy(routes, options = {}) {
                     log14(`response progress: model=${route.modelId} elapsedMs=${progress.elapsedMs} reasoningChars=${progress.reasoningChars} textChars=${progress.textChars} toolCalls=${progress.toolCallCount} reasoningTail=${JSON.stringify(progress.reasoningTail)}`);
                   }
                 });
+              audit({
+                transport: "http",
+                requestedModel: modelId,
+                dispatch: relayDispatch,
+                phase: "complete",
+                provider: route.providerId ?? "relay",
+                routeModel: route.modelId,
+                upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId,
+                outcome: "ok",
+                status: 200
+              });
             } catch (err) {
               const msg = formatUpstreamError(err);
               const status = upstreamHttpStatus(err, msg);
+              audit({
+                transport: "http",
+                requestedModel: modelId,
+                dispatch: relayDispatch,
+                phase: "complete",
+                provider: route.providerId ?? "relay",
+                routeModel: route.modelId,
+                upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId,
+                outcome: "error",
+                status
+              });
               if (debug) log14(`sdk error: ${route.modelId}: ${msg}`);
               if (status === 429) {
                 writeResponsesRateLimitStream(modelId, msg, write);
@@ -4265,9 +4466,31 @@ async function startCodexProxy(routes, options = {}) {
                 });
               }
               sendJson(res, 200, response);
+              audit({
+                transport: "http",
+                requestedModel: modelId,
+                dispatch: relayDispatch,
+                phase: "complete",
+                provider: route.providerId ?? "relay",
+                routeModel: route.modelId,
+                upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId,
+                outcome: "ok",
+                status: 200
+              });
             } catch (err) {
               const msg = formatUpstreamError(err);
               const status = upstreamHttpStatus(err, msg);
+              audit({
+                transport: "http",
+                requestedModel: modelId,
+                dispatch: relayDispatch,
+                phase: "complete",
+                provider: route.providerId ?? "relay",
+                routeModel: route.modelId,
+                upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId,
+                outcome: "error",
+                status
+              });
               if (debug) log14(`sdk error: ${route.modelId}: ${msg}`);
               if (status === 429) {
                 sendJson(res, 200, responsesRateLimitBody(modelId, msg));
@@ -4392,21 +4615,53 @@ Sec-WebSocket-Accept: ${wsAcceptKey(clientKey)}\r
 `
       );
       let frameBuf = Buffer.alloc(0);
-      let handled = false;
+      let externalActive = false;
       let nativeActive = false;
       let nativeUpstream;
+      let nativeSendTurn;
+      let socketClosing = false;
+      const externalResponseStates = /* @__PURE__ */ new Map();
+      let currentExternalCompletedResponse;
+      let currentExternalStateInput;
+      let currentExternalConsumedResponseId;
       let currentRequestModel = "";
-      const closeSocket = (code = 1e3) => {
-        if (!socket.destroyed) {
-          socket.write(wsCloseFrame(code));
-          socket.end();
+      const rememberExternalResponse = (response, input) => {
+        const responseId = typeof response.id === "string" ? response.id : void 0;
+        const output = Array.isArray(response.output) ? response.output : void 0;
+        if (!responseId || !output || response.error) return;
+        externalResponseStates.delete(responseId);
+        externalResponseStates.set(responseId, { input: [...input], output: [...output] });
+        while (externalResponseStates.size > MAX_EXTERNAL_RESPONSE_STATES) {
+          const oldest = externalResponseStates.keys().next().value;
+          if (!oldest) break;
+          externalResponseStates.delete(oldest);
         }
       };
+      const resolveExternalContinuation = (body) => {
+        const previousResponseId = typeof body.previous_response_id === "string" ? body.previous_response_id : void 0;
+        if (!previousResponseId || !isExternalToolContinuation(body.input)) return { body };
+        const previous = externalResponseStates.get(previousResponseId);
+        if (!previous) return { body, orphanedResponseId: previousResponseId };
+        return {
+          body: {
+            ...body,
+            input: [...previous.input, ...previous.output, ...body.input]
+          },
+          consumedResponseId: previousResponseId
+        };
+      };
+      const closeSocket = (code = 1e3) => {
+        if (socketClosing || socket.destroyed) return;
+        socketClosing = true;
+        socket.write(wsCloseFrame(code));
+        socket.end();
+      };
       const sendWsEvent = (sseChunk2) => {
-        if (socket.destroyed) return;
-        if (debug) {
-          const completed = captureCompletedResponse(sseChunk2);
-          if (completed) {
+        if (socketClosing || socket.destroyed) return;
+        const completed = captureCompletedResponse(sseChunk2);
+        if (completed) {
+          currentExternalCompletedResponse = completed;
+          if (debug) {
             appendCodexBodyDump({
               ts: (/* @__PURE__ */ new Date()).toISOString(),
               transport: "ws",
@@ -4424,7 +4679,6 @@ Sec-WebSocket-Accept: ${wsAcceptKey(clientKey)}\r
       };
       const onData = (chunk) => {
         frameBuf = Buffer.concat([frameBuf, chunk]);
-        if (handled && !nativeActive) return;
         const frame = wsDecodeFrame(frameBuf);
         if (!frame) return;
         frameBuf = Buffer.alloc(0);
@@ -4446,7 +4700,10 @@ Sec-WebSocket-Accept: ${wsAcceptKey(clientKey)}\r
           socket.end();
           return;
         }
-        handled = true;
+        if (externalActive) {
+          closeSocket(1008);
+          return;
+        }
         void (async () => {
           let body;
           try {
@@ -4487,6 +4744,7 @@ data: ${JSON.stringify({ error: { message: "Invalid JSON", type: "invalid_reques
             log14(`WS subagent dispatch: requested=${modelId} route=${subagentRoute?.modelId ?? "(none)"}`);
           }
           if (mixedNative && markedSubagent && !subagentRoute) {
+            audit({ transport: "ws", requestedModel: modelId, dispatch: "relay-subagent", phase: "complete", outcome: "error", status: 503 });
             sendWsEvent(`event: error
 data: ${JSON.stringify({ error: {
               message: "Codex marked this request as a Sub-agent, but no configured Codex Sub-agent route is available.",
@@ -4501,6 +4759,7 @@ data: ${JSON.stringify({ error: {
             if (!markedSubagent) {
               const dispatch = classifyCodexDispatch(modelId, routes, mixedNative.nativeModelIds);
               if (dispatch.kind === "unknown") {
+                audit({ transport: "ws", requestedModel: modelId, dispatch: "unknown", phase: "complete", outcome: "error", status: 404 });
                 sendWsEvent(`event: error
 data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "invalid_request_error" } })}
 
@@ -4509,10 +4768,23 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
                 return;
               }
               if (dispatch.kind === "native") {
+                audit({
+                  transport: "ws",
+                  requestedModel: modelId,
+                  dispatch: "native",
+                  phase: "dispatch",
+                  provider: "openai-native",
+                  routeModel: modelId,
+                  upstreamModel: modelId
+                });
+                const nativeBody = prepareNativeCodexBody(body);
+                if (debug && nativeBody !== body) {
+                  log14(`WS native history normalized: model=${modelId} converted Relay compaction for native verification`);
+                }
                 if (nativeActive && nativeUpstream) {
                   if (nativeUpstream.readyState === WebSocket.OPEN) {
                     if (debug) log14(`WS native forwarding next turn: model=${modelId}`);
-                    nativeUpstream.send(JSON.stringify({ type: "response.create", ...body }));
+                    nativeSendTurn?.(nativeBody, modelId);
                   } else if (debug) {
                     log14(`WS native cannot forward next turn: upstream_state=${nativeUpstream.readyState}`);
                   }
@@ -4523,6 +4795,7 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
                 let upstream;
                 let nativeOpened = false;
                 let nativeCompleted = false;
+                let nativeTurnModelId = modelId;
                 let nativeFrameCount = 0;
                 let finished = false;
                 let connectTimer;
@@ -4542,10 +4815,24 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
                   if (finished) return;
                   finished = true;
                   nativeActive = false;
+                  nativeSendTurn = void 0;
                   if (nativeUpstream === upstream) nativeUpstream = void 0;
                   clearTimers();
                   if (debug && message) {
-                    log14(`WS native upstream failed: model=${modelId} opened=${nativeOpened} frames=${nativeFrameCount} message=${message}`);
+                    log14(`WS native upstream failed: model=${nativeTurnModelId} opened=${nativeOpened} frames=${nativeFrameCount} message=${message}`);
+                  }
+                  if (message && !nativeCompleted) {
+                    audit({
+                      transport: "ws",
+                      requestedModel: nativeTurnModelId,
+                      dispatch: "native",
+                      phase: "complete",
+                      provider: "openai-native",
+                      routeModel: nativeTurnModelId,
+                      upstreamModel: nativeTurnModelId,
+                      outcome: "error",
+                      status: "upstream-failed"
+                    });
                   }
                   if (message && !nativeCompleted) sendNativeError(message);
                   try {
@@ -4554,20 +4841,31 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
                   }
                   closeSocket(closeCode);
                 };
+                const sendNativeTurn = (turnBody, turnModelId) => {
+                  if (!upstream || upstream.readyState !== WebSocket.OPEN) {
+                    if (debug) log14(`WS native cannot send turn: model=${turnModelId} upstream_state=${upstream?.readyState ?? "missing"}`);
+                    return;
+                  }
+                  nativeTurnModelId = turnModelId;
+                  nativeCompleted = false;
+                  if (firstFrameTimer) clearTimeout(firstFrameTimer);
+                  upstream.send(JSON.stringify({ type: "response.create", ...turnBody }));
+                  firstFrameTimer = setTimeout(() => closeBoth("Native Codex WebSocket response timed out"), 6e4);
+                };
                 try {
                   if (debug) {
                     log14(`WS native connecting: model=${modelId} url=${target.url} headers=[${Object.keys(target.headers).join(",")}]`);
                   }
                   upstream = new WebSocket(target.url, { headers: target.headers });
                   nativeUpstream = upstream;
+                  nativeSendTurn = sendNativeTurn;
                   nativeActive = true;
                   connectTimer = setTimeout(() => closeBoth("Native Codex WebSocket connection timed out"), 15e3);
                   upstream.once("open", () => {
                     nativeOpened = true;
                     if (connectTimer) clearTimeout(connectTimer);
                     if (debug) log14(`WS native upstream open: model=${modelId}`);
-                    upstream?.send(JSON.stringify({ type: "response.create", ...body }));
-                    firstFrameTimer = setTimeout(() => closeBoth("Native Codex WebSocket response timed out"), 6e4);
+                    sendNativeTurn(nativeBody, modelId);
                   });
                   upstream.once("unexpected-response", (_request, response) => {
                     if (debug) log14(`WS native upstream HTTP rejection: model=${modelId} status=${response.statusCode}`);
@@ -4585,6 +4883,17 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
                       if (typeof parsed.type === "string") eventType = parsed.type;
                       if (eventType === "response.completed" || eventType === "response.failed" || eventType === "response.incomplete") {
                         nativeCompleted = true;
+                        audit({
+                          transport: "ws",
+                          requestedModel: modelId,
+                          dispatch: "native",
+                          phase: "complete",
+                          provider: "openai-native",
+                          routeModel: modelId,
+                          upstreamModel: modelId,
+                          outcome: eventType === "response.completed" ? "ok" : "error",
+                          status: eventType
+                        });
                       }
                     } catch {
                     }
@@ -4605,6 +4914,7 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
                     if (debug) log14(`WS native downstream close: model=${modelId} frames=${nativeFrameCount} completed=${nativeCompleted}`);
                     finished = true;
                     nativeActive = false;
+                    nativeSendTurn = void 0;
                     if (nativeUpstream === upstream) nativeUpstream = void 0;
                     clearTimers();
                     try {
@@ -4619,6 +4929,7 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}`, type: "i
               }
             }
           }
+          externalActive = true;
           let resolved = subagentRoute ? resolveModel(routes, models, subagentRoute.modelId) : resolveModel(routes, models, modelId);
           if (!resolved) {
             const fb = routes[0];
@@ -4637,13 +4948,35 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}` } })}
             }
           }
           const { route, languageModel } = resolved;
+          const relayDispatch = markedSubagent ? "relay-subagent" : "relay";
+          audit({
+            transport: "ws",
+            requestedModel: modelId,
+            dispatch: relayDispatch,
+            phase: "dispatch",
+            provider: route.providerId ?? "relay",
+            routeModel: route.modelId,
+            upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId
+          });
+          currentExternalCompletedResponse = void 0;
+          currentExternalStateInput = void 0;
+          currentExternalConsumedResponseId = void 0;
+          const continuation = resolveExternalContinuation(body);
+          if (continuation.orphanedResponseId) {
+            if (debug) log14(`WS continuation rejected: unknown previous_response_id=${continuation.orphanedResponseId}`);
+            writeResponsesErrorStream(modelId, "Unknown or expired previous_response_id", sendWsEvent, 400);
+            externalActive = false;
+            return;
+          }
           try {
-            const routedBody = await prepareExternalCodexBody(body, {
+            const routedBody = await prepareExternalCodexBody(continuation.body, {
               relay: nativePayloadRelay,
               mixedNative,
               headers: req.headers
             });
-            let params = applyClaudeCodeOAuthIdentity(route, translateResponsesRequest(
+            currentExternalStateInput = responsesInputItems(routedBody.input);
+            currentExternalConsumedResponseId = continuation.consumedResponseId;
+            let params = applyClaudeCodeOAuthIdentity(route, applyExternalCodexRuntimeIdentity(translateResponsesRequest(
               routedBody,
               route.npm,
               {
@@ -4655,7 +4988,7 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}` } })}
                 upstreamModelId: route.upstreamModelId
               },
               { maxTools: maxToolsForNpm(route.npm) }
-            ));
+            ), route));
             if (route.contextWindow && route.contextWindow > 0) {
               const before = params.messages.length;
               const estimatedChars = estimateCodexRequestChars(params);
@@ -4688,9 +5021,37 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}` } })}
                   log14(`WS response progress: model=${route.modelId} elapsedMs=${progress.elapsedMs} reasoningChars=${progress.reasoningChars} textChars=${progress.textChars} toolCalls=${progress.toolCallCount} reasoningTail=${JSON.stringify(progress.reasoningTail)}`);
                 }
               });
+            if (currentExternalCompletedResponse && currentExternalStateInput) {
+              if (currentExternalConsumedResponseId) {
+                externalResponseStates.delete(currentExternalConsumedResponseId);
+              }
+              rememberExternalResponse(currentExternalCompletedResponse, currentExternalStateInput);
+            }
+            audit({
+              transport: "ws",
+              requestedModel: modelId,
+              dispatch: relayDispatch,
+              phase: "complete",
+              provider: route.providerId ?? "relay",
+              routeModel: route.modelId,
+              upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId,
+              outcome: "ok",
+              status: "response.completed"
+            });
           } catch (err) {
             const msg = formatUpstreamError(err);
             const status = upstreamHttpStatus(err, msg);
+            audit({
+              transport: "ws",
+              requestedModel: modelId,
+              dispatch: relayDispatch,
+              phase: "complete",
+              provider: route.providerId ?? "relay",
+              routeModel: route.modelId,
+              upstreamModel: route.auditUpstreamModelId ?? route.upstreamModelId,
+              outcome: "error",
+              status
+            });
             if (debug) log14(`WS sdk error: ${route.modelId}: ${msg}`);
             if (status === 429) {
               writeResponsesRateLimitStream(modelId, msg, sendWsEvent);
@@ -4698,10 +5059,11 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}` } })}
               writeResponsesErrorStream(modelId, msg, sendWsEvent, status);
             }
           }
-          closeSocket();
+          externalActive = false;
         })();
       };
       socket.on("error", () => socket.destroy());
+      socket.once("close", () => externalResponseStates.clear());
       socket.on("data", onData);
       onData(head);
     });
@@ -4726,44 +5088,44 @@ data: ${JSON.stringify({ error: { message: `Unknown model: ${modelId}` } })}
 }
 
 // src/codex/profile.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/codex/session.ts
 import {
   copyFileSync,
-  chmodSync,
+  chmodSync as chmodSync2,
   existsSync as existsSync3,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   readdirSync,
   readFileSync as readFileSync2,
   renameSync,
   rmSync,
   statSync,
   unlinkSync,
-  writeFileSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename, dirname, join as join2 } from "path";
+import { basename, dirname, join as join3 } from "path";
 var CODEX_PROFILE_NAME = "relay-ai-launch";
 var STALE_SESSION_MS = 5 * 60 * 1e3;
 var MAX_BACKUPS = 5;
 function getCodexHome(env = process.env) {
-  return env["CODEX_HOME"] || join2(homedir3(), ".codex");
+  return env["CODEX_HOME"] || join3(homedir3(), ".codex");
 }
 function getCodexProfilePath() {
-  return join2(getCodexHome(), `${CODEX_PROFILE_NAME}.config.toml`);
+  return join3(getCodexHome(), `${CODEX_PROFILE_NAME}.config.toml`);
 }
 function getRelayAiCodexDir(env = process.env) {
-  return join2(getAppHome(env), "codex");
+  return join3(getAppHome(env), "codex");
 }
 function getSessionLockPath(env = process.env) {
-  return join2(getRelayAiCodexDir(env), "session.json");
+  return join3(getRelayAiCodexDir(env), "session.json");
 }
 function getBackupsDir(env = process.env) {
-  return join2(getRelayAiCodexDir(env), "backups");
+  return join3(getRelayAiCodexDir(env), "backups");
 }
 function getCatalogPath(providerId, env = process.env) {
-  return join2(getRelayAiCodexDir(env), `models-${providerId}.json`);
+  return join3(getRelayAiCodexDir(env), `models-${providerId}.json`);
 }
 function ownedOverlayPaths(env = process.env) {
   const paths = [getCodexProfilePath()];
@@ -4771,15 +5133,15 @@ function ownedOverlayPaths(env = process.env) {
   if (existsSync3(codexDir)) {
     for (const name of readdirSync(codexDir)) {
       if (name.startsWith("models-") && name.endsWith(".json")) {
-        paths.push(join2(codexDir, name));
+        paths.push(join3(codexDir, name));
       }
     }
   }
-  const agentsDir = join2(getCodexHome(env), "agents");
+  const agentsDir = join3(getCodexHome(env), "agents");
   if (existsSync3(agentsDir)) {
     for (const name of readdirSync(agentsDir)) {
       if (/^relay-model-[a-z0-9-]+\.toml$/i.test(name)) {
-        paths.push(join2(agentsDir, name));
+        paths.push(join3(agentsDir, name));
       }
     }
   }
@@ -4787,27 +5149,27 @@ function ownedOverlayPaths(env = process.env) {
   return paths;
 }
 function atomicWriteFile(path3, content) {
-  mkdirSync(dirname(path3), { recursive: true });
+  mkdirSync2(dirname(path3), { recursive: true });
   const tmp = `${path3}.tmp.${process.pid}`;
-  writeFileSync(tmp, content, { encoding: "utf8", mode: 384 });
+  writeFileSync2(tmp, content, { encoding: "utf8", mode: 384 });
   renameSync(tmp, path3);
   try {
-    chmodSync(path3, 384);
+    chmodSync2(path3, 384);
   } catch {
   }
 }
 function rotateBackups(filePath, env = process.env) {
   if (!existsSync3(filePath)) return;
   const backupsDir = getBackupsDir(env);
-  mkdirSync(backupsDir, { recursive: true });
+  mkdirSync2(backupsDir, { recursive: true });
   const base = basename(filePath);
   const stamp = Date.now();
-  const backupPath = join2(backupsDir, `${base}.${stamp}.bak`);
+  const backupPath = join3(backupsDir, `${base}.${stamp}.bak`);
   copyFileSync(filePath, backupPath);
-  const backups = readdirSync(backupsDir).filter((n) => n.startsWith(`${base}.`) && n.endsWith(".bak")).map((n) => ({ name: n, mtime: statSync(join2(backupsDir, n)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const backups = readdirSync(backupsDir).filter((n) => n.startsWith(`${base}.`) && n.endsWith(".bak")).map((n) => ({ name: n, mtime: statSync(join3(backupsDir, n)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   for (const old of backups.slice(MAX_BACKUPS)) {
     try {
-      unlinkSync(join2(backupsDir, old.name));
+      unlinkSync(join3(backupsDir, old.name));
     } catch {
     }
   }
@@ -4828,7 +5190,7 @@ function readSessionLock(env = process.env) {
 }
 function writeSessionLock(lock, env = process.env) {
   const path3 = getSessionLockPath(env);
-  mkdirSync(getRelayAiCodexDir(env), { recursive: true });
+  mkdirSync2(getRelayAiCodexDir(env), { recursive: true });
   atomicWriteFile(path3, `${JSON.stringify(lock, null, 2)}
 `);
 }
@@ -4951,20 +5313,21 @@ function getCatalogOutputPath(providerId) {
   return getCatalogPath(providerId);
 }
 function getFavoritesCatalogPath() {
-  return join3(getRelayAiCodexDir(), "models-favorites.json");
+  return join4(getRelayAiCodexDir(), "models-favorites.json");
 }
 function getFavoritesAppCatalogPath() {
-  return join3(getRelayAiCodexDir(), "app-models-favorites.json");
+  return join4(getRelayAiCodexDir(), "app-models-favorites.json");
 }
 function profileName() {
   return CODEX_PROFILE_NAME;
 }
 
 // src/codex/launch.ts
-import { execFileSync, execSync as execSync2, spawn as spawn2 } from "child_process";
+import { execSync as execSync2 } from "child_process";
+import spawn2 from "cross-spawn";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var isWindows2 = process.platform === "win32";
 var CODEX_CI_ENV_VARS = [
   "CI",
@@ -4985,11 +5348,11 @@ function stripCodexInheritedEnv(env) {
   return out;
 }
 var CODEX_FALLBACK_PATHS = isWindows2 ? [
-  join4(process.env["APPDATA"] ?? homedir4(), "npm", "codex.cmd"),
-  join4(process.env["APPDATA"] ?? homedir4(), "npm", "codex")
+  join5(process.env["APPDATA"] ?? homedir4(), "npm", "codex.cmd"),
+  join5(process.env["APPDATA"] ?? homedir4(), "npm", "codex")
 ] : [
-  join4(homedir4(), ".local", "bin", "codex"),
-  join4(homedir4(), ".npm", "bin", "codex"),
+  join5(homedir4(), ".local", "bin", "codex"),
+  join5(homedir4(), ".npm", "bin", "codex"),
   "/usr/local/bin/codex",
   "/opt/homebrew/bin/codex"
 ];
@@ -5023,12 +5386,7 @@ function selectCodexBinary(candidates, exists, canRun) {
 }
 function canRunCodexBinary(path3) {
   try {
-    execFileSync(path3, ["--version"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 5e3,
-      shell: isWindows2
-    });
+    runCodexCommandSync(path3, ["--version"], { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -5067,8 +5425,7 @@ function launchCodex(modelId, env, extraArgs) {
     const args = ["--profile", profileName(), "-m", modelId, ...ensureCodexSandboxArgs(extraArgs)];
     const child = spawn2(codexPath, args, {
       stdio: "inherit",
-      env,
-      shell: isWindows2
+      env
     });
     const forward = (signal) => {
       child.kill(signal);
@@ -5498,14 +5855,12 @@ async function resolveCodexMixedModels(input) {
     subagents: subagentResult.resolved,
     all,
     providersById: new Map(input.compatible.map((provider) => [provider.id, provider])),
-    dropped: [...visibleResult.droppedFavorites, ...subagentResult.droppedFavorites]
+    dropped: [...visibleResult.droppedFavorites, ...subagentResult.droppedFavorites],
+    capacitySkipped: [...visibleResult.capacitySkippedFavorites, ...subagentResult.capacitySkippedFavorites]
   };
 }
 
 // src/codex/native-catalog.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
 function isCatalogModel(value) {
   if (!value || typeof value !== "object") return false;
   const model = value;
@@ -5522,7 +5877,7 @@ function validateNativeCodexCatalog(value) {
 }
 async function captureNativeCodexCatalog(options) {
   const run = options.run ?? (async (args) => {
-    const result = await execFileAsync(options.binaryPath, args, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+    const result = await runCodexCommand(options.binaryPath, args, { maxBuffer: 16 * 1024 * 1024 });
     return result.stdout;
   });
   const stdout = await run(options.bundled ? ["debug", "models", "--bundled"] : ["debug", "models"]);
@@ -5545,6 +5900,22 @@ async function captureNativeCodexCatalog(options) {
 }
 
 // src/codex/mixed-catalog.ts
+function externalInstructionValue(value) {
+  if (typeof value === "string") {
+    return value.replace(/^You are Codex,[^\n]*?\.\s*/i, "").replace(/\bAs Codex,\s+(\w)/g, (_match, nextChar) => nextChar.toUpperCase()).replace(/\s+as Codex\b/gi, "");
+  }
+  if (Array.isArray(value)) return value.map(externalInstructionValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, nested]) => [
+      key,
+      externalInstructionValue(nested)
+    ])
+  );
+}
+function externalModelMessages(templateMessages) {
+  return externalInstructionValue(templateMessages);
+}
 function externalCatalogEntryFromTemplate(template, entry, priority, visibility, multiAgentVersion) {
   const resolvedModel = entry.resolved.model;
   const generated = catalogEntryFromModel(
@@ -5554,7 +5925,7 @@ function externalCatalogEntryFromTemplate(template, entry, priority, visibility,
     false,
     entry.slug
   );
-  return {
+  const external = {
     ...template,
     ...generated,
     slug: entry.slug,
@@ -5562,6 +5933,9 @@ function externalCatalogEntryFromTemplate(template, entry, priority, visibility,
     visibility,
     multi_agent_version: multiAgentVersion
   };
+  external.model_messages = externalModelMessages(template.model_messages);
+  delete external.comp_hash;
+  return external;
 }
 function composeMixedCodexCatalog(input) {
   const template = input.nativeModels.find((model) => model.slug === "gpt-5.5") ?? input.nativeModels.find((model) => model.visibility === "list") ?? input.nativeModels[0];
@@ -5682,6 +6056,7 @@ async function prepareCodexMixedRelayRoutes(models, trace = false) {
         apiKey: backend.token,
         baseURL: `http://127.0.0.1:${backend.port}`,
         upstreamModelId: proxyRoute.aliasId,
+        auditUpstreamModelId: original.model.upstreamModelId || original.model.id,
         providerId: original.providerId,
         authType: "oauth",
         oauthAccountId: original.oauthAccountId,
@@ -6012,7 +6387,7 @@ async function writeFavoritesLaunchArtifacts(resolved, starting, proxyPort) {
   return { profilePath, catalogPath };
 }
 async function writeMixedLaunchArtifacts(plan, proxyPort) {
-  const catalogPath = join5(getRelayAiCodexDir(), "models-mixed.json");
+  const catalogPath = join6(getRelayAiCodexDir(), "models-mixed.json");
   writeOverlayFile(catalogPath, serializeCatalog(plan.catalog));
   const profilePath = getProfileOutputPath();
   writeOverlayFile(profilePath, buildCodexMixedProfileToml({
@@ -6136,7 +6511,7 @@ async function runCodexVertexLaunch(passthroughArgs, trace) {
     restoreCodexOverlay();
   }
 }
-async function runCodexCommand(codexArgs, trace = false, launch = {}) {
+async function runCodexCommand2(codexArgs, trace = false, launch = {}) {
   if (codexArgs.includes("--help") || codexArgs.includes("-h")) {
     console.log(codexHelpText());
     return 0;
@@ -6334,7 +6709,7 @@ Error: ${launchPlan.error}
   let mixedPlan = null;
   if (mixedMode) {
     try {
-      const version = execFileSync2(codexPath, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+      const version = runCodexCommandSync(codexPath, ["--version"]).stdout.trim();
       const mixedModels = await resolveCodexMixedModels({
         activeProvider,
         selectedModel,
@@ -6597,17 +6972,17 @@ import * as p10 from "@clack/prompts";
 
 // src/gemini/launch.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir5, tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var isWindows3 = process.platform === "win32";
 var GEMINI_API_KEY_AUTH_TYPE = "gemini-api-key";
 var GEMINI_FALLBACK_PATHS = isWindows3 ? [
-  join6(process.env["APPDATA"] ?? homedir5(), "npm", "gemini.cmd"),
-  join6(process.env["APPDATA"] ?? homedir5(), "npm", "gemini")
+  join7(process.env["APPDATA"] ?? homedir5(), "npm", "gemini.cmd"),
+  join7(process.env["APPDATA"] ?? homedir5(), "npm", "gemini")
 ] : [
-  join6(homedir5(), ".local", "bin", "gemini"),
-  join6(homedir5(), ".npm", "bin", "gemini"),
+  join7(homedir5(), ".local", "bin", "gemini"),
+  join7(homedir5(), ".npm", "bin", "gemini"),
   "/usr/local/bin/gemini",
   "/opt/homebrew/bin/gemini"
 ];
@@ -6628,7 +7003,7 @@ function buildGeminiChildEnv(proxyPort, proxyToken) {
   return env;
 }
 function createGeminiCliHomeOverlay() {
-  const cliHome = mkdtempSync(join6(tmpdir(), "relay-ai-gemini-"));
+  const cliHome = mkdtempSync(join7(tmpdir(), "relay-ai-gemini-"));
   const settings = {
     security: {
       auth: {
@@ -6636,9 +7011,9 @@ function createGeminiCliHomeOverlay() {
       }
     }
   };
-  const geminiDir = join6(cliHome, ".gemini");
-  mkdirSync2(geminiDir);
-  writeFileSync2(join6(geminiDir, "settings.json"), `${JSON.stringify(settings, null, 2)}
+  const geminiDir = join7(cliHome, ".gemini");
+  mkdirSync3(geminiDir);
+  writeFileSync3(join7(geminiDir, "settings.json"), `${JSON.stringify(settings, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -7738,6 +8113,267 @@ import * as p11 from "@clack/prompts";
 import http from "http";
 import { streamText as streamText3, generateText as generateText3 } from "ai";
 
+// src/antigravity/request-adapter.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { tool as tool3, jsonSchema as jsonSchema3 } from "ai";
+var UNSUPPORTED_VOICE_MESSAGE = "Voice transcription isn\u2019t supported by Relay AI yet. Please type your message. Your coding session remains active.";
+var OMITTED_VOICE_TEXT = "[Voice recording omitted because transcription is not supported by Relay AI.]";
+function isSupportedImage(part) {
+  return part.inlineData?.mimeType.toLowerCase().startsWith("image/") ?? false;
+}
+function isUnsupportedInlineData(part) {
+  return !!part.inlineData && !isSupportedImage(part);
+}
+function sanitizeUnsupportedInlineData(ccReq) {
+  const contents = ccReq.request?.contents ?? [];
+  let latestUserIndex = -1;
+  for (let i = contents.length - 1; i >= 0; i--) {
+    if (contents[i].role === "user") {
+      latestUserIndex = i;
+      break;
+    }
+  }
+  let latestUserTurnHasUnsupportedMedia = false;
+  const sanitizedContents = contents.map((message, index) => ({
+    ...message,
+    parts: message.parts.map((part) => {
+      if (!isUnsupportedInlineData(part)) return part;
+      if (index === latestUserIndex) latestUserTurnHasUnsupportedMedia = true;
+      return { text: OMITTED_VOICE_TEXT };
+    })
+  }));
+  return {
+    request: {
+      ...ccReq,
+      request: {
+        ...ccReq.request,
+        contents: sanitizedContents
+      }
+    },
+    latestUserTurnHasUnsupportedMedia
+  };
+}
+function tracePartChars(part) {
+  if (typeof part.text === "string") return part.text.length;
+  if (part.type !== "tool-result") return void 0;
+  const output = part.output;
+  if (typeof output === "string") return output.length;
+  if (output && typeof output === "object" && typeof output.value === "string") {
+    return output.value.length;
+  }
+  try {
+    return output === void 0 ? void 0 : JSON.stringify(output).length;
+  } catch {
+    return void 0;
+  }
+}
+function summarizeSdkRequestForTrace(request2) {
+  const messages = request2.messages.map((message) => {
+    const content = message.content;
+    if (typeof content === "string") {
+      return { role: message.role, parts: [{ type: "text", chars: content.length }] };
+    }
+    const parts = Array.isArray(content) ? content.map((rawPart) => {
+      const part = rawPart;
+      const summary = {
+        type: typeof part.type === "string" ? part.type : typeof rawPart
+      };
+      const chars = tracePartChars(part);
+      if (chars !== void 0) summary.chars = chars;
+      if (typeof part.toolName === "string") summary.toolName = part.toolName;
+      if (typeof part.toolCallId === "string") summary.toolCallId = part.toolCallId;
+      return summary;
+    }) : [{ type: typeof content }];
+    return { role: message.role, parts };
+  });
+  return {
+    systemChars: request2.system?.length ?? 0,
+    messages,
+    toolNames: Object.keys(request2.tools ?? {}),
+    ...request2.toolChoice ? { toolChoice: request2.toolChoice } : {}
+  };
+}
+var JSON_SCHEMA_TYPES = /* @__PURE__ */ new Map([
+  ["ARRAY", "array"],
+  ["BOOLEAN", "boolean"],
+  ["INTEGER", "integer"],
+  ["NULL", "null"],
+  ["NUMBER", "number"],
+  ["OBJECT", "object"],
+  ["STRING", "string"]
+]);
+function expandTextWithThinking(text5) {
+  if (!text5.includes("<thinking>")) {
+    return [{ type: "text", text: text5 }];
+  }
+  const out = [];
+  const tokens = text5.split(/<thinking>([\s\S]*?)<\/thinking>/);
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i] ?? "";
+    if (!token.trim()) continue;
+    out.push({ type: i % 2 === 1 ? "reasoning" : "text", text: token });
+  }
+  return out.length > 0 ? out : [{ type: "text", text: text5 }];
+}
+function normalizeSchemaType(value) {
+  if (typeof value === "string") {
+    return JSON_SCHEMA_TYPES.get(value) ?? value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(normalizeSchemaType);
+  }
+  return value;
+}
+function normalizeJsonSchema(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeJsonSchema);
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [
+      key,
+      key === "type" ? normalizeSchemaType(child) : normalizeJsonSchema(child)
+    ])
+  );
+}
+function translateTools(ccTools, options = {}) {
+  if (!ccTools?.length) return void 0;
+  const tools = {};
+  let toolCount = 0;
+  for (const t of ccTools) {
+    if (t.functionDeclarations) {
+      for (const fd of t.functionDeclarations) {
+        if (options.maxTools !== void 0 && toolCount >= options.maxTools) break;
+        tools[fd.name] = tool3({
+          description: fd.description || "",
+          inputSchema: jsonSchema3(
+            normalizeJsonSchema(fd.parameters || { type: "object", properties: {} })
+          )
+        });
+        toolCount++;
+      }
+    }
+  }
+  return Object.keys(tools).length > 0 ? tools : void 0;
+}
+function translateRequest(ccReq, options = {}) {
+  const systemInstructions = [];
+  const sdkMessages = [];
+  const nameToIdList = /* @__PURE__ */ new Map();
+  const fallbackAssistantReasoning = [...options.fallbackAssistantReasoning ?? []];
+  const request2 = ccReq.request || {};
+  if (request2.systemInstruction?.parts) {
+    for (const part of request2.systemInstruction.parts) {
+      if (part.text) {
+        systemInstructions.push(part.text);
+      }
+    }
+  }
+  const contents = request2.contents || [];
+  for (const msg of contents) {
+    const role = msg.role;
+    if (role === "system") {
+      for (const part of msg.parts) {
+        if (part.text) {
+          systemInstructions.push(part.text);
+        }
+      }
+      continue;
+    }
+    const sdkRole = role === "model" ? "assistant" : "user";
+    const hasFunctionCall = msg.parts.some((p15) => p15.functionCall);
+    const hasAssistantReasoning = role === "model" && msg.parts.some((p15) => p15.thought || p15.text?.includes("<thinking>"));
+    const hasComplexParts = msg.parts.some((p15) => p15.thought || p15.inlineData || p15.functionCall || p15.functionResponse);
+    const singleText = msg.parts.length === 1 ? msg.parts[0]?.text : void 0;
+    if (!hasComplexParts && singleText !== void 0 && !singleText.includes("<thinking>")) {
+      sdkMessages.push({
+        role: sdkRole,
+        content: singleText
+      });
+      continue;
+    }
+    const contentParts = [];
+    const toolResults = [];
+    if (role === "model" && hasFunctionCall && !hasAssistantReasoning) {
+      const fallback = fallbackAssistantReasoning.shift();
+      if (fallback?.trim()) {
+        contentParts.push({ type: "reasoning", text: fallback });
+      }
+    }
+    for (const part of msg.parts) {
+      if (part.text !== void 0) {
+        if (part.thought) {
+          contentParts.push({ type: "reasoning", text: part.text });
+        } else {
+          for (const piece of expandTextWithThinking(part.text)) {
+            contentParts.push(piece);
+          }
+        }
+      } else if (part.inlineData) {
+        if (isSupportedImage(part)) {
+          contentParts.push({
+            type: "image",
+            image: part.inlineData.data,
+            mimeType: part.inlineData.mimeType
+          });
+        } else {
+          contentParts.push({ type: "text", text: OMITTED_VOICE_TEXT });
+        }
+      } else if (part.functionCall) {
+        const id = "call_" + randomUUID2().replace(/-/g, "");
+        const name = part.functionCall.name;
+        if (!nameToIdList.has(name)) nameToIdList.set(name, []);
+        nameToIdList.get(name).push(id);
+        contentParts.push({
+          type: "tool-call",
+          toolCallId: id,
+          toolName: name,
+          input: part.functionCall.args || {}
+        });
+      } else if (part.functionResponse) {
+        const name = part.functionResponse.name;
+        const idList = nameToIdList.get(name) || [];
+        const id = idList.shift() || "call_" + randomUUID2().replace(/-/g, "");
+        toolResults.push({
+          type: "tool-result",
+          toolCallId: id,
+          toolName: name,
+          output: { type: "text", value: serializeToolResultContent(part.functionResponse.response) }
+        });
+      }
+    }
+    if (toolResults.length > 0) {
+      sdkMessages.push({
+        role: "tool",
+        content: toolResults
+      });
+    }
+    if (contentParts.length > 0) {
+      sdkMessages.push({
+        role: sdkRole,
+        content: contentParts
+      });
+    }
+  }
+  const system = systemInstructions.length > 0 ? systemInstructions.join("\n\n") : void 0;
+  const tools = translateTools(request2.tools, options);
+  let toolChoice;
+  const mode = request2.toolConfig?.functionCallingConfig?.mode;
+  if (mode === "ANY") {
+    toolChoice = "required";
+  } else if (mode === "AUTO" || tools) {
+    toolChoice = "auto";
+  }
+  return {
+    system,
+    messages: sdkMessages,
+    tools,
+    toolChoice
+  };
+}
+
 // src/antigravity/response-adapter.ts
 function normalizeFunctionCallArgs(args) {
   const out = {};
@@ -9615,19 +10251,19 @@ async function resolveAntigravityLaunchRoutes(opts) {
 }
 
 // src/antigravity/launch-cli.ts
-import { execFileSync as execFileSync3, execSync as execSync3 } from "child_process";
+import { execFileSync, execSync as execSync3 } from "child_process";
 import spawn4 from "cross-spawn";
 import { existsSync as existsSync6 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var isWindows4 = process.platform === "win32";
 var FALLBACK_PATHS = isWindows4 ? [
-  join7(process.env["APPDATA"] ?? homedir6(), "npm", "agy.cmd"),
-  join7(process.env["APPDATA"] ?? homedir6(), "npm", "agy"),
-  join7(homedir6(), "AppData", "Roaming", "npm", "agy.cmd")
+  join8(process.env["APPDATA"] ?? homedir6(), "npm", "agy.cmd"),
+  join8(process.env["APPDATA"] ?? homedir6(), "npm", "agy"),
+  join8(homedir6(), "AppData", "Roaming", "npm", "agy.cmd")
 ] : [
-  join7(homedir6(), ".local", "bin", "agy"),
-  join7(homedir6(), ".npm", "bin", "agy"),
+  join8(homedir6(), ".local", "bin", "agy"),
+  join8(homedir6(), ".npm", "bin", "agy"),
   "/usr/local/bin/agy",
   "/opt/homebrew/bin/agy"
 ];
@@ -9653,7 +10289,7 @@ function readAntigravityCliVersion(binaryPath = findAntigravityCliBinary() ?? vo
     return { version: null, error: 'Antigravity CLI binary "agy" not found' };
   }
   try {
-    const raw = execFileSync3(binaryPath, ["--version"], {
+    const raw = execFileSync(binaryPath, ["--version"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
     }).trim();
@@ -9702,10 +10338,10 @@ function launchAntigravityCli(env, extraArgs) {
 }
 
 // src/antigravity/launch-ide.ts
-import { execFileSync as execFileSync4, execSync as execSync4, spawn as spawn5 } from "child_process";
+import { execFileSync as execFileSync2, execSync as execSync4, spawn as spawn5 } from "child_process";
 import { existsSync as existsSync7 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/antigravity/ide-profile.ts
 import fs from "fs";
@@ -9739,8 +10375,8 @@ function prepareIdeProfile(profileDir, gatewayUrl) {
 }
 
 // src/antigravity/launch-ide.ts
-var LINUX_APP_PROFILE_DIR = join8(homedir7(), ".relay-ai", "antigravity", "app-profile");
-var LINUX_IDE_PROFILE_DIR = join8(homedir7(), ".relay-ai", "antigravity", "profile");
+var LINUX_APP_PROFILE_DIR = join9(homedir7(), ".relay-ai", "antigravity", "app-profile");
+var LINUX_IDE_PROFILE_DIR = join9(homedir7(), ".relay-ai", "antigravity", "profile");
 function sleep(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -9748,7 +10384,7 @@ function linuxAntigravityBinary() {
   const candidates = [
     "/usr/share/antigravity/antigravity",
     "/opt/antigravity/antigravity",
-    join8(homedir7(), ".local", "share", "antigravity", "antigravity")
+    join9(homedir7(), ".local", "share", "antigravity", "antigravity")
   ];
   for (const candidate of candidates) {
     if (existsSync7(candidate)) return candidate;
@@ -9806,7 +10442,7 @@ function defaultProcessList() {
   const psArgs = process.platform === "linux" ? ["-eo", "pid=,args="] : ["-axo", "pid=,command="];
   if (process.platform !== "darwin" && process.platform !== "linux") return "";
   try {
-    return execFileSync4("ps", psArgs, {
+    return execFileSync2("ps", psArgs, {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"],
       maxBuffer: 1024 * 1024 * 4
@@ -9870,11 +10506,11 @@ function quitAntigravityIdeGracefully() {
   }
   if (process.platform !== "darwin") return;
   try {
-    execFileSync4("osascript", ["-e", 'tell application "Antigravity IDE" to quit'], {
+    execFileSync2("osascript", ["-e", 'tell application "Antigravity IDE" to quit'], {
       stdio: ["ignore", "pipe", "pipe"]
     });
   } catch {
-    execFileSync4("osascript", ["-e", 'tell application id "com.google.antigravity-ide" to quit'], {
+    execFileSync2("osascript", ["-e", 'tell application id "com.google.antigravity-ide" to quit'], {
       stdio: ["ignore", "pipe", "pipe"]
     });
   }
@@ -9890,11 +10526,11 @@ function quitAntigravityAppGracefully() {
   }
   if (process.platform !== "darwin") return;
   try {
-    execFileSync4("osascript", ["-e", 'tell application "Antigravity" to quit'], {
+    execFileSync2("osascript", ["-e", 'tell application "Antigravity" to quit'], {
       stdio: ["ignore", "pipe", "pipe"]
     });
   } catch {
-    execFileSync4("osascript", ["-e", 'tell application id "com.google.antigravity" to quit'], {
+    execFileSync2("osascript", ["-e", 'tell application id "com.google.antigravity" to quit'], {
       stdio: ["ignore", "pipe", "pipe"]
     });
   }
@@ -9903,15 +10539,15 @@ function findAntigravityAppBinary() {
   const override = getAppPathOverride("antigravity");
   if (override) return existsSync7(override) ? override : null;
   if (process.platform === "win32") {
-    const localAppData = process.env["LOCALAPPDATA"] ?? join8(homedir7(), "AppData", "Local");
-    const winPath = join8(localAppData, "Programs", "Antigravity", "Antigravity.exe");
+    const localAppData = process.env["LOCALAPPDATA"] ?? join9(homedir7(), "AppData", "Local");
+    const winPath = join9(localAppData, "Programs", "Antigravity", "Antigravity.exe");
     return existsSync7(winPath) ? winPath : null;
   }
   if (process.platform === "linux") return linuxAntigravityBinary();
   if (process.platform !== "darwin") return null;
   const defaultPath = "/Applications/Antigravity.app/Contents/MacOS/Antigravity";
   if (existsSync7(defaultPath)) return defaultPath;
-  const homePath = join8(homedir7(), "Applications", "Antigravity.app", "Contents", "MacOS", "Antigravity");
+  const homePath = join9(homedir7(), "Applications", "Antigravity.app", "Contents", "MacOS", "Antigravity");
   if (existsSync7(homePath)) return homePath;
   return null;
 }
@@ -9919,15 +10555,15 @@ function findAntigravityIdeBinary() {
   const override = getAppPathOverride("antigravity-ide");
   if (override) return existsSync7(override) ? override : null;
   if (process.platform === "win32") {
-    const localAppData = process.env["LOCALAPPDATA"] ?? join8(homedir7(), "AppData", "Local");
-    const winPath = join8(localAppData, "Programs", "Antigravity IDE", "Antigravity IDE.exe");
+    const localAppData = process.env["LOCALAPPDATA"] ?? join9(homedir7(), "AppData", "Local");
+    const winPath = join9(localAppData, "Programs", "Antigravity IDE", "Antigravity IDE.exe");
     return existsSync7(winPath) ? winPath : null;
   }
   if (process.platform === "linux") return linuxAntigravityBinary();
   if (process.platform !== "darwin") return null;
   const defaultPath = "/Applications/Antigravity IDE.app/Contents/Resources/app/bin/antigravity-ide";
   if (existsSync7(defaultPath)) return defaultPath;
-  const homePath = join8(homedir7(), "Applications", "Antigravity IDE.app", "Contents", "Resources", "app", "bin", "antigravity-ide");
+  const homePath = join9(homedir7(), "Applications", "Antigravity IDE.app", "Contents", "Resources", "app", "bin", "antigravity-ide");
   if (existsSync7(homePath)) return homePath;
   return null;
 }
@@ -9988,7 +10624,7 @@ function launchAntigravityIde(env, profileDir, gatewayUrl, extraArgs) {
       return;
     }
     prepareIdeProfile(profileDir, gatewayUrl);
-    const relayExtensionsDir = join8(homedir7(), ".relay-ai", "antigravity", "extensions");
+    const relayExtensionsDir = join9(homedir7(), ".relay-ai", "antigravity", "extensions");
     const args = [
       `--user-data-dir=${profileDir}`,
       `--extensions-dir=${relayExtensionsDir}`,
@@ -10018,7 +10654,7 @@ function launchAntigravityIde(env, profileDir, gatewayUrl, extraArgs) {
 
 // src/antigravity.ts
 import { homedir as homedir8 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var SHUTDOWN_DRAIN_MS = 500;
 var AGY_FAVORITES_PROVIDER_ID = "__relay_agy_favorites__";
 var AGY_FAVORITES_PROVIDER_LABEL = "\u2605 Antigravity CLI Favorites";
@@ -10312,7 +10948,7 @@ async function runAntigravityAppCommand(childArgs, trace = false, boot) {
     trace,
     boot,
     async (env, _routes, gatewayHandle) => {
-      const profileDir = join9(homedir8(), ".relay-ai", "antigravity", "app-profile");
+      const profileDir = join10(homedir8(), ".relay-ai", "antigravity", "app-profile");
       if (isAntigravityAppRunning(profileDir)) {
         const restart = await p11.confirm({
           message: "Restart Antigravity to apply this Relay gateway?",
@@ -10360,7 +10996,7 @@ async function runAntigravityIdeCommand(childArgs, trace = false, boot) {
     trace,
     boot,
     async (env, _routes, gatewayHandle) => {
-      const profileDir = join9(homedir8(), ".relay-ai", "antigravity", "profile");
+      const profileDir = join10(homedir8(), ".relay-ai", "antigravity", "profile");
       if (isAntigravityIdeRunning(profileDir)) {
         const restart = await p11.confirm({
           message: "Restart Antigravity IDE to apply this Relay gateway?",
@@ -10405,8 +11041,7 @@ async function runAntigravityIdeCommand(childArgs, trace = false, boot) {
 // src/codex-app.ts
 import pc10 from "picocolors";
 import * as p12 from "@clack/prompts";
-import { execFileSync as execFileSync5 } from "child_process";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/codex/app-provider-routes.ts
 function codexRouteToProxyRoute(provider, model, apiKey) {
@@ -10495,14 +11130,14 @@ async function buildCodexAppProviderCatalogRoutes(provider, apiKey, selectedMode
 }
 
 // src/codex/app-config.ts
-import { existsSync as existsSync8, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname2, join as join10 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname2, join as join11 } from "path";
 import { parse, stringify } from "smol-toml";
 function getCodexConfigPath() {
-  return join10(getCodexHome(), "config.toml");
+  return join11(getCodexHome(), "config.toml");
 }
 function getCodexAppSidecarProfilePath() {
-  return join10(getCodexHome(), `${CODEX_APP_PROVIDER_ID}.config.toml`);
+  return join11(getCodexHome(), `${CODEX_APP_PROVIDER_ID}.config.toml`);
 }
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -10677,8 +11312,13 @@ function applyAppConfigPatch(spec, configPath = getCodexConfigPath()) {
   const text5 = `${stringify(merged)}
 `;
   validateAppConfigText(text5, spec);
-  mkdirSync3(dirname2(configPath), { recursive: true });
-  writeFileSync3(configPath, text5, "utf8");
+  mkdirSync4(dirname2(configPath), { recursive: true });
+  atomicWriteFile(configPath, text5);
+  const written = readCodexConfigText(configPath);
+  if (written !== text5) {
+    throw new Error(`Codex config readback mismatch at ${configPath}`);
+  }
+  validateAppConfigText(written, spec);
   return text5;
 }
 function applyRestoreKey(config, key, had, value) {
@@ -10734,7 +11374,7 @@ function restoreConfigFromState(state, configPath = getCodexConfigPath()) {
     rmSync3(configPath, { force: true });
     return true;
   }
-  writeFileSync3(configPath, `${stringify(config)}
+  writeFileSync4(configPath, `${stringify(config)}
 `, "utf8");
   return true;
 }
@@ -10745,31 +11385,69 @@ function previewAppConfigToml(spec) {
   return text5;
 }
 
+// src/codex/app-readiness.ts
+import { readFileSync as readFileSync4 } from "fs";
+function proxyRoot(spec) {
+  const base = spec.proxyBaseUrl ?? `http://127.0.0.1:${spec.proxyPort}/v1`;
+  if (!base.endsWith("/v1")) throw new Error("Codex App proxy base URL must end in /v1");
+  return base.slice(0, -3);
+}
+async function checkedJson(url, fetchImpl) {
+  const response = await fetchImpl(url);
+  if (!response.ok) throw new Error(`Relay readiness check failed: GET ${url} returned HTTP ${response.status}`);
+  return response.json();
+}
+async function verifyCodexAppReadiness(spec, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const root = proxyRoot(spec);
+  const health = await checkedJson(`${root}/health`, fetchImpl);
+  if (health.ok !== true) throw new Error("Relay proxy health check did not report ready");
+  const catalog = JSON.parse(readFileSync4(spec.catalogPath, "utf8"));
+  if (!Array.isArray(catalog.models) || catalog.models.length === 0) {
+    throw new Error("Relay Codex model catalog is empty or invalid");
+  }
+  const catalogIds = catalog.models.map((model) => model?.slug).filter((id) => typeof id === "string" && id.length > 0);
+  if (catalogIds.length !== catalog.models.length) throw new Error("Relay Codex model catalog contains an invalid model slug");
+  if (!catalogIds.includes(spec.route.modelId)) {
+    throw new Error(`Relay Codex model catalog is missing selected model ${spec.route.modelId}`);
+  }
+  const advertised = await checkedJson(`${root}/v1/models`, fetchImpl);
+  const advertisedIds = new Set((advertised.data ?? []).map((model) => model.id).filter((id) => typeof id === "string"));
+  for (const id of catalogIds) {
+    if (!advertisedIds.has(id)) throw new Error(`Relay proxy does not advertise catalog model ${id}`);
+  }
+  validateAppConfigText(readCodexConfigText(options.configPath), spec);
+}
+
 // src/codex/app-session.ts
 import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync9,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   rmSync as rmSync4,
   statSync as statSync2
 } from "fs";
-import { basename as basename2, join as join11 } from "path";
+import { basename as basename2, join as join12 } from "path";
+import { createHash as createHash3 } from "crypto";
 function getAppSessionLockPath(env = process.env) {
-  return join11(getRelayAiCodexDir(env), "session-app.json");
+  return join12(getRelayAiCodexDir(env), "session-app.json");
 }
 function getAppRestoreStatePath(env = process.env) {
-  return join11(getRelayAiCodexDir(env), "app-restore-state.json");
+  return join12(getRelayAiCodexDir(env), "app-restore-state.json");
 }
 function getAppCatalogPath(providerId, env = process.env) {
-  return join11(getRelayAiCodexDir(env), `app-models-${providerId}.json`);
+  return join12(getRelayAiCodexDir(env), `app-models-${providerId}.json`);
+}
+function fileSha256(path3) {
+  return createHash3("sha256").update(readFileSync5(path3)).digest("hex");
 }
 function readAppSessionLock(env = process.env) {
   const path3 = getAppSessionLockPath(env);
   if (!existsSync9(path3)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path3, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.startedAt === "string") return parsed;
   } catch {
   }
@@ -10787,7 +11465,7 @@ function readAppRestoreState(env = process.env) {
   const path3 = getAppRestoreStatePath(env);
   if (!existsSync9(path3)) return null;
   try {
-    return JSON.parse(readFileSync4(path3, "utf8"));
+    return JSON.parse(readFileSync5(path3, "utf8"));
   } catch {
     return null;
   }
@@ -10806,9 +11484,9 @@ function backupConfigToml(env = process.env) {
   if (!existsSync9(configPath)) return void 0;
   rotateBackups(configPath, env);
   const backupsDir = getBackupsDir(env);
-  mkdirSync4(backupsDir, { recursive: true });
+  mkdirSync5(backupsDir, { recursive: true });
   const base = basename2(configPath);
-  const backupPath = join11(backupsDir, `${base}.${Date.now()}.bak`);
+  const backupPath = join12(backupsDir, `${base}.${Date.now()}.bak`);
   copyFileSync2(configPath, backupPath);
   return backupPath;
 }
@@ -10825,7 +11503,7 @@ function saveAppRestoreStateBeforePatch(env = process.env) {
 function ownedAppCatalogPaths(env = process.env) {
   const codexDir = getRelayAiCodexDir(env);
   if (!existsSync9(codexDir)) return [];
-  return readdirSync2(codexDir).filter((n) => n.startsWith("app-models-") && n.endsWith(".json")).map((n) => join11(codexDir, n));
+  return readdirSync2(codexDir).filter((n) => n.startsWith("app-models-") && n.endsWith(".json")).map((n) => join12(codexDir, n));
 }
 function removeAppCatalogs(env = process.env) {
   const removed = [];
@@ -10843,7 +11521,7 @@ function newestConfigBackup(env = process.env) {
   if (!existsSync9(backupDir)) return null;
   const configBase = basename2(getCodexConfigPath());
   const candidates = readdirSync2(backupDir).filter((name) => name.startsWith(`${configBase}.`) && name.endsWith(".bak")).map((name) => {
-    const path3 = join11(backupDir, name);
+    const path3 = join12(backupDir, name);
     try {
       return { path: path3, mtimeMs: statSync2(path3).mtimeMs };
     } catch {
@@ -10869,7 +11547,12 @@ function restoreCodexAppOverlay(env = process.env) {
     clearAppSessionLock(env);
     return { restored: false, message: "Nothing to restore." };
   }
-  if (restoreState) {
+  const exactBackupIsSafe = Boolean(
+    managed && lock?.backupPath && existsSync9(lock.backupPath) && lock.patchedConfigSha256 && lock.originalConfigSha256 && fileSha256(getCodexConfigPath()) === lock.patchedConfigSha256 && fileSha256(lock.backupPath) === lock.originalConfigSha256
+  );
+  if (exactBackupIsSafe) {
+    copyFileSync2(lock.backupPath, getCodexConfigPath());
+  } else if (restoreState) {
     restoreConfigFromState(restoreState);
   } else if (lock?.backupPath && existsSync9(lock.backupPath)) {
     copyFileSync2(lock.backupPath, getCodexConfigPath());
@@ -10945,10 +11628,15 @@ function codexProxyRouteToCodexRoute(route, fallbackProviderId) {
     refreshToken: route.refreshToken
   };
 }
-async function waitForShutdownWithConfirm() {
+function codexAppUsesExplicitSelection(configOnly, launchProvider, launchModel) {
+  void configOnly;
+  return Boolean(launchProvider && launchModel);
+}
+async function waitForShutdownWithConfirm(assumeYes = false) {
   while (true) {
     const signal = await waitForShutdown2();
-    if (signal !== "sigint") break;
+    if (signal !== "sigint") return signal;
+    if (assumeYes) return signal;
     console.log("");
     const choice = await p12.select({
       message: "Close ChatGPT Desktop and restore your Codex config?",
@@ -10957,11 +11645,19 @@ async function waitForShutdownWithConfirm() {
         { value: "no", label: "No, keep session running" }
       ]
     });
-    if (p12.isCancel(choice) || choice === "yes") break;
+    if (p12.isCancel(choice) || choice === "yes") return signal;
   }
 }
-async function maybeCloseRunningCodexApp() {
+function unattendedShutdownClosesApp(assumeYes, signal) {
+  return assumeYes && signal !== "sigint";
+}
+async function maybeCloseRunningCodexApp(assumeYes = false) {
   if (!isCodexAppRunning()) return;
+  if (assumeYes) {
+    p12.log.step("Stopping ChatGPT Desktop...");
+    quitCodexAppGracefully();
+    return;
+  }
   const shouldClose = await p12.confirm({ message: "ChatGPT Desktop is still running. Close it?" });
   if (shouldClose && !p12.isCancel(shouldClose)) {
     p12.log.step("Stopping ChatGPT Desktop...");
@@ -10985,6 +11681,7 @@ ${pc10.bold("Options:")}
   --vertex     Use Claude models through Google Vertex AI
   --with-native Load native Codex models beside Relay models for this launch
   --relay-only Keep the current Relay-only launch behavior
+  --yes, -y     Approve a fully specified launch/restart without prompting
   --restore    Restore Codex config after an interrupted app session
   --config     Preview the generated Codex app configuration without launching
   --trace      Write proxy debug logs to ~/.relay-ai/logs/ and show errors on exit
@@ -11011,6 +11708,7 @@ ${pc10.bold("Preview (no writes):")}
 ${pc10.bold("Examples:")}
   relay-ai codex-app
   relay-ai codex-app --vertex
+  relay-ai codex-app --provider antigravity --model gemini-3.1-pro-high --with-native --yes
   relay-ai codex-app --config
   relay-ai codex-app --restore
   
@@ -11119,8 +11817,10 @@ async function runCodexAppVertexLaunch(configOnly, trace = false) {
       catalogPath
     };
     saveAppRestoreStateBeforePatch();
+    sessionActive = true;
     const backupPath = backupConfigToml();
     applyAppConfigPatch(spec);
+    await verifyCodexAppReadiness(spec);
     writeAppSessionLock({
       pid: process.pid,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11128,9 +11828,10 @@ async function runCodexAppVertexLaunch(configOnly, trace = false) {
       catalogPaths: [catalogPath],
       restoreStatePath: getAppRestoreStatePath(),
       backupPath,
-      proxyPort
+      proxyPort,
+      patchedConfigSha256: fileSha256(getCodexConfigPath()),
+      ...backupPath ? { originalConfigSha256: fileSha256(backupPath) } : {}
     });
-    sessionActive = true;
     p12.log.info(`Vertex AI \xB7 ${selectedEntry.display_name} \u2014 project: ${config.project} / location: ${config.location}`);
     logProxy(proxyPort);
     logActiveModel(selectedEntry.display_name, selectedEntry.id);
@@ -11139,6 +11840,7 @@ async function runCodexAppVertexLaunch(configOnly, trace = false) {
     } catch (err) {
       p12.log.warn(String(err instanceof Error ? err.message : err));
       p12.log.info(codexAppInstallHint());
+      throw err;
     }
     printCodexAppSessionPanel({
       modelLabel: selectedEntry.display_name,
@@ -11170,6 +11872,13 @@ async function runCodexAppCommand(args, opts = {}) {
     console.log(result.message);
     return result.liveSession ? 1 : 0;
   }
+  const configOnly = args.includes("--config");
+  if (opts.assumeYes && !configOnly) {
+    if (opts.vertex || !opts.launchProvider || !opts.launchModel || !opts.codexLaunchMode) {
+      console.error(pc10.red("--yes requires --provider, --model, and either --with-native or --relay-only."));
+      return 1;
+    }
+  }
   try {
     codexAppSupported();
   } catch (err) {
@@ -11177,7 +11886,6 @@ async function runCodexAppCommand(args, opts = {}) {
     return 1;
   }
   const interrupted = recoverInterruptedCodexAppSession();
-  const configOnly = args.includes("--config");
   const trace = args.includes("--trace");
   const debugLogPath = getCodexProxyDebugLogPath();
   if (trace && !configOnly) {
@@ -11185,7 +11893,7 @@ async function runCodexAppCommand(args, opts = {}) {
   }
   const isTty = Boolean(process.stdin.isTTY);
   if (!configOnly) {
-    const sessionCheck = checkAppSessionLock(isTty);
+    const sessionCheck = checkAppSessionLock(isTty || Boolean(opts.assumeYes));
     if (!sessionCheck.ok) {
       if (sessionCheck.reason === "non_tty") {
         console.error(pc10.red("relay-ai codex-app requires an interactive terminal."));
@@ -11243,7 +11951,7 @@ async function runCodexAppCommand(args, opts = {}) {
     compatible.find((lp) => lp.id === prefs.lastCodexProvider) ?? compatible[0]
   );
   let selectedModel = activeProvider.models.find((m) => m.id === prefs.lastCodexModel) ?? activeProvider.models[0];
-  if (!configOnly && opts.launchProvider && opts.launchModel) {
+  if (codexAppUsesExplicitSelection(configOnly, opts.launchProvider, opts.launchModel)) {
     const bootSelection = resolveBootSelection(
       compatible,
       opts.launchProvider,
@@ -11314,7 +12022,7 @@ async function runCodexAppCommand(args, opts = {}) {
     try {
       const embeddedBinary = findEmbeddedCodexBinary();
       if (!embeddedBinary) throw new Error("Embedded ChatGPT/Codex runtime was not found; mixed Desktop mode is unavailable on this installation");
-      const version = execFileSync5(embeddedBinary, ["--version"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+      const version = runCodexCommandSync(embeddedBinary, ["--version"]).stdout.trim();
       const mixedModels = await resolveCodexMixedModels({
         activeProvider,
         selectedModel,
@@ -11322,6 +12030,11 @@ async function runCodexAppCommand(args, opts = {}) {
         generalFavorites: favorites,
         subagentFavorites: prefs.codexSubagentModels ?? []
       });
+      if (mixedModels.capacitySkipped.length > 0) {
+        p12.log.warn(
+          `Skipped ${mixedModels.capacitySkipped.length} favorite(s) because the mixed catalog is full: ` + mixedModels.capacitySkipped.map((f) => `${f.providerId}:${f.modelId}`).join(", ")
+        );
+      }
       assertConfiguredCodexSubagentsResolved(prefs.codexSubagentModels ?? [], mixedModels);
       const multiAgentV2Supported = mixedModels.subagents.length === 0 || supportsMultiAgentV2(embeddedBinary);
       if (!multiAgentV2Supported) {
@@ -11345,7 +12058,7 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
       return 1;
     }
   }
-  if (!configOnly) {
+  if (!configOnly && !opts.assumeYes) {
     const modelLabel = formatCodexModelLabel(selectedModel);
     const confirmed = await confirmCodexLaunch(
       activeProvider.name,
@@ -11361,7 +12074,7 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
   let proxyHandle = null;
   let sessionActive = false;
   try {
-    const catalogPath = mixedPlan ? join12(getRelayAiCodexDir(), "app-models-mixed.json") : favoritesActive && resolvedFavorites.length > 0 ? getFavoritesAppCatalogPath() : getAppCatalogPath(route.providerId);
+    const catalogPath = mixedPlan ? join13(getRelayAiCodexDir(), "app-models-mixed.json") : favoritesActive && resolvedFavorites.length > 0 ? getFavoritesAppCatalogPath() : getAppCatalogPath(route.providerId);
     const activeRoute = mixedPlan ? {
       tier: "proxy",
       modelId: mixedPlan.selectedSlug,
@@ -11424,10 +12137,12 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
       return 0;
     }
     let proxyPort;
+    const routeAuditPath = mixedPlan ? prepareCodexRouteAuditLog() : void 0;
     if (mixedPlan) {
       proxyHandle = await startCodexProxy(mixedPlan.relayRoutes, {
         requireAuth: false,
         debug: trace,
+        routeAuditPath,
         mixedNative: {
           nativeModelIds: mixedPlan.nativeModelIds,
           subagentRouteModelId: mixedPlan.subagentRouteModelId,
@@ -11436,6 +12151,7 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
         }
       });
       proxyPort = proxyHandle.port;
+      p12.log.info(`Route audit (metadata only): ${routeAuditPath}`);
     } else if (favoritesActive && resolvedFavorites.length > 0) {
       const needsBackend = (r) => {
         const m = r.model;
@@ -11495,8 +12211,10 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
       ...mixedPlan ? { proxyBaseUrl: `${mixedProxyBaseUrl(proxyPort, mixedPlan.capability)}/v1` } : {}
     };
     saveAppRestoreStateBeforePatch();
+    sessionActive = true;
     const backupPath = backupConfigToml();
     applyAppConfigPatch(spec);
+    await verifyCodexAppReadiness(spec);
     writeAppSessionLock({
       pid: process.pid,
       startedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11504,9 +12222,10 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
       catalogPaths: [catalogPath],
       restoreStatePath: getAppRestoreStatePath(),
       backupPath,
-      proxyPort
+      proxyPort,
+      patchedConfigSha256: fileSha256(getCodexConfigPath()),
+      ...backupPath ? { originalConfigSha256: fileSha256(backupPath) } : {}
     });
-    sessionActive = true;
     const prevRecent = prefs.recentModelsByProvider?.[activeProvider.id] ?? [];
     const updatedRecent = [selectedModel.id, ...prevRecent.filter((id) => id !== selectedModel.id)].slice(0, 3);
     savePreferences({
@@ -11517,10 +12236,11 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
     logProxy(proxyPort);
     logActiveModel(modelLabel, selectedModel.id);
     try {
-      await launchOrRestartCodexApp();
+      await launchOrRestartCodexApp(void 0, opts.assumeYes);
     } catch (err) {
       p12.log.warn(String(err instanceof Error ? err.message : err));
       p12.log.info(codexAppInstallHint());
+      throw err;
     }
     printCodexAppSessionPanel({
       modelLabel,
@@ -11529,14 +12249,21 @@ Mixed Codex App mode is unavailable: ${err instanceof Error ? err.message : err}
       restoreCommand: "relay-ai codex-app --restore"
     });
     codexAppOutro(modelLabel);
-    await waitForShutdownWithConfirm();
+    const shutdownSignal = await waitForShutdownWithConfirm(opts.assumeYes);
     if (trace) printTraceLog(debugLogPath);
     console.log("");
     if (sessionActive) {
       restoreCodexAppOverlay();
       sessionActive = false;
     }
-    await maybeCloseRunningCodexApp();
+    if (unattendedShutdownClosesApp(Boolean(opts.assumeYes), shutdownSignal)) {
+      if (isCodexAppRunning()) {
+        p12.log.step("Stopping ChatGPT Desktop after unattended Relay shutdown...");
+        quitCodexAppGracefully();
+      }
+    } else {
+      await maybeCloseRunningCodexApp(opts.assumeYes);
+    }
     return 0;
   } finally {
     proxyHandle?.close();
@@ -11555,38 +12282,38 @@ import pc11 from "picocolors";
 import * as p13 from "@clack/prompts";
 
 // src/claude-desktop/app-config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join13, dirname as dirname3 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import { join as join14, dirname as dirname3 } from "path";
+import { randomUUID as randomUUID3 } from "crypto";
 function getClaudeDesktopHome() {
   if (process.platform === "win32") {
-    return join13(process.env.LOCALAPPDATA || join13(homedir9(), "AppData", "Local"), "Claude-3p");
+    return join14(process.env.LOCALAPPDATA || join14(homedir9(), "AppData", "Local"), "Claude-3p");
   }
   if (process.platform === "linux") {
-    return join13(process.env.XDG_CONFIG_HOME || join13(homedir9(), ".config"), "Claude-3p");
+    return join14(process.env.XDG_CONFIG_HOME || join14(homedir9(), ".config"), "Claude-3p");
   }
-  return join13(homedir9(), "Library", "Application Support", "Claude-3p");
+  return join14(homedir9(), "Library", "Application Support", "Claude-3p");
 }
 function getConfigLibraryPath() {
-  return join13(getClaudeDesktopHome(), "configLibrary");
+  return join14(getClaudeDesktopHome(), "configLibrary");
 }
 function getMetaJsonPath() {
-  return join13(getConfigLibraryPath(), "_meta.json");
+  return join14(getConfigLibraryPath(), "_meta.json");
 }
 function readMetaJson() {
   const metaPath = getMetaJsonPath();
   if (!existsSync10(metaPath)) return null;
   try {
-    return JSON.parse(readFileSync5(metaPath, "utf8"));
+    return JSON.parse(readFileSync6(metaPath, "utf8"));
   } catch {
     return null;
   }
 }
 function writeMetaJson(meta) {
   const metaPath = getMetaJsonPath();
-  mkdirSync5(dirname3(metaPath), { recursive: true });
-  writeFileSync4(metaPath, `${JSON.stringify(meta, null, 2)}
+  mkdirSync6(dirname3(metaPath), { recursive: true });
+  writeFileSync5(metaPath, `${JSON.stringify(meta, null, 2)}
 `, "utf8");
 }
 function buildRelayAiConfig(proxyPort) {
@@ -11599,11 +12326,11 @@ function buildRelayAiConfig(proxyPort) {
   };
 }
 function writeRelayAiConfig(proxyPort) {
-  const uuid = randomUUID2();
-  const configPath = join13(getConfigLibraryPath(), `${uuid}.json`);
+  const uuid = randomUUID3();
+  const configPath = join14(getConfigLibraryPath(), `${uuid}.json`);
   const config = buildRelayAiConfig(proxyPort);
-  mkdirSync5(dirname3(configPath), { recursive: true });
-  writeFileSync4(configPath, `${JSON.stringify(config, null, 2)}
+  mkdirSync6(dirname3(configPath), { recursive: true });
+  writeFileSync5(configPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
   const meta = readMetaJson() || { appliedId: "", entries: [] };
   meta.appliedId = uuid;
@@ -11758,22 +12485,22 @@ async function buildClaudeAppServerCatalog(entries, providersById, trace) {
 import {
   copyFileSync as copyFileSync3,
   existsSync as existsSync11,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync6,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync7,
   renameSync as renameSync2,
   rmSync as rmSync5,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync5
+  writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname4, join as join14 } from "path";
+import { dirname as dirname4, join as join15 } from "path";
 function getSessionLockPath2() {
-  return join14(getClaudeDesktopHome(), ".relay-ai.lock");
+  return join15(getClaudeDesktopHome(), ".relay-ai.lock");
 }
 function inspectSessionLock() {
   const path3 = getSessionLockPath2();
   if (!existsSync11(path3)) return { status: "missing" };
   try {
-    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path3, "utf8"));
     if (typeof parsed.pid === "number" && typeof parsed.startedAt === "string" && typeof parsed.uuid === "string" && typeof parsed.proxyPort === "number") {
       return { status: "valid", lock: parsed };
     }
@@ -11784,9 +12511,9 @@ function inspectSessionLock() {
 function writeSessionLock2(lock) {
   const path3 = getSessionLockPath2();
   const tempPath = `${path3}.tmp.${process.pid}`;
-  mkdirSync6(dirname4(path3), { recursive: true });
+  mkdirSync7(dirname4(path3), { recursive: true });
   try {
-    writeFileSync5(tempPath, `${JSON.stringify(lock, null, 2)}
+    writeFileSync6(tempPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
     renameSync2(tempPath, path3);
   } finally {
@@ -11821,7 +12548,7 @@ function restoreMetaJson() {
   }
 }
 function removeRelayAiConfig(uuid) {
-  const configPath = join14(getConfigLibraryPath(), `${uuid}.json`);
+  const configPath = join15(getConfigLibraryPath(), `${uuid}.json`);
   if (existsSync11(configPath)) {
     try {
       rmSync5(configPath, { force: true });
@@ -12139,17 +12866,17 @@ ${pc11.bold("Claude Desktop 3P Mode Active")}`);
 }
 
 // src/ai-doc.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var SKILL_DIR_NAME = "relay-ai-cli";
 var SKILL_INSTALL_DIRS = [
-  join15(getAppHome(), "skills"),
-  join15(homedir10(), ".claude", "skills"),
-  join15(homedir10(), ".agents", "skills"),
-  join15(homedir10(), ".codex", "skills"),
-  join15(homedir10(), ".cursor", "skills"),
-  join15(homedir10(), ".cursor", "skills-cursor")
+  join16(getAppHome(), "skills"),
+  join16(homedir10(), ".claude", "skills"),
+  join16(homedir10(), ".agents", "skills"),
+  join16(homedir10(), ".codex", "skills"),
+  join16(homedir10(), ".cursor", "skills"),
+  join16(homedir10(), ".cursor", "skills-cursor")
 ];
 function parseSkillVersion(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
@@ -12163,10 +12890,10 @@ function parseSkillVersion(content) {
   return null;
 }
 function readInstalledSkillVersion(skillDir) {
-  const skillPath = join15(skillDir, "SKILL.md");
+  const skillPath = join16(skillDir, "SKILL.md");
   if (!existsSync12(skillPath)) return null;
   try {
-    const head = readFileSync7(skillPath, "utf-8").slice(0, 1024);
+    const head = readFileSync8(skillPath, "utf-8").slice(0, 1024);
     return parseSkillVersion(head.includes("---", 4) ? head : `${head}
 ---
 `);
@@ -12176,8 +12903,8 @@ function readInstalledSkillVersion(skillDir) {
 }
 function skillInstallTargets() {
   return SKILL_INSTALL_DIRS.map((dir) => {
-    const skillDir = join15(dir, SKILL_DIR_NAME);
-    return { skillDir, skillPath: join15(skillDir, "SKILL.md") };
+    const skillDir = join16(dir, SKILL_DIR_NAME);
+    return { skillDir, skillPath: join16(skillDir, "SKILL.md") };
   });
 }
 function formatProviderModels(provider) {
@@ -12681,8 +13408,8 @@ function installAiDoc(opts = {}) {
         result.skipped.push(skillPath);
         continue;
       }
-      mkdirSync7(skillDir, { recursive: true });
-      writeFileSync6(skillPath, doc, "utf-8");
+      mkdirSync8(skillDir, { recursive: true });
+      writeFileSync7(skillPath, doc, "utf-8");
       if (previous) {
         result.updated.push({ path: skillPath, fromVersion: previous });
       } else {
@@ -12840,18 +13567,18 @@ function buildHttpProxyChildEnv(baseEnv, proxyUrl, caCertPath) {
 }
 
 // src/http-proxy/ca.ts
-import { randomBytes as randomBytes2, randomUUID as randomUUID3 } from "crypto";
+import { randomBytes as randomBytes2, randomUUID as randomUUID4 } from "crypto";
 import {
-  chmodSync as chmodSync2,
+  chmodSync as chmodSync3,
   existsSync as existsSync13,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync8,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync3,
   rmSync as rmSync6,
   statSync as statSync3,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname6, join as join17, resolve } from "path";
+import { dirname as dirname6, join as join18, resolve } from "path";
 import forge from "node-forge";
 var SESSION_ROOT = "http-proxy-sessions";
 var OWNER_FILE = "owner.pid";
@@ -12871,22 +13598,22 @@ function processIsRunning(pid) {
   }
 }
 function cleanupStaleHttpProxySessions(appHome = getAppHome()) {
-  const root = join17(appHome, SESSION_ROOT);
+  const root = join18(appHome, SESSION_ROOT);
   if (!existsSync13(root)) return;
   const now = Date.now();
   for (const name of readdirSync3(root)) {
-    const sessionDir = join17(root, name);
+    const sessionDir = join18(root, name);
     try {
       const stat = statSync3(sessionDir);
       if (!stat.isDirectory()) continue;
-      const ownerPath = join17(sessionDir, OWNER_FILE);
+      const ownerPath = join18(sessionDir, OWNER_FILE);
       if (!existsSync13(ownerPath)) {
         if (now - stat.mtimeMs > MID_CREATION_GRACE_MS) {
           rmSync6(sessionDir, { recursive: true, force: true });
         }
         continue;
       }
-      const pid = Number(readFileSync8(ownerPath, "utf8").trim());
+      const pid = Number(readFileSync9(ownerPath, "utf8").trim());
       if (!Number.isSafeInteger(pid) || pid <= 0) {
         const ownerStat = statSync3(ownerPath);
         const newestMtimeMs = Math.max(stat.mtimeMs, ownerStat.mtimeMs);
@@ -12902,13 +13629,13 @@ function cleanupStaleHttpProxySessions(appHome = getAppHome()) {
 }
 function createHttpProxyCertificates(appHome = getAppHome()) {
   cleanupStaleHttpProxySessions(appHome);
-  const root = join17(appHome, SESSION_ROOT);
-  mkdirSync9(root, { recursive: true, mode: 448 });
-  chmodSync2(root, 448);
-  const sessionDir = join17(root, randomUUID3());
-  mkdirSync9(sessionDir, { mode: 448 });
-  chmodSync2(sessionDir, 448);
-  writeFileSync8(join17(sessionDir, OWNER_FILE), `${process.pid}
+  const root = join18(appHome, SESSION_ROOT);
+  mkdirSync10(root, { recursive: true, mode: 448 });
+  chmodSync3(root, 448);
+  const sessionDir = join18(root, randomUUID4());
+  mkdirSync10(sessionDir, { mode: 448 });
+  chmodSync3(sessionDir, 448);
+  writeFileSync9(join18(sessionDir, OWNER_FILE), `${process.pid}
 `, { mode: 384 });
   try {
     const caKeys = forge.pki.rsa.generateKeyPair(2048);
@@ -12943,9 +13670,9 @@ function createHttpProxyCertificates(appHome = getAppHome()) {
     ]);
     server.sign(caKeys.privateKey, forge.md.sha256.create());
     const caCert = forge.pki.certificateToPem(ca);
-    const caCertPath = join17(sessionDir, "relay-ai-ca.pem");
-    writeFileSync8(caCertPath, caCert, { encoding: "utf8", mode: 384 });
-    chmodSync2(caCertPath, 384);
+    const caCertPath = join18(sessionDir, "relay-ai-ca.pem");
+    writeFileSync9(caCertPath, caCert, { encoding: "utf8", mode: 384 });
+    chmodSync3(caCertPath, 384);
     let cleaned = false;
     const cleanupOnExit = () => {
       if (cleaned) return;
@@ -12986,18 +13713,18 @@ function createHttpProxyCaBundle(relayCaCertPath, additionalCaCertPath) {
   if (resolve(additionalCaCertPath) === resolve(relayCaCertPath)) {
     return relayCaCertPath;
   }
-  const relayCa = readFileSync8(relayCaCertPath, "utf8").trimEnd();
-  const additionalCa = readFileSync8(additionalCaCertPath, "utf8").trim();
+  const relayCa = readFileSync9(relayCaCertPath, "utf8").trimEnd();
+  const additionalCa = readFileSync9(additionalCaCertPath, "utf8").trim();
   if (!additionalCa) return relayCaCertPath;
-  const combinedPath = join17(dirname6(relayCaCertPath), "combined-ca.pem");
-  writeFileSync8(
+  const combinedPath = join18(dirname6(relayCaCertPath), "combined-ca.pem");
+  writeFileSync9(
     combinedPath,
     `${relayCa}
 ${additionalCa}
 `,
     { encoding: "utf8", mode: 384 }
   );
-  chmodSync2(combinedPath, 384);
+  chmodSync3(combinedPath, 384);
   return combinedPath;
 }
 
@@ -13761,6 +14488,10 @@ function parseArgs(args) {
         parsed2.vertex = true;
         continue;
       }
+      if (arg === "--yes" || arg === "-y") {
+        parsed2.assumeYes = true;
+        continue;
+      }
       if (arg === "--with-native") {
         if (parsed2.codexLaunchMode === "relay-only") parsed2.error = "--with-native and --relay-only cannot be used together";
         parsed2.codexLaunchMode = "mixed";
@@ -15008,7 +15739,7 @@ Options:
   --trace    Write debug logs under ~/.relay-ai/logs/`);
       return 0;
     }
-    const { runUiCommand } = await import("./ui-command-OIY4243G.js");
+    const { runUiCommand } = await import("./ui-command-NYYLGTCD.js");
     return runUiCommand({ trace: parsed.trace, serverMode: parsed.uiServerMode });
   }
   if (parsed.command === "models") {
@@ -15051,7 +15782,7 @@ Options:
       console.log(codexAppHelpText());
       return 0;
     }
-    return runCodexAppCommand(parsed.claudeArgs, { vertex: parsed.vertex, launchProvider: parsed.launchProvider, launchModel: parsed.launchModel, codexLaunchMode: parsed.codexLaunchMode });
+    return runCodexAppCommand(parsed.claudeArgs, { vertex: parsed.vertex, launchProvider: parsed.launchProvider, launchModel: parsed.launchModel, codexLaunchMode: parsed.codexLaunchMode, assumeYes: parsed.assumeYes });
   }
   if (parsed.command === "claude-app") {
     if (parsed.showVersion) {
@@ -15073,7 +15804,7 @@ Options:
       console.log(codexHelpText());
       return 0;
     }
-    return runCodexCommand(parsed.claudeArgs, parsed.trace, {
+    return runCodexCommand2(parsed.claudeArgs, parsed.trace, {
       launchProvider: parsed.launchProvider,
       launchModel: parsed.launchModel,
       vertex: parsed.vertex,