diff --git a/README.md b/README.md
index 25f5ebb56..9233bad04 100644
--- a/README.md
+++ b/README.md
@@ -96,6 +96,17 @@ account exclusion, affinity expiry, or 401/403 and 429 recovery can rebind them.
 selection order when one of them — usually your Codex Desktop login — should only be reached for
 once the others are drained.
 
+Command Code supports an opt-in OAuth account pool
+(`config.commandCodeAccountPool.enabled`):
+sticky session affinity, 429 failover, and new-session quota / round-robin / fill-first
+picking with per-account 5h + weekly usage bars in the dashboard. The GUI's account
+panel shows an **Add account** button that opens the login and also accepts a pasted
+redirect URL / authorization code / raw API key (Command Code).
+Pool settings are explicit under `commandCodeAccountPool`:
+`enabled`, `autoSwitchThreshold` (0–100), `strategy` (`quota`, `round-robin`, or
+`fill-first`), and `stickyLimit` (1–100). Command Code also supports
+`accountPriorities` (-100–100 per account) and `activeAccountPinned`.
+
 ### For agents
 
 ```bash
diff --git a/gui/src/components/provider-workspace/ProviderAuthPanel.tsx b/gui/src/components/provider-workspace/ProviderAuthPanel.tsx
index 60c15225d..279939176 100644
--- a/gui/src/components/provider-workspace/ProviderAuthPanel.tsx
+++ b/gui/src/components/provider-workspace/ProviderAuthPanel.tsx
@@ -119,6 +119,10 @@ export default function ProviderAuthPanel({
   const [addingKey, setAddingKey] = useState(false);
   const [newKey, setNewKey] = useState("");
   const [keyBusy, setKeyBusy] = useState(false);
+  const [manualCode, setManualCode] = useState("");
+  const [manualCodeBusy, setManualCodeBusy] = useState(false);
+  const [manualCodeMsg, setManualCodeMsg] = useState("");
+  const [manualCodeOk, setManualCodeOk] = useState(true);
   const [importBusy, setImportBusy] = useState(false);
   const [importStatus, setImportStatus] = useState<"idle" | "invalid" | "failed" | "complete">("idle");
   const [importResult, setImportResult] = useState<CockpitImportResult | null>(null);
@@ -195,6 +199,25 @@ export default function ProviderAuthPanel({
     }
   };
 
+  const submitManualCode = async () => {
+    const input = manualCode.trim();
+    if (!input || manualCodeBusy || !authHandlers.onSubmitManualCode) return;
+    setManualCodeBusy(true);
+    setManualCodeMsg("");
+    try {
+      await authHandlers.onSubmitManualCode(item.name, input);
+      setManualCode("");
+      setManualCodeOk(true);
+      setManualCodeMsg(t("prov.pasteOk"));
+    } catch (error) {
+      setManualCodeOk(false);
+      const message = error instanceof Error && error.message.trim() ? error.message : t("prov.networkError");
+      setManualCodeMsg(t("prov.pasteFail", { error: message }));
+    } finally {
+      setManualCodeBusy(false);
+    }
+  };
+
   const importCockpitFile = async (file: File | undefined) => {
     if (!file || importBusy) return;
     setImportBusy(true);
@@ -326,6 +349,53 @@ export default function ProviderAuthPanel({
                     </div>
                   )}
                   <LoginUrlBlock url={hintForThis.url ?? ""} />
+                  {authHandlers.onSubmitManualCode && (
+                    <div className="pwi-auth-paste">
+                      <div className="muted text-label">
+                        {item.name === "command-code"
+                          ? t("prov.pasteCommandCodeHint")
+                          : t("prov.pasteRedirectHint")}
+                      </div>
+                      <div style={{ display: "flex", gap: 8 }}>
+                        <input
+                          type={item.name === "command-code" ? "password" : "text"}
+                          autoComplete="off"
+                          spellCheck={false}
+                          value={manualCode}
+                          onChange={e => { setManualCode(e.target.value); setManualCodeMsg(""); }}
+                          onKeyDown={e => {
+                            if (e.key === "Enter" && manualCode.trim()) {
+                              e.preventDefault();
+                              void submitManualCode();
+                            }
+                          }}
+                          placeholder={item.name === "command-code" ? t("prov.pasteCommandCodePlaceholder") : t("prov.pasteRedirect")}
+                          aria-label={item.name === "command-code" ? t("prov.pasteCommandCodePlaceholder") : t("prov.pasteRedirect")}
+                          disabled={manualCodeBusy}
+                          className="input text-label"
+                          style={{ flex: 1 }}
+                        />
+                        <button
+                          className="btn btn-ghost"
+                          type="button"
+                          disabled={manualCodeBusy || !manualCode.trim()}
+                          onClick={() => void submitManualCode()}
+                        >
+                          {manualCodeBusy ? t("prov.pasteSubmitting") : t("prov.pasteSubmit")}
+                        </button>
+                      </div>
+                      {manualCodeMsg && (
+                        <div
+                          role={manualCodeOk ? "status" : "alert"}
+                          aria-atomic="true"
+                          className="text-label"
+                          style={{ color: manualCodeOk ? "var(--accent-hover)" : "var(--amber)" }}
+                        >
+                          {manualCodeMsg}
+                        </div>
+                      )}
+                    </div>
+                  )}
                   {authHandlers.onCancelLogin && (
                     <button type="button" className="btn btn-ghost btn-sm" onClick={() => void authHandlers.onCancelLogin?.(item.name)}>
                       {t("common.cancel")}
diff --git a/gui/src/components/provider-workspace/types.ts b/gui/src/components/provider-workspace/types.ts
index 97e6f1969..7173d7aa8 100644
--- a/gui/src/components/provider-workspace/types.ts
+++ b/gui/src/components/provider-workspace/types.ts
@@ -74,6 +74,8 @@ export type AccountLoadState = "idle" | "loading" | "ready" | "error";
 export interface ProviderAuthHandlers {
   onLogin: (provider: string, addAccount?: boolean) => void | Promise<void>;
   onCancelLogin?: (provider: string) => void;
+  /** Submit a pasted redirect URL / authorization code / raw API key to an in-progress login. */
+  onSubmitManualCode?: (provider: string, input: string) => void | Promise<void>;
   onLogout: (provider: string) => void | Promise<void>;
   onReauth: (provider: string, accountId?: string) => void | Promise<void>;
   onSwitchAccount: (provider: string, account: OAuthAccountRow) => void | Promise<void>;
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index 189d1d27b..4ad919484 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -363,7 +363,9 @@ export const de: Record<TKey, string> = {
   "prov.aliasSaveFailed": "Alias konnte nicht gespeichert werden",
   "prov.accountId": "ID",
   "prov.pasteRedirect": "Redirect-URL oder Code einfügen",
-  "prov.pasteRedirectHint": "Zeigt der Browser einen localhost-Fehler, kopiere die vollständige URL aus der Adressleiste und füge sie hier ein (oder den Autorisierungscode).",
+  "prov.pasteRedirectHint": "Falls der Browser einen localhost-Fehler zeigt, kopieren Sie die vollständige URL aus der Adressleiste und fügen Sie sie hier ein (oder fügen Sie den Autorisierungscode ein).",
+  "prov.pasteCommandCodePlaceholder": "Command-Code-API-Schlüssel oder Redirect-URL einfügen",
+  "prov.pasteCommandCodeHint": "Fügen Sie einen Command-Code-API-Schlüssel (user_… aus ~/.commandcode/auth.json) ein, um ihn als weiteres Konto hinzuzufügen. Alternativ können Sie die Redirect-URL aus dem Browser einfügen.",
   "prov.pasteSubmit": "Senden",
   "prov.pasteSubmitting": "Wird gesendet…",
   "prov.pasteOk": "Code gesendet — Anmeldung wird abgeschlossen…",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index c25243a93..fc0b29db4 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -381,6 +381,8 @@ export const en = {
   "prov.accountId": "ID",
   "prov.pasteRedirect": "Paste redirect URL or code",
   "prov.pasteRedirectHint": "If the browser shows a localhost error, copy the full URL from its address bar and paste it here (or paste the authorization code).",
+  "prov.pasteCommandCodePlaceholder": "Paste Command Code API key or redirect URL",
+  "prov.pasteCommandCodeHint": "Paste a Command Code API key (user_… from ~/.commandcode/auth.json) to add it as another account, or the redirect URL from the browser.",
   "prov.pasteSubmit": "Submit",
   "prov.pasteSubmitting": "Submitting…",
   "prov.pasteOk": "Code submitted — finishing login…",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index 2e5b277dc..7f3455a2b 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -369,7 +369,9 @@ export const ja: Record<TKey, string> = {
   "prov.copyCode": "コードをコピー",
   "prov.codeCopied": "コードをコピーしました",
   "prov.pasteRedirect": "リダイレクト URL またはコードを貼り付け",
-  "prov.pasteRedirectHint": "ブラウザに localhost エラーが表示された場合、アドレスバーから URL 全体をコピーしてここに貼り付けてください(または認可コードを貼り付け)。",
+  "prov.pasteRedirectHint": "ブラウザに localhost エラーが表示された場合は、アドレスバーの完全な URL をコピーしてここに貼り付けてください（認可コードも可）。",
+  "prov.pasteCommandCodePlaceholder": "Command Code API キーまたはリダイレクト URL を貼り付け",
+  "prov.pasteCommandCodeHint": "Command Code API キー（~/.commandcode/auth.json の user_…）を貼り付けると別のアカウントとして追加されます。またはブラウザのリダイレクト URL を貼り付けます。",
   "prov.pasteSubmit": "送信",
   "prov.pasteSubmitting": "送信中…",
   "prov.pasteOk": "コードを送信しました — ログインを完了しています…",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index 96d0f226f..e282164e4 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -372,7 +372,9 @@ export const ko: Record<TKey, string> = {
   "prov.aliasSaveFailed": "별칭을 저장하지 못했습니다",
   "prov.accountId": "ID",
   "prov.pasteRedirect": "리다이렉트 URL 또는 코드 붙여넣기",
-  "prov.pasteRedirectHint": "브라우저에 localhost 오류가 표시되면, 주소창의 전체 URL을 복사해 여기에 붙여넣으세요(또는 인증 코드 붙여넣기).",
+  "prov.pasteRedirectHint": "브라우저에 localhost 오류가 표시되면 주소 표시줄의 전체 URL을 복사하여 여기에 붙여넣으세요(또는 인증 코드를 붙여넣으세요).",
+  "prov.pasteCommandCodePlaceholder": "Command Code API 키 또는 리다이렉트 URL 붙여넣기",
+  "prov.pasteCommandCodeHint": "Command Code API 키(~/.commandcode/auth.json의 user_…)를 붙여넣어 다른 계정으로 추가하거나 브라우저의 리다이렉트 URL을 붙여넣으세요.",
   "prov.pasteSubmit": "제출",
   "prov.pasteSubmitting": "제출 중…",
   "prov.pasteOk": "코드를 제출했습니다 — 로그인 완료 중…",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index d1d842966..a1443615d 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -374,7 +374,9 @@ export const ru: Record<TKey, string> = {
   "prov.aliasSaveFailed": "Не удалось сохранить псевдоним",
   "prov.accountId": "ID",
   "prov.pasteRedirect": "Вставьте URL перенаправления или код",
-  "prov.pasteRedirectHint": "Если браузер показывает ошибку localhost, скопируйте полный URL из его адресной строки и вставьте сюда (или вставьте код авторизации).",
+  "prov.pasteRedirectHint": "Если браузер показывает ошибку localhost, скопируйте полный URL из адресной строки и вставьте его сюда (или вставьте код авторизации).",
+  "prov.pasteCommandCodePlaceholder": "Вставьте API-ключ Command Code или URL перенаправления",
+  "prov.pasteCommandCodeHint": "Вставьте API-ключ Command Code (user_… из ~/.commandcode/auth.json), чтобы добавить его как ещё один аккаунт, или URL перенаправления из браузера.",
   "prov.pasteSubmit": "Отправить",
   "prov.pasteSubmitting": "Отправка…",
   "prov.pasteOk": "Код отправлен — завершаем вход…",
diff --git a/gui/src/i18n/tr.ts b/gui/src/i18n/tr.ts
index 77c81d666..3cb0219ac 100644
--- a/gui/src/i18n/tr.ts
+++ b/gui/src/i18n/tr.ts
@@ -377,7 +377,9 @@ export const tr: Record<TKey, string> = {
   "prov.aliasSaveFailed": "Takma ad kaydedilemedi",
   "prov.accountId": "ID",
   "prov.pasteRedirect": "Yönlendirme URL'sini veya kodu yapıştırın",
-  "prov.pasteRedirectHint": "Tarayıcı localhost hatası gösterirse adres çubuğundaki URL'yi kopyalayıp buraya yapıştırın.",
+  "prov.pasteRedirectHint": "Tarayıcı bir localhost hatası gösteriyorsa, adres çubuğundaki tam URL'yi kopyalayıp buraya yapıştırın (veya yetkilendirme kodunu yapıştırın).",
+  "prov.pasteCommandCodePlaceholder": "Command Code API anahtarını veya yönlendirme URL'sini yapıştırın",
+  "prov.pasteCommandCodeHint": "Başka bir hesap olarak eklemek için bir Command Code API anahtarı (user_…, ~/.commandcode/auth.json) veya tarayıcıdan yönlendirme URL'sini yapıştırın.",
   "prov.pasteSubmit": "Gönder",
   "prov.pasteSubmitting": "Gönderiliyor…",
   "prov.pasteOk": "Kod gönderildi — giriş tamamlanıyor…",
diff --git a/gui/src/i18n/zh-TW.ts b/gui/src/i18n/zh-TW.ts
index 7a119a666..5a461ae97 100644
--- a/gui/src/i18n/zh-TW.ts
+++ b/gui/src/i18n/zh-TW.ts
@@ -264,7 +264,9 @@ export const zhTW: Record<TKey, string> = {
   "prov.aliasSaveFailed": "無法儲存別名",
   "prov.accountId": "ID",
   "prov.pasteRedirect": "貼上重定向 URL 或授權碼",
-  "prov.pasteRedirectHint": "如果瀏覽器顯示 localhost 錯誤，請複製位址列中的完整 URL 並貼上到此處（或貼上授權碼）。",
+  "prov.pasteRedirectHint": "如果瀏覽器顯示 localhost 錯誤，請複製網址列的完整 URL 並貼到此處（或貼上授權碼）。",
+  "prov.pasteCommandCodePlaceholder": "貼上 Command Code API 金鑰或重新導向 URL",
+  "prov.pasteCommandCodeHint": "貼上 Command Code API 金鑰（~/.commandcode/auth.json 中的 user_…）以新增為另一個帳戶，或貼上瀏覽器中的重新導向 URL。",
   "prov.pasteSubmit": "提交",
   "prov.pasteSubmitting": "提交中…",
   "prov.pasteOk": "已提交授權碼 — 正在完成登入…",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 9825780ec..5b6c72708 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -369,7 +369,9 @@ export const zh: Record<TKey, string> = {
   "prov.aliasSaveFailed": "无法保存别名",
   "prov.accountId": "ID",
   "prov.pasteRedirect": "粘贴重定向 URL 或授权码",
-  "prov.pasteRedirectHint": "如果浏览器显示 localhost 错误，请复制地址栏中的完整 URL 并粘贴到此处（或粘贴授权码）。",
+  "prov.pasteRedirectHint": "如果浏览器显示 localhost 错误，请复制地址栏中的完整 URL 并粘贴到这里（或粘贴授权码）。",
+  "prov.pasteCommandCodePlaceholder": "粘贴 Command Code API 密钥或重定向 URL",
+  "prov.pasteCommandCodeHint": "粘贴 Command Code API 密钥（~/.commandcode/auth.json 中的 user_…）以添加为另一个账户，或粘贴浏览器中的重定向 URL。",
   "prov.pasteSubmit": "提交",
   "prov.pasteSubmitting": "提交中…",
   "prov.pasteOk": "已提交代码 — 正在完成登录…",
diff --git a/gui/src/pages/Providers.tsx b/gui/src/pages/Providers.tsx
index d51c9b58c..1081acd97 100644
--- a/gui/src/pages/Providers.tsx
+++ b/gui/src/pages/Providers.tsx
@@ -213,7 +213,7 @@ export default function Providers({ apiBase }: { apiBase: string }) {
 
   const bumpModelsRefresh = () => setModelsRefreshToken(n => n + 1);
 
-  const { cancelLoginOAuth, loginOAuth, logoutOAuth } = useProvidersOAuth({
+  const { cancelLoginOAuth, loginOAuth, logoutOAuth, submitManualCode } = useProvidersOAuth({
     apiBase, t, aliveRef, accountSets, setAccountSets,
     setBusy, setStatus, setLoginInfo, setOauthStatus, notify,
     fetchConfig, fetchOauth, fetchAccountSets, fetchProviderQuotas, bumpModelsRefresh,
@@ -367,6 +367,7 @@ export default function Providers({ apiBase }: { apiBase: string }) {
             authHandlers={{
               onLogin: requestLoginOAuth,
               onCancelLogin: cancelLoginOAuth,
+              onSubmitManualCode: submitManualCode,
               onLogout: logoutOAuth,
               onReauth: (provider, accountId) => loginOAuth(provider, true, accountId),
               onSwitchAccount: switchAccount,
diff --git a/gui/src/pages/use-providers-oauth.ts b/gui/src/pages/use-providers-oauth.ts
index 456d33e61..26905c589 100644
--- a/gui/src/pages/use-providers-oauth.ts
+++ b/gui/src/pages/use-providers-oauth.ts
@@ -211,5 +211,24 @@ export function useProvidersOAuth({
     }
   };
 
-  return { cancelLoginOAuth, loginOAuth, logoutOAuth };
+  const submitManualCode = async (provider: string, input: string) => {
+    try {
+      const res = await fetch(`${apiBase}/api/oauth/login/code`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ provider, input }),
+      });
+      if (!aliveRef.current) return;
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({})) as { error?: string };
+        throw new Error(data.error || res.statusText);
+      }
+    } catch (error) {
+      if (aliveRef.current) {
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+    }
+  };
+
+  return { cancelLoginOAuth, loginOAuth, logoutOAuth, submitManualCode };
 }
diff --git a/gui/src/styles/provider-workspace-settings.css b/gui/src/styles/provider-workspace-settings.css
index 4fc0d52dc..d2298dfd5 100644
--- a/gui/src/styles/provider-workspace-settings.css
+++ b/gui/src/styles/provider-workspace-settings.css
@@ -30,6 +30,7 @@
 .pwi-auth-wait-title { font-size: var(--text-control); font-weight: 600; color: var(--text); }
 .pwi-auth-wait-copy  { font-size: var(--text-label); color: var(--muted); line-height: 1.45; }
 .pwi-device-code-wrap { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; padding: 12px; margin: 6px 0; border: 1px solid var(--border); border-radius: 10px; background: var(--surface); }
+.pwi-auth-paste { display: flex; flex-direction: column; gap: 6px; margin-top: 8px; }
 .pwi-device-code { font-size: 20px; font-weight: 800; letter-spacing: .14em; color: var(--text); user-select: all; }
 .pwi-auth-row-copy { min-width: 0; display: flex; flex-direction: column; align-items: flex-start; gap: 2px; }
 .pwi-auth-row-secondary { max-width: 100%; overflow: hidden; text-overflow: ellipsis; font-size: var(--text-label); color: var(--muted); }
diff --git a/gui/tests/provider-auth-manual-code.test.tsx b/gui/tests/provider-auth-manual-code.test.tsx
new file mode 100644
index 000000000..ed2aa5677
--- /dev/null
+++ b/gui/tests/provider-auth-manual-code.test.tsx
@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, expect, mock, test } from "bun:test";
+import { Window } from "happy-dom";
+import { act } from "react";
+import type { Root } from "react-dom/client";
+import { LanguageProvider } from "../src/i18n/provider";
+import ProviderAuthPanel from "../src/components/provider-workspace/ProviderAuthPanel";
+import type { ProviderAuthHandlers } from "../src/components/provider-workspace/types";
+import type { WorkspaceItem } from "../src/provider-workspace/catalog";
+
+const globals = ["document", "window", "navigator", "localStorage", "IS_REACT_ACT_ENVIRONMENT"] as const;
+let previous: Record<(typeof globals)[number], unknown>;
+let win: Window;
+let host: HTMLElement;
+let root: Root | null = null;
+let submit: (provider: string, input: string) => Promise<void>;
+let rejection: unknown;
+
+const item: WorkspaceItem = {
+  name: "command-code",
+  adapter: "command-code",
+  baseUrl: "https://api.commandcode.ai",
+  authMode: "oauth",
+};
+
+beforeEach(() => {
+  previous = Object.fromEntries(globals.map(key => [key, Reflect.get(globalThis, key)])) as typeof previous;
+  win = new Window({ url: "http://localhost/" });
+  Object.defineProperty(win.navigator, "language", { configurable: true, value: "en-US" });
+  rejection = new Error("invalid authorization code");
+  submit = mock(async () => {
+    if (rejection) throw rejection;
+  });
+  Object.defineProperties(globalThis, {
+    document: { configurable: true, value: win.document }, window: { configurable: true, value: win },
+    navigator: { configurable: true, value: win.navigator }, localStorage: { configurable: true, value: win.localStorage },
+  });
+  (globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+  host = win.document.createElement("div") as unknown as HTMLElement;
+  win.document.body.appendChild(host as never);
+});
+
+afterEach(async () => {
+  if (root) { const current = root; await act(async () => { current.unmount(); }); root = null; }
+  for (const key of globals) Object.defineProperty(globalThis, key, { configurable: true, value: previous[key] });
+  await win.happyDOM?.close?.();
+});
+
+test("masks pasted Command Code credentials and preserves rejection feedback", async () => {
+  // React DOM must bind to the happy-dom globals installed in beforeEach.
+  const { createRoot } = await import("react-dom/client");
+  await act(async () => {
+    root = createRoot(host);
+    root.render(
+      <LanguageProvider>
+        <ProviderAuthPanel
+          item={item}
+          apiBase=""
+          busy
+          loginHint={{ provider: "command-code", url: "https://example.test/login" }}
+          authHandlers={{
+            onLogin: () => {}, onLogout: () => {}, onReauth: () => {}, onSwitchAccount: () => {}, onRemoveAccount: () => {},
+            onAddApiKey: async () => true, onSwitchApiKey: () => {}, onRemoveApiKey: () => {}, onEditAlias: () => {},
+            onSubmitManualCode: submit,
+          }}
+        />
+      </LanguageProvider>,
+    );
+  });
+
+  const input = host.querySelector('input[type="password"]') as HTMLInputElement;
+  expect(input).toBeTruthy();
+  expect(input.type).toBe("password");
+  await act(async () => {
+    const setter = Object.getOwnPropertyDescriptor(win.HTMLInputElement.prototype, "value")!.set!;
+    setter.call(input, "user_secret");
+    input.dispatchEvent(new win.Event("input", { bubbles: true }));
+  });
+  expect(input.value).toBe("user_secret");
+  expect((host.querySelector(".pwi-auth-paste button") as HTMLButtonElement).disabled).toBe(false);
+  await act(async () => {
+    (host.querySelector(".pwi-auth-paste button") as HTMLButtonElement).click();
+    await new Promise(resolve => setTimeout(resolve, 0));
+  });
+  expect(submit).toHaveBeenCalledWith("command-code", "user_secret");
+  expect(host.textContent).toContain("invalid authorization code");
+  expect(host.querySelector('[role="alert"]')?.textContent).toContain("invalid authorization code");
+
+  rejection = {};
+  await act(async () => {
+    (host.querySelector(".pwi-auth-paste button") as HTMLButtonElement).click();
+    await new Promise(resolve => setTimeout(resolve, 0));
+  });
+  expect(host.textContent).toContain("Could not submit code: Network error. Check that the proxy is running and try again.");
+  expect(host.querySelector('[role="alert"]')?.textContent).toContain("Network error");
+
+  rejection = null;
+  await act(async () => {
+    (host.querySelector(".pwi-auth-paste button") as HTMLButtonElement).click();
+    await new Promise(resolve => setTimeout(resolve, 0));
+  });
+  expect(host.querySelector('[role="status"]')?.textContent).toContain("Code submitted — finishing login…");
+});
diff --git a/src/cli/account-api.ts b/src/cli/account-api.ts
index be0e2e39e..66bc93abd 100644
--- a/src/cli/account-api.ts
+++ b/src/cli/account-api.ts
@@ -236,9 +236,10 @@ interface OAuthAccountDto {
   email?: string;
   active?: boolean;
   needsReauth?: boolean;
+  priority?: number;
 }
 
-async function fetchOAuthRows(deps: AccountDeps, baseUrl: string, name: string): Promise<FamilyRows> {
+export async function fetchOAuthRows(deps: AccountDeps, baseUrl: string, name: string): Promise<FamilyRows> {
   const res = await apiJson(deps, baseUrl, "GET", `/api/oauth/accounts?provider=${encodeURIComponent(name)}`);
   if (res.status === 0) return { rows: [], activeId: null, status: 0, networkDown: true };
   if (res.status !== 200) return { rows: [], activeId: null, status: res.status, errorJson: res.json };
@@ -252,6 +253,7 @@ async function fetchOAuthRows(deps: AccountDeps, baseUrl: string, name: string):
     email: a.email,
     active: a.active ?? a.id === activeId,
     needsReauth: a.needsReauth,
+    priority: typeof a.priority === "number" ? a.priority : 0,
   }));
   return { rows, activeId, status: 200 };
 }
diff --git a/src/cli/account-extended.ts b/src/cli/account-extended.ts
index 27b87137b..ba93ef12c 100644
--- a/src/cli/account-extended.ts
+++ b/src/cli/account-extended.ts
@@ -11,6 +11,7 @@ import {
   apiJson,
   classifyAccount,
   fetchCodexRows,
+  fetchOAuthRows,
   fetchProviderQuotaReport,
   fetchRows,
   proxyUnreachable,
@@ -345,8 +346,9 @@ export async function cmdAutoSwitch(args: string[], deps: AccountDeps): Promise<
   const action = args.shift();
   if (!name || !action) return usage();
   const classified = configAndType(deps, name);
-  if ("error" in classified || classified.type !== "codex") {
-    return usage("Error: auto-switch only applies to the openai Codex account pool");
+  const oauthPool = !('error' in classified) && classified.type === "oauth" && name === "command-code";
+  if ("error" in classified || (classified.type !== "codex" && !oauthPool)) {
+    return usage("Error: auto-switch applies to the openai Codex account pool and command-code");
   }
   let threshold: number | undefined;
   if (action === "on" && args.length === 0) threshold = 80;
@@ -359,14 +361,22 @@ export async function cmdAutoSwitch(args: string[], deps: AccountDeps): Promise<
   const baseUrl = await resolveBaseUrl(deps);
   if (!baseUrl) return proxyUnreachable();
   if (action === "status") {
-    const response = await apiJson(deps, baseUrl, "GET", "/api/codex-auth/active");
+    const response = oauthPool
+      ? await apiJson(deps, baseUrl, "GET", `/api/oauth/accounts/pool?provider=${encodeURIComponent(name)}`)
+      : await apiJson(deps, baseUrl, "GET", "/api/codex-auth/active");
     if (response.status === 0) return proxyUnreachable();
     if (response.status !== 200 || typeof response.json.autoSwitchThreshold !== "number") {
       return apiError(response.json, "failed to read auto-switch status");
     }
     threshold = response.json.autoSwitchThreshold;
   } else {
-    const response = await apiJson(deps, baseUrl, "PUT", "/api/codex-auth/auto-switch", { threshold });
+    const response = oauthPool
+      ? await apiJson(deps, baseUrl, "PUT", "/api/oauth/accounts/pool", {
+        provider: name,
+        autoSwitchThreshold: threshold,
+        enabled: threshold! > 0,
+      })
+      : await apiJson(deps, baseUrl, "PUT", "/api/codex-auth/auto-switch", { threshold });
     if (response.status === 0) return proxyUnreachable();
     if (response.status !== 200) return apiError(response.json, "failed to update auto-switch");
   }
@@ -572,8 +582,8 @@ export async function cmdImport(args: string[], deps: AccountDeps): Promise<numb
  * `devlog/_plan/260726_cooldown_lockout_hardening`: injected routing makes the proxy the
  * only model path for Codex Desktop, so a stuck cooldown reads as "the whole app is dead".
  *
- * Codex accounts only. API-key pools already reset their own 429 cooldowns through key
- * management (`clearKeyCooldowns`), and OAuth providers have no equivalent state here.
+ * Codex and Command Code OAuth accounts. API-key pools reset their own 429 cooldowns
+ * through key management (`clearKeyCooldowns`).
  */
 export async function cmdClearCooldown(args: string[], deps: AccountDeps): Promise<number> {
   const wantsJson = flag(args, "--json");
@@ -582,13 +592,16 @@ export async function cmdClearCooldown(args: string[], deps: AccountDeps): Promi
   if (!name || !requestedId || args.length) return usage();
   const classified = configAndType(deps, name);
   if ("error" in classified) return usage(`Error: ${classified.error}`);
-  if (classified.type !== "codex") {
-    return usage(`Error: ${name} is not a Codex account pool; cooldown clearing applies to Codex accounts only`);
+  const oauthPool = classified.type === "oauth" && name === "command-code";
+  if (classified.type !== "codex" && !oauthPool) {
+    return usage(`Error: ${name} cooldown clearing applies to Codex and command-code pools only`);
   }
   const id = requestedId === "main" ? MAIN_ID : requestedId;
   const baseUrl = await resolveBaseUrl(deps);
   if (!baseUrl) return proxyUnreachable();
-  const response = await apiJson(deps, baseUrl, "POST", "/api/codex-auth/accounts/clear-cooldown", { id });
+  const response = oauthPool
+    ? await apiJson(deps, baseUrl, "POST", "/api/oauth/accounts/clear-cooldown", { provider: name, accountId: id })
+    : await apiJson(deps, baseUrl, "POST", "/api/codex-auth/accounts/clear-cooldown", { id });
   if (response.status === 0) return proxyUnreachable();
   if (response.status !== 200) return apiError(response.json, `failed to clear cooldown for ${requestedId}`);
   const cleared = response.json?.cleared === true;
@@ -642,8 +655,9 @@ export async function cmdPriority(args: string[], deps: AccountDeps): Promise<nu
   if (!name || !requestedId || args.length) return usage();
   const classified = configAndType(deps, name);
   if ("error" in classified) return usage(`Error: ${classified.error}`);
-  if (classified.type !== "codex") {
-    return usage("Error: selection order only applies to the openai Codex account pool");
+  const oauthPool = classified.type === "oauth" && name === "command-code";
+  if (classified.type !== "codex" && !oauthPool) {
+    return usage("Error: selection order applies to the openai Codex account pool and command-code");
   }
   const id = requestedId === "main" ? MAIN_ID : requestedId;
 
@@ -661,7 +675,9 @@ export async function cmdPriority(args: string[], deps: AccountDeps): Promise<nu
 
   // No value means "show" — a read must not rewrite what it is reporting.
   if (priority === undefined) {
-    const result = await fetchCodexRows(deps, baseUrl);
+    const result = oauthPool
+      ? await fetchOAuthRows(deps, baseUrl, name)
+      : await fetchCodexRows(deps, baseUrl);
     const failed = familyFailure(result, `failed to read ${name} accounts`);
     if (failed !== null) return failed;
     const row = result.rows.find(candidate => candidate.id === id);
@@ -679,7 +695,9 @@ export async function cmdPriority(args: string[], deps: AccountDeps): Promise<nu
     return 0;
   }
 
-  const response = await apiJson(deps, baseUrl, "PUT", "/api/codex-auth/accounts/priority", { id, priority });
+  const response = oauthPool
+    ? await apiJson(deps, baseUrl, "PUT", "/api/oauth/accounts/pool/priority", { provider: name, id, priority })
+    : await apiJson(deps, baseUrl, "PUT", "/api/codex-auth/accounts/priority", { id, priority });
   if (response.status === 0) return proxyUnreachable();
   if (response.status !== 200) return apiError(response.json, `failed to set selection order for ${requestedId}`);
   const applied = typeof response.json.priority === "number" ? response.json.priority : (priority ?? 0);
diff --git a/src/codex/pool-rotation.ts b/src/codex/pool-rotation.ts
index d0d032be0..60fbbb836 100644
--- a/src/codex/pool-rotation.ts
+++ b/src/codex/pool-rotation.ts
@@ -3,6 +3,7 @@ import type { GenerationContext } from "../lib/state-store-sweeper";
 
 export const POOL_KEY_CODEX = "codex";
 export const POOL_KEY_ANTHROPIC = "anthropic";
+export const POOL_KEY_COMMAND_CODE = "command-code";
 
 interface SelectionState {
   activeKey?: string;
@@ -260,16 +261,22 @@ export function clearPoolRotationState(poolKey?: string): void {
 export function reconcilePoolRotationState(context: GenerationContext): number {
   if (context.generation <= lastReconciledGeneration) return 0;
   const anthropicIds = new Set<string>();
+  const commandCodeIds = 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));
     }
+    if (separator > 0 && key.slice(0, separator) === "command-code") {
+      commandCodeIds.add(key.slice(separator + 1));
+    }
   }
   let removed = 0;
   for (const [poolKey, state] of selectionState) {
     const valid = poolKey === POOL_KEY_ANTHROPIC
       ? anthropicIds
+      : poolKey === POOL_KEY_COMMAND_CODE
+        ? commandCodeIds
       : poolKey === POOL_KEY_CODEX || poolKey.startsWith(`${POOL_KEY_CODEX}:`)
         ? context.codexAccountIds
         : null;
diff --git a/src/lib/state-store-registrations.ts b/src/lib/state-store-registrations.ts
index 151402d2f..8a2141fd9 100644
--- a/src/lib/state-store-registrations.ts
+++ b/src/lib/state-store-registrations.ts
@@ -31,6 +31,7 @@ import {
   sweepExpiredXaiPermanentFailureVerdicts,
 } from "../oauth";
 import { sweepExpiredAnthropicRoutingHealth } from "../oauth/anthropic-routing";
+import { sweepExpiredOAuthPoolRoutingHealth } from "../oauth/oauth-pool-routing";
 import { listLiveOAuthAccountKeys, reconcileOAuthReauthState } from "../oauth/store";
 import { reconcileGuardianBackoff } from "../oauth/token-guardian";
 import { sweepExpiredApiKeyCooldowns } from "../providers/key-failover";
@@ -81,6 +82,7 @@ export const STATE_STORE_REGISTRATIONS = [
     reconcileGeneration: reconcileComboTargetCooldowns,
   },
   { name: "anthropic-routing-health", sweepExpired: sweepExpiredAnthropicRoutingHealth },
+  { name: "oauth-pool-routing-health", sweepExpired: now => sweepExpiredOAuthPoolRoutingHealth(undefined, now) },
   { name: "xai-refresh-verdicts", sweepExpired: sweepExpiredXaiPermanentFailureVerdicts },
   { name: "responses-continuation", sweepExpired: sweepExpiredResponseStates },
   { name: "antigravity-replay", sweepExpired: sweepExpiredAntigravityReplay },
diff --git a/src/oauth/command-code-routing.ts b/src/oauth/command-code-routing.ts
new file mode 100644
index 000000000..2a5afc466
--- /dev/null
+++ b/src/oauth/command-code-routing.ts
@@ -0,0 +1,170 @@
+/**
+ * Command Code OAuth account pool — thin adapter over the generic OAuth pool
+ * router (oauth-pool-routing.ts), mirroring the Codex pool rotation strategy.
+ *
+ * Default OFF via `config.commandCodeAccountPool.enabled`. See the generic
+ * router docs for the full behavior contract.
+ */
+import {
+  getAccountSet,
+  getAccountCredential,
+} from "./store";
+import { POOL_KEY_COMMAND_CODE } from "../codex/pool-rotation";
+import {
+  bindOAuthPoolSessionAffinity,
+  clearOAuthPoolAccountCooldown,
+  clearOAuthPoolSessionAffinityForAccount,
+  clearOAuthPoolState,
+  formatOAuthPoolAccountOrdinal,
+  formatOAuthPoolProviderForLog,
+  getEligibleOAuthPoolAccounts,
+  getOAuthPoolAccountHealthSnapshot,
+  getOAuthPoolAccessToken,
+  getOAuthPoolRetryAfterSeconds,
+  isOAuthPoolEnabled,
+  oauthPoolAutoSwitchThreshold,
+  oauthPoolSessionAffinitySizeForTests,
+  oauthPoolSessionKeyFromParts,
+  OAUTH_POOL_MAX_FAILOVERS_PER_REQUEST,
+  promoteOAuthPoolActiveAccount,
+  resetOAuthPoolRoutingForManualSelection,
+  resolveOAuthPoolAccountForSession,
+  rotateOAuthPoolAccountOn429,
+  sweepExpiredOAuthPoolRoutingHealth,
+  type OAuthAccountPoolConfig,
+  type OAuthPoolEligibilityHooks,
+  type OAuthPoolProviderHooks,
+  type OAuthPoolSelection,
+  type OAuthPoolSelectionReason,
+} from "./oauth-pool-routing";
+import type { OcxConfig } from "../types";
+
+const PROVIDER = "command-code";
+
+/** Config slice for the command-code pool. */
+export function commandCodeAccountPoolConfig(config: OcxConfig): OAuthAccountPoolConfig {
+  return hooks.configOf(config) ?? {};
+}
+
+const hooks: OAuthPoolProviderHooks = {
+  configOf: config => config.commandCodeAccountPool,
+  priorityOf: config => {
+    const priorities = config.commandCodeAccountPool?.accountPriorities;
+    if (!priorities) return () => 0;
+    return accountId => (
+      Object.hasOwn(priorities, accountId)
+        ? (Number.isFinite(priorities[accountId]) ? Math.max(-100, Math.min(100, priorities[accountId]!)) : 0)
+        : 0
+    );
+  },
+  pinnedOf: config => config.commandCodeAccountPool?.activeAccountPinned,
+  poolKey: POOL_KEY_COMMAND_CODE,
+};
+
+const eligibility: OAuthPoolEligibilityHooks = {
+  canRefresh: accountId => {
+    const set = getAccountSet(PROVIDER);
+    const cred = getAccountCredential(PROVIDER, accountId);
+    if (!cred) return false;
+    if (cred.source !== "local-cli") return true;
+    return set?.activeAccountId === accountId;
+  },
+};
+
+export { PROVIDER as COMMAND_CODE_POOL_PROVIDER };
+export const COMMAND_CODE_POOL_MAX_FAILOVERS_PER_REQUEST = OAUTH_POOL_MAX_FAILOVERS_PER_REQUEST;
+
+export function isCommandCodeAccountPoolEnabled(config: OcxConfig): boolean {
+  return isOAuthPoolEnabled(config, hooks);
+}
+
+export function commandCodeAutoSwitchThreshold(config: OcxConfig): number {
+  return oauthPoolAutoSwitchThreshold(config, hooks);
+}
+
+export function getCommandCodeAccountHealthSnapshot(accountId: string, now = Date.now()) {
+  return getOAuthPoolAccountHealthSnapshot(PROVIDER, accountId, now);
+}
+
+export function clearCommandCodeAccountCooldown(accountId: string): boolean {
+  return clearOAuthPoolAccountCooldown(PROVIDER, accountId);
+}
+
+export function sweepExpiredCommandCodeRoutingHealth(now = Date.now()): number {
+  return sweepExpiredOAuthPoolRoutingHealth(PROVIDER, now);
+}
+
+export function clearCommandCodeAccountPoolState(): void {
+  clearOAuthPoolState(PROVIDER);
+}
+
+export function commandCodeSessionAffinitySizeForTests(): number {
+  return oauthPoolSessionAffinitySizeForTests(PROVIDER);
+}
+
+export function getEligibleCommandCodeAccounts(now = Date.now()): string[] {
+  return getEligibleOAuthPoolAccounts(PROVIDER, hooks, eligibility, undefined, now);
+}
+
+export function getCommandCodePoolRetryAfterSeconds(now = Date.now()): number | null {
+  return getOAuthPoolRetryAfterSeconds(PROVIDER, now);
+}
+
+export function resolveCommandCodeAccountForSession(
+  sessionKey: string | null | undefined,
+  config: OcxConfig,
+  now = Date.now(),
+): OAuthPoolSelection {
+  return resolveOAuthPoolAccountForSession(PROVIDER, sessionKey, config, hooks, eligibility, now);
+}
+
+export function bindCommandCodeSessionAffinity(sessionKey: string | null | undefined, accountId: string, now = Date.now()): void {
+  bindOAuthPoolSessionAffinity(PROVIDER, sessionKey, accountId, now);
+}
+
+export function clearCommandCodeSessionAffinityForAccount(accountId: string): void {
+  clearOAuthPoolSessionAffinityForAccount(PROVIDER, accountId);
+}
+
+export function rotateCommandCodeAccountOn429(
+  config: OcxConfig,
+  failedAccountId: string,
+  retryAfterHeader: string | null | undefined,
+  sessionKey?: string | null,
+  now = Date.now(),
+): string | null {
+  return rotateOAuthPoolAccountOn429(PROVIDER, config, hooks, eligibility, failedAccountId, retryAfterHeader, sessionKey, now);
+}
+
+export function promoteCommandCodeActiveAccount(accountId: string): void {
+  promoteOAuthPoolActiveAccount(PROVIDER, accountId);
+}
+
+export function resetCommandCodeRoutingForManualSelection(accountId: string): void {
+  resetOAuthPoolRoutingForManualSelection(PROVIDER, hooks, accountId);
+}
+
+export async function getCommandCodePoolAccessToken(accountId: string): Promise<string> {
+  return getOAuthPoolAccessToken(PROVIDER, accountId, eligibility.canRefresh);
+}
+
+export function canRefreshCommandCodePoolAccount(accountId: string): boolean {
+  return eligibility.canRefresh(accountId);
+}
+
+export function formatCommandCodeAccountOrdinal(accountId: string): string {
+  return formatOAuthPoolAccountOrdinal(accountId);
+}
+
+export function formatCommandCodeProviderForLog(
+  providerName: string,
+  accountId: string | null | undefined,
+  config?: OcxConfig,
+): string {
+  return formatOAuthPoolProviderForLog(providerName, accountId, config);
+}
+
+export const commandCodeSessionKeyFromParts = oauthPoolSessionKeyFromParts;
+
+export type CommandCodeAccountSelectionReason = OAuthPoolSelectionReason;
+export interface CommandCodeAccountSelection extends OAuthPoolSelection {}
diff --git a/src/oauth/health.ts b/src/oauth/health.ts
index e0cf82556..5edb86670 100644
--- a/src/oauth/health.ts
+++ b/src/oauth/health.ts
@@ -1,5 +1,6 @@
 import { getCodexAccountHealthSnapshot, type CodexCooldownSource } from "../codex/routing";
 import { getAnthropicAccountHealthSnapshot } from "./anthropic-routing";
+import { getCommandCodeAccountHealthSnapshot } from "./command-code-routing";
 import { isAccountNeedsReauth } from "../codex/account-runtime-state";
 import { getCodexAccountCredential, listCodexAccountIds } from "../codex/account-store";
 import { MAIN_CODEX_ACCOUNT_ID } from "../codex/main-account";
@@ -180,11 +181,15 @@ export function projectStoredOAuthAccountHealth(
   const anthropicSnap = provider === "anthropic"
     ? getAnthropicAccountHealthSnapshot(account.id, now)
     : null;
+  const commandCodeSnap = provider === "command-code"
+    ? getCommandCodeAccountHealthSnapshot(account.id, now)
+    : null;
+  const poolSnap = provider === "anthropic" ? anthropicSnap : commandCodeSnap;
   return projectOAuthAccountHealth({
     needsReauth: account.needsReauth === true,
     reauthReason: account.needsReauth === true ? "refresh_failed" : undefined,
-    cooldownUntilMs: anthropicSnap?.cooldownUntil,
-    cooldownReason: anthropicSnap?.cooldownSource === "retry-after" ? "rate_limit" : anthropicSnap ? "quota" : undefined,
+    cooldownUntilMs: poolSnap?.cooldownUntil,
+    cooldownReason: poolSnap?.cooldownSource === "retry-after" ? "rate_limit" : poolSnap ? "quota" : undefined,
     warningReason: detectOAuthWarning(provider, account, opts.observeOnly === true, now),
     now,
   });
diff --git a/src/oauth/oauth-pool-routing.ts b/src/oauth/oauth-pool-routing.ts
new file mode 100644
index 000000000..791a1782a
--- /dev/null
+++ b/src/oauth/oauth-pool-routing.ts
@@ -0,0 +1,740 @@
+/**
+ * Generic OAuth account pool router (multiauth).
+ *
+ * Mirrors the Codex pool rotation strategy (priority tiers, quota headroom,
+ * sticky session affinity, 429/transient failover, RR / fill-first / quota
+ * strategies) for OAuth providers that can hold multiple accounts, so all
+ * multi-account providers share one rotation engine instead of per-provider
+ * copies.
+ *
+ * Default OFF per provider (config.xxxAccountPool.enabled !== true). When
+ * enabled:
+ * - Sticky session affinity across requests that share a session key
+ * - 429 cools the failed account and fails over to another eligible account
+ * - New sessions use `strategy` (default quota): lowest known fiveHour usage,
+ *   round-robin, or fill-first — affinity still wins for bound sessions
+ * - Selection order (priority) and manual pin behave like the Codex pool
+ *
+ * Affinity/health is process-local (lost on restart). Cooldown uses
+ * Retry-After when present, otherwise a default backoff. 401/403 credential
+ * failures should set needsReauth on the store (existing OAuth path) so the
+ * account is excluded from eligibility.
+ */
+import { createHash } from "node:crypto";
+import { setActiveAccount, getAccountSet, getAccountCredential } from "./store";
+import { getCachedProviderAccountQuota } from "../providers/quota";
+import { fallbackCodexAccountLogLabel } from "../codex/account-label";
+import {
+  normalizeAccountPoolStickyLimit,
+  normalizeAccountPoolStrategy,
+  notePoolRotationFailure,
+  notePoolRotationSuccess,
+  pickRoundRobinAccount,
+  selectPriorityTier,
+  seedPoolRotationAccount,
+} from "../codex/pool-rotation";
+import type { OcxAccountPoolRotationStrategy, OcxConfig } from "../types";
+import { sweepExpiredOnWrite } from "../lib/state-store-sweeper";
+import { retainedUtf8Bytes } from "../lib/admission";
+
+const DEFAULT_COOLDOWN_MS = 60_000;
+const MAX_COOLDOWN_MS = 15 * 60_000;
+const AFFINITY_IDLE_TTL_MS = 24 * 60 * 60_000;
+const MAX_AFFINITY_ENTRIES = 2_000;
+const MAX_AFFINITY_COMPONENT_BYTES = 512;
+const UNKNOWN_USAGE_SCORE = 100;
+const DEFAULT_AUTO_SWITCH_THRESHOLD = 80;
+/** Cap same-request 429 rotations so short Retry-After cannot infinite-loop. */
+export const OAUTH_POOL_MAX_FAILOVERS_PER_REQUEST = 3;
+/** Transient failures before the account is softly avoided (Codex parity). */
+const FAILOVER_THRESHOLD = 3;
+/** How long a transient failure keeps the account out of pool selection. */
+const TRANSIENT_SOFT_AVOID_MS = 30_000;
+/** Window past which a failure streak no longer counts. */
+const FAILURE_WINDOW_MS = 5 * 60_000;
+
+export interface OAuthAccountPoolConfig {
+  enabled?: boolean;
+  /** Usage % for new-session pick. Default 80. 0 = disable quota-based pick (active / affinity only). */
+  autoSwitchThreshold?: number;
+  /** New-session rotation strategy. Default quota (today's behaviour). */
+  strategy?: OcxAccountPoolRotationStrategy;
+  /** Successful new-session binds retained on one round-robin selection. Default 1; range 1..100. */
+  stickyLimit?: number;
+  /** Selection order per account id, higher used earlier. */
+  accountPriorities?: Record<string, number>;
+  /** Account id manually pinned by the operator. */
+  activeAccountPinned?: string;
+}
+
+export interface OAuthPoolProviderHooks {
+  /** Config slice for this provider (e.g. config.anthropicAccountPool). */
+  configOf: (config: OcxConfig) => OAuthAccountPoolConfig | undefined;
+  /** Selection order lookup; higher used earlier. Absent => 0. */
+  priorityOf: (config: OcxConfig) => (accountId: string) => number;
+  /** Manually pinned account id (tier ceiling), if any. */
+  pinnedOf: (config: OcxConfig) => string | undefined;
+  /** Pool key for the shared RR ring. */
+  poolKey: string;
+}
+
+export interface OAuthPoolProviderState {
+  /** Process-local upstream health per account. */
+  upstreamHealth: Map<string, AccountHealth>;
+  /** Sticky session affinity. */
+  sessionAffinity: Map<string, AffinityEntry>;
+  /** Whether the provider's own pool state has been seeded for tests. */
+  seeded: boolean;
+}
+
+interface AccountHealth {
+  cooldownUntil: number;
+  cooldownSource: "retry-after" | "default";
+  /** Transient-failure streak for soft-avoid. */
+  consecutiveFailures?: number;
+  lastFailureAt?: number;
+  softAvoidUntil?: number;
+}
+
+interface AffinityEntry {
+  accountId: string;
+  lastUsedAt: number;
+}
+
+const stateByProvider = new Map<string, OAuthPoolProviderState>();
+
+function stateFor(provider: string): OAuthPoolProviderState {
+  let state = stateByProvider.get(provider);
+  if (!state) {
+    state = { upstreamHealth: new Map(), sessionAffinity: new Map(), seeded: true };
+    stateByProvider.set(provider, state);
+  }
+  return state;
+}
+
+function normalizeAffinityComponent(value: string | null | undefined): string {
+  const normalized = value?.trim() ?? "";
+  return normalized && retainedUtf8Bytes(normalized) <= MAX_AFFINITY_COMPONENT_BYTES ? normalized : "";
+}
+
+function providerConfig(config: OcxConfig, hooks: OAuthPoolProviderHooks): OAuthAccountPoolConfig {
+  const raw = hooks.configOf(config);
+  if (!raw || typeof raw !== "object") return {};
+  return raw;
+}
+
+export function isOAuthPoolEnabled(config: OcxConfig, hooks: OAuthPoolProviderHooks): boolean {
+  return providerConfig(config, hooks).enabled === true;
+}
+
+export function oauthPoolAutoSwitchThreshold(config: OcxConfig, hooks: OAuthPoolProviderHooks): number {
+  const value = providerConfig(config, hooks).autoSwitchThreshold;
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 100) return value;
+  return DEFAULT_AUTO_SWITCH_THRESHOLD;
+}
+
+function parseRetryAfterMs(value: string | null | undefined, now: number): number | undefined {
+  const text = value?.trim();
+  if (!text) return undefined;
+  if (/^\d+(?:\.\d+)?$/.test(text)) {
+    const seconds = Number(text);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return Math.min(Math.max(Math.ceil(seconds * 1000), 1), MAX_COOLDOWN_MS);
+    }
+  }
+  const timestamp = Date.parse(text);
+  if (!Number.isFinite(timestamp)) return undefined;
+  const delay = timestamp - now;
+  return delay > 0 ? Math.min(delay, MAX_COOLDOWN_MS) : undefined;
+}
+
+export function getOAuthPoolAccountHealthSnapshot(
+  provider: string,
+  accountId: string,
+  now = Date.now(),
+): { cooldownUntil?: number; cooldownSource?: AccountHealth["cooldownSource"] } | null {
+  const entry = stateFor(provider).upstreamHealth.get(accountId);
+  if (!entry) return null;
+  if (entry.cooldownUntil <= now) {
+    stateFor(provider).upstreamHealth.delete(accountId);
+    return null;
+  }
+  return { cooldownUntil: entry.cooldownUntil, cooldownSource: entry.cooldownSource };
+}
+
+export function clearOAuthPoolAccountCooldown(provider: string, accountId: string): boolean {
+  return stateFor(provider).upstreamHealth.delete(accountId);
+}
+
+export function sweepExpiredOAuthPoolRoutingHealth(provider?: string, now = Date.now()): number {
+  if (provider === undefined) {
+    let removed = 0;
+    for (const name of stateByProvider.keys()) removed += sweepExpiredOAuthPoolRoutingHealth(name, now);
+    return removed;
+  }
+  let removed = 0;
+  const health = stateFor(provider).upstreamHealth;
+  for (const [accountId, entry] of health) {
+    if (entry.cooldownUntil > now) continue;
+    health.delete(accountId);
+    removed += 1;
+  }
+  return removed;
+}
+
+/** Test / logout helper. */
+export function clearOAuthPoolState(provider: string): void {
+  stateByProvider.delete(provider);
+}
+
+export function oauthPoolSessionAffinitySizeForTests(provider: string): number {
+  return stateFor(provider).sessionAffinity.size;
+}
+
+function isCooled(provider: string, accountId: string, now: number): boolean {
+  return getOAuthPoolAccountHealthSnapshot(provider, accountId, now) !== null;
+}
+
+function hasKnownUsage(provider: string, accountId: string): boolean {
+  const quota = getCachedProviderAccountQuota(provider, accountId);
+  return typeof quota?.fiveHourPercent === "number" && Number.isFinite(quota.fiveHourPercent);
+}
+
+function usageScore(provider: string, accountId: string): number {
+  const quota = getCachedProviderAccountQuota(provider, accountId);
+  if (!quota || typeof quota.fiveHourPercent !== "number" || !Number.isFinite(quota.fiveHourPercent)) {
+    return UNKNOWN_USAGE_SCORE;
+  }
+  return Math.max(0, Math.min(100, quota.fiveHourPercent));
+}
+
+const TOKEN_SKEW_MS = 60_000;
+
+/** Background `local-cli` slots with expired access are not pool-eligible (identity adoption risk). */
+function isPoolCredentialUsable(provider: string, accountId: string, now: number, canRefresh: (accountId: string) => boolean): boolean {
+  const cred = getAccountCredential(provider, accountId);
+  if (!cred) return false;
+  if (cred.source !== "local-cli") return true;
+  if (canRefresh(accountId)) return true;
+  return cred.expires > now + TOKEN_SKEW_MS;
+}
+
+export interface OAuthPoolEligibilityHooks {
+  /** Whether this account's token may be refreshed in the background (local-cli identity rule). */
+  canRefresh: (accountId: string) => boolean;
+  /** Usable-credential predicate; default reads the account store. */
+  isUsable?: (accountId: string) => boolean;
+}
+
+export function getEligibleOAuthPoolAccounts(
+  provider: string,
+  hooks: OAuthPoolProviderHooks,
+  eligibility: OAuthPoolEligibilityHooks,
+  excludeId?: string,
+  now = Date.now(),
+): string[] {
+  const set = getAccountSet(provider);
+  if (!set) return [];
+  return set.accounts
+    .filter(account =>
+      account.id !== excludeId
+      && account.needsReauth !== true
+      && !isCooled(provider, account.id, now)
+      && !isSoftAvoided(provider, account.id, now)
+      && isPoolCredentialUsable(provider, account.id, now, eligibility.canRefresh)
+      && (eligibility.isUsable?.(account.id) ?? true))
+    .map(account => account.id);
+}
+
+function isSoftAvoided(provider: string, accountId: string, now: number): boolean {
+  const entry = stateFor(provider).upstreamHealth.get(accountId);
+  if (!entry?.softAvoidUntil) return false;
+  if (entry.softAvoidUntil <= now) return false;
+  return true;
+}
+
+/** Earliest remaining cooldown among cooled accounts, for client Retry-After. */
+export function getOAuthPoolRetryAfterSeconds(provider: string, now = Date.now()): number | null {
+  const set = getAccountSet(provider);
+  if (!set) return null;
+  let earliest: number | null = null;
+  for (const account of set.accounts) {
+    const snap = getOAuthPoolAccountHealthSnapshot(provider, account.id, now);
+    if (!snap?.cooldownUntil) continue;
+    if (earliest === null || snap.cooldownUntil < earliest) earliest = snap.cooldownUntil;
+  }
+  if (earliest === null || earliest <= now) return null;
+  return Math.max(1, Math.ceil((earliest - now) / 1000));
+}
+
+/** Next eligible account in stable order after `afterId` (wrapping). */
+function pickNextFillFirstAccount(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  afterId: string,
+  eligible: readonly string[],
+): string | null {
+  if (eligible.length === 0) return null;
+  const ordered = [...eligible].sort((a, b) => a.localeCompare(b));
+  const set = getAccountSet(provider);
+  const stableAll = set
+    ? [...set.accounts.map(a => a.id)].sort((a, b) => a.localeCompare(b))
+    : ordered;
+  const startIdx = stableAll.indexOf(afterId);
+  if (startIdx < 0) {
+    for (const id of ordered) {
+      if (isActiveUnderFillFirstThreshold(provider, config, hooks, id)) return id;
+    }
+    return ordered[0] ?? null;
+  }
+  // Skip successors that are also at/above threshold (known drained usage).
+  let fallback: string | null = null;
+  for (let step = 1; step <= stableAll.length; step++) {
+    const candidate = stableAll[(startIdx + step) % stableAll.length]!;
+    if (!eligible.includes(candidate)) continue;
+    if (!fallback) fallback = candidate;
+    if (isActiveUnderFillFirstThreshold(provider, config, hooks, candidate)) return candidate;
+  }
+  return fallback ?? ordered[0] ?? null;
+}
+
+function pickAlternateAccount(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligibility: OAuthPoolEligibilityHooks,
+  excludeId: string,
+  now: number,
+): string | null {
+  const strategy = oauthPoolStrategy(config, hooks);
+  const eligible = eligibleWithPriority(provider, config, hooks, eligibility, now, excludeId);
+  if (strategy === "round-robin") {
+    return pickRoundRobinAccount(hooks.poolKey, eligible, stickyLimitForPool(config, hooks));
+  }
+  if (strategy === "fill-first") {
+    return pickNextFillFirstAccount(provider, config, hooks, excludeId, eligible);
+  }
+  return pickLowestUsageAmong(provider, eligible);
+}
+
+function pruneExpiredAffinity(provider: string, now: number): void {
+  const affinity = stateFor(provider).sessionAffinity;
+  for (const [key, entry] of affinity) {
+    if (now - entry.lastUsedAt > AFFINITY_IDLE_TTL_MS) affinity.delete(key);
+  }
+  if (affinity.size <= MAX_AFFINITY_ENTRIES) return;
+  const sorted = [...affinity.entries()].sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
+  const drop = affinity.size - MAX_AFFINITY_ENTRIES;
+  for (let i = 0; i < drop; i++) affinity.delete(sorted[i]![0]);
+}
+
+export type OAuthPoolSelectionReason =
+  | "pool-disabled"
+  | "affinity"
+  | "active"
+  | "lowest-usage"
+  | "only-eligible"
+  | "round-robin"
+  | "fill-first"
+  | "priority-preemption"
+  | "quota-switch"
+  | "failover"
+  | "none"
+  | "all-cooled";
+
+export interface OAuthPoolSelection {
+  accountId: string | null;
+  reason: OAuthPoolSelectionReason;
+}
+
+function stickyLimitForPool(config: OcxConfig, hooks: OAuthPoolProviderHooks): number {
+  return normalizeAccountPoolStickyLimit(providerConfig(config, hooks).stickyLimit);
+}
+
+function oauthPoolStrategy(config: OcxConfig, hooks: OAuthPoolProviderHooks): OcxAccountPoolRotationStrategy {
+  return normalizeAccountPoolStrategy(providerConfig(config, hooks).strategy);
+}
+
+function isActiveUnderFillFirstThreshold(provider: string, config: OcxConfig, hooks: OAuthPoolProviderHooks, accountId: string): boolean {
+  const threshold = oauthPoolAutoSwitchThreshold(config, hooks);
+  if (threshold <= 0) return true;
+  // Unknown usage must not force fill-first to abandon the active account.
+  if (!hasKnownUsage(provider, accountId)) return true;
+  return usageScore(provider, accountId) < threshold;
+}
+
+/**
+ * Fill-first: keep eligible active under threshold; otherwise advance to the next
+ * eligible id in stable sorted order after the current active (wrapping).
+ */
+function pickFillFirstAccount(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligible: readonly string[],
+): string | null {
+  if (eligible.length === 0) return null;
+
+  const set = getAccountSet(provider);
+  const active = set?.activeAccountId;
+  if (active && eligible.includes(active) && isActiveUnderFillFirstThreshold(provider, config, hooks, active)) {
+    return active;
+  }
+
+  if (!active || !set) {
+    const ordered = [...eligible].sort((a, b) => a.localeCompare(b));
+    for (const id of ordered) {
+      if (isActiveUnderFillFirstThreshold(provider, config, hooks, id)) return id;
+    }
+    return ordered[0] ?? null;
+  }
+
+  return pickNextFillFirstAccount(provider, config, hooks, active, eligible);
+}
+
+/**
+ * Unbound new-session pick for round-robin / fill-first. Returns null to fall through
+ * to the legacy quota path (or when the strategy is quota).
+ */
+function pickUnboundStrategyAccount(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligible: readonly string[],
+): { accountId: string; reason: "round-robin" | "fill-first" } | null {
+  const strategy = oauthPoolStrategy(config, hooks);
+  if (strategy === "quota") return null;
+
+  if (strategy === "round-robin") {
+    const limit = stickyLimitForPool(config, hooks);
+    const picked = pickRoundRobinAccount(hooks.poolKey, eligible, limit);
+    if (!picked) return null;
+    notePoolRotationSuccess(hooks.poolKey, picked, limit);
+    return { accountId: picked, reason: "round-robin" };
+  }
+
+  if (strategy === "fill-first") {
+    const picked = pickFillFirstAccount(provider, config, hooks, eligible);
+    if (!picked) return null;
+    return { accountId: picked, reason: "fill-first" };
+  }
+
+  return null;
+}
+
+/**
+ * Narrow the eligible list to the highest selection-order tier that still has
+ * usable quota, with the manual pin as a tier ceiling (Codex parity).
+ */
+function applyPriorityTier(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligibility: OAuthPoolEligibilityHooks,
+  ids: readonly string[],
+  now: number,
+): readonly string[] {
+  return selectPriorityTier(
+    ids,
+    hooks.priorityOf(config),
+    id => isActiveUnderFillFirstThreshold(provider, config, hooks, id),
+    hooks.pinnedOf(config),
+  );
+}
+
+function eligibleWithPriority(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligibility: OAuthPoolEligibilityHooks,
+  now: number,
+  excludeId?: string,
+): string[] {
+  const base = getEligibleOAuthPoolAccounts(provider, hooks, eligibility, excludeId, now);
+  return [...applyPriorityTier(provider, config, hooks, eligibility, base, now)];
+}
+
+/** Coolest account in an already-selected candidate list; first index wins ties. */
+function pickLowestUsageAmong(provider: string, ids: readonly string[]): string | null {
+  let best: string | null = null;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const id of ids) {
+    const score = usageScore(provider, id);
+    if (score < bestScore) {
+      best = id;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+function shouldFailover(provider: string, accountId: string, now: number): boolean {
+  const health = stateFor(provider).upstreamHealth.get(accountId);
+  if (health?.lastFailureAt && now - health.lastFailureAt > FAILURE_WINDOW_MS) return false;
+  return !!health && (health.consecutiveFailures ?? 0) >= FAILOVER_THRESHOLD;
+}
+
+/**
+ * Resolve which OAuth account should serve this session.
+ * When the pool is disabled, always returns the store's active account.
+ */
+export function resolveOAuthPoolAccountForSession(
+  provider: string,
+  sessionKey: string | null | undefined,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligibility: OAuthPoolEligibilityHooks,
+  now = Date.now(),
+): OAuthPoolSelection {
+  pruneExpiredAffinity(provider, now);
+  const set = getAccountSet(provider);
+  if (!set || set.accounts.length === 0) return { accountId: null, reason: "none" };
+
+  if (!isOAuthPoolEnabled(config, hooks)) {
+    return { accountId: set.activeAccountId, reason: "pool-disabled" };
+  }
+
+  const affinity = stateFor(provider).sessionAffinity;
+  const key = normalizeAffinityComponent(sessionKey);
+  if (key) {
+    const affined = affinity.get(key);
+    if (affined && now - affined.lastUsedAt <= AFFINITY_IDLE_TTL_MS) {
+      const stillThere = set.accounts.some(a => a.id === affined.accountId && a.needsReauth !== true);
+      if (stillThere && !isCooled(provider, affined.accountId, now)
+        && !isSoftAvoided(provider, affined.accountId, now)
+        && isPoolCredentialUsable(provider, affined.accountId, now, eligibility.canRefresh)
+        && !shouldFailover(provider, affined.accountId, now)) {
+        affined.lastUsedAt = now;
+        return { accountId: affined.accountId, reason: "affinity" };
+      }
+      affinity.delete(key);
+    }
+  }
+
+  const strategy = oauthPoolStrategy(config, hooks);
+  // Selection order is a boundary, not a quota-only preference: every strategy
+  // must rotate only inside the highest usable tier (or the manual pin's tier).
+  const eligible = eligibleWithPriority(provider, config, hooks, eligibility, now);
+  // No session identity (Desktop turns without a sticky key): hold the current
+  // active under RR/fill-first instead of treating every turn as a new session.
+  if (!key && (strategy === "round-robin" || strategy === "fill-first")) {
+    const activeOk = set.accounts.some(a => a.id === set.activeAccountId && a.needsReauth !== true)
+      && eligible.includes(set.activeAccountId)
+      && !isCooled(provider, set.activeAccountId, now)
+      && !isSoftAvoided(provider, set.activeAccountId, now)
+      && isPoolCredentialUsable(provider, set.activeAccountId, now, eligibility.canRefresh);
+    if (activeOk) {
+      return { accountId: set.activeAccountId, reason: "active" };
+    }
+  }
+
+  const strategyPick = pickUnboundStrategyAccount(provider, config, hooks, eligible);
+  if (strategyPick) {
+    if (key && normalizeAffinityComponent(strategyPick.accountId)) {
+      affinity.set(key, { accountId: strategyPick.accountId, lastUsedAt: now });
+      pruneExpiredAffinity(provider, now);
+    }
+    return { accountId: strategyPick.accountId, reason: strategyPick.reason };
+  }
+
+  const threshold = oauthPoolAutoSwitchThreshold(config, hooks);
+  const activeOk = set.accounts.some(a => a.id === set.activeAccountId && a.needsReauth !== true)
+    && eligible.includes(set.activeAccountId)
+    && !isCooled(provider, set.activeAccountId, now)
+    && !isSoftAvoided(provider, set.activeAccountId, now)
+    && isPoolCredentialUsable(provider, set.activeAccountId, now, eligibility.canRefresh);
+
+  let accountId: string | null = null;
+  let reason: OAuthPoolSelectionReason = "none";
+
+  // Priority preemption: a higher-ordered account with headroom replaces the
+  // active, unless a live pin lowers the tier ceiling (Codex parity). This
+  // applies regardless of the active account's usage so an operator's ordering
+  // is honored on the next unbound session.
+  const pinned = hooks.pinnedOf(config);
+  const pinnedLive = pinned !== undefined && eligible.includes(pinned) && isActiveUnderFillFirstThreshold(provider, config, hooks, pinned);
+  if (!pinnedLive && eligible.length > 0 && !eligible.includes(set.activeAccountId)) {
+    const preemptCandidate = pickLowestUsageAmong(provider, eligible.filter(id => isActiveUnderFillFirstThreshold(provider, config, hooks, id)));
+    if (preemptCandidate) {
+      accountId = preemptCandidate;
+      reason = "priority-preemption";
+    }
+  }
+
+  if (!accountId) {
+    if (threshold > 0) {
+      // Unknown usage must NOT force a switch away from the healthy active account.
+      if (activeOk && (!hasKnownUsage(provider, set.activeAccountId) || usageScore(provider, set.activeAccountId) < threshold)) {
+        accountId = set.activeAccountId;
+        reason = "active";
+      } else {
+        const picked = pickLowestUsageAmong(provider, eligible);
+        if (picked) {
+          accountId = picked;
+          reason = activeOk && picked === set.activeAccountId ? "active" : "lowest-usage";
+        } else if (activeOk) {
+          accountId = set.activeAccountId;
+          reason = "active";
+        }
+      }
+    } else if (activeOk) {
+      accountId = set.activeAccountId;
+      reason = "active";
+    } else {
+      const picked = pickLowestUsageAmong(provider, eligible.filter(id => id !== set.activeAccountId));
+      if (picked) {
+        accountId = picked;
+        reason = "only-eligible";
+      }
+    }
+  }
+
+  if (!accountId) {
+    const anyCooled = set.accounts.some(a => isCooled(provider, a.id, now));
+    return { accountId: null, reason: anyCooled ? "all-cooled" : "none" };
+  }
+
+  if (key && normalizeAffinityComponent(accountId)) {
+    affinity.set(key, { accountId, lastUsedAt: now });
+    pruneExpiredAffinity(provider, now);
+  }
+  return { accountId, reason };
+}
+
+export function bindOAuthPoolSessionAffinity(
+  provider: string,
+  sessionKey: string | null | undefined,
+  accountId: string,
+  now = Date.now(),
+): void {
+  const key = normalizeAffinityComponent(sessionKey);
+  if (!key || !normalizeAffinityComponent(accountId)) return;
+  stateFor(provider).sessionAffinity.set(key, { accountId, lastUsedAt: now });
+  pruneExpiredAffinity(provider, now);
+}
+
+export function clearOAuthPoolSessionAffinityForAccount(provider: string, accountId: string): void {
+  const affinity = stateFor(provider).sessionAffinity;
+  for (const [key, entry] of affinity) {
+    if (entry.accountId === accountId) affinity.delete(key);
+  }
+}
+
+/**
+ * Record a 429 for `failedAccountId`, cool it, clear its affinity, and pick a failover
+ * account. Does NOT promote the store active account — caller should promote only after a
+ * successful retry (or token resolve).
+ */
+export function rotateOAuthPoolAccountOn429(
+  provider: string,
+  config: OcxConfig,
+  hooks: OAuthPoolProviderHooks,
+  eligibility: OAuthPoolEligibilityHooks,
+  failedAccountId: string,
+  retryAfterHeader: string | null | undefined,
+  sessionKey?: string | null,
+  now = Date.now(),
+): string | null {
+  if (!isOAuthPoolEnabled(config, hooks)) return null;
+
+  const parsedRetry = parseRetryAfterMs(retryAfterHeader, now);
+  const health = stateFor(provider).upstreamHealth;
+  health.set(failedAccountId, {
+    cooldownUntil: now + (parsedRetry ?? DEFAULT_COOLDOWN_MS),
+    cooldownSource: parsedRetry ? "retry-after" : "default",
+  });
+  sweepExpiredOnWrite(now);
+  clearOAuthPoolSessionAffinityForAccount(provider, failedAccountId);
+  notePoolRotationFailure(hooks.poolKey, failedAccountId);
+
+  const next = pickAlternateAccount(provider, config, hooks, eligibility, failedAccountId, now);
+  if (!next) {
+    console.warn(`[oauth-pool:${provider}] all eligible ${provider} OAuth accounts are in cooldown; returning 429`);
+    return null;
+  }
+
+  const affinityKey = normalizeAffinityComponent(sessionKey);
+  if (affinityKey && normalizeAffinityComponent(next)) {
+    stateFor(provider).sessionAffinity.set(affinityKey, { accountId: next, lastUsedAt: now });
+    pruneExpiredAffinity(provider, now);
+  }
+  console.warn(
+    `[oauth-pool:${provider}] 429 on ${formatOAuthPoolAccountOrdinal(failedAccountId)}; failing over to ${formatOAuthPoolAccountOrdinal(next)}`,
+  );
+  return next;
+}
+
+/** Promote dashboard active account after a validated failover target is usable. */
+export function promoteOAuthPoolActiveAccount(provider: string, accountId: string): void {
+  void setActiveAccount(provider, accountId).catch(() => { /* best-effort */ });
+}
+
+/**
+ * Manual selection resets session affinity and seeds the RR ring so the next
+ * unbound new session honors the operator-chosen account (Codex parity).
+ */
+export function resetOAuthPoolRoutingForManualSelection(provider: string, hooks: OAuthPoolProviderHooks, accountId: string): void {
+  stateFor(provider).sessionAffinity.clear();
+  seedPoolRotationAccount(hooks.poolKey, accountId);
+}
+
+/**
+ * Resolve a bearer for pool traffic without adopting a newer global provider
+ * CLI credential into a background multiauth `local-cli` slot (same fail-closed
+ * rule as quota probes).
+ */
+export async function getOAuthPoolAccessToken(provider: string, accountId: string, canRefresh: (accountId: string) => boolean): Promise<string> {
+  const stored = getAccountCredential(provider, accountId);
+  if (!stored) {
+    const { OAuthLoginRequiredError } = await import("./index");
+    throw new OAuthLoginRequiredError(provider);
+  }
+  if (stored.expires > Date.now() + TOKEN_SKEW_MS) return stored.access;
+  if (!canRefresh(accountId)) {
+    throw new Error("background local-cli token expired; refuse CLI-adopting refresh for pool");
+  }
+  const { getValidAccessTokenForAccount } = await import("./index");
+  return getValidAccessTokenForAccount(provider, accountId);
+}
+
+export function formatOAuthPoolAccountOrdinal(accountId: string): string {
+  return fallbackCodexAccountLogLabel(accountId);
+}
+
+export function formatOAuthPoolProviderForLog(
+  providerName: string,
+  accountId: string | null | undefined,
+  _config?: OcxConfig,
+): string {
+  if (!accountId) return providerName;
+  return `${providerName}-${formatOAuthPoolAccountOrdinal(accountId)}`;
+}
+
+/**
+ * Build a sticky session key from request headers.
+ * Prefer true session/thread ids; do not use a shared cache-cohort prompt_cache_key
+ * alone (those collide across conversations).
+ */
+export function oauthPoolSessionKeyFromParts(input: {
+  sessionIdHeader?: string | null;
+  threadIdHeader?: string | null;
+  promptCacheKey?: string | null;
+  clientThreadId?: string | null;
+  /** When true, prompt_cache_key is a shared Desktop cohort — ignore it for affinity. */
+  promptCacheKeyIsSharedCohort?: boolean;
+}): string | null {
+  const preferred = (
+    input.clientThreadId
+    ?? input.sessionIdHeader
+    ?? input.threadIdHeader
+    ?? ""
+  ).trim();
+  if (preferred) {
+    return preferred.length <= 128 ? preferred : createHash("sha256").update(preferred).digest("hex");
+  }
+  if (input.promptCacheKeyIsSharedCohort) return null;
+  const cacheKey = input.promptCacheKey?.trim() ?? "";
+  if (!cacheKey) return null;
+  return cacheKey.length <= 128 ? cacheKey : createHash("sha256").update(cacheKey).digest("hex");
+}
diff --git a/src/providers/quota.ts b/src/providers/quota.ts
index 9891a2896..89caa67ab 100644
--- a/src/providers/quota.ts
+++ b/src/providers/quota.ts
@@ -1261,6 +1261,86 @@ async function fetchAnthropicQuota(provider: string): Promise<ProviderQuotaRepor
   return report(provider, "anthropic:oauth-usage", quota);
 }
 
+/**
+ * Command Code `GET /alpha/billing/credits` — the plan's rolling 5-hour and
+ * weekly caps in credit value (used/cap), plus the monthly credit pool.
+ * Mirrors Claude's 5h/weekly windows in the canonical fields so the dashboard
+ * renders them with the standard labels.
+ */
+const commandCodeUsageInflight = new Map<string, Promise<ProviderQuota | null>>();
+
+async function fetchCommandCodeUsageQuota(accessToken: string): Promise<ProviderQuota | null> {
+  const joinable = commandCodeUsageInflight.get(accessToken);
+  if (joinable) return joinable;
+
+  const probe = (async (): Promise<ProviderQuota | null> => {
+    const response = await fetch("https://api.commandcode.ai/alpha/billing/credits", {
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "cli",
+        Authorization: `Bearer ${accessToken}`,
+      },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    if (!response.ok) return null;
+    const body = asRecord(await readQuotaJson(response));
+    if (!body) return null;
+    const credits = asRecord(body.credits);
+    const windows = asRecord(body.windowLimits);
+    const fiveHour = asRecord(windows?.fiveHour);
+    const weekly = asRecord(windows?.weekly);
+    const percent = (used: unknown, cap: unknown): number | undefined => {
+      const usedNum = toFiniteNumber(used);
+      const capNum = toFiniteNumber(cap);
+      if (usedNum === undefined || capNum === undefined || capNum <= 0) return undefined;
+      return Math.max(0, Math.min(100, (usedNum / capNum) * 100));
+    };
+    const quota: ProviderQuota = { updatedAt: Date.now() };
+    const fiveHourPercent = percent(fiveHour?.used, fiveHour?.cap);
+    const weeklyPercent = percent(weekly?.used, weekly?.cap);
+    if (fiveHourPercent !== undefined) quota.fiveHourPercent = fiveHourPercent;
+    if (weeklyPercent !== undefined) quota.weeklyPercent = weeklyPercent;
+    const fiveHourResetAt = normalizeResetAt(fiveHour?.resetAt);
+    const weeklyResetAt = normalizeResetAt(weekly?.resetAt);
+    if (fiveHourResetAt !== undefined) quota.fiveHourResetAt = fiveHourResetAt;
+    if (weeklyResetAt !== undefined) quota.weeklyResetAt = weeklyResetAt;
+    // Command Code exposes only a remaining monthly balance, not a used/cap
+    // denominator. Do not manufacture a monthly percentage from it.
+    // Empty / schema-changed payloads must not cache as "success with no bars".
+    return hasQuotaRows(quota) ? quota : null;
+  })().finally(() => {
+    if (commandCodeUsageInflight.get(accessToken) === probe) commandCodeUsageInflight.delete(accessToken);
+  });
+  commandCodeUsageInflight.set(accessToken, probe);
+  return probe;
+}
+
+async function fetchCommandCodeQuota(provider: string): Promise<ProviderQuotaReport | null> {
+  // Capture the account we intend to probe before awaiting — a mid-flight active
+  // switch must not seed the wrong account's cache with this response.
+  const probedAccountId = getAccountSet("command-code")?.activeAccountId;
+  const probedAccountKey = probedAccountId ? accountCacheKey("command-code", probedAccountId) : null;
+  const writerGeneration = captureConfigGeneration();
+  let accessToken: string;
+  try {
+    accessToken = await getValidAccessToken("command-code");
+  } catch {
+    return null;
+  }
+  const quota = await fetchCommandCodeUsageQuota(accessToken);
+  if (!quota) return null;
+  // Share the active-account probe with the per-account cache so Providers-page
+  // loads do not double-hit the billing endpoint.
+  if (probedAccountId && probedAccountKey) {
+    const stillOwnsToken = getAccountCredential("command-code", probedAccountId)?.access === accessToken;
+    if (stillOwnsToken && mayCommitAccountQuotaKey(probedAccountKey, writerGeneration)) {
+      accountQuotaCache.set(probedAccountKey, { ts: Date.now(), quota });
+    }
+  }
+  return report(provider, "command-code:billing-credits", quota);
+}
+
 // ---------------------------------------------------------------------------
 // Per-account quota (multiauth)
 // ---------------------------------------------------------------------------
@@ -1304,7 +1384,7 @@ export interface ProviderAccountQuota {
 
 /** Providers whose per-account quota can be probed. Extend as other OAuth APIs are covered. */
 export function supportsPerAccountQuota(provider: string): boolean {
-  return provider === "anthropic";
+  return provider === "anthropic" || provider === "command-code";
 }
 
 function accountCacheKey(provider: string, accountId: string): string {
@@ -1424,7 +1504,13 @@ async function fetchAccountQuota(
   const probe = (async (): Promise<AccountQuotaCacheEntry> => {
     try {
       const token = await getTokenForAccountQuotaProbe(provider, accountId);
-      const quota = await fetchAnthropicUsageQuota(token);
+      // Never default a future provider onto Command Code's host: that would
+      // disclose its bearer token to an unrelated credential destination.
+      const quota = provider === "anthropic"
+        ? await fetchAnthropicUsageQuota(token)
+        : provider === "command-code"
+          ? await fetchCommandCodeUsageQuota(token)
+          : null;
       if (!quota) {
         // Preserve last-good bars and mark unavailable; advance TTL so failures
         // negative-cache instead of re-probing on every GUI poll.
@@ -1904,6 +1990,9 @@ async function maybeFetchProviderQuota(
     }
     if (provider.authMode === "oauth" && name === "xai") return fetchXaiQuota(name);
     if (provider.authMode === "oauth" && name === "anthropic") return fetchAnthropicQuota(name);
+    if (provider.authMode === "oauth" && name === "command-code" && provider.adapter === "command-code") {
+      return fetchCommandCodeQuota(name);
+    }
     if (provider.authMode === "oauth" && name === "cursor") return fetchCursorQuota(name);
     if (provider.authMode === "oauth" && name === "google-antigravity") return fetchAntigravityQuota(name, provider);
     // Kimi Code `/usages` accepts OAuth or coding-plan API keys, but only on the canonical
diff --git a/src/server/management/oauth-account-routes.ts b/src/server/management/oauth-account-routes.ts
index 649c5dd1d..31b69d337 100644
--- a/src/server/management/oauth-account-routes.ts
+++ b/src/server/management/oauth-account-routes.ts
@@ -1,5 +1,6 @@
 import { randomBytes, randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
+import type { OcxAccountPoolRotationStrategy } from "../../types";
 import type { CatalogModel } from "../../codex/catalog";
 import { catalogModelSlug, invalidateCodexModelsCache, nativeModelRows, uniqueCatalogModelsForPublicList } from "../../codex/catalog";
 import {
@@ -33,8 +34,12 @@ import { clearAccountQuotaCache, clearProviderQuotaCache, fetchProviderAccountQu
 import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
 import { clearThreadAccountMap } from "../../codex/routing";
 import {
+  DEFAULT_ACCOUNT_PRIORITY,
+  MAX_ACCOUNT_PRIORITY,
+  MIN_ACCOUNT_PRIORITY,
   normalizeAccountPoolStickyLimit,
   normalizeAccountPoolStrategy,
+  parseAccountPriority,
   parseAccountPoolStickyLimit,
   parseAccountPoolStrategy,
 } from "../../codex/pool-rotation";
@@ -243,6 +248,9 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
     const projectAccounts = () => {
       const set = getAccountSet(provider);
       const current = getLoginStatus(provider);
+      const priorities = provider === "command-code"
+        ? config.commandCodeAccountPool?.accountPriorities
+        : undefined;
       return {
         activeAccountId: current.activeAccountId ?? null,
         accounts: (current.accounts ?? []).map(summary => {
@@ -253,7 +261,11 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
               needsReauth: summary.needsReauth === true,
               reauthReason: summary.needsReauth === true ? "refresh_failed" : undefined,
             });
-          return { ...summary, ...oauthAccountHealthFields(provider, summary.id, health) };
+          return {
+            ...summary,
+            ...(typeof priorities?.[summary.id] === "number" ? { priority: priorities[summary.id] } : {}),
+            ...oauthAccountHealthFields(provider, summary.id, health),
+          };
         }),
       };
     };
@@ -292,6 +304,15 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       const { resetAnthropicRoutingForManualSelection } = await import("../../oauth/anthropic-routing");
       resetAnthropicRoutingForManualSelection(body.accountId);
     }
+    if (provider === "command-code") {
+      const { resetCommandCodeRoutingForManualSelection } = await import("../../oauth/command-code-routing");
+      config.commandCodeAccountPool = {
+        ...(config.commandCodeAccountPool ?? {}),
+        activeAccountPinned: body.accountId,
+      };
+      saveConfigPreservingClaudeCode(config);
+      resetCommandCodeRoutingForManualSelection(body.accountId);
+    }
     const { clearModelCache } = await import("../../codex/model-cache");
     const { clearGatherRoutedModelsInflight } = await import("../../codex/catalog");
     clearModelCache(provider);
@@ -304,16 +325,29 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
   // Opt-in Anthropic OAuth account pool (#294): enable/threshold/strategy + clear cooldown.
   if (url.pathname === "/api/oauth/accounts/pool" && req.method === "GET") {
     const provider = (url.searchParams.get("provider") ?? "").trim().toLowerCase();
-    if (provider !== "anthropic") return jsonResponse({ error: "pool config is only supported for anthropic" }, 400);
-    const pool = config.anthropicAccountPool ?? {};
-    return jsonResponse({
-      provider,
-      enabled: pool.enabled === true,
-      autoSwitchThreshold: typeof pool.autoSwitchThreshold === "number" ? pool.autoSwitchThreshold : 80,
-      strategy: normalizeAccountPoolStrategy(pool.strategy),
-      stickyLimit: normalizeAccountPoolStickyLimit(pool.stickyLimit),
-      experimental: true,
-    });
+    if (provider === "anthropic") {
+      const pool = config.anthropicAccountPool ?? {};
+      return jsonResponse({
+        provider,
+        enabled: pool.enabled === true,
+        autoSwitchThreshold: typeof pool.autoSwitchThreshold === "number" ? pool.autoSwitchThreshold : 80,
+        strategy: normalizeAccountPoolStrategy(pool.strategy),
+        stickyLimit: normalizeAccountPoolStickyLimit(pool.stickyLimit),
+        experimental: true,
+      });
+    }
+    if (provider === "command-code") {
+      const pool = config.commandCodeAccountPool ?? {};
+      return jsonResponse({
+        provider,
+        enabled: pool.enabled === true,
+        autoSwitchThreshold: typeof pool.autoSwitchThreshold === "number" ? pool.autoSwitchThreshold : 80,
+        strategy: normalizeAccountPoolStrategy(pool.strategy),
+        stickyLimit: normalizeAccountPoolStickyLimit(pool.stickyLimit),
+        experimental: true,
+      });
+    }
+    return jsonResponse({ error: "pool config is only supported for anthropic and command-code" }, 400);
   }
   if (url.pathname === "/api/oauth/accounts/pool" && (req.method === "PUT" || req.method === "PATCH")) {
     const parsedBody = await readManagementJsonBodyOr(req, {});
@@ -326,15 +360,49 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       autoSwitchThreshold?: unknown;
       strategy?: unknown;
       stickyLimit?: unknown;
+      accountPriorities?: unknown;
+      activeAccountPinned?: unknown;
     };
     const provider = typeof body.provider === "string" ? body.provider.trim().toLowerCase() : "";
-    if (provider !== "anthropic") return jsonResponse({ error: "pool config is only supported for anthropic" }, 400);
-    let enabled = config.anthropicAccountPool?.enabled === true;
+    if (provider !== "anthropic" && provider !== "command-code") return jsonResponse({ error: "pool config is only supported for anthropic and command-code" }, 400);
+    if (provider === "anthropic") {
+      // Anthropic path — upstream verbatim. Do not generalize.
+      let enabled = config.anthropicAccountPool?.enabled === true;
+      if (body.enabled !== undefined) {
+        if (typeof body.enabled !== "boolean") return jsonResponse({ error: "enabled must be a boolean" }, 400);
+        enabled = body.enabled;
+      }
+      let threshold = config.anthropicAccountPool?.autoSwitchThreshold ?? 80;
+      if (body.autoSwitchThreshold !== undefined) {
+        if (typeof body.autoSwitchThreshold !== "number" || !Number.isInteger(body.autoSwitchThreshold) || body.autoSwitchThreshold < 0 || body.autoSwitchThreshold > 100) return jsonResponse({ error: "autoSwitchThreshold must be an integer 0-100" }, 400);
+        threshold = body.autoSwitchThreshold;
+      }
+      let strategy = config.anthropicAccountPool?.strategy;
+      if (body.strategy !== undefined) {
+        const parsed = parseAccountPoolStrategy(body.strategy);
+        if (parsed === null) return jsonResponse({ error: "strategy must be one of: quota, round-robin, fill-first" }, 400);
+        strategy = parsed;
+      }
+      let stickyLimit = config.anthropicAccountPool?.stickyLimit;
+      if (body.stickyLimit !== undefined) {
+        const parsed = parseAccountPoolStickyLimit(body.stickyLimit);
+        if (parsed === null) return jsonResponse({ error: "stickyLimit must be an integer 1-100" }, 400);
+        stickyLimit = parsed;
+      }
+      if (body.accountPriorities !== undefined || body.activeAccountPinned !== undefined) return jsonResponse({ error: "account priorities and manual pins are only supported for command-code" }, 400);
+      config.anthropicAccountPool = { enabled, autoSwitchThreshold: threshold, ...(strategy !== undefined ? { strategy } : {}), ...(stickyLimit !== undefined ? { stickyLimit } : {}) };
+      saveConfigPreservingClaudeCode(config);
+      reconcileLiveStateStores();
+      return jsonResponse({ ok: true, provider, enabled, autoSwitchThreshold: threshold, strategy: normalizeAccountPoolStrategy(strategy), stickyLimit: normalizeAccountPoolStickyLimit(stickyLimit), experimental: true });
+    }
+    // Command Code path — alongside, not merged with Anthropic.
+    const poolKey = "commandCodeAccountPool" as const;
+    let enabled = config[poolKey]?.enabled === true;
     if (body.enabled !== undefined) {
       if (typeof body.enabled !== "boolean") return jsonResponse({ error: "enabled must be a boolean" }, 400);
       enabled = body.enabled;
     }
-    let threshold = config.anthropicAccountPool?.autoSwitchThreshold ?? 80;
+    let threshold = config[poolKey]?.autoSwitchThreshold ?? 80;
     if (body.autoSwitchThreshold !== undefined) {
       if (
         typeof body.autoSwitchThreshold !== "number"
@@ -346,7 +414,7 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       }
       threshold = body.autoSwitchThreshold;
     }
-    let strategy = config.anthropicAccountPool?.strategy;
+    let strategy = config[poolKey]?.strategy;
     if (body.strategy !== undefined) {
       const parsed = parseAccountPoolStrategy(body.strategy);
       if (parsed === null) {
@@ -354,7 +422,7 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       }
       strategy = parsed;
     }
-    let stickyLimit = config.anthropicAccountPool?.stickyLimit;
+    let stickyLimit = config[poolKey]?.stickyLimit;
     if (body.stickyLimit !== undefined) {
       const parsed = parseAccountPoolStickyLimit(body.stickyLimit);
       if (parsed === null) {
@@ -362,11 +430,38 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       }
       stickyLimit = parsed;
     }
-    config.anthropicAccountPool = {
+    const poolConfig = (config[poolKey] ?? {}) as {
+      accountPriorities?: Record<string, number>;
+      activeAccountPinned?: string;
+    };
+    let accountPriorities = poolConfig.accountPriorities;
+    if (body.accountPriorities !== undefined) {
+      if (!isPlainRecord(body.accountPriorities)) {
+        return jsonResponse({ error: "accountPriorities must be an object" }, 400);
+      }
+      const next: Record<string, number> = {};
+      for (const [id, value] of Object.entries(body.accountPriorities)) {
+        if (typeof value !== "number" || !Number.isInteger(value) || value < -100 || value > 100) {
+          return jsonResponse({ error: "accountPriorities values must be integers -100..100" }, 400);
+        }
+        next[id] = value;
+      }
+      accountPriorities = next;
+    }
+    let activeAccountPinned = poolConfig.activeAccountPinned;
+    if (body.activeAccountPinned !== undefined) {
+      if (body.activeAccountPinned !== null && typeof body.activeAccountPinned !== "string") {
+        return jsonResponse({ error: "activeAccountPinned must be a string or null" }, 400);
+      }
+      activeAccountPinned = body.activeAccountPinned === null ? undefined : body.activeAccountPinned;
+    }
+    config[poolKey] = {
       enabled,
       autoSwitchThreshold: threshold,
       ...(strategy !== undefined ? { strategy } : {}),
       ...(stickyLimit !== undefined ? { stickyLimit } : {}),
+      ...(accountPriorities !== undefined ? { accountPriorities } : {}),
+      ...(activeAccountPinned !== undefined ? { activeAccountPinned } : {}),
     };
     saveConfigPreservingClaudeCode(config);
     reconcileLiveStateStores();
@@ -384,11 +479,19 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
     const body = await readManagementJsonBodyOr(req, {}) as { provider?: unknown; accountId?: unknown };
     const provider = typeof body.provider === "string" ? body.provider.trim().toLowerCase() : "";
     const accountId = typeof body.accountId === "string" ? body.accountId.trim() : "";
-    if (provider !== "anthropic") return jsonResponse({ error: "clear-cooldown is only supported for anthropic" }, 400);
-    if (!accountId) return jsonResponse({ error: "missing accountId" }, 400);
-    const { clearAnthropicAccountCooldown } = await import("../../oauth/anthropic-routing");
-    const cleared = clearAnthropicAccountCooldown(accountId);
-    return jsonResponse({ ok: true, cleared });
+    if (provider === "anthropic") {
+      if (!accountId) return jsonResponse({ error: "missing accountId" }, 400);
+      const { clearAnthropicAccountCooldown } = await import("../../oauth/anthropic-routing");
+      const cleared = clearAnthropicAccountCooldown(accountId);
+      return jsonResponse({ ok: true, cleared });
+    }
+    if (provider === "command-code") {
+      if (!accountId) return jsonResponse({ error: "missing accountId" }, 400);
+      const { clearCommandCodeAccountCooldown } = await import("../../oauth/command-code-routing");
+      const cleared = clearCommandCodeAccountCooldown(accountId);
+      return jsonResponse({ ok: true, cleared });
+    }
+    return jsonResponse({ error: "clear-cooldown is only supported for anthropic and command-code" }, 400);
   }
 
   if (url.pathname === "/api/oauth/accounts/import" && req.method === "POST") {
@@ -454,6 +557,61 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
     if (!(await setAccountAlias(provider, accountId, alias || undefined))) return jsonResponse({ error: "account not found" }, 404);
     return jsonResponse({ ok: true, provider, accountId, alias: alias || null });
   }
+  // Selection order (priority) for the Command Code OAuth account pool:
+  // Codex-pool parity — higher used earlier; setting an order also releases any
+  // manual pin so the newer operator statement wins.
+  if (url.pathname === "/api/oauth/accounts/pool/priority" && req.method === "PUT") {
+    const body = await readManagementJsonBodyOr(req, {}) as { provider?: unknown; id?: unknown; priority?: unknown };
+    const provider = typeof body.provider === "string" ? body.provider.trim().toLowerCase() : "";
+    const id = typeof body.id === "string" ? body.id.trim() : "";
+    if (provider !== "command-code") {
+      return jsonResponse({ error: "priority is only supported for the command-code pool" }, 400);
+    }
+    if (!id) return jsonResponse({ error: "missing id" }, 400);
+    const { getAccountSet } = await import("../../oauth/store");
+    const set = getAccountSet(provider);
+    if (!set?.accounts.some(a => a.id === id)) return jsonResponse({ error: "account not found" }, 404);
+
+    let priority = DEFAULT_ACCOUNT_PRIORITY;
+    if (body.priority !== null) {
+      const parsed = parseAccountPriority(body.priority);
+      if (parsed === null) {
+        return jsonResponse({
+          error: `priority must be null or an integer ${MIN_ACCOUNT_PRIORITY}-${MAX_ACCOUNT_PRIORITY}`,
+        }, 400);
+      }
+      priority = parsed;
+    }
+
+    const existingPool = config.commandCodeAccountPool as {
+      accountPriorities?: Record<string, number>;
+      activeAccountPinned?: string;
+    };
+    const pool = existingPool ?? {};
+    const priorities = new Map(Object.entries(pool.accountPriorities ?? {}));
+    if (priority === DEFAULT_ACCOUNT_PRIORITY) priorities.delete(id);
+    else priorities.set(id, priority);
+    const next: Record<string, number> = {};
+    for (const [key, value] of priorities) next[key] = value;
+    const merged = {
+      ...(config.commandCodeAccountPool ?? {}),
+    } as {
+      enabled?: boolean;
+      autoSwitchThreshold?: number;
+      strategy?: OcxAccountPoolRotationStrategy;
+      stickyLimit?: number;
+      accountPriorities?: Record<string, number>;
+      activeAccountPinned?: string;
+    };
+    if (priorities.size > 0) merged.accountPriorities = next;
+    else delete merged.accountPriorities;
+    // Newer statement wins: an order supersedes a manual pin.
+    delete merged.activeAccountPinned;
+    config.commandCodeAccountPool = merged;
+    saveConfigPreservingClaudeCode(config);
+    reconcileLiveStateStores();
+    return jsonResponse({ ok: true, provider, id, priority });
+  }
   if (url.pathname === "/api/oauth/accounts" && req.method === "DELETE") {
     const provider = (url.searchParams.get("provider") ?? "").trim().toLowerCase();
     const id = url.searchParams.get("id") ?? "";
@@ -467,6 +625,16 @@ export async function handleOauthAccountRoutes(ctx: ManagementContext): Promise<
       clearAnthropicAccountCooldown(id);
       clearAnthropicSessionAffinityForAccount(id);
     }
+    if (provider === "command-code") {
+      const { clearCommandCodeAccountCooldown, clearCommandCodeSessionAffinityForAccount } = await import("../../oauth/command-code-routing");
+      clearCommandCodeAccountCooldown(id);
+      clearCommandCodeSessionAffinityForAccount(id);
+      if (config.commandCodeAccountPool?.activeAccountPinned === id) {
+        const { activeAccountPinned: _removedPin, ...withoutPin } = config.commandCodeAccountPool;
+        config.commandCodeAccountPool = withoutPin;
+        saveConfigPreservingClaudeCode(config);
+      }
+    }
     if (!getAccountSet(provider)) clearLoginState(provider);
     const { clearModelCache } = await import("../../codex/model-cache");
     const { clearGatherRoutedModelsInflight } = await import("../../codex/catalog");
diff --git a/src/server/responses/core.ts b/src/server/responses/core.ts
index 7fd2b87b0..b1be8b18a 100644
--- a/src/server/responses/core.ts
+++ b/src/server/responses/core.ts
@@ -73,6 +73,18 @@ import {
   resolveAnthropicAccountForSession,
   rotateAnthropicAccountOn429,
 } from "../../oauth/anthropic-routing";
+import {
+  COMMAND_CODE_POOL_MAX_FAILOVERS_PER_REQUEST,
+  bindCommandCodeSessionAffinity,
+  commandCodeSessionKeyFromParts,
+  formatCommandCodeProviderForLog,
+  getCommandCodePoolAccessToken,
+  getCommandCodePoolRetryAfterSeconds,
+  isCommandCodeAccountPoolEnabled,
+  promoteCommandCodeActiveAccount,
+  resolveCommandCodeAccountForSession,
+  rotateCommandCodeAccountOn429,
+} from "../../oauth/command-code-routing";
 import { buildWebSearchTool, planWebSearch, runWithWebSearch, shouldResolveOpenAiWebSearchSidecar } from "../../web-search";
 import { buildImageTool, buildVideoTool, planImageBridge, planVideoBridge, runWithImageBridge, clampImageMaxRounds, IMAGE_GEN_TOOL_NAME, VIDEO_GEN_TOOL_NAME } from "../../images";
 import { describeImagesInPlace, planVisionSidecar, resolveOpenAiVisionModel, shouldResolveOpenAiVisionSidecar, stripImagesInPlace } from "../../vision";
@@ -1869,6 +1881,8 @@ async function handleResponsesInner(
   let replayOAuthCredentialSnapshot: Pick<OAuthAccessSnapshot, "accountId" | "generation"> | undefined;
   let anthropicPoolAccountId: string | null = null;
   let anthropicPoolFailovers = 0;
+  let commandCodePoolAccountId: string | null = null;
+  let commandCodePoolFailovers = 0;
   const anthropicSessionKey = route.providerName === "anthropic" && route.provider.authMode === "oauth"
     ? anthropicSessionKeyFromParts({
       sessionIdHeader: sessionIdHeaderFromRequest(req.headers),
@@ -1878,6 +1892,15 @@ async function handleResponsesInner(
       promptCacheKeyIsSharedCohort: options.promptCacheKeyIsSharedCohort === true,
     })
     : null;
+  const commandCodeSessionKey = route.providerName === "command-code" && route.provider.authMode === "oauth"
+    ? commandCodeSessionKeyFromParts({
+      sessionIdHeader: sessionIdHeaderFromRequest(req.headers),
+      threadIdHeader: req.headers.get("thread-id"),
+      promptCacheKey: typeof parsed.options.promptCacheKey === "string" ? parsed.options.promptCacheKey : null,
+      clientThreadId: typeof parsed._clientThreadId === "string" ? parsed._clientThreadId : null,
+      promptCacheKeyIsSharedCohort: options.promptCacheKeyIsSharedCohort === true,
+    })
+    : null;
   if (route.provider.authMode === "oauth") {
     try {
       if (route.providerName === "anthropic" && isAnthropicAccountPoolEnabled(config)) {
@@ -1900,6 +1923,26 @@ async function handleResponsesInner(
         promoteAnthropicActiveAccount(selection.accountId);
         route.provider = { ...route.provider, apiKey: accessToken };
         logCtx.provider = formatAnthropicProviderForLog("anthropic", selection.accountId, config);
+      } else if (route.providerName === "command-code" && isCommandCodeAccountPoolEnabled(config)) {
+        const selection = resolveCommandCodeAccountForSession(commandCodeSessionKey, config);
+        if (!selection.accountId) {
+          if (selection.reason === "all-cooled") {
+            const retryAfterSec = getCommandCodePoolRetryAfterSeconds();
+            return formatErrorResponse(
+              429,
+              "rate_limit_error",
+              "All Command Code OAuth accounts are temporarily rate-limited",
+              retryAfterSec !== null ? { retryAfter: String(retryAfterSec) } : undefined,
+            );
+          }
+          return formatErrorResponse(401, "authentication_error", "No eligible Command Code OAuth account available");
+        }
+        const accessToken = await getCommandCodePoolAccessToken(selection.accountId);
+        commandCodePoolAccountId = selection.accountId;
+        bindCommandCodeSessionAffinity(commandCodeSessionKey, selection.accountId);
+        promoteCommandCodeActiveAccount(selection.accountId);
+        route.provider = { ...route.provider, apiKey: accessToken };
+        logCtx.provider = formatCommandCodeProviderForLog("command-code", selection.accountId, config);
       } else {
         const resolved = await getValidAccessTokenSnapshot(route.providerName);
         replayOAuthCredentialSnapshot = {
@@ -3485,6 +3528,42 @@ async function handleResponsesInner(
           break;
         }
       }
+      // Command Code OAuth account pool: cool the failed account and retry
+      // with another eligible OAuth account (bounded per request). Disabled by default.
+      while (
+        upstreamResponse.status === 429
+        && commandCodePoolAccountId
+        && isCommandCodeAccountPoolEnabled(config)
+        && commandCodePoolFailovers < COMMAND_CODE_POOL_MAX_FAILOVERS_PER_REQUEST
+      ) {
+        const nextAccountId = rotateCommandCodeAccountOn429(
+          config,
+          commandCodePoolAccountId,
+          upstreamResponse.headers.get("retry-after"),
+          commandCodeSessionKey,
+        );
+        if (!nextAccountId) break;
+        try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
+        try {
+          const accessToken = await getCommandCodePoolAccessToken(nextAccountId);
+          commandCodePoolAccountId = nextAccountId;
+          commandCodePoolFailovers += 1;
+          route.provider = { ...route.provider, apiKey: accessToken };
+          invalidateSameTargetRequest();
+          promoteCommandCodeActiveAccount(nextAccountId);
+          logCtx.provider = formatCommandCodeProviderForLog("command-code", nextAccountId, config);
+          activeAdapter = resolveAdapter(
+            resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire),
+            config.cacheRetention,
+          );
+          sealRequestAttemptIdentity(logCtx.activeAttempt, logCtx.provider, activeAdapter.name, logCtx.accountLogLabel);
+          const result = await rebuildAndRefetch("command-code-oauth-429");
+          if ("failed" in result) return result.failed;
+          upstreamResponse = result;
+        } catch {
+          break;
+        }
+      }
       // Anthropic 413 request_too_large: rebuild once with every image one tier lower
       // (spiral guard: single attempt). The biased response re-enters the 429 check above.
       if (shouldAttemptImageTierRetry({
diff --git a/src/types.ts b/src/types.ts
index d24811f43..75823012d 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -923,6 +923,25 @@ export interface OcxConfig {
     /** Successful new-session binds retained on one round-robin selection. Default 1; range 1..100. */
     stickyLimit?: number;
   };
+  /**
+   * Opt-in Command Code OAuth account pool (mirrors the Anthropic pool).
+   * Default OFF. Failover on 429 + sticky affinity; new sessions may pick
+   * lowest known 5h usage. Experimental — see the Anthropic pool docs before
+   * enabling.
+   */
+  commandCodeAccountPool?: {
+    enabled?: boolean;
+    /** Usage % threshold for new-session auto-pick. Default 80. 0 = disabled (affinity/active only). */
+    autoSwitchThreshold?: number;
+    /** New-session rotation strategy. Default quota (today's behaviour). */
+    strategy?: OcxAccountPoolRotationStrategy;
+    /** Successful new-session binds retained on one round-robin selection. Default 1; range 1..100. */
+    stickyLimit?: number;
+    /** Selection order per account id, higher used earlier. Absent = 0. Range -100..100. */
+    accountPriorities?: Record<string, number>;
+    /** Account id the operator last selected by hand. Suppresses upward priority preemption. */
+    activeAccountPinned?: string;
+  };
   /** Virtual `combo/<id>` models spanning concrete provider/model targets (issue #133). */
   combos?: Record<string, OcxComboConfig>;
   /**
diff --git a/src/usage/log.ts b/src/usage/log.ts
index 5256c2af9..babe71c9f 100644
--- a/src/usage/log.ts
+++ b/src/usage/log.ts
@@ -25,6 +25,7 @@ export type AttemptRecoveryKind =
   | "key-429"
   | "rate-limit-429"
   | "anthropic-oauth-429"
+  | "command-code-oauth-429"
   | "image-413";
 
 export interface PersistedUsageAttempt {
@@ -199,6 +200,7 @@ const ATTEMPT_RECOVERY_KINDS = new Set<AttemptRecoveryKind>([
   "key-429",
   "rate-limit-429",
   "anthropic-oauth-429",
+  "command-code-oauth-429",
   "image-413",
 ]);
 const USAGE_STATUSES = new Set<UsageStatus>([
diff --git a/tests/account-pool-management-api.test.ts b/tests/account-pool-management-api.test.ts
index 4dbe39926..7e9c733b6 100644
--- a/tests/account-pool-management-api.test.ts
+++ b/tests/account-pool-management-api.test.ts
@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { handleCodexAuthAPI } from "../src/codex/auth-api";
-import { saveConfig } from "../src/config";
+import { loadConfig, saveConfig } from "../src/config";
 import { startServer } from "../src/server";
 import type { OcxConfig } from "../src/types";
 import { installIsolatedCodexHome, type IsolatedCodexHome } from "./helpers/isolated-codex-home";
@@ -353,3 +353,244 @@ describe("Anthropic account pool strategy management API", () => {
     }
   });
 });
+
+describe("Command Code account pool strategy management API", () => {
+  let testDir = "";
+  let previousHome: string | undefined;
+  let isolatedCodexHome: IsolatedCodexHome | null = null;
+
+  function baseConfig(): OcxConfig {
+    return {
+      port: 0,
+      hostname: "127.0.0.1",
+      defaultProvider: "command-code",
+      providers: {
+        "command-code": { adapter: "command-code", baseUrl: "https://api.commandcode.ai", authMode: "oauth" },
+      },
+    } as OcxConfig;
+  }
+
+  beforeEach(() => {
+    previousHome = process.env.OPENCODEX_HOME;
+    isolatedCodexHome = installIsolatedCodexHome("ocx-cc-pool-mgmt-");
+    testDir = mkdtempSync(join(tmpdir(), "ocx-cc-pool-mgmt-"));
+    process.env.OPENCODEX_HOME = testDir;
+    saveConfig(baseConfig());
+    writeFileSync(join(testDir, "auth.json"), JSON.stringify({
+      "command-code": {
+        activeAccountId: "ccaa1111",
+        accounts: [
+          { id: "ccaa1111", credential: { access: "t1", refresh: "t1", expires: 9999999999999, email: "a@example.com", accountId: "cc-acct-1" } },
+        ],
+      },
+    }), { mode: 0o600 });
+  });
+
+  afterEach(() => {
+    if (previousHome === undefined) delete process.env.OPENCODEX_HOME;
+    else process.env.OPENCODEX_HOME = previousHome;
+    isolatedCodexHome?.restore();
+    isolatedCodexHome = null;
+    if (testDir) rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("GET /api/oauth/accounts/pool surfaces strategy defaults for command-code", async () => {
+    const server = startServer(0);
+    try {
+      const res = await fetch(new URL("/api/oauth/accounts/pool?provider=command-code", server.url));
+      expect(res.status).toBe(200);
+      expect(await res.json()).toMatchObject({
+        strategy: "quota",
+        stickyLimit: 1,
+      });
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("PUT /api/oauth/accounts/pool rejects invalid strategy for command-code", async () => {
+    const server = startServer(0);
+    try {
+      const res = await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          provider: "command-code",
+          enabled: true,
+          strategy: "weighted",
+        }),
+      });
+      expect(res.status).toBe(400);
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("PUT /api/oauth/accounts/pool accepts strategy and stickyLimit for command-code; GET reflects them", async () => {
+    const server = startServer(0);
+    try {
+      const put = await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          provider: "command-code",
+          enabled: true,
+          autoSwitchThreshold: 70,
+          strategy: "round-robin",
+          stickyLimit: 4,
+        }),
+      });
+      expect(put.status).toBe(200);
+      expect(await put.json()).toMatchObject({
+        ok: true,
+        enabled: true,
+        autoSwitchThreshold: 70,
+        strategy: "round-robin",
+        stickyLimit: 4,
+      });
+
+      const get = await fetch(new URL("/api/oauth/accounts/pool?provider=command-code", server.url));
+      expect(await get.json()).toMatchObject({
+        enabled: true,
+        autoSwitchThreshold: 70,
+        strategy: "round-robin",
+        stickyLimit: 4,
+      });
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("PUT without strategy fields preserves previously saved strategy for command-code", async () => {
+    const server = startServer(0);
+    try {
+      await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          provider: "command-code",
+          enabled: true,
+          strategy: "fill-first",
+          stickyLimit: 9,
+        }),
+      });
+      const put = await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          provider: "command-code",
+          enabled: false,
+          autoSwitchThreshold: 50,
+        }),
+      });
+      expect(put.status).toBe(200);
+      const get = await fetch(new URL("/api/oauth/accounts/pool?provider=command-code", server.url));
+      expect(await get.json()).toMatchObject({
+        enabled: false,
+        autoSwitchThreshold: 50,
+        strategy: "fill-first",
+        stickyLimit: 9,
+      });
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("PATCH with provider+strategy omits enabled and keeps current enabled for command-code", async () => {
+    const server = startServer(0);
+    try {
+      await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          provider: "command-code",
+          enabled: true,
+          strategy: "quota",
+        }),
+      });
+      const patch = await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          provider: "command-code",
+          strategy: "round-robin",
+        }),
+      });
+      expect(patch.status).toBe(200);
+      expect(await patch.json()).toMatchObject({
+        ok: true,
+        enabled: true,
+        strategy: "round-robin",
+      });
+      const get = await fetch(new URL("/api/oauth/accounts/pool?provider=command-code", server.url));
+      expect(await get.json()).toMatchObject({
+        enabled: true,
+        strategy: "round-robin",
+      });
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("GET /api/oauth/accounts?quota=1 works for command-code accounts", async () => {
+    const server = startServer(0);
+    try {
+      const res = await fetch(new URL("/api/oauth/accounts?provider=command-code&quota=1", server.url));
+      expect(res.status).toBe(200);
+      const body = await res.json() as { accounts: Array<{ id: string; quota?: unknown }> };
+      expect(body.accounts.length).toBe(1);
+      expect(body.accounts[0]!.id).toBe("ccaa1111");
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("manual Command Code account activation persists the pool pin", async () => {
+    const server = startServer(0);
+    try {
+      const res = await fetch(new URL("/api/oauth/accounts/active", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ provider: "command-code", accountId: "ccaa1111" }),
+      });
+      expect(res.status).toBe(200);
+      expect(loadConfig().commandCodeAccountPool?.activeAccountPinned).toBe("ccaa1111");
+    } finally {
+      await server.stop(true);
+    }
+  });
+
+  test("deleting the pinned Command Code account clears the persisted pin", async () => {
+    const server = startServer(0);
+    try {
+      await fetch(new URL("/api/oauth/accounts/active", server.url), {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ provider: "command-code", accountId: "ccaa1111" }),
+      });
+      expect(loadConfig().commandCodeAccountPool?.activeAccountPinned).toBe("ccaa1111");
+      const res = await fetch(new URL("/api/oauth/accounts?provider=command-code&id=ccaa1111", server.url), {
+        method: "DELETE",
+      });
+      expect(res.status).toBe(200);
+      expect(loadConfig().commandCodeAccountPool?.activeAccountPinned).toBeUndefined();
+    } finally {
+      await server.stop(true);
+    }
+  });
+});
+
+test("Anthropic pool rejects Command Code priority and pin controls", async () => {
+  const server = startServer(0);
+  try {
+    const response = await fetch(new URL("/api/oauth/accounts/pool", server.url), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ provider: "anthropic", enabled: true, accountPriorities: { account: 1 } }),
+    });
+    expect(response.status).toBe(400);
+    expect(await response.json()).toMatchObject({ error: "account priorities and manual pins are only supported for command-code" });
+  } finally {
+    await server.stop(true);
+  }
+});
diff --git a/tests/cli-account.test.ts b/tests/cli-account.test.ts
index 8a0110d67..fcf937cd4 100644
--- a/tests/cli-account.test.ts
+++ b/tests/cli-account.test.ts
@@ -50,6 +50,7 @@ let activeCodexAccountId: string | null = "chatgpt_1";
 let autoSwitchThreshold = 80;
 let activeReadFailure: { status: number; error: string } | null = null;
 let oauthListFailure: { provider: string; status: number; error: string } | null = null;
+let oauthPoolConfig: Record<string, unknown> = { enabled: false, autoSwitchThreshold: 80, strategy: "quota", stickyLimit: 1 };
 let keyListFailure: { provider: string; status: number; error: string } | null = null;
 let codexRefreshFailure: MockFailure | null = null;
 let autoSwitchUpdateFailure: MockFailure | null = null;
@@ -88,6 +89,11 @@ function fixtureConfig(): OcxConfig {
         baseUrl: "https://api.anthropic.com",
         authMode: "oauth",
       },
+      "command-code": {
+        adapter: "command-code",
+        baseUrl: "https://api.commandcode.ai",
+        authMode: "oauth",
+      },
       kiro: {
         adapter: "anthropic",
         baseUrl: "https://q.us-east-1.amazonaws.com",
@@ -215,7 +221,7 @@ async function mockManagementApi(req: Request): Promise<Response> {
     if (provider === "anthropic" && lastDeletedType === "oauth" && postDeleteReadFailure) {
       return json({ error: postDeleteReadFailure.error }, postDeleteReadFailure.status);
     }
-    if (provider === "anthropic") {
+    if (provider === "anthropic" || provider === "command-code") {
       return json({ activeAccountId: oauthActiveId, accounts: oauthAccounts.map(account => ({
         ...account,
         active: account.id === oauthActiveId,
@@ -238,6 +244,32 @@ async function mockManagementApi(req: Request): Promise<Response> {
     return json({ ok: true, activeAccountId: accountId });
   }
 
+  if (req.method === "GET" && url.pathname === "/api/oauth/accounts/pool") {
+    const provider = url.searchParams.get("provider");
+    if (provider !== "anthropic" && provider !== "command-code") {
+      return json({ error: "pool config is only supported for anthropic and command-code" }, 400);
+    }
+    return json({ provider, ...oauthPoolConfig });
+  }
+  if (req.method === "PUT" && url.pathname === "/api/oauth/accounts/pool") {
+    const payload = body as { provider?: string; enabled?: boolean; autoSwitchThreshold?: number };
+    if (payload.provider !== "anthropic" && payload.provider !== "command-code") {
+      return json({ error: "pool config is only supported for anthropic and command-code" }, 400);
+    }
+    oauthPoolConfig = { ...oauthPoolConfig, ...payload };
+    return json({ ok: true, ...oauthPoolConfig });
+  }
+  if (req.method === "PUT" && url.pathname === "/api/oauth/accounts/pool/priority") {
+    const payload = body as { provider?: string; id?: string; priority?: number };
+    if (payload.provider !== "anthropic" && payload.provider !== "command-code") {
+      return json({ error: "priority is only supported for anthropic and command-code pools" }, 400);
+    }
+    const account = oauthAccounts.find(entry => entry.id === payload.id);
+    if (!account) return json({ error: "account not found" }, 404);
+    account.priority = payload.priority ?? 0;
+    return json({ ok: true, provider: payload.provider, id: payload.id, priority: payload.priority });
+  }
+
   if (req.method === "POST" && url.pathname === "/api/oauth/accounts/import") {
     const payload = body as { provider?: string; format?: string; document?: unknown };
     if (payload.provider !== "google-antigravity") return json({ code: "unsupported_provider" }, 400);
@@ -409,6 +441,7 @@ beforeEach(() => {
   autoSwitchThreshold = 80;
   activeReadFailure = null;
   oauthListFailure = null;
+  oauthPoolConfig = { enabled: false, autoSwitchThreshold: 80, strategy: "quota", stickyLimit: 1 };
   keyListFailure = null;
   codexRefreshFailure = null;
   autoSwitchUpdateFailure = null;
@@ -432,7 +465,7 @@ beforeEach(() => {
     { id: "chatgpt_1", email: "j***@example.com", plan: "pro", needsReauth: true, priority: 1, quota: null },
   ];
   oauthAccounts = [
-    { id: "acct_1", email: "a***@example.com" },
+    { id: "acct_1", email: "a***@example.com", priority: 2 },
     { id: "acct_2" },
   ];
   oauthActiveId = "acct_1";
@@ -472,7 +505,7 @@ describe("ocx account CLI (issue #180 matrix)", () => {
     // column reads as a position on an axis rather than a magnitude. Without this the
     // whole suite passes with priorityText's `+${n}` branch collapsed to String(n).
     expect(result.stdout).toMatch(/^openai\s+codex\s+chatgpt_1\s+\S+\s+\+1\s/m);
-    expect(result.stdout).toMatch(/^anthropic\s+oauth\s+acct_1\s+a\*\*\*@example\.com\s+-\s+active/m);
+    expect(result.stdout).toMatch(/^anthropic\s+oauth\s+acct_1\s+a\*\*\*@example\.com\s+\+2\s+active/m);
     expect(result.stdout).toMatch(/^openrouter\s+api-key\s+key_1\s+test\*\*\*\*7890 \(personal\)\s+-\s+active/m);
     expect(result.stdout).not.toContain("__main__");
 
@@ -780,18 +813,50 @@ describe("ocx account CLI (issue #180 matrix)", () => {
   });
 
   test("21: auto-switch rejects wrong providers, invalid thresholds and missing providers", async () => {
-    const wrongProvider = await run(["auto-switch", "anthropic", "on"]);
+    const wrongProvider = await run(["auto-switch", "kiro", "on"]);
     const invalidThreshold = await run(["auto-switch", "openai", "threshold", "101"]);
     const missingProvider = await run(["auto-switch"]);
 
     expect(wrongProvider.code).toBe(1);
-    expect(wrongProvider.stderr).toContain("auto-switch only applies to the openai Codex account pool");
+    expect(wrongProvider.stderr).toContain("auto-switch applies to the openai Codex account pool and command-code");
     expect(invalidThreshold.code).toBe(1);
     expect(invalidThreshold.stderr).toContain("integer 0-100");
     expect(missingProvider.code).toBe(1);
     expect(missingProvider.stderr).toContain("Usage:");
   });
 
+  test("21b: auto-switch on/status works for command-code OAuth pool", async () => {
+    const on = await run(["auto-switch", "command-code", "on"]);
+    const status = await run(["auto-switch", "command-code", "status", "--json"]);
+    const poolPuts = requests.filter(request => request.path === "/api/oauth/accounts/pool");
+
+    expect(on.code).toBe(0);
+    expect(on.stdout).toBe("auto-switch: on (threshold 80%)");
+    expect(poolPuts).toContainEqual(expect.objectContaining({
+      method: "PUT",
+      body: expect.objectContaining({ provider: "command-code", enabled: true, autoSwitchThreshold: 80 }),
+    }));
+    expect(JSON.parse(status.stdout)).toEqual({
+      provider: "command-code",
+      autoSwitchThreshold: 80,
+      enabled: true,
+    });
+  });
+
+  test("21c: priority set/read works for command-code OAuth pool", async () => {
+    oauthAccounts = [{ id: "cc_a", email: "a***@test.com", active: true }];
+    oauthActiveId = "cc_a";
+    const setResult = await run(["priority", "command-code", "cc_a", "first", "--json"]);
+    expect(setResult.code).toBe(0);
+    expect(JSON.parse(setResult.stdout)).toEqual({ ok: true, provider: "command-code", id: "cc_a", priority: 2, preset: "first" });
+    const priorityPut = requests.find(request => request.path === "/api/oauth/accounts/pool/priority");
+    expect(priorityPut?.body).toEqual({ provider: "command-code", id: "cc_a", priority: 2 });
+
+    const readResult = await run(["priority", "command-code", "cc_a", "--json"]);
+    expect(readResult.code).toBe(0);
+    expect(JSON.parse(readResult.stdout)).toEqual({ ok: true, provider: "command-code", id: "cc_a", priority: 2, preset: "first" });
+  });
+
   test("22: remove without --yes prints the re-run hint and sends no request", async () => {
     // Recording fetchImpl proves no HTTP call is even attempted — the --yes
     // guard fires at arg-parse time, before resolveBaseUrl (Carver C-gate).
@@ -1258,11 +1323,11 @@ describe("ocx account CLI (issue #180 matrix)", () => {
       expect(priorityRequests()).toEqual([]);
     });
 
-    test("non-Codex providers are rejected", async () => {
-      const result = await run(["priority", "anthropic", "acct_1", "first"]);
+    test("unsupported providers are rejected", async () => {
+      const result = await run(["priority", "kiro", "acct_1", "first"]);
 
       expect(result.code).toBe(1);
-      expect(result.stderr).toContain("only applies to the openai Codex account pool");
+      expect(result.stderr).toContain("selection order applies to the openai Codex account pool and command-code");
     });
 
     // Both paths reach the proxy through different helpers — the read through
diff --git a/tests/command-code-account-pool.test.ts b/tests/command-code-account-pool.test.ts
new file mode 100644
index 000000000..f9b8c946a
--- /dev/null
+++ b/tests/command-code-account-pool.test.ts
@@ -0,0 +1,456 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { clearPoolRotationState, notePoolRotationFailure, POOL_KEY_COMMAND_CODE } from "../src/codex/pool-rotation";
+import {
+  bindCommandCodeSessionAffinity,
+  clearCommandCodeAccountPoolState,
+  formatCommandCodeProviderForLog,
+  getEligibleCommandCodeAccounts,
+  isCommandCodeAccountPoolEnabled,
+  resolveCommandCodeAccountForSession,
+  resetCommandCodeRoutingForManualSelection,
+  rotateCommandCodeAccountOn429,
+  commandCodeSessionKeyFromParts,
+} from "../src/oauth/command-code-routing";
+import { getAccountSet, saveCredential, setActiveAccount } from "../src/oauth/store";
+import { clearAccountQuotaCache, setCachedProviderAccountQuotaForTests } from "../src/providers/quota";
+import type { OcxAccountPoolRotationStrategy, OcxConfig } from "../src/types";
+
+const originalHome = process.env.OPENCODEX_HOME;
+let home: string;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "ocx-command-code-pool-"));
+  process.env.OPENCODEX_HOME = home;
+  clearCommandCodeAccountPoolState();
+  clearPoolRotationState();
+  clearAccountQuotaCache("command-code");
+});
+
+afterEach(() => {
+  clearCommandCodeAccountPoolState();
+  clearPoolRotationState();
+  clearAccountQuotaCache("command-code");
+  if (originalHome === undefined) delete process.env.OPENCODEX_HOME;
+  else process.env.OPENCODEX_HOME = originalHome;
+  rmSync(home, { recursive: true, force: true });
+});
+
+async function seedTwoAccounts() {
+  await saveCredential("command-code", {
+    access: "access-a",
+    refresh: "access-a",
+    expires: Date.now() + 3_600_000,
+    accountId: "uuid-aaaa",
+    email: "a@example.test",
+  });
+  await saveCredential("command-code", {
+    access: "access-b",
+    refresh: "access-b",
+    expires: Date.now() + 3_600_000,
+    accountId: "uuid-bbbb",
+    email: "b@example.test",
+  });
+  // saveCredential activates the newly appended account (B). Pin A as active for predictable tests.
+  const set = getAccountSet("command-code")!;
+  const a = set.accounts.find(acc => acc.credential.accountId === "uuid-aaaa")!;
+  const b = set.accounts.find(acc => acc.credential.accountId === "uuid-bbbb")!;
+  await setActiveAccount("command-code", a.id);
+  return { aId: a.id, bId: b.id };
+}
+
+function cfg(
+  enabled: boolean,
+  threshold = 80,
+  pool: { strategy?: OcxAccountPoolRotationStrategy; stickyLimit?: number } = {},
+): OcxConfig {
+  return {
+    port: 0,
+    defaultProvider: "command-code",
+    providers: {
+      "command-code": { adapter: "command-code", baseUrl: "https://api.commandcode.ai", authMode: "oauth" },
+    },
+    commandCodeAccountPool: {
+      enabled,
+      autoSwitchThreshold: threshold,
+      ...pool,
+    },
+  } as OcxConfig;
+}
+
+async function seedThreeAccounts() {
+  await saveCredential("command-code", {
+    access: "access-a",
+    refresh: "access-a",
+    expires: Date.now() + 3_600_000,
+    accountId: "uuid-aaaa",
+    email: "a@example.test",
+  });
+  await saveCredential("command-code", {
+    access: "access-b",
+    refresh: "access-b",
+    expires: Date.now() + 3_600_000,
+    accountId: "uuid-bbbb",
+    email: "b@example.test",
+  });
+  await saveCredential("command-code", {
+    access: "access-c",
+    refresh: "access-c",
+    expires: Date.now() + 3_600_000,
+    accountId: "uuid-cccc",
+    email: "c@example.test",
+  });
+  const set = getAccountSet("command-code")!;
+  const a = set.accounts.find(acc => acc.credential.accountId === "uuid-aaaa")!;
+  const b = set.accounts.find(acc => acc.credential.accountId === "uuid-bbbb")!;
+  const c = set.accounts.find(acc => acc.credential.accountId === "uuid-cccc")!;
+  await setActiveAccount("command-code", a.id);
+  return { aId: a.id, bId: b.id, cId: c.id };
+}
+
+describe("command-code account pool", () => {
+  test("default off always returns the active account", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    expect(isCommandCodeAccountPoolEnabled(cfg(false))).toBe(false);
+    const sel = resolveCommandCodeAccountForSession("session-1", cfg(false));
+    expect(sel.accountId).toBe(aId);
+    expect(sel.reason).toBe("pool-disabled");
+    expect(sel.accountId).not.toBe(bId);
+  });
+
+  test("affinity sticks across resolves until cooled", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    // Force lowest-usage toward B for a cold start with high active usage.
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 95 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    const first = resolveCommandCodeAccountForSession("sess-sticky", cfg(true));
+    expect(first.accountId).toBe(bId);
+    // Even if A becomes "better", affinity keeps B.
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 1 });
+    const second = resolveCommandCodeAccountForSession("sess-sticky", cfg(true));
+    expect(second.accountId).toBe(bId);
+    expect(second.reason).toBe("affinity");
+  });
+
+  test("429 cools the account and failover picks another eligible account", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    bindCommandCodeSessionAffinity("sess-fail", aId);
+    const next = rotateCommandCodeAccountOn429(cfg(true), aId, "30", "sess-fail");
+    expect(next).toBe(bId);
+    expect(getEligibleCommandCodeAccounts()).toEqual([bId]);
+    const after = resolveCommandCodeAccountForSession("sess-fail", cfg(true));
+    expect(after.accountId).toBe(bId);
+  });
+
+  test("all cooled returns all-cooled rather than none", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    expect(rotateCommandCodeAccountOn429(cfg(true), aId, "120")).toBe(bId);
+    expect(rotateCommandCodeAccountOn429(cfg(true), bId, "120")).toBeNull();
+    const sel = resolveCommandCodeAccountForSession("cooled-sess", cfg(true));
+    expect(sel.accountId).toBeNull();
+    expect(sel.reason).toBe("all-cooled");
+  });
+
+  test("unknown active usage does not force a switch", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    // Only B has known usage; active A is unknown and must stay selected under threshold rules.
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 5 });
+    const sel = resolveCommandCodeAccountForSession("unknown-usage", cfg(true, 80));
+    expect(sel.accountId).toBe(aId);
+    expect(sel.reason).toBe("active");
+  });
+
+  test("new session prefers lower fiveHour usage when above threshold", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 90 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 20 });
+    const sel = resolveCommandCodeAccountForSession("new-sess", cfg(true, 80));
+    expect(sel.accountId).toBe(bId);
+    expect(sel.reason).toBe("lowest-usage");
+  });
+
+  test("session key prefers session_id over prompt_cache_key", () => {
+    expect(commandCodeSessionKeyFromParts({
+      sessionIdHeader: "sess-a",
+      promptCacheKey: "cache-b",
+    })).toBe("sess-a");
+  });
+
+  test("shared Desktop cache cohort alone does not create affinity key", () => {
+    expect(commandCodeSessionKeyFromParts({
+      promptCacheKey: "shared-cohort-hash",
+      promptCacheKeyIsSharedCohort: true,
+    })).toBeNull();
+    expect(commandCodeSessionKeyFromParts({
+      promptCacheKey: "per-session-hash",
+      promptCacheKeyIsSharedCohort: false,
+    })).toBe("per-session-hash");
+  });
+
+  test("log label is non-PII ordinal", () => {
+    const label = formatCommandCodeProviderForLog("command-code", "deadbeefdeadbeef");
+    expect(label).toMatch(/^command-code-p[a-f0-9]{6}$/);
+    expect(label).not.toContain("deadbeef");
+  });
+
+  test("round-robin strategy rotates unbound new sessions", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "round-robin" });
+
+    const picks = [
+      resolveCommandCodeAccountForSession("sess-1", config).accountId,
+      resolveCommandCodeAccountForSession("sess-2", config).accountId,
+      resolveCommandCodeAccountForSession("sess-3", config).accountId,
+    ];
+    expect(new Set(picks).size).toBe(3);
+  });
+
+  test("null/empty session key holds active under RR instead of rotating every turn", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "round-robin", stickyLimit: 1 });
+
+    const picks = Array.from({ length: 6 }, () => resolveCommandCodeAccountForSession(null, config).accountId);
+    expect(picks.every(id => id === aId)).toBe(true);
+    expect(resolveCommandCodeAccountForSession("", config).reason).toBe("active");
+  });
+
+  test("affinity still wins over round-robin", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "round-robin" });
+
+    const first = resolveCommandCodeAccountForSession("T", config);
+    expect(first.accountId).toBeTruthy();
+    const pinned = first.accountId!;
+    await setActiveAccount("command-code", pinned === aId ? bId : aId);
+    expect(resolveCommandCodeAccountForSession("T", config).accountId).toBe(pinned);
+    expect(resolveCommandCodeAccountForSession("T", config).reason).toBe("affinity");
+  });
+
+  test("omitted strategy preserves quota / active behaviour", async () => {
+    const { aId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    const config = cfg(true);
+
+    expect(resolveCommandCodeAccountForSession(null, config).accountId).toBe(aId);
+    expect(resolveCommandCodeAccountForSession("new-sess", config).accountId).toBe(aId);
+  });
+
+  test("disabled pool ignores round-robin strategy", async () => {
+    const { aId } = await seedThreeAccounts();
+    const config = cfg(false, 80, { strategy: "round-robin" });
+    const picks = [
+      resolveCommandCodeAccountForSession(null, config).accountId,
+      resolveCommandCodeAccountForSession(null, config).accountId,
+      resolveCommandCodeAccountForSession(null, config).accountId,
+    ];
+    expect(picks).toEqual([aId, aId, aId]);
+    expect(resolveCommandCodeAccountForSession(null, config).reason).toBe("pool-disabled");
+  });
+
+  test("fill-first keeps active under threshold", async () => {
+    const { aId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "fill-first" });
+
+    const picks = Array.from({ length: 8 }, () => resolveCommandCodeAccountForSession("ff-sess", config).accountId);
+    expect(picks.every(id => id === aId)).toBe(true);
+    expect(resolveCommandCodeAccountForSession("ff-sess-2", config).reason).toBe("fill-first");
+    // Null session key also holds active (Desktop without sticky identity).
+    expect(resolveCommandCodeAccountForSession(null, config).accountId).toBe(aId);
+    expect(resolveCommandCodeAccountForSession(null, config).reason).toBe("active");
+  });
+
+  test("stickyLimit holds across successive unbound resolves", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "round-robin", stickyLimit: 3 });
+
+    const first = resolveCommandCodeAccountForSession("s1", config).accountId;
+    expect(first).toBeTruthy();
+    expect(resolveCommandCodeAccountForSession("s2", config).accountId).toBe(first);
+    expect(resolveCommandCodeAccountForSession("s3", config).accountId).toBe(first);
+    const fourth = resolveCommandCodeAccountForSession("s4", config).accountId;
+    expect(fourth).not.toBe(first);
+  });
+
+  test("429 / notePoolRotationFailure advances past sticky while account stays eligible", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "round-robin", stickyLimit: 10 });
+
+    const sticky = resolveCommandCodeAccountForSession("sticky-1", config).accountId!;
+    expect(resolveCommandCodeAccountForSession("sticky-2", config).accountId).toBe(sticky);
+
+    notePoolRotationFailure(POOL_KEY_COMMAND_CODE, sticky);
+    const afterClear = resolveCommandCodeAccountForSession("sticky-3", config).accountId;
+    expect(afterClear).toBeTruthy();
+    expect(afterClear).not.toBe(sticky);
+
+    // Re-establish sticky, then 429-cool the sticky account — failover + ring must leave it.
+    clearPoolRotationState();
+    const again = resolveCommandCodeAccountForSession("again-1", config).accountId!;
+    expect(resolveCommandCodeAccountForSession("again-2", config).accountId).toBe(again);
+    const failover = rotateCommandCodeAccountOn429(config, again, "30");
+    expect(failover).toBeTruthy();
+    expect(failover).not.toBe(again);
+    // After cooldown the failed account is unusable; null key holds active only when eligible.
+    await setActiveAccount("command-code", failover!);
+    const unboundAfter429 = resolveCommandCodeAccountForSession("again-3", config).accountId;
+    expect(unboundAfter429).not.toBe(again);
+    expect([bId, cId, aId].filter(id => id !== again)).toContain(unboundAfter429);
+  });
+
+  test("fill-first skips drained successors when advancing past threshold", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    const ordered = [aId, bId, cId].sort((a, b) => a.localeCompare(b));
+    setCachedProviderAccountQuotaForTests("command-code", ordered[0]!, { fiveHourPercent: 90 });
+    setCachedProviderAccountQuotaForTests("command-code", ordered[1]!, { fiveHourPercent: 95 });
+    setCachedProviderAccountQuotaForTests("command-code", ordered[2]!, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "fill-first" });
+    await setActiveAccount("command-code", ordered[0]!);
+
+    expect(resolveCommandCodeAccountForSession("ff-drain", config).accountId).toBe(ordered[2]);
+  });
+
+  test("fill-first 429 advances next in stable order, not lowest usage", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    // Sorted ids: force usage so lowest-usage would pick cId.
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 50 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 5 });
+    const config = cfg(true, 80, { strategy: "fill-first" });
+
+    const ordered = [aId, bId, cId].sort((a, b) => a.localeCompare(b));
+    // Ensure active is the first in stable order so fill-first holds it.
+    await setActiveAccount("command-code", ordered[0]!);
+    expect(resolveCommandCodeAccountForSession("ff-hold", config).accountId).toBe(ordered[0]);
+
+    const failover = rotateCommandCodeAccountOn429(config, ordered[0]!, "30");
+    expect(failover).toBe(ordered[1]);
+  });
+
+  test("unbound strategy pick does not promote active before token validation", async () => {
+    const { aId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    await setActiveAccount("command-code", aId);
+    const config = cfg(true, 80, { strategy: "round-robin", stickyLimit: 1 });
+
+    const before = getAccountSet("command-code")!.activeAccountId;
+    const picks = Array.from({ length: 3 }, (_, i) => resolveCommandCodeAccountForSession(`promo-${i}`, config));
+    expect(new Set(picks.map(p => p.accountId)).size).toBe(3);
+    expect(getAccountSet("command-code")!.activeAccountId).toBe(before);
+  });
+
+  test("manual selection seeds RR so the next unbound session uses that account", async () => {
+    const { aId, bId, cId } = await seedThreeAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 10 });
+    setCachedProviderAccountQuotaForTests("command-code", cId, { fiveHourPercent: 10 });
+    const config = cfg(true, 80, { strategy: "round-robin", stickyLimit: 1 });
+
+    resolveCommandCodeAccountForSession("seed-1", config);
+    resolveCommandCodeAccountForSession("seed-2", config);
+
+    await setActiveAccount("command-code", cId);
+    resetCommandCodeRoutingForManualSelection(cId);
+    expect(resolveCommandCodeAccountForSession("seed-3", config).accountId).toBe(cId);
+  });
+});
+
+describe("command-code account pool priority", () => {
+  test("higher-priority account with headroom preempts active under quota strategy", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    // Explicitly select A as active so B's higher priority preempts it.
+    await setActiveAccount("command-code", aId);
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 20 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 30 });
+    const config = {
+      ...cfg(true, 80),
+      commandCodeAccountPool: {
+        enabled: true,
+        autoSwitchThreshold: 80,
+        accountPriorities: { [bId]: 10 },
+      },
+    } as OcxConfig;
+
+    const sel = resolveCommandCodeAccountForSession("prio-new-sess", config);
+    expect(sel.accountId).toBe(bId);
+    expect(sel.reason).toBe("priority-preemption");
+  });
+
+  test("pinned account suppresses upward priority preemption", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 20 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 30 });
+    const config = {
+      ...cfg(true, 80),
+      commandCodeAccountPool: {
+        enabled: true,
+        autoSwitchThreshold: 80,
+        accountPriorities: { [bId]: 10 },
+        activeAccountPinned: aId,
+      },
+    } as OcxConfig;
+
+    const sel = resolveCommandCodeAccountForSession("pinned-sess", config);
+    expect(sel.accountId).toBe(aId);
+  });
+
+  test("priority tier constrains round-robin and fill-first selection", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 20 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 20 });
+
+    for (const strategy of ["round-robin", "fill-first"] as const) {
+      clearCommandCodeAccountPoolState();
+      clearPoolRotationState();
+      const config = {
+        ...cfg(true, 80, { strategy }),
+        commandCodeAccountPool: {
+          enabled: true,
+          autoSwitchThreshold: 80,
+          strategy,
+          accountPriorities: { [bId]: 10 },
+        },
+      } as OcxConfig;
+      expect(resolveCommandCodeAccountForSession(`${strategy}-priority`, config).accountId).toBe(bId);
+    }
+  });
+
+  test("manual pin constrains round-robin and fill-first selection", async () => {
+    const { aId, bId } = await seedTwoAccounts();
+    setCachedProviderAccountQuotaForTests("command-code", aId, { fiveHourPercent: 20 });
+    setCachedProviderAccountQuotaForTests("command-code", bId, { fiveHourPercent: 20 });
+
+    for (const strategy of ["round-robin", "fill-first"] as const) {
+      clearCommandCodeAccountPoolState();
+      clearPoolRotationState();
+      const config = {
+        ...cfg(true, 80, { strategy }),
+        commandCodeAccountPool: {
+          enabled: true,
+          autoSwitchThreshold: 80,
+          strategy,
+          accountPriorities: { [bId]: 10 },
+          activeAccountPinned: aId,
+        },
+      } as OcxConfig;
+      expect(resolveCommandCodeAccountForSession(`${strategy}-pin`, config).accountId).toBe(aId);
+    }
+  });
+});
diff --git a/tests/provider-account-quota.test.ts b/tests/provider-account-quota.test.ts
index 634c663ca..7cf4a86cc 100644
--- a/tests/provider-account-quota.test.ts
+++ b/tests/provider-account-quota.test.ts
@@ -419,3 +419,144 @@ describe("fetchProviderAccountQuotas", () => {
     expect(getCachedProviderAccountQuota("anthropic", first!.id)).toBeNull();
   });
 });
+
+describe("command-code per-account quota", () => {
+  async function seedCommandCodeAccounts() {
+    const expires = Date.now() + 60 * 60_000;
+    await saveCredential("command-code", {
+      access: "cc-token-first", refresh: "cc-token-first", expires,
+      accountId: "cc-acct-first", email: "cc-first@example.com",
+    });
+    await saveCredential("command-code", {
+      access: "cc-token-second", refresh: "cc-token-second", expires,
+      accountId: "cc-acct-second", email: "cc-second@example.com",
+    });
+  }
+
+  function creditsBody(fiveHourUsed: number, fiveHourCap: number, weeklyUsed: number, weeklyCap: number): string {
+    return JSON.stringify({
+      credits: { monthlyCredits: 80, purchasedCredits: 0, freeCredits: 0 },
+      windowLimits: {
+        limited: true,
+        exceeded: null,
+        fiveHour: { used: fiveHourUsed, cap: fiveHourCap, exceeded: false, resetAt: "2026-07-05T12:00:00Z" },
+        weekly: { used: weeklyUsed, cap: weeklyCap, exceeded: false, resetAt: "2026-07-08T12:00:00Z" },
+      },
+    });
+  }
+
+  test("reports each account's own 5h/weekly caps from /alpha/billing/credits", async () => {
+    await seedCommandCodeAccounts();
+    const seenTokens: string[] = [];
+    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+      expect(String(input)).toBe("https://api.commandcode.ai/alpha/billing/credits");
+      const auth = new Headers(init?.headers).get("authorization") ?? "";
+      seenTokens.push(auth);
+      // Distinct upstream numbers per credential — the whole point of a per-account probe.
+      const body = auth.endsWith("cc-token-first") ? creditsBody(3, 10, 6, 10) : creditsBody(0.5, 10, 1, 10);
+      return new Response(body, { status: 200 });
+    }) as typeof fetch;
+
+    const rows = await fetchProviderAccountQuotas("command-code");
+    expect(rows.length).toBe(2);
+    const values = rows.map(row => `${row.quota?.fiveHourPercent}/${row.quota?.weeklyPercent}`).sort();
+    // 3/10 = 30%, 6/10 = 60%; 0.5/10 = 5%, 1/10 = 10%
+    expect(values).toEqual(["30/60", "5/10"]);
+    expect(seenTokens.sort()).toEqual(["Bearer cc-token-first", "Bearer cc-token-second"]);
+    for (const row of rows) {
+      expect(row.quota?.customWindows).toBeUndefined();
+      // monthlyCredits is a remaining balance without a total/cap denominator.
+      expect(row.quota?.monthlyPercent).toBeUndefined();
+    }
+  });
+
+  test("credits-only payload is not treated as usable quota", async () => {
+    await saveCredential("command-code", {
+      access: "cc-token-only-credits", refresh: "cc-token-only-credits",
+      expires: Date.now() + 60 * 60_000, accountId: "cc-only", email: "only@example.com",
+    });
+    globalThis.fetch = (async () => new Response(JSON.stringify({
+      credits: { monthlyCredits: 80, purchasedCredits: 0, freeCredits: 0 },
+      windowLimits: {},
+    }), { status: 200 })) as typeof fetch;
+
+    const rows = await fetchProviderAccountQuotas("command-code");
+    expect(rows).toEqual([expect.objectContaining({ quota: null, unavailable: true })]);
+  });
+
+  test("unknown command-code provider adapter fails closed without probing", async () => {
+    await saveCredential("command-code", {
+      access: "cc-token-unknown", refresh: "cc-token-unknown",
+      expires: Date.now() + 60 * 60_000, accountId: "cc-unknown", email: "unknown@example.com",
+    });
+    let called = false;
+    globalThis.fetch = (async () => { called = true; return new Response("{}", { status: 200 }); }) as typeof fetch;
+    const config: OcxConfig = {
+      port: 1455,
+      defaultProvider: "command-code",
+      providers: {
+        "command-code": {
+          adapter: "command-code-alias",
+          authMode: "oauth",
+          baseUrl: "https://api.commandcode.ai",
+        },
+      },
+    };
+    const response = await fetchProviderQuotaReports(config, true);
+    expect(response.reports).toEqual([]);
+    expect(called).toBe(false);
+  });
+
+  test("supportsPerAccountQuota includes command-code", async () => {
+    expect(supportsPerAccountQuota("command-code")).toBe(true);
+  });
+
+  test("a failing command-code probe is flagged unavailable without dropping the sibling", async () => {
+    await seedCommandCodeAccounts();
+    globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+      const auth = new Headers(init?.headers).get("authorization") ?? "";
+      if (auth.endsWith("cc-token-first")) return new Response("rate limited", { status: 429 });
+      return new Response(creditsBody(1, 10, 2, 10), { status: 200 });
+    }) as typeof fetch;
+
+    const rows = await fetchProviderAccountQuotas("command-code");
+    const failed = rows.find(row => row.quota === null);
+    const ok = rows.find(row => row.quota !== null);
+    expect(failed?.unavailable).toBe(true);
+    expect(ok?.quota?.fiveHourPercent).toBe(10);
+    expect(ok?.quota?.weeklyPercent).toBe(20);
+  });
+
+  test("provider-report probe seeds the active command-code account cache", async () => {
+    await seedCommandCodeAccounts();
+    const { getAccountSet, setActiveAccount } = await import("../src/oauth/store");
+    const set = getAccountSet("command-code");
+    const first = set?.accounts.find(a => a.credential.email === "cc-first@example.com");
+    expect(first).toBeTruthy();
+    await setActiveAccount("command-code", first!.id);
+
+    let calls = 0;
+    globalThis.fetch = (async (_input: RequestInfo | URL, init?: RequestInit) => {
+      calls += 1;
+      const auth = new Headers(init?.headers).get("authorization") ?? "";
+      const body = auth.endsWith("cc-token-first") ? creditsBody(3, 10, 6, 10) : creditsBody(0.5, 10, 1, 10);
+      return new Response(body, { status: 200 });
+    }) as typeof fetch;
+
+    const config: OcxConfig = {
+      port: 1455,
+      defaultProvider: "command-code",
+      providers: {
+        "command-code": {
+          adapter: "command-code",
+          authMode: "oauth",
+          baseUrl: "https://api.commandcode.ai",
+        },
+      },
+    };
+    await fetchProviderQuotaReports(config, true);
+    expect(calls).toBe(1);
+    // The active-account probe seeded the per-account cache.
+    expect(getCachedProviderAccountQuota("command-code", first!.id)?.fiveHourPercent).toBe(30);
+  });
+});
diff --git a/tests/server-rate-limit-retry-e2e.test.ts b/tests/server-rate-limit-retry-e2e.test.ts
index 467f6ca52..10294316c 100644
--- a/tests/server-rate-limit-retry-e2e.test.ts
+++ b/tests/server-rate-limit-retry-e2e.test.ts
@@ -3,6 +3,8 @@ import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { saveConfig } from "../src/config";
+import { clearCommandCodeAccountPoolState } from "../src/oauth/command-code-routing";
+import { getAccountSet, saveCredential, setActiveAccount } from "../src/oauth/store";
 import { clearKeyCooldowns } from "../src/providers/key-failover";
 import { startServer } from "../src/server";
 import type { OcxConfig } from "../src/types";
@@ -19,6 +21,7 @@ beforeEach(() => {
   testDir = mkdtempSync(join(tmpdir(), "ocx-ratelimit-e2e-"));
   process.env.OPENCODEX_HOME = testDir;
   clearKeyCooldowns();
+  clearCommandCodeAccountPoolState();
 });
 
 afterEach(() => {
@@ -28,6 +31,7 @@ afterEach(() => {
   isolatedCodexHome = null;
   if (testDir) removeTreeWithRetry(testDir);
   clearKeyCooldowns();
+  clearCommandCodeAccountPoolState();
 });
 
 const okChatCompletion = JSON.stringify({
@@ -47,6 +51,61 @@ async function postResponses(serverUrl: string, model: string): Promise<Response
 }
 
 describe("server same-target 429 retry (end-to-end)", () => {
+  test("Command Code OAuth pool rotates accounts on consecutive 429s and stops when all are cooled", async () => {
+    const originalFetch = globalThis.fetch;
+    const seenAuth: string[] = [];
+    globalThis.fetch = (async (input, init) => {
+      const url = input instanceof Request ? input.url : String(input);
+      if (url === "https://api.commandcode.ai/alpha/generate") {
+        seenAuth.push(new Headers(init?.headers).get("authorization") ?? "");
+        return new Response(JSON.stringify({ error: { message: "rate limited" } }), {
+          status: 429,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      return originalFetch(input, init);
+    }) as typeof fetch;
+
+    let server: ReturnType<typeof startServer> | null = null;
+    try {
+      for (const [accountId, access] of [["account-a", "access-a"], ["account-b", "access-b"], ["account-c", "access-c"]] as const) {
+        await saveCredential("command-code", {
+          access,
+          refresh: access,
+          expires: Date.now() + 3_600_000,
+          accountId,
+          email: `${accountId}@example.test`,
+        });
+      }
+      const accounts = getAccountSet("command-code")!.accounts;
+      const first = accounts.find(account => account.credential.accountId === "account-a")!;
+      await setActiveAccount("command-code", first.id);
+      saveConfig({
+        port: 0,
+        hostname: "127.0.0.1",
+        defaultProvider: "command-code",
+        providers: {
+          "command-code": { adapter: "command-code", baseUrl: "https://api.commandcode.ai", authMode: "oauth" },
+        },
+        commandCodeAccountPool: { enabled: true, autoSwitchThreshold: 80 },
+      } as OcxConfig);
+      server = startServer(0);
+
+      const response = await postResponses(server.url, "command-code/deepseek/deepseek-v4-flash");
+      expect(response.status).toBe(429);
+      // Each rotation invalidates the same-target request cache: the next send
+      // is rebuilt with the next OAuth bearer, not replayed with the cooled one.
+      expect(seenAuth).toEqual(["Bearer access-a", "Bearer access-b", "Bearer access-c"]);
+      expect(seenAuth).toHaveLength(3);
+    } finally {
+      try {
+        await server?.stop(true);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    }
+  });
+
   test("single-key provider replays the identical request until upstream succeeds", async () => {
     const originalFetch = globalThis.fetch;
     const seenBodies: string[] = [];
diff --git a/tests/state-store-sweeper.test.ts b/tests/state-store-sweeper.test.ts
index 1d149fc6d..448bb89c7 100644
--- a/tests/state-store-sweeper.test.ts
+++ b/tests/state-store-sweeper.test.ts
@@ -86,6 +86,7 @@ describe("state-store sweeper", () => {
       "api-key-cooldowns",
       "combo-target-cooldowns",
       "anthropic-routing-health",
+      "oauth-pool-routing-health",
       "xai-refresh-verdicts",
       "responses-continuation",
       "antigravity-replay",