diff --git a/docs-site/src/content/docs/ja/reference/cli.md b/docs-site/src/content/docs/ja/reference/cli.md
index 8476d4cd1..022e3e337 100644
--- a/docs-site/src/content/docs/ja/reference/cli.md
+++ b/docs-site/src/content/docs/ja/reference/cli.md
@@ -223,7 +223,7 @@ refresh <provider>  Force-refresh Codex or provider quota reports.
 auto-switch <provider> <on|off|status|threshold N>  Control the Codex pool threshold.
 remove <provider> <id> --yes  Remove a stored account or key after an existence check.
 add-key <provider> [--label <label>]  Add a key read only from piped stdin.
-Codex pool switches apply to new sessions; running threads keep their account.
+Codex pool selection applies to the next request after clearing existing affinity; in-flight requests keep their captured account.
 ```
 
 すべてのサブコマンドはプロキシが実行中である必要があり、CLI が記録されたランタイムポートを自動的に探します。成功は
@@ -268,9 +268,12 @@ API エラーは終了コード 1 です。認証情報フィールドは manage
 #### `ocx account use <provider> <account-or-key-id|main> [--json]`
 
 既存の Codex アカウント、OAuth アカウント、または API key を選びます。`openai` で `main` は Codex App ログインを
-選択します。Codex の選択は **新しいセッション** から適用され、既存の thread は現在のアカウントを維持します。auto-switch
-threshold がオンなら後で手動 pin を上書きできます。不明なプロバイダーや id は終了
-コード 1 です。`--json` は次を返します。
+選択します。Codex Pool の選択は process-local affinity を消去し、既存の表示タスクを含む次のリクエストから適用されます。プロキシ再起動や affinity eviction 後もタスクは未紐付けになり得ますが、処理中のリクエストは取得済みアカウントを維持します。この選択は Pool routing のみを制御し、Direct mode は caller-owned/native main credential を使い続けます。使用量ベースのプロアクティブ切り替え、401/403 再認証、429/retry-after cooldown、除外、出力前 429/402 の障害回復により、後で別の適格 Pool アカウントが選ばれる場合があります。これらの回復経路は使用量ベース切り替えが off でも有効です。アカウント変更後も OpenCodex は会話コンテキストを再生しますが、provider prompt cache は再ウォームアップが必要な場合があります。
+不明なプロバイダーや id は終了コード 1 です。`--json` は次を返します。
+**401/403** では、そのアカウントへのプロセスローカルな affinity を解除し、再認証を要求します。
+**429** では `Retry-After` を尊重してアカウントの cooldown を開始し、affinity を解除したうえで、
+別の適格な Pool アカウントへリクエストを切り替えることがあります。これらの障害回復は
+`autoSwitchThreshold: 0` でも有効であり、`0` が無効にするのは使用量に基づく予防的な切り替えだけです。
 
 ```text
 { ok: true, provider, type, activeId }
diff --git a/docs-site/src/content/docs/ja/reference/configuration.md b/docs-site/src/content/docs/ja/reference/configuration.md
index ed1c42511..aa3b10d88 100644
--- a/docs-site/src/content/docs/ja/reference/configuration.md
+++ b/docs-site/src/content/docs/ja/reference/configuration.md
@@ -54,9 +54,9 @@ namespaced selected id を bare id に変えます。
 | `pausedCodexAccountIds?` | `string[]` | `[]` | Codex Auth で再開するまで、今後のすべての Pool 選択から除外するアカウント ID。メインを一時停止した場合は `__main__` も含みます。 |
 | `codexAccountNamespaces?` | `Record<string,string>` | — | 公開 model selector namespace から保存済み Codex アカウント target への任意 map。この foundation layer は map を検証・保存しますが、picker row の追加や routing の変更は行いません。 |
 | `activeCodexAccountId?` | `string` | — | 手動選択した pool アカウント。既存 thread affinity を消去して次のリクエストから適用し、処理中のリクエストは現在のアカウントを維持します。 |
-| `autoSwitchThreshold?` | `number` | `80` | 新しいセッション自動切替用の使用量百分率 threshold。既知の 5 時間、週次、30 日 quota window のうち最も高いスコアを使います。`0` なら quota 自動切替をオフにします。`quota` 戦略と `fill-first` の drain threshold にも使います。 |
-| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | Codex pool の新しいセッション rotation 戦略。**新しいセッションのみ**に適用され、既存 thread id は affinity を維持します。`quota`（既定）— アクティブアカウントが `autoSwitchThreshold` を超えたら既知 usage 最小を選択。`round-robin` — 適格アカウント間を smooth weighted で均等分散。`fill-first` — cooldown、使用不可、または（設定時）`autoSwitchThreshold` までアクティブアカウントを使い切り（未知 usage は強制切替しない）、安定ソート順で次へ。 |
-| `accountPoolStickyLimit?` | `number` | `1` | 1 回の round-robin 選択で次へ進む前に保持する成功的新セッション bind 数。範囲 1–100。`accountPoolStrategy` が `round-robin` のときのみ。 |
+| `autoSwitchThreshold?` | `number` | `80` | 使用量ベースのプロアクティブ切り替えしきい値。`quota` は紐付け済み/未紐付けタスクの次のリクエストを再評価でき、`fill-first` は未紐付け割り当ての使い切り基準としてのみ使用し、通常の `round-robin` 選択は使用しません。既知の 5 時間、週次、30 日 quota window の最大スコアを使います。`0` は使用量ベースの切り替えだけを無効にし、未紐付け割り当てや障害回復は無効にしません。 |
+| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | 新規/未紐付け Codex リクエストの割り当て戦略。live な `(parent thread id, quota scope)` affinity がなければ未紐付けで、プロキシ再起動や affinity リセット後は既存の表示タスクも未紐付けになり得ます。`quota` はアクティブアカウントがなければ既知 usage 最小の適格アカウントを選び、適格なアクティブアカウントが `autoSwitchThreshold` 未満なら維持します。しきい値到達後は、未紐付けリクエストまたは紐付け済みタスクの次のリクエストを usage の低い適格アカウントへ移せます。`round-robin` は未紐付けリクエストを均等分散し、`fill-first` は cooldown、使用不可、または drain threshold までアクティブアカウントへ割り当てます。 |
+| `accountPoolStickyLimit?` | `number` | `1` | 1 回の round-robin 選択で次へ進む前に保持する新規/未紐付けタスク割り当て数。カウンターは上流の成功後ではなくタスクの紐付け時に増えます。範囲 1–100。`accountPoolStrategy` が `round-robin` のときのみ。 |
 | `upstreamFailoverThreshold?` | `number` | `3` | 一時的な上流失敗が連続して起きたのち、以降の新しいセッションを別の適合 pool アカウントに failover する回数。`0` なら失敗ベースの failover をオフにします。 |
 | `modelCacheTtlMs?` | `number` | `300000` | プロバイダー別 `/models` キャッシュの有効期間（5 分）。 |
 | `appOwnedMemoryBudgetMb?` | `number` | `256` | 退避可能なアプリ所有の保持状態（ログ、キャッシュ、Blob、継続応答ペイロード）に対するプロセス全体の上限（MiB）です。有効範囲は 64〜4096 で、RSS やネイティブランタイムメモリの上限ではありません。 |
@@ -85,14 +85,26 @@ model picker entry の作成、session の固定、Pool / Direct routing の変
 :::note[Codex アカウントプール]
 pool アカウントの追加と quota 更新はダッシュボードの **Codex Auth** ページで処理してください。設定には secret で
 ないアカウント metadata だけを保存し、access/refresh token は強化された Codex アカウント credential store に別途
-保管します。既存 thread id はアカウント affinity を維持し、新しいセッションは `accountPoolStrategy`、quota、cooldown、health に
-応じて自動ルーティングされます。
+保管します。Pool routing は新規/未紐付け割り当て、使用量ベースのプロアクティブ切り替え、障害回復に分かれます。
+紐付け済みタスクは通常 affinity を維持しますが、`quota` はしきい値超過後の次のリクエストで再紐付けでき、
+pause、cooldown、再認証、障害処理も独立して routing を消去または変更できます。未紐付けリクエストには
+プロキシ再起動や affinity リセット後の既存タスクも含まれます。出力前の **429/402** は使用量ベースの
+切り替えがオフでも同じリクエストで適格な代替アカウントへ 1 回再試行できます。アカウント変更後も会話
+コンテキストは保持・再生されますが、アカウント間の provider prompt cache 再利用は保証されません。
 一時停止したアカウントと quota metadata は表示されたままですが、自動切り替え、再試行/failover 選択、cooldown 復旧プローブ、手動有効化の対象外です。
 一時停止するとそのアカウントの thread affinity map も消去されます。処理中のリクエストは取得済み credential を維持しますが、以降のターンは再ルーティングされ、一時停止中のアカウントは再利用できません。
 状態は再起動後も保持され、すべてのアカウントが一時停止中なら Pool ルーティングは別のアカウントを暗黙に選ばず失敗します。
 **上限到達を一括停止** は credential がある適格アカウントだけを先に更新し、関連する quota window が今回 100% と確認できたアカウントだけを停止します。credential がないアカウントや、quota が不明、または更新に失敗したアカウントは変更しません。
-
-**rotation 戦略**（新しいセッションのみ；bound thread は不変）：`quota`（既定）— `autoSwitchThreshold` 超過時に最小 usage を選択；`round-robin` — 均等分散、`accountPoolStickyLimit`（既定 `1`、1–100）で 1 選択あたりの成功 bind 数；`fill-first` — アクティブアカウントを cooldown、再認証、または threshold まで使い切り（未知 usage は強制切替しない）後、安定ソート順で次へ。rotation は provider enforcement を回避しません — 複数アカウント利用は ToS 違反の可能性があります。
+**401/403** では、そのアカウントへのプロセスローカルな affinity を解除し、再認証を要求します。
+**429** では `Retry-After` を尊重してアカウントの cooldown を開始し、affinity を解除したうえで、
+別の適格な Pool アカウントへリクエストを切り替えることがあります。これらの障害回復は
+`autoSwitchThreshold: 0` でも有効であり、`0` が無効にするのは使用量に基づく予防的な切り替えだけです。
+
+**割り当てとプロアクティブ切り替え戦略：** `quota`（既定）はアクティブアカウントがない場合に最小 usage の適格アカウントを選び、適格なアクティブアカウントが `autoSwitchThreshold` 未満なら維持します。`autoSwitchThreshold` 超過後は紐付け済みタスクの次のリクエストも再紐付けできます。`round-robin` は
+未紐付けリクエストを均等分散し、しきい値は通常の rotation を変えません。`accountPoolStickyLimit`
+（既定 `1`、1–100）は成功応答ではなく割り当て/紐付け数を数えます。`fill-first` は未紐付けリクエストを
+cooldown、再認証、または drain threshold までアクティブアカウントへ割り当て、正常な紐付け済みタスクは
+affinity を維持します。これらの戦略は provider enforcement を回避しません。
 :::
 
 ### 管理型レコード形式
diff --git a/docs-site/src/content/docs/ko/reference/cli.md b/docs-site/src/content/docs/ko/reference/cli.md
index 2acd60981..6c05c96d6 100644
--- a/docs-site/src/content/docs/ko/reference/cli.md
+++ b/docs-site/src/content/docs/ko/reference/cli.md
@@ -256,7 +256,7 @@ refresh <provider>  Force-refresh Codex or provider quota reports.
 auto-switch <provider> <on|off|status|threshold N>  Control the Codex pool threshold.
 remove <provider> <id> --yes  Remove a stored account or key after an existence check.
 add-key <provider> [--label <label>]  Add a key read only from piped stdin.
-Codex pool switches apply to new sessions; running threads keep their account.
+Codex pool selection applies to the next request after clearing existing affinity; in-flight requests keep their captured account.
 ```
 
 모든 하위 명령은 프록시가 실행 중이어야 하며 CLI가 기록된 런타임 포트를 자동으로 찾습니다. 성공은
@@ -309,9 +309,12 @@ API 오류는 종료 코드 1입니다. 자격 증명 필드는 management API
 #### `ocx account use <provider> <account-or-key-id|main> [--json]`
 
 기존 Codex 계정, OAuth 계정 또는 API key를 선택합니다. `openai`에서 `main`은 Codex App 로그인을
-선택합니다. Codex 선택은 **새 세션**부터 적용되며 기존 thread는 현재 계정을 유지합니다. auto-switch
-threshold가 켜져 있으면 나중에 수동 pin을 덮어쓸 수 있습니다. 알 수 없는 프로바이더나 id는 종료
-코드 1입니다. `--json`은 다음을 반환합니다.
+선택합니다. Codex Pool 선택은 프로세스 로컬 affinity를 지우고 기존에 보이던 작업을 포함한 다음 요청부터 적용됩니다. 프록시 재시작이나 affinity eviction 뒤에도 작업이 바인딩 없는 상태가 될 수 있지만, 진행 중인 요청은 이미 확보한 계정을 유지합니다. 이 선택은 Pool 라우팅만 제어하며 Direct mode는 호출자 소유/native main credential을 계속 사용합니다. 사용량 기반 선제 전환, 401/403 재인증, 429/retry-after cooldown, 제외, 출력 전 429/402 실패 복구는 나중에 다른 적격 Pool 계정을 선택할 수 있습니다. 이러한 복구 경로는 사용량 기반 전환이 꺼져 있어도 동작합니다. 계정이 바뀌어도 OpenCodex는 대화 문맥을 재생하지만 프로바이더 측 prompt cache는 다시 예열해야 할 수 있습니다.
+알 수 없는 프로바이더나 id는 종료 코드 1입니다. `--json`은 다음을 반환합니다.
+**401/403**이 발생하면 해당 계정의 프로세스 로컬 affinity를 해제하고 재인증을 요구합니다.
+**429**에서는 `Retry-After`를 준수해 계정 cooldown을 시작하고 affinity를 해제한 뒤,
+다른 적격 Pool 계정으로 요청을 전환할 수 있습니다. 이러한 실패 복구는
+`autoSwitchThreshold: 0`에서도 계속 작동하며, `0`은 사용량 기반 선제 전환만 비활성화합니다.
 
 ```text
 { ok: true, provider, type, activeId }
diff --git a/docs-site/src/content/docs/ko/reference/configuration.md b/docs-site/src/content/docs/ko/reference/configuration.md
index cb947d866..baea84752 100644
--- a/docs-site/src/content/docs/ko/reference/configuration.md
+++ b/docs-site/src/content/docs/ko/reference/configuration.md
@@ -55,9 +55,9 @@ namespaced selected id를 bare id로 바꿉니다.
 | `pausedCodexAccountIds?` | `string[]` | `[]` | Codex Auth에서 재개할 때까지 이후의 모든 Pool 선택에서 제외할 계정 ID. 메인 계정을 일시 중지하면 `__main__`도 포함됩니다. |
 | `codexAccountNamespaces?` | `Record<string,string>` | — | 공개 model selector namespace에서 저장된 Codex 계정 target으로 연결하는 선택적 map입니다. 이 foundation layer는 map을 검증하고 저장하지만 picker row를 추가하거나 routing을 변경하지 않습니다. |
 | `activeCodexAccountId?` | `string` | — | 수동으로 선택한 pool 계정. 선택 시 기존 thread affinity를 지우고 다음 요청부터 적용하며, 진행 중인 요청은 기존 계정을 유지합니다. |
-| `autoSwitchThreshold?` | `number` | `80` | 새 세션 자동 전환용 사용량 백분율 threshold. 알려진 5시간, 주간, 30일 quota window 중 가장 높은 점수를 씁니다. `0`이면 quota 자동 전환을 끕니다. `quota` 전략과 `fill-first` drain threshold에도 사용됩니다. |
-| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | Codex pool의 새 세션 rotation 전략. **새 세션에만** 적용되며 기존 thread id는 affinity를 유지합니다. `quota`(기본) — 활성 계정이 `autoSwitchThreshold`를 넘으면 알려진 usage가 가장 낮은 계정 선택. `round-robin` — 적격 계정 간 smooth weighted 균등 분배. `fill-first` — cooldown, 사용 불가 또는(설정 시) `autoSwitchThreshold`까지 활성 계정을 소진(알 수 없는 usage는 강제 전환하지 않음)한 뒤 안정 정렬 순으로 다음 계정. |
-| `accountPoolStickyLimit?` | `number` | `1` | 한 round-robin 선택이 다음으로 넘어가기 전에 유지하는 성공적 새 세션 bind 수. 범위 1–100. `accountPoolStrategy`가 `round-robin`일 때만 적용. |
+| `autoSwitchThreshold?` | `number` | `80` | 사용량 기반 선제 전환 임계값입니다. `quota`는 바인딩된 작업과 바인딩 없는 작업의 다음 요청을 모두 재평가할 수 있고, `fill-first`는 바인딩 없는 작업 배정의 소진 기준으로만 사용하며, 기본 `round-robin` 선택은 이 값을 사용하지 않습니다. 알려진 5시간, 주간, 30일 quota window 중 가장 높은 점수를 씁니다. `0`은 사용량 기반 전환만 끄며 바인딩 없는 작업 배정이나 실패 복구는 끄지 않습니다. |
+| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | 새 작업/바인딩 없는 Codex 요청의 계정 배정 전략입니다. `(parent thread id, quota scope)`의 live affinity가 없으면 바인딩 없는 요청이며, 프록시 재시작이나 affinity 초기화 뒤에는 기존에 보이던 작업도 바인딩이 없어질 수 있습니다. `quota`는 활성 계정이 없을 때 알려진 usage가 가장 낮은 적격 계정을 선택하고, 적격 활성 계정이 `autoSwitchThreshold` 미만이면 유지합니다. 임계값 도달 뒤에는 바인딩 없는 요청이나 바인딩된 작업의 다음 요청을 usage가 더 낮은 적격 계정으로 옮길 수 있습니다. `round-robin`은 바인딩 없는 요청을 균등 분배하고, `fill-first`는 cooldown, 사용 불가 또는 drain threshold까지 활성 계정에 배정합니다. |
+| `accountPoolStickyLimit?` | `number` | `1` | 한 round-robin 선택이 다음으로 넘어가기 전에 유지하는 새 작업/바인딩 없는 작업 배정 수입니다. 카운터는 업스트림 성공 뒤가 아니라 작업을 바인딩할 때 증가합니다. 범위 1–100이며 `accountPoolStrategy`가 `round-robin`일 때만 적용됩니다. |
 | `upstreamFailoverThreshold?` | `number` | `3` | 일시적인 업스트림 실패가 연속으로 발생한 뒤, 이후 새 세션을 다른 적합한 pool 계정으로 failover할 횟수. `0`이면 실패 기반 failover를 끕니다. |
 | `modelCacheTtlMs?` | `number` | `300000` | 프로바이더별 `/models` 캐시의 유효 기간(5분). |
 | `appOwnedMemoryBudgetMb?` | `number` | `256` | 제거 가능한 앱 소유 유지 상태(로그, 캐시, Blob, 연속 응답 페이로드)의 프로세스 전체 상한(MiB)입니다. 유효 범위는 64~4096이며 RSS나 네이티브 런타임 메모리 상한이 아닙니다. |
@@ -87,18 +87,30 @@ entry 생성, session 고정, Pool / Direct routing 변경을 수행하지 않
 :::note[Codex 계정 풀]
 pool 계정 추가와 quota 갱신은 대시보드의 **Codex Auth** 페이지에서 처리하세요. 설정에는 secret이
 아닌 계정 metadata만 저장하고, access/refresh token은 강화된 Codex 계정 credential store에 따로
-보관합니다. 기존 thread id는 계정 affinity를 유지하며, 새 세션은 `accountPoolStrategy`, quota,
-cooldown, health에 따라 자동 라우팅됩니다.
+보관합니다. Pool 라우팅은 새 작업/바인딩 없는 작업 배정, 사용량 기반 선제 전환, 실패 복구로
+구분됩니다. 바인딩된 작업은 보통 affinity를 유지하지만 `quota`는 사용량 임계값을 넘은 뒤 다음
+요청에서 재바인딩할 수 있고, 일시 중지, cooldown, 재인증, 실패 처리도 독립적으로 라우팅을
+지우거나 바꿀 수 있습니다. 바인딩 없는 요청은 live 계정 바인딩이 없는 요청이며, 프록시 재시작이나
+affinity 초기화 뒤의 기존 작업도 포함될 수 있습니다. 출력 전 **429/402**는 사용량 기반 선제
+전환이 꺼져 있어도 같은 요청에서 적격 대체 계정으로 한 번 재시도할 수 있습니다. 계정이 바뀌어도
+대화 문맥은 보존·재생되지만 계정 간 프로바이더 측 prompt cache 재사용은 보장되지 않아 다시
+예열해야 할 수 있습니다.
 일시 중지된 계정과 quota metadata는 계속 표시되지만 자동 전환, 재시도/failover 선택, cooldown 복구 probe, 수동 활성화에서는 제외됩니다.
 일시 중지는 해당 계정의 thread affinity map도 지웁니다. 진행 중인 요청은 이미 확보한 credential을 유지하지만, 이후 턴은 다시 라우팅되며 일시 중지된 계정은 재사용할 수 없습니다.
 상태는 재시작 후에도 유지되며, 모든 계정이 일시 중지되면 Pool 라우팅은 계정을 몰래 선택하지 않고 실패합니다.
 **한도 도달 계정 일시 중지**는 credential이 있는 적격 계정만 먼저 새로고친 뒤 관련 quota window가 이번 응답에서 100%로 확인된 계정만 일시 중지합니다. credential이 없는 계정과 quota가 없거나 새로고침에 실패한 계정은 변경하지 않습니다.
-
-**rotation 전략**(새 세션만; bound thread는 변경 없음): `quota`(기본) — `autoSwitchThreshold` 초과 시
-최저 usage 선택; `round-robin` — 균등 분배, `accountPoolStickyLimit`(기본 `1`, 1–100)로 한 선택당
-성공 bind 수; `fill-first` — 활성 계정을 cooldown, 재인증 또는 threshold까지 소진(알 수 없는 usage는
-강제 전환하지 않음)한 뒤 안정 정렬 순으로 다음 계정. rotation은 provider enforcement를 우회하지
-않습니다 — 다계정 사용은 ToS 위반일 수 있습니다.
+**401/403**이 발생하면 해당 계정의 프로세스 로컬 affinity를 해제하고 재인증을 요구합니다.
+**429**에서는 `Retry-After`를 준수해 계정 cooldown을 시작하고 affinity를 해제한 뒤,
+다른 적격 Pool 계정으로 요청을 전환할 수 있습니다. 이러한 실패 복구는
+`autoSwitchThreshold: 0`에서도 계속 작동하며, `0`은 사용량 기반 선제 전환만 비활성화합니다.
+
+**배정 및 선제 전환 전략:** `quota`(기본)는 활성 계정이 없을 때 최저 usage의 적격 계정을 선택하고,
+적격 활성 계정이 `autoSwitchThreshold` 미만이면 유지합니다. 임계값 도달 뒤에는 바인딩 없는 요청이나 바인딩된 작업의 다음 요청을 usage가 더 낮은 적격 계정으로 옮길 수 있습니다.
+`round-robin`은 바인딩 없는 요청을 균등 분배하며 임계값은 기본 순환에 영향을 주지 않습니다.
+`accountPoolStickyLimit`(기본 `1`, 1–100)은 성공 응답이 아니라 배정/바인딩 횟수를 셉니다.
+`fill-first`는 바인딩 없는 요청을 cooldown, 재인증 또는 drain threshold까지 활성 계정에 배정하고,
+정상적인 바인딩 작업은 affinity를 유지합니다. 이 전략들은 provider enforcement를 우회하지 않으며
+다계정 사용은 ToS 위반일 수 있습니다.
 :::
 
 ### 관리형 레코드 형태
diff --git a/docs-site/src/content/docs/reference/cli.md b/docs-site/src/content/docs/reference/cli.md
index 4e90900fc..23a276d2c 100644
--- a/docs-site/src/content/docs/reference/cli.md
+++ b/docs-site/src/content/docs/reference/cli.md
@@ -314,7 +314,7 @@ refresh <provider>  Force-refresh Codex or provider quota reports.
 auto-switch <provider> <on|off|status|threshold N>  Control the Codex pool threshold.
 remove <provider> <id> --yes  Remove a stored account or key after an existence check.
 add-key <provider> [--label <label>]  Add a key read only from piped stdin.
-Codex pool switches apply to new sessions; running threads keep their account.
+Codex pool selection applies to the next request after clearing existing affinity; in-flight requests keep their captured account.
 ```
 
 All subcommands require the proxy to be running; the CLI auto-resolves its recorded runtime port.
@@ -367,9 +367,19 @@ returns:
 #### `ocx account use <provider> <account-or-key-id|main> [--json]`
 
 Selects an existing Codex account, OAuth account, or API key. For `openai`, `main` selects the Codex
-App login. Codex selections apply only to **new sessions**; existing threads keep their account, and
-an enabled auto-switch threshold may later override the manual pin. Unknown providers or ids exit 1.
+App login. A Codex Pool selection clears process-local affinity and applies to the next request,
+including one from an existing visible task; proxy restart or affinity eviction can also leave a task
+unbound, while in-flight requests keep their captured account. This controls Pool routing only;
+Direct mode keeps using the caller-owned/native main credential. Usage-based proactive switching,
+401/403 reauthentication, 429/retry-after cooldowns, exclusion, and pre-output 429/402 failure
+recovery may later select another eligible Pool account. Those recovery paths remain active when
+usage-based switching is off. OpenCodex replays the conversation after an account change, but the
+provider-side prompt cache may be cold. Unknown providers or ids exit 1.
 `--json` returns:
+On a **401/403**, App login clears that account's process-local affinity and requires reauthentication.
+On a **429**, it honors `Retry-After`, starts the account cooldown, clears affinity, and may rotate
+the request to another eligible Pool account. These failure transitions remain active with
+`autoSwitchThreshold: 0`; that setting disables only usage-based proactive switching.
 
 ```text
 { ok: true, provider, type, activeId }
diff --git a/docs-site/src/content/docs/reference/configuration.md b/docs-site/src/content/docs/reference/configuration.md
index 0050fa718..a4ecabd68 100644
--- a/docs-site/src/content/docs/reference/configuration.md
+++ b/docs-site/src/content/docs/reference/configuration.md
@@ -60,9 +60,9 @@ differing backup and rewrites known legacy namespaced selected ids to bare ids.
 | `pausedCodexAccountIds?` | `string[]` | `[]` | Accounts excluded from every future Pool selection until resumed in Codex Auth. Includes the main `__main__` account when paused. |
 | `codexAccountNamespaces?` | `Record<string,string>` | — | Optional public model-selector namespace → stored Codex account target map. This foundation layer validates and persists the map but does not add picker rows or change routing. |
 | `activeCodexAccountId?` | `string` | — | Manually selected Pool account. Selection clears existing thread affinity and applies to the next request; in-flight requests keep their captured account. |
-| `autoSwitchThreshold?` | `number` | `80` | Usage percent threshold for new-session auto-switching. The score uses the hottest known 5h, weekly, or 30d quota window. Set `0` to disable quota auto-switching. Used by the `quota` strategy and as the drain threshold for `fill-first`. |
-| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | New-session rotation strategy for the Codex pool. Applies to **new sessions only**; existing thread ids keep affinity. `quota` — today's default: pick the lowest known usage when the active account crosses `autoSwitchThreshold`. `round-robin` — even spread across eligible accounts via smooth weighted selection. `fill-first` — keep the active account until it cools down, becomes unusable, or crosses `autoSwitchThreshold` when set (unknown usage does not force a switch), then advance to the next eligible account in stable sorted order. |
-| `accountPoolStickyLimit?` | `number` | `1` | Successful new-session binds retained on one round-robin selection before advancing. Range 1–100; only applies when `accountPoolStrategy` is `round-robin`. |
+| `autoSwitchThreshold?` | `number` | `80` | Usage threshold for proactive switching. `quota` can re-evaluate both bound and unbound tasks on their next request; `fill-first` uses it only as the drain point for unbound assignment; normal `round-robin` selection does not use it. The score uses the hottest known 5h, weekly, or 30d quota window. `0` disables usage-based proactive switching only, not unbound assignment or failure recovery. |
+| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | Assignment strategy for new/unbound Codex requests. A request is unbound when it has no live `(parent thread id, quota scope)` affinity; a visible existing task can become unbound after proxy restart or affinity reset. `quota` picks the lowest-usage eligible account when no active account exists, keeps an eligible active account below `autoSwitchThreshold`, and after the threshold may move an unbound request or proactively rebind a bound task to a lower-usage eligible account. `round-robin` distributes unbound requests evenly; `fill-first` keeps assigning unbound requests to the active account until cooldown, unavailability, or the configured drain threshold. |
+| `accountPoolStickyLimit?` | `number` | `1` | Number of new/unbound task assignments retained on one round-robin selection before advancing. The counter advances when a task is bound, not after an upstream success. Range 1–100; only applies when `accountPoolStrategy` is `round-robin`. |
 | `upstreamFailoverThreshold?` | `number` | `3` | Consecutive transient upstream failures before future new sessions fail over to another eligible pool account. Set `0` to disable failure failover. |
 | `modelCacheTtlMs?` | `number` | `300000` | Freshness window for the per-provider `/models` cache (5 min). |
 | `appOwnedMemoryBudgetMb?` | `number` | `256` | Process-wide cap in MiB for evictable app-owned retained state (logs, caches, blobs, and continuation payloads), valid from 64 to 4096. This does not cap RSS or native runtime memory. |
@@ -140,10 +140,15 @@ also force the same native-provider recovery with `ocx recover-history --legacy-
 :::note[Codex account pool]
 Use the dashboard's **Codex Auth** page to add pool accounts and refresh quotas. The config stores
 non-secret account metadata only; access and refresh tokens are kept in the hardened Codex account
-credential store. Existing thread ids keep account affinity, while new sessions auto-route based on
-`accountPoolStrategy`, quota, cooldown, and health. A pre-stream upstream **429**/**402** on one pool
-account is retried once on an eligible alternate account in the same request (so Codex CLI does not
-stall on a depleted primary while another account still has quota).
+credential store. Pool routing separates new/unbound assignment, usage-based proactive switching,
+and failure recovery. A bound task normally keeps affinity, but `quota` may rebind it on its next
+request after the usage threshold is crossed, while pause, cooldown, reauthentication, and failure
+handling can clear or move routing independently. An unbound request has no live account binding;
+this can include an existing visible task after proxy restart or affinity reset. A pre-stream
+upstream **429/402** on one pool account is retried once on an eligible alternate account in the
+same request, even when usage-based proactive switching is off.
+Account changes preserve and replay the conversation context, but provider-side prompt-cache reuse
+across accounts is not guaranteed and the cache may need to warm again.
 Pause keeps an account and its quota metadata visible, but excludes it from automatic switching,
 retry/failover selection, cooldown recovery probes, and manual activation. Pausing also clears that
 account's thread-affinity map: in-flight requests keep their captured credentials, but subsequent
@@ -153,14 +158,18 @@ restarts; if every account is paused, Pool routing fails instead of silently sel
 only those whose relevant quota window is freshly confirmed at 100%; accounts without credentials
 and unknown or failed quota refreshes are left unchanged.
 :::
+On a **401/403**, App login clears that account's process-local affinity and requires reauthentication.
+On a **429**, it honors `Retry-After`, starts the account cooldown, clears affinity, and may rotate
+the request to another eligible Pool account. These failure transitions remain active with
+`autoSwitchThreshold: 0`; that setting disables only usage-based proactive switching.
 
-**Rotation strategies** (new sessions only; bound threads are unchanged):
+**Assignment and proactive-switching strategies:**
 
 | Strategy | Behaviour |
 | --- | --- |
-| `quota` (default) | When the active account's known usage crosses `autoSwitchThreshold`, pick the lowest-usage eligible account across 5h, weekly, and 30d windows. `autoSwitchThreshold: 0` disables quota-based picking. |
-| `round-robin` | Even spread across eligible accounts. `accountPoolStickyLimit` (default `1`, range 1–100) keeps that many successful new-session binds on one pick before advancing. |
-| `fill-first` | Drain the active account until cooldown, reauthentication, or (when set) `autoSwitchThreshold`; unknown usage does not force a switch. Then advance to the next eligible account in stable sorted order. |
+| `quota` (default) | If no active account exists, pick the lowest-usage eligible account across 5h, weekly, and 30d windows. Otherwise retain an eligible active account below `autoSwitchThreshold`; after it crosses the threshold, an unbound request or a bound task's next request can move to a lower-usage eligible account. `autoSwitchThreshold: 0` disables this usage-driven re-evaluation, not failure recovery. |
+| `round-robin` | Evenly assign unbound requests across eligible accounts. `autoSwitchThreshold` does not change normal round-robin selection. `accountPoolStickyLimit` (default `1`, range 1–100) counts assignments/bindings on one pick, not successful upstream responses. |
+| `fill-first` | Assign unbound requests to the active account until cooldown, reauthentication, or (when set) the `autoSwitchThreshold` drain point; unknown usage does not force a switch. Healthy bound tasks keep affinity. |
 
 Rotation strategies do not protect against provider enforcement — multi-account use may violate
 provider terms of service.
diff --git a/docs-site/src/content/docs/ru/reference/cli.md b/docs-site/src/content/docs/ru/reference/cli.md
index 80493b7d5..d9bd98e86 100644
--- a/docs-site/src/content/docs/ru/reference/cli.md
+++ b/docs-site/src/content/docs/ru/reference/cli.md
@@ -240,7 +240,7 @@ refresh <provider>  Force-refresh Codex or provider quota reports.
 auto-switch <provider> <on|off|status|threshold N>  Control the Codex pool threshold.
 remove <provider> <id> --yes  Remove a stored account or key after an existence check.
 add-key <provider> [--label <label>]  Add a key read only from piped stdin.
-Codex pool switches apply to new sessions; running threads keep their account.
+Codex pool selection applies to the next request after clearing existing affinity; in-flight requests keep their captured account.
 ```
 
 Все подкоманды требуют работающего прокси; CLI автоматически определяет записанный runtime-порт.
@@ -298,9 +298,12 @@ plan/label по цепочке фолбэков использует план, 
 #### `ocx account use <provider> <account-or-key-id|main> [--json]`
 
 Выбирает существующий аккаунт Codex, OAuth-аккаунт или API-ключ. Для `openai` значение `main`
-выбирает вход Codex App. Выбор для Codex применяется только к **новым сессиям**; существующие
-потоки сохраняют свой аккаунт, а включённый порог автопереключения может позже переопределить
-ручное закрепление. Неизвестные провайдеры или id завершаются с кодом 1. `--json` возвращает:
+выбирает вход Codex App. Выбор Codex Pool очищает process-local affinity и применяется к следующему запросу, включая запрос существующей видимой задачи; после перезапуска прокси или affinity eviction задача также может стать непривязанной, а выполняющиеся запросы сохраняют захваченный аккаунт. Это управляет только Pool routing; Direct mode продолжает использовать caller-owned/native main credential. Проактивное переключение по использованию, повторная аутентификация 401/403, cooldown 429/retry-after, исключение и восстановление после отказа 429/402 до вывода могут позже выбрать другой подходящий Pool-аккаунт. Эти пути восстановления остаются активными, когда переключение по использованию выключено. После смены аккаунта OpenCodex воспроизводит контекст разговора, но prompt cache провайдера может потребовать прогрева. Неизвестные провайдеры
+или id завершаются с кодом 1. `--json` возвращает:
+При **401/403** локальная для процесса привязка к аккаунту сбрасывается и требуется повторная аутентификация.
+При **429** учитывается `Retry-After`, для аккаунта запускается cooldown, привязка сбрасывается,
+после чего запрос может перейти на другой подходящий аккаунт Pool. Эти переходы восстановления
+остаются активными при `autoSwitchThreshold: 0`; значение `0` отключает только проактивное переключение по использованию.
 
 ```text
 { ok: true, provider, type, activeId }
diff --git a/docs-site/src/content/docs/ru/reference/configuration.md b/docs-site/src/content/docs/ru/reference/configuration.md
index 93e58f6df..94b08abee 100644
--- a/docs-site/src/content/docs/ru/reference/configuration.md
+++ b/docs-site/src/content/docs/ru/reference/configuration.md
@@ -59,9 +59,9 @@ opencodex настраивается файлом `~/.opencodex/config.json`. Е
 | `pausedCodexAccountIds?` | `string[]` | `[]` | ID аккаунтов, исключённых из всех будущих выборов Pool до возобновления в Codex Auth. При паузе основного аккаунта включает `__main__`. |
 | `codexAccountNamespaces?` | `Record<string,string>` | — | Необязательная map публичного namespace селектора модели на сохранённую цель аккаунта Codex. Этот foundation layer проверяет и сохраняет map, но не добавляет строки picker и не меняет routing. |
 | `activeCodexAccountId?` | `string` | — | Вручную выбранный аккаунт пула. Выбор очищает существующие привязки потоков и действует со следующего запроса; выполняющиеся запросы сохраняют захваченный аккаунт. |
-| `autoSwitchThreshold?` | `number` | `80` | Порог процента использования для автопереключения новых сессий. Оценка использует самое «горячее» из известных окон квоты — 5-часовое, недельное или 30-дневное. Установите `0`, чтобы отключить автопереключение по квоте. Используется стратегией `quota` и как порог исчерпания для `fill-first`. |
-| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | Стратегия ротации новых сессий для пула Codex. Применяется **только к новым сессиям**; существующие id потоков сохраняют affinity. `quota` (по умолчанию) — выбор наименьшего известного usage, когда активный аккаунт превышает `autoSwitchThreshold`. `round-robin` — равномерное распределение между подходящими аккаунтами через smooth weighted selection. `fill-first` — использовать активный аккаунт до cooldown, недоступности или (если задано) `autoSwitchThreshold` (неизвестный usage не принуждает к переключению), затем переход к следующему подходящему аккаунту в стабильном отсортированном порядке. |
-| `accountPoolStickyLimit?` | `number` | `1` | Число успешных привязок новых сессий, удерживаемых на одном выборе round-robin перед переходом дальше. Диапазон 1–100; только при `accountPoolStrategy` = `round-robin`. |
+| `autoSwitchThreshold?` | `number` | `80` | Порог проактивного переключения по использованию. `quota` может повторно оценить следующий запрос как привязанной, так и непривязанной задачи; `fill-first` использует его только как точку исчерпания для непривязанных назначений; обычный `round-robin` его не использует. Оценка берёт самое горячее из окон 5 часов, недели и 30 дней. `0` отключает только переключение по использованию, но не назначение непривязанных задач и не восстановление после сбоев. |
+| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | Стратегия назначения для новых/непривязанных запросов Codex. Запрос непривязан, если у него нет live affinity `(parent thread id, quota scope)`; видимая существующая задача может стать непривязанной после перезапуска прокси или сброса affinity. `quota` выбирает подходящий аккаунт с наименьшим известным usage, когда активного аккаунта нет, сохраняет подходящий активный аккаунт ниже `autoSwitchThreshold`, а после порога может перевести непривязанный запрос или следующий запрос привязанной задачи на подходящий аккаунт с меньшим usage. `round-robin` равномерно распределяет непривязанные запросы; `fill-first` назначает их активному аккаунту до cooldown, недоступности или порога исчерпания. |
+| `accountPoolStickyLimit?` | `number` | `1` | Число назначений новых/непривязанных задач на одном выборе round-robin перед переходом дальше. Счётчик растёт при привязке задачи, а не после успеха upstream. Диапазон 1–100; только при `accountPoolStrategy` = `round-robin`. |
 | `upstreamFailoverThreshold?` | `number` | `3` | Число подряд идущих временных сбоев вышестоящей стороны, после которого будущие новые сессии переключаются (failover) на другой подходящий аккаунт пула. Установите `0`, чтобы отключить переключение по сбоям. |
 | `modelCacheTtlMs?` | `number` | `300000` | Окно свежести кэша `/models` каждого провайдера (5 минут). |
 | `appOwnedMemoryBudgetMb?` | `number` | `256` | Общий для процесса лимит в МиБ для вытесняемого удерживаемого состояния приложения (журналы, кэши, BLOB-данные и данные продолжения), допустимый диапазон — 64–4096. Это не лимит RSS или нативной памяти среды выполнения. |
@@ -93,22 +93,31 @@ raw id аккаунтов и email приватными, а селектор и
 :::note[Пул аккаунтов Codex]
 Используйте страницу **Codex Auth** дашборда для добавления аккаунтов пула и обновления квот.
 Конфигурация хранит только несекретные метаданные аккаунтов; access- и refresh-токены хранятся в
-защищённом хранилище учётных данных аккаунтов Codex. Существующие id потоков сохраняют привязку к
-аккаунту; новые сессии маршрутизируются по `accountPoolStrategy`, квоте, cooldown и
-работоспособности.
+защищённом хранилище учётных данных аккаунтов Codex. Pool routing разделяет назначение
+новых/непривязанных задач, проактивное переключение по использованию и восстановление после сбоев.
+Привязанная задача обычно сохраняет affinity, но `quota` может перепривязать её при следующем
+запросе после превышения порога; pause, cooldown, повторная аутентификация и обработка сбоев также
+могут независимо очистить или изменить routing. Непривязанным может стать и существующая задача
+после перезапуска прокси или сброса affinity. Отказ **429/402** до вывода допускает одну попытку
+на подходящем альтернативном аккаунте даже при выключенном переключении по использованию.
+Контекст разговора сохраняется и воспроизводится, но prompt cache провайдера между аккаунтами
+может не переиспользоваться и потребовать прогрева.
 Приостановленный аккаунт и его метаданные квоты остаются видимыми, но исключаются из автоматического переключения,
 повторов/failover, проб восстановления cooldown и ручной активации. Пауза также очищает карту affinity потоков
 этого аккаунта: выполняющиеся запросы сохраняют захваченные учётные данные, но последующие ходы
 перемаршрутизируются и не могут повторно использовать приостановленный аккаунт. Состояние сохраняется после перезапуска;
 если приостановлены все аккаунты, маршрутизация Pool завершается ошибкой, а не выбирает аккаунт скрытно.
 **Приостановить исчерпанные** сначала обновляет только подходящие аккаунты с доступными учётными данными и приостанавливает только те, для которых актуальное окно квоты в этом ответе подтверждено на уровне 100%. Аккаунты без учётных данных, с неизвестной квотой или неудачным обновлением не меняются.
-
-**Стратегии ротации** (только новые сессии; привязанные потоки не меняются): `quota` (по умолчанию)
-— выбор наименьшего usage при превышении `autoSwitchThreshold`; `round-robin` — равномерное
-распределение, `accountPoolStickyLimit` (по умолчанию `1`, 1–100) задаёт число успешных bind на один
-выбор; `fill-first` — исчерпание активного аккаунта (cooldown, reauth или threshold; неизвестный
-usage не принуждает к переключению), затем переход к следующему. Ротация не защищает от enforcement
-провайдера — использование нескольких аккаунтов может нарушать ToS.
+При **401/403** локальная для процесса привязка к аккаунту сбрасывается и требуется повторная аутентификация.
+При **429** учитывается `Retry-After`, для аккаунта запускается cooldown, привязка сбрасывается,
+после чего запрос может перейти на другой подходящий аккаунт Pool. Эти переходы восстановления
+остаются активными при `autoSwitchThreshold: 0`; значение `0` отключает только проактивное переключение по использованию.
+
+**Стратегии назначения и проактивного переключения:** `quota` выбирает подходящий аккаунт с наименьшим usage, когда активного аккаунта нет, сохраняет подходящий активный аккаунт ниже `autoSwitchThreshold`, а после порога может перевести непривязанный запрос или следующий запрос привязанной задачи на подходящий аккаунт с меньшим usage. `round-robin` равномерно распределяет непривязанные запросы, а порог не
+меняет обычную ротацию. `accountPoolStickyLimit` (по умолчанию `1`, 1–100) считает назначения/bind,
+а не успешные ответы. `fill-first` назначает непривязанные запросы активному аккаунту до cooldown,
+reauth или порога исчерпания; здоровые привязанные задачи сохраняют affinity. Эти стратегии не
+защищают от enforcement провайдера.
 :::
 
 ### claudeCode (OcxClaudeCodeConfig)
diff --git a/docs-site/src/content/docs/zh-cn/reference/cli.md b/docs-site/src/content/docs/zh-cn/reference/cli.md
index 00f58c054..93305df42 100644
--- a/docs-site/src/content/docs/zh-cn/reference/cli.md
+++ b/docs-site/src/content/docs/zh-cn/reference/cli.md
@@ -210,7 +210,7 @@ refresh <provider>  Force-refresh Codex or provider quota reports.
 auto-switch <provider> <on|off|status|threshold N>  Control the Codex pool threshold.
 remove <provider> <id> --yes  Remove a stored account or key after an existence check.
 add-key <provider> [--label <label>]  Add a key read only from piped stdin.
-Codex pool switches apply to new sessions; running threads keep their account.
+Codex pool selection applies to the next request after clearing existing affinity; in-flight requests keep their captured account.
 ```
 
 所有子命令都要求代理正在运行；CLI 会自动解析已记录的运行时端口。成功时退出码为 0。用法错误、
@@ -259,8 +259,11 @@ Kiro 账号时，输出会说明它只有一个登录 slot，再次登录会替
 #### `ocx account use <provider> <account-or-key-id|main> [--json]`
 
 选择已有的 Codex 账号、OAuth 账号或 API key。对 `openai` 而言，`main` 选择 Codex App 登录。
-Codex 选择只对**新 session**生效；已有 thread 保持其账号。启用的 auto-switch threshold 之后可能
-覆盖手动 pin。未知 provider 或 id 返回退出码 1。`--json` 返回：
+Codex Pool 选择会清除进程本地 affinity，并从下一次请求开始生效，包括已有可见任务的请求；代理重启或 affinity eviction 后，任务也可能变为未绑定，但进行中的请求保留已捕获账号。此选择只控制 Pool routing；Direct mode 继续使用 caller-owned/native main credential。基于用量的主动切换、401/403 重新认证、429/retry-after cooldown、排除，以及输出前 429/402 故障恢复之后仍可能选择其他合格 Pool 账号。这些恢复路径在关闭基于用量的切换时仍然有效。账号变化后 OpenCodex 会重放对话上下文，但 provider prompt cache 可能需要重新预热。未知 provider 或 id 返回退出码 1。`--json` 返回：
+遇到 **401/403** 时，App 登录会清除该账户的进程内 affinity 并要求重新认证。
+遇到 **429** 时，它会遵循 `Retry-After`、启动账户 cooldown、清除 affinity，
+并可将请求切换到另一个符合条件的 Pool 账户。即使 `autoSwitchThreshold: 0`，
+这些故障恢复流程仍然有效；`0` 只会禁用基于用量的主动切换。
 
 ```text
 { ok: true, provider, type, activeId }
diff --git a/docs-site/src/content/docs/zh-cn/reference/configuration.md b/docs-site/src/content/docs/zh-cn/reference/configuration.md
index 17c2249bb..6415a427f 100644
--- a/docs-site/src/content/docs/zh-cn/reference/configuration.md
+++ b/docs-site/src/content/docs/zh-cn/reference/configuration.md
@@ -53,9 +53,9 @@ no-replace 方式创建 `config.json.pre-openai-tiers-v2.bak`，并把已知旧
 | `pausedCodexAccountIds?` | `string[]` | `[]` | 在 Codex Auth 中恢复前，不参与任何后续 Pool 选择的账号 ID。暂停主账号时也包含 `__main__`。 |
 | `codexAccountNamespaces?` | `Record<string,string>` | — | 可选的公开 model selector namespace 到已保存 Codex account target 的映射。此 foundation layer 只验证并持久化该映射，不会添加 picker row 或改变 routing。 |
 | `activeCodexAccountId?` | `string` | — | 手动选择的 pool account。选择时清除已有 thread affinity，并从下一次请求开始生效；进行中的请求保留原账号。 |
-| `autoSwitchThreshold?` | `number` | `80` | 新 session 自动切换的 usage 百分比 threshold。分数取已知 5 小时、周或 30 天 quota window 中最高的一项。设为 `0` 可禁用 quota 自动切换。`quota` 策略和 `fill-first` 的耗尽 threshold 都会用到。 |
-| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | Codex pool 的新 session 轮换策略。仅适用于**新 session**；已有 thread id 保留 affinity。`quota`（默认）：活跃账号超过 `autoSwitchThreshold` 时选已知 usage 最低者。`round-robin`：在合格账号间平滑加权均分。`fill-first`：持续使用活跃账号，直到 cooldown、不可用或（如已设置）超过 `autoSwitchThreshold`（未知 usage 不会强制切换），再按稳定排序进入下一个合格账号。 |
-| `accountPoolStickyLimit?` | `number` | `1` | 一次 round-robin 选择在推进前保留的成功新 session 绑定数。范围 1–100；仅当 `accountPoolStrategy` 为 `round-robin` 时生效。 |
+| `autoSwitchThreshold?` | `number` | `80` | 基于用量的主动切换阈值。`quota` 可在下一次请求中重新评估已绑定和未绑定任务；`fill-first` 仅把它用作未绑定分配的耗尽点；正常 `round-robin` 不使用它。分数取已知 5 小时、周或 30 天 quota window 的最高值。`0` 只关闭基于用量的主动切换，不关闭未绑定任务分配或故障恢复。 |
+| `accountPoolStrategy?` | `"quota" \| "round-robin" \| "fill-first"` | `"quota"` | 新建/未绑定 Codex 请求的分配策略。没有 live `(parent thread id, quota scope)` affinity 的请求属于未绑定；代理重启或 affinity 重置后，已有可见任务也可能未绑定。`quota` 在没有活跃账号时选择已知 usage 最低的合格账号；活跃账号合格且低于 `autoSwitchThreshold` 时继续使用；达到阈值后，可把未绑定请求或已绑定任务的下一次请求切换到 usage 更低的合格账号。`round-robin` 均匀分配未绑定请求；`fill-first` 在 cooldown、不可用或耗尽阈值前持续分配给活跃账号。 |
+| `accountPoolStickyLimit?` | `number` | `1` | 一次 round-robin 选择在推进前保留的新建/未绑定任务分配数。计数在任务绑定时增加，而不是在上游成功后增加。范围 1–100；仅当 `accountPoolStrategy` 为 `round-robin` 时生效。 |
 | `upstreamFailoverThreshold?` | `number` | `3` | 连续发生多少次临时上游失败后，让后续新 session failover 到其他合格 pool account。设为 `0` 可禁用失败切换。 |
 | `modelCacheTtlMs?` | `number` | `300000` | 每个 provider 的 `/models` 缓存新鲜度窗口（5 分钟）。 |
 | `appOwnedMemoryBudgetMb?` | `number` | `256` | 进程级可驱逐应用保留状态（日志、缓存、Blob 和续接响应负载）上限，单位为 MiB，有效范围为 64–4096。它不是 RSS 或原生运行时内存上限。 |
@@ -82,18 +82,25 @@ pool account id（不能是内部 `__main__`），或用 `"@main"` 表示 Codex
 
 :::note[Codex 账号池]
 请在仪表盘 **Codex Auth** 页面添加 pool account 并刷新 quota。配置只保存非 secret account
-metadata；access/refresh token 存放在加固的 Codex account credential store 中。已有 thread id 会
-保留 account affinity；新 session 按 `accountPoolStrategy`、quota、cooldown 和 health 自动路由。
+metadata；access/refresh token 存放在加固的 Codex account credential store 中。Pool routing
+分为新建/未绑定任务分配、基于用量的主动切换和故障恢复。已绑定任务通常保持 affinity，但 `quota`
+可在超过阈值后的下一次请求中重新绑定；暂停、cooldown、重新认证和故障处理也能独立清除或改变
+routing。未绑定请求没有 live 账号绑定，也可能是代理重启或 affinity 重置后的已有任务。输出前的
+**429/402** 即使在关闭基于用量的主动切换时，也可在同一请求中对合格替代账号重试一次。
+账号变化后会保留并重放对话上下文，但账号间的 provider prompt cache 不保证复用，可能需要重新预热。
 暂停后仍会显示账号及其 quota metadata，但不会参与自动切换、重试/failover 选择、cooldown 恢复探测或手动激活。
 暂停还会清除该账号的 thread affinity map：进行中的请求保留已捕获的 credential，但后续 turn 会重新路由，无法再使用已暂停账号。
 暂停状态会跨重启保留；如果所有账号均已暂停，Pool 路由会明确失败，而不会暗中选择某个账号。
 **暂停已达上限账号** 会先刷新有 credential 的合格账号，只暂停相关 quota window 本次明确返回 100% 的账号；无 credential、未知额度或刷新失败的账号保持不变。
-
-**轮换策略**（仅新 session；已绑定 thread 不变）：`quota`（默认）— 活跃账号 usage 超过
-`autoSwitchThreshold` 时选最低者；`round-robin` — 均分，`accountPoolStickyLimit`（默认 `1`，
-1–100）控制一次选择保留多少成功绑定；`fill-first` — 耗尽活跃账号（cooldown、需重新认证或
-threshold；未知 usage 不强制切换）后按稳定排序进入下一个。轮换不能规避 provider enforcement —
-多账号使用可能违反服务条款。
+遇到 **401/403** 时，App 登录会清除该账户的进程内 affinity 并要求重新认证。
+遇到 **429** 时，它会遵循 `Retry-After`、启动账户 cooldown、清除 affinity，
+并可将请求切换到另一个符合条件的 Pool 账户。即使 `autoSwitchThreshold: 0`，
+这些故障恢复流程仍然有效；`0` 只会禁用基于用量的主动切换。
+
+**分配与主动切换策略：** `quota`（默认）在没有活跃账号时选择 usage 最低的合格账号；活跃账号合格且低于 `autoSwitchThreshold` 时继续使用；达到阈值后，可把未绑定请求或已绑定任务的下一次请求切换到 usage 更低的合格账号。`round-robin` 均匀分配未绑定请求，用量
+阈值不会改变正常轮换。`accountPoolStickyLimit`（默认 `1`，1–100）统计分配/绑定，而不是成功响应。
+`fill-first` 在 cooldown、重新认证或耗尽阈值前把未绑定请求分配给活跃账号；健康的已绑定任务保持
+affinity。这些策略不能规避 provider enforcement。
 :::
 
 ### 受管 record 形状
diff --git a/gui/src/components/AccountPoolStrategyControls.tsx b/gui/src/components/AccountPoolStrategyControls.tsx
index 5603f5a3c..d5023ca43 100644
--- a/gui/src/components/AccountPoolStrategyControls.tsx
+++ b/gui/src/components/AccountPoolStrategyControls.tsx
@@ -13,6 +13,12 @@ const STRATEGY_LABEL_KEYS = {
   "fill-first": "accountPool.strategyFillFirst",
 } as const;
 
+const STRATEGY_HINT_KEYS = {
+  quota: "accountPool.strategyHintQuota",
+  "round-robin": "accountPool.strategyHintRoundRobin",
+  "fill-first": "accountPool.strategyHintFillFirst",
+} as const;
+
 export interface AccountPoolStrategyControlsProps {
   strategy: AccountPoolStrategy;
   stickyDraft: string;
@@ -64,7 +70,8 @@ export default function AccountPoolStrategyControls({
         <div className="setting-label">
           <span className="title" id={`${strategySelectId}-label`}>{t("accountPool.strategy")}</span>
           <span className="desc">{t("accountPool.strategyDesc")}</span>
-          <span className="desc">{t("accountPool.strategyHint")}</span>
+          <span className="desc">{t(STRATEGY_HINT_KEYS[strategy])}</span>
+          <span className="desc">{t("accountPool.unboundDefinition")}</span>
         </div>
         <div className="setting-controls">
           <Select
diff --git a/gui/src/components/CodexAccountPool.tsx b/gui/src/components/CodexAccountPool.tsx
index 6ab3e2f6f..9731ca15c 100644
--- a/gui/src/components/CodexAccountPool.tsx
+++ b/gui/src/components/CodexAccountPool.tsx
@@ -19,6 +19,7 @@ import { redeemResetCredit } from "./codex-account-pool-handlers";
 import type { CodexAccountEntry } from "./codex-account-pool-types";
 import { accountNeedsReauth } from "../oauth-health-display";
 import { useCopyFeedback } from "./use-copy-feedback";
+import { DEFAULT_ACCOUNT_POOL_STRATEGY } from "../account-pool-strategy";
 
 // Single definition lives with the controller that owns this data (WP3).
 export type { CodexAccountEntry } from "../hooks/useCodexAccountPool";
@@ -51,6 +52,9 @@ export default function CodexAccountPool({ apiBase, accountModeState = null, ban
     updateFailed: t("codexAuth.autoSwitchUpdateFailed"),
     invalid: t("codexAuth.autoSwitchThresholdInvalid"),
   });
+  const [poolStrategy, setPoolStrategy] = useState<
+    typeof DEFAULT_ACCOUNT_POOL_STRATEGY | "round-robin" | "fill-first" | null
+  >(null);
   const { beginServerRead, acceptServerRead, rejectServerRead, hydrateServerValue } = autoSwitch;
   // A hook cannot be called conditionally, so the fallback instance is always created
   // but stays inert (no load, no polling) whenever a shared controller was injected.
@@ -335,28 +339,32 @@ export default function CodexAccountPool({ apiBase, accountModeState = null, ban
         </>
       )}
 
-      <CodexAutoSwitchSetting
-        threshold={autoSwitch.threshold}
-        draft={autoSwitch.draft}
-        hydrated={autoSwitch.hydrated}
-        saving={autoSwitch.saving}
-        loadError={autoSwitch.loadError}
-        feedback={autoSwitch.feedback}
-        onDraftChange={autoSwitch.setDraft}
-        onEditingChange={autoSwitch.setEditing}
-        onCommit={autoSwitch.commit}
-        onCancel={autoSwitch.cancel}
-        onToggle={autoSwitch.toggle}
-        onRetry={() => {
-          autoSwitch.retry();
-          void load();
-        }}
-      />
+      {poolStrategy !== null && (
+        <CodexAutoSwitchSetting
+          threshold={autoSwitch.threshold}
+          draft={autoSwitch.draft}
+          strategy={poolStrategy}
+          hydrated={autoSwitch.hydrated}
+          saving={autoSwitch.saving}
+          loadError={autoSwitch.loadError}
+          feedback={autoSwitch.feedback}
+          onDraftChange={autoSwitch.setDraft}
+          onEditingChange={autoSwitch.setEditing}
+          onCommit={autoSwitch.commit}
+          onCancel={autoSwitch.cancel}
+          onToggle={autoSwitch.toggle}
+          onRetry={() => {
+            autoSwitch.retry();
+            void load();
+          }}
+        />
+      )}
 
       <CodexPoolStrategySetting
         apiBase={apiBase}
         subscribeLoadObserver={controller.subscribeLoadObserver}
         readLastActive={controller.readLastActive}
+        onStrategyResolved={setPoolStrategy}
       />
 
       {confirm && (
diff --git a/gui/src/components/CodexAutoSwitchSetting.tsx b/gui/src/components/CodexAutoSwitchSetting.tsx
index 4af9a6cd3..76d10825d 100644
--- a/gui/src/components/CodexAutoSwitchSetting.tsx
+++ b/gui/src/components/CodexAutoSwitchSetting.tsx
@@ -1,13 +1,30 @@
 import { useRef } from "react";
 import { useT } from "../i18n/shared";
 import { clampNumberDraft } from "../clamp-draft";
+import type { AccountPoolStrategy } from "../account-pool-strategy";
 import { NumberStepper } from "./NumberStepper";
 
 export type AutoSwitchFeedback = { tone: "ok" | "err"; message: string } | null;
 
+const AUTO_SWITCH_DESCRIPTION_KEYS = {
+  quota: {
+    on: "codexAuth.autoSwitchQuotaDesc",
+    off: "codexAuth.autoSwitchQuotaOffDesc",
+  },
+  "round-robin": {
+    on: "codexAuth.autoSwitchRoundRobinDesc",
+    off: "codexAuth.autoSwitchRoundRobinDesc",
+  },
+  "fill-first": {
+    on: "codexAuth.autoSwitchFillFirstDesc",
+    off: "codexAuth.autoSwitchFillFirstOffDesc",
+  },
+} as const;
+
 export interface CodexAutoSwitchSettingProps {
   threshold: number;
   draft: string;
+  strategy?: AccountPoolStrategy;
   /** When false, chrome still paints but interaction is blocked until /active confirms. */
   hydrated?: boolean;
   saving: boolean;
@@ -24,6 +41,7 @@ export interface CodexAutoSwitchSettingProps {
 export function CodexAutoSwitchSetting({
   threshold,
   draft,
+  strategy = "quota",
   hydrated = true,
   saving,
   loadError,
@@ -38,6 +56,7 @@ export function CodexAutoSwitchSetting({
   const t = useT();
   const togglePointerIntentRef = useRef(false);
   const enabled = threshold > 0;
+  const descriptionKey = AUTO_SWITCH_DESCRIPTION_KEYS[strategy][enabled ? "on" : "off"];
   const controlsDisabled = saving || !hydrated;
   const feedbackMessage = saving ? t("common.saving") : feedback?.message ?? "";
   const feedbackTone = saving ? "pending" : feedback?.tone;
@@ -59,10 +78,10 @@ export function CodexAutoSwitchSetting({
         >
           {loadError
             ? t("codexAuth.autoSwitchLoadFailed")
-            : enabled
-              ? t("codexAuth.autoSwitchDesc", { threshold })
-              : t("codexAuth.autoSwitchOffDesc")}
+            : t(descriptionKey, { threshold })}
         </div>
+        <div className="card-sub">{t("codexAuth.failureRecoveryNote")}</div>
+        <div className="card-sub">{t("codexAuth.cacheWarning")}</div>
       </div>
       <div
         className="codex-auto-switch-controls"
diff --git a/gui/src/components/CodexPoolStrategySetting.tsx b/gui/src/components/CodexPoolStrategySetting.tsx
index f35e60e20..9cf4cbcae 100644
--- a/gui/src/components/CodexPoolStrategySetting.tsx
+++ b/gui/src/components/CodexPoolStrategySetting.tsx
@@ -34,10 +34,12 @@ export default function CodexPoolStrategySetting({
   apiBase,
   subscribeLoadObserver,
   readLastActive,
+  onStrategyResolved,
 }: {
   apiBase: string;
   subscribeLoadObserver?: (observer: CodexAccountLoadObserver) => () => void;
   readLastActive?: () => unknown;
+  onStrategyResolved?: (strategy: AccountPoolStrategy) => void;
 }) {
   const t = useT();
   // Seed defaults immediately — never gate the control chrome on a network round-trip.
@@ -61,13 +63,14 @@ export default function CodexPoolStrategySetting({
     const nextStrategy = normalizeAccountPoolStrategy(json.accountPoolStrategy);
     const nextSticky = normalizeAccountPoolStickyLimit(json.accountPoolStickyLimit);
     setStrategy(nextStrategy);
+    onStrategyResolved?.(nextStrategy);
     setStickyLimit(nextSticky);
     setStickyDraft(String(nextSticky));
     hydratedRef.current = true;
     setHydrated(true);
     setLoadError(false);
     setError(null);
-  }, []);
+  }, [onStrategyResolved]);
 
   const applyActivePayload = useCallback((value: unknown) => {
     const fields = strategyFieldsFromActive(value);
@@ -156,7 +159,10 @@ export default function CodexPoolStrategySetting({
     if (savingRef.current) return;
     const previousStrategy = strategy;
     const previousSticky = stickyLimit;
-    if (next.strategy !== undefined) setStrategy(next.strategy);
+    if (next.strategy !== undefined) {
+      setStrategy(next.strategy);
+      onStrategyResolved?.(next.strategy);
+    }
     if (next.stickyLimit !== undefined) {
       setStickyLimit(next.stickyLimit);
       setStickyDraft(String(next.stickyLimit));
@@ -169,6 +175,7 @@ export default function CodexPoolStrategySetting({
     revisionRef.current += 1;
     if (result.ok) {
       setStrategy(result.strategy);
+      onStrategyResolved?.(result.strategy);
       setStickyLimit(result.stickyLimit);
       setStickyDraft(String(result.stickyLimit));
       hydratedRef.current = true;
@@ -176,13 +183,14 @@ export default function CodexPoolStrategySetting({
     } else {
       setError(t("accountPool.strategyUpdateFailed"));
       setStrategy(previousStrategy);
+      onStrategyResolved?.(previousStrategy);
       setStickyLimit(previousSticky);
       setStickyDraft(String(previousSticky));
     }
     savingRef.current = false;
     setSaving(false);
     scheduleDeferredActiveRefresh();
-  }, [apiBase, scheduleDeferredActiveRefresh, stickyLimit, strategy, t]);
+  }, [apiBase, onStrategyResolved, scheduleDeferredActiveRefresh, stickyLimit, strategy, t]);
 
   // Block writes until /active confirms — defaults paint for CLS but must not overwrite server state.
   const controlsDisabled = saving || loadError || !hydrated;
diff --git a/gui/src/i18n/de.ts b/gui/src/i18n/de.ts
index dcb621f57..c99f27789 100644
--- a/gui/src/i18n/de.ts
+++ b/gui/src/i18n/de.ts
@@ -718,22 +718,26 @@ export const de: Record<TKey, string> = {
   "codexAuth.poolPreparedToast": "{email} ist für den Pool-Modus vorbereitet",
   "codexAuth.switchTitle": "Aktives Konto wechseln?",
   "codexAuth.switchDesc": "Dies gilt für die nächste Anfrage bestehender und neuer Codex-Sitzungen. Laufende Anfragen behalten ihr Konto.",
-  "codexAuth.cacheWarning": "Prompt-Cache wird beim Kontowechsel zurückgesetzt. Neue Sitzung startet mit leerem Cache.",
+  "codexAuth.cacheWarning": "OpenCodex spielt den Gesprächskontext nach jedem Kontowechsel erneut ab, aber der providerseitige Prompt-Cache kann kalt sein.",
   "codexAuth.setAsNext": "Konto auswählen",
   "codexAuth.cancel": "Abbrechen",
   "codexAuth.switchBack": "Zurück zum Hauptkonto?",
   "codexAuth.switchBackDesc": "Die nächste Anfrage bestehender und neuer Codex-Sitzungen verwendet dein App-Login-Konto.",
-  "codexAuth.autoSwitch": "Automatischer Kontowechsel",
-  "codexAuth.autoSwitchDesc": "Wechselt ab {threshold} % Auslastung, wenn ein verfügbares Konto eine niedrigere Auslastung hat; Go/Free nutzen nur das 30-Tage-Fenster",
-  "codexAuth.autoSwitchOffDesc": "Der automatische Kontowechsel ist ausgeschaltet",
-  "codexAuth.autoSwitchThreshold": "Wechselschwelle",
-  "codexAuth.autoSwitchThresholdAria": "Wechselschwelle in Prozent",
-  "codexAuth.autoSwitchThresholdInc": "Wechsel-Schwelle erhöhen",
-  "codexAuth.autoSwitchThresholdDec": "Wechsel-Schwelle verringern",
-  "codexAuth.autoSwitchLoadFailed": "Die Einstellung für den automatischen Kontowechsel konnte nicht geladen werden.",
+  "codexAuth.autoSwitch": "Proaktiver Wechsel nach Nutzung",
+  "codexAuth.autoSwitchQuotaDesc": "Kontingent: Ab {threshold} % Nutzung kann die nächste Anfrage zu einem geeigneten Konto mit geringerer Nutzung wechseln, auch bei einer bereits gebundenen Aufgabe; Go/Free nutzen nur 30 Tage.",
+  "codexAuth.autoSwitchQuotaOffDesc": "Der proaktive Wechsel nach Nutzung ist aus. Zuweisung neuer/ungebundener Aufgaben und Fehlerbehebung bleiben aktiv.",
+  "codexAuth.autoSwitchRoundRobinDesc": "Round-Robin-Zuweisung verwendet diesen Schwellenwert nicht und rotiert weiter neue/ungebundene Aufgaben.",
+  "codexAuth.autoSwitchFillFirstDesc": "Fill-first: {threshold} % ist der Entleerungspunkt für neue/ungebundene Aufgaben; gesunde gebundene Aufgaben behalten ihr Konto.",
+  "codexAuth.autoSwitchFillFirstOffDesc": "Fill-first hat keinen nutzungsbasierten Entleerungspunkt für neue/ungebundene Aufgaben; Cooldown, Neuanmeldung und Fehlerbehebung können das Routing weiterhin ändern.",
+  "codexAuth.failureRecoveryNote": "Fehlerbehebung ist getrennt: Eine Ablehnung vor der Ausgabe mit 429/402, Cooldown, Neuanmeldung, Ausschluss oder konfiguriertes temporäres Failover kann ein anderes geeignetes Konto auswählen.",
+  "codexAuth.autoSwitchThreshold": "Nutzungsschwelle",
+  "codexAuth.autoSwitchThresholdAria": "Nutzungsschwelle in Prozent",
+  "codexAuth.autoSwitchThresholdInc": "Nutzungsschwelle erhöhen",
+  "codexAuth.autoSwitchThresholdDec": "Nutzungsschwelle verringern",
+  "codexAuth.autoSwitchLoadFailed": "Die Einstellung für den nutzungsbasierten Wechsel konnte nicht geladen werden.",
   "codexAuth.autoSwitchThresholdInvalid": "Gib eine ganze Zahl von 1 bis 100 ein",
-  "codexAuth.autoSwitchUpdated": "Der automatische Kontowechsel wurde aktualisiert",
-  "codexAuth.autoSwitchUpdateFailed": "Die Aktualisierung konnte nicht bestätigt werden. Der zuletzt bestätigte Wert wird angezeigt.",
+  "codexAuth.autoSwitchUpdated": "Der proaktive Wechsel nach Nutzung wurde aktualisiert",
+  "codexAuth.autoSwitchUpdateFailed": "Die Aktualisierung des nutzungsbasierten Wechsels konnte nicht bestätigt werden. Der zuletzt bestätigte Wert wird angezeigt.",
   "anthropicPool.title": "Claude-Kontenpool (experimentell)",
   "anthropicPool.enabledDesc": "Bei 429 wird das Konto gekühlt und umgeschaltet. Neue Sitzungen bevorzugen Nutzung unter {threshold}% (5-Stunden-Balken).",
   "anthropicPool.disabledDesc": "Nutzt nur das aktive Claude-Konto. Nur aktivieren, wenn experimentelles Routing akzeptabel ist.",
@@ -749,16 +753,19 @@ export const de: Record<TKey, string> = {
   "anthropicPool.off": "Aus",
 
   "accountPool.strategy": "Rotationsstrategie",
-  "accountPool.strategyDesc": "Wie neue Sitzungen ein Konto aus dem Pool wählen.",
+  "accountPool.strategyDesc": "Wie OpenCodex einer neuen/ungebundenen Aufgabe ein Konto zuweist.",
   "accountPool.strategyQuota": "Kontingent",
   "accountPool.strategyRoundRobin": "Round-Robin",
   "accountPool.strategyFillFirst": "Fill-first",
-  "accountPool.strategyHint": "Gilt nur für neue Sitzungen; bestehende Threads behalten die Kontenaffinität.",
-  "accountPool.stickyLimit": "Sticky-Erfolge vor Rotation",
-  "accountPool.stickyLimitAria": "Sticky-Erfolge vor Rotation",
+  "accountPool.strategyHintQuota": "Kontingent kann eine bestehende Aufgabe bei ihrer nächsten Anfrage neu binden, nachdem die Nutzungsschwelle überschritten wurde.",
+  "accountPool.strategyHintRoundRobin": "Round-Robin rotiert nur Aufgaben ohne aktive Bindung; die Nutzungsschwelle ändert die normale Rotation nicht.",
+  "accountPool.strategyHintFillFirst": "Fill-first nutzt die Schwelle als Entleerungspunkt für ungebundene Aufgaben; gesunde gebundene Aufgaben behalten ihre Affinität.",
+  "accountPool.unboundDefinition": "Neue/ungebundene Aufgabe bedeutet eine Anfrage ohne aktuelle Kontobindung; eine sichtbare bestehende Aufgabe kann nach einem Proxy- oder Affinitätsreset ungebunden sein.",
+  "accountPool.stickyLimit": "Neue/ungebundene Zuweisungen vor Rotation",
+  "accountPool.stickyLimitAria": "Neue/ungebundene Zuweisungen vor Rotation",
   "accountPool.stickyLimitInc": "Sticky-Limit erhöhen",
   "accountPool.stickyLimitDec": "Sticky-Limit verringern",
-  "accountPool.stickyLimitHelp": "Das gewählte Konto für so viele erfolgreiche neue Sitzungsbindungen behalten, bevor weitergeschaltet wird.",
+  "accountPool.stickyLimitHelp": "So viele neue/ungebundene Aufgaben dem gewählten Konto zuweisen, bevor weitergeschaltet wird; gezählt wird bei der Bindung, nicht nach einem Upstream-Erfolg.",
   "accountPool.stickyLimitInvalid": "Gib eine ganze Zahl von 1 bis 100 ein",
   "accountPool.strategyLoadFailed": "Rotationsstrategie konnte nicht geladen werden.",
   "accountPool.strategyUpdateFailed": "Rotationsstrategie konnte nicht gespeichert werden.",
diff --git a/gui/src/i18n/en.ts b/gui/src/i18n/en.ts
index e130743dc..8f8b120ca 100644
--- a/gui/src/i18n/en.ts
+++ b/gui/src/i18n/en.ts
@@ -1159,22 +1159,26 @@ export const en = {
   "codexAuth.poolPreparedToast": "{email} is prepared for Pool mode",
   "codexAuth.switchTitle": "Switch active account?",
   "codexAuth.switchDesc": "This applies to the next request from existing and new Codex sessions. In-flight requests keep their captured account.",
-  "codexAuth.cacheWarning": "Prompt cache resets on account switch. New session starts with empty cache.",
+  "codexAuth.cacheWarning": "OpenCodex replays the conversation after any account change, but the provider-side prompt cache may be cold.",
   "codexAuth.setAsNext": "Select Account",
   "codexAuth.cancel": "Cancel",
   "codexAuth.switchBack": "Switch back to Main?",
   "codexAuth.switchBackDesc": "The next request from existing and new Codex sessions will use your App login account.",
-  "codexAuth.autoSwitch": "Automatic account switching",
-  "codexAuth.autoSwitchDesc": "Switches at {threshold}% usage or above when an eligible account has lower usage; Go/Free use 30d only",
-  "codexAuth.autoSwitchOffDesc": "Automatic account switching is off",
-  "codexAuth.autoSwitchThreshold": "Switch threshold",
-  "codexAuth.autoSwitchThresholdAria": "Switch threshold, percent",
-  "codexAuth.autoSwitchThresholdInc": "Increase switch threshold",
-  "codexAuth.autoSwitchThresholdDec": "Decrease switch threshold",
-  "codexAuth.autoSwitchLoadFailed": "Automatic switching setting could not be loaded.",
+  "codexAuth.autoSwitch": "Usage-based proactive switching",
+  "codexAuth.autoSwitchQuotaDesc": "Quota: at {threshold}% usage or above, the next request may move to a lower-usage eligible account, including an already-bound task; Go/Free use 30d only.",
+  "codexAuth.autoSwitchQuotaOffDesc": "Usage-based proactive switching is off. New/unbound assignment and failure recovery still apply.",
+  "codexAuth.autoSwitchRoundRobinDesc": "Round-robin assignment does not use this threshold; it continues to rotate new/unbound tasks.",
+  "codexAuth.autoSwitchFillFirstDesc": "Fill-first: {threshold}% is the drain point for new/unbound tasks; healthy bound tasks keep their account.",
+  "codexAuth.autoSwitchFillFirstOffDesc": "Fill-first has no usage drain point for new/unbound tasks; cooldown, reauthentication, and failure recovery can still move routing.",
+  "codexAuth.failureRecoveryNote": "Failure recovery is separate: a request rejected before output with 429/402, cooldown, reauthentication, exclusion, or configured transient failover may select another eligible account.",
+  "codexAuth.autoSwitchThreshold": "Usage threshold",
+  "codexAuth.autoSwitchThresholdAria": "Usage threshold, percent",
+  "codexAuth.autoSwitchThresholdInc": "Increase usage threshold",
+  "codexAuth.autoSwitchThresholdDec": "Decrease usage threshold",
+  "codexAuth.autoSwitchLoadFailed": "Usage-based switching setting could not be loaded.",
   "codexAuth.autoSwitchThresholdInvalid": "Enter a whole number from 1 to 100",
-  "codexAuth.autoSwitchUpdated": "Automatic account switching updated",
-  "codexAuth.autoSwitchUpdateFailed": "The update could not be confirmed. The last confirmed value is shown.",
+  "codexAuth.autoSwitchUpdated": "Usage-based proactive switching updated",
+  "codexAuth.autoSwitchUpdateFailed": "The usage-based switching update could not be confirmed. The last confirmed value is shown.",
 
   "anthropicPool.title": "Claude account pool (experimental)",
   "anthropicPool.enabledDesc": "On 429, cools the account and fails over. New sessions prefer usage under {threshold}% (5-hour bar).",
@@ -1191,16 +1195,19 @@ export const en = {
   "anthropicPool.off": "Off",
 
   "accountPool.strategy": "Rotation strategy",
-  "accountPool.strategyDesc": "How new sessions pick an account from the pool.",
+  "accountPool.strategyDesc": "How OpenCodex assigns an account to a new/unbound task.",
   "accountPool.strategyQuota": "Quota",
   "accountPool.strategyRoundRobin": "Round-robin",
   "accountPool.strategyFillFirst": "Fill-first",
-  "accountPool.strategyHint": "Applies to new sessions only; existing threads keep account affinity.",
-  "accountPool.stickyLimit": "Sticky successes before rotate",
-  "accountPool.stickyLimitAria": "Sticky successes before rotate",
+  "accountPool.strategyHintQuota": "Quota can also rebind an existing task on its next request after the usage threshold is crossed.",
+  "accountPool.strategyHintRoundRobin": "Round-robin rotates only tasks without a live binding; the usage threshold does not change normal rotation.",
+  "accountPool.strategyHintFillFirst": "Fill-first uses the threshold as a drain point for unbound tasks; healthy bound tasks keep affinity.",
+  "accountPool.unboundDefinition": "New/unbound task means a request with no current account binding; an existing visible task can become unbound after a proxy or affinity reset.",
+  "accountPool.stickyLimit": "New/unbound assignments before rotate",
+  "accountPool.stickyLimitAria": "New/unbound assignments before rotate",
   "accountPool.stickyLimitInc": "Increase sticky limit",
   "accountPool.stickyLimitDec": "Decrease sticky limit",
-  "accountPool.stickyLimitHelp": "Keep the selected account for this many successful new-session binds before advancing.",
+  "accountPool.stickyLimitHelp": "Keep the selected account for this many new/unbound task assignments before advancing; the counter increments when the task is bound, not after upstream success.",
   "accountPool.stickyLimitInvalid": "Enter a whole number from 1 to 100",
   "accountPool.strategyLoadFailed": "Rotation strategy could not be loaded.",
   "accountPool.strategyUpdateFailed": "Rotation strategy could not be saved.",
diff --git a/gui/src/i18n/ja.ts b/gui/src/i18n/ja.ts
index ae8109ed7..72f868ef4 100644
--- a/gui/src/i18n/ja.ts
+++ b/gui/src/i18n/ja.ts
@@ -1109,22 +1109,26 @@ export const ja: Record<TKey, string> = {
   "codexAuth.poolPreparedToast": "{email} はプールモード用に準備されました",
   "codexAuth.switchTitle": "アクティブアカウントを切り替えますか?",
   "codexAuth.switchDesc": "既存および新規 Codex セッションの次のリクエストから適用されます。処理中のリクエストは現在のアカウントを維持します。",
-  "codexAuth.cacheWarning": "アカウント切り替えでプロンプトキャッシュはリセットされます。新規セッションは空のキャッシュで開始します。",
+  "codexAuth.cacheWarning": "アカウントが変わっても OpenCodex は会話コンテキストを再生しますが、プロバイダー側のプロンプトキャッシュは再ウォームアップが必要な場合があります。",
   "codexAuth.setAsNext": "アカウントを選択",
   "codexAuth.cancel": "キャンセル",
   "codexAuth.switchBack": "メインに戻しますか?",
   "codexAuth.switchBackDesc": "既存および新規 Codex セッションの次のリクエストからアプリログインアカウントを使用します。",
-  "codexAuth.autoSwitch": "アカウントの自動切り替え",
-  "codexAuth.autoSwitchDesc": "使用率が {threshold}% 以上で、より使用率の低い利用可能なアカウントがある場合に切り替えます。Go/Free は 30 日枠のみを使用します",
-  "codexAuth.autoSwitchOffDesc": "アカウントの自動切り替えはオフです",
-  "codexAuth.autoSwitchThreshold": "切り替えしきい値",
-  "codexAuth.autoSwitchThresholdAria": "切り替えしきい値（パーセント）",
-  "codexAuth.autoSwitchThresholdInc": "切替しきい値を上げる",
-  "codexAuth.autoSwitchThresholdDec": "切替しきい値を下げる",
-  "codexAuth.autoSwitchLoadFailed": "アカウントの自動切り替え設定を読み込めませんでした。",
+  "codexAuth.autoSwitch": "使用量ベースのプロアクティブ切り替え",
+  "codexAuth.autoSwitchQuotaDesc": "クォータ: 使用率が {threshold}% 以上になると、既に紐付いたタスクを含む次のリクエストが、使用率の低い適格アカウントへ移る場合があります。Go/Free は 30 日枠のみを使用します。",
+  "codexAuth.autoSwitchQuotaOffDesc": "使用量ベースのプロアクティブ切り替えはオフです。新規/未紐付けタスクの割り当てと障害回復は引き続き適用されます。",
+  "codexAuth.autoSwitchRoundRobinDesc": "ラウンドロビン割り当てはこのしきい値を使用せず、新規/未紐付けタスクを引き続きローテーションします。",
+  "codexAuth.autoSwitchFillFirstDesc": "フィルファースト: {threshold}% は新規/未紐付けタスクの使い切り基準です。正常な紐付け済みタスクはアカウントを維持します。",
+  "codexAuth.autoSwitchFillFirstOffDesc": "フィルファーストには新規/未紐付けタスクの使用量基準がありません。クールダウン、再認証、障害回復では引き続きルーティングが変わる場合があります。",
+  "codexAuth.failureRecoveryNote": "障害回復は別です。出力前の 429/402 拒否、クールダウン、再認証、除外、または設定済みの一時障害フェイルオーバーにより、別の適格アカウントが選ばれる場合があります。",
+  "codexAuth.autoSwitchThreshold": "使用量しきい値",
+  "codexAuth.autoSwitchThresholdAria": "使用量しきい値（パーセント）",
+  "codexAuth.autoSwitchThresholdInc": "使用量しきい値を上げる",
+  "codexAuth.autoSwitchThresholdDec": "使用量しきい値を下げる",
+  "codexAuth.autoSwitchLoadFailed": "使用量ベースの切り替え設定を読み込めませんでした。",
   "codexAuth.autoSwitchThresholdInvalid": "1 から 100 までの整数を入力してください",
-  "codexAuth.autoSwitchUpdated": "アカウントの自動切り替え設定を更新しました",
-  "codexAuth.autoSwitchUpdateFailed": "更新を確認できませんでした。最後に確認された値を表示しています。",
+  "codexAuth.autoSwitchUpdated": "使用量ベースのプロアクティブ切り替え設定を更新しました",
+  "codexAuth.autoSwitchUpdateFailed": "使用量ベースの切り替え更新を確認できませんでした。最後に確認された値を表示しています。",
   "anthropicPool.title": "Claude アカウントプール（実験的）",
   "anthropicPool.enabledDesc": "429 時にアカウントをクールダウンしてフェイルオーバーします。新規セッションは 5 時間使用率が {threshold}% 未満のアカウントを優先します。",
   "anthropicPool.disabledDesc": "アクティブな Claude アカウントのみを使用します。実験的ルーティングを受け入れる場合のみ有効にしてください。",
@@ -1140,16 +1144,19 @@ export const ja: Record<TKey, string> = {
   "anthropicPool.off": "オフ",
 
   "accountPool.strategy": "ローテーション戦略",
-  "accountPool.strategyDesc": "新規セッションがプールからアカウントを選ぶ方法です。",
+  "accountPool.strategyDesc": "OpenCodex が新規/未紐付けタスクへアカウントを割り当てる方法です。",
   "accountPool.strategyQuota": "クォータ",
   "accountPool.strategyRoundRobin": "ラウンドロビン",
   "accountPool.strategyFillFirst": "フィルファースト",
-  "accountPool.strategyHint": "新規セッションにのみ適用されます。既存スレッドはアカウント親和性を維持します。",
-  "accountPool.stickyLimit": "ローテーション前の固定成功数",
-  "accountPool.stickyLimitAria": "ローテーション前の固定成功数",
+  "accountPool.strategyHintQuota": "クォータ戦略は使用量しきい値を超えると、既存タスクの次のリクエストも別アカウントへ再紐付けできます。",
+  "accountPool.strategyHintRoundRobin": "ラウンドロビンは有効な紐付けがないタスクだけをローテーションし、使用量しきい値は通常のローテーションを変えません。",
+  "accountPool.strategyHintFillFirst": "フィルファーストはしきい値を未紐付けタスクの使い切り基準として使用し、正常な紐付け済みタスクは親和性を維持します。",
+  "accountPool.unboundDefinition": "新規/未紐付けタスクとは、現在のアカウント紐付けがないリクエストです。既存の表示中タスクも、プロキシまたは親和性のリセット後は未紐付けになる場合があります。",
+  "accountPool.stickyLimit": "ローテーション前の新規/未紐付け割り当て数",
+  "accountPool.stickyLimitAria": "ローテーション前の新規/未紐付け割り当て数",
   "accountPool.stickyLimitInc": "スティッキー上限を上げる",
   "accountPool.stickyLimitDec": "スティッキー上限を下げる",
-  "accountPool.stickyLimitHelp": "次へ進む前に、選んだアカウントをこの回数の成功した新規セッション紐付け分保持します。",
+  "accountPool.stickyLimitHelp": "次へ進む前に、この回数の新規/未紐付けタスクを選択アカウントへ割り当てます。カウンターは上流の成功後ではなく、タスクを紐付けた時点で増えます。",
   "accountPool.stickyLimitInvalid": "1 から 100 までの整数を入力してください",
   "accountPool.strategyLoadFailed": "ローテーション戦略を読み込めませんでした。",
   "accountPool.strategyUpdateFailed": "ローテーション戦略を保存できませんでした。",
diff --git a/gui/src/i18n/ko.ts b/gui/src/i18n/ko.ts
index d5f16aae2..9980a7746 100644
--- a/gui/src/i18n/ko.ts
+++ b/gui/src/i18n/ko.ts
@@ -742,22 +742,26 @@ export const ko: Record<TKey, string> = {
   "codexAuth.poolPreparedToast": "{email} 계정을 풀 모드용으로 준비했습니다",
   "codexAuth.switchTitle": "활성 계정을 변경하시겠습니까?",
   "codexAuth.switchDesc": "기존 세션과 새 세션의 다음 요청부터 적용됩니다. 진행 중인 요청은 기존 계정을 유지합니다.",
-  "codexAuth.cacheWarning": "계정 전환 시 프롬프트 캐시가 초기화됩니다.",
+  "codexAuth.cacheWarning": "계정이 바뀌어도 OpenCodex는 대화 문맥을 재생하지만, 프로바이더 측 프롬프트 캐시는 다시 예열해야 할 수 있습니다.",
   "codexAuth.setAsNext": "계정 선택",
   "codexAuth.cancel": "취소",
   "codexAuth.switchBack": "메인 계정으로 돌아가시겠습니까?",
   "codexAuth.switchBackDesc": "기존 세션과 새 세션의 다음 요청부터 앱 로그인 계정을 사용합니다.",
-  "codexAuth.autoSwitch": "자동 계정 전환",
-  "codexAuth.autoSwitchDesc": "사용량이 {threshold}% 이상이고 사용량이 더 낮은 정상 계정이 있으면 전환합니다. Go/Free는 30일만 봅니다",
-  "codexAuth.autoSwitchOffDesc": "자동 계정 전환이 꺼져 있습니다",
-  "codexAuth.autoSwitchThreshold": "전환 임계값",
-  "codexAuth.autoSwitchThresholdAria": "전환 임계값(퍼센트)",
-  "codexAuth.autoSwitchThresholdInc": "전환 임계값 증가",
-  "codexAuth.autoSwitchThresholdDec": "전환 임계값 감소",
-  "codexAuth.autoSwitchLoadFailed": "자동 계정 전환 설정을 불러오지 못했습니다.",
+  "codexAuth.autoSwitch": "사용량 기반 선제 전환",
+  "codexAuth.autoSwitchQuotaDesc": "할당량: 사용량이 {threshold}% 이상이면 이미 바인딩된 작업을 포함해 다음 요청이 사용량이 더 낮은 적격 계정으로 이동할 수 있습니다. Go/Free는 30일만 봅니다.",
+  "codexAuth.autoSwitchQuotaOffDesc": "사용량 기반 선제 전환이 꺼져 있습니다. 새 작업/바인딩 없는 작업 배정과 실패 복구는 계속 적용됩니다.",
+  "codexAuth.autoSwitchRoundRobinDesc": "라운드로빈 배정은 이 임계값을 사용하지 않으며, 바인딩 없는 새 작업을 계속 순환합니다.",
+  "codexAuth.autoSwitchFillFirstDesc": "필 퍼스트: {threshold}%는 새 작업/바인딩 없는 작업의 소진 기준이며, 정상적인 바인딩 작업은 계정을 유지합니다.",
+  "codexAuth.autoSwitchFillFirstOffDesc": "필 퍼스트에는 새 작업/바인딩 없는 작업의 사용량 소진 기준이 없습니다. 쿨다운, 재인증, 실패 복구는 여전히 라우팅을 바꿀 수 있습니다.",
+  "codexAuth.failureRecoveryNote": "실패 복구는 별도입니다. 출력 전 429/402 거절, 쿨다운, 재인증, 제외 또는 설정된 일시적 장애 조치로 다른 적격 계정이 선택될 수 있습니다.",
+  "codexAuth.autoSwitchThreshold": "사용량 임계값",
+  "codexAuth.autoSwitchThresholdAria": "사용량 임계값(퍼센트)",
+  "codexAuth.autoSwitchThresholdInc": "사용량 임계값 증가",
+  "codexAuth.autoSwitchThresholdDec": "사용량 임계값 감소",
+  "codexAuth.autoSwitchLoadFailed": "사용량 기반 전환 설정을 불러오지 못했습니다.",
   "codexAuth.autoSwitchThresholdInvalid": "1~100 사이의 정수를 입력하세요",
-  "codexAuth.autoSwitchUpdated": "자동 계정 전환 설정을 저장했습니다",
-  "codexAuth.autoSwitchUpdateFailed": "자동 계정 전환 설정 변경을 확인하지 못했습니다. 마지막으로 확인된 값을 표시합니다.",
+  "codexAuth.autoSwitchUpdated": "사용량 기반 선제 전환 설정을 저장했습니다",
+  "codexAuth.autoSwitchUpdateFailed": "사용량 기반 전환 설정 변경을 확인하지 못했습니다. 마지막으로 확인된 값을 표시합니다.",
   "anthropicPool.title": "Claude 계정 풀(실험적)",
   "anthropicPool.enabledDesc": "429 시 계정을 쿨다운하고 장애 조치합니다. 새 세션은 5시간 사용량이 {threshold}% 미만인 계정을 우선합니다.",
   "anthropicPool.disabledDesc": "활성 Claude 계정만 사용합니다. 실험적 라우팅을 감수할 때만 켜세요.",
@@ -773,16 +777,19 @@ export const ko: Record<TKey, string> = {
   "anthropicPool.off": "꺼짐",
 
   "accountPool.strategy": "로테이션 전략",
-  "accountPool.strategyDesc": "새 세션이 풀에서 계정을 고르는 방식입니다.",
+  "accountPool.strategyDesc": "OpenCodex가 새 작업/바인딩 없는 작업에 계정을 배정하는 방식입니다.",
   "accountPool.strategyQuota": "할당량",
   "accountPool.strategyRoundRobin": "라운드로빈",
   "accountPool.strategyFillFirst": "필 퍼스트",
-  "accountPool.strategyHint": "새 세션에만 적용됩니다. 기존 스레드는 계정 어피니티를 유지합니다.",
-  "accountPool.stickyLimit": "회전 전 sticky 성공 횟수",
-  "accountPool.stickyLimitAria": "회전 전 sticky 성공 횟수",
+  "accountPool.strategyHintQuota": "할당량 전략은 사용량 임계값을 넘으면 기존 작업의 다음 요청도 다른 계정에 다시 바인딩할 수 있습니다.",
+  "accountPool.strategyHintRoundRobin": "라운드로빈은 현재 바인딩이 없는 작업만 순환하며, 사용량 임계값은 기본 순환에 영향을 주지 않습니다.",
+  "accountPool.strategyHintFillFirst": "필 퍼스트는 임계값을 바인딩 없는 작업의 소진 기준으로 사용하며, 정상적인 바인딩 작업은 어피니티를 유지합니다.",
+  "accountPool.unboundDefinition": "새 작업/바인딩 없는 작업은 현재 계정 바인딩이 없는 요청입니다. 기존에 보이던 작업도 프록시나 어피니티 상태가 초기화되면 바인딩이 없어질 수 있습니다.",
+  "accountPool.stickyLimit": "회전 전 새 작업/바인딩 없는 작업 배정 횟수",
+  "accountPool.stickyLimitAria": "회전 전 새 작업/바인딩 없는 작업 배정 횟수",
   "accountPool.stickyLimitInc": "스티키 한도 증가",
   "accountPool.stickyLimitDec": "스티키 한도 감소",
-  "accountPool.stickyLimitHelp": "다음으로 진행하기 전에 선택된 계정을 이 횟수의 성공한 새 세션 바인딩 동안 유지합니다.",
+  "accountPool.stickyLimitHelp": "다음 계정으로 넘어가기 전에 이 횟수의 새 작업/바인딩 없는 작업을 선택 계정에 배정합니다. 카운터는 업스트림 성공 후가 아니라 작업을 바인딩할 때 증가합니다.",
   "accountPool.stickyLimitInvalid": "1에서 100 사이의 정수를 입력하세요",
   "accountPool.strategyLoadFailed": "로테이션 전략을 불러오지 못했습니다.",
   "accountPool.strategyUpdateFailed": "로테이션 전략을 저장하지 못했습니다.",
diff --git a/gui/src/i18n/ru.ts b/gui/src/i18n/ru.ts
index a0bf4eb01..cb88d795b 100644
--- a/gui/src/i18n/ru.ts
+++ b/gui/src/i18n/ru.ts
@@ -1151,22 +1151,26 @@ export const ru: Record<TKey, string> = {
   "codexAuth.poolPreparedToast": "{email} подготовлен для режима пула",
   "codexAuth.switchTitle": "Сменить активный аккаунт?",
   "codexAuth.switchDesc": "Изменение применяется к следующему запросу существующих и новых сессий Codex. Выполняющиеся запросы сохраняют прежний аккаунт.",
-  "codexAuth.cacheWarning": "Кэш промптов сбрасывается при смене аккаунта. Новая сессия начнётся с пустым кэшем.",
+  "codexAuth.cacheWarning": "После любой смены аккаунта OpenCodex воспроизводит контекст разговора, но кэш промптов на стороне провайдера может быть холодным.",
   "codexAuth.setAsNext": "Выбрать аккаунт",
   "codexAuth.cancel": "Отмена",
   "codexAuth.switchBack": "Вернуться на основной аккаунт?",
   "codexAuth.switchBackDesc": "Следующий запрос существующих и новых сессий Codex будет использовать аккаунт входа через приложение.",
-  "codexAuth.autoSwitch": "Автоматическое переключение аккаунтов",
-  "codexAuth.autoSwitchDesc": "Переключает при использовании {threshold}% или выше, если доступен аккаунт с меньшим использованием; тарифы Go/Free используют только окно 30 дней",
-  "codexAuth.autoSwitchOffDesc": "Автоматическое переключение аккаунтов выключено",
-  "codexAuth.autoSwitchThreshold": "Порог переключения",
-  "codexAuth.autoSwitchThresholdAria": "Порог переключения в процентах",
-  "codexAuth.autoSwitchThresholdInc": "Увеличить порог переключения",
-  "codexAuth.autoSwitchThresholdDec": "Уменьшить порог переключения",
-  "codexAuth.autoSwitchLoadFailed": "Не удалось загрузить настройку автоматического переключения аккаунтов.",
+  "codexAuth.autoSwitch": "Проактивное переключение по использованию",
+  "codexAuth.autoSwitchQuotaDesc": "Квота: при использовании {threshold}% или выше следующий запрос может перейти на подходящий аккаунт с меньшим использованием, включая уже привязанную задачу; Go/Free используют только 30 дней.",
+  "codexAuth.autoSwitchQuotaOffDesc": "Проактивное переключение по использованию выключено. Назначение новых/непривязанных задач и восстановление после сбоев остаются активными.",
+  "codexAuth.autoSwitchRoundRobinDesc": "Round-robin не использует этот порог и продолжает ротировать новые/непривязанные задачи.",
+  "codexAuth.autoSwitchFillFirstDesc": "Fill-first: {threshold}% — порог исчерпания для новых/непривязанных задач; здоровые привязанные задачи сохраняют аккаунт.",
+  "codexAuth.autoSwitchFillFirstOffDesc": "У fill-first нет порога использования для новых/непривязанных задач; cooldown, повторная аутентификация и восстановление после сбоев всё ещё могут менять маршрутизацию.",
+  "codexAuth.failureRecoveryNote": "Восстановление после сбоев выполняется отдельно: отказ 429/402 до вывода, cooldown, повторная аутентификация, исключение или настроенный failover могут выбрать другой подходящий аккаунт.",
+  "codexAuth.autoSwitchThreshold": "Порог использования",
+  "codexAuth.autoSwitchThresholdAria": "Порог использования в процентах",
+  "codexAuth.autoSwitchThresholdInc": "Увеличить порог использования",
+  "codexAuth.autoSwitchThresholdDec": "Уменьшить порог использования",
+  "codexAuth.autoSwitchLoadFailed": "Не удалось загрузить настройку переключения по использованию.",
   "codexAuth.autoSwitchThresholdInvalid": "Введите целое число от 1 до 100",
-  "codexAuth.autoSwitchUpdated": "Настройки автоматического переключения обновлены",
-  "codexAuth.autoSwitchUpdateFailed": "Не удалось подтвердить обновление. Показано последнее подтверждённое значение.",
+  "codexAuth.autoSwitchUpdated": "Проактивное переключение по использованию обновлено",
+  "codexAuth.autoSwitchUpdateFailed": "Не удалось подтвердить обновление переключения по использованию. Показано последнее подтверждённое значение.",
   "anthropicPool.title": "Пул аккаунтов Claude (экспериментально)",
   "anthropicPool.enabledDesc": "При 429 аккаунт охлаждается и выполняется переключение. Новые сессии предпочитают использование ниже {threshold}% (полоса 5 часов).",
   "anthropicPool.disabledDesc": "Используется только активный аккаунт Claude. Включайте только если принимаете экспериментальную маршрутизацию.",
@@ -1182,16 +1186,19 @@ export const ru: Record<TKey, string> = {
   "anthropicPool.off": "Выкл",
 
   "accountPool.strategy": "Стратегия ротации",
-  "accountPool.strategyDesc": "Как новые сессии выбирают аккаунт из пула.",
+  "accountPool.strategyDesc": "Как OpenCodex назначает аккаунт новой/непривязанной задаче.",
   "accountPool.strategyQuota": "Квота",
   "accountPool.strategyRoundRobin": "Round-robin",
   "accountPool.strategyFillFirst": "Fill-first",
-  "accountPool.strategyHint": "Применяется только к новым сессиям; существующие треды сохраняют привязку к аккаунту.",
-  "accountPool.stickyLimit": "Успешных запросов до ротации",
-  "accountPool.stickyLimitAria": "Успешных запросов до ротации",
+  "accountPool.strategyHintQuota": "Quota может перепривязать существующую задачу при следующем запросе после превышения порога использования.",
+  "accountPool.strategyHintRoundRobin": "Round-robin ротирует только задачи без действующей привязки; порог использования не меняет обычную ротацию.",
+  "accountPool.strategyHintFillFirst": "Fill-first использует порог как точку исчерпания для непривязанных задач; здоровые привязанные задачи сохраняют affinity.",
+  "accountPool.unboundDefinition": "Новая/непривязанная задача — запрос без текущей привязки к аккаунту; видимая существующая задача может стать непривязанной после сброса прокси или affinity.",
+  "accountPool.stickyLimit": "Назначений новых/непривязанных задач до ротации",
+  "accountPool.stickyLimitAria": "Назначений новых/непривязанных задач до ротации",
   "accountPool.stickyLimitInc": "Увеличить sticky-лимит",
   "accountPool.stickyLimitDec": "Уменьшить sticky-лимит",
-  "accountPool.stickyLimitHelp": "Удерживать выбранный аккаунт на указанное число успешных привязок новых сессий, прежде чем перейти дальше.",
+  "accountPool.stickyLimitHelp": "Назначить выбранному аккаунту столько новых/непривязанных задач перед переходом дальше; счётчик растёт при привязке задачи, а не после успеха upstream.",
   "accountPool.stickyLimitInvalid": "Введите целое число от 1 до 100",
   "accountPool.strategyLoadFailed": "Не удалось загрузить стратегию ротации.",
   "accountPool.strategyUpdateFailed": "Не удалось сохранить стратегию ротации.",
diff --git a/gui/src/i18n/zh.ts b/gui/src/i18n/zh.ts
index 03e48ddc4..736465e37 100644
--- a/gui/src/i18n/zh.ts
+++ b/gui/src/i18n/zh.ts
@@ -735,22 +735,26 @@ export const zh: Record<TKey, string> = {
   "codexAuth.poolPreparedToast": "已为账户池模式准备 {email}",
   "codexAuth.switchTitle": "切换活跃账号？",
   "codexAuth.switchDesc": "从现有和新 Codex 会话的下一次请求开始生效。进行中的请求保留原账号。",
-  "codexAuth.cacheWarning": "切换账号会重置提示缓存。新会话从空缓存开始。",
+  "codexAuth.cacheWarning": "账号变化后 OpenCodex 会重放对话上下文，但提供商侧的提示缓存可能需要重新预热。",
   "codexAuth.setAsNext": "选择账号",
   "codexAuth.cancel": "取消",
   "codexAuth.switchBack": "切换回主账号？",
   "codexAuth.switchBackDesc": "现有和新 Codex 会话的下一次请求将使用应用登录账号。",
-  "codexAuth.autoSwitch": "自动切换账号",
-  "codexAuth.autoSwitchDesc": "使用率达到或超过 {threshold}% 且存在使用率更低的可用账号时切换；Go/Free 仅使用 30 天窗口",
-  "codexAuth.autoSwitchOffDesc": "自动切换账号已关闭",
-  "codexAuth.autoSwitchThreshold": "切换阈值",
-  "codexAuth.autoSwitchThresholdAria": "切换阈值（百分比）",
-  "codexAuth.autoSwitchThresholdInc": "提高切换阈值",
-  "codexAuth.autoSwitchThresholdDec": "降低切换阈值",
-  "codexAuth.autoSwitchLoadFailed": "无法加载自动切换账号设置。",
+  "codexAuth.autoSwitch": "基于用量的主动切换",
+  "codexAuth.autoSwitchQuotaDesc": "配额：使用率达到或超过 {threshold}% 时，包括已绑定任务在内的下一次请求可能转到用量更低的合格账号；Go/Free 仅使用 30 天窗口。",
+  "codexAuth.autoSwitchQuotaOffDesc": "基于用量的主动切换已关闭。新建/未绑定任务分配和故障恢复仍然生效。",
+  "codexAuth.autoSwitchRoundRobinDesc": "轮询分配不使用此阈值，并会继续轮换新建/未绑定任务。",
+  "codexAuth.autoSwitchFillFirstDesc": "填满优先：{threshold}% 是新建/未绑定任务的耗尽点；健康的已绑定任务继续使用原账号。",
+  "codexAuth.autoSwitchFillFirstOffDesc": "填满优先没有新建/未绑定任务的用量耗尽点；冷却、重新认证和故障恢复仍可能改变路由。",
+  "codexAuth.failureRecoveryNote": "故障恢复是独立机制：输出前的 429/402 拒绝、冷却、重新认证、排除或已配置的瞬时故障转移可能选择另一个合格账号。",
+  "codexAuth.autoSwitchThreshold": "用量阈值",
+  "codexAuth.autoSwitchThresholdAria": "用量阈值（百分比）",
+  "codexAuth.autoSwitchThresholdInc": "提高用量阈值",
+  "codexAuth.autoSwitchThresholdDec": "降低用量阈值",
+  "codexAuth.autoSwitchLoadFailed": "无法加载基于用量的切换设置。",
   "codexAuth.autoSwitchThresholdInvalid": "请输入 1 到 100 之间的整数",
-  "codexAuth.autoSwitchUpdated": "自动切换账号设置已更新",
-  "codexAuth.autoSwitchUpdateFailed": "无法确认更新。当前显示最后一次确认的值。",
+  "codexAuth.autoSwitchUpdated": "基于用量的主动切换设置已更新",
+  "codexAuth.autoSwitchUpdateFailed": "无法确认基于用量的切换更新。当前显示最后一次确认的值。",
   "anthropicPool.title": "Claude 账户池（实验性）",
   "anthropicPool.enabledDesc": "遇到 429 时冷却该账户并故障转移。新会话优先使用 5 小时用量低于 {threshold}% 的账户。",
   "anthropicPool.disabledDesc": "仅使用当前活跃的 Claude 账户。仅在接受实验性路由时启用。",
@@ -766,16 +770,19 @@ export const zh: Record<TKey, string> = {
   "anthropicPool.off": "关",
 
   "accountPool.strategy": "轮换策略",
-  "accountPool.strategyDesc": "新会话如何从账号池中选择账号。",
+  "accountPool.strategyDesc": "OpenCodex 如何为新建/未绑定任务分配账号。",
   "accountPool.strategyQuota": "配额",
   "accountPool.strategyRoundRobin": "轮询",
   "accountPool.strategyFillFirst": "填满优先",
-  "accountPool.strategyHint": "仅适用于新会话；现有线程保持账号亲和性。",
-  "accountPool.stickyLimit": "轮换前的粘性成功次数",
-  "accountPool.stickyLimitAria": "轮换前的粘性成功次数",
+  "accountPool.strategyHintQuota": "配额策略在超过用量阈值后，也可以在现有任务的下一次请求中重新绑定账号。",
+  "accountPool.strategyHintRoundRobin": "轮询只轮换没有有效绑定的任务；用量阈值不会改变正常轮换。",
+  "accountPool.strategyHintFillFirst": "填满优先把阈值用作未绑定任务的耗尽点；健康的已绑定任务保持亲和性。",
+  "accountPool.unboundDefinition": "新建/未绑定任务是当前没有账号绑定的请求；已有的可见任务在代理或亲和性重置后也可能变为未绑定。",
+  "accountPool.stickyLimit": "轮换前的新建/未绑定任务分配数",
+  "accountPool.stickyLimitAria": "轮换前的新建/未绑定任务分配数",
   "accountPool.stickyLimitInc": "提高粘性上限",
   "accountPool.stickyLimitDec": "降低粘性上限",
-  "accountPool.stickyLimitHelp": "在推进到下一个账号之前，将所选账号保留这么多次成功的新会话绑定。",
+  "accountPool.stickyLimitHelp": "在推进到下一个账号之前，为所选账号分配这么多次新建/未绑定任务；计数在任务绑定时增加，而不是在上游成功后增加。",
   "accountPool.stickyLimitInvalid": "请输入 1 到 100 之间的整数",
   "accountPool.strategyLoadFailed": "无法加载轮换策略。",
   "accountPool.strategyUpdateFailed": "无法保存轮换策略。",
diff --git a/gui/tests/account-pool-strategy.test.tsx b/gui/tests/account-pool-strategy.test.tsx
index 4df932a1a..856c44af8 100644
--- a/gui/tests/account-pool-strategy.test.tsx
+++ b/gui/tests/account-pool-strategy.test.tsx
@@ -158,8 +158,8 @@ describe("AccountPoolStrategyControls", () => {
     // Custom Select only paints the active label until opened (sidecar DNA).
     expect(quota).toContain("Quota");
     expect(quota).toContain("select-trigger");
-    expect(quota).toContain("Applies to new sessions only");
-    expect(quota).not.toContain("Sticky successes before rotate");
+    expect(quota).toContain("Quota can also rebind an existing task on its next request after the usage threshold is crossed.");
+    expect(quota).not.toContain("New/unbound assignments before rotate");
 
     const rr = renderToStaticMarkup(
       <LanguageProvider>
@@ -173,7 +173,7 @@ describe("AccountPoolStrategyControls", () => {
       </LanguageProvider>,
     );
     expect(rr).toContain("Round-robin");
-    expect(rr).toContain("Sticky successes before rotate");
+    expect(rr).toContain("New/unbound assignments before rotate");
     expect(rr).toContain('value="2"');
   });
 
@@ -214,8 +214,8 @@ describe("AccountPoolStrategyControls", () => {
         />
       </LanguageProvider>,
     );
-    expect(markup).toContain("How new sessions pick an account from the pool.");
-    expect(markup).toContain("Applies to new sessions only");
+    expect(markup).toContain("How OpenCodex assigns an account to a new/unbound task.");
+    expect(markup).toContain("New/unbound task means a request with no current account binding");
     expect((markup.match(/class="desc"/g) ?? []).length).toBeGreaterThanOrEqual(2);
   });
 
@@ -238,11 +238,11 @@ describe("AccountPoolStrategyControls", () => {
         />
       </LanguageProvider>,
     );
-    expect(markup).toContain("How new sessions pick an account from the pool.");
-    expect(markup).toContain("Applies to new sessions only");
+    expect(markup).toContain("How OpenCodex assigns an account to a new/unbound task.");
+    expect(markup).toContain("Round-robin rotates only tasks without a live binding");
     expect(markup).toContain('id="anthropic-pool-strategy"');
     // Round-robin adds its own row, and the sticky help text is a desc rather than a card-sub.
-    expect(markup).toContain("Sticky successes before rotate");
+    expect(markup).toContain("New/unbound assignments before rotate");
     expect((markup.match(/class="setting-row"/g) ?? []).length).toBe(2);
   });
 });
@@ -368,7 +368,7 @@ describe("CodexPoolStrategySetting optimistic strategy select", () => {
 
     expect(strategyTrigger(host).textContent).toContain("Round-robin");
     expect(strategyTrigger(host).disabled).toBe(false);
-    expect(host.textContent).toContain("Sticky successes before rotate");
+    expect(host.textContent).toContain("New/unbound assignments before rotate");
   });
 
   test("rolls back strategy when save fails", async () => {
diff --git a/gui/tests/codex-account-auto-switch.test.tsx b/gui/tests/codex-account-auto-switch.test.tsx
index cc4548c75..92e9c357b 100644
--- a/gui/tests/codex-account-auto-switch.test.tsx
+++ b/gui/tests/codex-account-auto-switch.test.tsx
@@ -11,6 +11,8 @@ import {
   type AutoSwitchFetch,
 } from "../src/codex-auto-switch";
 import { CodexAutoSwitchSetting as AutoSwitchSetting } from "../src/components/CodexAutoSwitchSetting";
+import AccountPoolStrategyControls from "../src/components/AccountPoolStrategyControls";
+import type { AccountPoolStrategy } from "../src/account-pool-strategy";
 import { LanguageProvider } from "../src/i18n/provider";
 
 let previousLanguage: unknown;
@@ -36,12 +38,14 @@ function renderSetting(
   saving = false,
   loadError = false,
   feedback: { tone: "ok" | "err"; message: string } | null = null,
+  strategy: AccountPoolStrategy = "quota",
 ): string {
   return renderToStaticMarkup(
     <LanguageProvider>
       <AutoSwitchSetting
         threshold={threshold}
         draft={draft}
+        strategy={strategy}
         saving={saving}
         loadError={loadError}
         feedback={feedback}
@@ -113,8 +117,9 @@ describe("Codex account auto-switch threshold", () => {
     expect(html).toContain('value="95"');
     expect(html).toContain('min="1"');
     expect(html).toContain('max="100"');
-    expect(html).toContain('aria-label="Switch threshold, percent"');
+    expect(html).toContain('aria-label="Usage threshold, percent"');
     expect(html).toContain("95% usage or above");
+    expect(html).toContain("including an already-bound task");
     expect(html).toContain('aria-pressed="true"');
   });
 
@@ -128,11 +133,49 @@ describe("Codex account auto-switch threshold", () => {
 
   test("renders an explicit off state without an editable threshold", () => {
     const html = renderSetting(0, "80");
-    expect(html).toContain("Automatic account switching is off");
+    expect(html).toContain("Usage-based proactive switching is off");
     expect(html).toContain('aria-pressed="false"');
     expect(html).not.toContain('type="number"');
   });
 
+  test("explains threshold semantics by strategy and separates recovery from cache continuity", () => {
+    const quota = renderSetting(80, "80", false, false, null, "quota");
+    const roundRobin = renderSetting(80, "80", false, false, null, "round-robin");
+    const fillFirst = renderSetting(80, "80", false, false, null, "fill-first");
+
+    expect(quota).toContain("including an already-bound task");
+    expect(roundRobin).toContain("does not use this threshold");
+    expect(fillFirst).toContain("drain point for new/unbound tasks");
+    for (const html of [quota, roundRobin, fillFirst]) {
+      expect(html).toContain("Failure recovery is separate");
+      expect(html).toContain("provider-side prompt cache may be cold");
+    }
+  });
+
+  test("defines unbound assignment and describes each rotation strategy accurately", () => {
+    const renderStrategy = (strategy: AccountPoolStrategy) => renderToStaticMarkup(
+      <LanguageProvider>
+        <AccountPoolStrategyControls
+          strategy={strategy}
+          stickyDraft="2"
+          onStrategyChange={() => {}}
+          onStickyDraftChange={() => {}}
+          onStickyCommit={() => {}}
+        />
+      </LanguageProvider>,
+    );
+
+    expect(renderStrategy("quota")).toContain("can also rebind an existing task");
+    expect(renderStrategy("round-robin")).toContain("usage threshold does not change normal rotation");
+    const fillFirst = renderStrategy("fill-first");
+    expect(fillFirst).toContain("healthy bound tasks keep affinity");
+    expect(fillFirst).toContain("existing visible task can become unbound");
+
+    const roundRobin = renderStrategy("round-robin");
+    expect(roundRobin).toContain("New/unbound assignments before rotate");
+    expect(roundRobin).toContain("not after upstream success");
+  });
+
   test("paints controls immediately with the default threshold (no loading placeholder)", () => {
     const html = renderSetting(DEFAULT_AUTO_SWITCH_THRESHOLD);
     expect(html).toContain('type="number"');
@@ -169,7 +212,7 @@ describe("Codex account auto-switch threshold", () => {
 
   test("surfaces load failure without hiding the toggle", () => {
     const failed = renderSetting(DEFAULT_AUTO_SWITCH_THRESHOLD, String(DEFAULT_AUTO_SWITCH_THRESHOLD), false, true);
-    expect(failed).toContain("Automatic switching setting could not be loaded.");
+    expect(failed).toContain("Usage-based switching setting could not be loaded.");
     expect(failed).toContain("Retry");
     expect(failed).toContain('aria-pressed="true"');
   });
diff --git a/gui/tests/codex-auto-switch-controller.test.tsx b/gui/tests/codex-auto-switch-controller.test.tsx
index d4afce5ee..357e0dc29 100644
--- a/gui/tests/codex-auto-switch-controller.test.tsx
+++ b/gui/tests/codex-auto-switch-controller.test.tsx
@@ -107,7 +107,12 @@ afterEach(async () => {
 
 async function mountHarness(): Promise<Harness> {
   const activeResponses: Array<Promise<Response> | Response> = [
-    Response.json({ activeCodexAccountId: null, autoSwitchThreshold: 80 }),
+    Response.json({
+      activeCodexAccountId: null,
+      autoSwitchThreshold: 80,
+      accountPoolStrategy: "quota",
+      accountPoolStickyLimit: 1,
+    }),
   ];
   const putResponses: Array<Promise<Response> | Response> = [];
   const writes: number[] = [];
@@ -179,14 +184,14 @@ async function mountHarness(): Promise<Harness> {
   });
   await act(flush);
 
-  const input = container.querySelector<HTMLInputElement>('input[aria-label="Switch threshold, percent"]');
+  const input = container.querySelector<HTMLInputElement>('input[aria-label="Usage threshold, percent"]');
   expect(input).not.toBeNull();
   expect(input?.value).toBe("80");
   expect(input?.readOnly).toBe(false);
   expect(refreshCallback).not.toBeNull();
 
   const currentInput = (): HTMLInputElement | null => (
-    container.querySelector<HTMLInputElement>('input[aria-label="Switch threshold, percent"]')
+    container.querySelector<HTMLInputElement>('input[aria-label="Usage threshold, percent"]')
   );
   const currentToggle = (): HTMLButtonElement => {
     const toggle = container.querySelector<HTMLButtonElement>("button.toggle[aria-pressed]");
@@ -216,6 +221,55 @@ async function mountHarness(): Promise<Harness> {
 }
 
 describe("Codex auto-switch controller interactions", () => {
+  test("defers strategy-specific switching controls until the persisted strategy resolves", async () => {
+    const active = deferred<Response>();
+    let activeReads = 0;
+    Object.defineProperty(globalThis, "fetch", {
+      configurable: true,
+      value: async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+        if (url.endsWith("/api/codex-auth/accounts") && method === "GET") {
+          return Response.json({ accounts: [] });
+        }
+        if (url.endsWith("/api/codex-auth/active") && method === "GET") {
+          activeReads += 1;
+          return (await active.promise).clone();
+        }
+        throw new Error(`unexpected fetch: ${method} ${url}`);
+      },
+    });
+
+    const container = document.createElement("div");
+    document.body.append(container);
+    const { createRoot } = await import("react-dom/client");
+    mountedRoot = createRoot(container);
+    await act(async () => {
+      mountedRoot?.render(
+        <LanguageProvider>
+          <CodexAccountPool apiBase="http://localhost" />
+        </LanguageProvider>,
+      );
+      await flush();
+    });
+
+    expect(activeReads).toBeGreaterThan(0);
+    expect(container.querySelector(".codex-auto-switch-card")).toBeNull();
+
+    active.resolve(Response.json({
+      activeCodexAccountId: null,
+      autoSwitchThreshold: 80,
+      accountPoolStrategy: "round-robin",
+      accountPoolStickyLimit: 1,
+    }));
+    await act(flush);
+
+    const card = container.querySelector<HTMLElement>(".codex-auto-switch-card");
+    expect(card).not.toBeNull();
+    expect(card?.textContent).toContain("Round-robin");
+    expect(card?.querySelector<HTMLInputElement>('input[aria-label="Usage threshold, percent"]')?.readOnly).toBe(false);
+  });
+
   test("blocks writes while /active is still pending", async () => {
     const active = deferred<Response>();
     const activeResponses: Array<Promise<Response> | Response> = [active.promise];
@@ -284,13 +338,7 @@ describe("Codex auto-switch controller interactions", () => {
     });
 
     const toggle = container.querySelector<HTMLButtonElement>("button.toggle[aria-pressed]");
-    expect(toggle).not.toBeNull();
-    expect(toggle?.disabled).toBe(true);
-
-    await act(async () => {
-      toggle?.click();
-      await flush();
-    });
+    expect(toggle).toBeNull();
     expect(writes).toEqual([]);
 
     await act(async () => {
@@ -305,7 +353,7 @@ describe("Codex auto-switch controller interactions", () => {
 
     const readyToggle = container.querySelector<HTMLButtonElement>("button.toggle[aria-pressed]");
     expect(readyToggle?.disabled).toBe(false);
-    expect(container.querySelector<HTMLInputElement>('input[aria-label="Switch threshold, percent"]')?.value).toBe("55");
+    expect(container.querySelector<HTMLInputElement>('input[aria-label="Usage threshold, percent"]')?.value).toBe("55");
     expect(writes).toEqual([]);
     expect(refreshCallback).not.toBeNull();
   });
@@ -418,7 +466,7 @@ describe("Codex auto-switch controller interactions", () => {
     expect(harness.writes).toEqual([0]);
     expect(harness.currentInput()).toBeNull();
     expect(harness.currentToggle().getAttribute("aria-pressed")).toBe("false");
-    expect(harness.container.textContent).toContain("Automatic account switching is off");
+    expect(harness.container.textContent).toContain("Usage-based proactive switching is off");
     expect(harness.container.querySelector('[role="alert"]')).toBeNull();
 
     await act(async () => {
@@ -455,7 +503,7 @@ describe("Codex auto-switch controller interactions", () => {
     expect(harness.writes).toEqual([0]);
     expect(harness.currentInput()).toBeNull();
     expect(harness.currentToggle().getAttribute("aria-pressed")).toBe("false");
-    expect(harness.container.textContent).toContain("Automatic account switching is off");
+    expect(harness.container.textContent).toContain("Usage-based proactive switching is off");
     expect(harness.container.querySelector('[role="alert"]')).toBeNull();
 
     await act(async () => {
diff --git a/src/cli/account.ts b/src/cli/account.ts
index 253cf6b3a..a237c4c32 100644
--- a/src/cli/account.ts
+++ b/src/cli/account.ts
@@ -243,11 +243,9 @@ async function cmdUse(rest: string[], deps: AccountDeps): Promise<number> {
   if (wantsJson) console.log(JSON.stringify({ ok: true, provider: name, type: c.type, activeId }, null, 2));
   else console.log(`${name}: active ${c.type === "api-key" ? "key" : "account"} is now ${displayId(activeId)}`);
   if (c.type === "codex") {
-    console.error("Applies to new Codex sessions; running threads keep their current account.");
-    const active = await apiJson(deps, baseUrl, "GET", "/api/codex-auth/active");
-    if (active.status === 200 && typeof active.json.autoSwitchThreshold === "number" && active.json.autoSwitchThreshold > 0) {
-      console.error(`Note: auto-switch (threshold ${active.json.autoSwitchThreshold}%) may override this pin.`);
-    }
+    console.error("Applies to the next request after clearing existing pool affinity; in-flight requests keep their captured account.");
+    console.error("Note: pool strategy, quota/cooldown/reauthentication state, and failure recovery may later select another eligible account.");
+    console.error("Conversation context is replayed after account changes, but the provider-side prompt cache may be cold.");
   }
   return 0;
 }
diff --git a/src/cli/help.ts b/src/cli/help.ts
index 71850d375..8aefb1373 100644
--- a/src/cli/help.ts
+++ b/src/cli/help.ts
@@ -122,7 +122,7 @@ const helpEntries: Record<string, HelpEntry> = {
       "add-key <provider> [--label <label>]  Add a key read only from piped stdin.",
       "login/reauth/code/cancel  Run browser or manual-code auth from a headless shell.",
       "reset-credits <id|main> [--consume --yes]  Inspect or consume Codex reset credits.",
-      "Codex pool switches apply to new sessions; running threads keep their account.",
+      "Codex pool selection applies to the next request after clearing existing affinity; in-flight requests keep their captured account.",
     ],
   },
   models: {
diff --git a/tests/cli-account.test.ts b/tests/cli-account.test.ts
index b692ddb85..3e17b4b25 100644
--- a/tests/cli-account.test.ts
+++ b/tests/cli-account.test.ts
@@ -580,13 +580,14 @@ describe("ocx account CLI (issue #180 matrix)", () => {
     expect(result.stdout).toContain("needs-reauth");
   });
 
-  test("WP2 regression: use openai main prints next-session and auto-switch override notes", async () => {
+  test("WP2 regression: use openai main explains next-request routing and cache continuity", async () => {
     const result = await run(["use", "openai", "main"]);
 
     expect(result.code).toBe(0);
-    expect(result.stderr).toContain("new Codex sessions");
-    expect(result.stderr).toContain("running threads keep their current account");
-    expect(result.stderr).toContain("auto-switch (threshold 80%) may override this pin");
+    expect(result.stderr).toContain("next request after clearing existing pool affinity");
+    expect(result.stderr).toContain("in-flight requests keep their captured account");
+    expect(result.stderr).toContain("failure recovery may later select another eligible account");
+    expect(result.stderr).toContain("provider-side prompt cache may be cold");
   });
 
   test("WP2 regression: classifyAccount routes a key-overridden OAuth provider to api-key", () => {