@bitkyc08/opencodex 2.12.0 → 2.13.0

package/src/routing/profile.ts

@@ -14,6 +14,7 @@ import type {
 import { codexAccountNamespaceEntries } from "../codex/account-namespaces";
 import { listComboIds, resolveComboId } from "../combos";
 import { hasOwnProvider } from "../config";
+import { MAX_COMPATIBILITY_REQUIRED_SUITES } from "./compatibility/types";
 import { POLICY_NAMESPACE } from "./profile-namespace";
 
 export { POLICY_NAMESPACE };
@@ -36,6 +37,17 @@ export const DEFAULT_UNKNOWN_EVIDENCE: Record<"capability" | "health" | "quota"
   cost: "penalize",
 };
 
+export const DEFAULT_DEGRADED_EVIDENCE: OcxRoutingUnknownEvidenceMode = "penalize";
+export const DEFAULT_COMPATIBILITY_UNKNOWN_EVIDENCE: OcxRoutingUnknownEvidenceMode = "exclude";
+
+export interface NormalizedRoutingProfileCompatibility {
+  requiredSuites: Array<{ suiteId: string; evidenceLayer: "protocol_conformance" | "live_route_compatibility" }>;
+  minStatus?: "PROBED" | "VERIFIED";
+  maxEvidenceAgeMs?: number;
+  unknownEvidence: OcxRoutingUnknownEvidenceMode;
+  degradedEvidence: OcxRoutingUnknownEvidenceMode;
+}
+
 export interface RoutingProfileValidationIssue {
   path: Array<string | number>;
   message: string;
@@ -63,6 +75,7 @@ export interface NormalizedRoutingProfile {
   optimize: { latency: number; health: number; cost: number; quota: number };
   limits: { maxEstimatedCostUsd?: number; onUnknownCost?: OcxRoutingUnknownCostCapMode };
   unknownEvidence: Record<"capability" | "health" | "quota" | "cost", OcxRoutingUnknownEvidenceMode>;
+  compatibility?: NormalizedRoutingProfileCompatibility;
   revision: string;
 }
 
@@ -80,6 +93,7 @@ const REQUIRE_KEYS = [
 ] as const;
 
 const UNKNOWN_EVIDENCE_KEYS = ["capability", "health", "quota", "cost"] as const;
+const EVIDENCE_LAYERS = new Set(["protocol_conformance", "live_route_compatibility"]);
 
 export function isValidPolicyId(id: string): boolean {
   return POLICY_ID_PATTERN.test(id);
@@ -153,8 +167,6 @@ function aliasIssues(
       message: "bare aliases in the OpenAI native family (gpt-*, o1-*, o3-*, o4-*, codex-*) are not allowed",
     });
   }
-  // Cross-namespace collisions: providers, combos, account namespaces, and
-  // sibling profile aliases all own public model ids that must stay unique.
   if (hasOwnProvider(config.providers, alias)) {
     issues.push({ path: ["alias"], message: `alias "${alias}" collides with configured provider name "${alias}"` });
   }
@@ -342,6 +354,72 @@ export function routingProfileIssues(
     }
   }
 
+  if (body.compatibility !== undefined) {
+    if (!body.compatibility || typeof body.compatibility !== "object" || Array.isArray(body.compatibility)) {
+      issues.push({ path: ["compatibility"], message: "compatibility must be an object" });
+    } else {
+      const compatibility = body.compatibility as Record<string, unknown>;
+      if (compatibility.requiredSuites !== undefined) {
+        if (!Array.isArray(compatibility.requiredSuites)) {
+          issues.push({ path: ["compatibility", "requiredSuites"], message: "requiredSuites must be an array" });
+        } else {
+          if (compatibility.requiredSuites.length > MAX_COMPATIBILITY_REQUIRED_SUITES) {
+            issues.push({
+              path: ["compatibility", "requiredSuites"],
+              message: `requiredSuites must contain at most ${MAX_COMPATIBILITY_REQUIRED_SUITES} entries`,
+            });
+          }
+          const seen = new Set<string>();
+          compatibility.requiredSuites.forEach((rawSuite, index) => {
+            if (!rawSuite || typeof rawSuite !== "object" || Array.isArray(rawSuite)) {
+              issues.push({ path: ["compatibility", "requiredSuites", index], message: "suite entry must be an object" });
+              return;
+            }
+            const suite = rawSuite as Record<string, unknown>;
+            const suiteId = typeof suite.suiteId === "string" ? suite.suiteId.trim() : "";
+            const layer = suite.evidenceLayer;
+            if (!suiteId) {
+              issues.push({ path: ["compatibility", "requiredSuites", index, "suiteId"], message: "suiteId is required" });
+            }
+            if (layer !== "protocol_conformance" && layer !== "live_route_compatibility") {
+              issues.push({
+                path: ["compatibility", "requiredSuites", index, "evidenceLayer"],
+                message: "evidenceLayer must be protocol_conformance or live_route_compatibility",
+              });
+            }
+            if (suiteId && typeof layer === "string" && EVIDENCE_LAYERS.has(layer)) {
+              const key = `${layer}:${suiteId}`;
+              if (seen.has(key)) {
+                issues.push({ path: ["compatibility", "requiredSuites", index], message: `duplicate required suite "${key}"` });
+              } else {
+                seen.add(key);
+              }
+            }
+          });
+        }
+      }
+      if (compatibility.minStatus !== undefined
+        && compatibility.minStatus !== "PROBED"
+        && compatibility.minStatus !== "VERIFIED") {
+        issues.push({ path: ["compatibility", "minStatus"], message: 'minStatus must be "PROBED" or "VERIFIED"' });
+      }
+      if (compatibility.maxEvidenceAgeMs !== undefined
+        && (typeof compatibility.maxEvidenceAgeMs !== "number"
+          || !Number.isInteger(compatibility.maxEvidenceAgeMs)
+          || compatibility.maxEvidenceAgeMs < 0)) {
+        issues.push({ path: ["compatibility", "maxEvidenceAgeMs"], message: "maxEvidenceAgeMs must be a non-negative integer" });
+      }
+      for (const key of ["unknownEvidence", "degradedEvidence"] as const) {
+        if (compatibility[key] !== undefined
+          && compatibility[key] !== "allow"
+          && compatibility[key] !== "penalize"
+          && compatibility[key] !== "exclude") {
+          issues.push({ path: ["compatibility", key], message: `${key} must be "allow", "penalize", or "exclude"` });
+        }
+      }
+    }
+  }
+
   return issues;
 }
 
@@ -372,6 +450,42 @@ function normalizedUnknownEvidence(raw: OcxRoutingProfileConfig): NormalizedRout
   return out;
 }
 
+function normalizedCompatibility(
+  raw: OcxRoutingProfileConfig,
+): NormalizedRoutingProfileCompatibility | undefined {
+  if (raw.compatibility === undefined) return undefined;
+  const compatibility = raw.compatibility;
+  const requiredSuites = (compatibility.requiredSuites ?? []).map(suite => ({
+    suiteId: suite.suiteId.trim(),
+    evidenceLayer: suite.evidenceLayer,
+  }));
+  const unknownEvidence = compatibility.unknownEvidence === "allow"
+    || compatibility.unknownEvidence === "penalize"
+    || compatibility.unknownEvidence === "exclude"
+    ? compatibility.unknownEvidence
+    : DEFAULT_COMPATIBILITY_UNKNOWN_EVIDENCE;
+  const degradedEvidence = compatibility.degradedEvidence === "allow"
+    || compatibility.degradedEvidence === "penalize"
+    || compatibility.degradedEvidence === "exclude"
+    ? compatibility.degradedEvidence
+    : DEFAULT_DEGRADED_EVIDENCE;
+
+  const hasControls = requiredSuites.length > 0
+    || compatibility.minStatus !== undefined
+    || compatibility.maxEvidenceAgeMs !== undefined
+    || compatibility.unknownEvidence !== undefined
+    || compatibility.degradedEvidence !== undefined;
+  if (!hasControls) return undefined;
+
+  return {
+    requiredSuites,
+    ...(compatibility.minStatus ? { minStatus: compatibility.minStatus } : {}),
+    ...(compatibility.maxEvidenceAgeMs !== undefined ? { maxEvidenceAgeMs: compatibility.maxEvidenceAgeMs } : {}),
+    unknownEvidence,
+    degradedEvidence,
+  };
+}
+
 function canonicalJson(value: unknown): string {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
@@ -390,6 +504,7 @@ export function normalizeRoutingProfile(id: string, raw: OcxRoutingProfileConfig
   const weights = { ...DEFAULT_PROFILE_WEIGHTS, ...(raw.optimize ?? {}) };
   const weightSum = weights.latency + weights.health + weights.cost + weights.quota;
   const safeSum = weightSum > 0 ? weightSum : 1;
+  const compatibility = normalizedCompatibility(raw);
   const profile: Omit<NormalizedRoutingProfile, "revision"> = {
     id,
     alias: alias || null,
@@ -413,6 +528,7 @@ export function normalizeRoutingProfile(id: string, raw: OcxRoutingProfileConfig
         : {}),
     },
     unknownEvidence: normalizedUnknownEvidence(raw),
+    ...(compatibility ? { compatibility } : {}),
   };
   return { ...profile, revision: profileRevision(profile) };
 }
@@ -427,7 +543,5 @@ export function getRoutingProfile(
 }
 
 export function listRoutingProfileIds(config: { routingProfiles?: Record<string, OcxRoutingProfileConfig> }): string[] {
-  // Code-unit comparison: deterministic across ICU versions/platforms, which
-  // matters for the API/CLI list contract (ids may contain ".", "_", "-").
   return Object.keys(config.routingProfiles ?? {}).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
 }

package/src/routing/trace.ts

@@ -102,6 +102,27 @@ export interface RouteCostEvidence {
   capOutcome?: RouteCostCapOutcome;
 }
 
+export interface RouteCompatibilitySuiteTrace {
+  suiteId: string;
+  evidenceLayer: string;
+  /** Privacy-safe prefix of the exact subject used for this layer/suite. */
+  subjectIdPrefix?: string;
+  verdict?: string;
+  minStatus?: string;
+  fresh?: boolean;
+  unknownPolicy?: string;
+  degradedPolicy?: string;
+  outcome: "satisfied" | "penalized" | "excluded" | "unknown";
+  reason?: string;
+}
+
+export interface RouteCompatibilityEvidence {
+  /** Legacy single-subject prefix retained for persisted trace compatibility. */
+  subjectIdPrefix?: string;
+  suites: RouteCompatibilitySuiteTrace[];
+  truncated?: true;
+}
+
 export interface RouteScoreEvidence {
   total: number;
   components: {
@@ -111,6 +132,7 @@ export interface RouteScoreEvidence {
     cost?: number;
     latency?: number;
     configuredPriority?: number;
+    compatibility?: number;
   };
 }
 
@@ -124,6 +146,7 @@ export interface RouteCandidateTrace {
   health?: RouteHealthEvidence;
   quota?: RouteQuotaEvidence;
   cost?: RouteCostEvidence;
+  compatibility?: RouteCompatibilityEvidence;
   score?: RouteScoreEvidence;
 }
 
@@ -149,6 +172,7 @@ export interface RouteDecisionTraceV1 {
     exclusions?: true;
     requirements?: true;
     strings?: true;
+    compatibility?: true;
   };
 }
 
@@ -202,6 +226,7 @@ export interface TraceCandidateInput {
   health?: RouteHealthEvidence;
   quota?: RouteQuotaEvidence;
   cost?: RouteCostEvidence;
+  compatibility?: RouteCompatibilityEvidence;
 }
 
 export interface TraceBuildInput {
@@ -222,18 +247,23 @@ export interface TraceBuildInput {
   now?: number;
 }
 
+interface ParseCaps {
+  candidates?: true;
+  exclusions?: true;
+  requirements?: true;
+  strings?: true;
+  compatibility?: true;
+}
+
 /** Bounded candidate copy: strings capped, exclusions sliced, score/evidence kept. */
-function buildCandidate(input: TraceCandidateInput, budget: { strings?: true; exclusions?: true }): RouteCandidateTrace {
+function buildCandidate(input: TraceCandidateInput, budget: ParseCaps): RouteCandidateTrace {
   const exclusions = input.exclusions.slice(0, MAX_EXCLUSIONS_PER_CANDIDATE);
   if (exclusions.length < input.exclusions.length) budget.exclusions = true;
-  // Evidence reaches the builder from internal producers (bounded) or from
-  // caller-supplied dry-run input (unbounded). Whitelist + bound it through
-  // the same parsers the persisted-row normalizer uses so no unknown nested
-  // field or oversized string survives into the trace.
   const capability = input.capability ? parseCapability(input.capability, budget) : undefined;
   const health = input.health ? parseHealth(input.health) : undefined;
   const quota = input.quota ? parseQuota(input.quota, budget) : undefined;
   const cost = input.cost ? parseCost(input.cost, budget) : undefined;
+  const compatibility = input.compatibility ? parseCompatibility(input.compatibility, budget) : undefined;
   return {
     provider: capString(input.provider, budget),
     model: capString(input.model, budget),
@@ -252,6 +282,7 @@ function buildCandidate(input: TraceCandidateInput, budget: { strings?: true; ex
     ...(health ? { health } : {}),
     ...(quota ? { quota } : {}),
     ...(cost ? { cost } : {}),
+    ...(compatibility ? { compatibility } : {}),
   };
 }
 
@@ -278,7 +309,7 @@ function buildRequirement(requirement: RouteRequirementEvidence, budget: { strin
  * pass provider/model NAME strings and opaque account references only.
  */
 export function buildRouteDecisionTrace(input: TraceBuildInput): RouteDecisionTraceV1 {
-  const budget: { strings?: true; exclusions?: true; candidates?: true } = {};
+  const budget: ParseCaps = {};
   const now = input.now ?? Date.now();
   const truncated: RouteDecisionTraceV1["truncated"] = {};
   let selectedIndex = Number.isInteger(input.selected.candidateIndex ?? 0)
@@ -287,8 +318,6 @@ export function buildRouteDecisionTrace(input: TraceBuildInput): RouteDecisionTr
 
   let candidates = (input.candidates ?? []).map(candidate => buildCandidate(candidate, budget));
   if (candidates.length > MAX_TRACE_CANDIDATES) {
-    // Keep the selected candidate even when it sits beyond the slice: a trace
-    // whose selected candidate vanished would contradict the decision.
     candidates = selectedIndex < MAX_TRACE_CANDIDATES
       ? candidates.slice(0, MAX_TRACE_CANDIDATES)
       : [...candidates.slice(0, MAX_TRACE_CANDIDATES - 1), candidates[selectedIndex]!];
@@ -296,7 +325,6 @@ export function buildRouteDecisionTrace(input: TraceBuildInput): RouteDecisionTr
     truncated.candidates = true;
   }
   if (candidates.length === 0) {
-    // Invariant: every decision names at least the selected route as a candidate.
     candidates = [{
       provider: capString(input.selected.provider, budget),
       model: capString(input.selected.model, budget),
@@ -349,6 +377,7 @@ export function buildRouteDecisionTrace(input: TraceBuildInput): RouteDecisionTr
   if (budget.strings) truncated.strings = true;
   if (budget.exclusions) truncated.exclusions = true;
   if (budget.candidates) truncated.candidates = true;
+  if (budget.compatibility) truncated.compatibility = true;
   if (Object.keys(truncated).length > 0) trace.truncated = truncated;
 
   return enforceByteBudget(trace);
@@ -369,9 +398,6 @@ function enforceByteBudget(trace: RouteDecisionTraceV1): RouteDecisionTraceV1 {
   }));
   const slimmed: RouteDecisionTraceV1 = { ...trace, truncated, candidates };
   if (serializedByteLength(slimmed) <= MAX_TRACE_BYTES) return slimmed;
-  // Second stage: shrink candidates. The selected candidate must survive and
-  // `selected.candidateIndex` must keep pointing at it (same invariant as the
-  // candidate-cap branch above).
   const half = Math.max(1, Math.floor(MAX_TRACE_CANDIDATES / 2));
   const selectedIndex = trace.selected.candidateIndex;
   const kept = selectedIndex < half
@@ -383,10 +409,6 @@ function enforceByteBudget(trace: RouteDecisionTraceV1): RouteDecisionTraceV1 {
     candidates: kept,
     selected: { ...slimmed.selected, candidateIndex: Math.min(selectedIndex, kept.length - 1) },
   };
-  // Last resort: keep shrinking deterministically until the byte budget holds.
-  // Each stage reduces a bounded dimension, and a single candidate with no
-  // exclusions is provably below MAX_TRACE_BYTES given the string cap, so the
-  // loop terminates.
   for (let stage = 0; stage < 4 && serializedByteLength(result) > MAX_TRACE_BYTES; stage++) {
     if (stage === 0) {
       result = {
@@ -420,16 +442,6 @@ function enforceByteBudget(trace: RouteDecisionTraceV1): RouteDecisionTraceV1 {
   return result;
 }
 
-// ---- defensive parsing of persisted rows --------------------------------------
-
-/** Caps applied by the normalizer; unioned into `truncated` on the result. */
-interface ParseCaps {
-  candidates?: true;
-  exclusions?: true;
-  requirements?: true;
-  strings?: true;
-}
-
 /** Defensive parse of one persisted exclusion reason. */
 function parseExclusion(raw: unknown, caps: ParseCaps): RouteExclusionReason | null {
   if (!isPlainRecord(raw)) return null;
@@ -571,13 +583,52 @@ function parseCost(raw: unknown, caps: ParseCaps): RouteCostEvidence | undefined
   return Object.keys(out).length > 0 ? out : undefined;
 }
 
+const MAX_COMPATIBILITY_SUITES = 8;
+const COMPATIBILITY_OUTCOMES = new Set(["satisfied", "penalized", "excluded", "unknown"]);
+
+function parseCompatibility(raw: unknown, caps: ParseCaps): RouteCompatibilityEvidence | undefined {
+  if (!isPlainRecord(raw)) return undefined;
+  const suitesRaw = Array.isArray(raw.suites) ? raw.suites : [];
+  if (suitesRaw.length > MAX_COMPATIBILITY_SUITES || raw.truncated === true) caps.compatibility = true;
+  const suites: RouteCompatibilitySuiteTrace[] = [];
+  for (const entry of suitesRaw.slice(0, MAX_COMPATIBILITY_SUITES)) {
+    if (!isPlainRecord(entry)) continue;
+    const suiteId = entry.suiteId;
+    const evidenceLayer = entry.evidenceLayer;
+    const outcome = entry.outcome;
+    if (typeof suiteId !== "string" || typeof evidenceLayer !== "string") continue;
+    if (typeof outcome !== "string" || !COMPATIBILITY_OUTCOMES.has(outcome)) continue;
+    const row: RouteCompatibilitySuiteTrace = {
+      suiteId: capString(suiteId, caps),
+      evidenceLayer: capString(evidenceLayer, caps),
+      outcome: outcome as RouteCompatibilitySuiteTrace["outcome"],
+    };
+    if (typeof entry.subjectIdPrefix === "string" && entry.subjectIdPrefix) {
+      row.subjectIdPrefix = capString(entry.subjectIdPrefix, caps);
+    }
+    for (const key of ["verdict", "minStatus", "reason", "unknownPolicy", "degradedPolicy"] as const) {
+      if (typeof entry[key] === "string") row[key] = capString(entry[key] as string, caps);
+    }
+    if (typeof entry.fresh === "boolean") row.fresh = entry.fresh;
+    suites.push(row);
+  }
+  const out: RouteCompatibilityEvidence = {
+    suites,
+    ...(raw.truncated === true ? { truncated: true as const } : {}),
+  };
+  if (typeof raw.subjectIdPrefix === "string" && raw.subjectIdPrefix) {
+    out.subjectIdPrefix = capString(raw.subjectIdPrefix, caps);
+  }
+  return suites.length > 0 || out.subjectIdPrefix || out.truncated ? out : undefined;
+}
+
 /** Whitelisted score parse; requires a finite `total` and bounded components. */
 function parseScore(raw: unknown): RouteScoreEvidence | undefined {
   if (!isPlainRecord(raw)) return undefined;
   if (!finiteNumber(raw.total)) return undefined;
   const components = isPlainRecord(raw.components) ? raw.components : {};
   const parsedComponents: RouteScoreEvidence["components"] = {};
-  for (const key of ["capability", "health", "quota", "cost", "latency", "configuredPriority"] as const) {
+  for (const key of ["capability", "health", "quota", "cost", "latency", "configuredPriority", "compatibility"] as const) {
     if (finiteNumber(components[key])) parsedComponents[key] = components[key];
   }
   return { total: raw.total, components: parsedComponents };
@@ -604,6 +655,7 @@ function parseCandidate(raw: unknown, caps: ParseCaps): RouteCandidateTrace | nu
   const health = parseHealth(raw.health);
   const quota = parseQuota(raw.quota, caps);
   const cost = parseCost(raw.cost, caps);
+  const compatibility = parseCompatibility(raw.compatibility, caps);
   const score = parseScore(raw.score);
   return {
     provider: provider.slice(0, MAX_TRACE_STRING),
@@ -617,6 +669,7 @@ function parseCandidate(raw: unknown, caps: ParseCaps): RouteCandidateTrace | nu
     ...(health ? { health } : {}),
     ...(quota ? { quota } : {}),
     ...(cost ? { cost } : {}),
+    ...(compatibility ? { compatibility } : {}),
     ...(score ? { score } : {}),
   };
 }
@@ -695,6 +748,7 @@ export function normalizeRouteDecisionTrace(raw: unknown): RouteDecisionTraceV1
   if (incoming.exclusions === true || caps.exclusions) truncated.exclusions = true;
   if (incoming.requirements === true || caps.requirements) truncated.requirements = true;
   if (incoming.strings === true || caps.strings) truncated.strings = true;
+  if (incoming.compatibility === true || caps.compatibility) truncated.compatibility = true;
 
   return {
     version: 1,
@@ -717,6 +771,6 @@ export function normalizeRouteDecisionTrace(raw: unknown): RouteDecisionTraceV1
         ? { tieBreak: selected.tieBreak.slice(0, MAX_TRACE_STRING) }
         : {}),
     },
-    ...(truncated && Object.keys(truncated).length > 0 ? { truncated } : {}),
+    ...(Object.keys(truncated).length > 0 ? { truncated } : {}),
   };
 }

package/src/server/auth-cors.ts

@@ -6,6 +6,7 @@ import {
   modelAdapterRecordConfigError,
   modelPreferHostedToolsConfigError,
   codexAutoStartEnabled,
+  nonBlankStringArrayConfigError,
   positiveIntegerConfigError,
   positiveIntegerRecordConfigError,
   providerBaseUrlConfigError,
@@ -509,6 +510,11 @@ export function providerManagementConfigError(name: unknown, provider: unknown):
   if (defaultMaxOutputError) return `provider ${name} ${defaultMaxOutputError}`;
   const maxOutputError = positiveIntegerRecordConfigError(raw.modelMaxOutputTokens, "modelMaxOutputTokens");
   if (maxOutputError) return `provider ${name} ${maxOutputError}`;
+  const structuredOutputOptOutError = nonBlankStringArrayConfigError(
+    raw.noStructuredOutputModels,
+    "noStructuredOutputModels",
+  );
+  if (structuredOutputOptOutError) return `provider ${name} ${structuredOutputOptOutError}`;
   const openRouterError = openRouterRoutingConfigError(typed);
   if (openRouterError) return `provider ${name} ${openRouterError}`;
   if (typed.authMode === "local") {
@@ -589,6 +595,7 @@ export function safeConfigDTO(config: OcxConfig): unknown {
       "noTemperatureModels",
       "noTopPModels",
       "noPenaltyModels",
+      "noStructuredOutputModels",
       "autoToolChoiceOnlyModels",
       "preserveReasoningContentModels",
       "requiresReasoningPlaceholderModels",

package/src/server/background-lifecycle.ts

@@ -14,6 +14,10 @@ import {
   cancelQueuedStorageWorkerSpawns,
   drainStorageWorkers,
 } from "../storage/worker-lifecycle";
+import {
+  acquireServerResourceOwner,
+  type ServerResourceOwnerLease,
+} from "../lib/server-resource-ownership";
 import {
   startMemoryWatchdog,
   type MemoryWatchdog,
@@ -29,6 +33,7 @@ type ProcessLoops = {
 type LeaseOwner = {
   token: symbol;
   applyPolicy: PolicyApply;
+  resources: ServerResourceOwnerLease;
 };
 
 export type ServerBackgroundLifecycleLease = {
@@ -103,6 +108,7 @@ function removeOwner(owner: LeaseOwner): boolean {
 
 function releaseOwnerSynchronously(owner: LeaseOwner): "inactive" | "shared" | "last" {
   if (!removeOwner(owner)) return "inactive";
+  owner.resources.release();
   const nextOwner = owners.at(-1);
   if (nextOwner) {
     setLivePolicyOwner(nextOwner.applyPolicy);
@@ -117,7 +123,8 @@ function releaseOwnerSynchronously(owner: LeaseOwner): "inactive" | "shared" | "
  *
  * The first live server starts the loops. Later servers only add a reference and
  * become the current policy sink; out-of-order release restores the newest
- * remaining sink. The final release owns timer and Worker teardown.
+ * remaining sink. The final release owns timer and Worker teardown. Resources
+ * registered while this server starts are released with this exact lease.
  */
 export function acquireServerBackgroundLifecycle(
   applyPolicy: PolicyApply,
@@ -129,13 +136,19 @@ export function acquireServerBackgroundLifecycle(
   const owner: LeaseOwner = {
     token: Symbol("server-background-lifecycle"),
     applyPolicy,
+    resources: acquireServerResourceOwner(),
   };
-  if (!processLoops) {
-    processLoops = startProcessLoops(applyPolicy);
-  } else {
-    setLivePolicyOwner(applyPolicy);
+  try {
+    if (!processLoops) {
+      processLoops = startProcessLoops(applyPolicy);
+    } else {
+      setLivePolicyOwner(applyPolicy);
+    }
+    owners.push(owner);
+  } catch (error) {
+    owner.resources.release();
+    throw error;
   }
-  owners.push(owner);
 
   let releaseFlight: Promise<void> | null = null;
   return {
@@ -166,4 +179,4 @@ export function acquireServerBackgroundLifecycle(
       releaseFlight = Promise.resolve();
     },
   };
-}
+}

package/src/server/chat-completions.ts

@@ -25,7 +25,7 @@ import type { OcxConfig } from "../types";
 import { readJsonRequestBody } from "./request-decompress";
 import {
   addFinalRequestLog,
-  httpStatusForTerminalStatus,
+  httpStatusForRequestLogTerminal,
   recordFirstOutput,
   type RequestLogContext,
   type RequestLogEntry,
@@ -216,7 +216,7 @@ async function handleChatCompletionsWithBudget(
     inboundWire: "chat",
     translatorBudget,
     ...(logIds ? { onFirstOutput: () => recordFirstOutput(logCtx, logIds.start) } : {}),
-    onNativePassthroughTerminal: status => finalizeNativeLog(httpStatusForTerminalStatus(status), { terminalStatus: status, closeReason: "terminal" }),
+    onNativePassthroughTerminal: status => finalizeNativeLog(httpStatusForRequestLogTerminal(status, logCtx), { terminalStatus: status, closeReason: "terminal" }),
     onNativePassthroughCancel: () => finalizeNativeLog(499, { closeReason: "client_cancel" }),
   });
 

package/src/server/claude-messages.ts

@@ -31,7 +31,7 @@ import { evidenceFromBody } from "../routing/request-evidence";
 import { resolveWireProtocolOverride } from "./adapter-resolve";
 import type { OcxConfig } from "../types";
 import { readJsonRequestBody } from "./request-decompress";
-import { addFinalRequestLog, httpStatusForTerminalStatus, recordFirstOutput, type RequestLogContext, type RequestLogEntry } from "./request-log";
+import { addFinalRequestLog, httpStatusForRequestLogTerminal, recordFirstOutput, type RequestLogContext, type RequestLogEntry } from "./request-log";
 import { conversationIdFromClaudeMetadata } from "./request-log-conversation";
 import { responseWithDeferredRequestLog } from "./relay";
 import { handleResponses } from "./responses";
@@ -605,7 +605,10 @@ async function handleClaudeMessagesWithBudget(
       return await anthropicNativePassthrough(req, config, logCtx, logIds, anthropicBody, "/v1/messages");
     }
     if (isRec(anthropicBody) && effortOverride) {
-      anthropicBody.output_config = { effort: effortOverride };
+      anthropicBody.output_config = {
+        ...(isRec(anthropicBody.output_config) ? anthropicBody.output_config : {}),
+        effort: effortOverride,
+      };
       delete anthropicBody.thinking;
     }
     const translation = anthropicToResponsesTranslation(anthropicBody, config.claudeCode);
@@ -735,7 +738,7 @@ async function handleClaudeMessagesWithBudget(
     stripClaudeMainAuthForNoncanonicalForward: true,
     translatorBudget,
     ...(logIds ? { onFirstOutput: () => recordFirstOutput(logCtx, logIds.start) } : {}),
-    onNativePassthroughTerminal: status => finalizeNativeLog(httpStatusForTerminalStatus(status), { terminalStatus: status, closeReason: "terminal" }),
+    onNativePassthroughTerminal: status => finalizeNativeLog(httpStatusForRequestLogTerminal(status, logCtx), { terminalStatus: status, closeReason: "terminal" }),
     onNativePassthroughCancel: () => finalizeNativeLog(499, { closeReason: "client_cancel" }),
   });
   const response = logIds ? responseWithDeferredRequestLog(upstream, logIds.requestId, logIds.start, logCtx) : upstream;