argo-search 2.9.7 → 2.9.8

package/scripts/recovery_runner.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""recovery_runner.py — 搜索主管线错误恢复执行器与 L3 策略。
+
+拆分自 search_pipeline.py：将零结果/异常退化恢复链与有界并发对冲执行器从主管线剥离。
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+from bounded_run import run_bounded
+from except_sets import OPT_IMPORT, SHAPE_BENIGN
+from search_rank import deduplicate_by_url
+
+
+def run_pipeline_recovery(
+    *,
+    query: str,
+    merged: list[dict[str, Any]],
+    raw_results: dict[str, list],
+    decision: dict[str, Any],
+    engines: list[str],
+    available_engines_fn: Any,
+    max_results: int,
+    max_rec_level: str | None,
+    echo_triggered: bool,
+    primary_grace_s: float,
+    timeout: float,
+    depth: str,
+    mode: str,
+    since_iso: str | None,
+    until_iso: str | None,
+    skip_cache: bool,
+    quota_batch: Any,
+    engine_search_fn: Any,
+    emit_usage_fn: Any = None,
+    recovery_engines_set: set[str] | None = None,
+    engine_domain_extra: dict[str, Any] | None = None,
+) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
+    """执行恢复链（L1 放宽 / L2 变体 / L3 换引擎）：有界并发对冲跑候选引擎并复检壳。"""
+    recovery_info = None
+    try:
+        from recovery import run_recovery
+        tried = list(raw_results.keys()) or list(engines)
+        fallback_engines = decision.get("engines_fallback") or []
+
+        rec_level = max_rec_level
+        if echo_triggered:
+            rec_level = "L3"
+        elif fallback_engines and decision.get("domain") not in (
+                None, "", "general", "general_search") \
+                and (rec_level is None or rec_level < "L3"):
+            rec_level = "L3"
+
+        try:
+            enabled_set = set(available_engines_fn())
+        except Exception:
+            enabled_set = None
+
+        dk = engine_domain_extra or {}
+
+        def _fire(eng: str) -> list[dict[str, Any]]:
+            if recovery_engines_set is not None:
+                recovery_engines_set.add(eng)
+            try:
+                res = engine_search_fn(
+                    query, eng, n=max_results,
+                    timeout=timeout, depth=depth, mode=mode,
+                    since=since_iso, until=until_iso,
+                    skip_cache=skip_cache, **dk,
+                )
+            except Exception as e:
+                sys.stderr.write(f"[recovery] 恢复链异常（{type(e).__name__}）: {e}\n")
+                res = []
+            goods = [r for r in (res or []) if isinstance(r, dict) and "error" not in r]
+            quota_batch.add(eng, bool(goods))
+            if goods:
+                for r in goods:
+                    r.setdefault("_engine", eng)
+                    r.setdefault("_recovered", True)
+                try:
+                    from postprocess_signals import drop_echo_items as _drop_echo
+                    goods = _drop_echo(goods, query)
+                except OPT_IMPORT + SHAPE_BENIGN:
+                    pass
+            return goods
+
+        def _recovery_executor(rq: str, rengines: list[str]) -> list[dict[str, Any]]:
+            if len(rengines) <= 1:
+                return _fire(rengines[0]) if rengines else []
+            grace = max(0.0, float(primary_grace_s or 0.0))
+            wait_s = grace * (len(rengines) - 1) + max(1.0, float(timeout)) + 1.0
+
+            def _enough(finished: list[tuple[str, Any]]) -> bool:
+                return any(isinstance(v, list) and v for _i, v in finished)
+
+            finished, _unfinished = run_bounded(
+                rengines, _fire, wait_s, max_workers=3,
+                enough=_enough, stagger_s=grace,
+            )
+            for _item, value in finished:
+                if isinstance(value, list) and value:
+                    return value
+            return []
+
+        rec_results, rec_result = run_recovery(
+            query, tried, _recovery_executor,
+            engines_fallback=fallback_engines, enabled=enabled_set, mode=mode,
+            max_level=rec_level,
+        )
+        recovery_info = rec_result.to_dict()
+
+        if emit_usage_fn is not None:
+            try:
+                emit_usage_fn("recovery", {
+                    "query": (query[:60] if query else query),
+                    "triggered": recovery_info.get("triggered"),
+                    "recovered": recovery_info.get("recovered"),
+                    "level_used": recovery_info.get("level_used"),
+                    "strategy_used": recovery_info.get("strategy_used"),
+                    "steps_tried": len(recovery_info.get("steps_tried") or []),
+                    "final_query": (recovery_info.get("final_query") or "")[:60],
+                    "note": recovery_info.get("note", ""),
+                })
+            except SHAPE_BENIGN:
+                pass
+
+        if rec_results:
+            try:
+                from recovery_l0 import finalize_l3_results
+                merged = finalize_l3_results(rec_results, max_results)
+            except ImportError:
+                merged = deduplicate_by_url(rec_results)[:max_results]
+
+            rec_by_eng: dict[str, list] = {}
+            for r in merged:
+                eng = r.get("_engine") or r.get("source") or ""
+                if eng:
+                    r.setdefault("consensus_engines", [eng])
+                    rec_by_eng.setdefault(eng, []).append(r)
+            for eng_name, lst in rec_by_eng.items():
+                raw_results.setdefault(eng_name, lst)
+
+    except ImportError:
+        pass
+    except Exception as e:
+        sys.stderr.write(f"[recovery] 错误恢复跳过: {type(e).__name__}\n")
+
+    return merged, recovery_info

package/scripts/replay_eval.py

@@ -534,8 +534,25 @@ def _fmt_header(doc: dict) -> str:
 
 # ── 命令行 ────────────────────────────────────────────────────────────────────
 
+def _read_queries_file(path: str) -> list[str]:
+    """从文件读查询词：每行一个，忽略空行与行首注释。
+
+    为什么要有这个入口：原来靠 shell 的 `mapfile` 拼参数，在 zsh / 空文件 /
+    只有空行三种情况下会静默退化成「录一条空查询」——2026-10-22 本地实跑
+    就录出了一条 query="" 的 case，而阈值判定只看 id 交集，于是「一条也算通过」。
+    """
+    qs = [line.strip() for line in Path(path).read_text(encoding="utf-8").splitlines()
+          if line.strip() and not line.lstrip().startswith("#")]
+    return qs
+
+
 def _cmd_record(args) -> int:
     queries = args.queries or _DEFAULT_QUERIES
+    if getattr(args, "queries_file", None):
+        queries = _read_queries_file(args.queries_file)
+        if not queries:
+            print(f"查询集是空的：{args.queries_file}", file=sys.stderr)
+            return 1
     out_path = Path(args.out) if args.out else DEFAULT_DATA_PATH
     cases: list[dict] = []
     for q in queries:
@@ -576,6 +593,7 @@ def main() -> int:
     ap.add_argument("--save-baseline", help="把当前结果存为对照基准")
     ap.add_argument("--record", action="store_true", help="联网录制（唯一会联网的模式）")
     ap.add_argument("--queries", nargs="*", help="录制用的查询词")
+    ap.add_argument("--queries-file", help="从文件读查询词（每行一个，空行与 # 注释忽略）")
     ap.add_argument("--out", help="录制结果写到哪里")
     ap.add_argument("--mode", default="auto")
     ap.add_argument("--depth", default="fast")

package/scripts/research.py

@@ -518,7 +518,8 @@ def deep_research(query: str, num_sub_queries: int = 4, max_results: int = 5,
                   route_strategy: str | None = None,
                   work_packages: Any = None,
                   allow_recompute: bool = False,
-                  broaden: bool = False) -> dict[str, Any]:
+                  broaden: bool = False,
+                  cross_lingual_trace: bool = False) -> dict[str, Any]:
     """执行取证。有工作包则按依赖分阶段；否则扩词检索。产出 dossier。"""
     import time as _time
     _deadline = _time.time() + timeout * 3
@@ -569,36 +570,49 @@ def deep_research(query: str, num_sub_queries: int = 4, max_results: int = 5,
             route_strategy=route_strategy,
         )
 
-    # --broaden: 来源不足时自动追加英文/学术方向补充搜索
-    if broaden and not packages:
-        all_urls: set[str] = set()
-        for sr in collection["sub_results"]:
-            for r in sr.get("results", []):
-                url = r.get("url") or r.get("canonical_url")
-                if url:
-                    all_urls.add(url)
-        if len(all_urls) < 15:
-            broaden_subs = [
-                {"query": f"{query} 论文 学术", "intent": "学术补充", "strategy": "academic"},
-                {"query": f"{query} research paper", "intent": "英文学术补充", "strategy": "english_focused"},
-            ]
+    # ── 跨语言长程搜索与溯源链路（Cross-Lingual Long-Range Trace & Pivot）──
+    trace_report: dict[str, Any] | None = None
+    try:
+        from cross_lingual_trace import (
+            assess_cross_lingual_need,
+            build_cross_lingual_trace_queries,
+            synthesize_cross_lingual_evidence,
+        )
+        assess = assess_cross_lingual_need(
+            original_query,
+            collection.get("merged_results", []),
+            domain=(profile or {}).get("key") or "",
+            force_trace=bool(cross_lingual_trace or broaden),
+        )
+        should_trace = cross_lingual_trace or (not packages and (broaden or assess["needed"]))
+        if should_trace and _time.time() < _deadline:
+            trace_subs = []
+            for t_lang in assess.get("target_langs", ["en"])[:2]:
+                trace_subs.extend(build_cross_lingual_trace_queries(original_query, target_lang=t_lang))
             existing_queries = {sq["query"] for sq in sub_queries}
-            broaden_subs = [sq for sq in broaden_subs if sq["query"] not in existing_queries]
-            if broaden_subs:
-                broaden_collection = collect_sources(
-                    broaden_subs, max_results, timeout, depth, mode,
+            trace_subs = [sq for sq in trace_subs if sq["query"] not in existing_queries]
+            if trace_subs:
+                trace_collection = collect_sources(
+                    trace_subs, max_results, timeout, depth, mode,
                     engines_priority=engines_priority or None,
                     profile=profile, budget=budget, route_strategy=route_strategy,
                 )
-                collection["sub_results"].extend(broaden_collection["sub_results"])
-                sub_queries.extend(broaden_subs)
-                # 重新融合：把所有 sub_results 的 results 合并进 merged_results
+                collection["sub_results"].extend(trace_collection["sub_results"])
+                sub_queries.extend(trace_subs)
+                trace_report = synthesize_cross_lingual_evidence(
+                    collection.get("merged_results", []),
+                    trace_collection.get("merged_results", []),
+                    original_query,
+                )
                 result_lists = [sr["results"] for sr in collection["sub_results"] if sr.get("results")]
                 if len(result_lists) > 1:
                     from search_rank import rrf_merge
                     collection["merged_results"] = rrf_merge(result_lists)[:max_results * 3]
                 elif result_lists:
                     collection["merged_results"] = result_lists[0]
+    except Exception as _trace_err:
+        import logging
+        logging.getLogger("unified_search").warning("跨语言长程溯源跳过: %s", _trace_err)
 
     gaps = identify_gaps(collection["sub_results"], original_query)
     source_grades = (profile or {}).get("source_grades") if profile else None
@@ -669,6 +683,8 @@ def deep_research(query: str, num_sub_queries: int = 4, max_results: int = 5,
         plan_info, rewrite_result,
     )
     _attach_evidence_loop(report, collection)
+    if trace_report is not None:
+        report["cross_lingual_trace"] = trace_report
     report["quality_gate_results"] = evaluate_dossier_gates(report)
     report["conclusion_cap"] = report["quality_gate_results"]["conclusion_cap"]
     return report

package/scripts/research_expand.py

@@ -8,6 +8,29 @@ Agent 的 MECE 问题树走 research_work_packages，不要把扩词当研究拆
 from __future__ import annotations
 
 import re
+
+
+def _english_anchor(query: str) -> str:
+    """中英混合查询里的英文锚点；单 token 不足以独立成查询时返回空串。
+
+    why（2026-10-22 实测）：「Rust 异步运行时怎么选」被扩成一条独立的
+    `Rust` 子查询，抓回 Rust 游戏官网、语言首页、算法库，15 条来源里 3 条
+    与问题无关；「AI 监管 新规」同理会扩成 `AI`。单 token 丢了中文里真正的
+    限定语（异步运行时/监管），既浪费一次检索又污染引用。
+    判据用「≥2 个词 或 单 token ≥5 字符」：`kubernetes`、`Python`、`Claude Code`
+    这类本身可独立检索的保留；`Rust`/`AI`/`DSH`/纯数字年份与股票代码不单飞。
+    """
+    tokens = [w for w in query.split()
+              if w.isascii() and len(w) > 1 and any(c.isalnum() for c in w)
+              and not w.isdigit()]
+    text = " ".join(tokens)
+    if not text:
+        return ""
+    if len(tokens) >= 2:
+        return text
+    return text if len(text) >= 5 else ""
+
+
 def expand_query(query: str, num_sub: int = 4) -> list[dict[str, str]]:
     """按关键词特征扩检索词。产出的是搜索变体，不是可验证子问题。"""
     sub_queries: list[dict[str, str]] = []
@@ -16,7 +39,7 @@ def expand_query(query: str, num_sub: int = 4) -> list[dict[str, str]]:
     has_english = any(c.isascii() and c.isalpha() for c in query)
 
     if has_chinese and has_english:
-        eng_words = " ".join(w for w in query.split() if w.isascii() and len(w) > 2)
+        eng_words = _english_anchor(query)
         if eng_words:
             sub_queries.append({
                 "query": eng_words,

package/scripts/retry_policy.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""retry_policy.py — 失败类别与重试判据（唯一来源）。
+
+拆出 engine_dispatch 的理由有两条：
+
+1. **单一真源**：重试判据（该不该再发一次）与归因判据（这次算什么失败）
+   必须用同一套词表与同一个优先级。两处各写一套的下场是重试按一套词表
+   跳过、熔断按另一套记账，对同一次失败给出两个不同判断。
+2. **行数门禁**：engine_dispatch 已接近祖父上限（tests/test_module_size_gate.
+   py），而本模块是纯策略、无 IO、无闭包状态——正好是「拆出去两边都轻」
+   的那一类。
+
+本模块不做决定、不碰状态：只把「错误文本 → 类别 → 是否值得重试」算出来。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cache_guard import _QUOTA_ERROR_KEYWORDS
+
+# 拦截页特征词（唯一来源）：error 文本里出现即判 blocked。HTML 引擎的反爬
+# 命中没有 error 文本（静默空结果），走 engines_base 的归因寄存器；
+# 这张表兜住「error 结果里带拦截页字样」的可见路径。
+_BLOCKED_ERROR_KEYWORDS = (
+    "just a moment", "checking your browser", "cf-browser-verification",
+    "challenge", "ddos-guard", "perimeterx", "access denied",
+    "handshake failure", "unable to handshake", "安全验证", "滑动验证",
+)
+
+# 确定性失败：源端状态，不是网络抖动。重试只是多烧一次调用并推迟切备选
+#——配额耗尽重试仍是耗尽，鉴权重试仍是 401，反爬重试仍撞同一堵墙。
+# 与 dsh-free-search 的 failure-aware fallback 同构（quota/auth 冷却到会话
+# 结束、bot-wall 短退避，只有 transient 才重试一次）。
+NON_RETRYABLE_STATUS = frozenset({"quota-exhausted", "auth-failed", "blocked"})
+
+
+def classify_error_status(message: Any) -> str:
+    """错误文本 → 失败类别。**重试判据与归因判据的共同定义点**。
+
+    优先级顺序即语义强弱：超时最具体（描述本次调用的形态），配额/限流/
+    拦截是源端状态，鉴权最后（401/403 也可能来自拦截页）。
+    """
+    m = str(message or "").lower()
+    if "timeout" in m or "timed out" in m:
+        return "timeout"
+    if any(k in m for k in _QUOTA_ERROR_KEYWORDS):
+        return "quota-exhausted"
+    if "rate" in m or "429" in m:
+        return "rate-limited"
+    if any(k in m for k in _BLOCKED_ERROR_KEYWORDS):
+        return "blocked"
+    if "auth" in m or "401" in m or "403" in m:
+        return "auth-failed"
+    return "error"
+
+
+def is_retryable_failure(res: list[Any] | None) -> bool:
+    """这组结果值不值得再试一次（纯函数，门禁可直接打到）。
+
+    判据取自 `classify_error_status`，与归因同源。空结果与无错误条目返回
+    True——沿用既有「重试一次」语义，本次只收紧确定性失败这一类。
+    """
+    for r in res or []:
+        if isinstance(r, dict) and "error" in r:
+            return classify_error_status(r.get("error")) not in NON_RETRYABLE_STATUS
+    return True
+
+
+def record_attempts(outcome: dict[str, Any], attempts: dict[str, int]) -> None:
+    """把「实际发了几次网络请求」如实写进 outcome。
+
+    单独成函数是为了让 engine_dispatch 不必为 3 行记账逻辑长到行数门禁
+    外面去；记账口径（至少 1 次）也只在这里定义一次。
+    """
+    outcome["attempts"] = max(1, int((attempts or {}).get("n", 1)))

package/scripts/route.py

@@ -22,7 +22,7 @@ from __future__ import annotations
 
 import sys
 import time
-from dataclasses import dataclass
+from search_types import slot_record as dataclass
 from typing import Any, Callable
 from cli_io import dumps
 
@@ -128,6 +128,7 @@ from route_lang import (  # noqa: E402
     _SOCIAL_ZH_GENERAL,
     _get_registry,
 )
+from paid_policy import insert_hedge
 from route_combo import (  # noqa: E402
     _expand_local_search,
     _general_fallback,
@@ -585,14 +586,11 @@ def _route_by_domain(ctx: _RouteCtx, domain: dict[str, Any], secondary: list[dic
         is_catch_all=is_catch_all, enabled=enabled)
     if _strong:
         confidence = 0.9
-    # 熔断统一处理 + 槽位回填（2026-10-02，回填逻辑与
-    # 判据见 backfill_after_breaker docstring）
+    # 熔断统一处理 + 槽位回填（判据见 backfill_after_breaker）
     engines_combo = backfill_after_breaker(
         engines_combo, enabled, features=features, query=query,
         skip_aux=_pure_combo, refill_pool=pre_policy_pool)
-    # budget 截断后保持一致 parallel，避免短 combo 仍开多余并行
-    # research 语境例外：子查询跑满 combo（no_early_stop），串行会拖垮
-    # 整条研究管线，强制并行
+    # parallel 与预算后 combo 长度对齐；research 语境强制并行
     if (mode == "fast" and context != "research") or len(engines_combo) <= 1:
         parallel = False
     elif context == "research":
@@ -601,6 +599,8 @@ def _route_by_domain(ctx: _RouteCtx, domain: dict[str, Any], secondary: list[dic
         # 双引擎默认串行，利于 early-stop（答案域）
         parallel = parallel and len(engines_combo) > 2
 
+    engines_combo = insert_hedge(engines_combo, domain.get("name", ""), mode, enabled)
+
     return _done(
         engine=engines_combo[0],
         engines=engines_combo,

package/scripts/route_cache.py

@@ -19,6 +19,7 @@ route_cache → route → route_cache 的循环导入。
 
 from __future__ import annotations
 
+import os
 import time
 from typing import Any
 
@@ -100,6 +101,23 @@ def _route_state_fingerprint() -> str:
         parts.append("cb=" + ",".join(sorted(get_breaker().auto_disabled())))
     except Exception:
         return ""
+    # 路由旋钮的 env 覆盖必须参与指纹：否则「设了 ARGO_GENERAL_FALLBACK_LEAD
+    # 却因缓存命中不生效」，逃生开关与 A/B 臂都变成摆设（2026-10-21 实测踩中）。
+    # LEGACY 是同一类开关（改通用兜底链的成员），一并入指纹，避免只修一个入口。
+    # 统一经 engine_env.get_env 取值（兼顾 ~/.config/argo/env 文件与进程环境）。
+    try:
+        from engine_env import get_env as _get_env
+    except Exception:
+        _get_env = lambda k, d="": os.environ.get(k, d)  # noqa: E731
+    parts.append("lead=" + (_get_env("ARGO_GENERAL_FALLBACK_LEAD") or ""))
+    parts.append("legacy=" + (_get_env("ARGO_GENERAL_FALLBACK_LEGACY") or ""))
+    # 付费对冲开关与月度预算同样改变 combo；不纳入指纹会让开关或预算变更在缓存命中时静默不生效。
+    parts.append("paid=" + (_get_env("ARGO_PAID_SEARCH") or ""))
+    try:
+        from budget import budget_signature
+        parts.append(f"bgt={budget_signature()!r}")
+    except Exception:
+        pass
     return "|".join(parts)
 
 

package/scripts/route_combo.py

@@ -12,6 +12,7 @@
 
 from __future__ import annotations
 
+import os
 from typing import Any
 
 from config import get_engines
@@ -101,6 +102,12 @@ def _general_fallback(enabled: set[str]) -> list[str]:
     except ImportError:
         GENERAL_FREE_FALLBACK = ("anysearch", "octen", "local_bing")
     order = list(GENERAL_FREE_FALLBACK)
+    # 领队覆盖（2026-10-21）：A/B 与线上回退都走这里，避免为了复测改常量。
+    # 传引擎名即把它提到首位（例：ARGO_GENERAL_FALLBACK_LEAD=anysearch 复现
+    # 2026-10-21 之前的顺位）；传空/未知值不生效。与下面的 LEGACY 开关正交。
+    lead_override = (os.environ.get("ARGO_GENERAL_FALLBACK_LEAD") or "").strip()
+    if lead_override and lead_override in order:
+        order = [lead_override] + [e for e in order if e != lead_override]
     # 逃生开关：A/B 与线上回退都走这条，避免为了复测改常量。
     # 2026-10-17 对拍（交错、随机序）：octen 入第二顺位后，anysearch 抖动
     # 窗口 p90 3273→1614ms、max 6266→1928ms、错误 9→0；健康窗口中位无差。

package/scripts/route_domains.py

@@ -76,6 +76,26 @@ _compiled_domains: list[dict[str, Any]] | None = None
 _compiled_domains_id: tuple | None = None  # (name, patterns/exclude_if 内容指纹)
 
 
+def _ensure_domain_compiled(domain: dict[str, Any]) -> list[tuple[re.Pattern, re.Pattern | None]]:
+    """按需编译单个域的触发词与意图正则（扫到哪个域才编译哪个域）。"""
+    rules = domain.get("_rules")
+    if rules is not None:
+        return rules
+    rules = []
+    for p in _pattern_entries(domain):
+        match_src, unless_src = _split_pattern_entry(p)
+        match_re = _try_compile(match_src)
+        if match_re is None:
+            continue  # 触发词写坏 → 丢这一条（与旧行为一致）
+        rules.append((match_re, _try_compile(unless_src)))
+    intent_src = domain.get("intent_required")
+    domain["_intent"] = (
+        _try_compile(intent_src) if isinstance(intent_src, str) and intent_src else None
+    )
+    domain["_rules"] = rules
+    return rules
+
+
 def _compile_domain_patterns(domains: list[dict[str, Any]]) -> list[dict[str, Any]]:
     """把域声明编译成可执行形态（`_rules` = (触发词, 该词的否决词|None) 列表）。
 
@@ -85,22 +105,9 @@ def _compile_domain_patterns(domains: list[dict[str, Any]]) -> list[dict[str, An
     """
     compiled = []
     for idx, domain in enumerate(domains):
-        rules = []
-        for p in _pattern_entries(domain):
-            match_src, unless_src = _split_pattern_entry(p)
-            match_re = _try_compile(match_src)
-            if match_re is None:
-                continue  # 触发词写坏 → 丢这一条（与旧行为一致）
-            rules.append((match_re, _try_compile(unless_src)))
-        intent_re = None
-        intent_src = domain.get("intent_required")
-        if isinstance(intent_src, str) and intent_src:
-            try:
-                intent_re = re.compile(intent_src)
-            except re.error:
-                intent_re = None
-        compiled.append({**domain, "_idx": idx, "_rules": rules,
-                         "_intent": intent_re})
+        entry = {**domain, "_idx": idx, "_rules": None, "_intent": None}
+        _ensure_domain_compiled(entry)
+        compiled.append(entry)
     return compiled
 
 
@@ -129,7 +136,7 @@ def _split_pattern_entry(entry: Any) -> tuple[Any, Any]:
 
 def _domain_fires(domain: dict[str, Any], query: str) -> bool:
     """一个域是否成立：任一触发词命中，且它自己的否决词没命中。"""
-    for match_re, unless_re in domain["_rules"]:
+    for match_re, unless_re in _ensure_domain_compiled(domain):
         if unless_re is not None and unless_re.search(query):
             continue
         if match_re.search(query):
@@ -155,7 +162,12 @@ def _get_compiled_domains(domains: list[dict[str, Any]]) -> list[dict[str, Any]]
     )
     if _compiled_domains is not None and _compiled_domains_id == dom_fp:
         return _compiled_domains
-    _compiled_domains = _compile_domain_patterns(domains)
+    # 槽位懒初始化：实际正则在 _domain_fires 扫到该域时才按需编译，
+    # 冷启动路由省去未扫到域（及被语言门跳过的域）的正则编译税。
+    _compiled_domains = [
+        {**domain, "_idx": idx, "_rules": None, "_intent": None}
+        for idx, domain in enumerate(domains)
+    ]
     _compiled_domains_id = dom_fp
     return _compiled_domains
 
@@ -168,7 +180,8 @@ def warm_compiled_domains() -> None:
     懒编译与全量回退都会自愈，预热是纯优化。
     """
     try:
-        _get_compiled_domains(get_domains())
+        for d in _get_compiled_domains(get_domains()):
+            _ensure_domain_compiled(d)
     except Exception:
         pass
 

package/scripts/search.py

@@ -214,7 +214,6 @@ def _missing_env_for(eng: str) -> list[str]:
 # 学习跳过判定。
 
 from engine_dispatch import (  # noqa: E402
-    _QUOTA_ERROR_KEYWORDS,
     classify_engine_outcome as _classify_engine_outcome,
     run_dispatch,
 )
@@ -547,18 +546,7 @@ def execute_search(query: str, decision: dict[str, Any], max_results: int,
 
 # ── 统一入口 ──────────────────────────────────────────────────────────────────
 
-def _resolve_include_local(include_local: bool | None, mode: str) -> bool:
-    """include-local 三态解析：True/False 显式，None=自动（fast/budget 开）。
-
-    本地文件命中此前默认全关，模型与用户在正常使用中永远看不到本机内容
-    （2026-09-29 审查：「本地内容搜索被忽略」）。自动开的安全垫已齐备：
-    宽根守卫（home/根目录不扫）+ 3s 子进程超时 + L1 并行提交（不占墙钟，
-    常规项目目录 rg 实测 33ms）。auto/deep 保持显式开启——深度模式由
-    调用方自主决定证据面。
-    """
-    if include_local is None:
-        return mode in ("fast", "budget")
-    return bool(include_local)
+from local_seek import resolve_include_local as _resolve_include_local
 
 
 def super_search(query: str, engine: str = "auto", n: int = 5, explain: bool = False,
@@ -785,13 +773,13 @@ def super_search(query: str, engine: str = "auto", n: int = 5, explain: bool = F
                   file=sys.stderr)
         if search_query != original_query:
             print(f"[改写] {original_query} → {search_query}", file=sys.stderr)
-    # L1 并行化：include_local 时把 _run_local_seek 提前提交到线程池，
-    # 与主搜索并行执行。主搜索完成时本地搜索通常已就绪，零额外墙钟。
-    include_local = _resolve_include_local(include_local, mode)
+    # L1 并行化：本地搜索与主搜索并行提交（仅显式开启时在宽根下提示）。
+    _local_seek_explicit = include_local is not None
+    include_local = _resolve_include_local(include_local, mode, query)
     _local_seek_future = None
     if include_local:
         _local_seek_future = _get_local_seek_executor().submit(
-            _run_local_seek, query, n)
+            _run_local_seek, query, n, warn=_local_seek_explicit)
 
     result = execute_search(
         query=search_query, decision=decision, max_results=n,
@@ -863,15 +851,15 @@ def super_search(query: str, engine: str = "auto", n: int = 5, explain: bool = F
             "url-seed: seed URL was not fetched; results are related discovery only"
         )
     # 恢复链两种结局分开说（2026-10-10 方案甲）：「恢复成功换了引擎」与
-    # 「触发了但无可用策略」对消费者的含义完全不同——后者意味着空结果是
-    # 查询本身无召回（该改写查询），不是引擎故障（该重试）。
+    # 「触发了但无可用策略」对消费者的含义完全不同。失败那一半再细分：
+    # 源被跳过/鉴权失败时不要写成「查询没有召回」（2026-10-22 修正），
+    # 具体判据与措辞在 search_attribution.zero_result_recovery_note。
     _rec_info = result.get("recovery") or {}
-    if isinstance(_rec_info, dict) and _rec_info.get("triggered") \
-            and not _rec_info.get("recovered"):
-        extra_lim.append(
-            "recovery triggered but no usable strategy ("
-            f"{_rec_info.get('note') or 'no note'}); empty results likely mean "
-            "the query had no recall — try rephrasing")
+    from search_attribution import zero_result_recovery_note
+    _rec_note = zero_result_recovery_note(
+        _rec_info, result.get("engine_outcomes"))
+    if _rec_note is not None:
+        extra_lim.append(_rec_note)
     elif result.get("recovery"):
         extra_lim.append("recovery used; engine fallback may differ from primary route")
     # 执行归因：把「为什么只有这么几条 / 为什么只跑了一个源」写进随答案一起
@@ -942,8 +930,8 @@ def super_search(query: str, engine: str = "auto", n: int = 5, explain: bool = F
         from serp_kill_log import drain_serp_guard_kills
         for _kill in drain_serp_guard_kills():
             result.setdefault("errors", []).append(
-                f"serp_guard: {_kill['engine']} 整页判垃圾被拦下"
-                f"（{_kill['results']} 条，疑似 SERP/跳转壳占比高）——"
+                f"serp_guard: {_kill['engine']} 头部结果均未覆盖 20% 查询词，"
+                f"整页按答非所问丢弃（{_kill['results']} 条）——"
                 "如需复核可设 ARGO_SERP_GUARD=0 重跑")
     except ImportError:
         pass