argo-search 2.9.7 → 2.9.9

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；健康窗口中位无差。
@@ -495,6 +502,20 @@ def _get_engines_combo(domain: dict[str, Any], enabled: set[str], mode: str = "a
     # 学习器在此处首次解析（惰性，见模块顶部 _get_learner）：走到这里说明
     # 真的要装配 combo，这笔钱躲不掉；不进本函数的路径（缓存命中等）不付。
     _adaptive_learner = _get_learner()
+
+    # 场景分桶取分（2026-10-24）：优先用 (engine, domain, lang) 的桶分，
+    # 桶无样本时 adaptive.get_score 自动回退全局分。判据与旧口径一致，
+    # 只是多了一个维度——「引擎在 A 域强、B 域弱」现在可被路由区分。
+    _dom_name = str(domain.get("name") or "")
+    _q_lang = str((features or {}).get("primary_lang") or "")
+
+    def _score_of(e: str) -> float:
+        try:
+            return _adaptive_learner.get_score(e, _dom_name, _q_lang)
+        except TypeError:
+            # 旧版 adaptive（无 domain/lang 形参）回退全局分
+            return _adaptive_learner.get_score(e)
+
     combo = domain.get("engines_combo", [])
     primary = domain.get("primary", "anysearch")
     fallback = domain.get("fallback")
@@ -574,7 +595,7 @@ def _get_engines_combo(domain: dict[str, Any], enabled: set[str], mode: str = "a
     # 成员与 fallback，自动进入恢复链 L3 兜底。
     if primary and (
             _adaptive_learner is None
-            or _adaptive_learner.get_score(primary) >= _VERTICAL_FLOOR):
+            or _score_of(primary) >= _VERTICAL_FLOOR):
         protect.add(primary)
     # 仅 modal_card 整 combo 免 cost 裁剪（结构化路径不可被 anysearch 顶替）
     if domain_name == "modal_card":
@@ -601,14 +622,14 @@ def _get_engines_combo(domain: dict[str, Any], enabled: set[str], mode: str = "a
         # 自动回归 combo，且它仍是域 fallback（恢复链 L3 候选）。
         if domain_name in _VERTICAL_PROTECT:
             protect = {e for e in original
-                       if _adaptive_learner.get_score(e) >= _VERTICAL_FLOOR
+                       if _score_of(e) >= _VERTICAL_FLOOR
                        } | protect
         filtered = [
             e for e in filtered
             if e in protect
             or (e == primary
-                and _adaptive_learner.get_score(e) >= _VERTICAL_FLOOR)
-            or _adaptive_learner.get_score(e) >= 0.3
+                and _score_of(e) >= _VERTICAL_FLOOR)
+            or _score_of(e) >= 0.3
         ]
         if not filtered:
             filtered = original
@@ -655,7 +676,7 @@ def _get_engines_combo(domain: dict[str, Any], enabled: set[str], mode: str = "a
                     seen_fam.add(f)
                     members = [x for x in rest if _fam(x) == f]
                     if len(members) > 1:
-                        scored = [(x, _adaptive_learner.get_score(x)) for x in members]
+                        scored = [(x, _score_of(x)) for x in members]
                         top_score = max(s for _, s in scored)
                         laggards = [x for x, s in scored if top_score - s >= 0.15]
                         if laggards and len(laggards) < len(scored):