@bitkyc08/opencodex 2.8.2-preview.20260731 → 2.9.1

package/src/codex/shim.ts

@@ -25,12 +25,14 @@ import { serviceApiTokenFilePath } from "../lib/service-secrets";
 import { recordOwnedConfigPath } from "../lib/config-ownership";
 import { windowsEnvIndirectBatchValue } from "../lib/win-paths";
 import { isWslRuntime, wslAutomountRoot } from "./home";
+import { truncateRetainedUtf8 } from "../lib/admission";
 
 const SHIM_MARKER = "opencodex codex autostart shim";
 const CODEX_SHIM_PROBE_BYTES = 16 * 1024;
 export const CODEX_SHIM_REPLACEMENT_STABLE_MS = 100;
 export const CODEX_SHIM_STATE_MAX_BYTES = 1024 * 1024;
 const CODEX_SHIM_RESTORE_LOCK_STALE_MS = 30_000;
+const MAX_DIAGNOSTIC_VALUE_BYTES = 8 * 1024;
 let lastShimDiscoveryError: string | null = null;
 /** Last human-readable reason discovery returned null (exposed for doctor/tests). */
 export function lastCodexDiscoveryError(): string | null {
@@ -309,10 +311,12 @@ export function findCodexOnPath(deps: CodexPathScanDeps = {}): string | null {
   }
 
   if (skippedInterop) {
-    lastShimDiscoveryError =
+    lastShimDiscoveryError = truncateRetainedUtf8(
       `Found a Windows codex at ${skippedInterop} via WSL PATH interop, but no Linux-side codex. ` +
       "Refusing to shim a Windows launcher from WSL (a WSL shim breaks Windows invocations). " +
-      "Install codex inside WSL (npm i -g @openai/codex), or run 'ocx ensure' from Windows to shim the Windows side.";
+      "Install codex inside WSL (npm i -g @openai/codex), or run 'ocx ensure' from Windows to shim the Windows side.",
+      MAX_DIAGNOSTIC_VALUE_BYTES,
+    );
   }
   return null;
 }
@@ -324,9 +328,11 @@ function findWindowsCodexTargets(): ShimFileState[] | null {
     if (existsSync(exe) && !isShim(exe)) {
       try {
         if (!lstatSync(exe).isDirectory()) {
-          lastShimDiscoveryError =
+          lastShimDiscoveryError = truncateRetainedUtf8(
             `Found codex.exe at ${exe}. Refusing to rename a real .exe because exact codex.exe invocations would break; ` +
-            "install a codex.cmd/codex.ps1 launcher or use `ocx service install` for autostart.";
+            "install a codex.cmd/codex.ps1 launcher or use `ocx service install` for autostart.",
+            MAX_DIAGNOSTIC_VALUE_BYTES,
+          );
           return null;
         }
       } catch { /* keep scanning */ }

package/src/codex/subagent-model-fallback.ts

@@ -26,6 +26,7 @@ import { isThreadSpawnRequest } from "../server/effort-policy";
 import { PROVIDER_REGISTRY } from "../providers/registry";
 import { isCanonicalOpenAiForwardProvider } from "../providers/openai-tiers";
 import { routeModel, type RouteResult } from "../router";
+import { sweepExpiredOnWrite } from "../lib/state-store-sweeper";
 export const DEFAULT_SUBAGENT_MODEL_FALLBACK_POLL_MS = 60_000;
 
 type SubagentQuotaPrimeFn = (config: OcxConfig, reason: string) => Promise<void>;
@@ -245,6 +246,17 @@ export function noteSubagentModelFailure(
       reason: "quota_exhausted",
     },
   );
+  sweepExpiredOnWrite(now);
+}
+
+export function sweepExpiredSubagentModelHealth(now = Date.now()): number {
+  let removed = 0;
+  for (const [key, health] of modelHealth) {
+    if (health.unavailableUntil > now) continue;
+    modelHealth.delete(key);
+    removed += 1;
+  }
+  return removed;
 }
 
 export function resetSubagentModelFallbackStateForTests(): void {

package/src/codex/websocket-registry.ts

@@ -1,5 +1,32 @@
 import type { ServerWebSocket } from "bun";
 import type { WsData } from "../server/ws-bridge";
+import { createAdmissionGate, type AdmissionMetrics, type AdmissionReservation } from "../lib/admission";
+
+export const MAX_TRACKED_CODEX_WEBSOCKETS = 128;
+const websocketGate = createAdmissionGate("codex_websockets", MAX_TRACKED_CODEX_WEBSOCKETS);
+
+export function tryReserveCodexWebSocket(): AdmissionReservation<ServerWebSocket<WsData>> | null {
+  const gateLease = websocketGate.tryAcquire();
+  if (!gateLease) return null;
+  let socket: ServerWebSocket<WsData> | undefined;
+  let active = true;
+  return {
+    bind(value) {
+      if (!active) return;
+      socket = value;
+    },
+    release() {
+      if (!active) return;
+      active = false;
+      socket = undefined;
+      gateLease.release();
+    },
+  };
+}
+
+export function codexWebSocketAdmissionMetrics(): AdmissionMetrics {
+  return websocketGate.metrics();
+}
 
 const socketsByAccount = new Map<string, Set<ServerWebSocket<WsData>>>();
 

package/src/combos/failover.ts

@@ -1,6 +1,11 @@
 import { classifyError, isCyberPolicyCode } from "../lib/errors";
 import type { OcxComboTarget } from "../types";
 import { targetKey } from "./types";
+import {
+  captureConfigGeneration,
+  sweepExpiredOnWrite,
+  type GenerationContext,
+} from "../lib/state-store-sweeper";
 
 interface TargetCooldown {
   cooldownUntil: number;
@@ -11,6 +16,8 @@ const MAX_COOLDOWN_MS = 10 * 60_000;
 
 /** Map<`${comboId}\0${provider/model}`, TargetCooldown> */
 const targetCooldowns = new Map<string, TargetCooldown>();
+let lastReconciledGeneration = 0;
+let liveComboTargets = new Set<string>();
 
 function cooldownMapKey(
   comboId: string,
@@ -55,20 +62,43 @@ export function isComboTargetInCooldown(
 export function coolComboTarget(
   comboId: string,
   target: Pick<OcxComboTarget, "provider" | "model">,
-  options?: { retryAfter?: string | null; now?: number; cooldownMs?: number },
+  options?: { retryAfter?: string | null; now?: number; cooldownMs?: number; writerGeneration?: number },
 ): void {
   const now = options?.now ?? Date.now();
+  const writerGeneration = options?.writerGeneration ?? captureConfigGeneration();
+  const ownerKey = `${comboId}::${targetKey(target)}`;
+  if (writerGeneration < lastReconciledGeneration && !liveComboTargets.has(ownerKey)) return;
   const cooldownMs = options?.cooldownMs
     ?? parseRetryAfterMs(options?.retryAfter, now)
     ?? DEFAULT_COOLDOWN_MS;
   targetCooldowns.set(cooldownMapKey(comboId, target), {
     cooldownUntil: now + Math.min(Math.max(cooldownMs, 1), MAX_COOLDOWN_MS),
   });
+  sweepExpiredOnWrite(now);
+}
+
+export function reconcileComboTargetCooldowns(context: GenerationContext): number {
+  if (context.generation <= lastReconciledGeneration) return 0;
+  liveComboTargets = new Set(context.comboTargets);
+  lastReconciledGeneration = context.generation;
+  return 0;
+}
+
+export function sweepExpiredComboTargetCooldowns(now = Date.now()): number {
+  let removed = 0;
+  for (const [key, cooldown] of targetCooldowns) {
+    if (cooldown.cooldownUntil > now) continue;
+    targetCooldowns.delete(key);
+    removed += 1;
+  }
+  return removed;
 }
 
 export function clearComboTargetCooldowns(comboId?: string): void {
   if (comboId === undefined) {
     targetCooldowns.clear();
+    liveComboTargets.clear();
+    lastReconciledGeneration = 0;
     return;
   }
   const prefix = `${comboId}\0`;

package/src/combos/request.ts

@@ -2,6 +2,15 @@ import type { OcxComboDefaultEffort, OcxComboTarget, OcxConfig } from "../types"
 import { resolveComboId } from "./types";
 
 const warnedUnsupportedDefaults = new Set<string>();
+let lastWarningReconciledGeneration = 0;
+
+export function reconcileComboWarningMemos(generation: number): number {
+  if (generation <= lastWarningReconciledGeneration) return 0;
+  const removed = warnedUnsupportedDefaults.size;
+  warnedUnsupportedDefaults.clear();
+  lastWarningReconciledGeneration = generation;
+  return removed;
+}
 
 export function resetComboEffortWarningStateForTests(): void {
   warnedUnsupportedDefaults.clear();

package/src/combos/resolve.ts

@@ -2,12 +2,17 @@ import type { OcxComboTarget, OcxConfig } from "../types";
 import { coolComboTarget, isComboTargetInCooldown } from "./failover";
 import { getCombo, resolveComboId, targetKey } from "./types";
 import type { NormalizedComboConfig } from "./types";
+import {
+  captureConfigGeneration,
+  type GenerationContext,
+} from "../lib/state-store-sweeper";
 
 export interface ComboPick {
   comboId: string;
   target: Required<OcxComboTarget>;
   targetIndex: number;
   attempted: string[];
+  writerGeneration: number;
 }
 
 interface SelectionState {
@@ -17,6 +22,17 @@ interface SelectionState {
 }
 
 const selectionState = new Map<string, SelectionState>();
+let lastReconciledGeneration = 0;
+let liveComboTargets = new Set<string>();
+
+function comboTargetOwnerKey(comboId: string, key: string): string {
+  return `${comboId}::${key}`;
+}
+
+function mayCommitComboState(comboId: string, key: string, writerGeneration: number): boolean {
+  return writerGeneration >= lastReconciledGeneration
+    || liveComboTargets.has(comboTargetOwnerKey(comboId, key));
+}
 
 export class UnknownComboError extends Error {
   constructor(readonly comboId: string) {
@@ -74,6 +90,7 @@ export function pickComboTarget(
     eligible?: (target: Required<OcxComboTarget>) => boolean;
   } = {},
 ): ComboPick | null {
+  const writerGeneration = captureConfigGeneration();
   const combo = getCombo(config, comboId);
   if (!combo) throw new UnknownComboError(comboId);
   const excluded = new Set(options.exclude ?? []);
@@ -114,6 +131,7 @@ export function pickComboTarget(
     target,
     targetIndex,
     attempted: [...excluded, targetKey(target)],
+    writerGeneration,
   };
 }
 
@@ -121,10 +139,13 @@ export function noteComboSuccess(
   comboId: string,
   combo: NormalizedComboConfig,
   target: Required<OcxComboTarget>,
+  writerGeneration = captureConfigGeneration(),
 ): void {
   if (combo.strategy !== "round-robin") return;
+  const key = targetKey(target);
+  if (!mayCommitComboState(comboId, key, writerGeneration)) return;
   const state = selectionState.get(comboId);
-  if (!state || state.activeKey !== targetKey(target)) return;
+  if (!state || state.activeKey !== key) return;
   state.successes += 1;
   if (state.successes >= combo.stickyLimit) {
     delete state.activeKey;
@@ -132,7 +153,12 @@ export function noteComboSuccess(
   }
 }
 
-export function noteComboFailure(comboId: string, target: OcxComboTarget): void {
+export function noteComboFailure(
+  comboId: string,
+  target: OcxComboTarget,
+  writerGeneration = captureConfigGeneration(),
+): void {
+  if (!mayCommitComboState(comboId, targetKey(target), writerGeneration)) return;
   const state = selectionState.get(comboId);
   if (state?.activeKey === targetKey(target)) {
     delete state.activeKey;
@@ -149,8 +175,11 @@ export function advanceComboAfterFailure(
     eligible?: (target: Required<OcxComboTarget>) => boolean;
   } = {},
 ): ComboPick | null {
-  noteComboFailure(pick.comboId, pick.target);
-  coolComboTarget(pick.comboId, pick.target, options);
+  noteComboFailure(pick.comboId, pick.target, pick.writerGeneration);
+  coolComboTarget(pick.comboId, pick.target, {
+    ...options,
+    writerGeneration: pick.writerGeneration,
+  });
   return pickComboTarget(config, pick.comboId, {
     exclude: pick.attempted,
     eligible: target => !isComboTargetInCooldown(pick.comboId, target, options.now)
@@ -158,9 +187,36 @@ export function advanceComboAfterFailure(
   });
 }
 
+export function reconcileComboRotationState(context: GenerationContext): number {
+  if (context.generation <= lastReconciledGeneration) return 0;
+  let removed = 0;
+  for (const [comboId, state] of selectionState) {
+    if (!context.comboIds.has(comboId)) {
+      selectionState.delete(comboId);
+      removed += 1;
+      continue;
+    }
+    if (state.activeKey && !context.comboTargets.has(comboTargetOwnerKey(comboId, state.activeKey))) {
+      delete state.activeKey;
+      state.successes = 0;
+      removed += 1;
+    }
+    for (const key of state.currentWeights.keys()) {
+      if (context.comboTargets.has(comboTargetOwnerKey(comboId, key))) continue;
+      state.currentWeights.delete(key);
+      removed += 1;
+    }
+  }
+  liveComboTargets = new Set(context.comboTargets);
+  lastReconciledGeneration = context.generation;
+  return removed;
+}
+
 export function clearComboSelectionState(comboId?: string): void {
   if (comboId === undefined) {
     selectionState.clear();
+    liveComboTargets.clear();
+    lastReconciledGeneration = 0;
     return;
   }
   selectionState.delete(comboId);

package/src/combos/types.ts

@@ -304,6 +304,18 @@ export function listComboIds(config: { combos?: Record<string, OcxComboConfig> }
   return Object.keys(config.combos ?? {}).sort((a, b) => a.localeCompare(b));
 }
 
+export function listLiveComboTargetKeys(
+  config: { combos?: Record<string, OcxComboConfig> },
+): ReadonlySet<string> {
+  const keys = new Set<string>();
+  for (const id of listComboIds(config)) {
+    const combo = getCombo(config, id);
+    if (!combo) continue;
+    for (const target of combo.targets) keys.add(`${id}::${targetKey(target)}`);
+  }
+  return keys;
+}
+
 export function getCombo(
   config: { combos?: Record<string, OcxComboConfig> },
   id: string,