feat(accounts): add compact quota row display toggle

app/core/account_priority.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class AccountPriority(str, Enum):
+    GOLD = "gold"
+    SILVER = "silver"
+    BRONZE = "bronze"
+
+
+_PRIORITY_ORDER: dict[AccountPriority, int] = {
+    AccountPriority.GOLD: 0,
+    AccountPriority.SILVER: 1,
+    AccountPriority.BRONZE: 2,
+}
+
+
+def coerce_account_priority(value: str | AccountPriority | None) -> AccountPriority:
+    if isinstance(value, AccountPriority):
+        return value
+    normalized = (value or "").strip().lower()
+    if normalized == AccountPriority.GOLD.value:
+        return AccountPriority.GOLD
+    if normalized == AccountPriority.BRONZE.value:
+        return AccountPriority.BRONZE
+    return AccountPriority.SILVER
+
+
+def account_priority_rank(value: str | AccountPriority | None) -> int:
+    return _PRIORITY_ORDER[coerce_account_priority(value)]

app/core/balancer/logic.py

@@ -5,6 +5,7 @@
 from dataclasses import dataclass
 from typing import Iterable, Literal
 
+from app.core.account_priority import AccountPriority, account_priority_rank
 from app.core.balancer.types import FailureClass, UpstreamError
 from app.core.usage import PLAN_CAPACITY_CREDITS_SECONDARY
 from app.core.utils.retry import backoff_seconds, parse_retry_after
@@ -49,6 +50,7 @@
 class AccountState:
     account_id: str
     status: AccountStatus
+    priority: AccountPriority = AccountPriority.SILVER
     used_percent: float | None = None
     reset_at: float | None = None
     blocked_at: float | None = None
@@ -232,19 +234,21 @@ def _round_robin_sort_key(state: AccountState) -> tuple[float, str]:
     probing = [s for s in available if s.health_tier == HEALTH_TIER_PROBING]
     draining = [s for s in available if s.health_tier == HEALTH_TIER_DRAINING]
     effective_pool = healthy or probing or draining or available
+    top_priority = min(account_priority_rank(state.priority) for state in effective_pool)
+    priority_pool = [state for state in effective_pool if account_priority_rank(state.priority) == top_priority]
 
     if routing_strategy == "round_robin":
-        selected = min(effective_pool, key=_round_robin_sort_key)
+        selected = min(priority_pool, key=_round_robin_sort_key)
     elif routing_strategy == "capacity_weighted":
         candidate_pool = (
-            _prefer_earlier_reset_candidates(effective_pool, current) if prefer_earlier_reset else effective_pool
+            _prefer_earlier_reset_candidates(priority_pool, current) if prefer_earlier_reset else priority_pool
         )
         if deterministic_probe:
             selected = min(candidate_pool, key=_capacity_probe_sort_key)
         else:
             selected = _select_capacity_weighted(candidate_pool)
     else:
-        selected = min(effective_pool, key=_reset_first_sort_key if prefer_earlier_reset else _usage_sort_key)
+        selected = min(priority_pool, key=_reset_first_sort_key if prefer_earlier_reset else _usage_sort_key)
     return SelectionResult(selected, None)
 
 

app/db/alembic/versions/20260503_000000_add_accounts_priority.py

@@ -0,0 +1,60 @@
+"""add priority to accounts
+
+Revision ID: 20260503_000000_add_accounts_priority
+Revises: 20260424_000000_merge_dashboard_session_ttl_and_request_log_heads
+Create Date: 2026-05-03
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260503_000000_add_accounts_priority"
+down_revision = "20260424_000000_merge_dashboard_session_ttl_and_request_log_heads"
+branch_labels = None
+depends_on = None
+
+_ACCOUNT_PRIORITY = sa.Enum(
+    "gold",
+    "silver",
+    "bronze",
+    name="account_priority",
+)
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {column["name"] for column in inspector.get_columns(table_name)}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "accounts")
+    if not columns or "priority" in columns:
+        return
+
+    with op.batch_alter_table("accounts") as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "priority",
+                _ACCOUNT_PRIORITY,
+                nullable=False,
+                server_default=sa.text("'silver'"),
+            )
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "accounts")
+    if "priority" not in columns:
+        return
+
+    with op.batch_alter_table("accounts") as batch_op:
+        batch_op.drop_column("priority")
+
+    _ACCOUNT_PRIORITY.drop(bind, checkfirst=True)

app/db/alembic/versions/20260503_000100_add_dashboard_priorities_enabled.py

@@ -0,0 +1,51 @@
+"""add priorities enabled to dashboard settings
+
+Revision ID: 20260503_000100_add_dashboard_priorities_enabled
+Revises: 20260503_000000_add_accounts_priority
+Create Date: 2026-05-03
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260503_000100_add_dashboard_priorities_enabled"
+down_revision = "20260503_000000_add_accounts_priority"
+branch_labels = None
+depends_on = None
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {column["name"] for column in inspector.get_columns(table_name)}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "dashboard_settings")
+    if not columns or "priorities_enabled" in columns:
+        return
+
+    with op.batch_alter_table("dashboard_settings") as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "priorities_enabled",
+                sa.Boolean(),
+                nullable=False,
+                server_default=sa.text("false"),
+            )
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "dashboard_settings")
+    if "priorities_enabled" not in columns:
+        return
+
+    with op.batch_alter_table("dashboard_settings") as batch_op:
+        batch_op.drop_column("priorities_enabled")

app/db/models.py

@@ -25,6 +25,8 @@
 from sqlalchemy import Enum as SqlEnum
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
 
+from app.core.account_priority import AccountPriority
+
 
 class Base(DeclarativeBase):
     pass
@@ -73,6 +75,17 @@ class Account(Base):
         default=AccountStatus.ACTIVE,
         nullable=False,
     )
+    priority: Mapped[AccountPriority] = mapped_column(
+        SqlEnum(
+            AccountPriority,
+            name="account_priority",
+            validate_strings=True,
+            values_callable=_enum_values,
+        ),
+        default=AccountPriority.SILVER,
+        server_default=text("'silver'"),
+        nullable=False,
+    )
     deactivation_reason: Mapped[str | None] = mapped_column(Text, nullable=True)
     reset_at: Mapped[int | None] = mapped_column(Integer, nullable=True)
     blocked_at: Mapped[int | None] = mapped_column(Integer, nullable=True)
@@ -212,6 +225,7 @@ class DashboardSettings(Base):
     prefer_earlier_reset_accounts: Mapped[bool] = mapped_column(
         Boolean, default=True, server_default=true(), nullable=False
     )
+    priorities_enabled: Mapped[bool] = mapped_column(Boolean, default=False, server_default=false(), nullable=False)
     routing_strategy: Mapped[str] = mapped_column(
         String,
         default="capacity_weighted",

app/modules/accounts/api.py

@@ -11,6 +11,7 @@
     AccountDeleteResponse,
     AccountImportResponse,
     AccountPauseResponse,
+    AccountPriorityUpdateRequest,
     AccountReactivateResponse,
     AccountsResponse,
     AccountTrendsResponse,
@@ -64,6 +65,18 @@ async def import_account(
         raise DashboardConflictError(str(exc), code="duplicate_identity_conflict") from exc
 
 
+@router.patch("/{account_id}/priority", response_model=AccountPauseResponse)
+async def update_account_priority(
+    account_id: str,
+    payload: AccountPriorityUpdateRequest,
+    context: AccountsContext = Depends(get_accounts_context),
+) -> AccountPauseResponse:
+    success = await context.service.update_account_priority(account_id, payload.priority)
+    if not success:
+        raise DashboardNotFoundError("Account not found", code="account_not_found")
+    return AccountPauseResponse(status="updated")
+
+
 @router.post("/{account_id}/reactivate", response_model=AccountReactivateResponse)
 async def reactivate_account(
     account_id: str,

app/modules/accounts/mappers.py

@@ -3,6 +3,7 @@
 from datetime import datetime, timezone
 
 from app.core import usage as usage_core
+from app.core.account_priority import coerce_account_priority
 from app.core.auth import DEFAULT_PLAN, extract_id_token_claims
 from app.core.crypto import TokenEncryptor
 from app.core.plan_types import coerce_account_plan_type
@@ -100,6 +101,7 @@ def _account_to_summary(
         display_name=account.email,
         plan_type=plan_type,
         status=account.status.value,
+        priority=coerce_account_priority(getattr(account, "priority", None)),
         usage=AccountUsage(
             primary_remaining_percent=primary_remaining_percent,
             secondary_remaining_percent=secondary_remaining_percent,

app/modules/accounts/repository.py

@@ -8,6 +8,7 @@
 from sqlalchemy.exc import OperationalError
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.core.account_priority import coerce_account_priority
 from app.db.models import Account, AccountStatus, DashboardSettings, RequestLog, StickySession, UsageHistory
 
 _SETTINGS_ROW_ID = 1
@@ -40,7 +41,7 @@ async def get_by_id(self, account_id: str) -> Account | None:
         return await self._session.get(Account, account_id)
 
     async def list_accounts(self) -> list[Account]:
-        result = await self._session.execute(select(Account).order_by(Account.email))
+        result = await self._session.execute(select(Account).order_by(func.lower(Account.email), Account.id))
         return list(result.scalars().all())
 
     async def list_request_usage_summary_by_account(
@@ -201,6 +202,16 @@ async def update_status_if_current(
         await self._session.commit()
         return result.scalar_one_or_none() is not None
 
+    async def update_priority(self, account_id: str, priority: str) -> bool:
+        result = await self._session.execute(
+            update(Account)
+            .where(Account.id == account_id)
+            .values(priority=coerce_account_priority(priority))
+            .returning(Account.id)
+        )
+        await self._session.commit()
+        return result.scalar_one_or_none() is not None
+
     async def delete(self, account_id: str) -> bool:
         await self._session.execute(delete(UsageHistory).where(UsageHistory.account_id == account_id))
         await self._session.execute(delete(RequestLog).where(RequestLog.account_id == account_id))
@@ -301,6 +312,7 @@ def _apply_account_updates(target: Account, source: Account) -> None:
     target.id_token_encrypted = source.id_token_encrypted
     target.last_refresh = source.last_refresh
     target.status = source.status
+    target.priority = source.priority
     target.deactivation_reason = source.deactivation_reason
     target.reset_at = source.reset_at
     target.blocked_at = source.blocked_at

app/modules/accounts/schemas.py

@@ -5,6 +5,7 @@
 
 from pydantic import Field
 
+from app.core.account_priority import AccountPriority
 from app.modules.shared.schemas import DashboardModel
 
 
@@ -62,6 +63,7 @@ class AccountSummary(DashboardModel):
     display_name: str
     plan_type: str
     status: str
+    priority: AccountPriority = AccountPriority.SILVER
     usage: AccountUsage | None = None
     reset_at_primary: datetime | None = None
     reset_at_secondary: datetime | None = None
@@ -89,6 +91,10 @@ class AccountImportResponse(DashboardModel):
     status: str
 
 
+class AccountPriorityUpdateRequest(DashboardModel):
+    priority: AccountPriority
+
+
 class AccountPauseResponse(DashboardModel):
     status: str
 

app/modules/accounts/service.py

@@ -6,6 +6,7 @@
 
 from pydantic import ValidationError
 
+from app.core.account_priority import AccountPriority, account_priority_rank
 from app.core.auth import (
     DEFAULT_EMAIL,
     DEFAULT_PLAN,
@@ -18,6 +19,7 @@
 from app.core.crypto import TokenEncryptor
 from app.core.plan_types import coerce_account_plan_type
 from app.core.utils.time import naive_utc_to_epoch, to_utc_naive, utcnow
+from app.core.config.settings_cache import get_settings_cache
 from app.db.models import Account, AccountStatus
 from app.modules.accounts.mappers import build_account_summaries, build_account_usage_trends
 from app.modules.accounts.repository import AccountsRepository
@@ -112,14 +114,25 @@ async def list_accounts(self) -> list[AccountSummary]:
         for account_quota_list in additional_quotas_by_account.values():
             account_quota_list.sort(key=lambda quota: quota.display_label or quota.quota_key or quota.limit_name)
 
-        return build_account_summaries(
+        summaries = build_account_summaries(
             accounts=accounts,
             primary_usage=primary_usage,
             secondary_usage=secondary_usage,
             request_usage_by_account=request_usage_by_account,
             additional_quotas_by_account=additional_quotas_by_account,
             encryptor=self._encryptor,
         )
+        settings = await get_settings_cache().get()
+        if getattr(settings, "priorities_enabled", False):
+            return sorted(
+                summaries,
+                key=lambda account: (
+                    account_priority_rank(account.priority),
+                    account.email.lower(),
+                    account.account_id,
+                ),
+            )
+        return summaries
 
     async def get_account_trends(self, account_id: str) -> AccountTrendsResponse | None:
         account = await self._repo.get_by_id(account_id)
@@ -160,6 +173,7 @@ async def import_account(self, raw: bytes) -> AccountImportResponse:
             chatgpt_account_id=raw_account_id,
             email=email,
             plan_type=plan_type,
+            priority=AccountPriority.SILVER,
             access_token_encrypted=self._encryptor.encrypt(auth.tokens.access_token),
             refresh_token_encrypted=self._encryptor.encrypt(auth.tokens.refresh_token),
             id_token_encrypted=self._encryptor.encrypt(auth.tokens.id_token),
@@ -180,6 +194,12 @@ async def import_account(self, raw: bytes) -> AccountImportResponse:
             status=saved.status,
         )
 
+    async def update_account_priority(self, account_id: str, priority: AccountPriority) -> bool:
+        result = await self._repo.update_priority(account_id, priority.value)
+        if result:
+            get_account_selection_cache().invalidate()
+        return result
+
     async def reactivate_account(self, account_id: str) -> bool:
         result = await self._repo.update_status(account_id, AccountStatus.ACTIVE, None, None, blocked_at=None)
         if result: