@remodex/rmx 1.0.2

package/src/codex/paths.ts

@@ -0,0 +1,78 @@
+import { realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { expandUserPath } from "../config";
+import { defaultCodexHome } from "./home";
+
+function resolveCodexHome(): string {
+  const raw = process.env.CODEX_HOME?.trim();
+  if (raw) {
+    const path = resolve(expandUserPath(raw));
+    let stat;
+    try {
+      stat = statSync(path);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`CODEX_HOME points to ${raw}, but that path could not be read: ${message}`);
+    }
+    if (!stat.isDirectory()) {
+      throw new Error(`CODEX_HOME points to ${raw}, but that path is not a directory`);
+    }
+    return realpathSync.native(path);
+  }
+
+  return defaultCodexHome();
+}
+
+export const CODEX_HOME = resolveCodexHome();
+export const CODEX_CONFIG_PATH = join(CODEX_HOME, "config.toml");
+export const CODEX_PROFILE_PATH = join(CODEX_HOME, "opencodex.config.toml");
+export const DEFAULT_CATALOG_PATH = join(CODEX_HOME, "opencodex-catalog.json");
+/**
+ * Catalog consumed by Codex instances launched with the Remodex profile.
+ *
+ * Keep this separate from both config.toml and Codex's private models_cache.json:
+ * config.toml remains user-owned, while models_cache.json is an implementation
+ * cache whose wrapper and invalidation semantics can change between Codex builds.
+ */
+export const CODEX_EXTERNAL_MODELS_PATH = join(CODEX_HOME, "models.json");
+export const CODEX_MODELS_CACHE_PATH = join(CODEX_HOME, "models_cache.json");
+
+/** Runtime CODEX_HOME lookup (honors CODEX_HOME env changes after import). */
+export function getCodexHome(): string {
+  return resolveCodexHome();
+}
+
+/** Runtime path lookup for callers that capture CODEX_HOME after module import. */
+export function externalCodexModelsPath(codexHome = getCodexHome()): string {
+  return join(codexHome, "models.json");
+}
+
+export function tomlString(value: string): string {
+  return JSON.stringify(value);
+}
+
+export function parseTomlString(raw: string): string {
+  if (raw.startsWith("\"")) {
+    try {
+      return JSON.parse(raw) as string;
+    } catch {
+      return raw.slice(1, -1);
+    }
+  }
+  return raw.slice(1, -1);
+}
+
+export function readRootTomlString(content: string, key: string): string | null {
+  const lines = content.split("\n");
+  const firstTable = lines.findIndex(l => /^\s*\[/.test(l));
+  const rootLines = firstTable === -1 ? lines : lines.slice(0, firstTable);
+  for (const line of rootLines) {
+    const m = line.match(new RegExp(`^\\s*${key}\\s*=\\s*(\"(?:\\\\.|[^\"])*\"|'[^']*')`));
+    if (m) return parseTomlString(m[1]);
+  }
+  return null;
+}
+
+export function resolveCodexConfigPath(path: string): string {
+  return isAbsolute(path) ? path : join(CODEX_HOME, path);
+}

package/src/codex/plugins-doctor.ts

@@ -0,0 +1,242 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { CODEX_CONFIG_PATH } from "./paths";
+import { redactUserPath } from "../lib/redact";
+
+// Mirrors codex-rs core-plugins/src/marketplace.rs MARKETPLACE_MANIFEST_RELATIVE_PATHS.
+// A marketplace root "resolves" only when one of these files exists under it.
+const MARKETPLACE_MANIFEST_RELATIVE_PATHS = [
+  ".agents/plugins/marketplace.json",
+  ".claude-plugin/marketplace.json",
+] as const;
+
+const OPENAI_BUNDLED_MARKETPLACE_NAME = "openai-bundled";
+
+// Where the Codex desktop app's bundled plugins live, relative to an install
+// root. Windows app-package paths embed the app version, so the actual install
+// root is discovered by scanning candidate bases (LOCALAPPDATA, etc.) rather
+// than hardcoded. The bundled marketplace dir is named after the marketplace.
+const BUNDLED_MARKETPLACE_LEAF = join("plugins", "bundled-marketplaces", OPENAI_BUNDLED_MARKETPLACE_NAME);
+const CODEX_APP_DIR_SEGMENTS = [join("Programs", "@openai", "codex"), join("Programs", "codex"), join("@openai", "codex"), "codex"] as const;
+
+// Plugins the issue (#43) calls out. Treated as data, not as an authoritative
+// allowlist: codex-rs only allowlists chrome/computer-use, but the diagnostic
+// just reports presence, so listing browser here is informational only.
+const COMMON_BUNDLED_PLUGINS = ["computer-use", "browser", "chrome"] as const;
+
+export type CodexPluginsDiagnostic =
+  | { applicable: false; reason: string; summary: string }
+  | {
+      applicable: true;
+      stale: boolean;
+      marketplace: {
+        name: string;
+        present: boolean;
+        sourceType: string | null;
+        source: string | null;
+        resolvesToManifest: boolean;
+        currentBundledPath: string | null;
+        pathMismatch: boolean;
+      };
+      bundledPlugins: Array<{ id: string; configured: boolean }>;
+      suggestedRepair: string | null;
+      summary: string;
+    };
+
+/** True when the table at `[marketplaces.<name>]` exists in the config text. */
+function readMarketplaceTable(configText: string, name: string): Record<string, string> | null {
+  // Split on CRLF or LF: config.toml on Windows (the platform this diagnostic
+  // targets) uses CRLF, and a leftover \r would defeat the `$`-anchored regexes.
+  const lines = configText.split(/\r?\n/);
+  const header = new RegExp(`^\\s*\\[marketplaces\\.(?:"${escapeRegExp(name)}"|${escapeRegExp(name)})\\]\\s*(?:#.*)?$`);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (header.test(lines[i] ?? "")) { start = i + 1; break; }
+  }
+  if (start === -1) return null;
+
+  const table: Record<string, string> = {};
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (/^\s*\[/.test(line)) break; // next table starts; stop
+    const m = line.match(/^\s*([A-Za-z0-9_-]+)\s*=\s*("(?:\\.|[^"])*"|'[^']*'|[^#]+?)\s*(?:#.*)?$/);
+    if (!m) continue;
+    table[m[1]] = unquoteTomlValue(m[2].trim());
+  }
+  return table;
+}
+
+function unquoteTomlValue(raw: string): string {
+  if (raw.startsWith("\"")) {
+    try { return JSON.parse(raw) as string; } catch { return raw.slice(1, -1); }
+  }
+  if (raw.startsWith("'")) return raw.slice(1, -1);
+  return raw;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** A directory is a bundled-marketplace root when it holds a supported manifest. */
+function dirHasManifest(dir: string): boolean {
+  return MARKETPLACE_MANIFEST_RELATIVE_PATHS.some(rel => existsSync(join(dir, rel)));
+}
+
+/**
+ * Locate the bundled `openai-bundled` marketplace dir under the installed Codex
+ * desktop app on Windows. Windows app paths embed the app version, so we scan
+ * candidate install bases for a versioned app dir whose
+ * `plugins/bundled-marketplaces/openai-bundled` holds a manifest. Returns the
+ * newest matching dir (by mtime) or null. Filesystem access is injectable for
+ * tests so a Windows layout can be exercised on any OS.
+ */
+export function locateCurrentBundledMarketplace(
+  options: {
+    env?: NodeJS.ProcessEnv;
+    listDir?: (dir: string) => string[];
+    isManifestRoot?: (dir: string) => boolean;
+    mtimeOf?: (dir: string) => number;
+  } = {},
+): string | null {
+  const env = options.env ?? process.env;
+  const listDir = options.listDir ?? ((dir: string) => {
+    try { return readdirSync(dir); } catch { return []; }
+  });
+  const isManifestRoot = options.isManifestRoot ?? dirHasManifest;
+  const mtimeOf = options.mtimeOf ?? ((dir: string) => {
+    try { return statSync(dir).mtimeMs; } catch { return 0; }
+  });
+
+  const bases = [env.LOCALAPPDATA, env.PROGRAMFILES, env["ProgramFiles(x86)"], env.APPDATA]
+    .filter((b): b is string => typeof b === "string" && b.length > 0);
+
+  const candidates: string[] = [];
+  for (const base of bases) {
+    for (const seg of CODEX_APP_DIR_SEGMENTS) {
+      const appRoot = join(base, seg);
+      // Direct (unversioned) layout.
+      const direct = join(appRoot, BUNDLED_MARKETPLACE_LEAF);
+      if (isManifestRoot(direct)) candidates.push(direct);
+      // Versioned layout: appRoot/<version>/plugins/bundled-marketplaces/openai-bundled
+      for (const child of listDir(appRoot)) {
+        const versioned = join(appRoot, child, BUNDLED_MARKETPLACE_LEAF);
+        if (isManifestRoot(versioned)) candidates.push(versioned);
+      }
+    }
+  }
+  if (candidates.length === 0) return null;
+  candidates.sort((a, b) => mtimeOf(b) - mtimeOf(a));
+  return candidates[0] ?? null;
+}
+
+/** Normalize a path for comparison: lowercase + unify separators (Windows is case-insensitive). */
+function normalizePathForCompare(path: string): string {
+  return path.replace(/[\\/]+/g, "\\").replace(/\\+$/, "").toLowerCase();
+}
+
+/** A local marketplace `source` resolves when it holds a supported manifest. */
+function sourceResolvesToManifest(source: string): boolean {
+  if (!isAbsolute(source)) return false;
+  if (!existsSync(source)) return false;
+  return MARKETPLACE_MANIFEST_RELATIVE_PATHS.some(rel => existsSync(join(source, rel)));
+}
+
+/**
+ * Read-only diagnostic for the Codex `openai-bundled` plugin marketplace.
+ *
+ * Only meaningful on Windows, where app-package paths embed the app version and
+ * go stale after an update. On other platforms it reports "not applicable".
+ * NEVER mutates config.toml, never invokes `codex plugin marketplace add`.
+ */
+export function diagnoseCodexBundledPlugins(
+  options: {
+    platform?: NodeJS.Platform;
+    configPath?: string;
+    locateCurrent?: () => string | null;
+  } = {},
+): CodexPluginsDiagnostic {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") {
+    return {
+      applicable: false,
+      reason: "not_windows",
+      summary: "not applicable (bundled-marketplace staleness is Windows-specific)",
+    };
+  }
+
+  const configPath = options.configPath ?? CODEX_CONFIG_PATH;
+  let configText: string;
+  try {
+    configText = readFileSync(configPath, "utf8");
+  } catch {
+    return {
+      applicable: false,
+      reason: "config_unreadable",
+      summary: "not applicable (Codex config.toml not found or unreadable)",
+    };
+  }
+
+  const table = readMarketplaceTable(configText, OPENAI_BUNDLED_MARKETPLACE_NAME);
+  const present = table !== null;
+  const sourceType = table?.source_type ?? null;
+  const source = table?.source ?? null;
+  const isLocal = sourceType === "local" && !!source;
+  const resolvesToManifest = isLocal ? sourceResolvesToManifest(source as string) : false;
+
+  // Locate the bundled marketplace under the currently installed Codex app, so
+  // we can tell "registered path differs from the live app path" (the Windows
+  // app-update staleness signal) apart from a merely missing manifest.
+  const locateCurrent = options.locateCurrent ?? (() => locateCurrentBundledMarketplace());
+  const currentBundledPath = locateCurrent();
+  const pathMismatch = !!(
+    currentBundledPath && source && isLocal &&
+    normalizePathForCompare(currentBundledPath) !== normalizePathForCompare(source)
+  );
+
+  // Stale = a registered local bundled marketplace whose source no longer
+  // resolves to a manifest, OR whose registered path differs from the live
+  // app's bundled path (the Windows app-update signal). A missing marketplace
+  // is "not stale" but flagged separately by `present: false`.
+  const stale = present && isLocal && (!resolvesToManifest || pathMismatch);
+  // Present but not a usable local entry (wrong source_type or empty source):
+  // not "stale" in the app-update sense, but it must NOT be reported as healthy.
+  const malformed = present && !isLocal;
+
+  const bundledPlugins = COMMON_BUNDLED_PLUGINS.map(id => ({
+    id,
+    configured: new RegExp(`\\[plugins\\.(?:"${escapeRegExp(`${id}@${OPENAI_BUNDLED_MARKETPLACE_NAME}`)}")\\]`).test(configText),
+  }));
+
+  const repairTarget = currentBundledPath ?? `<current ${OPENAI_BUNDLED_MARKETPLACE_NAME} path under the installed Codex app>`;
+  const suggestedRepair = (stale || pathMismatch)
+    ? `codex plugin marketplace add ${currentBundledPath ? redactUserPath(currentBundledPath) : repairTarget}`
+    : null;
+
+  const summary = !present
+    ? `no [marketplaces.${OPENAI_BUNDLED_MARKETPLACE_NAME}] entry in Codex config`
+    : malformed
+      ? `[marketplaces.${OPENAI_BUNDLED_MARKETPLACE_NAME}] is present but not a usable local source (source_type/source missing)`
+      : !resolvesToManifest
+        ? `stale: registered ${OPENAI_BUNDLED_MARKETPLACE_NAME} source no longer resolves to a marketplace manifest`
+        : pathMismatch
+          ? `stale: registered ${OPENAI_BUNDLED_MARKETPLACE_NAME} path differs from the installed Codex app's bundled path`
+          : `ok: ${OPENAI_BUNDLED_MARKETPLACE_NAME} marketplace resolves`;
+
+  return {
+    applicable: true,
+    stale,
+    marketplace: {
+      name: OPENAI_BUNDLED_MARKETPLACE_NAME,
+      present,
+      sourceType,
+      source: source ? redactUserPath(source) : null,
+      resolvesToManifest,
+      currentBundledPath: currentBundledPath ? redactUserPath(currentBundledPath) : null,
+      pathMismatch,
+    },
+    bundledPlugins,
+    suggestedRepair,
+    summary,
+  };
+}

package/src/codex/pool-rotation.ts

@@ -0,0 +1,295 @@
+import type { OcxAccountPoolRotationStrategy } from "../types";
+import type { GenerationContext } from "../lib/state-store-sweeper";
+
+export const POOL_KEY_CODEX = "codex";
+export const POOL_KEY_ANTHROPIC = "anthropic";
+
+interface SelectionState {
+  activeKey?: string;
+  successes: number;
+  currentWeights: Map<string, number>;
+}
+
+const selectionState = new Map<string, SelectionState>();
+let lastReconciledGeneration = 0;
+
+const DEFAULT_STICKY_LIMIT = 1;
+const MIN_STICKY_LIMIT = 1;
+const MAX_STICKY_LIMIT = 100;
+const DEFAULT_STRATEGY: OcxAccountPoolRotationStrategy = "quota";
+const VALID_STRATEGIES = new Set<OcxAccountPoolRotationStrategy>(["quota", "round-robin", "fill-first"]);
+
+/** Selection order for an account with no stored preference: one flat tier. */
+export const DEFAULT_ACCOUNT_PRIORITY = 0;
+export const MIN_ACCOUNT_PRIORITY = -100;
+export const MAX_ACCOUNT_PRIORITY = 100;
+
+/** Strict parse for management APIs — returns null instead of defaulting. */
+export function parseAccountPoolStrategy(raw: unknown): OcxAccountPoolRotationStrategy | null {
+  if (typeof raw === "string" && VALID_STRATEGIES.has(raw as OcxAccountPoolRotationStrategy)) {
+    return raw as OcxAccountPoolRotationStrategy;
+  }
+  return null;
+}
+
+/** Strict parse for management APIs — returns null instead of defaulting. */
+export function parseAccountPoolStickyLimit(raw: unknown): number | null {
+  if (typeof raw === "number" && Number.isInteger(raw) && raw >= MIN_STICKY_LIMIT && raw <= MAX_STICKY_LIMIT) {
+    return raw;
+  }
+  return null;
+}
+
+export function normalizeAccountPoolStrategy(raw: unknown): OcxAccountPoolRotationStrategy {
+  return parseAccountPoolStrategy(raw) ?? DEFAULT_STRATEGY;
+}
+
+export function normalizeAccountPoolStickyLimit(raw: unknown): number {
+  return parseAccountPoolStickyLimit(raw) ?? DEFAULT_STICKY_LIMIT;
+}
+
+/** Strict parse for management APIs — returns null instead of defaulting. */
+export function parseAccountPriority(raw: unknown): number | null {
+  if (
+    typeof raw === "number"
+    && Number.isInteger(raw)
+    && raw >= MIN_ACCOUNT_PRIORITY
+    && raw <= MAX_ACCOUNT_PRIORITY
+  ) {
+    return raw;
+  }
+  return null;
+}
+
+export function normalizeAccountPriority(raw: unknown): number {
+  return parseAccountPriority(raw) ?? DEFAULT_ACCOUNT_PRIORITY;
+}
+
+/**
+ * Narrow an already-eligible account list to the highest selection-order tier that
+ * still has usable quota. Priority is an *ordering* boundary layered on top of
+ * eligibility: it never admits an account the caller already filtered out, and it
+ * never keeps the pool on a tier whose every member is drained.
+ *
+ * Contract (each clause is load-bearing for "no behavior change when unconfigured"):
+ * - one distinct priority across `ids` (the unconfigured case) returns `ids` unchanged,
+ *   so today's pick sequence is preserved byte for byte;
+ * - input order is preserved inside the returned tier, which keeps the `__main__`
+ *   head-of-list bias and the first-index tie-break used by SWRR/lowest-usage;
+ * - every tier drained returns `ids` unchanged, reproducing today's
+ *   stay-put-until-429 behavior rather than inventing a pick;
+ * - a `pinnedId` that is present *and* has headroom lowers the ceiling to its own
+ *   tier, which is what makes a manual "use this now" survive round-robin and
+ *   fill-first without any mutable selection state. A drained or absent pin is
+ *   ignored, so the pin expires on its own once the account crosses the threshold.
+ */
+export function selectPriorityTier(
+  ids: readonly string[],
+  priorityOf: (id: string) => number,
+  hasHeadroom: (id: string) => boolean,
+  pinnedId?: string,
+): readonly string[] {
+  // Readonly out as well as in: the no-change cases return the caller's own array, so a
+  // mutating caller would corrupt its input in exactly the cases that must not change.
+  const list = ids;
+  if (list.length <= 1) return list;
+
+  const priorities = list.map(priorityOf);
+  const firstPriority = priorities[0]!;
+  if (priorities.every(priority => priority === firstPriority)) return list;
+
+  let ceiling = Number.POSITIVE_INFINITY;
+  if (pinnedId !== undefined) {
+    const pinnedIndex = list.indexOf(pinnedId);
+    if (pinnedIndex >= 0 && hasHeadroom(pinnedId)) ceiling = priorities[pinnedIndex]!;
+  }
+
+  const tiers = [...new Set(priorities)].sort((a, b) => b - a);
+  for (const tier of tiers) {
+    if (tier > ceiling) continue;
+    const members = list.filter((_, index) => priorities[index] === tier);
+    if (members.some(hasHeadroom)) return members;
+  }
+  return list;
+}
+
+function getOrCreateState(poolKey: string): SelectionState {
+  let state = selectionState.get(poolKey);
+  if (!state) {
+    state = { successes: 0, currentWeights: new Map() };
+    selectionState.set(poolKey, state);
+  }
+  return state;
+}
+
+function cloneSelectionState(state: SelectionState): SelectionState {
+  return {
+    activeKey: state.activeKey,
+    successes: state.successes,
+    currentWeights: new Map(state.currentWeights),
+  };
+}
+
+function smoothWeightedIndex(ids: readonly string[], state: SelectionState): number {
+  let best = -1;
+  let bestScore = Number.NEGATIVE_INFINITY;
+  let total = 0;
+  const weight = 1;
+  for (let i = 0; i < ids.length; i++) {
+    const id = ids[i]!;
+    const score = (state.currentWeights.get(id) ?? 0) + weight;
+    state.currentWeights.set(id, score);
+    total += weight;
+    if (score > bestScore) {
+      best = i;
+      bestScore = score;
+    }
+  }
+  if (best >= 0) {
+    const key = ids[best]!;
+    state.currentWeights.set(key, (state.currentWeights.get(key) ?? 0) - total);
+  }
+  return best;
+}
+
+/**
+ * Shared pick core. Mutates `state` the same way live resolve does; callers pass
+ * either the live map entry or a scratch/clone for dry-run peek.
+ */
+function pickRoundRobinFromState(
+  eligibleIds: readonly string[],
+  stickyLimit: number,
+  state: SelectionState,
+  commitSticky: boolean,
+): string | null {
+  if (eligibleIds.length === 0) return null;
+
+  const limit = normalizeAccountPoolStickyLimit(stickyLimit);
+
+  if (state.activeKey && eligibleIds.includes(state.activeKey)) {
+    return state.activeKey;
+  }
+
+  if (state.activeKey) {
+    delete state.activeKey;
+    state.successes = 0;
+  }
+
+  const index = smoothWeightedIndex(eligibleIds, state);
+  if (index < 0) return null;
+
+  const picked = eligibleIds[index]!;
+  if (commitSticky && limit > 1) {
+    state.activeKey = picked;
+    state.successes = 0;
+  }
+  return picked;
+}
+
+export function pickRoundRobinAccount(
+  poolKey: string,
+  eligibleIds: readonly string[],
+  stickyLimit: number,
+): string | null {
+  return pickRoundRobinFromState(eligibleIds, stickyLimit, getOrCreateState(poolKey), true);
+}
+
+/**
+ * Dry-run of {@link pickRoundRobinAccount}: returns the same account resolve would
+ * pick without advancing ring weights, activeKey, or successes.
+ */
+export function peekRoundRobinAccount(
+  poolKey: string,
+  eligibleIds: readonly string[],
+  stickyLimit: number,
+): string | null {
+  const live = selectionState.get(poolKey);
+  const scratch = live
+    ? cloneSelectionState(live)
+    : { successes: 0, currentWeights: new Map<string, number>() };
+  return pickRoundRobinFromState(eligibleIds, stickyLimit, scratch, false);
+}
+
+export function notePoolRotationSuccess(
+  poolKey: string,
+  accountId: string,
+  stickyLimit: number,
+): void {
+  const limit = normalizeAccountPoolStickyLimit(stickyLimit);
+  const state = selectionState.get(poolKey);
+  if (!state) return;
+  if (state.activeKey !== accountId) {
+    state.activeKey = accountId;
+    state.successes = 0;
+  }
+  state.successes += 1;
+  if (state.successes >= limit) {
+    delete state.activeKey;
+    state.successes = 0;
+  }
+}
+
+export function notePoolRotationFailure(poolKey: string, accountId: string): void {
+  const state = selectionState.get(poolKey);
+  if (state?.activeKey === accountId) {
+    delete state.activeKey;
+    state.successes = 0;
+  }
+}
+
+/**
+ * Force the next sticky/RR pick onto `accountId` (manual dashboard selection).
+ * Clears sticky success counters and ring weights so the seeded account is held
+ * for the next new-session pick before ordinary rotation resumes.
+ */
+export function seedPoolRotationAccount(poolKey: string, accountId: string): void {
+  const state = getOrCreateState(poolKey);
+  state.activeKey = accountId;
+  state.successes = 0;
+  state.currentWeights.clear();
+}
+
+export function clearPoolRotationState(poolKey?: string): void {
+  if (poolKey === undefined) {
+    selectionState.clear();
+    return;
+  }
+  selectionState.delete(poolKey);
+}
+
+export function reconcilePoolRotationState(context: GenerationContext): number {
+  if (context.generation <= lastReconciledGeneration) return 0;
+  const anthropicIds = new Set<string>();
+  for (const key of context.oauthAccountKeys) {
+    const separator = key.indexOf("\0");
+    if (separator > 0 && key.slice(0, separator) === "anthropic") {
+      anthropicIds.add(key.slice(separator + 1));
+    }
+  }
+  let removed = 0;
+  for (const [poolKey, state] of selectionState) {
+    const valid = poolKey === POOL_KEY_ANTHROPIC
+      ? anthropicIds
+      : poolKey === POOL_KEY_CODEX || poolKey.startsWith(`${POOL_KEY_CODEX}:`)
+        ? context.codexAccountIds
+        : null;
+    if (!valid) continue;
+    if (valid.size === 0) {
+      selectionState.delete(poolKey);
+      removed += 1;
+      continue;
+    }
+    if (state.activeKey && !valid.has(state.activeKey)) {
+      delete state.activeKey;
+      state.successes = 0;
+      removed += 1;
+    }
+    for (const accountId of state.currentWeights.keys()) {
+      if (valid.has(accountId)) continue;
+      state.currentWeights.delete(accountId);
+      removed += 1;
+    }
+  }
+  lastReconciledGeneration = context.generation;
+  return removed;
+}