diff --git a/docs-site/src/content/docs/reference/cli/providers-accounts.md b/docs-site/src/content/docs/reference/cli/providers-accounts.md
index 1c9cac81800..754834c4912 100644
--- a/docs-site/src/content/docs/reference/cli/providers-accounts.md
+++ b/docs-site/src/content/docs/reference/cli/providers-accounts.md
@@ -337,6 +337,32 @@ grant counts, nullable dates, cooldown, pending operation and journal availabili
 Empty grants are not the same as unavailable status. It never consumes a grant
 or resumes a pending spend. Consumption remains a human GUI operation.
 
+### Use remaining included quota
+
+To keep using a selected account past a proactive switching threshold or the main-account
+protection threshold, explicitly enable its remaining-quota preference:
+
+```bash
+ocx account use-remaining openai main on
+ocx account use openai main
+ocx account use-remaining openai main status --json
+ocx account use-remaining openai main off
+```
+
+Replace `main` with a unique pool-account ID or alias to target an added account.
+Enabling this disables proactive usage switching for that account. For the main login, it also
+moves both effective hard-lock thresholds to 100%, so a 95% reading can still admit a request.
+The preference persists across restarts until turned off; original threshold settings remain
+stored and resume applying when it is disabled. It does not select an account itself or override
+round-robin scheduling, manual/automatic pause, entitlement checks, reauthentication, or upstream
+cooldowns. Paid-credit permission remains a separate setting; enabling this never opts an account
+into credits or redeems a reset grant. The default-on main hard lock still refuses at 100%.
+
+`GET /api/codex-auth/accounts/use-remaining?id=<account-id>` reads the live policy.
+`PUT /api/codex-auth/accounts/use-remaining` accepts `{ id, useRemainingQuota: boolean }`.
+Both require the existing management authentication. This control is currently exposed through
+the CLI and API.
+
 ### Main-account quota protection
 
 In **Codex settings → Multi-auth → Advanced settings**, **Block main account**
diff --git a/docs-site/src/content/docs/reference/configuration/providers.md b/docs-site/src/content/docs/reference/configuration/providers.md
index d23c45edb22..347bd72f08f 100644
--- a/docs-site/src/content/docs/reference/configuration/providers.md
+++ b/docs-site/src/content/docs/reference/configuration/providers.md
@@ -45,6 +45,7 @@ separate. Full request URLs such as `/api/v1/responses` are not provider base UR
 | `contextCapValue?` | `number` | `350000` | Default used on first enable. A later enable restores the selected provider value. Updating the global value with `setAll: true` changes enabled caps only; `setAll: true` without a value enables all configured providers at the current global value. |
 | `codexAccounts?` | `CodexAccount[]` | `[]` | ChatGPT/Codex pool account metadata managed by Codex Auth. Secrets live separately in `codex-accounts.json`. |
 | `pausedCodexAccountIds?` | `string[]` | `[]` | Accounts excluded from Pool selection until resumed, including the main `__main__` account when paused. |
+| `codexUseRemainingQuotaAccountIds?` | `string[]` | `[]` | Accounts opted into using their remaining included quota. Disables proactive usage switching for listed accounts; for `__main__`, effective short/long hard-lock thresholds become 100%. Original thresholds remain stored and apply again after disabling. Pause, authentication, eligibility, cooldown and paid-credit permission still apply. Managed by `ocx account use-remaining openai <id-or-main> on`; this persistent preference does not select the account. |
 | `creditCodexAccountIds?` | `string[]` | `[]` | Accounts allowed to keep serving from ChatGPT credits after a usage limit, including the main `__main__` account. Upstream does not refuse an account that holds credits at 100%; it serves the request and draws the balance. Spending is opt-in: an account not listed here is skipped by selection while one of its usage windows (weekly or monthly, only monthly on 30-day plans, or the 5-hour window) reads 100% with its reset still ahead, and returns once that reset passes. A weekly or monthly reading without a reset time does not hold the account; a 5-hour reading at 100% without a reset holds it only while that reading is still fresh. When no other account is available, automatic selection finds none rather than spending credits. An unlisted `__main__` is also refused, like a hard-lock refusal, when a request names it or carries its credential. Listing `__main__` does not lift the main-account hard lock (on by default at 98%), which still stops the main login first; turn the lock off to let the main account spend credits (a lock at 100% still stops it at 100%). New accounts start unlisted. Managed by the **Use credits** switch in the Codex Auth header and the **Use credits after limit** switch in each account card's **⋯** menu. |
 | `codexQuotaAutoRefresh?` | `Record<string, object>` | `{}` | Per-Codex-login-account opt-in for automatic `fiveHour` and `weekly` window activation in Pool mode; Direct mode does not run this worker. In Providers/Codex Auth **Advanced settings**, one control enables or disables both supported windows across all current main and added accounts. New accounts are not opted in automatically. Enable skips windows absent from live WHAM data; disable also clears stale enabled windows. The UI reuses granular `/api/settings` writes, reconciles partial failures, and retries the original ON/OFF intent without replacing unrelated settings or completed reset markers. The API still rejects enabling an unavailable window with HTTP 409. At a reported reset time, opencodex sends one minimal non-stored Codex message using that account's quota and persists the activated timestamp. This does not apply to API-key providers. |
 | `codexAccountNamespaces?` | `Record<string, string>` | — | Optional map from an arbitrary public model selector to a stored Codex account target. When account-qualified picker rows are enabled, each selector whose target is present adds separate `<selector>/<native-openai-model>` rows to the Codex picker; each row uses only that account. With any selector active, bare native rows are hidden in the picker, but their ids remain routable and listed by raw `/v1/models` unless explicitly disabled. |
diff --git a/docs-site/src/content/docs/zh-cn/reference/cli/providers-accounts.md b/docs-site/src/content/docs/zh-cn/reference/cli/providers-accounts.md
index 684040f94e8..204e22636e0 100644
--- a/docs-site/src/content/docs/zh-cn/reference/cli/providers-accounts.md
+++ b/docs-site/src/content/docs/zh-cn/reference/cli/providers-accounts.md
@@ -5,6 +5,13 @@ description: 提供方配置、凭据、配额，以及模型目录命令。
 
 这些命令用于配置上游提供方、认证账号、管理凭据池，并控制暴露给 Codex 的模型目录。
 
+使用剩余套餐额度可通过 `ocx account use-remaining openai main on` 开启，再用
+`ocx account use openai main` 选择主账号；`status --json` 查看状态，`off` 关闭。
+将 `main` 替换为唯一的池账号 ID 或别名即可控制该账号。开启后关闭该账号按用量提前切换；
+主账号的短、长窗口硬锁阈值延后到 100%。开关跨重启保留，关闭后恢复原有阈值。
+暂停、重新认证、上游冷却和付费 credits 权限仍然生效；此开关不会开启付费额度。
+详见[英文说明](/reference/cli/providers-accounts/#use-remaining-included-quota)。
+
 ## 提供方
 
 ### `ocx provider <subcommand>`
diff --git a/scripts/test-layout/layout.json b/scripts/test-layout/layout.json
index 1f0d2d4ccaa..d39924059c7 100644
--- a/scripts/test-layout/layout.json
+++ b/scripts/test-layout/layout.json
@@ -2,6 +2,7 @@
   "version": 1,
   "root": "tests",
   "explicit": {
+    "codex-use-remaining-quota.test.ts": "codex-integration",
     "cli-log-view-filter.test.ts": "cli", "cli-usage-model-search.test.ts": "cli", "cli-companion-usage.test.ts": "cli", "cli-account-key-quota.test.ts": "cli",
     "cli-observe-snapshot.test.ts": "cli", "cli-access-data-plane.test.ts": "cli", "cli-access-key-guard.test.ts": "cli", "cli-access-rename.test.ts": "cli",
     "cli-access-audio.test.ts": "cli", "cli-access-audio-live.test.ts": "cli", "cli-log-follow.test.ts": "cli", "cli-injection-follow.test.ts": "cli",
diff --git a/skills/ocx/references/01_management_surface.md b/skills/ocx/references/01_management_surface.md
index 8d9ad48e645..281a6064454 100644
--- a/skills/ocx/references/01_management_surface.md
+++ b/skills/ocx/references/01_management_surface.md
@@ -27,7 +27,7 @@ These answer in the CLI head and never reach the proxy, so they work with nothin
 |---|---|
 | [lifecycle](01_surface_lifecycle.md) | 12 |
 | [providers-models](01_surface_providers-models.md) | 47 |
-| [accounts](01_surface_accounts.md) | 40 |
+| [accounts](01_surface_accounts.md) | 41 |
 | [agents-routing](01_surface_agents-routing.md) | 48 |
 | [integrations](01_surface_integrations.md) | 40 |
 | [observe-system](01_surface_observe-system.md) | 92 |
@@ -599,6 +599,10 @@ Original invocation order. These headings preserve links to the previous single-
 
 [State-changing task](01_surface_accounts.md#ocx-account-pool)
 
+### `ocx account use-remaining`
+
+[State-changing task](01_surface_accounts.md#ocx-account-use-remaining)
+
 ### `ocx account credits`
 
 [State-changing task](01_surface_accounts.md#ocx-account-credits)
@@ -1361,6 +1365,6 @@ Original invocation order. These headings preserve links to the previous single-
 
 ## Counts
 
-- declared capabilities: 328
-- of those, state-changing: 198
+- declared capabilities: 329
+- of those, state-changing: 199
 - head-resolved invocations: 2
diff --git a/skills/ocx/references/01_surface_accounts.md b/skills/ocx/references/01_surface_accounts.md
index 0deea60d2c2..e5ee669cbdc 100644
--- a/skills/ocx/references/01_surface_accounts.md
+++ b/skills/ocx/references/01_surface_accounts.md
@@ -8,7 +8,7 @@
 Use these declarations to choose a task, then check its flags and authority before execution.
 Non-mutating probes may still contact providers, consume quota or refresh caches.
 
-Declared capabilities: 40.
+Declared capabilities: 41.
 
 ### `ocx account login`
 
@@ -868,6 +868,29 @@ JSON mode: `envelope`.
 - Reads the target supported-field list before a narrow PUT. Null/unsupported, stored/effective and generic inert policy stay distinct; disabling does not promise that reactive429 rotation stops.
 - No local classification/defaults are round-tripped into the live target; supported-field reads are not CAS.
 
+### `ocx account use-remaining`
+
+Usage: `ocx account use-remaining openai <id|alias|main> <on|off|status> [--json]`
+
+Choose whether one Codex account keeps using its remaining included quota.
+
+State-changing: yes.
+
+| Method | Route |
+|---|---|
+| GET | `/api/codex-auth/accounts` |
+| GET | `/api/codex-auth/accounts/use-remaining` |
+| PUT | `/api/codex-auth/accounts/use-remaining` |
+
+| Flag | Value | Meaning |
+|---|---|---|
+| `--json` | boolean | Emit the validated account policy. |
+
+JSON mode: `envelope`.
+
+- On disables proactive usage switching for the selected account and raises main-account protection to 100%. Off restores the configured thresholds.
+- This is a persistent preference, not account selection. Pause, reauthentication, cooldown, entitlement and paid-credit policy still apply.
+
 ### `ocx account credits`
 
 Usage: `ocx account credits openai <id|alias|main> <on|off> [--json]; ocx account credits openai --all <on|off> [--json]`
diff --git a/src/cli/account-policy-dto.ts b/src/cli/account-policy-dto.ts
index 6f42734d2e1..c816d64ef9f 100644
--- a/src/cli/account-policy-dto.ts
+++ b/src/cli/account-policy-dto.ts
@@ -8,6 +8,7 @@ export const threshold = z.number().int().min(0).max(100);
 const nullableThreshold = threshold.nullable();
 const row = z.object({
   id: accountId, alias: text.optional(), autoSwitchThresholdOverride: nullableThreshold.optional(),
+  useRemainingQuota: z.boolean().optional(),
   quota: z.object({ shortWindowSeconds: z.number().finite().optional(), shortResetAt: z.number().finite().optional(),
     weeklyResetAt: z.number().finite().optional() }).nullable().optional(),
   quotaAutoRefresh: z.object({ fiveHourAvailable: z.boolean(), weeklyAvailable: z.boolean(),
@@ -39,6 +40,11 @@ export const poolSchema = z.object({
 export const thresholdReceipt = z.object({ ok: z.literal(true), id: accountId,
   autoSwitchThresholdOverride: nullableThreshold, autoSwitchThreshold: threshold });
 export const creditReceipt = z.object({ ok: z.literal(true), id: accountId, creditsAfterLimit: z.boolean() });
+export const remainingQuotaReceipt = z.object({ ok: z.literal(true), id: accountId,
+  useRemainingQuota: z.boolean(), autoSwitchThreshold: threshold,
+  mainAccountHardLock: z.object({ enabled: z.boolean(), state: z.enum(["off", "unknown", "ready", "blocked"]),
+    thresholds: z.object({ short: threshold, long: threshold }) }).optional(),
+});
 export const creditAllReceipt = z.object({ ok: z.literal(true), all: z.boolean(),
   ids: z.array(accountId).refine(ids => new Set(ids).size === ids.length) });
 const window = z.enum(["five_hour", "seven_day", "seven_day_overage_included"]);
diff --git a/src/cli/account-policy.ts b/src/cli/account-policy.ts
index 4ab90f0d3fb..96755cb3e63 100644
--- a/src/cli/account-policy.ts
+++ b/src/cli/account-policy.ts
@@ -4,14 +4,15 @@ import { resolveCodexAccountTargetFromRows } from "./account-target";
 import { runCatalogAction } from "./catalog-command-result";
 import { serializeManagementJson } from "./json-input";
 import { creditAllReceipt, creditReceipt, grantsSchema, parseDto, poolSchema, record,
-  rosterSchema, threshold, thresholdReceipt } from "./account-policy-dto";
+  rosterSchema, threshold, thresholdReceipt, remainingQuotaReceipt } from "./account-policy-dto";
 import { CliUsageError, RuntimeApiError, printData, runtimeBaseUrl, runtimeRequest, summaryLines,
   takeFlag, takeOptionWithSyntax, type RuntimeApiDeps } from "./runtime-api";
 
-type Subcommand = "pool" | "auto-switch" | "credits" | "quota-activation" | "anthropic-reset-grants";
+type Subcommand = "pool" | "auto-switch" | "credits" | "quota-activation" | "anthropic-reset-grants" | "use-remaining";
 const USAGE = "Usage: ocx account pool <provider> [--enabled on|off] [--threshold 0-100] [--strategy NAME] [--sticky 1-100] [--quota-window NAME] [--json]\n"
   + "       ocx account auto-switch openai <status|on|off|inherit|threshold N> --account ID [--json]\n"
   + "       ocx account credits openai <ID on|off|--all on|off> [--json]\n"
+  + "       ocx account use-remaining openai ID <on|off|status> [--json]\n"
   + "       ocx account quota-activation openai ID --window <fiveHour|weekly> <on|off> [--json]\n"
   + "       ocx account anthropic-reset-grants [ID] [--json]";
 const READ_ERRORS = { no_account: "No matching Anthropic OAuth account.", auth_failed: "Sign in to this Anthropic account again.",
@@ -52,6 +53,32 @@ function output(data: Record<string, unknown>, json: boolean, note?: string): nu
 }
 function requireEqual(actual: unknown, expected: unknown): void { if (actual !== expected) throw new Error("Unverified account policy result"); }
 
+async function useRemaining(args: string[], json: boolean, deps: RuntimeApiDeps): Promise<number> {
+  if (args.shift() !== "openai") usage();
+  const requested = selector(args.shift()), action = args.shift();
+  if (!["on", "off", "status"].includes(action ?? "")) usage();
+  done(args);
+  const pinned = { ...deps, baseUrl: await runtimeBaseUrl(deps) };
+  const { id } = await target(pinned, requested);
+  const path = "/api/codex-auth/accounts/use-remaining";
+  const result = parseDto(remainingQuotaReceipt, await request(
+    action === "status" ? path + "?id=" + encodeURIComponent(id) : path,
+    pinned, action === "status" ? undefined : { id, useRemainingQuota: action === "on" },
+  ));
+  requireEqual(result.id, id);
+  if (action !== "status") requireEqual(result.useRemainingQuota, action === "on");
+  if (result.useRemainingQuota) {
+    requireEqual(result.autoSwitchThreshold, 0);
+    if (id === MAIN_CODEX_ACCOUNT_ID) {
+      requireEqual(result.mainAccountHardLock?.thresholds.short, 100);
+      requireEqual(result.mainAccountHardLock?.thresholds.long, 100);
+    }
+  }
+  return output(result, json, result.useRemainingQuota
+    ? "Use remaining included quota: on. Paid-credit permission is unchanged."
+    : "Use remaining included quota: off. Configured usage thresholds apply.");
+}
+
 async function pool(args: string[], json: boolean, deps: RuntimeApiDeps): Promise<number> {
   const provider = selector(args.shift()).toLowerCase();
   if (!isValidProviderName(provider)) usage();
@@ -121,12 +148,12 @@ async function codex(sub: "auto-switch" | "credits" | "quota-activation", args:
       const override = selected?.autoSwitchThresholdOverride;
       if (override === undefined) throw new Error("Missing account threshold evidence");
       const active = record(await request("/api/codex-auth/active", pinned));
-      const effective = override ?? parseDto(threshold, active.autoSwitchThreshold);
+      const effective = selected?.useRemainingQuota ? 0 : override ?? parseDto(threshold, active.autoSwitchThreshold);
       return output({ ok: true, id, autoSwitchThresholdOverride: override, autoSwitchThreshold: effective }, json);
     }
     const result = parseDto(thresholdReceipt, await request("/api/codex-auth/auto-switch", pinned, { id, threshold: value }));
     requireEqual(result.id, id); requireEqual(result.autoSwitchThresholdOverride, value);
-    if (value !== null) requireEqual(result.autoSwitchThreshold, value);
+    if (value !== null && !rows.find(row => row.id === id)?.useRemainingQuota) requireEqual(result.autoSwitchThreshold, value);
     return output(result, json, "Account threshold saved.");
   }
   if (sub === "credits") {
@@ -156,6 +183,7 @@ export async function handleAccountPolicyCommand(sub: Subcommand, args: string[]
     const rest = [...args], json = takeFlag(rest, "--json");
     if (rest.includes("--json")) usage();
     if (sub === "pool") return pool(rest, json, deps);
+    if (sub === "use-remaining") return useRemaining(rest, json, deps);
     if (sub !== "anthropic-reset-grants") return codex(sub, rest, json, deps);
     const id = rest.length ? selector(rest.shift()) : undefined;
     done(rest);
diff --git a/src/cli/account.ts b/src/cli/account.ts
index 98973d029a2..ddf5cc061cd 100644
--- a/src/cli/account.ts
+++ b/src/cli/account.ts
@@ -69,6 +69,7 @@ const ACCOUNT_USAGE = `Usage:
   ocx account login <provider> [--id <account-id>] [--reauth] [--open-browser on|off] [--add-account on|off] [--code -] [--no-wait] [--json]
   ocx account pool <provider> [--enabled on|off] [--threshold N] [--strategy NAME] [--sticky N] [--quota-window W] [--json]
   ocx account credits openai <ID on|off|--all on|off> [--json]
+  ocx account use-remaining openai <ID|main> <on|off|status> [--json]
   ocx account quota-activation openai ID --window fiveHour|weekly <on|off> [--json]
   ocx account anthropic-reset-grants [ID] [--json]
   ocx account code <provider> [--flow <flow-id>] [--json]   (reads the code from stdin)
@@ -423,11 +424,11 @@ async function cmdClear(rest: string[], deps: AccountDeps): Promise<number> {
 export async function cmdAccount(args: string[], deps: AccountDeps = {}): Promise<number> {
   const [sub, ...rest] = args;
   try {
-    if (["pool", "credits", "quota-activation", "anthropic-reset-grants"].includes(sub ?? "")
+    if (["pool", "credits", "quota-activation", "anthropic-reset-grants", "use-remaining"].includes(sub ?? "")
       || (sub === "auto-switch" && rest[0]?.trim().toLowerCase() === "openai"
         && rest.some(arg => arg === "--account" || arg.startsWith("--account=")))) {
       const { handleAccountPolicyCommand } = await import("./account-policy");
-      return handleAccountPolicyCommand(sub as "pool" | "auto-switch" | "credits" | "quota-activation" | "anthropic-reset-grants", rest, deps);
+      return handleAccountPolicyCommand(sub as "pool" | "auto-switch" | "credits" | "quota-activation" | "anthropic-reset-grants" | "use-remaining", rest, deps);
     }
     if (sub === "list") return await cmdList(rest, deps);
     if (sub === "history") {
diff --git a/src/cli/capabilities-accounts.ts b/src/cli/capabilities-accounts.ts
index f405653c54e..c0f90499e38 100644
--- a/src/cli/capabilities-accounts.ts
+++ b/src/cli/capabilities-accounts.ts
@@ -162,6 +162,17 @@ export const ACCOUNT_CAPABILITIES: readonly Capability[] = [
     json: "envelope",
     details: ["Reads the target supported-field list before a narrow PUT. Null/unsupported, stored/effective and generic inert policy stay distinct; disabling does not promise that reactive429 rotation stops.","No local classification/defaults are round-tripped into the live target; supported-field reads are not CAS."],
   },
+  {
+    command: ["account", "use-remaining"],
+    usage: "ocx account use-remaining openai <id|alias|main> <on|off|status> [--json]",
+    summary: "Choose whether one Codex account keeps using its remaining included quota.",
+    routes: [{ method: "GET", path: "/api/codex-auth/accounts" },
+      { method: "GET", path: "/api/codex-auth/accounts/use-remaining" }, { method: "PUT", path: "/api/codex-auth/accounts/use-remaining" }],
+    flags: [{ name: "--json", value: "boolean", summary: "Emit the validated account policy." }],
+    mutates: true, json: "envelope",
+    details: ["On disables proactive usage switching for the selected account and raises main-account protection to 100%. Off restores the configured thresholds.",
+      "This is a persistent preference, not account selection. Pause, reauthentication, cooldown, entitlement and paid-credit policy still apply."],
+  },
   {
     command: ["account","credits"],
     usage: "ocx account credits openai <id|alias|main> <on|off> [--json]; ocx account credits openai --all <on|off> [--json]",
diff --git a/src/cli/registry.ts b/src/cli/registry.ts
index 93d4f244b5b..28d69cd1654 100644
--- a/src/cli/registry.ts
+++ b/src/cli/registry.ts
@@ -329,6 +329,7 @@ export const CLI_COMMANDS: CliCommandEntry[] = [
       "add-key <provider> [--label <label>]  Add a key read only from piped stdin.",
       "pool <provider>          Read/edit runtime-supported pool policy.",
       "credits openai ...       Explicit paid-credit-after-limit policy; separate from displaying balances.",
+      "use-remaining openai <id|main> <on|off|status>  Use included quota up to its limit.",
       "quota-activation openai  Enable/disable one account reset-window refresh policy.",
       "anthropic-reset-grants   Read grant status only; consumption remains in the dashboard.",
       "login supports explicit browser/add-account options only for applicable flows; human verification remains required.",
diff --git a/src/codex/account-auto-switch.ts b/src/codex/account-auto-switch.ts
index b9a4b0d9e88..6d3de62f79a 100644
--- a/src/codex/account-auto-switch.ts
+++ b/src/codex/account-auto-switch.ts
@@ -1,6 +1,7 @@
 import type { OcxConfig } from "../types";
 import { deleteConfigObjectChildKey } from "../config/rebase-provenance";
 import { isValidCodexAccountId, MAIN_CODEX_ACCOUNT_ID } from "./account-id";
+import { codexAccountUsesRemainingQuota } from "./account-use-remaining";
 
 export const DEFAULT_CODEX_AUTO_SWITCH_THRESHOLD = 80;
 export const MIN_CODEX_AUTO_SWITCH_THRESHOLD = 0;
@@ -34,6 +35,7 @@ export function getEffectiveCodexAutoSwitchThreshold(
   config: OcxConfig,
   accountId: string,
 ): number {
+  if (codexAccountUsesRemainingQuota(config, accountId)) return 0;
   const override = getCodexAccountAutoSwitchThresholdOverride(config, accountId);
   if (override !== null) return override;
   return config.autoSwitchThreshold ?? DEFAULT_CODEX_AUTO_SWITCH_THRESHOLD;
diff --git a/src/codex/account-lifecycle.ts b/src/codex/account-lifecycle.ts
index 93771f26d9e..5c5c1be9451 100644
--- a/src/codex/account-lifecycle.ts
+++ b/src/codex/account-lifecycle.ts
@@ -19,6 +19,7 @@ import { clearMainAccountCredentialPresence, clearMainAccountInfoCache, observeM
 import { extractAccountIdClaims } from "../oauth/chatgpt";
 import { forgetCodexAccountPause } from "./account-pause";
 import { forgetCodexAccountCreditUse } from "./account-credit-use";
+import { setCodexAccountUseRemainingQuota } from "./account-use-remaining";
 import { clearCodexAccountPin, forgetCodexAccountPriority } from "./account-priority";
 import { forgetCodexQuotaAutoRefreshAccount } from "./quota-auto-refresh-state";
 import { forgetCodexAccountAutoSwitchThreshold } from "./account-auto-switch";
@@ -183,6 +184,7 @@ export function deleteCodexAccount(runtimeConfig: OcxConfig, accountId: string):
     forgetCodexAccountCreditUse(runtimeConfig, accountId);
     forgetCodexAccountPriority(runtimeConfig, accountId);
     forgetCodexAccountAutoSwitchThreshold(runtimeConfig, accountId);
+    setCodexAccountUseRemainingQuota(runtimeConfig, accountId, false);
     if (runtimeConfig.codexQuotaAutoRefresh?.[accountId]) {
       const retained = { ...runtimeConfig.codexQuotaAutoRefresh };
       delete retained[accountId];
diff --git a/src/codex/account-use-remaining.ts b/src/codex/account-use-remaining.ts
new file mode 100644
index 00000000000..0b94d9a0165
--- /dev/null
+++ b/src/codex/account-use-remaining.ts
@@ -0,0 +1,23 @@
+import type { OcxConfig } from "../types";
+import { deleteConfigTopLevelKey } from "../config/rebase-provenance";
+import { isValidCodexAccountId, MAIN_CODEX_ACCOUNT_ID } from "./account-id";
+
+type Policy = Pick<OcxConfig, "codexUseRemainingQuotaAccountIds">;
+
+/** Included-quota preference only; never grants permission to spend credits. */
+export function codexAccountUsesRemainingQuota(config: Policy | undefined, accountId: string): boolean {
+  return config?.codexUseRemainingQuotaAccountIds?.includes(accountId) ?? false;
+}
+
+export function validRemainingQuotaAccountIds(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every(id => id === MAIN_CODEX_ACCOUNT_ID || isValidCodexAccountId(id));
+}
+
+/** Preserve the underlying thresholds so turning this off restores their current values. */
+export function setCodexAccountUseRemainingQuota(config: OcxConfig, accountId: string, enabled: boolean): void {
+  const ids = new Set(config.codexUseRemainingQuotaAccountIds ?? []);
+  if (enabled) ids.add(accountId);
+  else ids.delete(accountId);
+  if (ids.size) config.codexUseRemainingQuotaAccountIds = [...ids];
+  else deleteConfigTopLevelKey(config, "codexUseRemainingQuotaAccountIds");
+}
diff --git a/src/codex/auth-api/account-list.ts b/src/codex/auth-api/account-list.ts
index 9dfefd9975c..b73f675cf17 100644
--- a/src/codex/auth-api/account-list.ts
+++ b/src/codex/auth-api/account-list.ts
@@ -10,6 +10,7 @@ import { ConfigMutationLockError, mutatePersistedConfig } from "../../config";
 import { reconcileMainCodexAccountRuntimeState } from "../account-lifecycle";
 import { isCodexAccountPaused, setCodexAccountPaused } from "../account-pause";
 import { codexAccountUsesCreditsAfterLimit } from "../account-credit-use";
+import { codexAccountUsesRemainingQuota } from "../account-use-remaining";
 import { getCodexAccountPriority } from "../account-priority";
 import { getCodexAccountAutoSwitchThresholdOverride } from "../account-auto-switch";
 import { clearThreadAccountMapForAccount, isCodexAccountPlanExcluded, reconcileCodexActiveAfterExclusion } from "../routing";
@@ -142,6 +143,7 @@ export function poolAccountDto(
     priority,
     autoSwitchThresholdOverride: getCodexAccountAutoSwitchThresholdOverride(config, account.id),
     creditsAfterLimit: codexAccountUsesCreditsAfterLimit(config, account.id),
+    useRemainingQuota: codexAccountUsesRemainingQuota(config, account.id),
     quota: quota ? { ...quota } : null,
     ...codexCreditsDtoField(config, account.id, poolQuotaHistoryIdentity(account.id) ?? null),
     needsReauth: needsReauth || health.status === "reauth_required",
@@ -170,6 +172,7 @@ export interface CodexAuthAccountDto {
   autoSwitchThresholdOverride: number | null;
   /** False keeps the account out of selection while one of its usage windows is full. */
   creditsAfterLimit?: boolean;
+  useRemainingQuota?: boolean;
   quota: (StoredAccountQuota | (Omit<StoredAccountQuota, "updatedAt"> & { updatedAt: number })) | null;
   credits?: CodexCredits;
   needsReauth?: boolean;
@@ -384,6 +387,7 @@ export async function listCodexAuthAccountsSnapshot(
       priority: getCodexAccountPriority(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
       autoSwitchThresholdOverride: getCodexAccountAutoSwitchThresholdOverride(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
       creditsAfterLimit: codexAccountUsesCreditsAfterLimit(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
+      useRemainingQuota: codexAccountUsesRemainingQuota(runtimeConfig, MAIN_CODEX_ACCOUNT_ID),
       hasCredential: hasMainCredential,
       needsReauth: mainNeedsReauth,
       ...(mainReauthReason !== undefined ? { reauthReason: mainReauthReason } : {}),
diff --git a/src/codex/auth-api/routes.ts b/src/codex/auth-api/routes.ts
index f52b289c7f8..bdd0f6f9a73 100644
--- a/src/codex/auth-api/routes.ts
+++ b/src/codex/auth-api/routes.ts
@@ -1,4 +1,5 @@
 import { CODEX_ACCOUNT_LOG_LABEL_RE, codexAccountLogLabel } from "../account-label";
+import { handleUseRemainingQuotaRoute } from "./use-remaining-route";
 import { poolQuotaHistoryIdentity, readCodexAccountRecord } from "../account-store";
 import { estimateCodexQuotaCapacity, insufficientCodexCapacity } from "../quota-capacity";
 import type { CodexCapacityResult } from "../quota-capacity";
@@ -32,6 +33,9 @@ export async function handleCodexAuthAPI(
   convergeCodexCatalog?: CodexAuthCatalogConvergence,
   principal?: import("../../server/management-auth").ManagementPrincipal,
 ): Promise<Response | null> {
+  if (url.pathname === "/api/codex-auth/accounts/use-remaining" && (req.method === "GET" || req.method === "PUT")) {
+    return handleUseRemainingQuotaRoute(req, url, config);
+  }
   if (url.pathname === "/api/codex-auth/accounts" && req.method === "GET") {
     const forceRefresh = url.searchParams.get("refresh") === "1" || url.searchParams.get("refresh") === "true";
     return jsonResponse({ accounts: await listCodexAuthAccounts(config, forceRefresh) });
diff --git a/src/codex/auth-api/use-remaining-route.ts b/src/codex/auth-api/use-remaining-route.ts
new file mode 100644
index 00000000000..0dfff82bbf8
--- /dev/null
+++ b/src/codex/auth-api/use-remaining-route.ts
@@ -0,0 +1,36 @@
+import type { OcxConfig } from "../../types";
+import { captureConfigTopLevelRollback } from "../../config/rebase-provenance";
+import { MAIN_CODEX_ACCOUNT_ID, isValidCodexAccountId } from "../account-id";
+import { getEffectiveCodexAutoSwitchThreshold } from "../account-auto-switch";
+import { codexAccountUsesRemainingQuota, setCodexAccountUseRemainingQuota } from "../account-use-remaining";
+import { getMainAccountHardLockStatus } from "../main-account-hard-lock";
+import { configuredPoolAccount, getRuntimeConfig, saveRuntimeConfig } from "./runtime-config";
+import { jsonResponse } from "./http";
+
+/** Called only behind the existing Codex management authentication boundary. */
+export async function handleUseRemainingQuotaRoute(req: Request, url: URL, config: OcxConfig): Promise<Response> {
+  const parsed: unknown = req.method === "PUT" ? await req.json().catch(() => null) : { id: url.searchParams.get("id") };
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return jsonResponse({ error: "body must be an object" }, 400);
+  const body = parsed as { id?: unknown; useRemainingQuota?: unknown };
+  if (typeof body.id !== "string" || (body.id !== MAIN_CODEX_ACCOUNT_ID && !isValidCodexAccountId(body.id))) {
+    return jsonResponse({ error: "Invalid account id format" }, 400);
+  }
+  const runtime = getRuntimeConfig(config);
+  if (body.id !== MAIN_CODEX_ACCOUNT_ID && !configuredPoolAccount(runtime, body.id)) return jsonResponse({ error: "Account not found" }, 404);
+  if (req.method === "PUT") {
+    if (typeof body.useRemainingQuota !== "boolean") return jsonResponse({ error: "useRemainingQuota must be a boolean" }, 400);
+    const rollback = captureConfigTopLevelRollback(runtime, ["codexUseRemainingQuotaAccountIds"]);
+    try {
+      setCodexAccountUseRemainingQuota(runtime, body.id, body.useRemainingQuota);
+      saveRuntimeConfig(config, runtime);
+    } catch (error) {
+      rollback();
+      throw error;
+    }
+  }
+  return jsonResponse({ ok: true, id: body.id,
+    useRemainingQuota: codexAccountUsesRemainingQuota(runtime, body.id),
+    autoSwitchThreshold: getEffectiveCodexAutoSwitchThreshold(runtime, body.id),
+    ...(body.id === MAIN_CODEX_ACCOUNT_ID ? { mainAccountHardLock: getMainAccountHardLockStatus(runtime) } : {}),
+  });
+}
diff --git a/src/codex/auth-context.ts b/src/codex/auth-context.ts
index 13ef41a0adb..8b2103e91d1 100644
--- a/src/codex/auth-context.ts
+++ b/src/codex/auth-context.ts
@@ -597,7 +597,7 @@ export class CodexRecoveryWithheldError extends CodexAccountCooldownError {
 
 export type CodexAuthPolicyConfig = Readonly<Pick<OcxConfig,
   "codexMainAccountHardLock" | "codexMainAccountHardLockThresholds" | "codexDesktopAuthless" | "runtimeRole" | "pausedCodexAccountIds"
-  | "creditCodexAccountIds"
+  | "creditCodexAccountIds" | "codexUseRemainingQuotaAccountIds"
 >>;
 
 interface CodexAuthMaterializationOptions {
@@ -732,7 +732,7 @@ function mainCreditsHoldResetAt(config: Pick<OcxConfig, "creditCodexAccountIds">
 }
 
 function assertMainAccountPolicy(
-  config: Pick<OcxConfig, "codexMainAccountHardLock" | "codexMainAccountHardLockThresholds" | "creditCodexAccountIds"> | undefined,
+  config: Pick<OcxConfig, "codexMainAccountHardLock" | "codexMainAccountHardLockThresholds" | "creditCodexAccountIds" | "codexUseRemainingQuotaAccountIds"> | undefined,
 ): void {
   if (config) {
     const status = getMainAccountHardLockStatus(config);
diff --git a/src/codex/main-account-hard-lock.ts b/src/codex/main-account-hard-lock.ts
index fda12552410..66399819199 100644
--- a/src/codex/main-account-hard-lock.ts
+++ b/src/codex/main-account-hard-lock.ts
@@ -1,4 +1,6 @@
 import type { OcxConfig } from "../types";
+import { MAIN_CODEX_ACCOUNT_ID } from "./account-id";
+import { codexAccountUsesRemainingQuota } from "./account-use-remaining";
 import { getMainPolicyQuota } from "./quota";
 import { MAIN_ACCOUNT_HARD_LOCK_PERCENT, MAIN_ACCOUNT_HARD_LOCK_SHORT_PERCENT, MAIN_ACCOUNT_HARD_LOCK_MIN_PERCENT } from "./quota-types";
 
@@ -13,9 +15,10 @@ export interface MainAccountHardLockStatus {
   window?: "short" | "long";
 }
 
-type PolicyConfig = Pick<OcxConfig, "codexMainAccountHardLock" | "codexMainAccountHardLockThresholds">;
+type PolicyConfig = Pick<OcxConfig, "codexMainAccountHardLock" | "codexMainAccountHardLockThresholds" | "codexUseRemainingQuotaAccountIds">;
 
 export function resolveMainAccountHardLockThresholds(config: PolicyConfig | undefined): { short: number; long: number } {
+  if (codexAccountUsesRemainingQuota(config, MAIN_CODEX_ACCOUNT_ID)) return { short: 100, long: 100 };
   const valid = (value: unknown, fallback: number): number => typeof value === "number"
     && Number.isInteger(value) && value >= MAIN_ACCOUNT_HARD_LOCK_MIN_PERCENT && value <= 100 ? value : fallback;
   const long = valid(config?.codexMainAccountHardLockThresholds?.long, MAIN_ACCOUNT_HARD_LOCK_PERCENT);
diff --git a/src/config/diagnostics.ts b/src/config/diagnostics.ts
index e086acce8ae..c8cb0c9b91a 100644
--- a/src/config/diagnostics.ts
+++ b/src/config/diagnostics.ts
@@ -1,4 +1,5 @@
 import { isSubagentModelEntry, rawSubagentModelForce } from "./subagent-models";
+import { validRemainingQuotaAccountIds } from "../codex/account-use-remaining";
 import { protocolConfigSchema } from "./schema/config-schema";
 import { createHash } from "node:crypto";
 import { lstatSync, readFileSync } from "node:fs";
@@ -483,6 +484,12 @@ function creditCodexAccountIdsError(value: unknown): string | null {
   return "schema_invalid: creditCodexAccountIds: must be an array of account ids or omitted";
 }
 
+function remainingQuotaAccountIdsError(value: unknown): string | null {
+  const ids = rawConfigRecord(value)?.codexUseRemainingQuotaAccountIds;
+  return ids === undefined || validRemainingQuotaAccountIds(ids) ? null
+    : "schema_invalid: codexUseRemainingQuotaAccountIds: must be an array of Codex account ids or omitted";
+}
+
 function oauthOpenBrowserError(value: unknown): string | null {
   const raw = rawConfigRecord(value);
   if (!raw || !Object.hasOwn(raw, "oauthOpenBrowser")) return null;
@@ -692,6 +699,7 @@ export function validateConfigCandidate(value: unknown): { ok: true; config: Ocx
     ?? oauthOpenBrowserError(value)
     ?? showCodexCreditsError(value)
     ?? creditCodexAccountIdsError(value)
+    ?? remainingQuotaAccountIdsError(value)
     ?? runtimeRoleError(value)
     ?? remoteGuiConfigError(value)
     ?? clientConnectionConfigError(value)
diff --git a/src/config/schema/config-schema.ts b/src/config/schema/config-schema.ts
index 89cfff25aca..fd4bcf71b33 100644
--- a/src/config/schema/config-schema.ts
+++ b/src/config/schema/config-schema.ts
@@ -1,4 +1,5 @@
 import { MAIN_ACCOUNT_HARD_LOCK_MIN_PERCENT } from "../../codex/quota-types";
+import { validRemainingQuotaAccountIds } from "../../codex/account-use-remaining";
 import * as z from "zod/v4";
 import { compactionRecoverySchema } from "./compaction-recovery";
 import { blockedModelRedirectsSchema } from "./blocked-model-redirects";
@@ -283,6 +284,7 @@ export const configSchema = z.object({
   // so a hand-edited typo cannot trip the backup-and-defaults repair path; the write path rejects
   // it (creditCodexAccountIdsError in diagnostics).
   creditCodexAccountIds: z.array(z.string().regex(/^[a-zA-Z0-9._-]{1,64}$/)).optional().catch(undefined),
+  codexUseRemainingQuotaAccountIds: z.custom<string[]>(validRemainingQuotaAccountIds).optional().catch(undefined),
   // A malformed policy degrades to "no policy" rather than failing the parse, so a hand-edited
   // typo cannot trip the backup-and-defaults repair path and wipe providers or pool accounts.
   // Silently ignoring it would be its own trap, so the write path rejects it and loadConfig warns.
diff --git a/src/server/management/route-registry.ts b/src/server/management/route-registry.ts
index b40055e8d88..2e84d8007eb 100644
--- a/src/server/management/route-registry.ts
+++ b/src/server/management/route-registry.ts
@@ -99,6 +99,8 @@ export const MANAGEMENT_ROUTES: readonly ManagementRoute[] = [
   // codex/auth-api
   { method: "DELETE", path: "/api/codex-auth/accounts", module: "codex/auth-api/routes", mutates: true },
   { method: "GET", path: "/api/codex-auth/accounts", module: "codex/auth-api/routes", mutates: false },
+  { method: "GET", path: "/api/codex-auth/accounts/use-remaining", module: "codex/auth-api/routes", mutates: false },
+  { method: "PUT", path: "/api/codex-auth/accounts/use-remaining", module: "codex/auth-api/routes", mutates: true },
   { method: "GET", path: "/api/codex-auth/active", module: "codex/auth-api/routes", mutates: false },
   { method: "GET", path: "/api/codex-auth/login-status", module: "codex/auth-api/routes", mutates: false },
   { method: "GET", path: "/api/codex-auth/quota", module: "codex/auth-api/routes", mutates: false },
diff --git a/src/types/config.ts b/src/types/config.ts
index ce3a31353ac..ccf55f375b5 100644
--- a/src/types/config.ts
+++ b/src/types/config.ts
@@ -589,6 +589,8 @@ export interface OcxConfig {
   codexMainAccountHardLock?: boolean;
   /** Per-window percentages: short defaults to 90, long to 98; integers 80..100, short <= long. */
   codexMainAccountHardLockThresholds?: { short?: number; long?: number };
+  /** Use included quota to 100% for these accounts; preserves thresholds and credit-spending policy. */
+  codexUseRemainingQuotaAccountIds?: string[];
   /** Explicit top-level deletion intent used by stale whole-config rebases. */
   configRebaseProvenance?: OcxConfigRebaseProvenance | Record<string, unknown>;
   /** OpenAI provider-contract migration marker (v2 = single `openai` provider with account mode). */
diff --git a/structure/cli-management.md b/structure/cli-management.md
index e8357ebbc2d..d37027e69b5 100644
--- a/structure/cli-management.md
+++ b/structure/cli-management.md
@@ -1,5 +1,10 @@
 # CLI management and discovery
 
+`ocx account use-remaining openai <id-or-main> on|off|status` in `src/cli/account-policy.ts`
+resolves the selected runtime's roster and validates the authenticated API receipt. It controls
+the [remaining included-quota preference](providers/openai-accounts.md#main-account-policy-observations);
+status is read-only, and account selection is a separate command.
+
 `src/cli/` contains the terminal management interface. Process ownership, startup, stop and service contracts remain in [Runtime](runtime.md); this document owns command discovery, help, management-client presentation and the generated operating reference.
 
 ## CLI readiness diagnostics
diff --git a/structure/config.md b/structure/config.md
index 211f6708d9f..7df63f64624 100644
--- a/structure/config.md
+++ b/structure/config.md
@@ -91,7 +91,7 @@ object so the freshness the data write moved does not read as a replacement. A d
 A schema-invalid top-level JSON value is repairable only when it is a non-array object.
 `loadConfig` backs up arrays, primitives, and null before using defaults, so the repair merge cannot turn them into a valid config while discarding the original bytes.
 
-`src/config/schema/config-schema.ts` accepts the opt-in `codexAccountPriorityFailback` preference and degrades a malformed value in a loaded file to false without discarding providers, while a write candidate carrying a non-boolean value is rejected. A malformed entry in `codexAccountAutoSwitchThresholds` is dropped on load with a warning and the valid entries are kept, so an unrelated save cannot erase them. Its [routing contract](providers/openai-accounts.md#ongoing-priority-failback) requires quota strategy and a positive threshold.
+`src/config/schema/config-schema.ts` accepts the opt-in `codexAccountPriorityFailback` preference and degrades a malformed value in a loaded file to false without discarding providers, while a write candidate carrying a non-boolean value is rejected. A malformed entry in `codexAccountAutoSwitchThresholds` is dropped on load with a warning and the valid entries are kept, so an unrelated save cannot erase them. Its [routing contract](providers/openai-accounts.md#ongoing-priority-failback) requires quota strategy and a positive threshold. The default-off `codexUseRemainingQuotaAccountIds` list degrades to absent when malformed; write candidates reject invalid account ids. Its [included-quota policy](providers/openai-accounts.md#main-account-policy-observations) preserves thresholds and credit-spending permission.
 
 | Group | Keys | Resolution rule |
 | --- | --- | --- |
diff --git a/structure/gui-and-management-api.md b/structure/gui-and-management-api.md
index 333ab103d98..ec6c76f5aae 100644
--- a/structure/gui-and-management-api.md
+++ b/structure/gui-and-management-api.md
@@ -239,6 +239,8 @@ that disable back to disk.
 
 `src/server/index.ts` authenticates and routes `/api/*`, then delegates to
 `src/server/management-api.ts`, which composes the route modules under `src/server/management/`.
+Codex account routes include authenticated GET/PUT `/api/codex-auth/accounts/use-remaining`;
+the [main-account policy contract](providers/openai-accounts.md#main-account-policy-observations) owns its semantics.
 Codex account routes live in `src/codex/auth-api/routes.ts` because they own the credential store, not
 because they are a different plane. Upstream account response reads and OrcaRouter key exchange follow the [bounded ingestion contract](transports/inventory.md#bounded-response-ingestion-and-orcarouter-login).
 
diff --git a/structure/providers/openai-accounts.md b/structure/providers/openai-accounts.md
index 4ed82b37bca..10cec7b1882 100644
--- a/structure/providers/openai-accounts.md
+++ b/structure/providers/openai-accounts.md
@@ -455,6 +455,16 @@ false. Exact-account and Direct routes are unchanged.
 
 ## Main-account policy observations
 
+`src/codex/account-use-remaining.ts` owns the persistent, default-off
+`codexUseRemainingQuotaAccountIds` opt-in. Effective auto-switch thresholds resolve to zero
+for listed accounts; main protection resolves to 100% in both governing windows.
+Underlying thresholds remain stored, and disabling restores their current values.
+Account deletion removes its opt-in. No cooldown, pause, eligibility or credit-spending
+permission is removed. Selected-main and caller-owned Direct materialization use the same policy.
+`src/codex/auth-api/use-remaining-route.ts` exposes authenticated GET/PUT and rolls back
+the live preference when persistence fails; GET never saves. Coverage is in
+`tests/codex-integration/codex-use-remaining-quota.test.ts` and the existing main-auth suite.
+
 The main-account admission policy defaults to 90% for short windows and 98% for long windows;
 `codexMainAccountHardLockThresholds` permits ordered integer thresholds from 80 through 100.
 Policy evidence retention uses the minimum configurable 80%, so a partial update or elapsed reset
diff --git a/tests/cli/cli-account-policy.test.ts b/tests/cli/cli-account-policy.test.ts
index 9096c6a27c9..0e0a2caabe9 100644
--- a/tests/cli/cli-account-policy.test.ts
+++ b/tests/cli/cli-account-policy.test.ts
@@ -55,6 +55,45 @@ function fixture(handler?: (call: Call, index: number) => unknown | Promise<unkn
 function result() { expect(stdout.mock.calls).toHaveLength(1); return JSON.parse(stdout.mock.calls[0]![0]); }
 function privateOutput() { expect(JSON.stringify([...stdout.mock.calls, ...stderr.mock.calls])).not.toContain(PRIVATE); }
 
+test.each(["on", "off", "status"])("use-remaining %s resolves one account and verifies the receipt", async action => {
+  const f = fixture(call => {
+    if (call.path.startsWith("/api/codex-auth/accounts/use-remaining")) return {
+      ok: true, id: "__main__", useRemainingQuota: action !== "off", autoSwitchThreshold: action === "off" ? 65 : 0,
+      mainAccountHardLock: { enabled: true, state: "ready", thresholds: { short: action === "off" ? 90 : 100, long: action === "off" ? 98 : 100 } },
+      token: PRIVATE,
+    };
+  });
+  expect(await policy("use-remaining", ["openai", "main", action, "--json"], f.deps)).toBe(0);
+  expect(f.calls[1]!.method).toBe(action === "status" ? "GET" : "PUT");
+  expect(f.calls[1]!.body).toEqual(action === "status" ? undefined : { id: "__main__", useRemainingQuota: action === "on" });
+  expect(result().useRemainingQuota).toBe(action !== "off"); privateOutput();
+});
+
+test("use-remaining refuses a misleading receipt before claiming success", async () => {
+  const f = fixture(call => call.path.includes("use-remaining") ? {
+    ok: true, id: "a", useRemainingQuota: true, autoSwitchThreshold: 95,
+  } : undefined);
+  expect(await policy("use-remaining", ["openai", "Alpha", "on", "--json"], f.deps)).toBe(1);
+  expect(stdout.mock.calls).toHaveLength(0);
+});
+
+test.each(["status", "threshold"])("auto-switch %s reports the remaining-quota override without losing the saved threshold", async action => {
+  const f = fixture(call => {
+    if (call.path === "/api/codex-auth/accounts") return { accounts: rows.map(row => ({ ...row, useRemainingQuota: row.id === "a" })) };
+    if (call.path === "/api/codex-auth/auto-switch") return { ok: true, id: "a", autoSwitchThresholdOverride: 42, autoSwitchThreshold: 0 };
+  });
+  expect(await policy("auto-switch", ["openai", action, ...(action === "threshold" ? ["42"] : []), "--account", "a", "--json"], f.deps)).toBe(0);
+  expect(result()).toMatchObject({ id: "a", autoSwitchThreshold: 0, autoSwitchThresholdOverride: action === "status" ? null : 42 });
+});
+
+test.each([["openai", "a"], ["openai", "a", "yes"], ["anthropic", "a", "on"], ["openai", "a", "on", "--all"]])(
+  "invalid use-remaining arguments are rejected before runtime access: %j", async args => {
+    const f = fixture();
+    expect(await policy("use-remaining", args, f.deps)).toBe(2);
+    expect(f.calls).toHaveLength(0);
+  },
+);
+
 describe("account policy argument and identity boundaries", () => {
   const invalid: [Parameters<typeof policy>[0], string[]][] = [
     ["credits", ["openai", "a"]], ["credits", ["openai", "a", "on", "--all"]],
diff --git a/tests/codex-integration/codex-use-remaining-quota.test.ts b/tests/codex-integration/codex-use-remaining-quota.test.ts
new file mode 100644
index 00000000000..1709cced440
--- /dev/null
+++ b/tests/codex-integration/codex-use-remaining-quota.test.ts
@@ -0,0 +1,172 @@
+import { afterEach, beforeEach, expect, spyOn, test } from "bun:test";
+import { createTempHome, type TempHome } from "../helpers/temp-home";
+import { getEffectiveCodexAutoSwitchThreshold } from "../../src/codex/account-auto-switch";
+import { setCodexAccountUseRemainingQuota } from "../../src/codex/account-use-remaining";
+import { getMainAccountHardLockStatus } from "../../src/codex/main-account-hard-lock";
+import { captureMainQuotaWriter, clearMainAccountInfoCache, observeMainQuotaIdentity } from "../../src/codex/main-account-cache";
+import { clearAccountQuota, setAccountQuotaFromParsed, updateAccountQuota } from "../../src/codex/quota";
+import { clearCodexUpstreamHealth, clearThreadAccountMap, recordCodexUpstreamOutcome, resolveCodexAccountForThread } from "../../src/codex/routing";
+import { saveCodexAccountCredential } from "../../src/codex/account-store";
+import { deleteCodexAccount } from "../../src/codex/account-lifecycle";
+import { handleCodexAuthAPI } from "../../src/codex/auth-api";
+import { configSchema } from "../../src/config/schema/config-schema";
+import { validateConfigCandidate } from "../../src/config/diagnostics";
+import { requireManagementAuth, type ManagementAuthState } from "../../src/server/management-auth";
+import * as configModule from "../../src/config";
+import { setIcaclsRunnerForTests, setAsyncIcaclsRunnerForTests } from "../../src/lib/windows-secret-acl";
+import { flushConfigDirHardeningForTests } from "../../src/config/paths";
+import type { OcxConfig } from "../../src/types";
+
+let home: TempHome;
+const acl = { success: true, exitCode: 0, timedOut: false, stdout: "" };
+beforeEach(() => {
+  home = createTempHome("ocx-use-remaining-");
+  setIcaclsRunnerForTests(() => acl); setAsyncIcaclsRunnerForTests(async () => acl);
+  clearAccountQuota(); clearMainAccountInfoCache(); clearCodexUpstreamHealth(); clearThreadAccountMap();
+});
+afterEach(async () => {
+  clearAccountQuota(); clearMainAccountInfoCache(); clearCodexUpstreamHealth(); clearThreadAccountMap();
+  await flushConfigDirHardeningForTests();
+  setIcaclsRunnerForTests(null); setAsyncIcaclsRunnerForTests(null); home.remove();
+});
+function config(): OcxConfig {
+  return { port: 10100, defaultProvider: "openai", providers: { openai: {
+    adapter: "openai-responses", baseUrl: "https://chatgpt.com/backend-api/codex",
+    authMode: "forward", codexAccountMode: "pool",
+  } }, autoSwitchThreshold: 95,
+    codexAccounts: ["a", "b"].map(id => ({ id, email: id + "@example.test", isMain: false })),
+    activeCodexAccountId: "a", codexAccountAutoSwitchThresholds: { a: 90 },
+    codexMainAccountHardLockThresholds: { short: 90, long: 95 } };
+}
+async function request(cfg: OcxConfig, body: unknown, method = "PUT") {
+  const url = new URL("http://localhost/api/codex-auth/accounts/use-remaining" + (method === "GET" ? "?id=a" : ""));
+  return (await handleCodexAuthAPI(new Request(url, { method, ...(method === "GET" ? {} : {
+    headers: { "Content-Type": "application/json" }, body: JSON.stringify(body),
+  }) }), url, cfg))!;
+}
+function credentials() {
+  for (const id of ["a", "b"]) saveCodexAccountCredential(id, {
+    accessToken: "fixture-access-" + id, refreshToken: "fixture-refresh-" + id,
+    expiresAt: Date.now() + 3600_000, chatgptAccountId: "fixture-account-" + id,
+  });
+}
+function observeMain(percent: number, short = false) {
+  observeMainQuotaIdentity("remaining-main");
+  setAccountQuotaFromParsed("__main__", short ? { shortPercent: percent } : { weeklyPercent: percent },
+    undefined, captureMainQuotaWriter("remaining-main"));
+}
+
+test("main admits 95 and 99.9 percent only after explicit opt-in, then blocks at 100", () => {
+  const cfg = config();
+  observeMain(95);
+  expect(getMainAccountHardLockStatus(cfg).state).toBe("blocked");
+  setCodexAccountUseRemainingQuota(cfg, "__main__", true);
+  expect(getMainAccountHardLockStatus(cfg)).toMatchObject({ enabled: true, state: "ready", thresholds: { short: 100, long: 100 } });
+  observeMain(99.9);
+  expect(getMainAccountHardLockStatus(cfg).state).toBe("ready");
+  observeMain(100);
+  expect(getMainAccountHardLockStatus(cfg).state).toBe("blocked");
+  expect(cfg.codexMainAccountHardLock).toBeUndefined();
+  expect(cfg.creditCodexAccountIds).toBeUndefined();
+});
+
+test("short-window protection also moves to 100 and disabling restores configured values", () => {
+  const cfg = config();
+  observeMain(95, true);
+  setCodexAccountUseRemainingQuota(cfg, "__main__", true);
+  expect(getMainAccountHardLockStatus(cfg).state).toBe("ready");
+  setCodexAccountUseRemainingQuota(cfg, "__main__", false);
+  expect(getMainAccountHardLockStatus(cfg)).toMatchObject({ state: "blocked", thresholds: { short: 90, long: 95 } });
+  expect(cfg.codexUseRemainingQuotaAccountIds).toBeUndefined();
+});
+
+test("manual account continues at 95 with a cooler alternative, but not while paused or cooled", () => {
+  const cfg = config(); credentials();
+  updateAccountQuota("a", 95); updateAccountQuota("b", 5);
+  expect(resolveCodexAccountForThread("before", cfg)).toBe("b");
+  cfg.activeCodexAccountId = "a";
+  setCodexAccountUseRemainingQuota(cfg, "a", true);
+  expect(resolveCodexAccountForThread("after", cfg)).toBe("a");
+  cfg.pausedCodexAccountIds = ["a"];
+  expect(resolveCodexAccountForThread("paused", cfg)).toBe("b");
+  cfg.pausedCodexAccountIds = []; cfg.activeCodexAccountId = "a";
+  recordCodexUpstreamOutcome(cfg, "a", 429, { retryAfterMs: 60_000 });
+  expect(resolveCodexAccountForThread("cooled", cfg)).toBe("b");
+});
+
+test("included quota at 100 is still held without paid-credit permission", () => {
+  const cfg = config(); credentials();
+  setCodexAccountUseRemainingQuota(cfg, "a", true);
+  setAccountQuotaFromParsed("a", { weeklyPercent: 100, weeklyResetAt: Math.floor(Date.now() / 1000) + 3600 });
+  updateAccountQuota("b", 5);
+  expect(resolveCodexAccountForThread("no-paid", cfg)).toBe("b");
+  expect(cfg.creditCodexAccountIds).toBeUndefined();
+});
+
+test("API persists only selected preference, preserves thresholds, and read status never saves", async () => {
+  const cfg = config();
+  const result = await request(cfg, { id: "a", useRemainingQuota: true });
+  expect(result.status).toBe(200);
+  expect(await result.json()).toMatchObject({ id: "a", useRemainingQuota: true, autoSwitchThreshold: 0 });
+  expect(configModule.loadConfig().codexUseRemainingQuotaAccountIds).toEqual(["a"]);
+  expect(getEffectiveCodexAutoSwitchThreshold(cfg, "b")).toBe(95);
+  const saver = spyOn(configModule, "saveConfigPreservingClaudeCode").mockImplementation(() => { throw new Error("must not save"); });
+  try { expect((await request(cfg, null, "GET")).status).toBe(200); } finally { saver.mockRestore(); }
+  cfg.autoSwitchThreshold = 85;
+  await request(cfg, { id: "a", useRemainingQuota: false });
+  expect(getEffectiveCodexAutoSwitchThreshold(cfg, "a")).toBe(90);
+  expect(cfg.codexAccountAutoSwitchThresholds).toEqual({ a: 90 });
+});
+
+test("main API opt-in returns the effective 100-percent protection and preserves paid-credit settings", async () => {
+  const cfg = config(); observeMain(95);
+  const response = await request(cfg, { id: "__main__", useRemainingQuota: true });
+  expect(response.status).toBe(200);
+  expect(await response.json()).toMatchObject({ id: "__main__", useRemainingQuota: true, autoSwitchThreshold: 0,
+    mainAccountHardLock: { enabled: true, state: "ready", thresholds: { short: 100, long: 100 } } });
+  expect(configModule.loadConfig().codexUseRemainingQuotaAccountIds).toEqual(["__main__"]);
+  expect(cfg.creditCodexAccountIds).toBeUndefined();
+});
+
+test.each(["GET", "PUT"])("remaining-quota %s requires management credentials", method => {
+  const cfg = config();
+  const state: ManagementAuthState = { available: true, token: "fixture-admin-secret", source: "environment",
+    sessions: new Map(), pairingGrants: new Map() };
+  const url = "http://127.0.0.1/api/codex-auth/accounts/use-remaining?id=a";
+  for (const token of [undefined, "fixture-provider-secret"]) {
+    const headers = new Headers({ Host: "127.0.0.1" });
+    if (token) headers.set("x-opencodex-api-key", token);
+    expect(requireManagementAuth(new Request(url, { method, headers }), state, cfg)?.status).toBe(401);
+  }
+  expect(requireManagementAuth(new Request(url, { method, headers: {
+    Host: "127.0.0.1", "x-opencodex-api-key": state.token,
+  } }), state, cfg)).toBeNull();
+});
+
+test.each([null, [], { id: "a", useRemainingQuota: "true" }, { id: "__proto__", useRemainingQuota: true }])(
+  "malformed use-remaining request is refused without mutation: %j", async body => {
+    const cfg = config(); expect((await request(cfg, body)).status).toBe(400);
+    expect(cfg.codexUseRemainingQuotaAccountIds).toBeUndefined();
+  },
+);
+test("unknown account returns 404 and failed save rolls back live permission", async () => {
+  const cfg = config();
+  expect((await request(cfg, { id: "unknown", useRemainingQuota: true })).status).toBe(404);
+  const saver = spyOn(configModule, "saveConfigPreservingClaudeCode").mockImplementation(() => { throw new Error("fixture-save-refused"); });
+  try {
+    await expect(request(cfg, { id: "a", useRemainingQuota: true })).rejects.toThrow("fixture-save-refused");
+    expect(cfg.codexUseRemainingQuotaAccountIds).toBeUndefined();
+    expect(getEffectiveCodexAutoSwitchThreshold(cfg, "a")).toBe(90);
+  } finally { saver.mockRestore(); }
+});
+test("malformed persisted preference fails closed and account deletion removes its opt-in", () => {
+  const cfg = config();
+  expect(configSchema.parse({ ...cfg, codexUseRemainingQuotaAccountIds: ["__proto__"] }).codexUseRemainingQuotaAccountIds).toBeUndefined();
+  expect(validateConfigCandidate({ ...cfg, codexUseRemainingQuotaAccountIds: ["__proto__"] })).toMatchObject({ ok: false });
+  expect(validateConfigCandidate({ ...cfg, codexUseRemainingQuotaAccountIds: ["a", "__main__"] })).toMatchObject({ ok: true });
+  setCodexAccountUseRemainingQuota(cfg, "a", true);
+  setCodexAccountUseRemainingQuota(cfg, "b", true);
+  credentials();
+  deleteCodexAccount(cfg, "a");
+  expect(cfg.codexUseRemainingQuotaAccountIds).toEqual(["b"]);
+});
diff --git a/tests/codex-integration/main-account-hard-lock-auth.test.ts b/tests/codex-integration/main-account-hard-lock-auth.test.ts
index a7fcfabe763..21ee54b71d7 100644
--- a/tests/codex-integration/main-account-hard-lock-auth.test.ts
+++ b/tests/codex-integration/main-account-hard-lock-auth.test.ts
@@ -412,6 +412,28 @@ describe("main quota policy at native admission", () => {
     expect(headersForCodexAuthContext(new Headers(), context, cfg).get("authorization")).toBe(`Bearer ${bearer()}`);
   });
 
+  test("use-remaining admits selected main at 95 and still blocks materialization at 100", async () => {
+    const cfg = accountZeroConfig();
+    cfg.codexUseRemainingQuotaAccountIds = [MAIN];
+    quota(95);
+    const context = await resolveCodexAuthContext(new Headers(), cfg, "pool", { accountId: MAIN });
+    expect(context.kind).toBe("main-pool");
+    expect(headersForCodexAuthContext(new Headers(), context, cfg).get("authorization")).toBe(`Bearer ${bearer()}`);
+    quota(100);
+    expect(() => headersForCodexAuthContext(new Headers(), context, cfg)).toThrow(CodexMainAccountHardLockError);
+    expect(cfg.creditCodexAccountIds).toBeUndefined();
+  });
+
+  test("use-remaining admits caller-owned Direct main until preference is revoked", async () => {
+    const cfg = accountZeroConfig();
+    cfg.codexUseRemainingQuotaAccountIds = [MAIN];
+    observeMainQuotaCredential(bearer(), accountId); quota(95);
+    forbidPhysicalReads();
+    await expect(resolveCodexAuthContext(caller(), cfg, "direct")).resolves.toMatchObject({ kind: "main" });
+    cfg.codexUseRemainingQuotaAccountIds = [];
+    await expect(resolveCodexAuthContext(caller(), cfg, "direct")).rejects.toBeInstanceOf(CodexMainAccountHardLockError);
+  });
+
   test("short-only 99 blocks exact main and main-only Pool without probe or reauth", async () => {
     quota(99);
     const cfg = config();
diff --git a/tests/fixtures/test-layout-expected.json b/tests/fixtures/test-layout-expected.json
index 5e648d1b623..f43cf52ae22 100644
--- a/tests/fixtures/test-layout-expected.json
+++ b/tests/fixtures/test-layout-expected.json
@@ -1,4 +1,5 @@
 {
+  "codex-use-remaining-quota.test.ts": "codex-integration",
   "cli-log-view-filter.test.ts": "cli",
   "cli-usage-model-search.test.ts": "cli",
   "cli-companion-usage.test.ts": "cli",