tangwang · tangwang · tangwang · tangwang
Showing 34 changed files Show diff stats
api/app.py
api/routes/search.py
config/config.yaml
config/dictionaries/style_intent_color.csv
config/dictionaries/style_intent_size.csv
config/loader.py
config/schema.py
context/request_context.py
docs/TODO-意图判断-2.md
docs/TODO-意图判断.md
docs/Untitled
docs/数据统计/options名称和取值统计.md
docs/相关性检索优化说明.md
embeddings/README.md
embeddings/config.py
embeddings/image_encoder.py
embeddings/server.py
embeddings/text_embedding_tei.py
embeddings/text_encoder.py
query/query_parser.py
@@ -27,6 +27,8 @@ from slowapi.errors import RateLimitExceeded
 # Configure backend logging
 import pathlib
+from request_log_context import LOG_LINE_FORMAT, RequestLogContextFilter
+
 def configure_backend_logging() -> None:
     log_dir = pathlib.Path("logs")
@@ -34,9 +36,8 @@ def configure_backend_logging() -&gt; None:
     log_level = os.getenv("LOG_LEVEL", "INFO").upper()
     numeric_level = getattr(logging, log_level, logging.INFO)
-    default_formatter = logging.Formatter(
-        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
+    default_formatter = logging.Formatter(LOG_LINE_FORMAT)
+    request_filter = RequestLogContextFilter()
     root_logger = logging.getLogger()
     root_logger.setLevel(numeric_level)
@@ -45,6 +46,7 @@ def configure_backend_logging() -&gt; None:
     console_handler = logging.StreamHandler()
     console_handler.setLevel(numeric_level)
     console_handler.setFormatter(default_formatter)
+    console_handler.addFilter(request_filter)
     root_logger.addHandler(console_handler)
     backend_handler = TimedRotatingFileHandler(
@@ -56,6 +58,7 @@ def configure_backend_logging() -&gt; None:
     )
     backend_handler.setLevel(numeric_level)
     backend_handler.setFormatter(default_formatter)
+    backend_handler.addFilter(request_filter)
     root_logger.addHandler(backend_handler)
     verbose_logger = logging.getLogger("backend.verbose")
@@ -71,11 +74,16 @@ def configure_backend_logging() -&gt; None:
         encoding="utf-8",
     )
     verbose_handler.setLevel(numeric_level)
-    verbose_handler.setFormatter(
-        logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-    )
+    verbose_handler.setFormatter(logging.Formatter(LOG_LINE_FORMAT))
+    verbose_handler.addFilter(request_filter)
     verbose_logger.addHandler(verbose_handler)
+    for logger_name in ("uvicorn", "uvicorn.error", "uvicorn.access"):
+        uvicorn_logger = logging.getLogger(logger_name)
+        uvicorn_logger.handlers.clear()
+        uvicorn_logger.setLevel(numeric_level)
+        uvicorn_logger.propagate = True
+
 configure_backend_logging()
 logger = logging.getLogger(__name__)
@@ -101,6 +109,16 @@ _suggestion_service: Optional[SuggestionService] = None
 _app_config = None
+def _request_log_extra_from_http(request: Request) -> dict:
+    reqid = getattr(getattr(request, "state", None), "reqid", None) or request.headers.get("X-Request-ID")
+    uid = (
+        getattr(getattr(request, "state", None), "uid", None)
+        or request.headers.get("X-User-ID")
+        or request.headers.get("User-ID")
+    )
+    return {"reqid": reqid or "-1", "uid": uid or "-1"}
+
+
 def init_service(es_host: str = "http://localhost:9200"):
     """
     Initialize search service with unified configuration.
@@ -261,7 +279,11 @@ async def shutdown_event():
 async def global_exception_handler(request: Request, exc: Exception):
     """Global exception handler with detailed logging."""
     client_ip = request.client.host if request.client else "unknown"
-    logger.error(f"Unhandled exception from {client_ip}: {exc}", exc_info=True)
+    logger.error(
+        f"Unhandled exception from {client_ip}: {exc}",
+        exc_info=True,
+        extra=_request_log_extra_from_http(request),
+    )
     return JSONResponse(
         status_code=500,
@@ -276,7 +298,10 @@ async def global_exception_handler(request: Request, exc: Exception):
 @app.exception_handler(HTTPException)
 async def http_exception_handler(request: Request, exc: HTTPException):
     """HTTP exception handler."""
-    logger.warning(f"HTTP exception from {request.client.host if request.client else 'unknown'}: {exc.status_code} - {exc.detail}")
+    logger.warning(
+        f"HTTP exception from {request.client.host if request.client else 'unknown'}: {exc.status_code} - {exc.detail}",
+        extra=_request_log_extra_from_http(request),
+    )
     return JSONResponse(
         status_code=exc.status_code,
@@ -59,6 +59,8 @@ async def search(request: SearchRequest, http_request: Request):
     Requires tenant_id in header (X-Tenant-ID) or query parameter (tenant_id).
     """
     reqid, uid = extract_request_info(http_request)
+    http_request.state.reqid = reqid
+    http_request.state.uid = uid
     # Extract tenant_id (required)
     tenant_id = http_request.headers.get('X-Tenant-ID')
@@ -213,6 +215,8 @@ async def search_by_image(request: ImageSearchRequest, http_request: Request):
     Requires tenant_id in header (X-Tenant-ID) or query parameter (tenant_id).
     """
     reqid, uid = extract_request_info(http_request)
+    http_request.state.reqid = reqid
+    http_request.state.uid = uid
     # Extract tenant_id (required)
     tenant_id = http_request.headers.get('X-Tenant-ID')
@@ -17,9 +17,9 @@ runtime:
   embedding_port: 6005
   embedding_text_port: 6005
   embedding_image_port: 6008
-  translator_host: "127.0.0.1"
+  translator_host: "0.0.0.0"
   translator_port: 6006
-  reranker_host: "127.0.0.1"
+  reranker_host: "0.0.0.0"
   reranker_port: 6007
 # 基础设施连接（敏感项优先读环境变量：ES_*、REDIS_*、DB_*、DASHSCOPE_API_KEY、DEEPL_AUTH_KEY）
@@ -116,6 +116,14 @@ query_config:
   translation_embedding_wait_budget_ms_source_in_index: 500 # 80
   translation_embedding_wait_budget_ms_source_not_in_index: 500 #200
+  style_intent:
+    enabled: true
+    color_dictionary_path: "config/dictionaries/style_intent_color.csv"
+    size_dictionary_path: "config/dictionaries/style_intent_size.csv"
+    dimension_aliases:
+      color: ["color", "colors", "colour", "colours", "颜色", "色", "色系"]
+      size: ["size", "sizes", "sizing", "尺码", "尺寸", "码数", "号码", "码"]
+
   # 动态多语言检索字段配置
   # multilingual_fields 会被拼成 title.{lang}/brief.{lang}/... 形式；
   # shared_fields 为无语言后缀字段。
@@ -186,6 +194,10 @@ query_config:
     - total_inventory
     - option1_name
     - option1_values
+    - option2_name
+    - option2_values
+    - option3_name
+    - option3_values
     - specifications
     - skus
@@ -0,0 +1,15 @@
+black,black,blk,黑,黑色
+white,white,wht,白,白色
+red,red,reddish,红,红色
+blue,blue,blu,蓝,蓝色
+green,green,grn,绿,绿色
+yellow,yellow,ylw,黄,黄色
+pink,pink,粉,粉色
+purple,purple,violet,紫,紫色
+gray,gray,grey,灰,灰色
+brown,brown,棕,棕色,咖啡色
+beige,beige,khaki,米色,卡其色
+navy,navy,navy blue,藏青,藏蓝,深蓝
+silver,silver,银,银色
+gold,gold,金,金色
+orange,orange,橙,橙色
@@ -0,0 +1,8 @@
+xs,xs,extra small,x-small,加小码
+s,s,small,小码,小号
+m,m,medium,中码,中号
+l,l,large,大码,大号
+xl,xl,x-large,extra large,加大码
+xxl,xxl,2xl,xx-large,双加大码
+xxxl,xxxl,3xl,xxx-large,三加大码
+one size,one size,onesize,free size,均码
@@ -95,6 +95,29 @@ def _read_rewrite_dictionary(path: Path) -&gt; Dict[str, str]:
     return rewrite_dict
+def _read_synonym_csv_dictionary(path: Path) -> List[List[str]]:
+    rows: List[List[str]] = []
+    if not path.exists():
+        return rows
+
+    with open(path, "r", encoding="utf-8") as handle:
+        for raw_line in handle:
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            parts = [segment.strip() for segment in line.split(",")]
+            normalized = [segment for segment in parts if segment]
+            if normalized:
+                rows.append(normalized)
+    return rows
+
+
+_DEFAULT_STYLE_INTENT_DIMENSION_ALIASES: Dict[str, List[str]] = {
+    "color": ["color", "colors", "colour", "colours", "颜色", "色", "色系"],
+    "size": ["size", "sizes", "sizing", "尺码", "尺寸", "码数", "号码", "码"],
+}
+
+
 class AppConfigLoader:
     """Load the unified application configuration."""
@@ -253,6 +276,45 @@ class AppConfigLoader:
             if isinstance(query_cfg.get("text_query_strategy"), dict)
             else {}
         )
+        style_intent_cfg = (
+            query_cfg.get("style_intent")
+            if isinstance(query_cfg.get("style_intent"), dict)
+            else {}
+        )
+
+        def _resolve_project_path(value: Any, default_path: Path) -> Path:
+            if value in (None, ""):
+                return default_path
+            candidate = Path(str(value))
+            if candidate.is_absolute():
+                return candidate
+            return self.project_root / candidate
+
+        style_color_path = _resolve_project_path(
+            style_intent_cfg.get("color_dictionary_path"),
+            self.config_dir / "dictionaries" / "style_intent_color.csv",
+        )
+        style_size_path = _resolve_project_path(
+            style_intent_cfg.get("size_dictionary_path"),
+            self.config_dir / "dictionaries" / "style_intent_size.csv",
+        )
+        configured_dimension_aliases = (
+            style_intent_cfg.get("dimension_aliases")
+            if isinstance(style_intent_cfg.get("dimension_aliases"), dict)
+            else {}
+        )
+        style_dimension_aliases: Dict[str, List[str]] = {}
+        for intent_type, default_aliases in _DEFAULT_STYLE_INTENT_DIMENSION_ALIASES.items():
+            aliases = configured_dimension_aliases.get(intent_type)
+            if isinstance(aliases, list) and aliases:
+                style_dimension_aliases[intent_type] = [str(alias) for alias in aliases if str(alias).strip()]
+            else:
+                style_dimension_aliases[intent_type] = list(default_aliases)
+
+        style_intent_terms = {
+            "color": _read_synonym_csv_dictionary(style_color_path),
+            "size": _read_synonym_csv_dictionary(style_size_path),
+        }
         query_config = QueryConfig(
             supported_languages=list(query_cfg.get("supported_languages") or ["zh", "en"]),
             default_language=str(query_cfg.get("default_language") or "en"),
@@ -324,6 +386,9 @@ class AppConfigLoader:
             translation_embedding_wait_budget_ms_source_not_in_index=int(
                 query_cfg.get("translation_embedding_wait_budget_ms_source_not_in_index", 200)
             ),
+            style_intent_enabled=bool(style_intent_cfg.get("enabled", True)),
+            style_intent_terms=style_intent_terms,
+            style_intent_dimension_aliases=style_dimension_aliases,
         )
         function_score_cfg = raw.get("function_score") if isinstance(raw.get("function_score"), dict) else {}
@@ -64,6 +64,9 @@ class QueryConfig:
     # 检测语言不在 index_languages 内：翻译对召回更关键，预算较长。
     translation_embedding_wait_budget_ms_source_in_index: int = 80
     translation_embedding_wait_budget_ms_source_not_in_index: int = 200
+    style_intent_enabled: bool = True
+    style_intent_terms: Dict[str, List[List[str]]] = field(default_factory=dict)
+    style_intent_dimension_aliases: Dict[str, List[str]] = field(default_factory=dict)
 @dataclass(frozen=True)
@@ -12,6 +12,8 @@ from typing import Dict, Any, Optional, List
 from dataclasses import dataclass, field
 import uuid
+from request_log_context import bind_request_log_context, reset_request_log_context
+
 class RequestContextStage(Enum):
     """搜索阶段枚举"""
@@ -375,9 +377,15 @@ def get_current_request_context() -&gt; Optional[RequestContext]:
 def set_current_request_context(context: RequestContext) -> None:
     """设置当前线程的请求上下文"""
     threading.current_thread().request_context = context
+    _, _, tokens = bind_request_log_context(context.reqid, context.uid)
+    threading.current_thread().request_log_tokens = tokens
 def clear_current_request_context() -> None:
     """清除当前线程的请求上下文"""
+    tokens = getattr(threading.current_thread(), 'request_log_tokens', None)
+    if tokens is not None:
+        reset_request_log_context(tokens)
+        delattr(threading.current_thread(), 'request_log_tokens')
     if hasattr(threading.current_thread(), 'request_context'):
         delattr(threading.current_thread(), 'request_context')
 \ No newline at end of file
@@ -0,0 +1,40 @@
+
+一、 增加款式意图识别模块
+意图类型： 颜色，尺码（目前只需要支持这两种）
+
+
+二、 意图判断
+- 意图召回层：
+每种意图，有一个召回词集合
+对query（包括原始query、各种翻译query 都做匹配）
+- 以颜色意图为例：
+有一个词表，每一行 都逗号分割，互为同义词，行内第一个为标准化词
+query匹配了其中任何一个词，都认为，具有颜色意图
+匹配规则： 用细粒度、粗粒度分词，看是否有在词表中的。原始query分词、和每种翻译的分词，都要用。
+
+
+三、 意图使用：
+  当前 SKU 置顶逻辑在「分页 + 详情回填」之后
+流程是：run_rerank → 按 from/size 切片 → page fill → _apply_sku_sorting_for_page_hits → ResultFormatter
+  要改为：  
+  1. 有款式意图的时候，才做sku筛选  
+  2. sku筛选的时机，改为在reranker之前，对所有内容（rerank输入的所有spus）做sku筛选
+  3. 从仅 option1 扩展到多个维度，识别的意图，包含意图的维度名（color）和维度名的泛化词list（color、颜色、colour、colors...），遍历spu的option1_name,option2_name,option3_name字段，看哪个能匹配上意图的维度名list，哪个匹配上了，则在这个维度筛选。
+    1. 比如匹配到option2_name，那么取每一个sku的option2_values。如果没匹配到任何一个，那么把三个属性值都用空格拼接起来。这个值要记录下来。有两个作用：
+      1. 用来跟query匹配，看哪个更query相关性更高，以此进行最优sku筛选，把选出来的sku置顶，并替换spu的image_url
+      2. 用来做rerank doc的title补充，从而参与rerank
+  4. Rerank doc （有款式意图的时候）要带上属性后缀，拼接到title后面。在调用 run_rerank 前，对每条 hit 生成「用于重排的 doc 文本」（标题 + 可选后缀）  
+
+- sku筛选的规则也要优化： 
+现在的逻辑是，先做包含的判断，找到第一个 option_value被query包含的，则直接认为匹配。没有匹配的再用embedding相似度。
+改为： 
+  1. 第一轮：遍历完，如果有且仅有一个被query包含，那么认为匹配。  
+  2. 第二轮：如果有多个符合（被query包含），跳到3。如果没有，对每个词都走泛化词表进行匹配。  
+  3. 第三轮：如果有多个，那么对这多个，走embedding相关性取最高的。如果一个也没有，则对所有的走embedding相关性取最高的
+  这个sku筛选也需要提取为一个独立的模块。
+
+细节备注：
+在重排窗口内，第一次 ES 查询会把 _source 裁成「重排模板需要的字段」，默认只有 title 等，不包含 skus / option*_name。因此，有意图的时候，需要给这一次的_source加上 skus / option*_name  
+
+5. TODO： 搜索接口里，results[].skus 不是全量子 SKU：由 sku_filter_dimension 控制在应用层按维度分组折叠，每个「维度取值组合」只保留一条 SKU（组内第一条）。请求未传该字段时，Pydantic 默认是 ["option1"]，等价于只按 option1_value 去重；服务端不会读取店铺主题的「主展示维」，需调用方与装修配置对齐并传入正确维度。因此当用户有款式等更细粒度意图、而款式落在 option2/option3（或对应 option*_name）时，若仍用默认只按 option1（常见为颜色）折叠，同一颜色下多种款式只会出现一条代表 SKU，无法从返回的 skus 里拿到该颜色下的全部款式行。（若业务需要全量子款，需传包含对应维度的 sku_filter_dimension，或传 null/[] 跳过折叠——以当前 ResultFormatter 实现为准。）
+
@@ -0,0 +1,53 @@
+
+
+增加款式意图识别模块。意图类型： 颜色，尺码（目前只需要支持这两种）
+
+一、 意图判断
+- 意图召回层：
+每种意图，有一个召回词集合
+对query（包括原始query、各种翻译query 都做匹配）
+- 以颜色意图为例：
+有一个词表，每一行 都逗号分割，互为同义词，行内第一个为标准化词
+query匹配了其中任何一个词，都认为，具有颜色意图
+匹配规则： 用细粒度、粗粒度分词，看是否有在词表中的。原始query分词、和每种翻译的分词，都要用。
+
+二、 意图使用：
+  当前 SKU 置顶逻辑在「分页 + 详情回填」之后
+流程是：run_rerank → 按 from/size 切片 → page fill → _apply_sku_sorting_for_page_hits → ResultFormatter
+  要改为：  
+  1. 有款式意图的时候，才做sku筛选  
+  2. sku筛选的时机，改为在reranker之前，对所有内容（rerank输入的所有spus）做sku筛选
+  3. 从仅 option1 扩展到多个维度，识别的意图，包含意图的维度名（color）和维度名的泛化词list（color、颜色、colour、colors...），遍历spu的option1_name,option2_name,option3_name字段，看哪个能匹配上意图的维度名list，哪个匹配上了，则在这个维度筛选。
+    1. 比如匹配到option2_name，那么取每一个sku的option2_values。如果没匹配到任何一个，那么把三个属性值都用空格拼接起来。这个值要记录下来。有两个作用：
+      1. 用来跟query匹配，看哪个更query相关性更高，以此进行最优sku筛选，把选出来的sku置顶，并替换spu的image_url
+      2. 用来做rerank doc的title补充，从而参与rerank
+  4. Rerank doc （有款式意图的时候）要带上属性后缀，拼接到title后面。在调用 run_rerank 前，对每条 hit 生成「用于重排的 doc 文本」（标题 + 可选后缀）  
+
+- sku筛选的规则也要优化： 
+现在的逻辑是，先做包含的判断，找到第一个 option_value被query包含的，则直接认为匹配。没有匹配的再用embedding相似度。
+改为： 
+  1. 第一轮：遍历完，如果有且仅有一个被query包含，那么认为匹配。  
+  2. 第二轮：如果有多个符合（被query包含），跳到3。如果没有，对每个词都走泛化词表进行匹配。  
+  3. 第三轮：如果有多个，那么对这多个，走embedding相关性取最高的。如果一个也没有，则对所有的走embedding相关性取最高的
+  这个sku筛选也需要提取为一个独立的模块。
+
+细节备注：
+intent 考虑由 QueryParser 编排、具体实现拆成独立模块，主义好，现有的分词等基础设施的复用，缺失的英文分词可以补充。
+在重排窗口内，第一次 ES 查询会把 _source 裁成「重排模板需要的字段」，默认只有 title 等，不包含 skus / option*_name。因此，有意图的时候，需要给这一次的_source加上 skus / option*_name  
+
+先仔细理解需求，查看代码，深度思考应该如何设计，和当前的系统较好的融合，给出统一的设计，可以根据需要适当改造当前的实现，降低整个系统的复杂度，提高模块化程度，而不是打补丁。修改后的最终状态应该是要足够简单、清晰、无冗余和分叉，模块间低耦合。多步思考确认最佳施工方案之后才进行代码修改。
+
+5. TODO： 搜索接口里，results[].skus 不是全量子 SKU：由 sku_filter_dimension 控制在应用层按维度分组折叠，每个「维度取值组合」只保留一条 SKU（组内第一条）。请求未传该字段时，Pydantic 默认是 ["option1"]，等价于只按 option1_value 去重；服务端不会读取店铺主题的「主展示维」，需调用方与装修配置对齐并传入正确维度。因此当用户有款式等更细粒度意图、而款式落在 option2/option3（或对应 option*_name）时，若仍用默认只按 option1（常见为颜色）折叠，同一颜色下多种款式只会出现一条代表 SKU，无法从返回的 skus 里拿到该颜色下的全部款式行。（若业务需要全量子款，需传包含对应维度的 sku_filter_dimension，或传 null/[] 跳过折叠——以当前 ResultFormatter 实现为准。）
+
+
+
+
+
+GPT5.4 主要思路：
+我准备按这条线改，尽量把逻辑收束成两个新模块而不是继续堆在 Searcher 里：
+
+QueryParser 负责产出统一的“款式意图分析结果”，包含：命中的意图类型、标准化值、命中的 query 变体、分词结果、维度候选词。
+独立的 SKU 选择模块负责：维度解析、候选值抽取、三阶段匹配、选中 SKU 后的主图替换，以及生成 rerank 用的属性后缀。
+Searcher 只编排：解析 query -> 首次 ES 召回 -> 若有款式意图则对 rerank 窗口内全部 hits 做 SKU 预筛选并补充 rerank doc 文本 -> run_rerank -> 分页 -> page fill -> ResultFormatter。这样旧的页内 SKU 置顶逻辑可以下沉或删除，避免前后两个阶段重复做同一件事。我再补看一下你最近写的意图草稿文档，确认有没有现成词表示例或边界条件，避免我这边把词表格式和你预期做偏。
+
+
@@ -0,0 +1,38 @@
+
+一、 增加款式意图识别模块
+意图类型： 颜色，尺码（目前只需要支持这两种）
+
+
+二、 意图判断
+- 意图召回层：
+每种意图，有一个召回词集合
+对query（包括原始query、各种翻译query 都做匹配）
+- 以颜色意图为例：
+有一个词表，每一行 都逗号分割，互为同义词，行内第一个为标准化词
+query匹配了其中任何一个词，都认为，具有颜色意图
+匹配规则： 用细粒度、粗粒度分词，看是否有在词表中的。原始query分词、和每种翻译的分词，都要用。
+
+
+三、 意图使用：
+  当前 SKU 置顶逻辑在「分页 + 详情回填」之后
+流程是：run_rerank → 按 from/size 切片 → page fill → _apply_sku_sorting_for_page_hits → ResultFormatter
+  要改为：  
+  1. 有款式意图的时候，才做sku筛选  
+  2. sku筛选的时机，改为在reranker之前，对所有内容（rerank输入的所有spus）做sku筛选
+  3. 从仅 option1 扩展到多个维度，识别的意图，包含意图的维度名（color）和维度名的泛化词list（color、颜色、colour、colors...），遍历spu的option1_name,option2_name,option3_name字段，看哪个能匹配上意图的维度名list，哪个匹配上了，则在这个维度筛选。
+    1. 比如匹配到option2_name，那么取每一个sku的option2_values。如果没匹配到任何一个，那么把三个属性值都用空格拼接起来。这个值要记录下来。有两个作用：
+      1. 用来跟query匹配，看哪个更query相关性更高，以此进行最优sku筛选，把选出来的sku置顶，并替换spu的image_url
+      2. 用来做rerank doc的title补充，从而参与rerank
+  4. Rerank doc （有款式意图的时候）要带上属性后缀，拼接到title后面。在调用 run_rerank 前，对每条 hit 生成「用于重排的 doc 文本」（标题 + 可选后缀）  
+
+- sku筛选的规则也要优化： 
+现在的逻辑是，先做包含的判断，找到第一个 option_value被query包含的，则直接认为匹配。没有匹配的再用embedding相似度。
+改为： 
+  1. 第一轮：遍历完，如果有且仅有一个被query包含，那么认为匹配。  
+  2. 第二轮：如果有多个符合（被query包含），跳到3。如果没有，对每个词都走泛化词表进行匹配。  
+  3. 第三轮：如果有多个，那么对这多个，走embedding相关性取最高的。如果一个也没有，则对所有的走embedding相关性取最高的
+  这个sku筛选也需要提取为一个独立的模块。
+
+细节备注：
+intent 考虑由 QueryParser 编排、具体实现拆成独立模块，主义好，现有的分词等基础设施的复用，缺失的英文分词可以补充。
+在重排窗口内，第一次 ES 查询会把 _source 裁成「重排模板需要的字段」，默认只有 title 等，不包含 skus / option*_name。因此，有意图的时候，需要给这一次的_source加上 skus / option*_name  
@@ -0,0 +1,118 @@
+
+## prompt
+参考 @docs/常用查询 - ES.md 帮我查询 tenant_Id=163的@search_products.json (1314-1332) 这些字段的统计分布，也就是这里每个字段的所有的值及其对应的文档数
+
+
+已按 `docs/常用查询 - ES.md` 的写法，在索引 **`search_products_tenant_163`** 上做了 `terms` 聚合（租户已按索引拆分，用 `match_all` 即可，等价于只查 tenant 163）。集群在本机 `localhost:9200` 上执行成功。
+
+## 结果概要
+
+- **总文档数**：8977  
+- 六个字段的 **`sum_other_doc_count` 均为 0**，在 `size: 20000` 下没有截断，即：**当前数据里每个字段的取值都已全部列出**。  
+- **`__missing__`**：来自聚合里的 `"missing": "__missing__"`，表示该字段缺失或为空的文档数（便于和「有值」一起看）。  
+- **`option1_values` / `option2_values`** 多为多值数组：同一篇文档可落入多个桶，因此 **各桶 `doc_count` 之和会大于 8977**（这是 ES `terms` 的正常语义，表示「含该取值的文档数」，不是互斥分区）。  
+- **`option1_name` / `option2_name` / `option3_name`** 及 **`option3_values`** 的桶计数之和与文档关系更接近单值/稀疏（见下方校验）。
+
+### `option1_name`（13 个取值）
+
+| 值 | 文档数 |
+|---:|---:|
+| __missing__ | 4538 |
+| Size | 2916 |
+| Color | 1174 |
+| 颜色 | 244 |
+| COLOR | 56 |
+| color | 16 |
+| Colour | 15 |
+| Variant | 9 |
+| Style | 3 |
+| Colors | 2 |
+| Scent | 2 |
+| Cup Size | 1 |
+| Pattern Name | 1 |
+
+### `option2_name`（13 个取值）
+
+| 值 | 文档数 |
+|---:|---:|
+| __missing__ | 4666 |
+| Color | 2879 |
+| Size | 1134 |
+| 尺码 | 244 |
+| SIZE | 17 |
+| size | 16 |
+| Style | 12 |
+| Cup Size | 4 |
+| Item Package Quantity | 1 |
+| Number of Items | 1 |
+| Ring Size | 1 |
+| Scent | 1 |
+| Team Name | 1 |
+
+### `option3_name`（11 个取值）
+
+| 值 | 文档数 |
+|---:|---:|
+| __missing__ | 8831 |
+| Fit Type | 52 |
+| Special Size | 31 |
+| Number of Items | 17 |
+| Special Size Type | 16 |
+| Team Name | 15 |
+| Material Type | 8 |
+| Style | 4 |
+| Configuration | 1 |
+| Hand Orientation | 1 |
+| Pattern Name | 1 |
+
+### `option1_values` / `option2_values`
+
+- **桶数量**：`option1_values` **3463**，`option2_values` **3605**（完整列表过长，不宜贴在对话里）。  
+- **文档中出现最多的取值（前 10）**  
+  - **option1_values**：`__missing__` 4538，其后如 Medium 749、Black 653、Large 635、8/9/White/10/7/Small…  
+  - **option2_values**：`__missing__` 4666，其后如 L 1161、M 1158、S 1064、XL 1036、Black 876…  
+
+### `option3_values`（94 个桶，已全部枚举）
+
+除 `__missing__` 8831 外，另有 93 个具体取值；上文 Markdown 表里已列全（从 Standard 到 `standard` 等）。
+
+---
+
+## 可复用的查询（与文档一致）
+
+```bash
+curl -sS -u 'saas:4hOaLaf41y2VuI8y' -X GET 'http://localhost:9200/search_products_tenant_163/_search?pretty' \
+  -H 'Content-Type: application/json' -d '{
+  "query": { "match_all": {} },
+  "size": 0,
+  "track_total_hits": true,
+  "aggs": {
+    "option1_name_dist": {
+      "terms": { "field": "option1_name", "size": 20000, "order": { "_count": "desc" }, "missing": "__missing__" }
+    },
+    "option2_name_dist": {
+      "terms": { "field": "option2_name", "size": 20000, "order": { "_count": "desc" }, "missing": "__missing__" }
+    },
+    "option3_name_dist": {
+      "terms": { "field": "option3_name", "size": 20000, "order": { "_count": "desc" }, "missing": "__missing__" }
+    },
+    "option1_values_dist": {
+      "terms": { "field": "option1_values", "size": 20000, "order": { "_count": "desc" }, "missing": "__missing__" }
+    },
+    "option2_values_dist": {
+      "terms": { "field": "option2_values", "size": 20000, "order": { "_count": "desc" }, "missing": "__missing__" }
+    },
+    "option3_values_dist": {
+      "terms": { "field": "option3_values", "size": 20000, "order": { "_count": "desc" }, "missing": "__missing__" }
+    }
+  }
+}'
+```
+
+若某租户取值超过 2 万，需把 `size` 再加大或用 **composite** 分页扫完全部桶。
+
+## 完整 JSON（含 3463 + 3605 条 value 分布）
+
+已整理为：`/tmp/tenant163_option_fields_distribution.json`（约 620KB），结构为按字段分组的 `values: [{ "value", "doc_count" }, ...]`，便于你用脚本或表格工具打开。
+
+如需去掉 `__missing__` 桶，从请求里删掉各聚合中的 `"missing": "__missing__"` 即可。
 \ No newline at end of file
@@ -17,9 +17,9 @@
 查询链路（文本相关）：
 1. `QueryParser.parse()`  
-   负责产出解析事实：`query_normalized`、`rewritten_query`、`detected_language`、`translations`、`query_vector`、`query_tokens`、`contains_chinese`、`contains_english`。
+   负责产出解析事实：`query_normalized`、`rewritten_query`、`detected_language`、`translations`、`query_vector`、`query_tokens`。
 2. `Searcher.search()`  
-   负责读取租户 `index_languages`，并将其一方面传给 `QueryParser` 作为 `target_languages`，另一方面传给 `ESQueryBuilder` 作为字段展开约束。
+   负责读取租户 `index_languages`，并将其传给 `QueryParser` 作为 `target_languages`（控制翻译目标语种）；`ESQueryBuilder` 仅根据 `detected_language` 与各条译文构建子句字段，不再接收 `index_languages`。
 2. `ESQueryBuilder._build_advanced_text_query()`  
    基于 `rewritten_query + detected_language + translations + index_languages` 构建 `base_query` 与 `base_query_trans_*`；并按语言动态拼接 `title/brief/description/vendor/category_*` 的 `.{lang}` 字段，叠加 shared 字段（`tags`、`option*_values`）。
 3. `build_query()`  
@@ -76,9 +76,6 @@
 最终按 `bool.should` 组合，`minimum_should_match: 1`。
-> **附 — 混写辅助召回**  
-> 当中英（或多脚本）混写时，为略抬召回：`QueryParser` 用 `contains_chinese`（文中有汉字）、`contains_english`（分词中有长度 ≥3 的纯英文 token）打标；`ESQueryBuilder` 在某一语言的 `multi_match` 上，按规则把**另一语种**的同类字段并入同一 `fields`（受 `index_languages` 限制），并入列的 boost 为配置值再乘 **`mixed_script_merged_field_boost_scale`（默认 0.6，`ESQueryBuilder` 构造参数）**。字段在内部以 `(path, boost)` 列表合并后再格式化为 ES 字符串。
-
 ## 5. 关键配置项（文本策略）
 `query_config` 下与解析等待相关的项：
@@ -147,11 +144,9 @@
   - `translations`
   - `query_vector`
   - `query_tokens`
-  - `contains_chinese` / `contains_english`
 - `Searcher` 负责“租户语境”：
   - `index_languages`
   - 将其传给 parser 作为 `target_languages`
-  - 将其传给 builder 作为字段展开约束
 - `ESQueryBuilder` 负责“表达式展开”：
   - 动态字段组装
   - 子句权重分配
@@ -5,6 +5,8 @@
 - `../docs/TEI_SERVICE说明文档.md`
 - `../docs/CNCLIP_SERVICE说明文档.md`
+**请求日志串联（reqid / uid）**：统一实现在仓库根目录的 `request_log_context.py`（勿放到 `utils/` 下，以免 `.venv-embedding` 因 `utils/__init__.py` 拉取数据库依赖）。Uvicorn 日志配置见 `config/uvicorn_embedding_logging.json`。
+
 ---
 这个目录是一个完整的“向量化模块”，包含：
@@ -2,6 +2,7 @@
 from __future__ import annotations
+import os
 from typing import Optional
 from config.loader import get_app_config
@@ -25,6 +26,11 @@ class EmbeddingConfig(object):
         self.TEXT_NORMALIZE_EMBEDDINGS = bool(text_backend.get("normalize_embeddings", True))
         self.TEI_BASE_URL = str(text_backend.get("base_url") or "http://127.0.0.1:8080")
         self.TEI_TIMEOUT_SEC = int(text_backend.get("timeout_sec", 60))
+        self.TEI_MAX_CLIENT_BATCH_SIZE = int(
+            os.getenv("TEI_MAX_CLIENT_BATCH_SIZE")
+            or text_backend.get("max_client_batch_size")
+            or 24
+        )
         self.USE_CLIP_AS_SERVICE = services.image_backend == "clip_as_service"
         self.CLIP_AS_SERVICE_SERVER = str(image_backend.get("server") or "grpc://127.0.0.1:51000")
@@ -13,6 +13,7 @@ from config.loader import get_app_config
 from config.services_config import get_embedding_image_base_url
 from embeddings.cache_keys import build_image_cache_key
 from embeddings.redis_embedding_cache import RedisEmbeddingCache
+from request_log_context import build_downstream_request_headers, build_request_log_extra
 class CLIPImageEncoder:
@@ -40,6 +41,8 @@ class CLIPImageEncoder:
         request_data: List[str],
         normalize_embeddings: bool = True,
         priority: int = 0,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> List[Any]:
         """
         Call the embedding service API.
@@ -50,6 +53,7 @@ class CLIPImageEncoder:
         Returns:
             List of embeddings (list[float]) or nulls (None), aligned to input order
         """
+        response = None
         try:
             response = requests.post(
                 self.endpoint,
@@ -58,12 +62,26 @@ class CLIPImageEncoder:
                     "priority": max(0, int(priority)),
                 },
                 json=request_data,
+                headers=build_downstream_request_headers(request_id=request_id, user_id=user_id),
                 timeout=60
             )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
-            logger.error(f"CLIPImageEncoder service request failed: {e}", exc_info=True)
+            body_preview = ""
+            if response is not None:
+                try:
+                    body_preview = (response.text or "")[:300]
+                except Exception:
+                    body_preview = ""
+            logger.error(
+                "CLIPImageEncoder service request failed | status=%s body=%s error=%s",
+                getattr(response, "status_code", "n/a"),
+                body_preview,
+                e,
+                exc_info=True,
+                extra=build_request_log_extra(request_id=request_id, user_id=user_id),
+            )
             raise
     def encode_image(self, image: Image.Image) -> np.ndarray:
@@ -79,6 +97,8 @@ class CLIPImageEncoder:
         url: str,
         normalize_embeddings: bool = True,
         priority: int = 0,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> np.ndarray:
         """
         Generate image embedding via network service using URL.
@@ -98,6 +118,8 @@ class CLIPImageEncoder:
             [url],
             normalize_embeddings=normalize_embeddings,
             priority=priority,
+            request_id=request_id,
+            user_id=user_id,
         )
         if not response_data or len(response_data) != 1 or response_data[0] is None:
             raise RuntimeError(f"No image embedding returned for URL: {url}")
@@ -113,6 +135,8 @@ class CLIPImageEncoder:
         batch_size: int = 8,
         normalize_embeddings: bool = True,
         priority: int = 0,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> List[np.ndarray]:
         """
         Encode a batch of images efficiently via network service.
@@ -151,6 +175,8 @@ class CLIPImageEncoder:
                 batch_urls,
                 normalize_embeddings=normalize_embeddings,
                 priority=priority,
+                request_id=request_id,
+                user_id=user_id,
             )
             if not response_data or len(response_data) != len(batch_urls):
                 raise RuntimeError(
@@ -176,6 +202,8 @@ class CLIPImageEncoder:
         batch_size: Optional[int] = None,
         normalize_embeddings: bool = True,
         priority: int = 0,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> List[np.ndarray]:
         """
         与 ClipImageModel / ClipAsServiceImageEncoder 一致的接口，供索引器 document_transformer 调用。
@@ -192,4 +220,6 @@ class CLIPImageEncoder:
             batch_size=batch_size or 8,
             normalize_embeddings=normalize_embeddings,
             priority=priority,
+            request_id=request_id,
+            user_id=user_id,
         )
@@ -26,17 +26,17 @@ from embeddings.cache_keys import build_image_cache_key, build_text_cache_key
 from embeddings.config import CONFIG
 from embeddings.protocols import ImageEncoderProtocol
 from embeddings.redis_embedding_cache import RedisEmbeddingCache
+from request_log_context import (
+    LOG_LINE_FORMAT,
+    RequestLogContextFilter,
+    bind_request_log_context,
+    build_request_log_extra,
+    reset_request_log_context,
+)
 app = FastAPI(title="saas-search Embedding Service", version="1.0.0")
-class _DefaultRequestIdFilter(logging.Filter):
-    def filter(self, record: logging.LogRecord) -> bool:
-        if not hasattr(record, "reqid"):
-            record.reqid = "-1"
-        return True
-
-
 def configure_embedding_logging() -> None:
     root_logger = logging.getLogger()
     if getattr(root_logger, "_embedding_logging_configured", False):
@@ -47,17 +47,15 @@ def configure_embedding_logging() -&gt; None:
     log_level = os.getenv("LOG_LEVEL", "INFO").upper()
     numeric_level = getattr(logging, log_level, logging.INFO)
-    formatter = logging.Formatter(
-        "%(asctime)s | reqid:%(reqid)s | %(name)s | %(levelname)s | %(message)s"
-    )
-    request_filter = _DefaultRequestIdFilter()
+    formatter = logging.Formatter(LOG_LINE_FORMAT)
+    context_filter = RequestLogContextFilter()
     root_logger.setLevel(numeric_level)
     root_logger.handlers.clear()
     stream_handler = logging.StreamHandler()
     stream_handler.setLevel(numeric_level)
     stream_handler.setFormatter(formatter)
-    stream_handler.addFilter(request_filter)
+    stream_handler.addFilter(context_filter)
     root_logger.addHandler(stream_handler)
     verbose_logger = logging.getLogger("embedding.verbose")
@@ -231,6 +229,7 @@ class _TextDispatchTask:
     normalized: List[str]
     effective_normalize: bool
     request_id: str
+    user_id: str
     priority: int
     created_at: float
     done: threading.Event
@@ -321,12 +320,13 @@ def _text_dispatch_worker_loop(worker_idx: int) -&gt; None:
                 _priority_label(task.priority),
                 len(task.normalized),
                 queue_wait_ms,
-                extra=_request_log_extra(task.request_id),
+                extra=build_request_log_extra(task.request_id, task.user_id),
             )
             task.result = _embed_text_impl(
                 task.normalized,
                 task.effective_normalize,
                 task.request_id,
+                task.user_id,
                 task.priority,
             )
         except Exception as exc:
@@ -339,6 +339,7 @@ def _submit_text_dispatch_and_wait(
     normalized: List[str],
     effective_normalize: bool,
     request_id: str,
+    user_id: str,
     priority: int,
 ) -> _EmbedResult:
     if not any(worker.is_alive() for worker in _text_dispatch_workers):
@@ -347,6 +348,7 @@ def _submit_text_dispatch_and_wait(
         normalized=normalized,
         effective_normalize=effective_normalize,
         request_id=request_id,
+        user_id=user_id,
         priority=_effective_priority(priority),
         created_at=time.perf_counter(),
         done=threading.Event(),
@@ -380,6 +382,7 @@ class _SingleTextTask:
     priority: int
     created_at: float
     request_id: str
+    user_id: str
     done: threading.Event
     result: Optional[List[float]] = None
     error: Optional[Exception] = None
@@ -435,10 +438,6 @@ def _preview_vector(vec: Optional[List[float]], max_dims: int = _VECTOR_PREVIEW_
     return [round(float(v), 6) for v in vec[:max_dims]]
-def _request_log_extra(request_id: str) -> Dict[str, str]:
-    return {"reqid": request_id}
-
-
 def _resolve_request_id(http_request: Request) -> str:
     header_value = http_request.headers.get("X-Request-ID")
     if header_value and header_value.strip():
@@ -446,6 +445,13 @@ def _resolve_request_id(http_request: Request) -&gt; str:
     return str(uuid.uuid4())[:8]
+def _resolve_user_id(http_request: Request) -> str:
+    header_value = http_request.headers.get("X-User-ID") or http_request.headers.get("User-ID")
+    if header_value and header_value.strip():
+        return header_value.strip()[:64]
+    return "-1"
+
+
 def _request_client(http_request: Request) -> str:
     client = getattr(http_request, "client", None)
     host = getattr(client, "host", None)
@@ -522,18 +528,21 @@ def _text_batch_worker_loop() -&gt; None:
         try:
             queue_wait_ms = [(time.perf_counter() - task.created_at) * 1000.0 for task in batch]
             reqids = [task.request_id for task in batch]
+            uids = [task.user_id for task in batch]
             logger.info(
-                "text microbatch dispatch | size=%d priority=%s queue_wait_ms_min=%.2f queue_wait_ms_max=%.2f reqids=%s preview=%s",
+                "text microbatch dispatch | size=%d priority=%s queue_wait_ms_min=%.2f queue_wait_ms_max=%.2f reqids=%s uids=%s preview=%s",
                 len(batch),
                 _priority_label(max(task.priority for task in batch)),
                 min(queue_wait_ms) if queue_wait_ms else 0.0,
                 max(queue_wait_ms) if queue_wait_ms else 0.0,
                 reqids,
+                uids,
                 _preview_inputs(
                     [task.text for task in batch],
                     _LOG_PREVIEW_COUNT,
                     _LOG_TEXT_PREVIEW_CHARS,
                 ),
+                extra=build_request_log_extra(),
             )
             batch_t0 = time.perf_counter()
             embs = _encode_local_st([task.text for task in batch], normalize_embeddings=False)
@@ -548,19 +557,23 @@ def _text_batch_worker_loop() -&gt; None:
                     raise RuntimeError("Text model returned empty embedding in micro-batch")
                 task.result = vec
             logger.info(
-                "text microbatch done | size=%d reqids=%s dim=%d backend_elapsed_ms=%.2f",
+                "text microbatch done | size=%d reqids=%s uids=%s dim=%d backend_elapsed_ms=%.2f",
                 len(batch),
                 reqids,
+                uids,
                 len(batch[0].result) if batch and batch[0].result is not None else 0,
                 (time.perf_counter() - batch_t0) * 1000.0,
+                extra=build_request_log_extra(),
             )
         except Exception as exc:
             logger.error(
-                "text microbatch failed | size=%d reqids=%s error=%s",
+                "text microbatch failed | size=%d reqids=%s uids=%s error=%s",
                 len(batch),
                 [task.request_id for task in batch],
+                [task.user_id for task in batch],
                 exc,
                 exc_info=True,
+                extra=build_request_log_extra(),
             )
             for task in batch:
                 task.error = exc
@@ -573,6 +586,7 @@ def _encode_single_text_with_microbatch(
     text: str,
     normalize: bool,
     request_id: str,
+    user_id: str,
     priority: int,
 ) -> List[float]:
     task = _SingleTextTask(
@@ -581,6 +595,7 @@ def _encode_single_text_with_microbatch(
         priority=_effective_priority(priority),
         created_at=time.perf_counter(),
         request_id=request_id,
+        user_id=user_id,
         done=threading.Event(),
     )
     with _text_single_queue_cv:
@@ -632,6 +647,9 @@ def load_models():
                 _text_model = TEITextModel(
                     base_url=str(base_url),
                     timeout_sec=timeout_sec,
+                    max_client_batch_size=int(
+                        backend_cfg.get("max_client_batch_size") or CONFIG.TEI_MAX_CLIENT_BATCH_SIZE
+                    ),
                 )
             elif backend_name == "local_st":
                 from embeddings.text_embedding_sentence_transformers import Qwen3TextModel
@@ -823,6 +841,7 @@ def _embed_text_impl(
     normalized: List[str],
     effective_normalize: bool,
     request_id: str,
+    user_id: str,
     priority: int = 0,
 ) -> _EmbedResult:
     if _text_model is None:
@@ -854,7 +873,7 @@ def _embed_text_impl(
             effective_normalize,
             len(out[0]) if out and out[0] is not None else 0,
             cache_hits,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         return _EmbedResult(
             vectors=out,
@@ -873,6 +892,7 @@ def _embed_text_impl(
                         missing_texts[0],
                         normalize=effective_normalize,
                         request_id=request_id,
+                        user_id=user_id,
                         priority=priority,
                     )
                 ]
@@ -905,7 +925,7 @@ def _embed_text_impl(
             "Text embedding backend failure: %s",
             e,
             exc_info=True,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         raise RuntimeError(f"Text embedding backend failure: {e}") from e
@@ -931,7 +951,7 @@ def _embed_text_impl(
         cache_hits,
         len(missing_texts),
         backend_elapsed_ms,
-        extra=_request_log_extra(request_id),
+        extra=build_request_log_extra(request_id, user_id),
     )
     return _EmbedResult(
         vectors=out,
@@ -954,75 +974,79 @@ async def embed_text(
         raise HTTPException(status_code=503, detail="Text embedding model not loaded in this service")
     request_id = _resolve_request_id(http_request)
+    user_id = _resolve_user_id(http_request)
+    _, _, log_tokens = bind_request_log_context(request_id, user_id)
     response.headers["X-Request-ID"] = request_id
-
-    if priority < 0:
-        raise HTTPException(status_code=400, detail="priority must be >= 0")
-    effective_priority = _effective_priority(priority)
-    effective_normalize = bool(CONFIG.TEXT_NORMALIZE_EMBEDDINGS) if normalize is None else bool(normalize)
-    normalized: List[str] = []
-    for i, t in enumerate(texts):
-        if not isinstance(t, str):
-            raise HTTPException(status_code=400, detail=f"Invalid text at index {i}: must be string")
-        s = t.strip()
-        if not s:
-            raise HTTPException(status_code=400, detail=f"Invalid text at index {i}: empty string")
-        normalized.append(s)
-
-    cache_check_started = time.perf_counter()
-    cache_only = _try_full_text_cache_hit(normalized, effective_normalize)
-    if cache_only is not None:
-        latency_ms = (time.perf_counter() - cache_check_started) * 1000.0
-        _text_stats.record_completed(
-            success=True,
-            latency_ms=latency_ms,
-            backend_latency_ms=0.0,
-            cache_hits=cache_only.cache_hits,
-            cache_misses=0,
-        )
-        logger.info(
-            "embed_text response | backend=%s mode=cache-only priority=%s inputs=%d normalize=%s dim=%d cache_hits=%d cache_misses=0 first_vector=%s latency_ms=%.2f",
-            _text_backend_name,
-            _priority_label(effective_priority),
-            len(normalized),
-            effective_normalize,
-            len(cache_only.vectors[0]) if cache_only.vectors and cache_only.vectors[0] is not None else 0,
-            cache_only.cache_hits,
-            _preview_vector(cache_only.vectors[0] if cache_only.vectors else None),
-            latency_ms,
-            extra=_request_log_extra(request_id),
-        )
-        return cache_only.vectors
-
-    accepted, active = _text_request_limiter.try_acquire(bypass_limit=effective_priority > 0)
-    if not accepted:
-        _text_stats.record_rejected()
-        logger.warning(
-            "embed_text rejected | client=%s backend=%s priority=%s inputs=%d normalize=%s active=%d limit=%d preview=%s",
-            _request_client(http_request),
-            _text_backend_name,
-            _priority_label(effective_priority),
-            len(normalized),
-            effective_normalize,
-            active,
-            _TEXT_MAX_INFLIGHT,
-            _preview_inputs(normalized, _LOG_PREVIEW_COUNT, _LOG_TEXT_PREVIEW_CHARS),
-            extra=_request_log_extra(request_id),
-        )
-        raise HTTPException(
-            status_code=_OVERLOAD_STATUS_CODE,
-            detail=(
-                "Text embedding service busy for priority=0 requests: "
-                f"active={active}, limit={_TEXT_MAX_INFLIGHT}"
-            ),
-        )
-
+    response.headers["X-User-ID"] = user_id
     request_started = time.perf_counter()
     success = False
     backend_elapsed_ms = 0.0
     cache_hits = 0
     cache_misses = 0
+    limiter_acquired = False
+
     try:
+        if priority < 0:
+            raise HTTPException(status_code=400, detail="priority must be >= 0")
+        effective_priority = _effective_priority(priority)
+        effective_normalize = bool(CONFIG.TEXT_NORMALIZE_EMBEDDINGS) if normalize is None else bool(normalize)
+        normalized: List[str] = []
+        for i, t in enumerate(texts):
+            if not isinstance(t, str):
+                raise HTTPException(status_code=400, detail=f"Invalid text at index {i}: must be string")
+            s = t.strip()
+            if not s:
+                raise HTTPException(status_code=400, detail=f"Invalid text at index {i}: empty string")
+            normalized.append(s)
+
+        cache_check_started = time.perf_counter()
+        cache_only = _try_full_text_cache_hit(normalized, effective_normalize)
+        if cache_only is not None:
+            latency_ms = (time.perf_counter() - cache_check_started) * 1000.0
+            _text_stats.record_completed(
+                success=True,
+                latency_ms=latency_ms,
+                backend_latency_ms=0.0,
+                cache_hits=cache_only.cache_hits,
+                cache_misses=0,
+            )
+            logger.info(
+                "embed_text response | backend=%s mode=cache-only priority=%s inputs=%d normalize=%s dim=%d cache_hits=%d cache_misses=0 first_vector=%s latency_ms=%.2f",
+                _text_backend_name,
+                _priority_label(effective_priority),
+                len(normalized),
+                effective_normalize,
+                len(cache_only.vectors[0]) if cache_only.vectors and cache_only.vectors[0] is not None else 0,
+                cache_only.cache_hits,
+                _preview_vector(cache_only.vectors[0] if cache_only.vectors else None),
+                latency_ms,
+                extra=build_request_log_extra(request_id, user_id),
+            )
+            return cache_only.vectors
+
+        accepted, active = _text_request_limiter.try_acquire(bypass_limit=effective_priority > 0)
+        if not accepted:
+            _text_stats.record_rejected()
+            logger.warning(
+                "embed_text rejected | client=%s backend=%s priority=%s inputs=%d normalize=%s active=%d limit=%d preview=%s",
+                _request_client(http_request),
+                _text_backend_name,
+                _priority_label(effective_priority),
+                len(normalized),
+                effective_normalize,
+                active,
+                _TEXT_MAX_INFLIGHT,
+                _preview_inputs(normalized, _LOG_PREVIEW_COUNT, _LOG_TEXT_PREVIEW_CHARS),
+                extra=build_request_log_extra(request_id, user_id),
+            )
+            raise HTTPException(
+                status_code=_OVERLOAD_STATUS_CODE,
+                detail=(
+                    "Text embedding service busy for priority=0 requests: "
+                    f"active={active}, limit={_TEXT_MAX_INFLIGHT}"
+                ),
+            )
+        limiter_acquired = True
         logger.info(
             "embed_text request | client=%s backend=%s priority=%s inputs=%d normalize=%s active=%d limit=%d preview=%s",
             _request_client(http_request),
@@ -1033,7 +1057,7 @@ async def embed_text(
             active,
             _TEXT_MAX_INFLIGHT,
             _preview_inputs(normalized, _LOG_PREVIEW_COUNT, _LOG_TEXT_PREVIEW_CHARS),
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         verbose_logger.info(
             "embed_text detail | payload=%s normalize=%s backend=%s priority=%s",
@@ -1041,13 +1065,14 @@ async def embed_text(
             effective_normalize,
             _text_backend_name,
             _priority_label(effective_priority),
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         result = await run_in_threadpool(
             _submit_text_dispatch_and_wait,
             normalized,
             effective_normalize,
             request_id,
+            user_id,
             effective_priority,
         )
         success = True
@@ -1074,7 +1099,7 @@ async def embed_text(
             cache_misses,
             _preview_vector(result.vectors[0] if result.vectors else None),
             latency_ms,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         verbose_logger.info(
             "embed_text result detail | count=%d priority=%s first_vector=%s latency_ms=%.2f",
@@ -1084,7 +1109,7 @@ async def embed_text(
             if result.vectors and result.vectors[0] is not None
             else [],
             latency_ms,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         return result.vectors
     except HTTPException:
@@ -1107,24 +1132,27 @@ async def embed_text(
             latency_ms,
             e,
             exc_info=True,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         raise HTTPException(status_code=502, detail=str(e)) from e
     finally:
-        remaining = _text_request_limiter.release(success=success)
-        logger.info(
-            "embed_text finalize | success=%s priority=%s active_after=%d",
-            success,
-            _priority_label(effective_priority),
-            remaining,
-            extra=_request_log_extra(request_id),
-        )
+        if limiter_acquired:
+            remaining = _text_request_limiter.release(success=success)
+            logger.info(
+                "embed_text finalize | success=%s priority=%s active_after=%d",
+                success,
+                _priority_label(effective_priority),
+                remaining,
+                extra=build_request_log_extra(request_id, user_id),
+            )
+        reset_request_log_context(log_tokens)
 def _embed_image_impl(
     urls: List[str],
     effective_normalize: bool,
     request_id: str,
+    user_id: str,
 ) -> _EmbedResult:
     if _image_model is None:
         raise RuntimeError("Image model not loaded")
@@ -1154,7 +1182,7 @@ def _embed_image_impl(
             effective_normalize,
             len(out[0]) if out and out[0] is not None else 0,
             cache_hits,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         return _EmbedResult(
             vectors=out,
@@ -1194,7 +1222,7 @@ def _embed_image_impl(
         cache_hits,
         len(missing_urls),
         backend_elapsed_ms,
-        extra=_request_log_extra(request_id),
+        extra=build_request_log_extra(request_id, user_id),
     )
     return _EmbedResult(
         vectors=out,
@@ -1217,74 +1245,78 @@ async def embed_image(
         raise HTTPException(status_code=503, detail="Image embedding model not loaded in this service")
     request_id = _resolve_request_id(http_request)
+    user_id = _resolve_user_id(http_request)
+    _, _, log_tokens = bind_request_log_context(request_id, user_id)
     response.headers["X-Request-ID"] = request_id
-
-    if priority < 0:
-        raise HTTPException(status_code=400, detail="priority must be >= 0")
-    effective_priority = _effective_priority(priority)
-
-    effective_normalize = bool(CONFIG.IMAGE_NORMALIZE_EMBEDDINGS) if normalize is None else bool(normalize)
-    urls: List[str] = []
-    for i, url_or_path in enumerate(images):
-        if not isinstance(url_or_path, str):
-            raise HTTPException(status_code=400, detail=f"Invalid image at index {i}: must be string URL/path")
-        s = url_or_path.strip()
-        if not s:
-            raise HTTPException(status_code=400, detail=f"Invalid image at index {i}: empty URL/path")
-        urls.append(s)
-
-    cache_check_started = time.perf_counter()
-    cache_only = _try_full_image_cache_hit(urls, effective_normalize)
-    if cache_only is not None:
-        latency_ms = (time.perf_counter() - cache_check_started) * 1000.0
-        _image_stats.record_completed(
-            success=True,
-            latency_ms=latency_ms,
-            backend_latency_ms=0.0,
-            cache_hits=cache_only.cache_hits,
-            cache_misses=0,
-        )
-        logger.info(
-            "embed_image response | mode=cache-only priority=%s inputs=%d normalize=%s dim=%d cache_hits=%d cache_misses=0 first_vector=%s latency_ms=%.2f",
-            _priority_label(effective_priority),
-            len(urls),
-            effective_normalize,
-            len(cache_only.vectors[0]) if cache_only.vectors and cache_only.vectors[0] is not None else 0,
-            cache_only.cache_hits,
-            _preview_vector(cache_only.vectors[0] if cache_only.vectors else None),
-            latency_ms,
-            extra=_request_log_extra(request_id),
-        )
-        return cache_only.vectors
-
-    accepted, active = _image_request_limiter.try_acquire(bypass_limit=effective_priority > 0)
-    if not accepted:
-        _image_stats.record_rejected()
-        logger.warning(
-            "embed_image rejected | client=%s priority=%s inputs=%d normalize=%s active=%d limit=%d preview=%s",
-            _request_client(http_request),
-            _priority_label(effective_priority),
-            len(urls),
-            effective_normalize,
-            active,
-            _IMAGE_MAX_INFLIGHT,
-            _preview_inputs(urls, _LOG_PREVIEW_COUNT, _LOG_IMAGE_PREVIEW_CHARS),
-            extra=_request_log_extra(request_id),
-        )
-        raise HTTPException(
-            status_code=_OVERLOAD_STATUS_CODE,
-            detail=(
-                "Image embedding service busy for priority=0 requests: "
-                f"active={active}, limit={_IMAGE_MAX_INFLIGHT}"
-            ),
-        )
-
+    response.headers["X-User-ID"] = user_id
     request_started = time.perf_counter()
     success = False
     backend_elapsed_ms = 0.0
     cache_hits = 0
     cache_misses = 0
+    limiter_acquired = False
+
     try:
+        if priority < 0:
+            raise HTTPException(status_code=400, detail="priority must be >= 0")
+        effective_priority = _effective_priority(priority)
+
+        effective_normalize = bool(CONFIG.IMAGE_NORMALIZE_EMBEDDINGS) if normalize is None else bool(normalize)
+        urls: List[str] = []
+        for i, url_or_path in enumerate(images):
+            if not isinstance(url_or_path, str):
+                raise HTTPException(status_code=400, detail=f"Invalid image at index {i}: must be string URL/path")
+            s = url_or_path.strip()
+            if not s:
+                raise HTTPException(status_code=400, detail=f"Invalid image at index {i}: empty URL/path")
+            urls.append(s)
+
+        cache_check_started = time.perf_counter()
+        cache_only = _try_full_image_cache_hit(urls, effective_normalize)
+        if cache_only is not None:
+            latency_ms = (time.perf_counter() - cache_check_started) * 1000.0
+            _image_stats.record_completed(
+                success=True,
+                latency_ms=latency_ms,
+                backend_latency_ms=0.0,
+                cache_hits=cache_only.cache_hits,
+                cache_misses=0,
+            )
+            logger.info(
+                "embed_image response | mode=cache-only priority=%s inputs=%d normalize=%s dim=%d cache_hits=%d cache_misses=0 first_vector=%s latency_ms=%.2f",
+                _priority_label(effective_priority),
+                len(urls),
+                effective_normalize,
+                len(cache_only.vectors[0]) if cache_only.vectors and cache_only.vectors[0] is not None else 0,
+                cache_only.cache_hits,
+                _preview_vector(cache_only.vectors[0] if cache_only.vectors else None),
+                latency_ms,
+                extra=build_request_log_extra(request_id, user_id),
+            )
+            return cache_only.vectors
+
+        accepted, active = _image_request_limiter.try_acquire(bypass_limit=effective_priority > 0)
+        if not accepted:
+            _image_stats.record_rejected()
+            logger.warning(
+                "embed_image rejected | client=%s priority=%s inputs=%d normalize=%s active=%d limit=%d preview=%s",
+                _request_client(http_request),
+                _priority_label(effective_priority),
+                len(urls),
+                effective_normalize,
+                active,
+                _IMAGE_MAX_INFLIGHT,
+                _preview_inputs(urls, _LOG_PREVIEW_COUNT, _LOG_IMAGE_PREVIEW_CHARS),
+                extra=build_request_log_extra(request_id, user_id),
+            )
+            raise HTTPException(
+                status_code=_OVERLOAD_STATUS_CODE,
+                detail=(
+                    "Image embedding service busy for priority=0 requests: "
+                    f"active={active}, limit={_IMAGE_MAX_INFLIGHT}"
+                ),
+            )
+        limiter_acquired = True
         logger.info(
             "embed_image request | client=%s priority=%s inputs=%d normalize=%s active=%d limit=%d preview=%s",
             _request_client(http_request),
@@ -1294,16 +1326,16 @@ async def embed_image(
             active,
             _IMAGE_MAX_INFLIGHT,
             _preview_inputs(urls, _LOG_PREVIEW_COUNT, _LOG_IMAGE_PREVIEW_CHARS),
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         verbose_logger.info(
             "embed_image detail | payload=%s normalize=%s priority=%s",
             urls,
             effective_normalize,
             _priority_label(effective_priority),
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
-        result = await run_in_threadpool(_embed_image_impl, urls, effective_normalize, request_id)
+        result = await run_in_threadpool(_embed_image_impl, urls, effective_normalize, request_id, user_id)
         success = True
         backend_elapsed_ms = result.backend_elapsed_ms
         cache_hits = result.cache_hits
@@ -1327,7 +1359,7 @@ async def embed_image(
             cache_misses,
             _preview_vector(result.vectors[0] if result.vectors else None),
             latency_ms,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         verbose_logger.info(
             "embed_image result detail | count=%d first_vector=%s latency_ms=%.2f",
@@ -1336,7 +1368,7 @@ async def embed_image(
             if result.vectors and result.vectors[0] is not None
             else [],
             latency_ms,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         return result.vectors
     except HTTPException:
@@ -1358,15 +1390,17 @@ async def embed_image(
             latency_ms,
             e,
             exc_info=True,
-            extra=_request_log_extra(request_id),
+            extra=build_request_log_extra(request_id, user_id),
         )
         raise HTTPException(status_code=502, detail=f"Image embedding backend failure: {e}") from e
     finally:
-        remaining = _image_request_limiter.release(success=success)
-        logger.info(
-            "embed_image finalize | success=%s priority=%s active_after=%d",
-            success,
-            _priority_label(effective_priority),
-            remaining,
-            extra=_request_log_extra(request_id),
-        )
+        if limiter_acquired:
+            remaining = _image_request_limiter.release(success=success)
+            logger.info(
+                "embed_image finalize | success=%s priority=%s active_after=%d",
+                success,
+                _priority_label(effective_priority),
+                remaining,
+                extra=build_request_log_extra(request_id, user_id),
+            )
+        reset_request_log_context(log_tokens)
@@ -2,11 +2,14 @@
 from __future__ import annotations
+import logging
 from typing import Any, List, Union
 import numpy as np
 import requests
+logger = logging.getLogger(__name__)
+
 class TEITextModel:
     """
@@ -18,12 +21,13 @@ class TEITextModel:
       response: [[...], [...], ...]
     """
-    def __init__(self, base_url: str, timeout_sec: int = 60):
+    def __init__(self, base_url: str, timeout_sec: int = 60, max_client_batch_size: int = 24):
         if not base_url or not str(base_url).strip():
             raise ValueError("TEI base_url must not be empty")
         self.base_url = str(base_url).rstrip("/")
         self.endpoint = f"{self.base_url}/embed"
         self.timeout_sec = int(timeout_sec)
+        self.max_client_batch_size = max(1, int(max_client_batch_size))
         self._health_check()
     def _health_check(self) -> None:
@@ -72,16 +76,28 @@ class TEITextModel:
             if not isinstance(t, str) or not t.strip():
                 raise ValueError(f"Invalid input text at index {i}: {t!r}")
-        response = requests.post(
-            self.endpoint,
-            json={"inputs": texts},
-            timeout=self.timeout_sec,
-        )
-        response.raise_for_status()
-        payload = response.json()
-        vectors = self._parse_payload(payload, expected_len=len(texts))
-        if normalize_embeddings:
-            vectors = [self._normalize(vec) for vec in vectors]
+        if len(texts) > self.max_client_batch_size:
+            logger.info(
+                "TEI batch split | total_inputs=%d chunk_size=%d chunks=%d",
+                len(texts),
+                self.max_client_batch_size,
+                (len(texts) + self.max_client_batch_size - 1) // self.max_client_batch_size,
+            )
+
+        vectors: List[np.ndarray] = []
+        for start in range(0, len(texts), self.max_client_batch_size):
+            batch = texts[start : start + self.max_client_batch_size]
+            response = requests.post(
+                self.endpoint,
+                json={"inputs": batch},
+                timeout=self.timeout_sec,
+            )
+            response.raise_for_status()
+            payload = response.json()
+            parsed = self._parse_payload(payload, expected_len=len(batch))
+            if normalize_embeddings:
+                parsed = [self._normalize(vec) for vec in parsed]
+            vectors.extend(parsed)
         return np.array(vectors, dtype=object)
     def _parse_payload(self, payload: Any, expected_len: int) -> List[np.ndarray]:
@@ -13,6 +13,7 @@ from config.loader import get_app_config
 from config.services_config import get_embedding_text_base_url
 from embeddings.cache_keys import build_text_cache_key
 from embeddings.redis_embedding_cache import RedisEmbeddingCache
+from request_log_context import build_downstream_request_headers, build_request_log_extra
 class TextEmbeddingEncoder:
@@ -40,6 +41,8 @@ class TextEmbeddingEncoder:
         request_data: List[str],
         normalize_embeddings: bool = True,
         priority: int = 0,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> List[Any]:
         """
         Call the embedding service API.
@@ -50,6 +53,7 @@ class TextEmbeddingEncoder:
         Returns:
             List of embeddings (list[float]) or nulls (None), aligned to input order
         """
+        response = None
         try:
             response = requests.post(
                 self.endpoint,
@@ -58,12 +62,26 @@ class TextEmbeddingEncoder:
                     "priority": max(0, int(priority)),
                 },
                 json=request_data,
+                headers=build_downstream_request_headers(request_id=request_id, user_id=user_id),
                 timeout=60
             )
             response.raise_for_status()
             return response.json()
         except requests.exceptions.RequestException as e:
-            logger.error(f"TextEmbeddingEncoder service request failed: {e}", exc_info=True)
+            body_preview = ""
+            if response is not None:
+                try:
+                    body_preview = (response.text or "")[:300]
+                except Exception:
+                    body_preview = ""
+            logger.error(
+                "TextEmbeddingEncoder service request failed | status=%s body=%s error=%s",
+                getattr(response, "status_code", "n/a"),
+                body_preview,
+                e,
+                exc_info=True,
+                extra=build_request_log_extra(request_id=request_id, user_id=user_id),
+            )
             raise
     def encode(
@@ -72,7 +90,9 @@ class TextEmbeddingEncoder:
         normalize_embeddings: bool = True,
         priority: int = 0,
         device: str = 'cpu',
-        batch_size: int = 32
+        batch_size: int = 32,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
     ) -> np.ndarray:
         """
         Encode text into embeddings via network service with Redis caching.
@@ -113,6 +133,8 @@ class TextEmbeddingEncoder:
                 request_data,
                 normalize_embeddings=normalize_embeddings,
                 priority=priority,
+                request_id=request_id,
+                user_id=user_id,
             )
             # Process response
@@ -12,7 +12,6 @@ from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional, Tuple
 import numpy as np
 import logging
-import re
 from concurrent.futures import ThreadPoolExecutor, wait
 from embeddings.text_encoder import TextEmbeddingEncoder
@@ -20,25 +19,14 @@ from config import SearchConfig
 from translation import create_translation_client
 from .language_detector import LanguageDetector
 from .query_rewriter import QueryRewriter, QueryNormalizer
+from .style_intent import StyleIntentDetector, StyleIntentProfile, StyleIntentRegistry
+from .tokenization import extract_token_strings, simple_tokenize_query
 logger = logging.getLogger(__name__)
 import hanlp  # type: ignore
-def simple_tokenize_query(text: str) -> List[str]:
-    """
-    Lightweight tokenizer for suggestion-side heuristics only.
-
-    - Consecutive CJK characters form one token
-    - Latin / digit runs (with internal hyphens) form tokens
-    """
-    if not text:
-        return []
-    pattern = re.compile(r"[\u4e00-\u9fff]+|[A-Za-z0-9_]+(?:-[A-Za-z0-9_]+)*")
-    return pattern.findall(text)
-
-
 @dataclass(slots=True)
 class ParsedQuery:
     """Container for query parser facts."""
@@ -50,8 +38,7 @@ class ParsedQuery:
     translations: Dict[str, str] = field(default_factory=dict)
     query_vector: Optional[np.ndarray] = None
     query_tokens: List[str] = field(default_factory=list)
-    contains_chinese: bool = False
-    contains_english: bool = False
+    style_intent_profile: Optional[StyleIntentProfile] = None
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary representation."""
@@ -62,8 +49,9 @@ class ParsedQuery:
             "detected_language": self.detected_language,
             "translations": self.translations,
             "query_tokens": self.query_tokens,
-            "contains_chinese": self.contains_chinese,
-            "contains_english": self.contains_english,
+            "style_intent_profile": (
+                self.style_intent_profile.to_dict() if self.style_intent_profile is not None else None
+            ),
         }
@@ -101,6 +89,11 @@ class QueryParser:
         self.language_detector = LanguageDetector()
         self.rewriter = QueryRewriter(config.query_config.rewrite_dictionary)
         self._tokenizer = tokenizer or self._build_tokenizer()
+        self.style_intent_registry = StyleIntentRegistry.from_query_config(config.query_config)
+        self.style_intent_detector = StyleIntentDetector(
+            self.style_intent_registry,
+            tokenizer=self._tokenizer,
+        )
         # Eager initialization (startup-time failure visibility, no lazy init in request path)
         if self.config.query_config.enable_text_embedding and self._text_encoder is None:
@@ -176,47 +169,11 @@ class QueryParser:
     @staticmethod
     def _extract_tokens(tokenizer_result: Any) -> List[str]:
         """Normalize tokenizer output into a flat token string list."""
-        if not tokenizer_result:
-            return []
-        if isinstance(tokenizer_result, str):
-            token = tokenizer_result.strip()
-            return [token] if token else []
-
-        tokens: List[str] = []
-        for item in tokenizer_result:
-            token: Optional[str] = None
-            if isinstance(item, str):
-                token = item
-            elif isinstance(item, (list, tuple)) and item:
-                token = str(item[0])
-            elif item is not None:
-                token = str(item)
-
-            if token is None:
-                continue
-            token = token.strip()
-            if token:
-                tokens.append(token)
-        return tokens
+        return extract_token_strings(tokenizer_result)
     def _get_query_tokens(self, query: str) -> List[str]:
         return self._extract_tokens(self._tokenizer(query))
-    @staticmethod
-    def _contains_cjk(text: str) -> bool:
-        """Whether query contains any CJK ideograph."""
-        return bool(re.search(r"[\u4e00-\u9fff]", text or ""))
-
-    @staticmethod
-    def _is_pure_english_word_token(token: str) -> bool:
-        """
-        A tokenizer token counts as English iff it is letters only (optional internal hyphens)
-        and length >= 3.
-        """
-        if not token or len(token) < 3:
-            return False
-        return bool(re.fullmatch(r"[A-Za-z]+(?:-[A-Za-z]+)*", token))
-
     def parse(
         self,
         query: str,
@@ -285,19 +242,12 @@ class QueryParser:
         log_info(f"Language detection | Detected language: {detected_lang}")
         if context:
             context.store_intermediate_result('detected_language', detected_lang)
-        # Stage 4: Query analysis (tokenization + script flags)
+        # Stage 4: Query analysis (tokenization)
         query_tokens = self._get_query_tokens(query_text)
-        contains_chinese = self._contains_cjk(query_text)
-        contains_english = any(self._is_pure_english_word_token(t) for t in query_tokens)
-        log_debug(
-            f"Query analysis | Query tokens: {query_tokens} | "
-            f"contains_chinese={contains_chinese} | contains_english={contains_english}"
-        )
+        log_debug(f"Query analysis | Query tokens: {query_tokens}")
         if context:
             context.store_intermediate_result('query_tokens', query_tokens)
-            context.store_intermediate_result('contains_chinese', contains_chinese)
-            context.store_intermediate_result('contains_english', contains_english)
         # Stage 5: Translation + embedding. Parser only coordinates async enrichment work; the
         # caller decides translation targets and later search-field planning.
@@ -351,7 +301,12 @@ class QueryParser:
                     log_debug("Submitting query vector generation")
                     def _encode_query_vector() -> Optional[np.ndarray]:
-                        arr = self.text_encoder.encode([query_text], priority=1)
+                        arr = self.text_encoder.encode(
+                            [query_text],
+                            priority=1,
+                            request_id=(context.reqid if context else None),
+                            user_id=(context.uid if context else None),
+                        )
                         if arr is None or len(arr) == 0:
                             return None
                         vec = arr[0]
@@ -451,6 +406,22 @@ class QueryParser:
                 context.store_intermediate_result("translations", translations)
         # Build result
+        base_result = ParsedQuery(
+            original_query=query,
+            query_normalized=normalized,
+            rewritten_query=query_text,
+            detected_language=detected_lang,
+            translations=translations,
+            query_vector=query_vector,
+            query_tokens=query_tokens,
+        )
+        style_intent_profile = self.style_intent_detector.detect(base_result)
+        if context:
+            context.store_intermediate_result(
+                "style_intent_profile",
+                style_intent_profile.to_dict(),
+            )
+
         result = ParsedQuery(
             original_query=query,
             query_normalized=normalized,
@@ -459,8 +430,7 @@ class QueryParser:
             translations=translations,
             query_vector=query_vector,
             query_tokens=query_tokens,
-            contains_chinese=contains_chinese,
-            contains_english=contains_english,
+            style_intent_profile=style_intent_profile,
         )
         if context and hasattr(context, 'logger'):
@@ -0,0 +1,261 @@
+"""
+Style intent detection for query understanding.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Set, Tuple
+
+from .tokenization import TokenizedText, normalize_query_text, tokenize_text
+
+
+@dataclass(frozen=True)
+class StyleIntentDefinition:
+    intent_type: str
+    term_groups: Tuple[Tuple[str, ...], ...]
+    dimension_aliases: Tuple[str, ...]
+    synonym_to_canonical: Dict[str, str]
+    max_term_ngram: int = 3
+
+    @classmethod
+    def from_rows(
+        cls,
+        intent_type: str,
+        rows: Sequence[Sequence[str]],
+        dimension_aliases: Sequence[str],
+    ) -> "StyleIntentDefinition":
+        term_groups: List[Tuple[str, ...]] = []
+        synonym_to_canonical: Dict[str, str] = {}
+        max_ngram = 1
+
+        for row in rows:
+            normalized_terms: List[str] = []
+            for raw_term in row:
+                term = normalize_query_text(raw_term)
+                if not term or term in normalized_terms:
+                    continue
+                normalized_terms.append(term)
+            if not normalized_terms:
+                continue
+
+            canonical = normalized_terms[0]
+            term_groups.append(tuple(normalized_terms))
+            for term in normalized_terms:
+                synonym_to_canonical[term] = canonical
+                max_ngram = max(max_ngram, len(term.split()))
+
+        aliases = tuple(
+            dict.fromkeys(
+                term
+                for term in (
+                    normalize_query_text(alias)
+                    for alias in dimension_aliases
+                )
+                if term
+            )
+        )
+
+        return cls(
+            intent_type=intent_type,
+            term_groups=tuple(term_groups),
+            dimension_aliases=aliases,
+            synonym_to_canonical=synonym_to_canonical,
+            max_term_ngram=max_ngram,
+        )
+
+    def match_candidates(self, candidates: Iterable[str]) -> Set[str]:
+        matched: Set[str] = set()
+        for candidate in candidates:
+            canonical = self.synonym_to_canonical.get(normalize_query_text(candidate))
+            if canonical:
+                matched.add(canonical)
+        return matched
+
+    def match_text(
+        self,
+        text: str,
+        *,
+        tokenizer: Optional[Callable[[str], Any]] = None,
+    ) -> Set[str]:
+        bundle = tokenize_text(text, tokenizer=tokenizer, max_ngram=self.max_term_ngram)
+        return self.match_candidates(bundle.candidates)
+
+
+@dataclass(frozen=True)
+class DetectedStyleIntent:
+    intent_type: str
+    canonical_value: str
+    matched_term: str
+    matched_query_text: str
+    dimension_aliases: Tuple[str, ...]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "intent_type": self.intent_type,
+            "canonical_value": self.canonical_value,
+            "matched_term": self.matched_term,
+            "matched_query_text": self.matched_query_text,
+            "dimension_aliases": list(self.dimension_aliases),
+        }
+
+
+@dataclass(frozen=True)
+class StyleIntentProfile:
+    query_variants: Tuple[TokenizedText, ...] = field(default_factory=tuple)
+    intents: Tuple[DetectedStyleIntent, ...] = field(default_factory=tuple)
+
+    @property
+    def is_active(self) -> bool:
+        return bool(self.intents)
+
+    def get_intents(self, intent_type: Optional[str] = None) -> List[DetectedStyleIntent]:
+        if intent_type is None:
+            return list(self.intents)
+        normalized = normalize_query_text(intent_type)
+        return [intent for intent in self.intents if intent.intent_type == normalized]
+
+    def get_canonical_values(self, intent_type: str) -> Set[str]:
+        return {intent.canonical_value for intent in self.get_intents(intent_type)}
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "active": self.is_active,
+            "intents": [intent.to_dict() for intent in self.intents],
+            "query_variants": [
+                {
+                    "text": variant.text,
+                    "normalized_text": variant.normalized_text,
+                    "fine_tokens": list(variant.fine_tokens),
+                    "coarse_tokens": list(variant.coarse_tokens),
+                    "candidates": list(variant.candidates),
+                }
+                for variant in self.query_variants
+            ],
+        }
+
+
+class StyleIntentRegistry:
+    """Holds style intent vocabularies and matching helpers."""
+
+    def __init__(
+        self,
+        definitions: Dict[str, StyleIntentDefinition],
+        *,
+        enabled: bool = True,
+    ) -> None:
+        self.definitions = definitions
+        self.enabled = bool(enabled)
+
+    @classmethod
+    def from_query_config(cls, query_config: Any) -> "StyleIntentRegistry":
+        style_terms = getattr(query_config, "style_intent_terms", {}) or {}
+        dimension_aliases = getattr(query_config, "style_intent_dimension_aliases", {}) or {}
+        definitions: Dict[str, StyleIntentDefinition] = {}
+
+        for intent_type, rows in style_terms.items():
+            definition = StyleIntentDefinition.from_rows(
+                intent_type=normalize_query_text(intent_type),
+                rows=rows or [],
+                dimension_aliases=dimension_aliases.get(intent_type, []),
+            )
+            if definition.synonym_to_canonical:
+                definitions[definition.intent_type] = definition
+
+        return cls(
+            definitions,
+            enabled=bool(getattr(query_config, "style_intent_enabled", True)),
+        )
+
+    def get_definition(self, intent_type: str) -> Optional[StyleIntentDefinition]:
+        return self.definitions.get(normalize_query_text(intent_type))
+
+    def get_dimension_aliases(self, intent_type: str) -> Tuple[str, ...]:
+        definition = self.get_definition(intent_type)
+        return definition.dimension_aliases if definition else tuple()
+
+
+class StyleIntentDetector:
+    """Detects style intents from parsed query variants."""
+
+    def __init__(
+        self,
+        registry: StyleIntentRegistry,
+        *,
+        tokenizer: Optional[Callable[[str], Any]] = None,
+    ) -> None:
+        self.registry = registry
+        self.tokenizer = tokenizer
+
+    def _build_query_variants(self, parsed_query: Any) -> Tuple[TokenizedText, ...]:
+        seen = set()
+        variants: List[TokenizedText] = []
+        texts = [
+            getattr(parsed_query, "original_query", None),
+            getattr(parsed_query, "query_normalized", None),
+            getattr(parsed_query, "rewritten_query", None),
+        ]
+
+        translations = getattr(parsed_query, "translations", {}) or {}
+        if isinstance(translations, dict):
+            texts.extend(translations.values())
+
+        for raw_text in texts:
+            text = str(raw_text or "").strip()
+            if not text:
+                continue
+            normalized = normalize_query_text(text)
+            if not normalized or normalized in seen:
+                continue
+            seen.add(normalized)
+            variants.append(
+                tokenize_text(
+                    text,
+                    tokenizer=self.tokenizer,
+                    max_ngram=max(
+                        (definition.max_term_ngram for definition in self.registry.definitions.values()),
+                        default=3,
+                    ),
+                )
+            )
+
+        return tuple(variants)
+
+    def detect(self, parsed_query: Any) -> StyleIntentProfile:
+        if not self.registry.enabled or not self.registry.definitions:
+            return StyleIntentProfile()
+
+        query_variants = self._build_query_variants(parsed_query)
+        detected: List[DetectedStyleIntent] = []
+        seen_pairs = set()
+
+        for variant in query_variants:
+            for intent_type, definition in self.registry.definitions.items():
+                matched_canonicals = definition.match_candidates(variant.candidates)
+                if not matched_canonicals:
+                    continue
+
+                for candidate in variant.candidates:
+                    normalized_candidate = normalize_query_text(candidate)
+                    canonical = definition.synonym_to_canonical.get(normalized_candidate)
+                    if not canonical or canonical not in matched_canonicals:
+                        continue
+                    pair = (intent_type, canonical)
+                    if pair in seen_pairs:
+                        continue
+                    seen_pairs.add(pair)
+                    detected.append(
+                        DetectedStyleIntent(
+                            intent_type=intent_type,
+                            canonical_value=canonical,
+                            matched_term=normalized_candidate,
+                            matched_query_text=variant.text,
+                            dimension_aliases=definition.dimension_aliases,
+                        )
+                    )
+                    break
+
+        return StyleIntentProfile(
+            query_variants=query_variants,
+            intents=tuple(detected),
+        )
@@ -0,0 +1,122 @@
+"""
+Shared tokenization helpers for query understanding.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import Any, Callable, Iterable, List, Optional, Sequence, Tuple
+
+
+_TOKEN_PATTERN = re.compile(r"[\u4e00-\u9fff]+|[A-Za-z0-9_]+(?:-[A-Za-z0-9_]+)*")
+
+
+def normalize_query_text(text: Optional[str]) -> str:
+    if text is None:
+        return ""
+    return " ".join(str(text).strip().casefold().split())
+
+
+def simple_tokenize_query(text: str) -> List[str]:
+    """
+    Lightweight tokenizer for coarse query matching.
+
+    - Consecutive CJK characters form one token
+    - Latin / digit runs (with internal hyphens) form tokens
+    """
+    if not text:
+        return []
+    return _TOKEN_PATTERN.findall(text)
+
+
+def extract_token_strings(tokenizer_result: Any) -> List[str]:
+    """Normalize tokenizer output into a flat token string list."""
+    if not tokenizer_result:
+        return []
+    if isinstance(tokenizer_result, str):
+        token = tokenizer_result.strip()
+        return [token] if token else []
+
+    tokens: List[str] = []
+    for item in tokenizer_result:
+        token: Optional[str] = None
+        if isinstance(item, str):
+            token = item
+        elif isinstance(item, (list, tuple)) and item:
+            token = str(item[0])
+        elif item is not None:
+            token = str(item)
+
+        if token is None:
+            continue
+        token = token.strip()
+        if token:
+            tokens.append(token)
+    return tokens
+
+
+def _dedupe_preserve_order(values: Iterable[str]) -> List[str]:
+    result: List[str] = []
+    seen = set()
+    for value in values:
+        normalized = normalize_query_text(value)
+        if not normalized or normalized in seen:
+            continue
+        seen.add(normalized)
+        result.append(normalized)
+    return result
+
+
+def _build_phrase_candidates(tokens: Sequence[str], max_ngram: int) -> List[str]:
+    if not tokens:
+        return []
+
+    phrases: List[str] = []
+    upper = max(1, int(max_ngram))
+    for size in range(1, upper + 1):
+        if size > len(tokens):
+            break
+        for start in range(0, len(tokens) - size + 1):
+            phrase = " ".join(tokens[start:start + size]).strip()
+            if phrase:
+                phrases.append(phrase)
+    return phrases
+
+
+@dataclass(frozen=True)
+class TokenizedText:
+    text: str
+    normalized_text: str
+    fine_tokens: Tuple[str, ...]
+    coarse_tokens: Tuple[str, ...]
+    candidates: Tuple[str, ...]
+
+
+def tokenize_text(
+    text: str,
+    *,
+    tokenizer: Optional[Callable[[str], Any]] = None,
+    max_ngram: int = 3,
+) -> TokenizedText:
+    normalized_text = normalize_query_text(text)
+    coarse_tokens = _dedupe_preserve_order(simple_tokenize_query(text))
+
+    fine_raw = extract_token_strings(tokenizer(text)) if tokenizer is not None and text else []
+    fine_tokens = _dedupe_preserve_order(fine_raw)
+
+    candidates = _dedupe_preserve_order(
+        list(fine_tokens)
+        + list(coarse_tokens)
+        + _build_phrase_candidates(fine_tokens, max_ngram=max_ngram)
+        + _build_phrase_candidates(coarse_tokens, max_ngram=max_ngram)
+        + ([normalized_text] if normalized_text else [])
+    )
+
+    return TokenizedText(
+        text=text,
+        normalized_text=normalized_text,
+        fine_tokens=tuple(fine_tokens),
+        coarse_tokens=tuple(coarse_tokens),
+        candidates=tuple(candidates),
+    )
@@ -0,0 +1,107 @@
+"""
+Request-scoped reqid/uid for logging and downstream HTTP headers.
+
+Kept as a **top-level module** (not under ``utils/``) because ``utils/__init__.py``
+pulls optional deps (e.g. sqlalchemy) that are not installed in ``.venv-embedding``.
+Uvicorn ``--log-config`` and the embedding service must be able to import this module
+without importing the full ``utils`` package.
+"""
+
+from __future__ import annotations
+
+import logging
+from contextvars import ContextVar, Token
+from typing import Dict, Optional, Tuple
+
+_DEFAULT_REQUEST_ID = "-1"
+_DEFAULT_USER_ID = "-1"
+
+_request_id_var: ContextVar[str] = ContextVar("request_log_reqid", default=_DEFAULT_REQUEST_ID)
+_user_id_var: ContextVar[str] = ContextVar("request_log_uid", default=_DEFAULT_USER_ID)
+
+LOG_LINE_FORMAT = (
+    "%(asctime)s | reqid:%(reqid)s | uid:%(uid)s | %(levelname)-8s | %(name)s | %(message)s"
+)
+
+
+def _normalize_value(value: Optional[str], *, fallback: str) -> str:
+    text = str(value or "").strip()
+    return text[:64] if text else fallback
+
+
+def bind_request_log_context(
+    request_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+) -> Tuple[str, str, Tuple[Token[str], Token[str]]]:
+    """Bind reqid/uid to contextvars for the current execution context."""
+    normalized_reqid = _normalize_value(request_id, fallback=_DEFAULT_REQUEST_ID)
+    normalized_uid = _normalize_value(user_id, fallback=_DEFAULT_USER_ID)
+    req_token = _request_id_var.set(normalized_reqid)
+    uid_token = _user_id_var.set(normalized_uid)
+    return normalized_reqid, normalized_uid, (req_token, uid_token)
+
+
+def reset_request_log_context(tokens: Tuple[Token[str], Token[str]]) -> None:
+    """Reset reqid/uid contextvars back to their previous values."""
+    req_token, uid_token = tokens
+    _request_id_var.reset(req_token)
+    _user_id_var.reset(uid_token)
+
+
+def current_request_log_context() -> Tuple[str, str]:
+    """Return the currently bound reqid/uid pair."""
+    return _request_id_var.get(), _user_id_var.get()
+
+
+def build_request_log_extra(
+    request_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+) -> Dict[str, str]:
+    """Build logging extras, defaulting to the current bound context."""
+    current_reqid, current_uid = current_request_log_context()
+    return {
+        "reqid": _normalize_value(request_id, fallback=current_reqid),
+        "uid": _normalize_value(user_id, fallback=current_uid),
+    }
+
+
+def build_downstream_request_headers(
+    request_id: Optional[str] = None,
+    user_id: Optional[str] = None,
+) -> Dict[str, str]:
+    """Build headers for downstream service calls when request context exists."""
+    extra = build_request_log_extra(request_id=request_id, user_id=user_id)
+    if extra["reqid"] == _DEFAULT_REQUEST_ID and extra["uid"] == _DEFAULT_USER_ID:
+        return {}
+    headers = {"X-Request-ID": extra["reqid"]}
+    if extra["uid"]:
+        headers["X-User-ID"] = extra["uid"]
+    return headers
+
+
+class RequestLogContextFilter(logging.Filter):
+    """Inject reqid/uid defaults into all log records."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        reqid = getattr(record, "reqid", None)
+        uid = getattr(record, "uid", None)
+
+        if reqid is None or uid is None:
+            bound_reqid, bound_uid = current_request_log_context()
+            reqid = reqid if reqid is not None else bound_reqid
+            uid = uid if uid is not None else bound_uid
+
+        if reqid == _DEFAULT_REQUEST_ID and uid == _DEFAULT_USER_ID:
+            try:
+                from context.request_context import get_current_request_context
+
+                context = get_current_request_context()
+            except Exception:
+                context = None
+            if context is not None:
+                reqid = getattr(context, "reqid", None) or reqid
+                uid = getattr(context, "uid", None) or uid
+
+        record.reqid = _normalize_value(reqid, fallback=_DEFAULT_REQUEST_ID)
+        record.uid = _normalize_value(uid, fallback=_DEFAULT_USER_ID)
+        return True
@@ -8,14 +8,11 @@ Simplified architecture:
 - function_score wrapper for boosting fields
 """
-from typing import Dict, Any, List, Optional, Union, Tuple
+from typing import Dict, Any, List, Optional, Tuple
 import numpy as np
 from config import FunctionScoreConfig
-# (Elasticsearch field path, boost before formatting as "path^boost")
-MatchFieldSpec = Tuple[str, float]
-
 class ESQueryBuilder:
     """Builds Elasticsearch DSL queries."""
@@ -39,7 +36,6 @@ class ESQueryBuilder:
         tie_breaker_base_query: float = 0.9,
         best_fields_boosts: Optional[Dict[str, float]] = None,
         best_fields_clause_boost: float = 2.0,
-        mixed_script_merged_field_boost_scale: float = 0.6,
         phrase_field_boosts: Optional[Dict[str, float]] = None,
         phrase_match_base_fields: Optional[Tuple[str, ...]] = None,
         phrase_match_slop: int = 0,
@@ -60,7 +56,6 @@ class ESQueryBuilder:
             function_score_config: Function score configuration
             default_language: Default language to use when detection fails or returns "unknown"
             knn_boost: Boost value for KNN (embedding recall)
-            mixed_script_merged_field_boost_scale: Multiply per-field ^boost for cross-script merged fields
         """
         self.match_fields = match_fields
         self.field_boosts = field_boosts or {}
@@ -77,7 +72,6 @@ class ESQueryBuilder:
         self.translation_minimum_should_match = translation_minimum_should_match
         self.translation_boost = float(translation_boost)
         self.tie_breaker_base_query = float(tie_breaker_base_query)
-        self.mixed_script_merged_field_boost_scale = float(mixed_script_merged_field_boost_scale)
         default_best_fields = {
             base: self._get_field_boost(base)
             for base in self.core_multilingual_fields
@@ -180,7 +174,6 @@ class ESQueryBuilder:
         knn_num_candidates: int = 200,
         min_score: Optional[float] = None,
         parsed_query: Optional[Any] = None,
-        index_languages: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """
         Build complete ES query with post_filter support for multi-select faceting.
@@ -223,11 +216,7 @@ class ESQueryBuilder:
         # Text recall (always include if query_text exists)
         if query_text:
             # Unified text query strategy
-            text_query = self._build_advanced_text_query(
-                query_text,
-                parsed_query,
-                index_languages=index_languages,
-            )
+            text_query = self._build_advanced_text_query(query_text, parsed_query)
             recall_clauses.append(text_query)
         # Embedding recall (KNN - separate from query, handled below)
@@ -434,90 +423,36 @@ class ESQueryBuilder:
             return float(self.field_boosts[base_field])
         return 1.0
-    def _build_match_field_specs(
+    def _match_field_strings(
         self,
         language: str,
         *,
         multilingual_fields: Optional[List[str]] = None,
         shared_fields: Optional[List[str]] = None,
         boost_overrides: Optional[Dict[str, float]] = None,
-    ) -> List[MatchFieldSpec]:
-        """
-        Per-language match targets as (field_path, boost). Single source of truth before
-        formatting as Elasticsearch ``fields`` strings.
-        """
+    ) -> List[str]:
+        """Build ``multi_match`` / ``combined_fields`` field entries for one language code."""
         lang = (language or "").strip().lower()
-        specs: List[MatchFieldSpec] = []
-        text_fields = multilingual_fields if multilingual_fields is not None else self.multilingual_fields
+        text_bases = multilingual_fields if multilingual_fields is not None else self.multilingual_fields
         term_fields = shared_fields if shared_fields is not None else self.shared_fields
         overrides = boost_overrides or {}
-
-        for base in text_fields:
-            field = f"{base}.{lang}"
+        out: List[str] = []
+        for base in text_bases:
+            path = f"{base}.{lang}"
             boost = float(overrides.get(base, self._get_field_boost(base, lang)))
-            specs.append((field, boost))
-
+            out.append(self._format_field_with_boost(path, boost))
         for shared in term_fields:
             boost = float(overrides.get(shared, self._get_field_boost(shared, None)))
-            specs.append((shared, boost))
-        return specs
-
-    def _format_match_field_specs(self, specs: List[MatchFieldSpec]) -> List[str]:
-        """Format (field_path, boost) pairs for Elasticsearch multi_match ``fields``."""
-        return [self._format_field_with_boost(path, boost) for path, boost in specs]
-
-    def _merge_supplemental_lang_field_specs(
-        self,
-        specs: List[MatchFieldSpec],
-        supplemental_lang: str,
-    ) -> List[MatchFieldSpec]:
-        """Append supplemental-language columns; boosts multiplied by mixed_script scale."""
-        scale = float(self.mixed_script_merged_field_boost_scale)
-        extra_all = self._build_match_field_specs(supplemental_lang)
-        seen = {path for path, _ in specs}
-        out = list(specs)
-        for path, boost in extra_all:
-            if path not in seen:
-                out.append((path, boost * scale))
-                seen.add(path)
-        return out
-
-    def _expand_match_field_specs_for_mixed_script(
-        self,
-        lang: str,
-        specs: List[MatchFieldSpec],
-        contains_chinese: bool,
-        contains_english: bool,
-        index_languages: List[str],
-        is_source: bool = False
-    ) -> List[MatchFieldSpec]:
-        """
-        When the query mixes scripts, widen each clause to indexed fields for the other script
-        (e.g. zh clause also searches title.en when the query contains an English word token).
-        """
-        norm = {str(x or "").strip().lower() for x in (index_languages or []) if str(x or "").strip()}
-        allow = norm or {"zh", "en"}
-
-        def can_use(lcode: str) -> bool:
-            return lcode in allow if norm else True
-
-        out = list(specs)
-        lnorm = (lang or "").strip().lower()
-        if is_source:
-            if contains_english and lnorm != "en" and can_use("en"):
-                out = self._merge_supplemental_lang_field_specs(out, "en")
-            if contains_chinese and lnorm != "zh" and can_use("zh"):
-                out = self._merge_supplemental_lang_field_specs(out, "zh")
+            out.append(self._format_field_with_boost(shared, boost))
         return out
     def _build_best_fields_clause(self, language: str, query_text: str) -> Optional[Dict[str, Any]]:
-        specs = self._build_match_field_specs(
+        fields = self._match_field_strings(
             language,
             multilingual_fields=list(self.best_fields_boosts),
             shared_fields=[],
             boost_overrides=self.best_fields_boosts,
         )
-        fields = self._format_match_field_specs(specs)
         if not fields:
             return None
         return {
@@ -530,13 +465,12 @@ class ESQueryBuilder:
         }
     def _build_phrase_clause(self, language: str, query_text: str) -> Optional[Dict[str, Any]]:
-        specs = self._build_match_field_specs(
+        fields = self._match_field_strings(
             language,
             multilingual_fields=list(self.phrase_field_boosts),
             shared_fields=[],
             boost_overrides=self.phrase_field_boosts,
         )
-        fields = self._format_match_field_specs(specs)
         if not fields:
             return None
         clause: Dict[str, Any] = {
@@ -560,20 +494,8 @@ class ESQueryBuilder:
         clause_name: str,
         *,
         is_source: bool,
-        contains_chinese: bool,
-        contains_english: bool,
-        index_languages: List[str],
     ) -> Optional[Dict[str, Any]]:
-        all_specs = self._build_match_field_specs(lang)
-        expanded_specs = self._expand_match_field_specs_for_mixed_script(
-            lang,
-            all_specs,
-            contains_chinese,
-            contains_english,
-            index_languages,
-            is_source,
-        )
-        combined_fields = self._format_match_field_specs(expanded_specs)
+        combined_fields = self._match_field_strings(lang)
         if not combined_fields:
             return None
         minimum_should_match = (
@@ -607,29 +529,10 @@ class ESQueryBuilder:
             clause["bool"]["boost"] = float(self.translation_boost)
         return clause
-    def _get_embedding_field(self, language: str) -> str:
-        """Get embedding field name for a language."""
-        # Currently using unified embedding field
-        return self.text_embedding_field or "title_embedding"
-    
-    @staticmethod
-    def _normalize_language_list(languages: Optional[List[str]]) -> List[str]:
-        normalized: List[str] = []
-        seen = set()
-        for language in languages or []:
-            token = str(language or "").strip().lower()
-            if not token or token in seen:
-                continue
-            seen.add(token)
-            normalized.append(token)
-        return normalized
-
     def _build_advanced_text_query(
         self,
         query_text: str,
         parsed_query: Optional[Any] = None,
-        *,
-        index_languages: Optional[List[str]] = None,
     ) -> Dict[str, Any]:
         """
         Build advanced text query using base and translated lexical clauses.
@@ -649,39 +552,26 @@ class ESQueryBuilder:
         should_clauses = []
         source_lang = self.default_language
         translations: Dict[str, str] = {}
-        contains_chinese = False
-        contains_english = False
-        normalized_index_languages = self._normalize_language_list(index_languages)
         if parsed_query:
             detected_lang = getattr(parsed_query, "detected_language", None)
             source_lang = detected_lang if detected_lang and detected_lang != "unknown" else self.default_language
             translations = getattr(parsed_query, "translations", None) or {}
-            contains_chinese = bool(getattr(parsed_query, "contains_chinese", False))
-            contains_english = bool(getattr(parsed_query, "contains_english", False))
         source_lang = str(source_lang or self.default_language).strip().lower() or self.default_language
         base_query_text = (
             getattr(parsed_query, "rewritten_query", None) if parsed_query else None
         ) or query_text
-        def append_clause(lang: str, lang_query: str, clause_name: str, is_source: bool) -> None:
-            nonlocal should_clauses
-            clause = self._build_lexical_language_clause(
-                lang,
-                lang_query,
-                clause_name,
-                is_source=is_source,
-                contains_chinese=contains_chinese,
-                contains_english=contains_english,
-                index_languages=normalized_index_languages,
-            )
-            if not clause:
-                return
-            should_clauses.append(clause)
-
         if base_query_text:
-            append_clause(source_lang, base_query_text, "base_query", True)
+            base_clause = self._build_lexical_language_clause(
+                source_lang,
+                base_query_text,
+                "base_query",
+                is_source=True,
+            )
+            if base_clause:
+                should_clauses.append(base_clause)
         for lang, translated_text in translations.items():
             normalized_lang = str(lang or "").strip().lower()
@@ -690,7 +580,14 @@ class ESQueryBuilder:
                 continue
             if normalized_lang == source_lang and normalized_text == base_query_text:
                 continue
-            append_clause(normalized_lang, normalized_text, f"base_query_trans_{normalized_lang}", False)
+            trans_clause = self._build_lexical_language_clause(
+                normalized_lang,
+                normalized_text,
+                f"base_query_trans_{normalized_lang}",
+                is_source=False,
+            )
+            if trans_clause:
+                should_clauses.append(trans_clause)
         # Fallback to a simple query when language fields cannot be resolved.
         if not should_clauses:
@@ -62,11 +62,19 @@ def build_docs_from_hits(
     need_category_path = "{category_path}" in doc_template
     for hit in es_hits:
         src = hit.get("_source") or {}
+        title_suffix = str(hit.get("_style_rerank_suffix") or "").strip()
         if only_title:
-            docs.append(pick_lang_text(src.get("title")))
+            title = pick_lang_text(src.get("title"))
+            if title_suffix:
+                title = f"{title} {title_suffix}".strip()
+            docs.append(title)
         else:
             values = _SafeDict(
-                title=pick_lang_text(src.get("title")),
+                title=(
+                    f"{pick_lang_text(src.get('title'))} {title_suffix}".strip()
+                    if title_suffix
+                    else pick_lang_text(src.get("title"))
+                ),
                 brief=pick_lang_text(src.get("brief")) if need_brief else "",
                 vendor=pick_lang_text(src.get("vendor")) if need_vendor else "",
                 description=pick_lang_text(src.get("description")) if need_description else "",
@@ -10,12 +10,13 @@ import time, json
 import logging
 import hashlib
 from string import Formatter
-import numpy as np
 from utils.es_client import ESClient
 from query import QueryParser, ParsedQuery
+from query.style_intent import StyleIntentRegistry
 from embeddings.image_encoder import CLIPImageEncoder
 from .es_query_builder import ESQueryBuilder
+from .sku_intent_selector import SkuSelectionDecision, StyleSkuSelector
 from config import SearchConfig
 from config.tenant_config_loader import get_tenant_config_loader
 from context.request_context import RequestContext, RequestContextStage
@@ -115,6 +116,12 @@ class Searcher:
         else:
             self.image_encoder = image_encoder
         self.source_fields = config.query_config.source_fields
+        self.style_intent_registry = StyleIntentRegistry.from_query_config(self.config.query_config)
+        self.style_sku_selector = StyleSkuSelector(
+            self.style_intent_registry,
+            text_encoder_getter=lambda: getattr(self.query_parser, "text_encoder", None),
+            tokenizer_getter=lambda: getattr(self.query_parser, "_tokenizer", None),
+        )
         # Query builder - simplified single-layer architecture
         self.query_builder = ESQueryBuilder(
@@ -155,7 +162,11 @@ class Searcher:
             return
         es_query["_source"] = {"includes": self.source_fields}
-    def _resolve_rerank_source_filter(self, doc_template: str) -> Dict[str, Any]:
+    def _resolve_rerank_source_filter(
+        self,
+        doc_template: str,
+        parsed_query: Optional[ParsedQuery] = None,
+    ) -> Dict[str, Any]:
         """
         Build a lightweight _source filter for rerank prefetch.
@@ -182,6 +193,16 @@ class Searcher:
         if not includes:
             includes.add("title")
+        if self._has_style_intent(parsed_query):
+            includes.update(
+                {
+                    "skus",
+                    "option1_name",
+                    "option2_name",
+                    "option3_name",
+                }
+            )
+
         return {"includes": sorted(includes)}
     def _fetch_hits_by_ids(
@@ -225,256 +246,23 @@ class Searcher:
         return hits_by_id, int(resp.get("took", 0) or 0)
     @staticmethod
-    def _normalize_sku_match_text(value: Optional[str]) -> str:
-        """Normalize free text for lightweight SKU option matching."""
-        if value is None:
-            return ""
-        return " ".join(str(value).strip().casefold().split())
-
-    @staticmethod
-    def _sku_option1_embedding_key(
-        sku: Dict[str, Any],
-        spu_option1_name: Optional[Any] = None,
-    ) -> Optional[str]:
-        """
-        Text sent to the embedding service for option1 must be "name:value"
-        (option name from SKU row or SPU-level option1_name).
-        """
-        value_raw = sku.get("option1_value")
-        if value_raw is None:
-            return None
-        value = str(value_raw).strip()
-        if not value:
-            return None
-        name = sku.get("option1_name")
-        if name is None or not str(name).strip():
-            name = spu_option1_name
-        name_str = str(name).strip() if name is not None and str(name).strip() else ""
-        if name_str:
-            value = f"{name_str}:{value}"
-        return value.casefold()
-
-    def _build_sku_query_texts(self, parsed_query: ParsedQuery) -> List[str]:
-        """Collect original and translated query texts for SKU option matching."""
-        candidates: List[str] = []
-        for text in (
-            getattr(parsed_query, "original_query", None),
-            getattr(parsed_query, "query_normalized", None),
-            getattr(parsed_query, "rewritten_query", None),
-        ):
-            normalized = self._normalize_sku_match_text(text)
-            if normalized:
-                candidates.append(normalized)
-
-        translations = getattr(parsed_query, "translations", {}) or {}
-        if isinstance(translations, dict):
-            for text in translations.values():
-                normalized = self._normalize_sku_match_text(text)
-                if normalized:
-                    candidates.append(normalized)
-
-        deduped: List[str] = []
-        seen = set()
-        for text in candidates:
-            if text in seen:
-                continue
-            seen.add(text)
-            deduped.append(text)
-        return deduped
-
-    def _find_query_matching_sku_index(
-        self,
-        skus: List[Dict[str, Any]],
-        query_texts: List[str],
-        spu_option1_name: Optional[Any] = None,
-    ) -> Optional[int]:
-        """Return the first SKU whose option1_value (or name:value) appears in query texts."""
-        if not skus or not query_texts:
-            return None
-
-        for index, sku in enumerate(skus):
-            option1_value = self._normalize_sku_match_text(sku.get("option1_value"))
-            if not option1_value:
-                continue
-            if any(option1_value in query_text for query_text in query_texts):
-                return index
-            embed_key = self._sku_option1_embedding_key(sku, spu_option1_name)
-            if embed_key and embed_key != option1_value:
-                composite_norm = self._normalize_sku_match_text(embed_key.replace(":", " "))
-                if any(composite_norm in query_text for query_text in query_texts):
-                    return index
-                if any(embed_key.casefold() in query_text for query_text in query_texts):
-                    return index
-        return None
-
-    def _encode_query_vector_for_sku_matching(
-        self,
-        parsed_query: ParsedQuery,
-        context: Optional[RequestContext] = None,
-    ) -> Optional[np.ndarray]:
-        """Best-effort fallback query embedding for final-page SKU matching."""
-        query_text = (
-            getattr(parsed_query, "rewritten_query", None)
-            or getattr(parsed_query, "query_normalized", None)
-            or getattr(parsed_query, "original_query", None)
-        )
-        if not query_text:
-            return None
-
-        text_encoder = getattr(self.query_parser, "text_encoder", None)
-        if text_encoder is None:
-            return None
-
-        try:
-            vectors = text_encoder.encode([query_text], priority=1)
-        except Exception as exc:
-            logger.warning("Failed to encode query vector for SKU matching: %s", exc, exc_info=True)
-            if context is not None:
-                context.add_warning(f"SKU query embedding failed: {exc}")
-            return None
-
-        if vectors is None or len(vectors) == 0:
-            return None
-
-        vector = vectors[0]
-        if vector is None:
-            return None
-        return np.asarray(vector, dtype=np.float32)
-
-    def _select_sku_by_embedding(
-        self,
-        skus: List[Dict[str, Any]],
-        option1_vectors: Dict[str, np.ndarray],
-        query_vector: np.ndarray,
-        spu_option1_name: Optional[Any] = None,
-    ) -> Tuple[Optional[int], Optional[float]]:
-        """Select the SKU whose option1 embedding key (name:value) is most similar to the query."""
-        best_index: Optional[int] = None
-        best_score: Optional[float] = None
-
-        for index, sku in enumerate(skus):
-            embed_key = self._sku_option1_embedding_key(sku, spu_option1_name)
-            if not embed_key:
-                continue
-            option_vector = option1_vectors.get(embed_key)
-            if option_vector is None:
-                continue
-            score = float(np.inner(query_vector, option_vector))
-            if best_score is None or score > best_score:
-                best_index = index
-                best_score = score
-
-        return best_index, best_score
-
-    @staticmethod
-    def _promote_matching_sku(source: Dict[str, Any], match_index: int) -> Optional[Dict[str, Any]]:
-        """Move the matched SKU to the front and swap the SPU image."""
-        skus = source.get("skus")
-        if not isinstance(skus, list) or match_index < 0 or match_index >= len(skus):
-            return None
-
-        matched_sku = skus.pop(match_index)
-        skus.insert(0, matched_sku)
+    def _has_style_intent(parsed_query: Optional[ParsedQuery]) -> bool:
+        profile = getattr(parsed_query, "style_intent_profile", None)
+        return bool(getattr(profile, "is_active", False))
-        image_src = matched_sku.get("image_src") or matched_sku.get("imageSrc")
-        if image_src:
-            source["image_url"] = image_src
-        return matched_sku
-
-    def _apply_sku_sorting_for_page_hits(
+    def _apply_style_intent_to_hits(
         self,
         es_hits: List[Dict[str, Any]],
         parsed_query: ParsedQuery,
         context: Optional[RequestContext] = None,
-    ) -> None:
-        """Sort each page hit's SKUs so the best-matching SKU is first."""
-        if not es_hits:
-            return
-
-        query_texts = self._build_sku_query_texts(parsed_query)
-        unmatched_hits: List[Dict[str, Any]] = []
-        option1_values_to_encode: List[str] = []
-        seen_option1_values = set()
-        text_matched = 0
-        embedding_matched = 0
-
-        for hit in es_hits:
-            source = hit.get("_source")
-            if not isinstance(source, dict):
-                continue
-            skus = source.get("skus")
-            if not isinstance(skus, list) or not skus:
-                continue
-
-            spu_option1_name = source.get("option1_name")
-            match_index = self._find_query_matching_sku_index(
-                skus, query_texts, spu_option1_name=spu_option1_name
-            )
-            if match_index is not None:
-                self._promote_matching_sku(source, match_index)
-                text_matched += 1
-                continue
-
-            unmatched_hits.append(hit)
-            for sku in skus:
-                embed_key = self._sku_option1_embedding_key(sku, spu_option1_name)
-                if not embed_key or embed_key in seen_option1_values:
-                    continue
-                seen_option1_values.add(embed_key)
-                option1_values_to_encode.append(embed_key)
-
-        if not unmatched_hits or not option1_values_to_encode:
-            return
-
-        query_vector = getattr(parsed_query, "query_vector", None)
-        if query_vector is None:
-            query_vector = self._encode_query_vector_for_sku_matching(parsed_query, context=context)
-        if query_vector is None:
-            return
-
-        text_encoder = getattr(self.query_parser, "text_encoder", None)
-        if text_encoder is None:
-            return
-
-        try:
-            encoded_option_vectors = text_encoder.encode(option1_values_to_encode, priority=1)
-        except Exception as exc:
-            logger.warning("Failed to encode SKU option1 values for final-page sorting: %s", exc, exc_info=True)
-            if context is not None:
-                context.add_warning(f"SKU option embedding failed: {exc}")
-            return
-
-        option1_vectors: Dict[str, np.ndarray] = {}
-        for option1_value, vector in zip(option1_values_to_encode, encoded_option_vectors):
-            if vector is None:
-                continue
-            option1_vectors[option1_value] = np.asarray(vector, dtype=np.float32)
-
-        query_vector_array = np.asarray(query_vector, dtype=np.float32)
-        for hit in unmatched_hits:
-            source = hit.get("_source")
-            if not isinstance(source, dict):
-                continue
-            skus = source.get("skus")
-            if not isinstance(skus, list) or not skus:
-                continue
-            match_index, _ = self._select_sku_by_embedding(
-                skus,
-                option1_vectors,
-                query_vector_array,
-                spu_option1_name=source.get("option1_name"),
-            )
-            if match_index is None:
-                continue
-            self._promote_matching_sku(source, match_index)
-            embedding_matched += 1
-
-        if text_matched or embedding_matched:
-            logger.info(
-                "Final-page SKU sorting completed | text_matched=%s | embedding_matched=%s",
-                text_matched,
-                embedding_matched,
+    ) -> Dict[str, SkuSelectionDecision]:
+        decisions = self.style_sku_selector.prepare_hits(es_hits, parsed_query)
+        if decisions and context is not None:
+            context.store_intermediate_result(
+                "style_intent_sku_decisions",
+                {doc_id: decision.to_dict() for doc_id, decision in decisions.items()},
             )
+        return decisions
     def search(
         self,
@@ -583,7 +371,8 @@ class Searcher:
         context.metadata['feature_flags'] = {
             'translation_enabled': enable_translation,
             'embedding_enabled': enable_embedding,
-            'rerank_enabled': do_rerank
+            'rerank_enabled': do_rerank,
+            'style_intent_enabled': bool(self.style_intent_registry.enabled),
         }
         # Step 1: Parse query
@@ -607,6 +396,7 @@ class Searcher:
                 domain="default",
                 is_simple_query=True
             )
+            context.metadata["feature_flags"]["style_intent_active"] = self._has_style_intent(parsed_query)
             context.logger.info(
                 f"查询解析完成 | 原查询: '{parsed_query.original_query}' | "
@@ -645,7 +435,6 @@ class Searcher:
                 enable_knn=enable_embedding and parsed_query.query_vector is not None,
                 min_score=min_score,
                 parsed_query=parsed_query,
-                index_languages=index_langs,
             )
             # Add facets for faceted search
@@ -668,7 +457,10 @@ class Searcher:
             es_query_for_fetch = es_query
             rerank_prefetch_source = None
             if in_rerank_window:
-                rerank_prefetch_source = self._resolve_rerank_source_filter(effective_doc_template)
+                rerank_prefetch_source = self._resolve_rerank_source_filter(
+                    effective_doc_template,
+                    parsed_query=parsed_query,
+                )
                 es_query_for_fetch = dict(es_query)
                 es_query_for_fetch["_source"] = rerank_prefetch_source
@@ -752,6 +544,20 @@ class Searcher:
         finally:
             context.end_stage(RequestContextStage.ELASTICSEARCH_SEARCH_PRIMARY)
+        style_intent_decisions: Dict[str, SkuSelectionDecision] = {}
+        if self._has_style_intent(parsed_query) and in_rerank_window:
+            style_intent_decisions = self._apply_style_intent_to_hits(
+                es_response.get("hits", {}).get("hits") or [],
+                parsed_query,
+                context=context,
+            )
+            if style_intent_decisions:
+                context.logger.info(
+                    "款式意图 SKU 预筛选完成 | hits=%s",
+                    len(style_intent_decisions),
+                    extra={'reqid': context.reqid, 'uid': context.uid}
+                )
+
         # Optional Step 4.5: AI reranking（仅当请求范围在重排窗口内时执行）
         if do_rerank and in_rerank_window:
             context.start_stage(RequestContextStage.RERANKING)
@@ -842,6 +648,11 @@ class Searcher:
                             if "_source" in detail_hit:
                                 hit["_source"] = detail_hit.get("_source") or {}
                                 filled += 1
+                        if style_intent_decisions:
+                            self.style_sku_selector.apply_precomputed_decisions(
+                                sliced,
+                                style_intent_decisions,
+                            )
                         if fill_took:
                             es_response["took"] = int((es_response.get("took", 0) or 0) + fill_took)
                         context.logger.info(
@@ -884,7 +695,18 @@ class Searcher:
                         continue
                     rerank_debug_by_doc[str(doc_id)] = item
-            self._apply_sku_sorting_for_page_hits(es_hits, parsed_query, context=context)
+            if self._has_style_intent(parsed_query):
+                if in_rerank_window and style_intent_decisions:
+                    self.style_sku_selector.apply_precomputed_decisions(
+                        es_hits,
+                        style_intent_decisions,
+                    )
+                elif not in_rerank_window:
+                    style_intent_decisions = self._apply_style_intent_to_hits(
+                        es_hits,
+                        parsed_query,
+                        context=context,
+                    )
             # Format results using ResultFormatter
             formatted_results = ResultFormatter.format_search_results(
@@ -903,6 +725,11 @@ class Searcher:
                     rerank_debug = None
                     if doc_id is not None:
                         rerank_debug = rerank_debug_by_doc.get(str(doc_id))
+                    style_intent_debug = None
+                    if doc_id is not None and style_intent_decisions:
+                        decision = style_intent_decisions.get(str(doc_id))
+                        if decision is not None:
+                            style_intent_debug = decision.to_dict()
                     raw_score = hit.get("_score")
                     try:
@@ -941,6 +768,9 @@ class Searcher:
                         debug_entry["fused_score"] = rerank_debug.get("fused_score")
                         debug_entry["matched_queries"] = rerank_debug.get("matched_queries")
+                    if style_intent_debug:
+                        debug_entry["style_intent_sku"] = style_intent_debug
+
                     per_result_debug.append(debug_entry)
             # Format facets
@@ -988,7 +818,8 @@ class Searcher:
                     "translations": context.query_analysis.translations,
                     "has_vector": context.query_analysis.query_vector is not None,
                     "is_simple_query": context.query_analysis.is_simple_query,
-                    "domain": context.query_analysis.domain
+                    "domain": context.query_analysis.domain,
+                    "style_intent_profile": context.get_intermediate_result("style_intent_profile"),
                 },
                 "es_query": context.get_intermediate_result('es_query', {}),
                 "es_response": {
@@ -0,0 +1,405 @@
+"""
+SKU selection for style-intent-aware search results.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple
+
+import numpy as np
+
+from query.style_intent import StyleIntentProfile, StyleIntentRegistry
+from query.tokenization import normalize_query_text
+
+
+@dataclass(frozen=True)
+class SkuSelectionDecision:
+    selected_sku_id: Optional[str]
+    rerank_suffix: str
+    selected_text: str
+    matched_stage: str
+    similarity_score: Optional[float] = None
+    resolved_dimensions: Dict[str, Optional[str]] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "selected_sku_id": self.selected_sku_id,
+            "rerank_suffix": self.rerank_suffix,
+            "selected_text": self.selected_text,
+            "matched_stage": self.matched_stage,
+            "similarity_score": self.similarity_score,
+            "resolved_dimensions": dict(self.resolved_dimensions),
+        }
+
+
+@dataclass
+class _SkuCandidate:
+    index: int
+    sku_id: str
+    sku: Dict[str, Any]
+    selection_text: str
+    intent_texts: Dict[str, str]
+
+
+class StyleSkuSelector:
+    """Selects the best SKU for an SPU based on detected style intent."""
+
+    def __init__(
+        self,
+        registry: StyleIntentRegistry,
+        *,
+        text_encoder_getter: Optional[Callable[[], Any]] = None,
+        tokenizer_getter: Optional[Callable[[], Any]] = None,
+    ) -> None:
+        self.registry = registry
+        self._text_encoder_getter = text_encoder_getter
+        self._tokenizer_getter = tokenizer_getter
+
+    def prepare_hits(
+        self,
+        es_hits: List[Dict[str, Any]],
+        parsed_query: Any,
+    ) -> Dict[str, SkuSelectionDecision]:
+        decisions: Dict[str, SkuSelectionDecision] = {}
+        style_profile = getattr(parsed_query, "style_intent_profile", None)
+        if not isinstance(style_profile, StyleIntentProfile) or not style_profile.is_active:
+            return decisions
+
+        query_texts = self._build_query_texts(parsed_query, style_profile)
+        query_vector = self._get_query_vector(parsed_query)
+        tokenizer = self._get_tokenizer()
+
+        for hit in es_hits:
+            source = hit.get("_source")
+            if not isinstance(source, dict):
+                continue
+
+            decision = self._select_for_source(
+                source,
+                style_profile=style_profile,
+                query_texts=query_texts,
+                query_vector=query_vector,
+                tokenizer=tokenizer,
+            )
+            if decision is None:
+                continue
+
+            self._apply_decision_to_source(source, decision)
+            if decision.rerank_suffix:
+                hit["_style_rerank_suffix"] = decision.rerank_suffix
+
+            doc_id = hit.get("_id")
+            if doc_id is not None:
+                decisions[str(doc_id)] = decision
+
+        return decisions
+
+    def apply_precomputed_decisions(
+        self,
+        es_hits: List[Dict[str, Any]],
+        decisions: Dict[str, SkuSelectionDecision],
+    ) -> None:
+        if not es_hits or not decisions:
+            return
+
+        for hit in es_hits:
+            doc_id = hit.get("_id")
+            if doc_id is None:
+                continue
+            decision = decisions.get(str(doc_id))
+            if decision is None:
+                continue
+            source = hit.get("_source")
+            if not isinstance(source, dict):
+                continue
+            self._apply_decision_to_source(source, decision)
+            if decision.rerank_suffix:
+                hit["_style_rerank_suffix"] = decision.rerank_suffix
+
+    def _build_query_texts(
+        self,
+        parsed_query: Any,
+        style_profile: StyleIntentProfile,
+    ) -> List[str]:
+        texts = [variant.normalized_text for variant in style_profile.query_variants if variant.normalized_text]
+        if texts:
+            return list(dict.fromkeys(texts))
+
+        fallbacks: List[str] = []
+        for value in (
+            getattr(parsed_query, "original_query", None),
+            getattr(parsed_query, "query_normalized", None),
+            getattr(parsed_query, "rewritten_query", None),
+        ):
+            normalized = normalize_query_text(value)
+            if normalized:
+                fallbacks.append(normalized)
+        translations = getattr(parsed_query, "translations", {}) or {}
+        if isinstance(translations, dict):
+            for value in translations.values():
+                normalized = normalize_query_text(value)
+                if normalized:
+                    fallbacks.append(normalized)
+        return list(dict.fromkeys(fallbacks))
+
+    def _get_query_vector(self, parsed_query: Any) -> Optional[np.ndarray]:
+        query_vector = getattr(parsed_query, "query_vector", None)
+        if query_vector is not None:
+            return np.asarray(query_vector, dtype=np.float32)
+
+        text_encoder = self._get_text_encoder()
+        if text_encoder is None:
+            return None
+
+        query_text = (
+            getattr(parsed_query, "rewritten_query", None)
+            or getattr(parsed_query, "query_normalized", None)
+            or getattr(parsed_query, "original_query", None)
+        )
+        if not query_text:
+            return None
+
+        vectors = text_encoder.encode([query_text], priority=1)
+        if vectors is None or len(vectors) == 0 or vectors[0] is None:
+            return None
+        return np.asarray(vectors[0], dtype=np.float32)
+
+    def _get_text_encoder(self) -> Any:
+        if self._text_encoder_getter is None:
+            return None
+        return self._text_encoder_getter()
+
+    def _get_tokenizer(self) -> Any:
+        if self._tokenizer_getter is None:
+            return None
+        return self._tokenizer_getter()
+
+    @staticmethod
+    def _fallback_sku_text(sku: Dict[str, Any]) -> str:
+        parts = []
+        for field_name in ("option1_value", "option2_value", "option3_value"):
+            value = str(sku.get(field_name) or "").strip()
+            if value:
+                parts.append(value)
+        return " ".join(parts)
+
+    def _resolve_dimensions(
+        self,
+        source: Dict[str, Any],
+        style_profile: StyleIntentProfile,
+    ) -> Dict[str, Optional[str]]:
+        option_names = {
+            "option1_value": normalize_query_text(source.get("option1_name")),
+            "option2_value": normalize_query_text(source.get("option2_name")),
+            "option3_value": normalize_query_text(source.get("option3_name")),
+        }
+        resolved: Dict[str, Optional[str]] = {}
+        for intent in style_profile.intents:
+            if intent.intent_type in resolved:
+                continue
+            aliases = set(intent.dimension_aliases or self.registry.get_dimension_aliases(intent.intent_type))
+            matched_field = None
+            for field_name, option_name in option_names.items():
+                if option_name and option_name in aliases:
+                    matched_field = field_name
+                    break
+            resolved[intent.intent_type] = matched_field
+        return resolved
+
+    def _build_candidates(
+        self,
+        skus: List[Dict[str, Any]],
+        resolved_dimensions: Dict[str, Optional[str]],
+    ) -> List[_SkuCandidate]:
+        candidates: List[_SkuCandidate] = []
+        for index, sku in enumerate(skus):
+            fallback_text = self._fallback_sku_text(sku)
+            intent_texts: Dict[str, str] = {}
+            for intent_type, field_name in resolved_dimensions.items():
+                if field_name:
+                    value = str(sku.get(field_name) or "").strip()
+                    intent_texts[intent_type] = value or fallback_text
+                else:
+                    intent_texts[intent_type] = fallback_text
+
+            selection_parts: List[str] = []
+            seen = set()
+            for value in intent_texts.values():
+                normalized = normalize_query_text(value)
+                if not normalized or normalized in seen:
+                    continue
+                seen.add(normalized)
+                selection_parts.append(str(value).strip())
+
+            selection_text = " ".join(selection_parts).strip() or fallback_text
+            candidates.append(
+                _SkuCandidate(
+                    index=index,
+                    sku_id=str(sku.get("sku_id") or ""),
+                    sku=sku,
+                    selection_text=selection_text,
+                    intent_texts=intent_texts,
+                )
+            )
+        return candidates
+
+    @staticmethod
+    def _is_direct_match(
+        candidate: _SkuCandidate,
+        query_texts: Sequence[str],
+    ) -> bool:
+        if not candidate.intent_texts or not query_texts:
+            return False
+        for value in candidate.intent_texts.values():
+            normalized_value = normalize_query_text(value)
+            if not normalized_value:
+                return False
+            if not any(normalized_value in query_text for query_text in query_texts):
+                return False
+        return True
+
+    def _is_generalized_match(
+        self,
+        candidate: _SkuCandidate,
+        style_profile: StyleIntentProfile,
+        tokenizer: Any,
+    ) -> bool:
+        if not candidate.intent_texts:
+            return False
+
+        for intent_type, value in candidate.intent_texts.items():
+            definition = self.registry.get_definition(intent_type)
+            if definition is None:
+                return False
+            matched_canonicals = definition.match_text(value, tokenizer=tokenizer)
+            if not matched_canonicals.intersection(style_profile.get_canonical_values(intent_type)):
+                return False
+        return True
+
+    def _select_by_embedding(
+        self,
+        candidates: Sequence[_SkuCandidate],
+        query_vector: Optional[np.ndarray],
+    ) -> Tuple[Optional[_SkuCandidate], Optional[float]]:
+        if not candidates:
+            return None, None
+        text_encoder = self._get_text_encoder()
+        if query_vector is None or text_encoder is None:
+            return candidates[0], None
+
+        unique_texts = list(
+            dict.fromkeys(
+                normalize_query_text(candidate.selection_text)
+                for candidate in candidates
+                if normalize_query_text(candidate.selection_text)
+            )
+        )
+        if not unique_texts:
+            return candidates[0], None
+
+        vectors = text_encoder.encode(unique_texts, priority=1)
+        vector_map: Dict[str, np.ndarray] = {}
+        for key, vector in zip(unique_texts, vectors):
+            if vector is None:
+                continue
+            vector_map[key] = np.asarray(vector, dtype=np.float32)
+
+        best_candidate: Optional[_SkuCandidate] = None
+        best_score: Optional[float] = None
+        query_vector_array = np.asarray(query_vector, dtype=np.float32)
+        for candidate in candidates:
+            normalized_text = normalize_query_text(candidate.selection_text)
+            candidate_vector = vector_map.get(normalized_text)
+            if candidate_vector is None:
+                continue
+            score = float(np.inner(query_vector_array, candidate_vector))
+            if best_score is None or score > best_score:
+                best_candidate = candidate
+                best_score = score
+
+        return best_candidate or candidates[0], best_score
+
+    def _select_for_source(
+        self,
+        source: Dict[str, Any],
+        *,
+        style_profile: StyleIntentProfile,
+        query_texts: Sequence[str],
+        query_vector: Optional[np.ndarray],
+        tokenizer: Any,
+    ) -> Optional[SkuSelectionDecision]:
+        skus = source.get("skus")
+        if not isinstance(skus, list) or not skus:
+            return None
+
+        resolved_dimensions = self._resolve_dimensions(source, style_profile)
+        candidates = self._build_candidates(skus, resolved_dimensions)
+        if not candidates:
+            return None
+
+        direct_matches = [candidate for candidate in candidates if self._is_direct_match(candidate, query_texts)]
+        if len(direct_matches) == 1:
+            chosen = direct_matches[0]
+            return self._build_decision(chosen, resolved_dimensions, matched_stage="direct")
+
+        generalized_matches: List[_SkuCandidate] = []
+        if not direct_matches:
+            generalized_matches = [
+                candidate
+                for candidate in candidates
+                if self._is_generalized_match(candidate, style_profile, tokenizer)
+            ]
+            if len(generalized_matches) == 1:
+                chosen = generalized_matches[0]
+                return self._build_decision(chosen, resolved_dimensions, matched_stage="generalized")
+
+        embedding_pool = direct_matches or generalized_matches or candidates
+        chosen, similarity_score = self._select_by_embedding(embedding_pool, query_vector)
+        if chosen is None:
+            return None
+        stage = "embedding_from_matches" if direct_matches or generalized_matches else "embedding_from_all"
+        return self._build_decision(
+            chosen,
+            resolved_dimensions,
+            matched_stage=stage,
+            similarity_score=similarity_score,
+        )
+
+    @staticmethod
+    def _build_decision(
+        candidate: _SkuCandidate,
+        resolved_dimensions: Dict[str, Optional[str]],
+        *,
+        matched_stage: str,
+        similarity_score: Optional[float] = None,
+    ) -> SkuSelectionDecision:
+        return SkuSelectionDecision(
+            selected_sku_id=candidate.sku_id or None,
+            rerank_suffix=str(candidate.selection_text or "").strip(),
+            selected_text=str(candidate.selection_text or "").strip(),
+            matched_stage=matched_stage,
+            similarity_score=similarity_score,
+            resolved_dimensions=dict(resolved_dimensions),
+        )
+
+    @staticmethod
+    def _apply_decision_to_source(source: Dict[str, Any], decision: SkuSelectionDecision) -> None:
+        skus = source.get("skus")
+        if not isinstance(skus, list) or not skus or not decision.selected_sku_id:
+            return
+
+        selected_index = None
+        for index, sku in enumerate(skus):
+            if str(sku.get("sku_id") or "") == decision.selected_sku_id:
+                selected_index = index
+                break
+        if selected_index is None:
+            return
+
+        selected_sku = skus.pop(selected_index)
+        skus.insert(0, selected_sku)
+
+        image_src = selected_sku.get("image_src") or selected_sku.get("imageSrc")
+        if image_src:
+            source["image_url"] = image_src
@@ -13,9 +13,11 @@ from config import (
 )
 from embeddings.text_encoder import TextEmbeddingEncoder
 from embeddings.image_encoder import CLIPImageEncoder
+from embeddings.text_embedding_tei import TEITextModel
 from embeddings.bf16 import encode_embedding_for_redis
 from embeddings.cache_keys import build_image_cache_key, build_text_cache_key
 from query import QueryParser
+from context.request_context import create_request_context, set_current_request_context, clear_current_request_context
 class _FakeRedis:
@@ -168,6 +170,30 @@ def test_text_embedding_encoder_cache_hit(monkeypatch):
     assert np.allclose(out[1], np.array([0.3, 0.4], dtype=np.float32))
+def test_text_embedding_encoder_forwards_request_headers(monkeypatch):
+    fake_cache = _FakeEmbeddingCache()
+    monkeypatch.setattr("embeddings.text_encoder.RedisEmbeddingCache", lambda **kwargs: fake_cache)
+
+    captured = {}
+
+    def _fake_post(url, json, timeout, **kwargs):
+        captured["headers"] = dict(kwargs.get("headers") or {})
+        return _FakeResponse([[0.1, 0.2]])
+
+    monkeypatch.setattr("embeddings.text_encoder.requests.post", _fake_post)
+
+    context = create_request_context(reqid="req-ctx-1", uid="user-ctx-1")
+    set_current_request_context(context)
+    try:
+        encoder = TextEmbeddingEncoder(service_url="http://127.0.0.1:6005")
+        encoder.encode(["hello"])
+    finally:
+        clear_current_request_context()
+
+    assert captured["headers"]["X-Request-ID"] == "req-ctx-1"
+    assert captured["headers"]["X-User-ID"] == "user-ctx-1"
+
+
 def test_image_embedding_encoder_cache_hit(monkeypatch):
     fake_cache = _FakeEmbeddingCache()
     cached = np.array([0.5, 0.6], dtype=np.float32)
@@ -234,3 +260,37 @@ def test_query_parser_skips_query_vector_when_disabled():
     parsed = parser.parse("red dress", tenant_id="162", generate_vector=False)
     assert parsed.query_vector is None
+
+
+def test_tei_text_model_splits_batches_over_client_limit(monkeypatch):
+    monkeypatch.setattr(TEITextModel, "_health_check", lambda self: None)
+    calls = []
+
+    class _Response:
+        def __init__(self, payload):
+            self._payload = payload
+
+        def raise_for_status(self):
+            return None
+
+        def json(self):
+            return self._payload
+
+    def _fake_post(url, json, timeout):
+        inputs = list(json["inputs"])
+        calls.append(inputs)
+        return _Response([[float(idx)] for idx, _ in enumerate(inputs, start=1)])
+
+    monkeypatch.setattr("embeddings.text_embedding_tei.requests.post", _fake_post)
+
+    model = TEITextModel(
+        base_url="http://127.0.0.1:8080",
+        timeout_sec=20,
+        max_client_batch_size=24,
+    )
+    vectors = model.encode([f"text-{idx}" for idx in range(25)], normalize_embeddings=False)
+
+    assert len(calls) == 2
+    assert len(calls[0]) == 24
+    assert len(calls[1]) == 1
+    assert len(vectors) == 25
@@ -9,6 +9,9 @@ from search.es_query_builder import ESQueryBuilder
 def _builder() -> ESQueryBuilder:
     return ESQueryBuilder(
         match_fields=["title.en^3.0", "brief.en^1.0"],
+        multilingual_fields=["title", "brief"],
+        core_multilingual_fields=["title", "brief"],
+        shared_fields=[],
         text_embedding_field="title_embedding",
         default_language="en",
     )
@@ -25,10 +28,6 @@ def _lexical_clause(query_root: Dict[str, Any]) -&gt; Dict[str, Any]:
     raise AssertionError("no lexical bool clause in query_root")
-def _lexical_combined_fields(query_root: Dict[str, Any]) -> list:
-    return _lexical_clause(query_root)["must"][0]["combined_fields"]["fields"]
-
-
 def test_knn_prefilter_includes_range_filters():
     qb = _builder()
     q = qb.build_query(
@@ -93,7 +92,6 @@ def test_text_query_contains_only_base_and_translation_named_queries():
         query_text="dress",
         parsed_query=parsed_query,
         enable_knn=False,
-        index_languages=["en", "zh", "fr"],
     )
     should = q["query"]["bool"]["should"]
     names = [clause["bool"]["_name"] for clause in should]
@@ -115,120 +113,8 @@ def test_text_query_skips_duplicate_translation_same_as_base():
         query_text="dress",
         parsed_query=parsed_query,
         enable_knn=False,
-        index_languages=["en", "zh"],
     )
     root = q["query"]
     assert root["bool"]["_name"] == "base_query"
     assert [clause["multi_match"]["type"] for clause in root["bool"]["should"]] == ["best_fields", "phrase"]
-
-
-def test_mixed_script_merges_en_fields_into_zh_clause():
-    qb = ESQueryBuilder(
-        match_fields=["title.en^3.0"],
-        multilingual_fields=["title", "brief"],
-        shared_fields=[],
-        text_embedding_field="title_embedding",
-        default_language="en",
-    )
-    parsed_query = SimpleNamespace(
-        rewritten_query="法式 dress",
-        detected_language="zh",
-        translations={},
-        contains_chinese=True,
-        contains_english=True,
-    )
-    q = qb.build_query(
-        query_text="法式 dress",
-        parsed_query=parsed_query,
-        enable_knn=False,
-        index_languages=["zh", "en"],
-    )
-    fields = _lexical_combined_fields(q["query"])
-    bases = {f.split("^", 1)[0] for f in fields}
-    assert "title.zh" in bases and "title.en" in bases
-    assert "brief.zh" in bases and "brief.en" in bases
-    # Merged supplemental language fields use boost * 0.6 by default.
-    assert "title.en^0.6" in fields
-    assert "brief.en^0.6" in fields
-
-
-def test_mixed_script_merges_zh_fields_into_en_clause():
-    qb = ESQueryBuilder(
-        match_fields=["title.en^3.0"],
-        multilingual_fields=["title"],
-        shared_fields=[],
-        text_embedding_field="title_embedding",
-        default_language="en",
-    )
-    parsed_query = SimpleNamespace(
-        rewritten_query="red 连衣裙",
-        detected_language="en",
-        translations={},
-        contains_chinese=True,
-        contains_english=True,
-    )
-    q = qb.build_query(
-        query_text="red 连衣裙",
-        parsed_query=parsed_query,
-        enable_knn=False,
-        index_languages=["zh", "en"],
-    )
-    fields = _lexical_combined_fields(q["query"])
-    bases = {f.split("^", 1)[0] for f in fields}
-    assert "title.en" in bases and "title.zh" in bases
-    assert "title.zh^0.6" in fields
-
-
-def test_mixed_script_merged_fields_scale_configured_boosts():
-    qb = ESQueryBuilder(
-        match_fields=["title.en^3.0"],
-        multilingual_fields=["title"],
-        shared_fields=[],
-        field_boosts={"title.zh": 5.0, "title.en": 10.0},
-        text_embedding_field="title_embedding",
-        default_language="en",
-    )
-    parsed_query = SimpleNamespace(
-        rewritten_query="法式 dress",
-        detected_language="zh",
-        translations={},
-        contains_chinese=True,
-        contains_english=True,
-    )
-    q = qb.build_query(
-        query_text="法式 dress",
-        parsed_query=parsed_query,
-        enable_knn=False,
-        index_languages=["zh", "en"],
-    )
-    fields = _lexical_combined_fields(q["query"])
-    assert "title.zh^5.0" in fields
-    assert "title.en^6.0" in fields  # 10.0 * 0.6
-
-
-def test_mixed_script_does_not_merge_en_when_not_in_index_languages():
-    qb = ESQueryBuilder(
-        match_fields=["title.zh^3.0"],
-        multilingual_fields=["title"],
-        shared_fields=[],
-        text_embedding_field="title_embedding",
-        default_language="zh",
-    )
-    parsed_query = SimpleNamespace(
-        rewritten_query="法式 dress",
-        detected_language="zh",
-        translations={},
-        contains_chinese=True,
-        contains_english=True,
-    )
-    q = qb.build_query(
-        query_text="法式 dress",
-        parsed_query=parsed_query,
-        enable_knn=False,
-        index_languages=["zh"],
-    )
-    fields = _lexical_combined_fields(q["query"])
-    bases = {f.split("^", 1)[0] for f in fields}
-    assert "title.zh" in bases
-    assert "title.en" not in bases
 """
 ES text recall: base_query (rewritten @ detected_language) + base_query_trans_*.
-Covers combinations of query language vs tenant index_languages, translations,
-and mixed Chinese/English queries. Asserts named lexical clause boundaries,
-combined_fields payloads, and per-language target fields (title.{lang}).
+Covers translation routing, mixed-script queries (per-clause language fields only),
+and clause naming. Asserts named lexical clause boundaries, combined_fields payloads,
+and per-language target fields (title.{lang}).
 """
 from types import SimpleNamespace
@@ -14,11 +14,7 @@ import numpy as np
 from search.es_query_builder import ESQueryBuilder
-def _builder_multilingual_title_only(
-    *,
-    default_language: str = "en",
-    mixed_script_scale: float = 0.6,
-) -> ESQueryBuilder:
+def _builder_multilingual_title_only(*, default_language: str = "en") -> ESQueryBuilder:
     """Minimal builder: only title.{lang} for easy field assertions."""
     return ESQueryBuilder(
         match_fields=["title.en^1.0"],
@@ -26,7 +22,6 @@ def _builder_multilingual_title_only(
         shared_fields=[],
         text_embedding_field="title_embedding",
         default_language=default_language,
-        mixed_script_merged_field_boost_scale=mixed_script_scale,
         function_score_config=None,
     )
@@ -101,22 +96,16 @@ def _build(
     rewritten: str,
     detected_language: str,
     translations: Dict[str, str],
-    index_languages: List[str],
-    contains_chinese: bool = False,
-    contains_english: bool = False,
 ) -> Dict[str, Any]:
     parsed = SimpleNamespace(
         rewritten_query=rewritten,
         detected_language=detected_language,
         translations=dict(translations),
-        contains_chinese=contains_chinese,
-        contains_english=contains_english,
     )
     return qb.build_query(
         query_text=query_text,
         parsed_query=parsed,
         enable_knn=False,
-        index_languages=index_languages,
     )
@@ -131,7 +120,6 @@ def test_zh_query_index_zh_en_includes_base_zh_and_trans_en():
         rewritten="连衣裙",
         detected_language="zh",
         translations={"en": "dress"},
-        index_languages=["zh", "en"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_en"}
@@ -149,7 +137,6 @@ def test_en_query_index_zh_en_includes_base_en_and_trans_zh():
         rewritten="dress",
         detected_language="en",
         translations={"zh": "连衣裙"},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_zh"}
@@ -167,7 +154,6 @@ def test_de_query_index_de_en_fr_includes_base_and_two_translations():
         rewritten="kleid",
         detected_language="de",
         translations={"en": "dress", "fr": "robe"},
-        index_languages=["de", "en", "fr"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_en", "base_query_trans_fr"}
@@ -188,7 +174,6 @@ def test_de_query_index_only_en_zh_base_on_de_translations_on_target_fields():
         rewritten="schuh",
         detected_language="de",
         translations={"en": "shoe", "zh": "鞋"},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_en", "base_query_trans_zh"}
@@ -201,10 +186,10 @@ def test_de_query_index_only_en_zh_base_on_de_translations_on_target_fields():
     assert idx["base_query_trans_zh"]["boost"] == qb.translation_boost
-# --- 中英混写：原文在 base_query；翻译子句独立；混写时 base 子句扩列 ---
+# --- 中英混写：base 打在检测语种字段；翻译子句打在译文语种字段 ---
-def test_mixed_zh_primary_with_en_translation_merges_en_into_zh_base_clause():
+def test_mixed_zh_detected_base_clause_zh_fields_only_with_en_translation():
     qb = _builder_multilingual_title_only(default_language="en")
     q = _build(
         qb,
@@ -212,19 +197,16 @@ def test_mixed_zh_primary_with_en_translation_merges_en_into_zh_base_clause():
         rewritten="红色 dress",
         detected_language="zh",
         translations={"en": "red dress"},
-        index_languages=["zh", "en"],
-        contains_chinese=True,
-        contains_english=True,
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_en"}
     assert _combined_fields_clause(idx["base_query"])["query"] == "红色 dress"
-    assert _has_title_lang(idx["base_query"], "zh") and _has_title_lang(idx["base_query"], "en")
+    assert _has_title_lang(idx["base_query"], "zh") and not _has_title_lang(idx["base_query"], "en")
     assert _combined_fields_clause(idx["base_query_trans_en"])["query"] == "red dress"
     assert _has_title_lang(idx["base_query_trans_en"], "en")
-def test_mixed_en_primary_with_zh_translation_merges_zh_into_en_base_clause():
+def test_mixed_en_detected_base_clause_en_fields_only_with_zh_translation():
     qb = _builder_multilingual_title_only(default_language="en")
     q = _build(
         qb,
@@ -232,18 +214,15 @@ def test_mixed_en_primary_with_zh_translation_merges_zh_into_en_base_clause():
         rewritten="nike 运动鞋",
         detected_language="en",
         translations={"zh": "耐克运动鞋"},
-        index_languages=["zh", "en"],
-        contains_chinese=True,
-        contains_english=True,
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_zh"}
     assert _combined_fields_clause(idx["base_query"])["query"] == "nike 运动鞋"
-    assert _has_title_lang(idx["base_query"], "en") and _has_title_lang(idx["base_query"], "zh")
+    assert _has_title_lang(idx["base_query"], "en") and not _has_title_lang(idx["base_query"], "zh")
     assert _combined_fields_clause(idx["base_query_trans_zh"])["query"] == "耐克运动鞋"
-def test_mixed_zh_query_index_zh_only_no_en_merge_in_base():
+def test_zh_query_no_translations_only_zh_fields():
     qb = _builder_multilingual_title_only(default_language="en")
     q = _build(
         qb,
@@ -251,9 +230,6 @@ def test_mixed_zh_query_index_zh_only_no_en_merge_in_base():
         rewritten="法式 dress",
         detected_language="zh",
         translations={},
-        index_languages=["zh"],
-        contains_chinese=True,
-        contains_english=True,
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query"}
@@ -272,7 +248,6 @@ def test_skips_translation_when_same_lang_and_same_text_as_base():
         rewritten="NIKE",
         detected_language="en",
         translations={"en": "NIKE", "zh": "耐克"},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_zh"}
@@ -286,7 +261,6 @@ def test_keeps_translation_when_same_text_but_different_lang_than_base():
         rewritten="NIKE",
         detected_language="en",
         translations={"zh": "NIKE"},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_zh"}
@@ -304,7 +278,6 @@ def test_translation_language_key_is_normalized_case_insensitive():
         rewritten="dress",
         detected_language="en",
         translations={"ZH": "连衣裙"},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert "base_query_trans_zh" in idx
@@ -319,17 +292,16 @@ def test_empty_translation_value_is_skipped():
         rewritten="dress",
         detected_language="en",
         translations={"zh": "  ", "fr": "robe"},
-        index_languages=["en", "zh", "fr"],
     )
     idx = _clauses_index(q)
     assert "base_query_trans_zh" not in idx
     assert "base_query_trans_fr" in idx
-# --- index_languages 为空：视为「未约束」source_in_index 为 True ---
+# --- base 子句无 bool.boost；翻译子句带 translation_boost；phrase should 继承 phrase_match_boost ---
-def test_empty_index_languages_treats_source_as_in_index_boosts():
+def test_de_base_and_en_translation_phrase_boosts():
     qb = _builder_multilingual_title_only(default_language="en")
     q = _build(
         qb,
@@ -337,7 +309,6 @@ def test_empty_index_languages_treats_source_as_in_index_boosts():
         rewritten="x",
         detected_language="de",
         translations={"en": "y"},
-        index_languages=[],
     )
     idx = _clauses_index(q)
     assert "boost" not in idx["base_query"]
@@ -359,7 +330,6 @@ def test_no_translations_only_base_query():
         rewritten="hello",
         detected_language="en",
         translations={},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query"}
@@ -374,15 +344,12 @@ def test_text_clauses_present_alongside_knn():
         rewritten_query="dress",
         detected_language="en",
         translations={"zh": "连衣裙"},
-        contains_chinese=False,
-        contains_english=True,
     )
     q = qb.build_query(
         query_text="dress",
         query_vector=np.array([0.1, 0.2, 0.3], dtype=np.float32),
         parsed_query=parsed,
         enable_knn=True,
-        index_languages=["en", "zh"],
     )
     assert "knn" in q
     idx = _clauses_index(q)
@@ -396,14 +363,11 @@ def test_detected_language_unknown_falls_back_to_default_language():
         rewritten_query="shirt",
         detected_language="unknown",
         translations={"zh": "衬衫"},
-        contains_chinese=False,
-        contains_english=True,
     )
     q = qb.build_query(
         query_text="shirt",
         parsed_query=parsed,
         enable_knn=False,
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_zh"}
@@ -419,7 +383,6 @@ def test_ru_query_index_ru_en_includes_base_ru_and_trans_en():
         rewritten="платье",
         detected_language="ru",
         translations={"en": "dress"},
-        index_languages=["ru", "en"],
     )
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_en"}
@@ -428,11 +391,8 @@ def test_ru_query_index_ru_en_includes_base_ru_and_trans_en():
     assert _combined_fields_clause(idx["base_query_trans_en"])["query"] == "dress"
-def test_translation_for_lang_not_listed_in_index_languages_still_generates_clause():
-    """
-    当前实现：凡是 translations 里非空的条目都会生成子句；
-    index_languages 只约束混写扩列，不用于过滤翻译子句。
-    """
+def test_translation_generates_clause_for_any_target_lang_key():
+    """translations 里非空的每个语种键都会生成对应 base_query_trans_* 子句。"""
     qb = _builder_multilingual_title_only(default_language="en")
     q = _build(
         qb,
@@ -440,7 +400,6 @@ def test_translation_for_lang_not_listed_in_index_languages_still_generates_clau
         rewritten="dress",
         detected_language="en",
         translations={"zh": "连衣裙", "de": "Kleid"},
-        index_languages=["en", "zh"],
     )
     idx = _clauses_index(q)
     assert "base_query_trans_de" in idx
@@ -457,9 +416,6 @@ def test_mixed_detected_zh_rewrite_differs_from_query_text_uses_rewritten_in_bas
         rewritten="红色连衣裙",
         detected_language="zh",
         translations={"en": "red dress"},
-        index_languages=["zh", "en"],
-        contains_chinese=True,
-        contains_english=False,
     )
     idx = _clauses_index(q)
     assert _combined_fields_clause(idx["base_query"])["query"] == "红色连衣裙"
@@ -11,14 +11,6 @@ def _tokenizer(text):
     return str(text).split()
-def test_pure_english_word_token_length_and_script():
-    assert QueryParser._is_pure_english_word_token("ab") is False
-    assert QueryParser._is_pure_english_word_token("abc") is True
-    assert QueryParser._is_pure_english_word_token("wi-fi") is True
-    assert QueryParser._is_pure_english_word_token("连衣裙") is False
-    assert QueryParser._is_pure_english_word_token("ab12") is False
-
-
 def _build_config() -> SearchConfig:
     return SearchConfig(
         es_index_name="test_products",
@@ -36,7 +28,7 @@ def _build_config() -&gt; SearchConfig:
     )
-def test_parse_adds_en_fields_for_mixed_chinese_query_with_meaningful_english(monkeypatch):
+def test_parse_mixed_zh_query_translates_to_en(monkeypatch):
     parser = QueryParser(_build_config(), translator=_DummyTranslator(), tokenizer=_tokenizer)
     monkeypatch.setattr(parser.language_detector, "detect", lambda text: "zh")
@@ -48,15 +40,13 @@ def test_parse_adds_en_fields_for_mixed_chinese_query_with_meaningful_english(mo
     )
     assert result.detected_language == "zh"
-    assert result.contains_chinese is True
-    assert result.contains_english is True
     assert result.translations == {"en": "法式 dress 连衣裙-en"}
     assert result.query_tokens == ["法式", "dress", "连衣裙"]
     assert not hasattr(result, "query_text_by_lang")
     assert not hasattr(result, "search_langs")
-def test_parse_adds_zh_fields_for_english_query_when_cjk_present(monkeypatch):
+def test_parse_mixed_en_query_translates_to_zh(monkeypatch):
     parser = QueryParser(_build_config(), translator=_DummyTranslator(), tokenizer=_tokenizer)
     monkeypatch.setattr(parser.language_detector, "detect", lambda text: "en")
@@ -68,8 +58,6 @@ def test_parse_adds_zh_fields_for_english_query_when_cjk_present(monkeypatch):
     )
     assert result.detected_language == "en"
-    assert result.contains_chinese is True
-    assert result.contains_english is True
     assert result.translations == {"zh": "red 连衣裙-zh"}
     assert result.query_tokens == ["red", "连衣裙"]
@@ -87,7 +75,5 @@ def test_parse_waits_for_translation_when_source_in_index_languages(monkeypatch)
     )
     assert result.detected_language == "en"
-    assert result.contains_chinese is False
-    assert result.contains_english is True
     assert result.translations.get("zh") == "off shoulder top-zh"
     assert not hasattr(result, "source_in_index_languages")
@@ -18,6 +18,7 @@ from config import (
     SearchConfig,
 )
 from context import create_request_context
+from query.style_intent import DetectedStyleIntent, StyleIntentProfile
 from search.searcher import Searcher
@@ -30,6 +31,7 @@ class _FakeParsedQuery:
     translations: Dict[str, str] = None
     query_vector: Any = None
     domain: str = "default"
+    style_intent_profile: Any = None
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -39,9 +41,27 @@ class _FakeParsedQuery:
             "detected_language": self.detected_language,
             "translations": self.translations or {},
             "domain": self.domain,
+            "style_intent_profile": (
+                self.style_intent_profile.to_dict() if self.style_intent_profile is not None else None
+            ),
         }
+def _build_style_intent_profile(intent_type: str, canonical_value: str, *dimension_aliases: str) -> StyleIntentProfile:
+    aliases = dimension_aliases or (intent_type,)
+    return StyleIntentProfile(
+        intents=(
+            DetectedStyleIntent(
+                intent_type=intent_type,
+                canonical_value=canonical_value,
+                matched_term=canonical_value,
+                matched_query_text=canonical_value,
+                dimension_aliases=tuple(aliases),
+            ),
+        )
+    )
+
+
 class _FakeQueryParser:
     def parse(
         self,
@@ -340,6 +360,57 @@ def test_searcher_rerank_prefetch_source_follows_doc_template(monkeypatch):
     assert es_client.calls[0]["body"]["_source"] == {"includes": ["brief", "title", "vendor"]}
+def test_searcher_rerank_prefetch_source_includes_sku_fields_when_style_intent_active(monkeypatch):
+    es_client = _FakeESClient()
+    searcher = _build_searcher(_build_search_config(rerank_enabled=True), es_client)
+    context = create_request_context(reqid="t1c", uid="u1c")
+
+    monkeypatch.setattr(
+        "search.searcher.get_tenant_config_loader",
+        lambda: SimpleNamespace(get_tenant_config=lambda tenant_id: {"index_languages": ["en"]}),
+    )
+    monkeypatch.setattr(
+        "search.rerank_client.run_rerank",
+        lambda **kwargs: (kwargs["es_response"], None, []),
+    )
+
+    class _IntentQueryParser:
+        text_encoder = None
+
+        def parse(
+            self,
+            query: str,
+            tenant_id: str,
+            generate_vector: bool,
+            context: Any,
+            target_languages: Any = None,
+        ):
+            return _FakeParsedQuery(
+                original_query=query,
+                query_normalized=query,
+                rewritten_query=query,
+                translations={},
+                style_intent_profile=_build_style_intent_profile(
+                    "color", "black", "color", "colors", "颜色"
+                ),
+            )
+
+    searcher.query_parser = _IntentQueryParser()
+
+    searcher.search(
+        query="black dress",
+        tenant_id="162",
+        from_=0,
+        size=5,
+        context=context,
+        enable_rerank=None,
+    )
+
+    assert es_client.calls[0]["body"]["_source"] == {
+        "includes": ["option1_name", "option2_name", "option3_name", "skus", "title"]
+    }
+
+
 def test_searcher_skips_rerank_when_request_explicitly_false(monkeypatch):
     es_client = _FakeESClient()
     searcher = _build_searcher(_build_search_config(rerank_enabled=True), es_client)
@@ -434,6 +505,9 @@ def test_searcher_promotes_sku_when_option1_matches_translated_query(monkeypatch
                 query_normalized=query,
                 rewritten_query=query,
                 translations={"en": "black dress"},
+                style_intent_profile=_build_style_intent_profile(
+                    "color", "black", "color", "colors", "颜色"
+                ),
             )
     searcher.query_parser = _TranslatedQueryParser()
@@ -481,8 +555,8 @@ def test_searcher_promotes_sku_by_embedding_when_query_has_no_direct_option_matc
     encoder = _FakeTextEncoder(
         {
             "linen summer dress": [0.8, 0.2],
-            "color:red": [1.0, 0.0],
-            "color:blue": [0.0, 1.0],
+            "red": [1.0, 0.0],
+            "blue": [0.0, 1.0],
         }
     )
@@ -503,6 +577,9 @@ def test_searcher_promotes_sku_by_embedding_when_query_has_no_direct_option_matc
                 rewritten_query=query,
                 translations={},
                 query_vector=np.array([0.0, 1.0], dtype=np.float32),
+                style_intent_profile=_build_style_intent_profile(
+                    "color", "blue", "color", "colors", "颜色"
+                ),
             )
     searcher.query_parser = _EmbeddingQueryParser()
@@ -0,0 +1,35 @@
+from types import SimpleNamespace
+
+from config import QueryConfig
+from query.style_intent import StyleIntentDetector, StyleIntentRegistry
+
+
+def test_style_intent_detector_matches_original_and_translated_queries():
+    query_config = QueryConfig(
+        style_intent_terms={
+            "color": [["black", "黑色", "black"]],
+            "size": [["xl", "x-large", "加大码"]],
+        },
+        style_intent_dimension_aliases={
+            "color": ["color", "颜色"],
+            "size": ["size", "尺码"],
+        },
+    )
+    detector = StyleIntentDetector(
+        StyleIntentRegistry.from_query_config(query_config),
+        tokenizer=lambda text: text.split(),
+    )
+
+    parsed_query = SimpleNamespace(
+        original_query="黑色 连衣裙",
+        query_normalized="黑色 连衣裙",
+        rewritten_query="黑色 连衣裙",
+        translations={"en": "black dress xl"},
+    )
+
+    profile = detector.detect(parsed_query)
+
+    assert profile.is_active is True
+    assert profile.get_canonical_values("color") == {"black"}
+    assert profile.get_canonical_values("size") == {"xl"}
+    assert len(profile.query_variants) == 2
@@ -14,6 +14,8 @@ from datetime import datetime
 from typing import Any, Dict, Optional
 from pathlib import Path
+from request_log_context import LOG_LINE_FORMAT, RequestLogContextFilter
+
 class StructuredFormatter(logging.Formatter):
     """Structured JSON formatter with request context support"""
@@ -89,25 +91,6 @@ def _log_with_context(logger: logging.Logger, level: int, msg: str, **kwargs):
             logging.setLogRecordFactory(old_factory)
-class RequestContextFilter(logging.Filter):
-    """Filter that automatically injects request context from thread-local storage"""
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        """Inject request context from thread-local storage"""
-        try:
-            # Import here to avoid circular imports
-            from context.request_context import get_current_request_context
-            context = get_current_request_context()
-            if context:
-                # Ensure every request-scoped log record carries reqid/uid.
-                # If they are missing in the context, fall back to "-1".
-                record.reqid = getattr(context, "reqid", None) or "-1"
-                record.uid = getattr(context, "uid", None) or "-1"
-        except (ImportError, AttributeError):
-            pass
-        return True
-
-
 class ContextAwareConsoleFormatter(logging.Formatter):
     """
     Console formatter that injects reqid/uid into the log line.
@@ -156,9 +139,7 @@ def setup_logging(
     # Create formatters
     structured_formatter = StructuredFormatter()
-    console_formatter = ContextAwareConsoleFormatter(
-        '%(asctime)s | reqid:%(reqid)s | uid:%(uid)s | %(levelname)-8s | %(name)-15s | %(message)s'
-    )
+    console_formatter = ContextAwareConsoleFormatter(LOG_LINE_FORMAT)
     # Add console handler
     if enable_console: