@bitkyc08/opencodex 2.65.0 → 2.66.0

package/src/server/responses/core-combo-native.ts

@@ -0,0 +1,323 @@
+/**
+ * Native Chat candidates inside the combo loop (PF-07).
+ *
+ * The Chat ingress hands the combo a `ComboProtocolSource` only for a combo route with
+ * `protocols.rollout.nativeChatCombos` on; without one nothing here runs. For the candidate the
+ * combo is about to dispatch, the concrete route is settled the way the Chat ingress settles a
+ * single route, and the native Chat lane's own eligibility rule decides whether the child goes
+ * native. A native child runs `runNativeChatAttempt` (through the source) on the attempt the combo
+ * already opened, with the combo's per-target budget, the client's abort signal and the turn
+ * lease, built from a fresh copy of the source body; every other candidate keeps the bridge.
+ * Under `unrepresentable: "reject"` a candidate whose path would drop a requested feature is never
+ * picked, and a combo whose every enabled candidate is skipped answers the ingress refusal.
+ *
+ * No `./` sibling import on purpose: `core-options.ts` names this module's types, so an edge back
+ * into the owner graph would close a cycle.
+ */
+import type { OcxConfig } from "../../types";
+import type { RouteResult } from "../../router";
+import type { DataPlaneAdmission } from "../auth-cors";
+import type { AdmissionLease } from "../../lib/admission";
+import type { RequestExecutionBudget } from "../../lib/request-execution-budget";
+import type { TransientSendBudget } from "../../lib/upstream-retry";
+import type { ResponsesTerminalStatus } from "../../bridge";
+import type { NativeChatFinishLog } from "../chat-native";
+import type { InferenceAttempt } from "../inference/attempt";
+import type { ProtocolEnvelope } from "../../protocols/envelope";
+import type { ProtocolFeature } from "../../protocols/features";
+import type { PersistedUsageAttempt } from "../../usage/log";
+import {
+  finishRequestAttempt,
+  sealRequestAttemptIdentity,
+  type RequestLogContext,
+} from "../request-log";
+import { captureRouteStaticPolicy, routeConcreteModel } from "../../router";
+import { comboDefaultEffort, concreteComboRequestBody, getCombo } from "../../combos";
+import { supportedLadderFor } from "../effort-policy";
+import { resolveWireProtocolOverride } from "../adapter-resolve";
+import { resolveOpenCodeGoTransport } from "../../providers/opencode-go-transport";
+import { getOrAllocateRequestSessionLane } from "../request-log-conversation";
+import { assertRouteAllowedByScope, resolveAdmissionModelScope } from "../admission-model-scope";
+import { isNativeChatRouteEligible } from "../chat-native-eligibility";
+import { chatCompletionsErrorResponse } from "../../chat/outbound";
+import { isRequestExecutionBudget } from "../../lib/request-execution-budget";
+import { markResponseNonReplayable } from "../../lib/upstream-retry";
+import { redactSecretString } from "../../lib/redact";
+import { upstreamWireForAdapter } from "../../protocols/contract";
+import { checkRepresentable, unrepresentableMessage } from "../../protocols/guard";
+import { deliveryModeForLane, requestPathForLane } from "../../protocols/path";
+import { resolveProtocolSettings } from "../../protocols/settings";
+import { addProtocolEntryReason, markAttemptProtocolPath, markProtocolBlocked } from "../../protocols/trace";
+import { markClientWire } from "../inference/client-wire";
+
+type Rec = Record<string, unknown>;
+type ComboTarget = { provider: string; model: string };
+
+/** What the source needs to run one native child on the combo's open attempt. */
+export interface NativeComboChildRun {
+  route: RouteResult;
+  /** A fresh copy of the source Chat body, never another candidate's rewritten one. */
+  body: Rec;
+  childLog: RequestLogContext;
+  attemptHandle: InferenceAttempt;
+  sendBudget: RequestExecutionBudget;
+  turnAdmissionLease?: AdmissionLease;
+  onFirstOutput: () => void;
+  /** Reports to the combo's child callbacks; it never writes the parent's final row itself. */
+  finishLog: NativeChatFinishLog;
+}
+
+/** Supplied by the Chat ingress for a combo route when `nativeChatCombos` is on. */
+export interface ComboProtocolSource {
+  readonly inbound: "chat";
+  readonly envelope: ProtocolEnvelope;
+  /** Runs `runNativeChatAttempt`; the response it returns is in the Chat wire. */
+  dispatchNativeChild(input: NativeComboChildRun): Promise<Response>;
+}
+
+/** The native plan for one dispatch: the settled route and its own fresh body. */
+export interface NativeComboChildPlan {
+  route: RouteResult;
+  body: Rec;
+  sendBudget: RequestExecutionBudget;
+}
+
+export interface ComboProtocolLanes {
+  /** Pick predicate. False only for a candidate the `reject` policy skips. */
+  pickable(target: ComboTarget): boolean;
+  /** The ingress refusal when every enabled candidate was skipped; otherwise undefined. */
+  refusal(): Response | undefined;
+  /** The native plan for the candidate about to dispatch, or undefined to keep the bridge. */
+  nativeChild(
+    target: ComboTarget,
+    targetRoute: RouteResult,
+    targetSendBudget: TransientSendBudget | undefined,
+  ): NativeComboChildPlan | undefined;
+}
+
+interface CandidateVerdict {
+  skip?: ProtocolFeature[];
+}
+
+export function createComboProtocolLanes(input: {
+  source: ComboProtocolSource | undefined;
+  req: Request;
+  config: OcxConfig;
+  logCtx: RequestLogContext;
+  admission: DataPlaneAdmission | undefined;
+  comboId: string;
+  targets: readonly ComboTarget[];
+}): ComboProtocolLanes | undefined {
+  const { source, req, config, logCtx, admission, comboId, targets } = input;
+  if (!source) return undefined;
+  const envelope = source.envelope;
+  const reject = resolveProtocolSettings(config).unrepresentable === "reject";
+  const selector = (target: ComboTarget): string => `${target.provider}/${target.model}`;
+
+  // The Chat ingress's own settlement of a single route, applied to the concrete target: the
+  // key's model scope, the static policy captured for a Chat inbound, the wire override and the
+  // OpenCode Go transport. A refusal here keeps the bridge, which reports it in its own shape.
+  const settle = (target: ComboTarget, targetRoute: RouteResult): RouteResult | undefined => {
+    try {
+      const route: RouteResult = { ...targetRoute };
+      assertRouteAllowedByScope(resolveAdmissionModelScope(config, admission), selector(target), route);
+      const routedProvider = route.provider;
+      route.staticPolicy = captureRouteStaticPolicy(
+        route.providerName, route.modelId, routedProvider, route.staticPolicy.effectiveAlias, "chat",
+      );
+      const wireProvider = resolveWireProtocolOverride(route.providerName, route.modelId, routedProvider, "chat", route.staticPolicy);
+      route.provider = resolveOpenCodeGoTransport(wireProvider, getOrAllocateRequestSessionLane(req), routedProvider);
+      return route;
+    } catch {
+      return undefined;
+    }
+  };
+
+  // Eligibility reads a body, and a body is a charged copy, so the adapter is checked first:
+  // a candidate that can never go native costs no copy at all.
+  const nativeBody = (target: ComboTarget, route: RouteResult | undefined): Rec | undefined => {
+    if (!route || route.provider.adapter !== "openai-chat") return undefined;
+    const body = envelope.freshBody();
+    // The concrete selector, as the bridge child's body carries it; the wire model comes from
+    // the route either way, and the pinned-effort lookup reads this.
+    body.model = selector(target);
+    return isNativeChatRouteEligible(route, body, config) ? body : undefined;
+  };
+
+  const verdicts = new Map<string, CandidateVerdict>();
+  let skipRecorded = false;
+  const judge = (target: ComboTarget): CandidateVerdict => {
+    const key = selector(target);
+    const cached = verdicts.get(key);
+    if (cached) return cached;
+    let verdict: CandidateVerdict = {};
+    let targetRoute: RouteResult | undefined;
+    try {
+      targetRoute = routeConcreteModel(config, key);
+    } catch {
+      // Not evidence about the path; dispatch keeps the existing routing failure surface.
+      targetRoute = undefined;
+    }
+    if (targetRoute) {
+      const settled = settle(target, targetRoute);
+      const native = nativeBody(target, settled) !== undefined;
+      const upstream = native ? "chat" : upstreamWireForAdapter((settled ?? targetRoute).provider.adapter);
+      const checked = checkRepresentable({
+        inbound: "chat",
+        requestPath: requestPathForLane("chat", native ? "native" : "bridge", upstream),
+        features: envelope.features(),
+        policy: "reject",
+      });
+      if (!checked.ok) {
+        verdict = { skip: checked.features };
+        if (!skipRecorded) {
+          skipRecorded = true;
+          addProtocolEntryReason(logCtx, "feature-unrepresentable");
+        }
+      }
+    }
+    verdicts.set(key, verdict);
+    return verdict;
+  };
+
+  return {
+    pickable: target => !reject || judge(target).skip === undefined,
+    refusal: () => {
+      if (!reject) return undefined;
+      const enabled = targets.filter(target => {
+        const provider = config.providers[target.provider];
+        return provider !== undefined && provider.disabled !== true;
+      });
+      if (enabled.length === 0) return undefined;
+      const skipped = enabled.map(judge);
+      if (skipped.some(verdict => verdict.skip === undefined)) return undefined;
+      const features = [...new Set(skipped.flatMap(verdict => verdict.skip ?? []))];
+      // The same refusal the ingress gives a single route: 400 in the Chat shape, feature keys
+      // only, a blocked trace, and no upstream send.
+      markProtocolBlocked(logCtx, { inbound: "chat", reasonCodes: ["feature-unrepresentable"], features });
+      logCtx.errorCode = "unsupported_feature";
+      return markClientWire(chatCompletionsErrorResponse(
+        400, unrepresentableMessage(features), "invalid_request_error", "unsupported_feature",
+      ), "chat");
+    },
+    nativeChild: (target, targetRoute, targetSendBudget) => {
+      // Without the request's execution budget a native child could not share its sends, so it
+      // keeps the bridge rather than opening a tracker of its own.
+      if (!isRequestExecutionBudget(targetSendBudget)) return undefined;
+      const route = settle(target, targetRoute);
+      const body = nativeBody(target, route);
+      if (!route || !body) return undefined;
+      applyComboEffort(body, config, comboId, target, targetRoute);
+      return { route, body, sendBudget: targetSendBudget };
+    },
+  };
+}
+
+/**
+ * The combo's reasoning-effort policy, applied to the Chat spelling of the same field.
+ *
+ * The bridge child gets it from `concreteComboRequestBody` on the Responses body; a native child
+ * must not lose a forced or default effort just because it skipped that body. The same function
+ * decides, through a one-field Responses view, so the two lanes cannot disagree.
+ */
+function applyComboEffort(
+  body: Rec,
+  config: OcxConfig,
+  comboId: string,
+  target: ComboTarget,
+  targetRoute: RouteResult,
+): void {
+  const combo = getCombo(config, comboId);
+  if (!combo) return;
+  const hadEffort = Object.hasOwn(body, "reasoning_effort");
+  const shaped = concreteComboRequestBody(
+    hadEffort ? { reasoning: { effort: body.reasoning_effort } } : {},
+    target,
+    comboDefaultEffort(config, comboId),
+    supportedLadderFor({ provider: targetRoute.provider, modelId: targetRoute.modelId }),
+    combo.reasoningEffortMode,
+    combo.defaultEffortMode,
+  );
+  const reasoning = shaped.reasoning;
+  if (reasoning === undefined) {
+    if (hadEffort) delete body.reasoning_effort;
+    return;
+  }
+  const effort = (reasoning as { effort?: unknown }).effort;
+  if (typeof effort === "string") body.reasoning_effort = effort;
+}
+
+/** The combo's child callbacks, gated so a discarded attempt never reaches the parent. */
+export interface ComboChildCallbacks {
+  onTerminal(status: ResponsesTerminalStatus): void;
+  onCancel(): void;
+  onResponseComplete(model: string): void;
+}
+
+/**
+ * Run one native child on the attempt the combo opened, and mark its answer as Chat wire.
+ *
+ * The child's outcomes map onto the combo's existing child callbacks: a terminal or cancellation
+ * after the response was handed over publishes through the gate (and so reaches the parent's
+ * final-row owner only once the combo commits), while a failure answered before that is left to
+ * the combo's ordinary failure path. A non-OK answer produced after output was observed is marked
+ * non-replayable, so the combo stops instead of re-running a turn that already ran upstream.
+ */
+export async function dispatchNativeComboChild(input: {
+  source: ComboProtocolSource;
+  plan: NativeComboChildPlan;
+  logCtx: RequestLogContext;
+  childLog: RequestLogContext;
+  attempt: PersistedUsageAttempt;
+  startedAt: number;
+  turnAdmissionLease?: AdmissionLease;
+  onFirstOutput: () => void;
+  callbacks: ComboChildCallbacks;
+}): Promise<Response> {
+  const { plan, logCtx, childLog, attempt, startedAt, callbacks } = input;
+  childLog.providerAdapter = plan.route.provider.adapter;
+  markAttemptProtocolPath(attempt, {
+    mode: deliveryModeForLane("chat", "native", "chat"),
+    requestPath: requestPathForLane("chat", "native", "chat"),
+  });
+  let outputSeen = false;
+  const finishLog: NativeChatFinishLog = (status, message, closeReason = "non_stream") => {
+    if (message) childLog.upstreamError = redactSecretString(message).slice(0, 500);
+    if (closeReason !== "non_stream") {
+      // A streamed body ends after the combo merged this child into the parent row, so what the
+      // stream learned last is carried across here before the parent's row is written.
+      if (childLog.usage !== undefined) logCtx.usage = childLog.usage;
+      if (closeReason === "client_cancel") return callbacks.onCancel();
+    }
+    if (status < 400) {
+      callbacks.onTerminal("completed");
+      callbacks.onResponseComplete(plan.route.modelId);
+      return;
+    }
+    if (closeReason === "terminal") {
+      childLog.terminalHttpStatus = status;
+      callbacks.onTerminal("failed");
+    }
+  };
+  const attemptHandle: InferenceAttempt = {
+    attempt,
+    startedAt,
+    seal: label => sealRequestAttemptIdentity(attempt, childLog.provider, childLog.providerAdapter ?? attempt.adapter, label),
+    finish: (status, usage) => finishRequestAttempt(attempt, status, Date.now() - startedAt, usage),
+  };
+  const response = await input.source.dispatchNativeChild({
+    route: plan.route,
+    body: plan.body,
+    childLog,
+    attemptHandle,
+    sendBudget: plan.sendBudget,
+    ...(input.turnAdmissionLease ? { turnAdmissionLease: input.turnAdmissionLease } : {}),
+    onFirstOutput: () => {
+      outputSeen = true;
+      input.onFirstOutput();
+    },
+    finishLog,
+  });
+  if (!response.ok && outputSeen) markResponseNonReplayable(response);
+  return markClientWire(response, "chat");
+}

package/src/server/responses/core-combo.ts

@@ -1,4 +1,8 @@
-import { isDeclaredReasoningEffort } from "../../reasoning-effort";
+import {
+  isCodexReasoningEffort,
+  isDeclaredReasoningEffort,
+  resolveEffortAtOrBelow,
+} from "../../reasoning-effort";
 import { recordAttemptRequestedEffort } from "../request-log";
 import {
   CODEX_TEXT_GUARDED_BUDGET_POLICY,
@@ -9,13 +13,14 @@ import type {
   RequestExecutionBudgetPolicy,
   RequestExecutionBudget,
 } from "../../lib/request-execution-budget";
-import type { OcxConfig } from "../../types";
+import type { OcxComboDefaultEffort, OcxConfig } from "../../types";
 import type { RequestLogContext } from "../request-log";
 import type { HandleResponsesOptions, ResponsesDispatchers, ConsumedComboFailure } from "./core-options";
 import type { TranslatorBudget } from "../../lib/translator-budget";
 import {
   getCombo,
   comboRequestHasImageInput,
+  pickComboTarget,
   pickComboTargetWithWait,
   targetKey,
   concreteComboRequestBody,
@@ -25,6 +30,11 @@ import {
   comboFailureDecision,
   advanceComboAfterFailure,
   comboFailureCooldownScope,
+  JEV_PROVIDER_ID,
+  resolveJevDecision,
+  type ComboPick,
+  type JevCandidate,
+  type JevDecision,
 } from "../../combos";
 import { formatErrorResponse } from "../../bridge";
 import { SEND_BUDGET_EXHAUSTED_CODE } from "../../lib/errors";
@@ -65,6 +75,7 @@ import type { ResponsesTerminalStatus } from "../../bridge";
 import { beginRequestAttempt, sealRequestAttemptIdentity, finishRequestAttempt } from "../request-log";
 import { rememberComboForLane } from "./combo-session-recall";
 import { runTurnAdapterSseResponses } from "./core-lifetime";
+import { normalizePersistedJevDecision } from "../../usage/jev-stats";
 import {
   isNativePassthroughSseResponse,
   isEagerRelaySseResponse,
@@ -75,6 +86,8 @@ import { preflightComboStreamResponse } from "./combo-stream-preflight";
 import { streamingContextOverflowResponse, jsonContextOverflowResponse } from "./context-overflow";
 import { mandatoryResponsesReasoningReplayUnavailable } from "./core-replay";
 import { settleOperatorReplacement } from "../../lib/upstream-retry";
+import { createComboProtocolLanes, dispatchNativeComboChild } from "./core-combo-native";
+import { clientWireOf } from "../inference/client-wire";
 
 /**
  * Sends one combo target may run on its own before the ladder moves on. A target is a whole
@@ -166,6 +179,65 @@ export function comboTargetSendBudget(
   });
 }
 
+interface JevComboChoice {
+  pick: ComboPick;
+  candidate: JevCandidate;
+}
+
+/** Enumerate the current ordinary Combo eligibility set without retaining attempted picks. */
+function eligibleJevComboChoices(
+  config: OcxConfig,
+  comboId: string,
+  eligible: (target: NonNullable<ReturnType<typeof getCombo>>["targets"][number]) => boolean,
+  now: number,
+): JevComboChoice[] {
+  const combo = getCombo(config, comboId);
+  if (!combo) return [];
+  const excluded = new Set<string>();
+  const choices: JevComboChoice[] = [];
+  while (excluded.size < combo.targets.length) {
+    const pick = pickComboTarget(config, comboId, { exclude: excluded, eligible, now });
+    if (!pick) break;
+    const key = targetKey(pick.target);
+    excluded.add(key);
+    // The TypeSafe row owns a decision credential, not an inference transport.
+    if (pick.target.provider === JEV_PROVIDER_ID) continue;
+    let ladder: string[] | undefined;
+    try {
+      const route = routeConcreteModel(config, key);
+      ladder = supportedLadderFor({ provider: route.provider, modelId: route.modelId });
+    } catch {
+      // Preserve the existing routing-failure surface. Unknown capability becomes the explicit
+      // no-effort choice rather than broadening JEV's effort allowlist.
+      ladder = undefined;
+    }
+    const supportedEfforts = (ladder ?? []).filter(isCodexReasoningEffort) as OcxComboDefaultEffort[];
+    const configuredEfforts = pick.target.reasoningEfforts;
+    const reasoningEfforts = configuredEfforts === undefined
+      ? supportedEfforts
+      : configuredEfforts.filter(effort => supportedEfforts.includes(effort));
+    // An explicit allowlist is restrictive. If catalog capabilities drift until no configured
+    // effort remains supported, omit the target instead of silently broadening JEV's choices.
+    if (configuredEfforts !== undefined && reasoningEfforts.length === 0) continue;
+    choices.push({
+      pick: { ...pick, attempted: [key] },
+      candidate: {
+        key,
+        provider: pick.target.provider,
+        model: pick.target.model,
+        reasoningEfforts,
+      },
+    });
+  }
+  // #5691: the synchronous pick above does not defer emergency-only targets, so apply the
+  // same rule here — withhold them from JEV while any normal target is offered, never when
+  // they are all that remains.
+  if (combo.cooldownWaitPolicy === "before-last-resort" && choices.some(choice => !choice.pick.target.lastResort)) {
+    return choices.filter(choice => !choice.pick.target.lastResort);
+  }
+  return choices;
+}
+
 
 /** Dispatch a Responses combo within its shared send budget and preserve terminal child failures. */
 export async function executeComboResponses(
@@ -190,6 +262,17 @@ export async function executeComboResponses(
   if (!combo) {
     return formatErrorResponse(404, "invalid_request_error", `Unknown combo: ${comboId}`);
   }
+  // PF-07: present only for a Chat combo with `nativeChatCombos` on; otherwise every child
+  // takes the bridge below exactly as before.
+  const protocolLanes = createComboProtocolLanes({
+    source: options.protocolSource,
+    req,
+    config,
+    logCtx,
+    admission: options.admission,
+    comboId,
+    targets: combo.targets,
+  });
   // The ladder's own scope, derived from what this combo DECLARES. It shares the request-wide
   // counter with the holder that arrived on options -- a combo child already inherited that
   // counter, but nothing read it as a limit across targets -- while its transition and
@@ -298,7 +381,10 @@ export async function executeComboResponses(
   const payloadEligible = (target: (typeof combo.targets)[number]): boolean =>
     comboPayloadReadable || !unreadableEncryptedAgentTask || canDecryptUnreadableAgentTask(target);
   const targetEligible = (target: (typeof combo.targets)[number]): boolean =>
-    payloadEligible(target) && reasoningReplayEligible(target);
+    (combo.strategy !== "jev" || target.provider !== JEV_PROVIDER_ID)
+    && payloadEligible(target)
+    && reasoningReplayEligible(target)
+    && (protocolLanes?.pickable(target) ?? true);
   const onlyReplayIncompatibleTargetsRemain = (excluded: Iterable<string> = []): boolean => {
     const excludedKeys = new Set(excluded);
     const remaining = combo.targets.filter(target => {
@@ -398,11 +484,78 @@ export async function executeComboResponses(
   }
 
   if (!pick) {
+    // Every enabled candidate skipped as unrepresentable: the ingress refusal, with no send.
+    const protocolRefusal = protocolLanes?.refusal();
+    if (protocolRefusal) return protocolRefusal;
     if (onlyReplayIncompatibleTargetsRemain()) return targetIncompatibleResponse();
     return options.abortSignal?.aborted
       ? clientCancelledResponse()
       : comboUnavailable(comboId);
   }
+  let jevDecision: JevDecision | undefined;
+  if (combo.strategy === "jev") {
+    const choices = eligibleJevComboChoices(config, comboId, targetEligible, Date.now());
+    const first = choices[0];
+    if (!first) return comboUnavailable(comboId);
+    const resolvedFailOpenEffort = resolveEffortAtOrBelow(
+      "medium",
+      first.candidate.reasoningEfforts,
+    );
+    const fallback: Pick<JevDecision, "targetKey" | "effort"> = {
+      targetKey: first.candidate.key,
+      effort: resolvedFailOpenEffort && isCodexReasoningEffort(resolvedFailOpenEffort)
+        ? resolvedFailOpenEffort as OcxComboDefaultEffort
+        : null,
+    };
+    const decisionStartedAt = Date.now();
+    let decision: JevDecision;
+    try {
+      decision = await resolveJevDecision({
+        body,
+        candidates: choices.map(choice => choice.candidate),
+        fallback,
+        config,
+        signal: options.abortSignal,
+      });
+    } catch (error) {
+      if (options.abortSignal?.aborted) return clientCancelledResponse();
+      decision = {
+        ...fallback,
+        gate: "network",
+        latencyMs: Math.max(0, Date.now() - decisionStartedAt),
+      };
+    }
+    jevDecision = decision;
+    const selected = choices.find(choice => choice.candidate.key === decision.targetKey) ?? first;
+    pick = { ...selected.pick, attempted: [targetKey(selected.pick.target)] };
+    logCtx.jevDecision = normalizePersistedJevDecision({
+      version: 1,
+      comboId,
+      selected: {
+        provider: selected.pick.target.provider,
+        model: selected.pick.target.model,
+        effort: decision.effort,
+      },
+      gate: decision.gate,
+      latencyMs: decision.latencyMs,
+      ...(decision.confidence !== undefined ? { confidence: decision.confidence } : {}),
+      ...(decision.chosenProbability !== undefined
+        ? { chosenProbability: decision.chosenProbability }
+        : {}),
+      ...(decision.usage ? { usage: decision.usage } : {}),
+    });
+    console.debug("[combo] JEV decision", {
+      targetKey: decision.targetKey,
+      effort: decision.effort,
+      gate: decision.gate,
+      latencyMs: decision.latencyMs,
+      ...(decision.confidence !== undefined ? { confidence: decision.confidence } : {}),
+      ...(decision.chosenProbability !== undefined
+        ? { chosenProbability: decision.chosenProbability }
+        : {}),
+      ...(decision.usage ? { usage: decision.usage } : {}),
+    });
+  }
   // One immutable combo selection trace, before any child dispatch; child
   // adoption below must never replace it with a concrete child route trace.
   logCtx.routeDecision = comboRouteDecisionTrace(config, comboId, pick, requestedModel);
@@ -475,14 +628,32 @@ export async function executeComboResponses(
       ...(logCtx.surface ? { surface: logCtx.surface } : {}),
     };
     const targetRoute = routeConcreteModel(config, `${pick.target.provider}/${pick.target.model}`);
+    const targetReasoningEfforts = supportedLadderFor({
+      provider: targetRoute.provider,
+      modelId: targetRoute.modelId,
+    });
+    const initialJevDecision = firstComboTarget ? jevDecision : undefined;
     const childBody = concreteComboRequestBody(
       body,
       pick.target,
-      comboDefaultEffort(config, comboId),
-      supportedLadderFor({ provider: targetRoute.provider, modelId: targetRoute.modelId }),
+      initialJevDecision ? initialJevDecision.effort : comboDefaultEffort(config, comboId),
+      initialJevDecision?.effort === null ? [] : targetReasoningEfforts,
       combo.reasoningEffortMode,
-      combo.defaultEffortMode,
+      initialJevDecision !== undefined && initialJevDecision.effort !== null ? "force" : combo.defaultEffortMode,
     );
+    if (initialJevDecision) {
+      delete childBody.service_tier;
+      if (initialJevDecision.effort !== null) {
+        const childReasoning = childBody.reasoning;
+        const preservedReasoning = childReasoning && typeof childReasoning === "object" && !Array.isArray(childReasoning)
+          ? childReasoning as Record<string, unknown>
+          : {};
+        childBody.reasoning = { ...preservedReasoning, effort: initialJevDecision.effort };
+        delete childBody.reasoning_effort;
+        delete childBody.thinking_budget;
+        delete childBody.thinking;
+      }
+    }
     const childHeaders = buildComboChildHeaders(req.headers);
     const childRequest = new Request(req.url, {
       method: req.method,
@@ -550,14 +721,40 @@ export async function executeComboResponses(
     let response: Response;
     try {
       const currentTargetProvider = pick.target.provider;
-      const deferCodexResetDerivedCooldown = combo.strategy === "failover"
-        && combo.targets.slice(pick.targetIndex + 1).some(target =>
+      const remainingTargets = combo.strategy === "jev"
+        ? combo.targets.filter(target => !pick!.attempted.includes(targetKey(target)))
+        : combo.targets.slice(pick.targetIndex + 1);
+      const deferCodexResetDerivedCooldown = (combo.strategy === "failover" || combo.strategy === "jev")
+        && remainingTargets.some(target =>
           target.provider === currentTargetProvider
           && targetEligible(target)
           && !isComboTargetInCooldown(comboId, target),
         );
-      response = await requestDispatchers.handleResponses(childRequest, config, childLog, {
+      const nativeChild = protocolLanes?.nativeChild(pick.target, targetRoute, targetSendBudget);
+      response = nativeChild ? await dispatchNativeComboChild({
+        source: options.protocolSource!,
+        plan: nativeChild,
+        logCtx,
+        childLog,
+        attempt,
+        startedAt: started,
+        ...(options.turnAdmissionLease ? { turnAdmissionLease: options.turnAdmissionLease } : {}),
+        // Attempt-relative TTFT, recorded here for the same reason as the bridge child below.
+        onFirstOutput: () => {
+          if (attempt.firstOutputMs === undefined) {
+            attempt.firstOutputMs = Math.max(0, Date.now() - started);
+          }
+          options.onFirstOutput?.();
+        },
+        callbacks: {
+          onTerminal: callbackGate.onTerminal,
+          onCancel: callbackGate.onCancel,
+          onResponseComplete: callbackGate.onResponseComplete,
+        },
+      }) : await requestDispatchers.handleResponses(childRequest, config, childLog, {
         ...options,
+        // A bridge child is a concrete route; the native source belongs to this loop only.
+        ...(options.protocolSource ? { protocolSource: undefined } : {}),
         // After the spread: the child must run on THIS target's ladder, not on the holder the
         // parent arrived with.
         sendBudget: targetSendBudget,
@@ -597,7 +794,9 @@ export async function executeComboResponses(
       return clientCancelledResponse();
     }
 
-    if (response.ok && !runTurnAdapterSseResponses.has(response)) {
+    // A native Chat child reports a pre-stream failure by status before any byte, so its body
+    // is never peeked; a non-OK one takes the ordinary failure path below.
+    if (response.ok && !runTurnAdapterSseResponses.has(response) && clientWireOf(response) !== "chat") {
       const nativePassthrough = isNativePassthroughSseResponse(response);
       const eagerRelay = isEagerRelaySseResponse(response);
       let preflight;
@@ -754,19 +953,30 @@ export async function executeComboResponses(
     );
     const failureNow = Date.now();
     const attemptedTargets = pick.attempted;
+    const failureCooldownScope = comboFailureCooldownScope(failure.response.status, failure.classificationText, {
+      code: failure.upstreamCode,
+    });
+    const failedTargetKey = targetKey(pick.target);
+    let failedTargetCooldownRecorded = false;
     const nextPick = advanceComboAfterFailure(config, pick, {
       retryAfter: failure.retryAfter,
       resetAt: failure.resetAt,
       cooldownMs: combo.cooldownMs,
       now: failureNow,
-      cooldownScope: comboFailureCooldownScope(failure.response.status, failure.classificationText, {
-        code: failure.upstreamCode,
-      }),
+      cooldownScope: failureCooldownScope,
       eligible: targetEligible,
       status: failure.response.status,
       code: failure.upstreamCode,
       message: failure.classificationText,
+      onCooldownRecorded: target => {
+        failedTargetCooldownRecorded ||= targetKey(target) === failedTargetKey;
+      },
     });
+    // A sibling cooldown is not this failure's write: stale-generation removal can
+    // refuse recording even for a cooldown-producing classification. Require both.
+    const failedTargetCooled = failureCooldownScope !== "none"
+      && failedTargetCooldownRecorded
+      && isComboTargetInCooldown(comboId, pick.target, failureNow);
     // Same target selector as the exclusionary pick below, minus `exclude`: the only
     // difference is deliberate and is the whole point of the single-target retry.
     const retryAfterCooldown = () =>
@@ -797,6 +1007,7 @@ export async function executeComboResponses(
         && combo.targets.length === 1
         && combo.waitForCooldownMs > 0
         && comboTargetsDispatched <= 1
+        && failedTargetCooled
         && !options.abortSignal?.aborted
       ) {
         pick = await retryAfterCooldown();