feat(compare): 比价记录列表支持「已下单」筛选与店名/菜名搜索

GET /api/v1/compare/records 新增 ordered / keyword 两个查询参数,过滤全部下推到 SQL。
不能分页之后再由客户端 filter —— 一页里可能一条都不命中,列表看着就是空的,
得翻很多页才蹦出一条。

顺带修掉这条链路上几处随数据量线性变慢的地方:

- 列表查询 defer raw_payload / llm_calls / llm_price_snapshot 三个重型 JSON 列。
  出参 ComparisonRecordOut 根本不读,却是每页几百 KB~几 MB 的白读 + 白反序列化,
  是「比价记录/全部记录」页慢的主要来源;详情接口不 defer,raw_payload 照常返回。
- 「已下单」标记改为只按本页店名(≤ limit 条)反查 savings,不再把该用户全部下单
  店名捞进内存跟 50 条记录取交集。
- 新增 (user_id, created_at, id) 复合索引:反向扫恰好等于列表的
  ORDER BY created_at DESC, id DESC,PG 免排序直接取前 n 条。
  迁移走 CREATE INDEX CONCURRENTLY,不阻塞线上 harvest 写入。
- keyword 转义 LIKE 通配符后再匹配,避免搜一个「%」把整表拉回来。
- nginx 对 application/json 开 gzip:此前 gzip off + gzip_types 只含 text/html
  + gzip_proxied off 三个默认值凑一起,等于所有接口都在裸奔;记录列表这种
  字段名和中文店名高度重复的 JSON 压缩比稳定 8~10 倍。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

alembic/versions/analytics_active_idx_active_composite_index.py

@@ -5,8 +5,10 @@ Revises: 135e79414fd0
 Create Date: 2026-07-18 17:35:00.000000
 
 给 analytics_event 加活跃口径热点复合索引 (event, page, user_id, created_at):
-activity.active_event_condition 按 (event=show & page=home) ∪ 比价 ∪ 领券 过滤后
-group by user_id、max(created_at)。覆盖索引让该聚合走 index-only,避免高频 show 事件全表扫。
+activity.active_event_condition 按 event IN (home_visible ∪ 比价 ∪ 领券) 过滤后
+group by user_id、max(created_at)。覆盖索引让该聚合走 index-only,避免高频活跃事件全表扫。
+(历史:早期首页可见用 event=show+page=home 组合,故索引含 page 列;现改单一 home_visible、
+不再按 page 过滤 → page 列成冗余,索引仍靠 event 前缀生效;如需更优可后续新迁移瘦成 (event,user_id,created_at)。)
 
 ⚠️ 本分支迁移树有**既有多头**:135e79414fd0(不活跃两表)与 phone_rebind_log 同从
 comparison_llm_cost 分叉,`alembic upgrade head` 会多头报错。本迁移挂在 135e79414fd0

alembic/versions/comparison_user_created_idx.py

@@ -0,0 +1,52 @@
+"""add composite index (user_id, created_at, id) on comparison_record
+
+C 端「我的比价记录」列表(GET /api/v1/compare/records)是
+`WHERE user_id=? ORDER BY created_at DESC, id DESC LIMIT n` —— 原来只有单列 user_id 索引,
+过滤完还要把该用户的**全部**记录取出来排序才能拿前 n 条,重度用户随记录数线性变慢。
+
+本复合索引的反向扫恰好等于 (created_at DESC, id DESC),规划器直接取前 n 条、免排序。
+列序 (user_id, created_at, id) 与查询一一对应,不要调整。
+
+Revision ID: comparison_user_created_idx
+Revises: merge_active_phone
+Create Date: 2026-07-21
+"""
+
+from __future__ import annotations
+
+from alembic import op
+
+revision = "comparison_user_created_idx"
+down_revision = "merge_active_phone"
+branch_labels = None
+depends_on = None
+
+INDEX_NAME = "ix_comparison_user_created"
+COLUMNS = ["user_id", "created_at", "id"]
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name == "postgresql":
+        # 线上 comparison_record 已有数据量,普通 CREATE INDEX 持表写锁会阻塞比价 harvest 写入;
+        # 用 CONCURRENTLY 不锁表(须脱离事务,autocommit_block 切到自动提交)。
+        # 同 comparison_status_created_idx 的做法。
+        with op.get_context().autocommit_block():
+            op.create_index(
+                INDEX_NAME, "comparison_record", COLUMNS,
+                unique=False, postgresql_concurrently=True,
+            )
+    else:
+        op.create_index(INDEX_NAME, "comparison_record", COLUMNS, unique=False)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if bind.dialect.name == "postgresql":
+        with op.get_context().autocommit_block():
+            op.drop_index(
+                INDEX_NAME, table_name="comparison_record",
+                postgresql_concurrently=True,
+            )
+    else:
+        op.drop_index(INDEX_NAME, table_name="comparison_record")

app/admin/repositories/queries.py

@@ -145,7 +145,7 @@ def list_users(
     代价是翻页期间数据变动可能错位一条——admin 低频场景可接受(同 [list_all_withdraw_orders])。
     日期入参统一转 tz-aware UTC 比较(列为 timestamptz,见 _as_utc)。"""
     # 最近活跃 = max(注册时间, 最近行为事件, 最近领券发起)。baseline 由 last_login_at 改为 created_at
-    #(登录不代表在用 App;口径统一到 activity.py,含 home_view + 比价 + 领券,见 activity.ACTIVE_EVENTS)。
+    #(登录不代表在用 App;口径统一到 activity.py,含 home_visible + 比价 + 领券,见 activity.ACTIVE_EVENTS)。
     # 未命中侧 coalesce 到 created_at(恒非空基线)。派生表 1:1,outerjoin 不放大行数。
     ev_agg, eng_agg = activity.last_active_subqueries(db)
     last_active = activity.last_active_expr(

app/api/v1/ad.py

@@ -281,7 +281,10 @@ def ecpm_report(payload: EcpmReportIn, user: CurrentUser, db: DbSession) -> Ecpm
     丢一两条不影响业务(穿山甲后台报表是结算权威)。eCPM 与发奖(S2S)是两条独立流,不逐条关联。
     """
     attributed_trace_id = crud_ecpm.attributable_trace_id(
-        db, feed_scene=payload.feed_scene, trace_id=payload.trace_id
+        db,
+        feed_scene=payload.feed_scene,
+        trace_id=payload.trace_id,
+        exposure_ms=payload.exposure_ms,
     )
     if payload.trace_id and attributed_trace_id is None:
         logger.info(
@@ -296,11 +299,12 @@ def ecpm_report(payload: EcpmReportIn, user: CurrentUser, db: DbSession) -> Ecpm
         feed_scene=payload.feed_scene,
         trace_id=attributed_trace_id,
         app_env=payload.app_env, our_code_id=payload.our_code_id,
+        exposure_ms=payload.exposure_ms,
     )
     logger.info(
-        "ad ecpm report user_id=%d type=%s scene=%s session=%s ecpm=%s adn=%s slot=%s app=%s code=%s",
+        "ad ecpm report user_id=%d type=%s scene=%s session=%s ecpm=%s exposure_ms=%s adn=%s slot=%s app=%s code=%s",
         user.id, payload.ad_type, payload.feed_scene, payload.ad_session_id, payload.ecpm,
-        payload.adn, payload.slot_id, payload.app_env, payload.our_code_id,
+        payload.exposure_ms, payload.adn, payload.slot_id, payload.app_env, payload.our_code_id,
     )
     return EcpmReportOut(ok=True)
 

app/api/v1/compare_record.py

@@ -115,13 +115,22 @@ def list_records(
     db: DbSession,
     limit: int = Query(20, ge=1, le=100),
     cursor: int | None = Query(None, description="上一页末条 id"),
+    ordered: bool | None = Query(
+        None,
+        description="true=只看「已下单」(店名命中本人真实下单)的记录;不传=全部",
+    ),
+    keyword: str | None = Query(
+        None,
+        max_length=64,
+        description="按店名 / 菜名模糊搜索,忽略大小写;空白串等同不传",
+    ),
     include_trace: bool = Query(
         False,
         description="客户端开了本机 agent 调试模式时带 true,放行本人记录的 trace_url",
     ),
 ) -> ComparisonRecordPage:
     items, next_cursor = crud_compare.list_records(
-        db, user.id, limit=limit, cursor=cursor
+        db, user.id, limit=limit, cursor=cursor, ordered=ordered, keyword=keyword
     )
     outs = [ComparisonRecordOut.model_validate(it) for it in items]
     # 权限闸:未开 debug_trace_enabled 的用户不下发 trace_url(列表页「复制调试链接」靠它)。

app/models/analytics_event.py

@@ -25,8 +25,9 @@ class AnalyticsEvent(Base):
     __tablename__ = "analytics_event"
     __table_args__ = (
         # 活跃口径聚合热点(activity.active_event_condition + last_active_subqueries):
-        # 按 (event,page) 过滤 首页可见(show/home)∪比价∪领券,再 group by user_id 取
-        # max(created_at)。覆盖索引 → 该聚合走 index-only,避免高频 show 事件全表扫。
+        # 按 event IN (home_visible∪比价∪领券) 过滤,再 group by user_id 取 max(created_at)。
+        # 覆盖索引 → 该聚合走 index-only。注:page 列是早期 show+home 组合的遗留,现不再按 page
+        # 过滤(索引靠 event 前缀仍生效);后续可新迁移瘦成 (event,user_id,created_at)。
         Index("ix_analytics_event_active", "event", "page", "user_id", "created_at"),
     )
 

app/models/comparison.py

@@ -45,6 +45,10 @@ class ComparisonRecord(Base):
         # 首页轮播 / 省钱战绩聚合都按 status='success' 过滤 + created_at 近期排序;
         # 复合索引避免随数据量增大退化成全表扫(单列 created_at 索引不含 status)。
         Index("ix_comparison_status_created", "status", "created_at"),
+        # C 端「我的比价记录」列表:WHERE user_id=? ORDER BY created_at DESC, id DESC LIMIT n。
+        # 单列 user_id 索引只能过滤,排序仍要把该用户全部记录取出来排一遍;这条复合索引的**反向扫**
+        # 恰好等于 (created_at DESC, id DESC),PG 直接取前 n 条、免排序。列序不能动。
+        Index("ix_comparison_user_created", "user_id", "created_at", "id"),
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)

app/repositories/activity.py

@@ -1,6 +1,6 @@
 """活跃口径唯一真源:worker(不活跃清零)与 admin(最近活跃/DAU)共用,防两处漂移。
 
-口径 = max(User.created_at, AnalyticsEvent[首页可见 show/home + 比价 + 领券], CouponPromptEngagement[claim_started])。
+口径 = max(User.created_at, AnalyticsEvent[首页可见 home_visible + 比价 + 领券], CouponPromptEngagement[claim_started])。
 **不含 last_login_at**(登录/re-login 不代表在用 App);created_at 为恒非空基线。
 清零/预警按北京自然日 0 点对齐(见 reset_cutoff)。
 """
@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from datetime import date, datetime, timedelta, timezone
 
-from sqlalchemy import and_, func, or_, select
+from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
 from app.core.rewards import CN_TZ, cn_today
@@ -16,24 +16,18 @@ from app.models.analytics_event import AnalyticsEvent
 from app.models.coupon_state import CouponPromptEngagement
 
 # —— 活跃口径事件(与"用户管理"口径一致)——
-# 首页可见:前端埋点 event=show + page=home(组合判定,单个 event 名不足以区分,见
-# active_event_condition);其余为纯 event 名。
-HOME_VIEW_EVENT = "show"
-HOME_VIEW_PAGE = "home"
+# 首页可见:前端埋点确认 event=home_visible(首页进入可视区时触发,单一 event 名即可判定)。
+HOME_VISIBLE_EVENT = "home_visible"
 COMPARE_START_EVENT = "real_compare_start"   # 发起比价(含浮窗触发)
 COUPON_START_EVENT = "real_coupon_start"     # 发起领券
-# 纯 event 名即可判定的活跃事件(首页可见是 event+page 组合、不在此列)
-ACTIVE_EVENTS = (COMPARE_START_EVENT, COUPON_START_EVENT)
+ACTIVE_EVENTS = (HOME_VISIBLE_EVENT, COMPARE_START_EVENT, COUPON_START_EVENT)
 ACTIVE_ENGAGE_TYPE = "claim_started"         # coupon_prompt_engagement 一键领取
 
 
 def active_event_condition():
-    """analytics_event 中算"活跃"的行为过滤:首页可见(event=show & page=home)
+    """analytics_event 中算"活跃"的行为过滤:首页可见(event=home_visible)
     ∪ 发起比价 ∪ 发起领券。worker 子查询与 admin 展示共用,单一真源。"""
-    return or_(
-        and_(AnalyticsEvent.event == HOME_VIEW_EVENT, AnalyticsEvent.page == HOME_VIEW_PAGE),
-        AnalyticsEvent.event.in_(ACTIVE_EVENTS),
-    )
+    return AnalyticsEvent.event.in_(ACTIVE_EVENTS)
 
 
 def as_utc(value: datetime) -> datetime:

app/repositories/ad_ecpm.py

@@ -15,9 +15,22 @@ from app.core.rewards import cn_today
 from app.models.ad_ecpm import AdEcpmRecord
 from app.models.coupon_state import CouponSession
 
+MIN_REVENUE_EXPOSURE_MS = 1000
+
+
+def effective_ecpm_raw(ecpm_raw: str, exposure_ms: int | None) -> str:
+    """曝光不足一秒时保留展示记录，但把该条有效 eCPM 归零。"""
+    if exposure_ms is not None and exposure_ms < MIN_REVENUE_EXPOSURE_MS:
+        return "0"
+    return ecpm_raw
+
 
 def attributable_trace_id(
-    db: Session, *, feed_scene: str | None, trace_id: str | None
+    db: Session,
+    *,
+    feed_scene: str | None,
+    trace_id: str | None,
+    exposure_ms: int | None = None,
 ) -> str | None:
     """返回广告展示允许归属的业务 trace。
 
@@ -31,7 +44,12 @@ def attributable_trace_id(
     session_status = db.execute(
         select(CouponSession.status).where(CouponSession.trace_id == trace_id)
     ).scalar_one_or_none()
-    return None if session_status in {"failed", "abandoned"} else trace_id
+    if session_status not in {"failed", "abandoned"}:
+        return trace_id
+    # 已真实上墙但不足一秒的曝光要在终态明细中明确显示 0，而不是被误判成“未填充”。
+    if exposure_ms is not None and exposure_ms < MIN_REVENUE_EXPOSURE_MS:
+        return trace_id
+    return None
 
 
 def create_ecpm_record(
@@ -47,6 +65,7 @@ def create_ecpm_record(
     trace_id: str | None = None,
     app_env: str | None = None,
     our_code_id: str | None = None,
+    exposure_ms: int | None = None,
 ) -> AdEcpmRecord:
     """落一条 eCPM 上报记录。report_date 用北京时间当天,供按天聚合。
 
@@ -67,7 +86,7 @@ def create_ecpm_record(
         trace_id=trace_id,
         app_env=app_env,
         our_code_id=our_code_id,
-        ecpm_raw=ecpm_raw,
+        ecpm_raw=effective_ecpm_raw(ecpm_raw, exposure_ms),
         report_date=cn_today().isoformat(),
     )
     db.add(rec)

app/repositories/comparison.py

@@ -7,8 +7,8 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from sqlalchemy import func, select
-from sqlalchemy.orm import Session
+from sqlalchemy import func, or_, select
+from sqlalchemy.orm import Session, defer
 
 from app.core.rewards import CN_TZ
 from app.models.ad_feed_reward import AdFeedRewardRecord
@@ -375,19 +375,48 @@ def harvest_abort(
     return rec
 
 
-def _ordered_shop_names(db: Session, user_id: int) -> set[str]:
-    """该用户「真实下单」(source='compare')覆盖到的店名集合,用来给比价记录打「已下单」。
+def _ordered_shop_name_select(user_id: int):
+    """该用户「真实下单」(source='compare')覆盖到的店名 select,给「已下单」筛选当子查询。
+
+    口径与 [_ordered_shop_names] 完全一致,只是时机不同:那边是**拿到本页之后**按 candidates
+    反查打标;这边是**分页之前**就要过滤,拿不到 candidates,只能整段下推成子查询。
+    没有先捞成集合再展开 IN (...) 字面量 —— 重度用户下单过的店名可能上千,展开会撞 SQLite
+    的绑定变量上限,而且又变回了那个「随下单量线性变慢」的老写法。
+    """
+    return select(SavingsRecord.shop_name).where(
+        SavingsRecord.user_id == user_id,
+        SavingsRecord.source == "compare",
+        SavingsRecord.shop_name.is_not(None),
+    )
+
+
+def _like_escape(kw: str) -> str:
+    """转义 LIKE 通配符(百分号 / 下划线 / 反斜杠),让用户输入只按字面量匹配(配合 escape 参数)。
+
+    不转义的话搜一个「%」就等于把整表拉回来。
+    """
+    return kw.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+
+
+def _ordered_shop_names(db: Session, user_id: int, candidates: set[str]) -> set[str]:
+    """[candidates] 里哪些店名被该用户「真实下单」(source='compare')覆盖过,用来打「已下单」。
 
     只认 compare(归因命中后真实上报),demo 演示数据不算。下单上报不带 trace_id,
     只能按店名对齐——两边店名同源(都来自比价意图识别阶段的门店名 query),精确相等即视为同店。
     语义=店级:同一家店比价过多次,这些记录会一并标「已下单」。
+
+    ⚠️ 只查**本页出现过的店名**(candidates ≤ limit 条),不再把该用户全部下单店名捞回内存:
+    老写法随下单量线性增长,重度用户几千行全读一遍只为跟 50 条记录取交集。空集合直接返回
+    (避免 IN () 非法)。
     """
+    if not candidates:
+        return set()
     rows = db.execute(
         select(SavingsRecord.shop_name).where(
             SavingsRecord.user_id == user_id,
             SavingsRecord.source == "compare",
-            SavingsRecord.shop_name.is_not(None),
-        )
+            SavingsRecord.shop_name.in_(candidates),
+        ).distinct()
     ).scalars().all()
     return {s for s in rows if s}
 
@@ -415,17 +444,60 @@ def _ad_coins_by_trace(db: Session, user_id: int, trace_ids: list[str]) -> dict[
     return {tid: int(coin) for tid, coin in rows if tid}
 
 
+# 列表出参(ComparisonRecordOut)根本不读、但 select(ORM) 默认会一并捞回来的重型 JSON 列:
+#   - raw_payload:done.params 上报体全量,**每条记录都有**(harvest 与 POST 两条写路径都落)。
+#     单条几 KB~几十 KB,一页 50 条就是稳定几百 KB~几 MB 的白读 + 白反序列化。
+#   - llm_calls:每次 LLM 调用的 input_messages + output 全文。只有走老客户端 POST /compare/record
+#     的记录才有(_backfill_llm_calls 回填;harvest 路径不落),但有的时候单条就能到 MB 级 —— 一页里
+#     混进几条这种记录,整个请求就被它们拖住。
+#   - llm_price_snapshot:逐模型单价快照,同样只在回填时落。
+# 三列全部读出来再被 pydantic 丢掉,是「比价记录/全部记录」页慢的主要来源。
+# ⚠️ defer 的列一旦在别处被读到会触发**逐行**懒加载(N+1);列表这条链路(ComparisonRecordOut
+# 不声明这三个字段 → 不会 getattr 到)是安全的。详情接口 get_record 不 defer,raw_payload 照常返回。
+_LIST_DEFERRED = (
+    ComparisonRecord.raw_payload,
+    ComparisonRecord.llm_calls,
+    ComparisonRecord.llm_price_snapshot,
+)
+
+
 def list_records(
     db: Session,
     user_id: int,
     *,
     limit: int = 20,
     cursor: int | None = None,
+    ordered: bool | None = None,
+    keyword: str | None = None,
 ) -> tuple[list[ComparisonRecord], int | None]:
     """比价记录分页(按创建时间倒序、id 兜底,游标式)。附「已下单」店级标记 + 「看广告赚的金币」(瞬态,不写库)。"""
-    stmt = select(ComparisonRecord).where(ComparisonRecord.user_id == user_id)
+    stmt = (
+        select(ComparisonRecord)
+        .where(ComparisonRecord.user_id == user_id)
+        .options(*(defer(col) for col in _LIST_DEFERRED))
+    )
     if cursor is not None:
         stmt = stmt.where(ComparisonRecord.id < cursor)
+    # 「已下单」tab 与搜索框的过滤都下推到这里,不能留给客户端对整页结果 filter ——
+    # 分页之后一页里可能一条都不命中,列表看着就是空的/卡住的,得翻很多页才蹦出一条。
+    if ordered:
+        stmt = stmt.where(
+            ComparisonRecord.store_name.in_(_ordered_shop_name_select(user_id))
+        )
+    kw = (keyword or "").strip()
+    if kw:
+        # product_names 是写路径从 items[].name 派生的普通文本列(items 本身是 JSON,SQLite 下
+        # 中文被 ensure_ascii 转义,没法直接 LIKE)—— 搜「菜名」靠的就是它。
+        # ilike:PG 原生 ILIKE,SQLite 渲染成 lower() LIKE lower(),两边都忽略大小写。
+        pattern = f"%{_like_escape(kw)}%"
+        stmt = stmt.where(
+            or_(
+                ComparisonRecord.store_name.ilike(pattern, escape="\\"),
+                ComparisonRecord.product_names.ilike(pattern, escape="\\"),
+            )
+        )
+    # 排序与 ix_comparison_user_created(user_id, created_at, id)对齐 —— DESC/DESC 正好是该索引的
+    # 反向扫,PG 免排序直接取前 limit 条。改排序方向前先想清楚索引还吃不吃得上。
     stmt = stmt.order_by(ComparisonRecord.created_at.desc(), ComparisonRecord.id.desc()).limit(limit)
 
     items = list(db.execute(stmt).scalars().all())
@@ -433,7 +505,10 @@ def list_records(
 
     # 「已下单」标记:本页记录的 store_name 若落在该用户真实下单的店名集合里即 True。
     # ordered / ad_coins_earned 均非 ORM 列,仅挂实例上供 ComparisonRecordOut(from_attributes) 读出,不持久化。
-    ordered_shops = _ordered_shop_names(db, user_id)
+    page_shops = {it.store_name for it in items if it.store_name}
+    # ordered=True 时上面已按同一口径(_ordered_shop_name_select)筛过,本页必然全是已下单,
+    # 省掉这次反查;其余情况照旧按本页店名反查 savings。
+    ordered_shops = page_shops if ordered else _ordered_shop_names(db, user_id, page_shops)
     # 「本次比价看广告赚的金币」:按本页 trace_id 一次性聚合(同 ordered 范式)。
     ad_coins = _ad_coins_by_trace(db, user_id, [it.trace_id for it in items])
     for it in items:

app/schemas/ad.py

@@ -69,6 +69,12 @@ class EcpmReportIn(BaseModel):
         description="本次比价/领券 trace_id(信息流场景带上):把这条展示收益归属到对应比价/领券,"
         "供领券数据/比价记录看板聚合本场广告收益;激励视频/福利为空",
     )
+    exposure_ms: int | None = Field(
+        None,
+        ge=0,
+        le=86_400_000,
+        description="本条广告真实在屏曝光毫秒数；小于 1000ms 时收益强制按 0 计算。旧客户端不传则保持原口径",
+    )
     app_env: str | None = Field(
         None, max_length=16, description="我们的穿山甲应用环境:prod(傻瓜比价正式) / test(测试应用)"
     )

deploy/nginx/app-api.shaguabijia.com.conf

@@ -25,6 +25,18 @@ server {
     # (纯文字反馈体积小、不受影响 → 呈现为「时好时坏」)。根治仍需客户端上传前压缩。
     client_max_body_size 32m;
 
+    # JSON 响应压缩。nginx 默认 gzip off,且就算 on 了 gzip_types 也只含 text/html、
+    # gzip_proxied 默认 off(反代来的响应一律不压)—— 三个默认值凑一起 = 我们所有接口都在裸奔。
+    # 比价记录列表这种一次 50 条、字段名 + 中文店名/菜名高度重复的 JSON,gzip 压缩比稳定在 8~10 倍
+    # (几百 KB → 几十 KB),弱网下省的就是首屏那几秒。
+    # 只压 JSON:APK 直链(/media/shaguabijia.apk)、图片本身已是压缩格式,再压纯浪费 CPU。
+    gzip              on;
+    gzip_proxied      any;      # 反代响应也压(默认 off = 对我们这套反代等于没开)
+    gzip_types        application/json;
+    gzip_min_length   1024;     # 小响应压了反而更大(gzip 头开销),不值当
+    gzip_comp_level   5;        # 5 是体积/CPU 的常用折中点,再往上收益递减
+    gzip_vary         on;       # 给 CDN/中间缓存正确按 Accept-Encoding 分桶
+
     location / {
         proxy_pass http://127.0.0.1:8770;
         proxy_http_version 1.1;

docs/api/compare/compare-records.md

@@ -10,6 +10,12 @@
 |---|---|---|---|---|
 | `limit` | int | ❌ | 20 | 1–100 |
 | `cursor` | int | ❌ | null | 上一页末条 `id`,首页不传 |
+| `ordered` | bool | ❌ | null | `true`=只出「已下单」(店名命中本人真实下单)的记录;不传=不筛 |
+| `keyword` | string | ❌ | null | 按店名 / 菜名模糊搜索,忽略大小写,≤64 字符;纯空白等同不传 |
+| `include_trace` | bool | ❌ | false | 客户端开了本机 agent 调试模式时带 `true`,放行**本人**记录的 `trace_url` |
+
+`ordered` / `keyword` 都在服务端过滤后再分页,客户端不要拿一页结果自己 filter ——
+分页之后一页里可能一条都不命中,列表会看着像空的。
 
 ## 出参
 响应 `200`：`{ items: ComparisonRecordOut[], next_cursor: int|null }`（分页见 [索引#游标分页约定](./README.md#游标分页约定)）
@@ -38,6 +44,9 @@
 | `items` | object[] | 下单菜品 `{name, qty, specs?}` |
 | `comparison_results` | object[] | 逐平台对比（price 单位元，已按 rank 升序） |
 | `skipped_dish_names` | string[] | 被跳过的菜名 |
+| `ordered` | bool | 「已下单」店级标记:店名命中本人 `source='compare'` 的下单记录即 `true`。**瞬态字段,不在表里**,每次查询现算 |
+| `ad_coins_earned` | int | 本次比价看信息流广告实发的金币(按 `trace_id` 聚合)。同为瞬态字段 |
+| `trace_url` | string \| null | pricebot 调试链接。未开 `debug_trace_enabled` 且未带 `include_trace=true` 时为 `null` |
 | `created_at` | datetime | 时间 |
 
 ## 错误

docs/superpowers/specs/2026-07-16-inactivity-reset-design.md

@@ -38,8 +38,8 @@
 
 | 决策点 | 结论 | 理由 |
 |---|---|---|
-| **活跃口径** | 与"用户管理"一致：`max(首页可见 show/home, 比价, 领券)`，**不含 last_login_at**；无任何信号时以 `created_at` 为非空基线 | 比价可从**浮窗**触发、不进首页；`last_login_at` 只在登录/换绑动作更新（re-login 也算），代表不了"在用 App"，故彻底排除 |
-| **"进首页"信号落地** | **方案 A：前端上报 `home_view` 埋点**（复用 `/analytics/events`），非新接口 | 三个活跃信号统一为同类埋点事件；零新接口零新列；与 admin 口径天然一致。B（鉴权接口 + 列）"更权威"的优势是假的——比价/领券仍是端上报事件，最弱环决定整体可信度 |
+| **活跃口径** | 与"用户管理"一致：`max(首页可见 home_visible, 比价, 领券)`，**不含 last_login_at**；无任何信号时以 `created_at` 为非空基线 | 比价可从**浮窗**触发、不进首页；`last_login_at` 只在登录/换绑动作更新（re-login 也算），代表不了"在用 App"，故彻底排除 |
+| **"进首页"信号落地** | **方案 A：前端上报 `home_visible` 埋点**（复用 `/analytics/events`），非新接口 | 三个活跃信号统一为同类埋点事件；零新接口零新列；与 admin 口径天然一致。B（鉴权接口 + 列）"更权威"的优势是假的——比价/领券仍是端上报事件，最弱环决定整体可信度 |
 | **清零范围** | **金币 + 折算现金**（**邀请现金不清**——产品红线，仅快照入审计） | 对应"账户里的金币和现金"；邀请奖励金与金币现金物理隔离、不可累加，见 `wallet.CoinAccount` 注释 |
 | **预警推送** | **可插拔通知器 + 日志占位**（v1），后续接 JPush/短信 | 现状无真实推送能力；先把清零主流程 + 审计做扎实，不阻塞 |
 | **预警时机** | **完全可配置**（提前天数列表 + 次数 + 执行点 + 通道） | R5 |
@@ -76,7 +76,7 @@ last_active = max(
 ### 模块内容
 
 - 常量：
-  - **首页可见活跃信号已定名：`event=show` + `page=home`**（前端确认，原占位 `home_view`；下文出现的 `home_view` 均指此信号）。活跃行为过滤见 `activity.active_event_condition()`：首页可见 ∪ 比价 `real_compare_start` ∪ 领券 `real_coupon_start`；`ACTIVE_EVENTS` 仅含后两个纯 event 名（首页可见是 event+page 组合、单列）。
+  - **首页可见活跃信号已定名：`event=home_visible`**（前端最终确认；曾用过渡期 `show`+`page=home` 组合，已废弃）。活跃行为过滤见 `activity.active_event_condition()`：首页可见 `home_visible` ∪ 比价 `real_compare_start` ∪ 领券 `real_coupon_start`——三者均为纯 event 名，全部收进 `ACTIVE_EVENTS`。
   - `ACTIVE_ENGAGE_TYPE = "claim_started"`
 - `last_active_subqueries(db)` —— 复刻现 admin `queries._last_active_parts()`：两个按 `user_id` 的 `GROUP BY max(created_at)` 聚合子查询。
 - `last_active_expr(base_col, ev_sub, eng_sub, dialect)` —— 生成 `greatest`/`max`（PG `func.greatest`／SQLite `func.max`）；子聚合缺失时 `coalesce(子聚合, User.created_at)` 兜底（注册基线恒非空，**替代原 last_login_at**）。
@@ -210,7 +210,7 @@ INACTIVITY_RESET_CHECK_INTERVAL_SEC = 1800  # worker 唤醒间隔（可复用现
 
 ## 9. 幂等与重新活跃
 
-- **重新活跃自动退出**：`inactive_days` 由 §4 口径**实时算**。用户一有 `home_view`/比价/领券（**登录本身不算**），`last_active` 前移，自动移出预警与清零队列。**无需**显式"重置标记"。
+- **重新活跃自动退出**：`inactive_days` 由 §4 口径**实时算**。用户一有 `home_visible`/比价/领券（**登录本身不算**），`last_active` 前移，自动移出预警与清零队列。**无需**显式"重置标记"。
 - **预警去重**：`inactivity_notification_log` 中存在 `stage==k 且 created_at > last_active` 的行 ⟹ 本 streak 已推过档 `k`，不重推。用户回归后 `last_active` 前移，旧预警行自然"失效"，开启新 streak。
 - **清零幂等**：阶段 B 只处理三桶非全 0 者；清完 = 0，次日不再匹配。worker 重启 / 多次唤醒 / 补跑均安全，不产生重复清零或重复流水。
 - **稳健补发**：worker 漏跑数天后，某用户可能同时满足多档；只补发**最紧急的未推档**（最小 `k`），避免一次刷屏。
@@ -221,7 +221,7 @@ INACTIVITY_RESET_CHECK_INTERVAL_SEC = 1800  # worker 唤醒间隔（可复用现
 
 | 场景 | 处理 |
 |---|---|
-| 新用户 | `created_at` 作活跃基线（恒非空）→ 注册即"第 1 日活跃"；注册后连续 15 天无 home_view/比价/领券 才清 |
+| 新用户 | `created_at` 作活跃基线（恒非空）→ 注册即"第 1 日活跃"；注册后连续 15 天无 home_visible/比价/领券 才清 |
 | 在途提现 | 提现申请时现金已扣入 `WithdrawOrder`，当前余额已不含在途；只清当前余额、不动提现单。提现失败退款到已清账户 = 用户的钱，正常 |
 | 与 `daily_auto_exchange` 并存 | 各自逐用户幂等；金币多已日结折现金，三桶全清正好覆盖 |
 | 时区/日界 | 统一北京（`rewards.cn_today()`/`CN_TZ`）；**清零/预警按北京自然日 0 点对齐**（末次活跃记为第 1 日 → 第 16 日 0 点清零，见 §4），非滚动 24h；流水 `created_at` 沿用北京 wall-clock naive |
@@ -229,11 +229,11 @@ INACTIVITY_RESET_CHECK_INTERVAL_SEC = 1800  # worker 唤醒间隔（可复用现
 
 ---
 
-## 11. 前端依赖：`home_view` 埋点（跨仓 — Android）
+## 11. 前端依赖：`home_visible` 埋点（跨仓 — Android）
 
-- **Android 端**（`shaguabijia-app-android`）需在**首页可见**（`onResume`/Tab 切入）时，向现有 `POST /api/v1/analytics/events` 批量上报里加一条 `event=<首页可见事件名>`（名称明天加埋点时定，暂记 `"home_view"`） 的事件，**携带登录后的 `user_id`**。
+- **Android 端**（`shaguabijia-app-android`）需在**首页可见**（`onResume`/Tab 切入）时，向现有 `POST /api/v1/analytics/events` 批量上报里加一条 `event=home_visible`（前端已定名）的事件，**携带登录后的 `user_id`**。
 - 客户端按会话/前台去重即可（服务端只取 `max(created_at)`，多报无害）。
-- **上线顺序依赖**：`home_view` 全量覆盖前，"进首页"信号缺失，只有比价/领券能推进活跃、其余落到 `created_at` 基线（"只开首页不操作"且注册满 15 天的用户会被误清）—— 故**开真清（`ENABLED=true`）必须待 `home_view` 铺满后再开**（§13）；dry-run 只记名单不动钱、可先开着看。
+- **上线顺序依赖**：`home_visible` 全量覆盖前，"进首页"信号缺失，只有比价/领券能推进活跃、其余落到 `created_at` 基线（"只开首页不操作"且注册满 15 天的用户会被误清）—— 故**开真清（`ENABLED=true`）必须待 `home_visible` 铺满后再开**（§13）；dry-run 只记名单不动钱、可先开着看。
 
 ---
 
@@ -241,25 +241,25 @@ INACTIVITY_RESET_CHECK_INTERVAL_SEC = 1800  # worker 唤醒间隔（可复用现
 
 - `app/admin/repositories/queries.py`：删本地 `_ACTIVE_EVENTS`/`_last_active_parts()`，改用 `activity.py` 的常量与子查询构造；`list_users` 的 `greatest(...)` 排序/筛选、`_attach_last_active` 均改走共享构造器。
 - `app/admin/repositories/stats.py`：`COMPARE_START_EVENT`/`COUPON_START_EVENT`/活跃用户集（`:138-146`）改用共享常量与口径。
-- **行为变化（预期内、需产品知会）**：admin 的"最近活跃 / DAU"口径变化——**移除 `last_login_at`（登录不再计为活跃）、以 `created_at` 为基线、纳入 `home_view`**。net：`home_view` 铺满后更准（真正把"开首页"算进活跃）；铺满前"只登录不操作"的用户活跃度会下降。
-- **回归底线**：现有 admin 用户列表 / stats 测试按新口径**更新预期**（last_login_at 移除 + created_at 基线 + home_view 纳入）；非活跃口径部分行为不变。
+- **行为变化（预期内、需产品知会）**：admin 的"最近活跃 / DAU"口径变化——**移除 `last_login_at`（登录不再计为活跃）、以 `created_at` 为基线、纳入 `home_visible`**。net：`home_visible` 铺满后更准（真正把"开首页"算进活跃）；铺满前"只登录不操作"的用户活跃度会下降。
+- **回归底线**：现有 admin 用户列表 / stats 测试按新口径**更新预期**（last_login_at 移除 + created_at 基线 + home_visible 纳入）；非活跃口径部分行为不变。
 
 ---
 
 ## 13. 灰度与上线顺序（安全优先）
 
 1. **后端先行**：合入共享模块 + 两表 + worker + 通知器，`INACTIVITY_RESET_ENABLED=False`；活跃口径以 `created_at` 为非空基线、**不含 last_login_at**。
-2. **Android 发版**：上报 `home_view`；观察 analytics 覆盖率。
+2. **Android 发版**：上报 `home_visible`；观察 analytics 覆盖率。
 3. **dry-run 灰度（默认即是）**：`INACTIVITY_RESET_ENABLED=False` 时 worker 常驻只写审计名单（`reason=inactive_Nd_dryrun`）、不动钱、不预警；核对名单准确。
 4. **开真清**：确认无误后置 `INACTIVITY_RESET_ENABLED=True`（转为真清 + 预警）。
-5. **收尾/监控**：持续观察 `home_view` 覆盖率与预警/清零名单；发现"活跃却被判不活跃"的漏报即回查埋点覆盖（口径已不含 last_login_at，登录不再兜底）。
+5. **收尾/监控**：持续观察 `home_visible` 覆盖率与预警/清零名单；发现"活跃却被判不活跃"的漏报即回查埋点覆盖（口径已不含 last_login_at，登录不再兜底）。
 
 ---
 
 ## 14. 测试计划
 
-- **活跃口径（共享模块）**：`home_view`/比价/领券 各单独命中都算活跃；**纯登录不算**；无信号用户以 `created_at` 计；`max` 取最新；naive/aware 混算不崩。
-- **admin 回归**：用户列表 / stats 按新口径更新预期（移除 last_login_at + created_at 基线 + home_view）。
+- **活跃口径（共享模块）**：`home_visible`/比价/领券 各单独命中都算活跃；**纯登录不算**；无信号用户以 `created_at` 计；`max` 取最新；naive/aware 混算不崩。
+- **admin 回归**：用户列表 / stats 按新口径更新预期（移除 last_login_at + created_at 基线 + home_visible）。
 - **不活跃判定**：`last_active` 分别 `<15d / =15d / >15d` × 有/无余额 的命中矩阵。
 - **清零**：三桶归零；`inactivity_reset_log` 清前值正确；三条流水 `biz_type=inactivity_reset`、`balance_after=0`、`ref_id=log.id`；`total_coin_earned` 不变。
 - **预警**：命中窗口调 notifier + 写 `notification_log`；同 streak 不重推；回归后 `last_active` 前移可再次预警；漏跑补发最紧急档。

scripts/seed_inactivity_cases.py

@@ -33,6 +33,7 @@ from app.models.wallet import (  # noqa: E402
     CoinTransaction,
     InviteCashTransaction,
 )
+from app.repositories import activity  # noqa: E402
 from app.repositories import wallet as wallet_repo  # noqa: E402
 
 MARK = "vcase"  # username 前缀,用于清理
@@ -47,7 +48,7 @@ CASES = [
     ("6 只有现金",        30,   0, 200,   0, None, "清 cash;审计1行+1流水"),
     ("7 只有邀请(红线)",  30,   0,   0, 300, None, "不选中/不清/无审计/无流水;invite=300 原封"),
     ("8 预警窗(10天)",    10,  50,  60,  70, None, "不清;发 T-7 预警;notification_log 1行;余额不动"),
-    ("9 活跃兜底",        30, 100, 200, 300,    1, "昨日 home_view→last_active 近→不清不警"),
+    ("9 活跃兜底",        30, 100, 200, 300,    1, "昨日 home_visible→last_active 近→不清不警"),
     ("10 新用户(3天)",     3, 100, 200,   0, None, "created_at 近→不清不警"),
 ]
 
@@ -86,8 +87,8 @@ def seed(db) -> None:
         acc.coin_balance, acc.cash_balance_cents, acc.invite_cash_balance_cents = coin, cash, invite
         acc.total_coin_earned = coin
         if ev_days is not None:
-            db.add(AnalyticsEvent(  # 首页可见 = event=show + page=home
-                event="show", page="home", device_id=MARK, user_id=u.id,
+            db.add(AnalyticsEvent(  # 首页可见 = event=home_visible(单一 event 名,见 activity.ACTIVE_EVENTS)
+                event=activity.HOME_VISIBLE_EVENT, device_id=MARK, user_id=u.id,
                 client_ts=0, created_at=now - timedelta(days=ev_days),
             ))
         db.flush()

tests/test_ad_ecpm_trace_revenue.py

@@ -58,6 +58,32 @@ def test_revenue_yuan_by_trace_empty() -> None:
         db.close()
 
 
+def test_short_exposure_keeps_record_with_zero_revenue() -> None:
+    """不足一秒仍落展示记录，以便后台显示 0 而不是未填充。"""
+    db = SessionLocal()
+    try:
+        rec = crud_ecpm.create_ecpm_record(
+            db, 1, ad_type="draw", ecpm_raw="350",
+            ad_session_id="sess-short-exposure", feed_scene="coupon",
+            trace_id="trace-short-exposure", exposure_ms=999,
+        )
+        assert rec.ecpm_raw == "0"
+        assert crud_ecpm.revenue_yuan_by_trace(db, ["trace-short-exposure"]) == {
+            "trace-short-exposure": 0.0
+        }
+    finally:
+        db.execute(delete(AdEcpmRecord).where(
+            AdEcpmRecord.ad_session_id == "sess-short-exposure"
+        ))
+        db.commit()
+        db.close()
+
+
+def test_one_second_exposure_keeps_original_ecpm() -> None:
+    assert crud_ecpm.effective_ecpm_raw("350", 1000) == "350"
+    assert crud_ecpm.effective_ecpm_raw("350", None) == "350"
+
+
 def test_terminal_coupon_trace_is_not_attributable_to_late_impression() -> None:
     """领券失败或被放弃后才到达的广告展示保留收益记录，但不再关联死亡 trace。"""
     db = SessionLocal()
@@ -80,6 +106,12 @@ def test_terminal_coupon_trace_is_not_attributable_to_late_impression() -> None:
         assert crud_ecpm.attributable_trace_id(
             db, feed_scene="coupon", trace_id="abandoned-before-ad"
         ) is None
+        assert crud_ecpm.attributable_trace_id(
+            db, feed_scene="coupon", trace_id="failed-before-ad", exposure_ms=999
+        ) == "failed-before-ad"
+        assert crud_ecpm.attributable_trace_id(
+            db, feed_scene="coupon", trace_id="abandoned-before-ad", exposure_ms=999
+        ) == "abandoned-before-ad"
         assert crud_ecpm.attributable_trace_id(
             db, feed_scene="comparison", trace_id="failed-before-ad"
         ) == "failed-before-ad"

tests/test_compare_record.py

@@ -222,6 +222,210 @@ def test_stats_compare_count_and_saved(client) -> None:
     assert s2["compare_count"] == 2  # 仍 2(failed 不计)
 
 
+def test_records_ordered_flag(client) -> None:
+    """「已下单」店级标记:店名命中该用户 source='compare' 的下单记录才 True。
+
+    覆盖 list_records 只按**本页店名**反查 savings 的写法(原来是把该用户全部下单店名捞回内存
+    再取交集,随下单量线性变慢)——两种写法结果必须一致,故这里按店名逐条断言。
+    """
+    token = _login(client, "13800002010")
+
+    # 两条比价记录:一条海底捞(稍后会有对应下单),一条没下过单的店
+    client.post("/api/v1/compare/record", json=_food_payload("ord-1"), headers=_auth(token))
+    other = _food_payload("ord-2")
+    other["store_name"] = "没下过单的店"
+    client.post("/api/v1/compare/record", json=other, headers=_auth(token))
+
+    # 下单前:两条都不该带「已下单」
+    items = client.get("/api/v1/compare/records", headers=_auth(token)).json()["items"]
+    assert {it["store_name"]: it["ordered"] for it in items} == {
+        "海底捞(朝阳店)": False,
+        "没下过单的店": False,
+    }
+
+    # 对海底捞真实下单一笔(order/report 写 source='compare' 的 savings_record)
+    r = client.post(
+        "/api/v1/order/report",
+        json={
+            "client_event_id": "evt-ordered-flag",
+            "platform": "美团",
+            "platform_package": "com.sankuai.meituan",
+            "pay_channel": "wechat",
+            "compared_price_cents": 12350,
+            "paid_amount_cents": 12350,
+            "shop_name": "海底捞(朝阳店)",
+            "original_price_cents": 12850,
+        },
+        headers=_auth(token),
+    )
+    assert r.status_code == 200, r.text
+
+    # 下单后:只有同店名那条翻成 True,另一条不受影响
+    items = client.get("/api/v1/compare/records", headers=_auth(token)).json()["items"]
+    assert {it["store_name"]: it["ordered"] for it in items} == {
+        "海底捞(朝阳店)": True,
+        "没下过单的店": False,
+    }
+
+    # 别人的下单不该影响本人标记(_ordered_shop_names 按 user_id 过滤)
+    token_b = _login(client, "13800002011")
+    client.post("/api/v1/compare/record", json=_food_payload("ord-b"), headers=_auth(token_b))
+    items_b = client.get("/api/v1/compare/records", headers=_auth(token_b)).json()["items"]
+    assert [it["ordered"] for it in items_b] == [False]
+
+
+def test_records_list_omits_raw_payload(client) -> None:
+    """列表出参不含 raw_payload(仓库层 defer 掉了重型 JSON 列);详情接口照常返回。
+
+    defer 的列一旦被 ORM 实例读到会触发逐行懒加载(N+1),而列表 schema 本就不该带 raw_payload
+    —— 这条同时守住「列表不泄露上报体全量」和「没人不小心把它加回出参」。
+    """
+    token = _login(client, "13800002012")
+    rid = client.post(
+        "/api/v1/compare/record", json=_food_payload("no-raw"), headers=_auth(token)
+    ).json()["id"]
+
+    items = client.get("/api/v1/compare/records", headers=_auth(token)).json()["items"]
+    assert len(items) == 1
+    assert "raw_payload" not in items[0]
+    # 概要字段照常齐全(defer 没误伤列表要用的列)
+    assert items[0]["store_name"] == "海底捞(朝阳店)"
+    assert items[0]["best_platform_id"] == "meituan"
+    assert items[0]["comparison_results"] and items[0]["items"]
+
+    # 详情不 defer:raw_payload 全量还在
+    d = client.get(f"/api/v1/compare/records/{rid}", headers=_auth(token)).json()
+    assert d["raw_payload"]["trace_id"] == "no-raw"
+
+
+def test_records_ordered_filter(client) -> None:
+    """ordered=true 只出「已下单」的记录,且过滤结果自身能翻页。
+
+    这个筛选必须在服务端做:客户端早先是对「已经拉回来的那一页」做 filter,分页之后一页里
+    很可能一条已下单都没有 ——「已下单」tab 就会看着像空的,得手动翻很多页才蹦出一条。
+    """
+    token = _login(client, "13800002013")
+
+    # 3 条「下过单的店」+ 2 条没下过单的店,交错写入,确保过滤不是靠顺序碰巧对上
+    for i in range(3):
+        p = _food_payload(f"of-ordered-{i}")
+        p["store_name"] = "下过单的店"
+        client.post("/api/v1/compare/record", json=p, headers=_auth(token))
+        if i < 2:
+            q = _food_payload(f"of-plain-{i}")
+            q["store_name"] = "没下过单的店"
+            client.post("/api/v1/compare/record", json=q, headers=_auth(token))
+
+    client.post(
+        "/api/v1/order/report",
+        json={
+            "client_event_id": "evt-ordered-filter",
+            "platform": "美团",
+            "platform_package": "com.sankuai.meituan",
+            "pay_channel": "wechat",
+            "compared_price_cents": 12350,
+            "paid_amount_cents": 12350,
+            "shop_name": "下过单的店",
+            "original_price_cents": 12850,
+        },
+        headers=_auth(token),
+    )
+
+    # 不传 ordered:5 条全出(「全部记录」tab 口径不变)
+    assert len(client.get("/api/v1/compare/records", headers=_auth(token)).json()["items"]) == 5
+
+    # ordered=true:只出那 3 条,且每条都自带 ordered=True
+    page = client.get("/api/v1/compare/records?ordered=true", headers=_auth(token)).json()
+    assert [it["store_name"] for it in page["items"]] == ["下过单的店"] * 3
+    assert all(it["ordered"] for it in page["items"])
+    assert page["next_cursor"] is None
+
+    # 游标只在「已下单」集合内走 —— 不会把没下单的记录算进一页的 limit 里
+    p1 = client.get(
+        "/api/v1/compare/records?ordered=true&limit=2", headers=_auth(token)
+    ).json()
+    assert len(p1["items"]) == 2
+    assert p1["next_cursor"] is not None
+    p2 = client.get(
+        f"/api/v1/compare/records?ordered=true&limit=2&cursor={p1['next_cursor']}",
+        headers=_auth(token),
+    ).json()
+    assert [it["store_name"] for it in p2["items"]] == ["下过单的店"]
+    # 两页不重叠,合起来正好 3 条
+    assert len({it["id"] for it in p1["items"] + p2["items"]}) == 3
+
+    # 别人的下单不该让本人记录进「已下单」
+    token_b = _login(client, "13800002014")
+    pb = _food_payload("of-b")
+    pb["store_name"] = "下过单的店"
+    client.post("/api/v1/compare/record", json=pb, headers=_auth(token_b))
+    assert client.get(
+        "/api/v1/compare/records?ordered=true", headers=_auth(token_b)
+    ).json()["items"] == []
+
+
+def test_records_keyword_search(client) -> None:
+    """keyword 按店名 / 菜名模糊搜(忽略大小写),LIKE 通配符只当字面量;搜索结果也能翻页。
+
+    菜名走写路径派生的 product_names 文本列 —— items 是 JSON,SQLite 下中文被 ensure_ascii
+    转义,直接 LIKE 搜不到。
+    """
+    token = _login(client, "13800002015")
+
+    b = _food_payload("kw-b")
+    b["store_name"] = "Pizza Hut"
+    b["items"] = [{"name": "榴莲比萨", "qty": 1}]
+    client.post("/api/v1/compare/record", json=b, headers=_auth(token))
+
+    c = _food_payload("kw-c")
+    c["store_name"] = "100%纯牛肉汉堡"
+    c["items"] = [{"name": "双层牛肉堡", "qty": 1}]
+    client.post("/api/v1/compare/record", json=c, headers=_auth(token))
+
+    # 默认 payload 的店名是「海底捞(朝阳店)」
+    client.post("/api/v1/compare/record", json=_food_payload("kw-a"), headers=_auth(token))
+
+    def _search(kw: str, **extra) -> list[str]:
+        r = client.get(
+            "/api/v1/compare/records",
+            params={"keyword": kw, **extra},
+            headers=_auth(token),
+        )
+        assert r.status_code == 200, r.text
+        return [it["store_name"] for it in r.json()["items"]]
+
+    assert _search("海底捞") == ["海底捞(朝阳店)"]          # 店名命中
+    assert _search("榴莲") == ["Pizza Hut"]                  # 菜名命中(product_names)
+    assert _search("pizza") == ["Pizza Hut"]                 # 忽略大小写
+    assert _search("PIZZA") == ["Pizza Hut"]
+    assert _search("不存在的店") == []                        # 没命中就是空
+    # 通配符只当普通字符:搜 % 不该把整表拉回来,搜 _ 也不该匹配任意单字符
+    assert _search("%") == ["100%纯牛肉汉堡"]
+    assert _search("_") == []
+    # 纯空白等同不传 → 不过滤
+    assert len(_search("   ")) == 3
+
+    # 搜索结果自身可翻页
+    for i in range(3):
+        p = _food_payload(f"kw-page-{i}")
+        p["store_name"] = "连锁烤鱼店"
+        client.post("/api/v1/compare/record", json=p, headers=_auth(token))
+    p1 = client.get(
+        "/api/v1/compare/records",
+        params={"keyword": "烤鱼", "limit": 2},
+        headers=_auth(token),
+    ).json()
+    assert len(p1["items"]) == 2
+    assert p1["next_cursor"] is not None
+    p2 = client.get(
+        "/api/v1/compare/records",
+        params={"keyword": "烤鱼", "limit": 2, "cursor": p1["next_cursor"]},
+        headers=_auth(token),
+    ).json()
+    assert [it["store_name"] for it in p2["items"]] == ["连锁烤鱼店"]
+    assert len({it["id"] for it in p1["items"] + p2["items"]}) == 3
+
+
 def test_requires_auth(client) -> None:
     """不带 token 统一 401。"""
     assert client.post("/api/v1/compare/record", json={"trace_id": "t"}).status_code == 401

tests/test_inactivity_reset.py

@@ -42,9 +42,9 @@ def test_reset_cutoff_is_cn_midnight_of_today_minus_days_minus_1() -> None:
 
 
 def test_active_event_constants() -> None:
-    # 首页可见 = event=show + page=home 组合,不在纯 event 名集合里
-    assert activity.HOME_VIEW_EVENT == "show" and activity.HOME_VIEW_PAGE == "home"
-    assert activity.HOME_VIEW_EVENT not in activity.ACTIVE_EVENTS
+    # 首页可见:前端埋点确认 event=home_visible,单一 event 名,在 ACTIVE_EVENTS 中
+    assert activity.HOME_VISIBLE_EVENT == "home_visible"
+    assert activity.HOME_VISIBLE_EVENT in activity.ACTIVE_EVENTS
     assert "real_compare_start" in activity.ACTIVE_EVENTS
     assert "real_coupon_start" in activity.ACTIVE_EVENTS
     assert activity.ACTIVE_ENGAGE_TYPE == "claim_started"
@@ -133,15 +133,15 @@ def test_last_active_expr_takes_max_of_baseline_and_events() -> None:
         db.close()
 
 
-def test_home_signal_uses_show_event_on_home_page() -> None:
-    """首页可见活跃口径 = event=show + page=home 组合;show 但非 home 页不算活跃。"""
+def test_home_signal_uses_home_visible_event() -> None:
+    """首页可见活跃口径 = event=home_visible(单一事件名,前端埋点已确认);其他事件不算活跃。"""
     from sqlalchemy import select
     db = SessionLocal()
     try:
         base = datetime(2026, 1, 1, tzinfo=timezone.utc)
-        seen = _new_user(db, created_at=base)      # show/home → 活跃
-        _add_event(db, seen, "show", datetime(2026, 1, 10, tzinfo=timezone.utc), page="home")
-        other = _new_user(db, created_at=base)     # show/其他页 → 不算活跃
+        seen = _new_user(db, created_at=base)      # home_visible → 活跃
+        _add_event(db, seen, "home_visible", datetime(2026, 1, 10, tzinfo=timezone.utc))
+        other = _new_user(db, created_at=base)     # 其他事件 → 不算活跃
         _add_event(db, other, "show", datetime(2026, 1, 10, tzinfo=timezone.utc), page="coupon")
         db.commit()
 
@@ -156,8 +156,8 @@ def test_home_signal_uses_show_event_on_home_page() -> None:
                     .where(User.id == uid))
             return activity.norm_utc(db.execute(stmt).scalar_one())
 
-        assert last_active(seen) == datetime(2026, 1, 10, tzinfo=timezone.utc)  # show/home 算
-        assert last_active(other) == base                                       # show/其他页 不算
+        assert last_active(seen) == datetime(2026, 1, 10, tzinfo=timezone.utc)  # home_visible 算
+        assert last_active(other) == base                                       # 其他事件不算
     finally:
         db.rollback()
         db.close()
@@ -194,9 +194,9 @@ def test_run_reset_clears_coin_and_cash_but_preserves_invite_cash() -> None:
         # 末次活跃 = created_at 基线 = 1/10(距 today 22 天 → 应清)
         old = _new_user(db, created_at=datetime(2026, 1, 10, tzinfo=timezone.utc),
                         coin=100, cash=200, invite=300)
-        # 活跃用户:昨天有 home_view → 不清
+        # 活跃用户:昨天有 home_visible → 不清
         fresh = _new_user(db, created_at=datetime(2026, 1, 1, tzinfo=timezone.utc), coin=50)
-        _add_event(db, fresh, "show", datetime(2026, 1, 31, tzinfo=timezone.utc), page="home")
+        _add_event(db, fresh, "home_visible", datetime(2026, 1, 31, tzinfo=timezone.utc))
         db.commit()
 
         stats = inactivity.run_reset_once(db, reset_days=15, today=today)