@bitkyc08/opencodex 2.9.1 → 2.10.0

package/src/oauth/index.ts

@@ -629,8 +629,11 @@ export function buildModelsRequest(prov: OcxProviderConfig, apiKey: string | und
  * configs on the next `ocx start`, instead of only fresh installs. The live `/models` fetch stays
  * the primary source; this keeps the static fallback (and models-not-in-/models) current.
  *
- * Only touches providers that are registry-managed AND still `authMode: "oauth"`, and only the
- * preset fields (never apiKey/baseUrl/user toggles). Persists + returns true when anything changed.
+ * Only touches providers that are registry-managed AND still `authMode: "oauth"`. Preset fields
+ * are refreshed, while the registry's `liveModels` default is normally filled only when no value
+ * is stored. Antigravity has one versioned exception below because its old GUI-generated `true`
+ * cannot be distinguished from a hand-written pre-migration `true`. Persists + returns true when
+ * anything changed.
  */
 function cloneProviderField(value: unknown): unknown {
   if (Array.isArray(value)) return [...value];
@@ -658,11 +661,30 @@ const OAUTH_RECONCILE_FIELDS: (keyof OcxProviderConfig)[] = [
   "preserveReasoningContentModels",
 ];
 
+const GOOGLE_ANTIGRAVITY_PROVIDER = "google-antigravity";
+const GOOGLE_ANTIGRAVITY_STATIC_CATALOG_VERSION = 1 as const;
+
 export function reconcileOAuthProviders(config: OcxConfig): boolean {
   let changed = false;
+  const migrateAntigravityStaticCatalog =
+    config.googleAntigravityStaticCatalogVersion !== GOOGLE_ANTIGRAVITY_STATIC_CATALOG_VERSION;
   for (const [name, prov] of Object.entries(config.providers)) {
     const def = OAUTH_PROVIDERS[name];
-    if (!def || prov.authMode !== "oauth") continue;
+    // Normalize the canonical row before the OAuth-only reconciliation guard. The old GUI and a
+    // manual edit both persist the same bare `true`, with no source metadata, so every ambiguous
+    // pre-marker value is reset once. A deliberate live-discovery choice can be re-enabled after
+    // the marker and is then preserved. Do this before the guard so omitted/non-OAuth authMode
+    // rows do not get stamped without actually receiving the new static default.
+    if (name === GOOGLE_ANTIGRAVITY_PROVIDER && migrateAntigravityStaticCatalog && prov.liveModels !== false) {
+      prov.liveModels = false;
+      changed = true;
+    }
+    // During the one-time Antigravity static-catalog migration, also refresh preset catalog
+    // fields when authMode is omitted or non-oauth. Otherwise liveModels flips to static while
+    // a stale models[] remains the published catalog forever.
+    const migrateAntigravityCatalogFields =
+      name === GOOGLE_ANTIGRAVITY_PROVIDER && migrateAntigravityStaticCatalog;
+    if (!def || (prov.authMode !== "oauth" && !migrateAntigravityCatalogFields)) continue;
     const preset = def.providerConfig;
     for (const field of OAUTH_RECONCILE_FIELDS) {
       if (JSON.stringify(prov[field]) === JSON.stringify(preset[field])) continue;
@@ -673,12 +695,23 @@ export function reconcileOAuthProviders(config: OcxConfig): boolean {
       }
       changed = true;
     }
+    // Before this marker existed, the GUI materialized an omitted `liveModels` as `true` on any
+    // settings save. Since persisted values have no provenance, the pre-guard normalization above
+    // intentionally resets all pre-marker `true` values once. Later choices are version-bounded.
+    if (prov.liveModels === undefined && preset.liveModels !== undefined) {
+      prov.liveModels = preset.liveModels;
+      changed = true;
+    }
     // Heal a defaultModel that no longer exists in the refreshed list (e.g. a deprecated snapshot).
     if (prov.defaultModel && preset.defaultModel && !(prov.models ?? []).includes(prov.defaultModel)) {
       prov.defaultModel = preset.defaultModel;
       changed = true;
     }
   }
+  if (migrateAntigravityStaticCatalog) {
+    config.googleAntigravityStaticCatalogVersion = GOOGLE_ANTIGRAVITY_STATIC_CATALOG_VERSION;
+    changed = true;
+  }
   if (changed) saveConfig(config);
   return changed;
 }
@@ -739,6 +772,15 @@ export function upsertOAuthProvider(config: OcxConfig, provider: string): void {
   if (namespaceCollision) throw new Error(namespaceCollision);
   const existing = config.providers[provider];
   const next: OcxProviderConfig = { ...def.providerConfig };
+  // `liveModels` is a user-facing provider toggle. A registry default seeds new rows, but an
+  // explicit post-migration choice must survive re-login and the latest-config upsert. Old GUI
+  // saves and manual edits left identical pre-marker `true` values, so that ambiguous state is
+  // reset once; users who deliberately forced discovery can re-enable it after migration.
+  const preserveExistingLiveModels = provider !== GOOGLE_ANTIGRAVITY_PROVIDER
+    || config.googleAntigravityStaticCatalogVersion === GOOGLE_ANTIGRAVITY_STATIC_CATALOG_VERSION;
+  if (preserveExistingLiveModels && typeof existing?.liveModels === "boolean") {
+    next.liveModels = existing.liveModels;
+  }
   if (existing && getProviderRegistryEntry(provider)?.allowKeyAuthOverride === true) {
     // Shared sanitizeApiKeyValue trim / no-CRLF checks from api-key pool writes.
     let storedApiKey = sanitizeApiKeyValue(existing.apiKey);
@@ -762,6 +804,9 @@ export function upsertOAuthProvider(config: OcxConfig, provider: string): void {
     }
   }
   config.providers[provider] = next;
+  if (provider === GOOGLE_ANTIGRAVITY_PROVIDER) {
+    config.googleAntigravityStaticCatalogVersion = GOOGLE_ANTIGRAVITY_STATIC_CATALOG_VERSION;
+  }
 }
 
 interface RunLoginDeps {

package/src/providers/registry.ts

@@ -507,6 +507,43 @@ const NEURALWATT_REASONING_HISTORY_MODELS = [
   "kimi-k2.6", "kimi-k2.7-code",
   "qwen3.5-397b", "qwen3.6-35b",
 ];
+
+// 260728 Baseten Model APIs: `/v1/models` owns the live lineup, while these hints
+// describe only capabilities that Baseten documents per slug. Unlisted live models
+// intentionally inherit the empty provider ladder instead of being advertised with
+// opencodex's generic reasoning defaults. Audio is omitted because the current proxy
+// request model does not carry OpenAI `audio_url` parts.
+// Evidence: https://docs.baseten.co/inference/model-apis/reasoning
+//           https://docs.baseten.co/inference/model-apis/vision
+const BASETEN_FULL_REASONING_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+const BASETEN_MODEL_REASONING_EFFORTS: Record<string, string[]> = {
+  "deepseek-ai/DeepSeek-V4-Pro": BASETEN_FULL_REASONING_EFFORTS,
+  "thinkingmachines/inkling": BASETEN_FULL_REASONING_EFFORTS,
+  "openai/gpt-oss-120b": BASETEN_FULL_REASONING_EFFORTS,
+  "moonshotai/Kimi-K3": ["low", "high", "max"],
+  "zai-org/GLM-5.2": ["high", "max"],
+  "zai-org/GLM-5.2-Fast": ["high", "max"],
+};
+const BASETEN_MODEL_REASONING_EFFORT_MAP: Record<string, Record<string, string>> = {
+  "deepseek-ai/DeepSeek-V4-Pro": { none: "none", minimal: "minimal" },
+  "thinkingmachines/inkling": { none: "none", minimal: "minimal" },
+  "openai/gpt-oss-120b": { none: "none", minimal: "minimal" },
+  "moonshotai/Kimi-K3": { none: "none" },
+  "zai-org/GLM-5.2": { none: "none" },
+  "zai-org/GLM-5.2-Fast": { none: "none" },
+};
+const BASETEN_MODEL_DEFAULT_REASONING_EFFORTS: Record<string, string> = {
+  "deepseek-ai/DeepSeek-V4-Pro": "medium",
+  "thinkingmachines/inkling": "high",
+  "openai/gpt-oss-120b": "medium",
+  "moonshotai/Kimi-K3": "max",
+};
+const BASETEN_MODEL_INPUT_MODALITIES: Record<string, string[]> = {
+  "thinkingmachines/inkling": ["text", "image"],
+  "moonshotai/Kimi-K2.6": ["text", "image"],
+  "moonshotai/Kimi-K2.7-Code": ["text", "image"],
+  "moonshotai/Kimi-K3": ["text", "image"],
+};
 const UMANS_MODELS = [
   "umans-coder",
   "umans-kimi-k2.7",
@@ -983,6 +1020,31 @@ export const PROVIDER_REGISTRY: readonly ProviderRegistryEntry[] = [
     },
     note: "Serverless text and vision-language chat models only; Hyperbolic's separate image, audio, and GPU endpoints are out of scope.",
   },
+  {
+    id: "baseten",
+    label: "Baseten Model APIs",
+    baseUrl: "https://inference.baseten.co/v1",
+    adapter: "openai-chat",
+    authKind: "key",
+    dashboardUrl: "https://app.baseten.co/settings/api_keys",
+    liveModels: true,
+    preserveCustomDestination: true,
+    // Baseten's Chat Completions contract documents parallel_tool_calls as default-on.
+    parallelToolCalls: true,
+    // Baseten says models outside its reasoning table do not support reasoning. Keep
+    // unknown/new live slugs conservative until an official-docs registry refresh proves it.
+    reasoningEfforts: [],
+    modelReasoningEfforts: BASETEN_MODEL_REASONING_EFFORTS,
+    modelReasoningEffortMap: BASETEN_MODEL_REASONING_EFFORT_MAP,
+    modelDefaultReasoningEfforts: BASETEN_MODEL_DEFAULT_REASONING_EFFORTS,
+    modelInputModalities: BASETEN_MODEL_INPUT_MODALITIES,
+    modelDiscovery: {
+      path: "models",
+      maxResponseBytes: 1_048_576,
+      maxModels: 256,
+    },
+    note: "Shared Model APIs only (personal API key, or team key with Call Model APIs access); dedicated Truss predict endpoints are outside this preset.",
+  },
   // FREEZE 2026-07-10: exact serverless ids remain auth-gated/unverified. Evidence: devlog/_plan/260710_provider_hardening/003_research_aggregators.md.
   { id: "together", label: "Together", baseUrl: "https://api.together.xyz/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://api.together.xyz/settings/api-keys" },
   { id: "fireworks", label: "Fireworks", baseUrl: "https://api.fireworks.ai/inference/v1", adapter: "openai-chat", authKind: "key", dashboardUrl: "https://fireworks.ai/account/api-keys" },

package/src/server/index.ts

@@ -474,7 +474,7 @@ export function startServer(port?: number) {
           }
           throw error;
         }
-        const { applyNativeVisibility, buildCatalogEntries, disabledNativeSlugs, exactComboCatalogSlugs, loadCatalogTemplate, nativeOpenAiSlugs, orderForSubagents, filterCatalogVisibleModels, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs, desktopVisibleNativeSlugs } = await import("../codex/catalog");
+        const { applyNativeVisibility, buildCatalogEntries, disabledNativeSlugs, exactComboCatalogSlugs, loadCatalogTemplate, nativeOpenAiSlugs, nativeReasoningEfforts, nativeDefaultReasoningEffort, orderForSubagents, filterCatalogVisibleModels, uniqueCatalogModelsForRawPublicList, visibleNativeSlugs, desktopVisibleNativeSlugs } = await import("../codex/catalog");
         const nativeSlugs = nativeOpenAiSlugs();
         const goEnabled = filterCatalogVisibleModels(goModels, config);
         const goOrdered = orderForSubagents(goEnabled, config.subagentModels);
@@ -524,9 +524,45 @@ export function startServer(port?: number) {
         }
         // OpenAI list shape: native gpt bare + routed models namespaced "<provider>/<id>"
         // (pure availability list — disabled natives are omitted entirely).
+        // Grok Build discovers models through this endpoint too, and its model picker only
+        // enables /effort for entries that advertise the reasoning ladder in the Grok model
+        // catalog shape (supports_reasoning_effort + reasoning_efforts[]). The Codex catalog
+        // branch above already carries the same ladders, so mirror them here — native rows
+        // from the upstream snapshot, routed rows from the configured provider tiers. The
+        // default uses the same canonical fallback as the Codex catalog resolver
+        // (configured default, then medium, then high, then the first tier). Extra fields
+        // are ignored by plain OpenAI clients.
+        const grokEffortOption = (value: string, isDefault: boolean) => ({
+          value,
+          label: `${value[0].toUpperCase()}${value.slice(1)} Effort`,
+          ...(isDefault ? { default: true } : {}),
+        });
+        const grokEffortFields = (efforts: string[], configuredDefault?: string) => {
+          if (efforts.length === 0) return {};
+          const defaultEffort = configuredDefault && efforts.includes(configuredDefault)
+            ? configuredDefault
+            : efforts.includes("medium") ? "medium" : efforts.includes("high") ? "high" : efforts[0];
+          return {
+            supports_reasoning_effort: true,
+            reasoning_effort: defaultEffort,
+            reasoning_efforts: efforts.map(effort => grokEffortOption(effort, effort === defaultEffort)),
+          };
+        };
         const data = [
-          ...visibleNativeSlugs(config).map(id => ({ id, object: "model", created: 0, owned_by: "openai" })),
-          ...uniqueCatalogModelsForRawPublicList(goOrdered).map(m => ({ id: m.alias ?? `${m.provider}/${m.id}`, object: "model", created: 0, owned_by: m.owned_by ?? m.provider })),
+          ...visibleNativeSlugs(config).map(id => ({
+            id,
+            object: "model",
+            created: 0,
+            owned_by: "openai",
+            ...grokEffortFields(nativeReasoningEfforts(id), nativeDefaultReasoningEffort(id)),
+          })),
+          ...uniqueCatalogModelsForRawPublicList(goOrdered).map(m => ({
+            id: m.alias ?? `${m.provider}/${m.id}`,
+            object: "model",
+            created: 0,
+            owned_by: m.owned_by ?? m.provider,
+            ...grokEffortFields(m.reasoningEfforts ?? [], m.defaultReasoningEffort),
+          })),
         ];
         return jsonResponse({ object: "list", data }, 200, req, config);
       }

package/src/server/management/agent-settings-routes.ts

@@ -460,7 +460,11 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
       ...listCatalogNativeSlugs().filter(ns => !disabled.has(ns)),
       ...visibleRouted,
     ];
-    return jsonResponse({ chosen: config.subagentModels ?? [], available });
+    // #857: let CLI/GUI show when a running Codex app-server keeps an older
+    // in-memory catalog than the one on disk.
+    const { collectCodexAppServerCatalogState } = await import("../../codex/app-server-processes");
+    const catalogState = collectCodexAppServerCatalogState();
+    return jsonResponse({ chosen: config.subagentModels ?? [], available, catalogState });
   }
   if (url.pathname === "/api/subagent-models" && req.method === "PUT") {
     let body: { models?: unknown };
@@ -646,7 +650,40 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
   }
   if (url.pathname === "/api/claude-desktop/apply" && req.method === "POST") {
     try {
-      const state = await buildClaudeDesktopState(config);
+      // #859: the CLI delegates here so the registry is built in the serving
+      // process. Accept an optional mode; default stays static for back-compat.
+      let mode: "static" | "hybrid" | "discovery" = "static";
+      const rawBody = await req.text();
+      let parsed: unknown;
+      if (rawBody.trim()) {
+        try {
+          parsed = JSON.parse(rawBody);
+        } catch {
+          return jsonResponse({ error: "invalid JSON body" }, 400);
+        }
+        const requested = (parsed as { mode?: unknown } | null)?.mode;
+        if (requested !== undefined) {
+          if (requested === "static" || requested === "hybrid" || requested === "discovery") {
+            mode = requested;
+          } else {
+            return jsonResponse({ error: "mode must be static, hybrid, or discovery" }, 400);
+          }
+        }
+      }
+      // #859: a delegated CLI apply carries the profile it just saved — the
+      // daemon's own config can be older, and building state from it would
+      // apply (and persist) the stale profile over the newer one.
+      const bodyProfile = (parsed as { profile?: unknown } | null)?.profile;
+      let profileOverride: Parameters<typeof buildClaudeDesktopState>[1];
+      if (bodyProfile !== undefined) {
+        const { parseDesktopProfile } = await import("../../claude/desktop-profile");
+        try {
+          profileOverride = parseDesktopProfile(bodyProfile);
+        } catch (error) {
+          return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 400);
+        }
+      }
+      const state = await buildClaudeDesktopState(config, profileOverride);
       config.claudeCode = { ...(config.claudeCode ?? {}), desktopProfile: state.profile };
       saveConfigPreservingClaudeCode(config);
       const { writeDesktop3pConfig } = await import("../../claude/desktop-3p");
@@ -662,7 +699,7 @@ export async function handleAgentSettingsRoutes(ctx: ManagementContext): Promise
         [...desktopVisibleNativeSlugs(config)],
         routed,
         config.apiKeys?.[0]?.key,
-        "static",
+        mode,
         state.profile,
       );
       if (!result.written) return jsonResponse({ error: result.reason ?? "Claude Desktop apply failed", saved: true, path: result.path }, 500);

package/src/server/management/logs-usage-routes.ts

@@ -321,6 +321,7 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
           result.error === "codex_busy"
             || result.error === "stale_preview"
             || result.error === "referenced_history"
+            || result.error === "pinned_thread"
             || result.error === "storage_mutation_busy"
             || result.error === "restore_pending_overlap"
             ? 409
@@ -333,6 +334,7 @@ export async function handleLogsUsageRoutes(ctx: ManagementContext): Promise<Res
           stale_preview: "Archived files changed since preview — run Preview again.",
           restore_pending_overlap: "Selected archives overlap an incomplete trash restore — finish or retry restore first.",
           referenced_history: "Selected archives are still referenced by forked or paginated history.",
+          pinned_thread: "Selected archives include a pinned thread — unpin it in Codex before cleanup.",
           invalid_digest: "Preview digest is missing or invalid.",
           invalid_mode: "mode must be quarantine or permanent.",
           fs_failed: "Filesystem cleanup failed. Some changes may already be applied — check CODEX_HOME/.trash and any recovery path in the response.",

package/src/server/management/provider-routes.ts

@@ -365,7 +365,10 @@ export async function handleProviderRoutes(ctx: ManagementContext): Promise<Resp
       });
     }
     if (prov.liveModels === false) {
-      return jsonResponse({ ok: false, latencyMs: 0, error: "static catalog only — upstream not verified" });
+      // A static catalog has no live discovery endpoint to test. This is neither
+      // positive connectivity evidence nor an outage, and it must stay before
+      // credential resolution/network access for providers such as Antigravity.
+      return jsonResponse({ applicable: false, reason: "static_catalog", latencyMs: 0 });
     }
     const { resolveModelsAuthToken, buildModelsRequest } = await import("../../oauth");
     const apiKey = await resolveModelsAuthToken(name, prov);

package/src/server/management/sidebar-routes.ts

@@ -68,7 +68,9 @@ export async function handleSidebarRoutes(ctx: ManagementContext): Promise<Respo
         message:
           `Refused: agent session detected (${agentDrivenMarkers().slice(0, 3).join(", ")}) and this request `
           + `carries no dashboard session. Starring writes to the user's own GitHub account, so ask the user `
-          + `directly and only if they say yes run: gh api -X PUT /user/starred/${STAR_REPO}`,
+          + `directly as a required Yes/No choice — not a soft aside, and no answer is not a No, so re-ask `
+          + `it unchanged while it is open — and only if they say yes run: `
+          + `gh api -X PUT /user/starred/${STAR_REPO}`,
       }, 403);
     }
     const result = await starRepository();

package/src/server/relay-eager.ts

@@ -25,10 +25,24 @@
  */
 
 import { buildFailedTailPayload } from "./relay";
+import {
+  nextSseBlock,
+  replaceSseDataPayload,
+  sseDataPayload,
+  type SsePayloadRewrite,
+} from "./sse-payload-rewrite";
+import type { TranslatorBudget } from "../lib/translator-budget";
 
 export type EagerRelayHooks = {
   /** Feed one upstream chunk through SSE inspection (createSseInspector.feed). */
   inspectChunk: (chunk: Uint8Array) => void;
+  /**
+   * Optional inline client-facing payload rewrite, framed to complete SSE
+   * blocks inside the single reader. This is what lets win32 rewrite traffic
+   * (image_gen restore, item-id repair) use this relay instead of the
+   * Bun#32111-unsafe tee()+JS-pull chain (#864).
+   */
+  rewritePayload?: SsePayloadRewrite;
   /** Flush inspection at upstream end (createSseInspector.finish). */
   finishInspection: () => void;
   /** Drop inspector-owned frame/item state during producer teardown. */
@@ -46,6 +60,8 @@ export type EagerRelayHooks = {
 export type EagerRelayOptions = {
   /** Bounded client queue in bytes; producer pauses above it. Default 8 MiB. */
   maxQueueBytes?: number;
+  /** Transient-budget owner for the inline-rewrite frame buffer. */
+  rewriteBudget?: TranslatorBudget;
   /** Post-cancel discard-drain wall-clock bound. Default 15 000 ms. */
   postCancelDrainMs?: number;
   /** Post-cancel discard-drain byte bound. Default 32 MiB. */
@@ -76,6 +92,72 @@ export function relaySseEagerBounded(
   const now = opts?.now ?? Date.now;
 
   const reader = body.getReader();
+  const rewrite = hooks.rewritePayload;
+  const rewriteDecoder = rewrite ? new TextDecoder() : null;
+  const rewriteEncoder = rewrite ? new TextEncoder() : null;
+  const rewriteBudget = opts?.rewriteBudget;
+  let frameBuffer = "";
+  let frameBufferBytes = 0;
+  /** Frame complete SSE blocks and rewrite each block's data payload in place. */
+  const rewriteOutbound = (value: Uint8Array): Uint8Array => {
+    let out = "";
+    const fragment = rewriteDecoder!.decode(value, { stream: true });
+    if (rewriteBudget) {
+      const nextBytes = frameBufferBytes + rewriteEncoder!.encode(fragment).byteLength;
+      const reservation = rewriteBudget.reserveTransient(nextBytes, { kind: "live_transient" });
+      try {
+        frameBuffer += fragment;
+        reservation.commitRetained();
+        rewriteBudget.releaseRetained(frameBufferBytes, { kind: "live_transient" });
+        frameBufferBytes = nextBytes;
+      } catch (error) {
+        reservation.release();
+        throw error;
+      }
+    } else {
+      frameBuffer += fragment;
+      frameBufferBytes += value.byteLength;
+    }
+    for (;;) {
+      const next = nextSseBlock(frameBuffer);
+      if (!next) break;
+      const payload = sseDataPayload(next.block);
+      const rewrittenPayload = payload === null ? null : rewrite!(payload);
+      // Replace only on an actual change: replaceSseDataPayload collapses
+      // multi-data-line events and normalizes newline style even when the
+      // payload is identical, which corrupts valid streams.
+      const block = payload !== null && rewrittenPayload !== payload
+        ? replaceSseDataPayload(next.block, rewrittenPayload!)
+        : next.block;
+      out += block + next.delimiter;
+      frameBuffer = next.rest;
+    }
+    if (rewriteBudget) {
+      const remaining = rewriteEncoder!.encode(frameBuffer).byteLength;
+      rewriteBudget.releaseRetained(frameBufferBytes - remaining, { kind: "live_transient" });
+      frameBufferBytes = remaining;
+    } else {
+      frameBufferBytes = rewriteEncoder!.encode(frameBuffer).byteLength;
+    }
+    return rewriteEncoder!.encode(out);
+  };
+  /** Flush any trailing partial block at upstream end (rewrite applied, matching the pull relay). */
+  const flushRewriteTail = (): Uint8Array => {
+    if (!rewrite) return new Uint8Array(0);
+    // Decoder-flushed bytes logically follow everything already decoded.
+    let tail = frameBuffer + rewriteDecoder!.decode();
+    const payload = sseDataPayload(tail);
+    if (payload !== null) {
+      const rewrittenPayload = rewrite(payload);
+      if (rewrittenPayload !== payload) tail = replaceSseDataPayload(tail, rewrittenPayload);
+    }
+    frameBuffer = "";
+    if (rewriteBudget && frameBufferBytes > 0) {
+      rewriteBudget.releaseRetained(frameBufferBytes, { kind: "live_transient" });
+    }
+    frameBufferBytes = 0;
+    return rewriteEncoder!.encode(tail);
+  };
   let queuedBytes = 0;
   let cancelled = false;
   let done = false;
@@ -126,6 +208,13 @@ export function relaySseEagerBounded(
         const { done: upstreamDone, value } = result;
         if (upstreamDone) {
           hooks.finishInspection();
+          if (rewrite) {
+            const tail = flushRewriteTail();
+            if (tail.byteLength > 0 && !cancelled) {
+              queuedBytes += tail.byteLength;
+              try { controllerRef?.enqueue(tail); } catch { /* client already gone */ }
+            }
+          }
           if (!hooks.sawTerminal() && !cancelled && !upstream.signal.aborted) {
             syntheticKind = "incomplete";
           }
@@ -141,9 +230,11 @@ export function relaySseEagerBounded(
           }
           continue;
         }
-        queuedBytes += value.byteLength;
+        const outbound = rewrite ? rewriteOutbound(value) : value;
+        if (outbound.byteLength === 0) continue;
+        queuedBytes += outbound.byteLength;
         try {
-          controllerRef?.enqueue(value);
+          controllerRef?.enqueue(outbound);
         } catch {
           // Controller already torn down (client went away without cancel()).
           cancelled = true;
@@ -174,6 +265,13 @@ export function relaySseEagerBounded(
         }
       }
     } finally {
+      // Release any retained rewrite-buffer bytes on every teardown path
+      // (error, cancel, upstream abort) — consumption/EOF release alone
+      // leaves them charged.
+      if (rewriteBudget && frameBufferBytes > 0) {
+        try { rewriteBudget.releaseRetained(frameBufferBytes, { kind: "live_transient" }); } catch { /* teardown must not throw */ }
+        frameBufferBytes = 0;
+      }
       if (syntheticKind) hooks.onSynthetic(syntheticKind);
       if (cancelled && !hooks.sawTerminal()) {
         hooks.onClientCancel();

package/src/server/responses/collaboration.ts

@@ -183,6 +183,18 @@ export interface MultiAgentGuidanceDeps {
     configuredModels: readonly string[],
     surface: SpawnAgentSurface,
   ) => EffectiveSubagentRoster | Promise<EffectiveSubagentRoster>;
+  collectCatalogState?: () => { state: "fresh" | "stale" | "not_running" | "unknown" };
+}
+
+async function defaultCollectCatalogState(): Promise<{ state: "fresh" | "stale" | "not_running" | "unknown" }> {
+  // Explicit override for tests and diagnostics: process state is global and
+  // would otherwise leak the host machine's app-server into hermetic tests.
+  const override = process.env.OPENCODEX_APP_SERVER_CATALOG_STATE_OVERRIDE;
+  if (override === "fresh" || override === "stale" || override === "not_running" || override === "unknown") {
+    return { state: override };
+  }
+  const { collectCodexAppServerCatalogState } = await import("../../codex/app-server-processes");
+  return collectCodexAppServerCatalogState();
 }
 
 
@@ -214,6 +226,15 @@ export async function multiAgentGuidanceText(
   if (surface === null) return null;
 
   if (surface === "v2") {
+    // #857: the disk catalog may be newer than the running app-server's
+    // in-memory copy. Advertising preferred models or a roster the running
+    // Codex cannot actually spawn makes spawn_agent reject the override, so
+    // suppress positive model claims while the state is stale or unknown.
+    const catalogState = await (deps.collectCatalogState ?? defaultCollectCatalogState)();
+    if (catalogState.state === "stale" || catalogState.state === "unknown") {
+      return "<multi_agent_mode>The model catalog changed after Codex started; do not set "
+        + "model or reasoning_effort overrides until Codex restarts.</multi_agent_mode>";
+    }
     // codex-rs supplies the Proactive text on v2; the proxy only adds model-designation
     // guidance, and only when there is something concrete to designate: a configured
     // injectionModel and/or a roster entry that resolves in the injected catalog.

package/src/server/responses/core.ts

@@ -144,7 +144,7 @@ import {
   sanitizePassthroughHeaders,
 } from "../relay";
 import { relaySseEagerBounded } from "../relay-eager";
-import { selectEagerPath } from "../../lib/bun-stream-caps";
+import { isWin32EagerRewrite, selectEagerPath } from "../../lib/bun-stream-caps";
 import { cancelBodyOnAbort } from "../../lib/abort";
 import {
   createResponsesItemIdPayloadRewrite,
@@ -1759,12 +1759,23 @@ async function handleResponsesInner(
     if (isEventStream && upstreamResponse.body) {
       const repairConfig = route.provider.responsesItemIdRepair;
       const needsClientRewrite = imageGenCallAliases.size > 0 || hasResponsesItemIdRepair(repairConfig);
+      // Compose opt-in payload rewrites into one parse/stringify pass (image-gen restore first).
+      const payloadRewrites = [
+        createImageGenCallRestoreRewrite(imageGenCallAliases),
+        hasResponsesItemIdRepair(repairConfig)
+          ? createResponsesItemIdPayloadRewrite(repairConfig!, translatorBudget)
+          : undefined,
+      ].filter((rewrite): rewrite is NonNullable<typeof rewrite> => rewrite !== undefined);
+      // #864: win32 rewrite traffic must never enter the tee()+JS-pull chain
+      // (Bun#32111 JS-sink segfault — text frames pass, the terminal block is
+      // lost). The eager single reader applies the same rewrites inline.
+      const win32EagerRewrite = isWin32EagerRewrite(process.platform, needsClientRewrite);
       const eagerPath = selectEagerPath(
         process.platform,
         needsClientRewrite,
         config.streamMode ?? "auto",
       );
-      if (eagerPath?.useEagerRelay) {
+      if (eagerPath?.useEagerRelay || win32EagerRewrite) {
         const turnAc = new AbortController();
         linkAbortSignal(upstream, turnAc.signal);
         registerTurn(turnAc, options.turnAdmissionLease);
@@ -1801,6 +1812,9 @@ async function handleResponsesInner(
           finishInspection: () => inspector.finish(),
           disposeInspection: () => inspector.dispose(),
           sawTerminal: () => inspector.reported(),
+          ...(win32EagerRewrite
+            ? { rewritePayload: composeSsePayloadRewrites(...payloadRewrites) }
+            : {}),
           onSynthetic: kind => {
             if (!reportNativeTerminal) return;
             if (kind === "incomplete") {
@@ -1814,9 +1828,10 @@ async function handleResponsesInner(
           },
           onClientCancel: () => options.onNativePassthroughCancel?.(),
           onDone: () => unregisterTurn(turnAc),
-        });
-        // selectEagerPath admits only no-rewrite traffic, so this stays a pure native relay on
-        // both eligible platforms; win32 must never enter an image/item-id JS pull wrapper (#32111).
+        }, win32EagerRewrite ? { rewriteBudget: translatorBudget } : undefined);
+        // selectEagerPath admits only no-rewrite traffic on both eligible platforms;
+        // win32 rewrite traffic reaches this relay too, but with the payload rewrite
+        // applied inline — never via an image/item-id JS pull wrapper (#32111, #864).
         if (!headers.has("content-type")) headers.set("content-type", "text/event-stream");
         return markEagerRelaySseResponse(
           markNativePassthroughSseResponse(new Response(eagerBody, {
@@ -1886,13 +1901,6 @@ async function handleResponsesInner(
       // win32 must keep the pure native relay (Bun#32111 JS-sink segfault); elsewhere a JS pull
       // relay is established practice (relayWithAbort, relaySseWithHeartbeat) and lets a
       // mid-stream reset end with a clean response.failed terminal instead of a raw socket error.
-      // Compose opt-in payload rewrites into one parse/stringify pass (image-gen restore first).
-      const payloadRewrites = [
-        createImageGenCallRestoreRewrite(imageGenCallAliases),
-        hasResponsesItemIdRepair(repairConfig)
-          ? createResponsesItemIdPayloadRewrite(repairConfig!, translatorBudget)
-          : undefined,
-      ].filter((rewrite): rewrite is NonNullable<typeof rewrite> => rewrite !== undefined);
       const rewrittenBody = payloadRewrites.length > 0
         ? relaySseWithPayloadRewrite(nativeBody, composeSsePayloadRewrites(...payloadRewrites), translatorBudget)
         : nativeBody;