后台权限管理支持「自定义」角色：按人存 pages_override，可见页逐页勾选并即时生效

admin_user 加 pages_override(可空 JSON)+ Alembic 迁移;role=="custom" 时可见页由这份逐页
勾选决定,否则跟随角色。create/update 收 pages_override(切回普通角色自动清空),_validate_role
放行 custom 哨兵角色。登录/me 下发有效页时优先用 override → 左侧导航直接按勾选生效。
补 4 个用例覆盖建/改/切回/切入,test_admin_roles 全绿。

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

app/admin/repositories/stats.py

@@ -30,17 +30,11 @@ from app.models.user import User
 from app.models.wallet import CoinTransaction, WithdrawOrder
 
 _BEIJING = timezone(timedelta(hours=8))
-REWARD_VIDEO_BIZ_TYPES = ("reward_video", "ad_reward")
+COUPON_REWARD_BIZ_TYPES = ("reward_video", "ad_reward", "coupon", "coupon_reward")
-# 领券/比价奖励金币的真实来源是信息流广告发奖(ad_feed_reward_record,按 feed_scene 分场景);
-# coin_transaction 里只有扁平的 feed_ad_reward、biz_type 不分 coupon/comparison,故这俩桶历史从未
-# 被写入,仅留作未来兜底,实际金额在下方按 feed_scene 汇总 ad_feed_reward_record 得出。reward_video/
-# ad_reward 是激励视频,单独成桶、不再混进领券奖励(历史误并会把激励视频金币双计进领券)。
-COUPON_REWARD_BIZ_TYPES = ("coupon", "coupon_reward")
 COMPARISON_REWARD_BIZ_TYPES = ("comparison", "compare_reward", "comparison_reward")
 EXCLUDED_REWARD_BIZ_TYPES = ("invite_inviter", "invite_invitee", "admin_grant")
 UNCLASSIFIED_FEED_BIZ_TYPES = ("feed_ad_reward",)
 REGULAR_TASK_EXCLUDED_BIZ_TYPES = (
-    *REWARD_VIDEO_BIZ_TYPES,
     *COUPON_REWARD_BIZ_TYPES,
     *COMPARISON_REWARD_BIZ_TYPES,
     *EXCLUDED_REWARD_BIZ_TYPES,
@@ -368,7 +362,7 @@ def dashboard_overview(
     period_reward_video_coin_total = _sum(
         CoinTransaction.amount,
         *period_coin_conds,
-        CoinTransaction.biz_type.in_(REWARD_VIDEO_BIZ_TYPES),
+        CoinTransaction.biz_type.in_(("reward_video", "ad_reward")),
     )
     period_feed_ad_coin_total = _sum(
         CoinTransaction.amount,
@@ -390,29 +384,15 @@ def dashboard_overview(
         *period_coin_conds,
         CoinTransaction.biz_type.like("task_%"),
     )
-    # 领券/比价奖励金币 = biz_type 桶(历史空,兜底)+ 该场景信息流广告实发金币
-    # (ad_feed_reward_record.feed_scene,granted;reward_date 是北京日期串,与 period 同自然日窗口)。
     period_coupon_reward_coin_total = _sum(
         CoinTransaction.amount,
         *period_coin_conds,
         CoinTransaction.biz_type.in_(COUPON_REWARD_BIZ_TYPES),
-    ) + _sum(
-        AdFeedRewardRecord.coin,
-        AdFeedRewardRecord.status == "granted",
-        AdFeedRewardRecord.feed_scene == "coupon",
-        AdFeedRewardRecord.reward_date >= period_from.isoformat(),
-        AdFeedRewardRecord.reward_date <= period_to.isoformat(),
     )
     period_comparison_reward_coin_total = _sum(
         CoinTransaction.amount,
         *period_coin_conds,
         CoinTransaction.biz_type.in_(COMPARISON_REWARD_BIZ_TYPES),
-    ) + _sum(
-        AdFeedRewardRecord.coin,
-        AdFeedRewardRecord.status == "granted",
-        AdFeedRewardRecord.feed_scene == "comparison",
-        AdFeedRewardRecord.reward_date >= period_from.isoformat(),
-        AdFeedRewardRecord.reward_date <= period_to.isoformat(),
     )
     period_regular_task_coin_total = _sum(
         CoinTransaction.amount,
@@ -563,7 +543,7 @@ def dashboard_overview(
             "reward_video_coin_total": _sum(
                 CoinTransaction.amount,
                 CoinTransaction.amount > 0,
-                CoinTransaction.biz_type.in_(REWARD_VIDEO_BIZ_TYPES),
+                CoinTransaction.biz_type.in_(("reward_video", "ad_reward")),
             ),
             "reward_video_watch_count": _count(
                 AdRewardRecord,

app/admin/routers/ops_marquee_seed.py

@@ -19,8 +19,6 @@ from app.admin.schemas.ops_marquee_seed import (
     OpsMarqueeSeedCreate,
     OpsMarqueeSeedOut,
     OpsMarqueeSeedUpdate,
-    OpsRealRecordItem,
-    OpsRealRecordsOut,
     OpsSavingsFeedPreviewOut,
 )
 from app.models.admin import AdminUser
@@ -70,22 +68,6 @@ def preview_feed(
     return OpsSavingsFeedPreviewOut(items=ops_marquee.get_feed(db, limit=limit, mode=mode))
 
 
-@router.get("/real-records", response_model=OpsRealRecordsOut, summary="分页浏览当前模式下可展示的记录(审核用)")
-def list_real_records(
-    db: AdminDb,
-    mode: Annotated[str | None, Query(description="mixed/real/seed;不传=当前持久化模式")] = None,
-    offset: Annotated[int, Query(ge=0)] = 0,
-    limit: Annotated[int, Query(ge=1, le=50)] = 8,
-) -> OpsRealRecordsOut:
-    """分页列出**当前模式**下可在 app 轮播展示的全部记录(**不去重**):只真实=真实记录;只种子=各启用
-    种子按生成逻辑各出一行;混播=真实+种子。与 app 同口径洗牌+去连簇,固定种子→翻页稳定、能翻遍全部。
-    item.user_id=0 表示种子行。"""
-    if mode is not None and mode not in ops_marquee.FEED_MODES:
-        raise HTTPException(status_code=400, detail="mode 需为 mixed / real / seed")
-    items, total = ops_marquee.list_real_records(db, mode=mode, offset=offset, limit=limit)
-    return OpsRealRecordsOut(items=[OpsRealRecordItem(**it) for it in items], total=total)
-
-
 # 注:/mode 两个端点须在 /{seed_id} 之前注册,否则 PATCH /mode 会被 /{seed_id} 抢先按 id 解析。
 @router.get("/mode", summary="首页轮播数据源模式(mixed/real/seed)")
 def get_feed_mode(db: AdminDb) -> dict:

app/admin/schemas/ops_marquee_seed.py

@@ -62,16 +62,3 @@ class OpsSavingsFeedPreviewItem(BaseModel):
 class OpsSavingsFeedPreviewOut(BaseModel):
     """运营预览:实际混播出来的 feed(真实记录会插队,与客户端一致)。"""
     items: list[OpsSavingsFeedPreviewItem]
-
-
-class OpsRealRecordItem(BaseModel):
-    masked_user: str          # 脱敏后展示名(与 app 一致)
-    saved_amount_cents: int   # 节省金额(分)
-    created_at: str           # 比价记录时间(YYYY-MM-DD HH:MM)
-    user_id: int              # 真实 user_id(供运营核对,不下发客户端)
-
-
-class OpsRealRecordsOut(BaseModel):
-    """分页浏览「全部可展示的真实记录」(success+省>0,不去重、稳定顺序)。"""
-    items: list[OpsRealRecordItem]
-    total: int                # 满足条件的真实记录总数(算页数用)

app/api/v1/wallet.py

@@ -43,7 +43,6 @@ from app.schemas.welfare import (
     WithdrawRequest,
     WithdrawResultOut,
     WithdrawStatusOut,
-    WithdrawTierOut,
 )
 
 logger = logging.getLogger("shagua.wallet")
@@ -174,15 +173,8 @@ def unbind_wechat(
     return UnbindWechatResultOut(bound=False)
 
 
-@router.get("/withdraw-info", response_model=WithdrawInfoOut, summary="提现额度/绑定状态/免确认开关/档位")
+@router.get("/withdraw-info", response_model=WithdrawInfoOut, summary="提现额度/绑定状态/免确认开关")
-def withdraw_info(
+def withdraw_info(user: CurrentUser, db: DbSession) -> WithdrawInfoOut:
-    user: CurrentUser,
-    db: DbSession,
-    source: str = Query(
-        "coin_cash",
-        description="提现账户:coin_cash(福利页,下发 tiers 档位) / invite_cash(邀请页,tiers 为空走旧逻辑)",
-    ),
-) -> WithdrawInfoOut:
     u = db.get(User, user.id)
     # 顺带同步免确认授权状态(捕获首单确认后已生效的授权 pending→active),让开关展示实时
     auth = crud_wallet.sync_transfer_auth(db, user.id)
@@ -193,7 +185,6 @@ def withdraw_info(
         wechat_nickname=u.wechat_nickname if u else None,
         wechat_avatar_url=u.wechat_avatar_url if u else None,
         transfer_auth_enabled=bool(auth and auth.state == "active"),
-        tiers=[WithdrawTierOut(**t) for t in crud_wallet.withdraw_tier_states(db, user.id, source)],
     )
 
 
@@ -227,9 +218,6 @@ def withdraw(req: WithdrawRequest, user: CurrentUser, db: DbSession) -> Withdraw
             status_code=status.HTTP_409_CONFLICT,
             detail="已有提现申请正在审核或打款中,请处理完成后再申请",
         ) from e
-    except crud_wallet.WithdrawTierUnavailableError as e:
-        # 福利页档位闸(7-9):次数满/已选其他额度。正常客户端已按 tiers 预拦,此处兜底防绕过。
-        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="今日额度已达上限") from e
     except crud_wallet.InsufficientCashError as e:
         raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="现金余额不足") from e
 

app/core/rewards.py

@@ -6,7 +6,6 @@
 from __future__ import annotations
 
 from datetime import date, datetime, timedelta, timezone
-from typing import NamedTuple
 
 # 业务时区:签到的"今天"按北京时间算,不能用 UTC。
 # 否则 UTC+8 的凌晨 0~8 点会被算成 UTC 的前一天,导致签到日期错位。
@@ -53,30 +52,6 @@ WITHDRAW_MIN_CENTS: int = 10
 WITHDRAW_MAX_CENTS: int = 5_000_000  # 5 万元
 
 
-# ===== 提现档位(福利页 coin_cash;7-9 对齐原型 withdrawal.html)=====
-# 后端是档位唯一真相源:withdraw-info 按此下发,create_withdraw 按此校验(防绕过客户端刷)。
-# 规则(2026-07-09 拍板):
-#   - 新人档(is_newbie):账号历史一次性,"发起就算用过"(任意状态含被拒),用过即不再下发;
-#     0.1 与 0.3 各自独立同天可各提一次,且不参与常规档"每日选一个额度"互斥。
-#   - 常规档:按北京日计次(0.5×3 / 10×1 / 20×1),三档每天只能选一个。
-# invite_cash(邀请页)本轮无档位概念,不在此表。改档位=改这里发版。
-class WithdrawTier(NamedTuple):
-    amount_cents: int
-    label: str          # 客户端档位方块展示文案
-    badge: str | None   # 角标文案;None=无角标
-    daily_limit: int    # 每日次数上限(新人档的"历史一次性"另由 is_newbie 判定)
-    is_newbie: bool
-
-
-WITHDRAW_TIERS_COIN_CASH: tuple[WithdrawTier, ...] = (
-    WithdrawTier(10, "0.1", "新人福利", 1, True),
-    WithdrawTier(30, "0.3", "新人福利", 1, True),
-    WithdrawTier(50, "0.5", None, 3, False),
-    WithdrawTier(1000, "10", None, 1, False),
-    WithdrawTier(2000, "20", None, 1, False),
-)
-
-
 # ===== 一次性任务(领一次,user_task 去重)=====
 TASK_ENABLE_NOTIFICATION = "enable_notification"
 

app/repositories/ad_feed_reward.py

@@ -176,19 +176,10 @@ def grant_feed_reward(
         )
         return _commit_record(db, rec, client_event_id)
 
-    # 按点位场景拆流水文案(2026-07):比价等候期看的广告 vs 领券时看的广告,在收益明细里分开显示。
-    # feed_scene=comparison→比价奖励 / coupon→领券奖励;其它(welfare/空/旧端不带)维持通用「信息流广告奖励」。
-    # 客户端按此 biz_type 直显固定文案(见 CoinHistoryViewModel.coinTitle),故 remark 只作后台留痕/兜底。
-    if feed_scene == "comparison":
-        reward_biz, reward_remark = "feed_ad_reward_comparison", "比价奖励"
-    elif feed_scene == "coupon":
-        reward_biz, reward_remark = "feed_ad_reward_coupon", "领券奖励"
-    else:
-        reward_biz, reward_remark = "feed_ad_reward", "信息流广告奖励"
     crud_wallet.grant_coins(
         db, user_id, coin,
-        biz_type=reward_biz, ref_id=client_event_id,
+        biz_type="feed_ad_reward", ref_id=client_event_id,
-        remark=reward_remark,
+        remark="信息流广告奖励",
     )
     rec = AdFeedRewardRecord(
         client_event_id=client_event_id,

app/repositories/ops_marquee.py

@@ -217,28 +217,12 @@ def _recent_real_rows(db: Session) -> list[tuple[int, int, str | None]]:
     return out
 
 
-def _shuffle_declustered(rows: list, rng: random.Random | None = None) -> list:
-    """洗牌 + 「去连簇」:先洗牌,再贪心重排让相邻两条尽量不是同一 user_id(元素 [0] 即 user_id)。
-    rng=None → 用全局 _rng(feed 每次新随机);传入 rng(如固定种子 Random)→ 排列确定(admin 稳定分页)。
-    减少同一用户连续出现;只有少数几个用户时 best-effort。"""
-    rng = rng or _rng
-    pool = list(rows)
-    rng.shuffle(pool)
-    result: list = []
-    while pool:
-        prev_uid = result[-1][0] if result else None
-        # 优先挑与上一条不同 user 的;挑不到(只剩同 user)才取第一个
-        idx = next((i for i, r in enumerate(pool) if r[0] != prev_uid), 0)
-        result.append(pool.pop(idx))
-    return result
-
-
 def get_feed(db: Session, limit: int = 8, mode: str | None = None) -> list[dict]:
     """返回最多 limit 条 {masked_user, saved_amount_cents, time(HH:MM:SS 北京)}。
 
     mode:显式传入(admin 预览指定模式)则用它、**不改持久化配置**;不传(客户端 /savings-feed)读
     持久化的 marquee_feed_mode;非法值一律回退到持久化模式。
-    真实条:success 且 0 < saved ≤ 上限,**不按 user 去重**(打乱 + 去连簇:相邻尽量不同用户、减少单人连刷)后取前 limit。
+    真实条:success 且 0 < saved ≤ 上限,按 user 去重(同一用户只取最新一条,避免单人刷屏)。
     不足用启用的种子补齐——**公平随机抽取** need 个(而非固定取前 N),让所有种子都有机会露出;
     种子用户名留空则随机合成(避开撞名),金额取**长尾随机**(小额居多、偶尔大额,更像真实分布)。
     真实 + 种子仍不满 limit → 内置合成条**补满**,保证轮播既不空也不稀疏。
@@ -251,13 +235,19 @@ def get_feed(db: Session, limit: int = 8, mode: str | None = None) -> list[dict]
     items: list[dict] = []
     used_names: set[str] = set()
 
-    # 真实条(mixed / real):**不按 user 去重**——打乱 + 去连簇(相邻尽量不同用户、减少单人连刷)后取前
+    # 真实条(mixed / real):取较多近期记录(带 ~30s 缓存)后按 user 去重;金额超上限的异常值已在查询剔除。
-    # limit;金额超上限的异常值已在查询剔除。同一用户可多条露出,但被打散、尽量不连续。
     if mode != "seed":
-        for uid, sc, nick in _shuffle_declustered(_recent_real_rows(db))[:limit]:
+        rows = _recent_real_rows(db)
+        seen_users: set[int] = set()
+        for uid, sc, nick in rows:
+            if uid in seen_users:
+                continue
+            seen_users.add(uid)
             name = _mask_real(nick, uid)
-            used_names.add(name)  # 同一用户可多条,名字重复无害(used_names 仅供种子避重)
+            used_names.add(name)  # 真实名按昵称/id 稳定;偶发撞名可接受
             items.append({"masked_user": name, "saved_amount_cents": int(sc)})
+            if len(items) >= limit:
+                break
 
     # 种子补位 + 合成兜底(mixed / seed):mixed 下补真实不足的部分,seed 下全量用种子/合成。
     # real 模式**跳过**——只出真实,不掺任何假数据(真实不足则少于 limit,为 0 时返回空)。
@@ -310,78 +300,6 @@ def get_feed(db: Session, limit: int = 8, mode: str | None = None) -> list[dict]
     return items
 
 
-# ===== admin 侧:分页浏览「当前模式下可展示的记录」(审核用,不去重) =====
-_REAL_BROWSE_CAP = 1000   # 真实记录一次最多纳入这么多去洗牌+分页(足够审核;防超大库全量洗牌)
-_BROWSE_SEED = 20260707   # 固定洗牌种子:同一批数据下排列恒定 → 翻页稳定、能翻遍全部
-
-
-def _seed_browse_row(seed: OpsMarqueeSeed) -> dict:
-    """把一条种子按其「生成逻辑」**确定性**生成一行浏览项(名字/金额按 seed.id 派生固定种子 → 翻页稳定)。
-    名字:运营手填的非模板名原样用,否则本地合成;金额:区间内确定性长尾取值。user_id=0(种子无真实用户)。"""
-    r = random.Random(_BROWSE_SEED * 1_000_003 + int(seed.id))
-    fixed = (seed.masked_user or "").strip()
-    name = fixed if (fixed and not fixed.startswith("用户****")) else _synth_name(r)
-    lo = max(0, int(seed.min_cents))
-    hi = max(lo, int(seed.max_cents))
-    amt = lo if hi <= lo else lo + int(round((hi - lo) * (r.random() ** 2.2)))
-    return {"masked_user": name, "saved_amount_cents": amt, "created_at": "", "user_id": 0}
-
-
-def list_real_records(
-    db: Session, mode: str | None = None, offset: int = 0, limit: int = 8
-) -> tuple[list[dict], int]:
-    """分页浏览「**当前模式**下可在 app 轮播展示的全部记录」,供 admin 逐页审核(**不去重**):
-      - 只真实:全部 success+省>0 的真实记录;
-      - 只种子:每条启用种子按生成逻辑各出一行;
-      - 混播:真实 + 种子 全部合在一起。
-    与 app 轮播同口径:先洗牌 + 去连簇(相邻尽量不同 user;种子各自独立、不算同 user);**固定种子** →
-    同批数据下排列恒定,翻页不跳、能翻遍全部。返回 (items, total);item.user_id=0 表示种子。"""
-    mode = mode if mode in FEED_MODES else get_feed_mode(db)
-    # pool: [(cluster_key, item)];cluster_key 供去连簇——真实=user_id、种子=各自唯一负数(互不聚簇)
-    pool: list[tuple[int, dict]] = []
-    if mode != "seed":
-        rows = db.execute(
-            select(
-                ComparisonRecord.user_id,
-                ComparisonRecord.saved_amount_cents,
-                User.nickname,
-                ComparisonRecord.created_at,
-            )
-            .join(User, User.id == ComparisonRecord.user_id)
-            .where(
-                ComparisonRecord.status == "success",
-                ComparisonRecord.saved_amount_cents > 0,
-                ComparisonRecord.saved_amount_cents <= _REAL_MAX_CENTS,
-            )
-            .order_by(ComparisonRecord.created_at.desc())
-            .limit(_REAL_BROWSE_CAP)
-        ).all()
-        for uid, sc, nick, ca in rows:
-            pool.append((
-                int(uid),
-                {
-                    "masked_user": _mask_real(nick, int(uid)),
-                    "saved_amount_cents": int(sc),
-                    "created_at": str(ca)[:16] if ca is not None else "",
-                    "user_id": int(uid),
-                },
-            ))
-    if mode != "real":
-        seeds = (
-            db.execute(select(OpsMarqueeSeed).where(OpsMarqueeSeed.enabled.is_(True)))
-            .scalars()
-            .all()
-        )
-        for i, s in enumerate(seeds):
-            pool.append((-(i + 1), _seed_browse_row(s)))  # 每个种子唯一 key → 互不聚簇
-    total = len(pool)
-    # 每次用同一固定种子新建 Random → 同批数据排列恒定(翻页稳定);同时相邻尽量不同 user。
-    ordered = _shuffle_declustered(pool, random.Random(_BROWSE_SEED))
-    off = max(0, offset)
-    items = [item for _key, item in ordered[off : off + limit]]
-    return items, total
-
-
 # ===== 运营侧:种子 CRUD =====
 def list_seeds(db: Session) -> list[OpsMarqueeSeed]:
     return list(

app/repositories/wallet.py

@@ -11,7 +11,7 @@ import unicodedata
 import uuid
 from datetime import datetime, timedelta, timezone
 
-from sqlalchemy import func, select, update
+from sqlalchemy import select, update
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
@@ -67,10 +67,6 @@ class WithdrawTooFrequentError(Exception):
     """提现申请过于频繁,或已有未完成提现单。"""
 
 
-class WithdrawTierUnavailableError(Exception):
-    """该档位今日不可提:次数已满,或今天已选了其他额度(7-9 福利页档位规则)。"""
-
-
 class WithdrawTransferError(Exception):
     """调用微信转账失败(已退回余额)。"""
 
@@ -609,89 +605,6 @@ def _settle_after_ambiguous(db: Session, order: WithdrawOrder, reason: str) -> N
         db.commit()
 
 
-def _beijing_today_start_utc() -> datetime:
-    """北京时今日 0 点(转 UTC)。WithdrawOrder.created_at 是 func.now()(UTC)存储,
-    比较时统一转 UTC,与 admin 看板 today_start 同口径(admin/repositories/queries.py)。"""
-    return (
-        datetime.now(rewards.CN_TZ)
-        .replace(hour=0, minute=0, second=0, microsecond=0)
-        .astimezone(timezone.utc)
-    )
-
-
-def withdraw_tier_states(db: Session, user_id: int, source: str = "coin_cash") -> list[dict]:
-    """福利页(coin_cash)提现档位的可提现状态。withdraw-info 下发与 create_withdraw 校验共用此口径。
-
-    规则(2026-07-09 拍板,7-9提现ui对齐):
-      - 新人档(0.1/0.3):账号历史一次性——只要发起过(**任意状态**,含被拒/失败,"发起就算")
-        即视为已用,直接**从返回列表消失**;两档各自独立互不影响,不参与"每日选一个额度"互斥。
-      - 常规档(0.5×3 / 10×1 / 20×1):按北京日计次,"发起就算占用"(当天创建的单不论最终状态
-        都计入,被拒/失败不退当天名额);三档每天只能选一个,选定后其余两档当天 other_tier_selected。
-      - invite_cash 本轮无档位概念 → 返回空列表(邀请页客户端仍用本地写死档位,行为不变)。
-    余额是否足够由客户端本地判断(余额随兑换实时变化,不在此快照)。
-    """
-    if source != "coin_cash":
-        return []
-    tiers = rewards.WITHDRAW_TIERS_COIN_CASH
-    amounts = [t.amount_cents for t in tiers]
-    newbie_amounts = [t.amount_cents for t in tiers if t.is_newbie]
-    # 新人档历史是否用过:任意时间、任意状态("发起就算")
-    used_newbie: set[int] = set(
-        db.execute(
-            select(WithdrawOrder.amount_cents)
-            .distinct()
-            .where(
-                WithdrawOrder.user_id == user_id,
-                WithdrawOrder.source == "coin_cash",
-                WithdrawOrder.amount_cents.in_(newbie_amounts),
-            )
-        ).scalars()
-    ) if newbie_amounts else set()
-    # 今日(北京日)每档已发起次数(任意状态)
-    today_counts: dict[int, int] = {
-        int(amount): int(cnt)
-        for amount, cnt in db.execute(
-            select(WithdrawOrder.amount_cents, func.count(WithdrawOrder.id))
-            .where(
-                WithdrawOrder.user_id == user_id,
-                WithdrawOrder.source == "coin_cash",
-                WithdrawOrder.amount_cents.in_(amounts),
-                WithdrawOrder.created_at >= _beijing_today_start_utc(),
-            )
-            .group_by(WithdrawOrder.amount_cents)
-        )
-    }
-    # "每日选一个额度":今天发起过的常规档(新人档不算)
-    selected_regular = next(
-        (t.amount_cents for t in tiers if not t.is_newbie and today_counts.get(t.amount_cents, 0) > 0),
-        None,
-    )
-    out: list[dict] = []
-    for t in tiers:
-        if t.is_newbie:
-            if t.amount_cents in used_newbie:
-                continue  # 用过即消失,不再下发
-            out.append({
-                "amount_cents": t.amount_cents, "label": t.label, "badge": t.badge,
-                "is_newbie": True, "available": True, "disabled_reason": None,
-                "remaining_today": 1,
-            })
-            continue
-        used = today_counts.get(t.amount_cents, 0)
-        if selected_regular is not None and selected_regular != t.amount_cents:
-            available, reason, remaining = False, "other_tier_selected", 0
-        elif used >= t.daily_limit:
-            available, reason, remaining = False, "quota_exhausted", 0
-        else:
-            available, reason, remaining = True, None, t.daily_limit - used
-        out.append({
-            "amount_cents": t.amount_cents, "label": t.label, "badge": t.badge,
-            "is_newbie": False, "available": available, "disabled_reason": reason,
-            "remaining_today": remaining,
-        })
-    return out
-
-
 def create_withdraw(
     db: Session,
     user_id: int,
@@ -747,19 +660,6 @@ def create_withdraw(
     if active_order_id is not None:
         raise WithdrawTooFrequentError
 
-    # 福利页档位闸(7-9):coin_cash 只能提预设档位,且该档今日可提(服务端权威口径,防绕过
-    # 客户端刷)。放在幂等返回/在途互斥之后:同号重试仍原样返回旧单,不被档位闸误杀。
-    # allow_sub_min(0.01 调试直发)保持原样放行,不受档位约束;invite_cash 本轮无档位概念不校验。
-    if source == "coin_cash" and not allow_sub_min:
-        tier_state = next(
-            (t for t in withdraw_tier_states(db, user_id, source) if t["amount_cents"] == amount_cents),
-            None,
-        )
-        if tier_state is None:  # 非预设档位金额,或新人档已用过(已从列表消失)
-            raise InvalidWithdrawAmountError
-        if not tier_state["available"]:
-            raise WithdrawTierUnavailableError
-
     # 账户须存在(原子扣款的 UPDATE 不会建账户)
     get_or_create_account(db, user_id, commit=True)
 

app/schemas/welfare.py

@@ -75,21 +75,6 @@ class ExchangeResultOut(BaseModel):
 
 # ===== 提现(现金 → 微信零钱) =====
 
-class WithdrawTierOut(BaseModel):
-    """提现档位(福利页 coin_cash;7-9 对齐原型)。served by rewards.WITHDRAW_TIERS_COIN_CASH。"""
-
-    amount_cents: int = Field(..., description="档位金额(分)")
-    label: str = Field(..., description="档位方块展示文案,如 0.1 / 10")
-    badge: str | None = Field(None, description="角标文案(如 新人福利);无则空")
-    is_newbie: bool = Field(False, description="新人档:历史一次性,用过后不再下发;免广告直提")
-    available: bool = Field(True, description="当前是否可提(次数/选一额度口径;余额由客户端自判)")
-    disabled_reason: str | None = Field(
-        None,
-        description="不可提原因:quota_exhausted(今日次数满) / other_tier_selected(今日已选其他额度)",
-    )
-    remaining_today: int = Field(0, description="今日剩余可提次数")
-
-
 class WithdrawInfoOut(BaseModel):
     min_cents: int = Field(..., description="单次最低提现(分)")
     max_cents: int = Field(..., description="单次最高提现(分)")
@@ -99,10 +84,6 @@ class WithdrawInfoOut(BaseModel):
     transfer_auth_enabled: bool = Field(
         False, description="是否已开启免确认到账(开启后提现免跳微信确认,直接到账)"
     )
-    tiers: list[WithdrawTierOut] = Field(
-        default_factory=list,
-        description="提现档位(source=coin_cash 下发;invite_cash 为空,客户端走旧逻辑)",
-    )
 
 
 # ===== 免确认收款授权(用户授权免确认模式)=====

scripts/seed_coinhistory_labels_test.py

@@ -1,166 +0,0 @@
-"""收益明细「金币记录」文案验证脚手架(2026-07 文案改版验收用)。
-
-问题:客户端按 bizType 显示固定文案(路线B,强制覆盖后端 remark),但账号若没有对应
-bizType 的流水,收益明细页就空着,无从验证。本脚本往指定测试用户塞每种 bizType 各一条
-流水,让你在手机收益明细页一屏核对全部新文案;验收完 --clean 一键删除,不污染数据。
-
-⚠️ 仅 dev 库用(APP_ENV=dev 时才允许 --seed/--clean)。所有测试流水 ref_id 前缀 TESTDOC,
-按前缀精确清理,不会误删真实流水。
-
-用法(pricebot env 直调,见项目 CLAUDE.md):
-  D:/miniconda/envs/pricebot/python.exe scripts/seed_coinhistory_labels_test.py --show
-  D:/miniconda/envs/pricebot/python.exe scripts/seed_coinhistory_labels_test.py --seed
-  D:/miniconda/envs/pricebot/python.exe scripts/seed_coinhistory_labels_test.py --clean
-"""
-from __future__ import annotations
-
-import argparse
-import sys
-
-from app.core.config import settings
-from app.core.rewards import CN_TZ
-from datetime import datetime
-
-from app.db.session import SessionLocal
-from app.models.user import User
-from app.models.wallet import CoinAccount, CoinTransaction
-
-TEST_PHONE = "11111111111"
-REF_PREFIX = "TESTDOC"  # 所有本脚本造的流水都带这个 ref_id 前缀,便于精确清理
-
-# 每条 = (bizType, 故意写错/留空的 remark, 金币数)。
-# remark 故意填「错的」→ 若客户端仍显示新文案 = 证明路线B强制覆盖生效(无视后端 remark)。
-# task_ 一条留空 remark → 走客户端兜底映射。顺序即手机上从新到旧的展示顺序(后塞的在最上)。
-CASES: list[tuple[str, str, int]] = [
-    ("signin", "每日签到 第99天(旧文案,应被覆盖)", 220),
-    ("signin_boost", "签到膨胀 第99天", 3000),
-    ("reward_video", "看视频奖励金币(旧文案,应被覆盖)", 200),
-    ("feed_ad_reward_comparison", "", 50),   # 后端新拆:比价场景 → 比价奖励
-    ("feed_ad_reward_coupon", "", 50),       # 后端新拆:领券场景 → 领券奖励
-    ("feed_ad_reward", "信息流广告奖励(welfare/旧数据兜底)", 50),
-    ("price_report_reward", "上报更低价审核通过(旧文案,应被覆盖)", 1000),
-    ("feedback_reward", "意见反馈被采纳(旧文案,应被覆盖)", 10000),
-    ("task_enable_notification", "", 750),   # remark 留空 → 客户端「打开消息提醒奖励」
-    # 下两条现实中不会进金币记录(invite 发现金进邀请钱包 / compare_milestone 后端死代码不发钱),
-    # 仅用于验证「杀掉好友比价奖励 + 兜底改任务奖励」:两条都应显示「任务奖励」(remark 被强制无视)。
-    ("invite", "好友比价奖励(旧文案,应被杀→任务奖励)", 200),
-    ("compare_milestone", "", 120),
-]
-
-
-def _client_coin_title(biz_type: str, remark: str | None) -> str:
-    """复刻 CoinHistoryViewModel.coinTitle 的最新逻辑(路线B),用于 --show 预览。
-
-    ⚠️ 必须与客户端保持一致;客户端改了这里也要同步,否则预览会骗人。
-    """
-    fixed = {
-        "exchange_out": "金币兑换现金",
-        "signin": "每日签到奖励",
-        "signin_boost": "签到膨胀奖励",
-        "reward_video": "看视频赚金币",
-        "ad_reward": "看视频赚金币",
-        "feed_ad_reward_comparison": "比价奖励",
-        "feed_ad_reward_coupon": "领券奖励",
-        "feed_ad_reward": "信息流广告奖励",
-        "price_report_reward": "爆料奖励",
-        "feedback_reward": "反馈奖励",
-        "invite": "任务奖励",  # 杀掉"好友比价奖励",归兜底
-    }
-    if biz_type in fixed:
-        return fixed[biz_type]
-    if remark:
-        return remark
-    if biz_type == "task_enable_notification":
-        return "打开消息提醒奖励"
-    return "任务奖励"
-
-
-def _get_user(db) -> User:
-    u = db.query(User).filter(User.phone == TEST_PHONE).first()
-    if not u:
-        print(f"✗ 库里没有测试号 {TEST_PHONE} —— 先在手机上用这个号登录一次再跑本脚本。")
-        sys.exit(1)
-    return u
-
-
-def cmd_show() -> None:
-    """只打印:每种 bizType 经客户端映射后会显示成什么(不写库)。"""
-    print("bizType 造流水后,收益明细页预期显示的文案:\n")
-    print(f"  {'bizType':32} {'后端remark(故意填的)':32} → 手机显示")
-    print("  " + "-" * 90)
-    for biz, remark, _coin in CASES:
-        shown = _client_coin_title(biz, remark or None)
-        rk = (remark or "(空)")
-        print(f"  {biz:32} {rk:32} → {shown}")
-    print("\n注:remark 列是故意填的『旧/错』文案;'手机显示'若为新文案 = 强制覆盖生效。")
-    print("invite / compare_milestone 已从客户端映射删除:invite 有 remark 故显示原样,")
-    print("compare_milestone remark 空故落兜底『奖励』—— 两者都不再有专属新文案(符合『去掉』)。")
-
-
-def cmd_seed() -> None:
-    if settings.APP_ENV != "dev":
-        print(f"✗ 拒绝:APP_ENV={settings.APP_ENV},本脚本只在 dev 库造测试数据。")
-        sys.exit(1)
-    db = SessionLocal()
-    u = _get_user(db)
-    acc = db.query(CoinAccount).filter(CoinAccount.user_id == u.id).first()
-    if acc is None:
-        acc = CoinAccount(user_id=u.id, coin_balance=0, cash_balance_cents=0)
-        db.add(acc)
-        db.flush()
-    now = datetime.now(CN_TZ).replace(tzinfo=None)
-    made = 0
-    for i, (biz, remark, coin) in enumerate(CASES):
-        ref = f"{REF_PREFIX}:{biz}:{i}"
-        exists = db.query(CoinTransaction).filter(CoinTransaction.ref_id == ref).first()
-        if exists:
-            continue
-        acc.coin_balance += coin
-        db.add(CoinTransaction(
-            user_id=u.id, amount=coin, balance_after=acc.coin_balance,
-            biz_type=biz, ref_id=ref, remark=remark or None, created_at=now,
-        ))
-        made += 1
-    db.commit()
-    print(f"✓ 已给 user_id={u.id}({TEST_PHONE})造 {made} 条测试流水,当前金币余额 {acc.coin_balance}。")
-    print("  → 打开手机 App「收益明细 / 金币记录」下拉刷新,逐条核对文案。")
-    print("  → 验收完跑 --clean 删除这些测试流水。")
-
-
-def cmd_clean() -> None:
-    if settings.APP_ENV != "dev":
-        print(f"✗ 拒绝:APP_ENV={settings.APP_ENV}。")
-        sys.exit(1)
-    db = SessionLocal()
-    u = _get_user(db)
-    rows = db.query(CoinTransaction).filter(
-        CoinTransaction.user_id == u.id,
-        CoinTransaction.ref_id.like(f"{REF_PREFIX}:%"),
-    ).all()
-    total = sum(r.amount for r in rows)
-    for r in rows:
-        db.delete(r)
-    acc = db.query(CoinAccount).filter(CoinAccount.user_id == u.id).first()
-    if acc is not None:
-        acc.coin_balance -= total  # 把造流水时加的余额扣回,还原
-    db.commit()
-    print(f"✓ 已删除 {len(rows)} 条 TESTDOC 测试流水,余额回扣 {total},当前 {acc.coin_balance if acc else 0}。")
-
-
-def main() -> None:
-    ap = argparse.ArgumentParser(description="收益明细金币文案验证脚手架")
-    g = ap.add_mutually_exclusive_group(required=True)
-    g.add_argument("--show", action="store_true", help="只打印每种 bizType 的预期显示文案,不写库")
-    g.add_argument("--seed", action="store_true", help="往测试号造每种 bizType 各一条流水")
-    g.add_argument("--clean", action="store_true", help="删除本脚本造的所有测试流水")
-    args = ap.parse_args()
-    if args.show:
-        cmd_show()
-    elif args.seed:
-        cmd_seed()
-    elif args.clean:
-        cmd_clean()
-
-
-if __name__ == "__main__":
-    main()

tests/test_admin_read.py

@@ -320,92 +320,3 @@ def test_read_apis_require_auth(admin_client: TestClient) -> None:
         "/admin/api/feedbacks",
     ]:
         assert admin_client.get(path).status_code == 401, path
-
-
-def test_period_comparison_reward_coin_from_feed_scene(
-    admin_client: TestClient, admin_token: str
-) -> None:
-    """比价奖励金币口径:按 ad_feed_reward_record.feed_scene='comparison' 的实发金币
-    (status=granted)汇总,而非查从不写入的 biz_type 桶(修复大盘该卡恒 0)。
-    too_short(未发奖)不计。"""
-    from app.models.ad_feed_reward import AdFeedRewardRecord
-
-    d = "2021-06-15"  # 独立历史日,隔离其它用例数据
-    db = SessionLocal()
-    try:
-        uid = user_repo.upsert_user_for_login(db, phone="13800008801", register_channel="sms").id
-        db.add(AdFeedRewardRecord(
-            client_event_id="cmp-fs-granted", user_id=uid, reward_date=d,
-            ecpm_raw="0", coin=123, feed_scene="comparison", status="granted",
-        ))
-        db.add(AdFeedRewardRecord(
-            client_event_id="cmp-fs-tooshort", user_id=uid, reward_date=d,
-            ecpm_raw="0", coin=99, feed_scene="comparison", status="too_short",
-        ))
-        db.commit()
-    finally:
-        db.close()
-
-    r = admin_client.get(
-        "/admin/api/stats/overview", params={"date_from": d, "date_to": d},
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200, r.text
-    assert r.json()["period"]["coins"]["comparison_reward_coin_total"] == 123
-
-
-def test_period_coupon_reward_coin_from_feed_scene(
-    admin_client: TestClient, admin_token: str
-) -> None:
-    """领券奖励金币口径:按 ad_feed_reward_record.feed_scene='coupon' 的实发金币汇总。"""
-    from app.models.ad_feed_reward import AdFeedRewardRecord
-
-    d = "2021-06-16"
-    db = SessionLocal()
-    try:
-        uid = user_repo.upsert_user_for_login(db, phone="13800008802", register_channel="sms").id
-        db.add(AdFeedRewardRecord(
-            client_event_id="cpn-fs-granted", user_id=uid, reward_date=d,
-            ecpm_raw="0", coin=456, feed_scene="coupon", status="granted",
-        ))
-        db.commit()
-    finally:
-        db.close()
-
-    r = admin_client.get(
-        "/admin/api/stats/overview", params={"date_from": d, "date_to": d},
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200, r.text
-    assert r.json()["period"]["coins"]["coupon_reward_coin_total"] == 456
-
-
-def test_period_coupon_reward_excludes_reward_video(
-    admin_client: TestClient, admin_token: str
-) -> None:
-    """领券奖励金币不再把激励视频金币算进来(reward_video/ad_reward 从领券桶拆出);
-    激励视频仍单独计入 reward_video_coin_total。"""
-    from datetime import datetime
-
-    from app.models.wallet import CoinTransaction
-
-    d = "2021-06-17"
-    db = SessionLocal()
-    try:
-        uid = user_repo.upsert_user_for_login(db, phone="13800008803", register_channel="sms").id
-        db.add(CoinTransaction(
-            user_id=uid, amount=50, balance_after=50, biz_type="reward_video",
-            ref_id="rv-split-1", created_at=datetime(2021, 6, 17, 12, 0, 0),
-        ))
-        db.commit()
-    finally:
-        db.close()
-
-    r = admin_client.get(
-        "/admin/api/stats/overview", params={"date_from": d, "date_to": d},
-        headers=_auth(admin_token),
-    )
-    assert r.status_code == 200, r.text
-    coins = r.json()["period"]["coins"]
-    assert coins["coupon_reward_coin_total"] == 0        # 激励视频不计入领券奖励
-    assert coins["reward_video_coin_total"] == 50        # 仍计入激励视频卡

tests/test_invite_cash_withdraw.py

@@ -143,15 +143,14 @@ def test_two_accounts_withdraw_independent(client, monkeypatch) -> None:
     _reject(r1.json()["out_bill_no"])    # 退回 invite_cash + 结清活跃单
     r2 = client.post(
         "/api/v1/wallet/withdraw",
-        # 50 分 = 0.5 元档(7-9 起 coin_cash 只能提预设档位)
+        json={"amount_cents": 100, "source": "coin_cash"},
-        json={"amount_cents": 50, "source": "coin_cash"},
         headers=_auth(token),
     )
     assert r2.json()["status"] == "reviewing"
 
     cash, invite_cash = _balances(client, token)
     assert invite_cash == 500    # 已退回
-    assert cash == 350           # 扣了 cash 50
+    assert cash == 300           # 扣了 cash 100
 
 
 def test_invite_me_returns_reward_stats(client) -> None:
@@ -178,8 +177,7 @@ def test_withdraw_orders_source_filter(client, monkeypatch) -> None:
     _reject(r1.json()["out_bill_no"])    # 结清,才能提第二笔
     client.post(
         "/api/v1/wallet/withdraw",
-        # 50 分 = 0.5 元档(7-9 起 coin_cash 只能提预设档位)
+        json={"amount_cents": 100, "source": "coin_cash"},
-        json={"amount_cents": 50, "source": "coin_cash"},
         headers=_auth(token),
     )
 

tests/test_withdraw_ledger_check.py

@@ -139,8 +139,7 @@ def test_coin_cash_withdraw_still_reconciled(client, monkeypatch) -> None:
     before = _ledger()
     r = client.post(
         "/api/v1/wallet/withdraw",
-        # 50 分 = 0.5 元档(7-9 起 coin_cash 只能提预设档位)
+        json={"amount_cents": 200, "source": "coin_cash"},
-        json={"amount_cents": 50, "source": "coin_cash"},
         headers=_auth(token),
     )
     assert r.status_code == 200, r.text

tests/test_withdraw_tiers.py

@@ -1,186 +0,0 @@
-"""福利页(coin_cash)提现档位规则测试(7-9提现ui对齐)。
-
-规则(2026-07-09 拍板):
-  - 档位 0.1/0.3(新人,历史一次性,免广告)+ 0.5(日3次)/10/20(日1次)。
-  - 计次口径"发起就算":当天创建的单不论最终状态(含被拒)都占名额;新人档任何状态都算用过。
-  - 常规三档每天只能选一个;新人档不参与该互斥,两个新人档同天可各提一次。
-  - invite_cash 无档位概念:tiers 为空、下单不走档位闸(邀请页行为不变)。
-wxpay 调用全部 monkeypatch;现金余额 DB 直灌(同 test_withdraw.py 套路)。
-"""
-from __future__ import annotations
-
-from sqlalchemy import select
-
-from app.db.session import SessionLocal
-from app.models.user import User
-from app.models.wallet import CoinAccount
-from app.repositories import wallet as crud_wallet
-
-
-def _login(client, phone: str) -> str:
-    client.post("/api/v1/auth/sms/send", json={"phone": phone})
-    r = client.post("/api/v1/auth/sms/login", json={"phone": phone, "code": "123456"})
-    assert r.status_code == 200, r.text
-    return r.json()["access_token"]
-
-
-def _auth(token: str) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"}
-
-
-def _seed_balances(client, token: str, phone: str, cash: int = 0, invite_cash: int = 0) -> None:
-    client.get("/api/v1/wallet/account", headers=_auth(token))
-    db = SessionLocal()
-    try:
-        user = db.execute(select(User).where(User.phone == phone)).scalar_one()
-        acc = db.get(CoinAccount, user.id)
-        acc.cash_balance_cents = cash
-        acc.invite_cash_balance_cents = invite_cash
-        db.commit()
-    finally:
-        db.close()
-
-
-def _patch_userinfo(monkeypatch, openid: str) -> None:
-    monkeypatch.setattr(
-        "app.integrations.wxpay.code_to_userinfo",
-        lambda code: {"openid": openid, "nickname": "昵称", "avatar_url": None, "raw": {}},
-    )
-
-
-def _reject(bill: str) -> None:
-    """管理员拒绝:退款结清活跃单(便于同用户继续发起下一笔;名额按'发起就算'仍占)。"""
-    db = SessionLocal()
-    try:
-        crud_wallet.reject_withdraw(db, bill, "test")
-    finally:
-        db.close()
-
-
-def _withdraw(client, token: str, cents: int):
-    return client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": cents, "source": "coin_cash"},
-        headers=_auth(token),
-    )
-
-
-def _tiers(client, token: str, source: str = "coin_cash") -> list[dict]:
-    r = client.get(
-        "/api/v1/wallet/withdraw-info", params={"source": source}, headers=_auth(token)
-    )
-    assert r.status_code == 200, r.text
-    return r.json()["tiers"]
-
-
-def test_withdraw_info_tiers_full_and_invite_empty(client, monkeypatch) -> None:
-    """新用户 coin_cash 下发 5 档(新人角标齐);invite_cash tiers 为空。"""
-    token = _login(client, "13800006001")
-    tiers = _tiers(client, token)
-    assert [t["amount_cents"] for t in tiers] == [10, 30, 50, 1000, 2000]
-    assert [t["label"] for t in tiers] == ["0.1", "0.3", "0.5", "10", "20"]
-    assert tiers[0]["badge"] == "新人福利" and tiers[0]["is_newbie"] is True
-    assert tiers[1]["badge"] == "新人福利" and tiers[1]["is_newbie"] is True
-    assert all(t["available"] for t in tiers)
-    assert tiers[2]["remaining_today"] == 3  # 0.5 日 3 次
-    assert _tiers(client, token, source="invite_cash") == []
-
-
-def test_newbie_tiers_independent_and_once_forever(client, monkeypatch) -> None:
-    """0.1 提过(即使被拒)→ 永久消失;同天 0.3 仍可提;新人档不锁常规档。"""
-    _patch_userinfo(monkeypatch, "openid_tier_2")
-    token = _login(client, "13800006002")
-    _seed_balances(client, token, "13800006002", cash=5000)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r = _withdraw(client, token, 10)  # 0.1 新人档
-    assert r.status_code == 200, r.text
-    _reject(r.json()["out_bill_no"])  # 被拒也算用过("发起就算")
-
-    tiers = _tiers(client, token)
-    amounts = [t["amount_cents"] for t in tiers]
-    assert 10 not in amounts          # 0.1 消失
-    assert 30 in amounts              # 0.3 还在,同天仍可提
-    # 新人档不参与"选一个额度":常规三档全部仍可提
-    regular = {t["amount_cents"]: t for t in tiers if not t["is_newbie"]}
-    assert all(regular[a]["available"] for a in (50, 1000, 2000))
-
-    r = _withdraw(client, token, 30)  # 同天 0.3 照提
-    assert r.status_code == 200, r.text
-    _reject(r.json()["out_bill_no"])
-
-    # 0.1 已用过,重提 → 非法金额(档位已消失)
-    r = _withdraw(client, token, 10)
-    assert r.status_code == 400, r.text
-
-
-def test_regular_daily_select_one_tier(client, monkeypatch) -> None:
-    """当天提过 0.5 → 10/20 置灰 other_tier_selected,下单 409;0.5 还能继续提(3 次内)。"""
-    _patch_userinfo(monkeypatch, "openid_tier_3")
-    token = _login(client, "13800006003")
-    _seed_balances(client, token, "13800006003", cash=10_000)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r = _withdraw(client, token, 50)
-    assert r.status_code == 200, r.text
-    _reject(r.json()["out_bill_no"])  # 结清活跃单;当天名额仍占("发起就算")
-
-    tiers = {t["amount_cents"]: t for t in _tiers(client, token)}
-    assert tiers[50]["available"] and tiers[50]["remaining_today"] == 2
-    assert not tiers[1000]["available"] and tiers[1000]["disabled_reason"] == "other_tier_selected"
-    assert not tiers[2000]["available"] and tiers[2000]["disabled_reason"] == "other_tier_selected"
-
-    r = _withdraw(client, token, 1000)  # 选一额度互斥 → 409
-    assert r.status_code == 409, r.text
-    assert "今日额度已达上限" in r.json()["detail"]
-
-    r = _withdraw(client, token, 50)  # 0.5 第 2 次照常
-    assert r.status_code == 200, r.text
-
-
-def test_regular_daily_quota_exhausted(client, monkeypatch) -> None:
-    """0.5 日 3 次:第 4 次 409;tiers 显示 quota_exhausted。"""
-    _patch_userinfo(monkeypatch, "openid_tier_4")
-    token = _login(client, "13800006004")
-    _seed_balances(client, token, "13800006004", cash=10_000)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    for _ in range(3):
-        r = _withdraw(client, token, 50)
-        assert r.status_code == 200, r.text
-        _reject(r.json()["out_bill_no"])
-
-    tiers = {t["amount_cents"]: t for t in _tiers(client, token)}
-    assert not tiers[50]["available"]
-    assert tiers[50]["disabled_reason"] == "quota_exhausted"
-    assert tiers[50]["remaining_today"] == 0
-
-    r = _withdraw(client, token, 50)
-    assert r.status_code == 409, r.text
-
-
-def test_non_tier_amount_rejected_for_coin_cash(client, monkeypatch) -> None:
-    """coin_cash 只能提预设档位:任意其他金额 400(防绕过客户端刷)。"""
-    _patch_userinfo(monkeypatch, "openid_tier_5")
-    token = _login(client, "13800006005")
-    _seed_balances(client, token, "13800006005", cash=10_000)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r = _withdraw(client, token, 123)
-    assert r.status_code == 400, r.text
-
-
-def test_invite_cash_not_gated_by_tiers(client, monkeypatch) -> None:
-    """invite_cash 不走档位闸:非档位金额(200=2元)照常下单——邀请页行为不变。"""
-    _patch_userinfo(monkeypatch, "openid_tier_6")
-    token = _login(client, "13800006006")
-    _seed_balances(client, token, "13800006006", invite_cash=500)
-    client.post("/api/v1/wallet/bind-wechat", json={"code": "c"}, headers=_auth(token))
-
-    r = client.post(
-        "/api/v1/wallet/withdraw",
-        json={"amount_cents": 200, "source": "invite_cash"},
-        headers=_auth(token),
-    )
-    assert r.status_code == 200, r.text
-    assert r.json()["status"] == "reviewing"