argo-search 2.9.7 → 2.9.9

package/scripts/route_domains.py

@@ -70,10 +70,123 @@ _ZH_LANG_GATED_DOMAINS = frozenset({
 })
 
 
-# ── 域预编译（内容指纹缓存） ──────────────────────────────────────────────────
+# ── 域预编译（内容指纹缓存与锚点快筛） ──────────────────────────────────────────
 
 _compiled_domains: list[dict[str, Any]] | None = None
 _compiled_domains_id: tuple | None = None  # (name, patterns/exclude_if 内容指纹)
+_compiled_domains_ref: int | None = None
+_anchor_matcher: re.Pattern | None = None
+_anchor_to_domains: dict[str, list[int]] = {}
+_unconstrained_domains: set[int] = set()
+
+
+def _extract_anchors(src: Any) -> set[str] | None:
+    """从正则源码中提取一组必须包含其一的字面锚点词集合（全小写）。
+
+    若无法提取安全锚点（如含有纯通配、字符集类 []、通用转义字符类），返回 None。
+    """
+    if not isinstance(src, str) or not src:
+        return None
+    s = re.sub(r"^\(\?[a-zA-Z]+\)", "", src)
+    s = re.sub(r"\\b", "", s)
+    if s.startswith("(") and s.endswith(")"):
+        s = s[1:-1]
+    parts: list[str] = []
+    depth = 0
+    cur: list[str] = []
+    for ch in s:
+        if ch in ("(", "["):
+            depth += 1
+        elif ch in (")", "]"):
+            depth -= 1
+        if ch == "|" and depth == 0:
+            parts.append("".join(cur))
+            cur = []
+        else:
+            cur.append(ch)
+    if cur:
+        parts.append("".join(cur))
+
+    anchors: set[str] = set()
+    for part in parts:
+        # 正则字符类与元字符无法保证字面子串存在
+        if re.search(r"\[.*?\]", part) or re.search(r"\\[wWdDsS]", part):
+            return None
+        runs = re.findall(r"[\u4e00-\u9fff]{1,}|[a-zA-Z0-9_\-\.]{2,}", part)
+        if not runs:
+            return None
+        for r in runs:
+            anchors.add(r.lower())
+    return anchors if anchors else None
+
+
+def _init_anchor_index(compiled: list[dict[str, Any]]) -> None:
+    """初始化全局锚点自动机索引（方案一：Aho-Corasick 前置快速分桶）。"""
+    global _anchor_matcher, _anchor_to_domains, _unconstrained_domains
+    _anchor_to_domains = {}
+    _unconstrained_domains = set()
+    all_anchors: set[str] = set()
+
+    for idx, domain in enumerate(compiled):
+        entries = _pattern_entries(domain)
+        if not entries:
+            _unconstrained_domains.add(idx)
+            continue
+        dom_anchors: set[str] = set()
+        unconstrained = False
+        for p in entries:
+            match_src, _ = _split_pattern_entry(p)
+            anc = _extract_anchors(match_src)
+            if anc is None:
+                unconstrained = True
+                break
+            dom_anchors.update(anc)
+        if unconstrained or not dom_anchors:
+            _unconstrained_domains.add(idx)
+        else:
+            for term in dom_anchors:
+                _anchor_to_domains.setdefault(term, []).append(idx)
+                all_anchors.add(term)
+
+    if all_anchors:
+        sorted_terms = sorted(all_anchors, key=len, reverse=True)
+        escaped = [re.escape(t) for t in sorted_terms]
+        _anchor_matcher = re.compile("|".join(escaped), re.IGNORECASE)
+    else:
+        _anchor_matcher = None
+
+
+def _get_candidate_domain_indices(query: str) -> set[int] | None:
+    """通过锚点词快速扫描返回候选域索引集合；无索引时返回 None。"""
+    if _anchor_matcher is None:
+        return None
+    candidates = set(_unconstrained_domains)
+    for m in _anchor_matcher.finditer(query):
+        term = m.group(0).lower()
+        doms = _anchor_to_domains.get(term)
+        if doms:
+            candidates.update(doms)
+    return candidates
+
+
+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]]:
@@ -85,22 +198,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
 
 
@@ -127,18 +227,30 @@ def _split_pattern_entry(entry: Any) -> tuple[Any, Any]:
     return entry, None
 
 
-def _domain_fires(domain: dict[str, Any], query: str) -> bool:
-    """一个域是否成立：任一触发词命中，且它自己的否决词没命中。"""
-    for match_re, unless_re in domain["_rules"]:
+def _domain_fires_with_span(domain: dict[str, Any], query: str) -> tuple[bool, int, int]:
+    """一个域是否成立，并返回命中的 (是否成立, match_span_start, match_span_len)。"""
+    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):
-            return True
-    return False
+        m = match_re.search(query)
+        if m is not None:
+            start, end = m.span()
+            return True, start, end - start
+    return False, 0, 0
+
+
+def _domain_fires(domain: dict[str, Any], query: str) -> bool:
+    """一个域是否成立：任一触发词命中，且它自己的否决词没命中。"""
+    fires, _, _ = _domain_fires_with_span(domain, query)
+    return fires
 
 
 def _get_compiled_domains(domains: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    global _compiled_domains, _compiled_domains_id
+    global _compiled_domains, _compiled_domains_id, _compiled_domains_ref
+    # 快速指针比对：当传入同一 domains 引用且已编译时 O(1) 返回，免除 97 域的 SHA1 开销
+    dom_ref = id(domains)
+    if _compiled_domains is not None and _compiled_domains_ref == dom_ref:
+        return _compiled_domains
     # 用内容指纹替代 id(domains)，避免 GC 后 id 复用导致缓存失效/错误。
     # 指纹含规则本体（只记长度会漏「改正则不改条数」的编辑），且必须覆盖
     # exclude_if / intent_required——它们和 patterns 一样会改变命中结果。
@@ -155,8 +267,15 @@ 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
+    _compiled_domains_ref = dom_ref
+    _init_anchor_index(_compiled_domains)
     return _compiled_domains
 
 
@@ -168,7 +287,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
 
@@ -298,20 +418,39 @@ def match_domains(query: str, domains: list[dict[str, Any]] | None = None,
         domains = get_domains()
     compiled = _get_compiled_domains(domains)
     hits: list[dict[str, Any]] = []
+    secondary_hits: list[tuple[dict[str, Any], float]] = []
     catch_all: dict[str, Any] | None = None
     non_zh = bool(primary_lang and primary_lang not in ("zh", "mixed", "other"))
-    for domain in compiled:
+    candidates = _get_candidate_domain_indices(query)
+    q_len = max(len(query), 1)
+
+    for idx, domain in enumerate(compiled):
         if not domain.get("patterns", []):
             catch_all = domain
             continue
         if non_zh and domain.get("name") in _ZH_LANG_GATED_DOMAINS:
             continue
-        if _domain_fires(domain, query):
-            hits.append(domain)
-        if len(hits) >= max_n:
-            break
+        if candidates is not None and idx not in candidates:
+            continue
+        fires, span_start, span_len = _domain_fires_with_span(domain, query)
+        if fires:
+            if not hits:
+                hits.append(domain)
+            else:
+                pos_ratio = span_start / q_len
+                # 方案二：跨度高（特异性强）优先提拔；同跨度下严格保持前序特化域顺位稳定
+                score = (span_len * 2.0) - (idx * 0.1) + (pos_ratio * 0.01)
+                secondary_hits.append((domain, score))
+            if len(hits) + len(secondary_hits) >= max_n:
+                break
+
+    if secondary_hits:
+        secondary_hits.sort(key=lambda x: x[1], reverse=True)
+        hits.extend(h[0] for h in secondary_hits)
+
     hits = _social_domain_first(hits)
     hits = _intent_gate(hits, query)
+    hits = hits[:max_n]
     return hits if hits else ([catch_all] if catch_all else [])
 
 

package/scripts/safe_conn.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""safe_conn.py — 解析即锁定的 HTTP/HTTPS 连接类（DNS rebinding / TOCTOU 防护）
+
+独立成模块的理由：``http.client`` 会连带拉起 ``ssl``（实测 ≈14 ms）。
+``url_safety`` 被 ``robots_guard`` 等在**模块级**导入（见 robots_guard 的
+「轻导入」注释），若把 ``http.client`` 放在 ``url_safety`` 里，
+``test_robots_guard.test_module_import_stays_light`` 会红。连接类只在真正
+建连时经 ``net_proxy.open_connection`` 导入，不进轻导入路径。
+
+原理：``check_url()`` 在请求前解析一次 DNS，``http.client`` 在 ``connect()``
+时再解析一次——两次之间域名可改指内网（DNS rebinding）。本类在 ``connect()``
+里解析一次、过滤私网、把结果钉给本次 TCP 连接，窗口关闭；SNI/Host 仍用原域名。
+"""
+
+from __future__ import annotations
+
+import http.client
+
+from url_safety import pin_host
+
+
+class SafeHTTPConnection(http.client.HTTPConnection):
+    """解析即锁定的 HTTP 连接：TCP 只连校验过的公网 IP，Host 头仍用原域名。"""
+
+    def connect(self):
+        pinned = pin_host(self.host)
+        if pinned is None:
+            return super().connect()
+        host = self.host
+        self.host = pinned
+        try:
+            super().connect()
+        finally:
+            self.host = host
+
+
+class SafeHTTPSConnection(http.client.HTTPSConnection):
+    """解析即锁定的 HTTPS 连接：TCP 钉公网 IP，SNI/证书校验仍用原域名。"""
+
+    def connect(self):
+        pinned = pin_host(self.host)
+        if pinned is None:
+            return super().connect()
+        host = self.host
+        self.host = pinned
+        try:
+            http.client.HTTPConnection.connect(self)      # 仅 TCP
+        finally:
+            self.host = host
+        server_hostname = self._tunnel_host or host
+        self.sock = self._context.wrap_socket(
+            self.sock, server_hostname=server_hostname)

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

package/scripts/search_attribution.py

@@ -44,15 +44,112 @@ def top_engine_latency(engine_latency: dict[str, Any] | None,
 
 
 def usage_log_attribution(engine_latency: dict[str, Any] | None,
-                          top_n: int = DEFAULT_TOP_N) -> dict[str, Any]:
-    """usage_log query 流的归因字段（当前只有引擎耗时 Top-N）。
+                          top_n: int = DEFAULT_TOP_N,
+                          engine_outcomes: Iterable[dict[str, Any]] | None = None
+                          ) -> dict[str, Any]:
+    """usage_log query 流的归因字段（慢源 Top-N + 失败类别）。
 
     返回 dict 以便调用方 **展开进日志记录**，未来新增归因维度（如
     「等待预算被谁耗掉」「缓存未命中的原因分布」）时只扩这里，
     主管线那一行 `**usage_log_attribution(...)` 不动——归因是会长大的，
     写入点不该跟着长（主管线有模块大小门禁，见模块 docstring）。
+
+    失败类别只记「哪类」不记条数：errors 已经记了条数，两者互补。
+    """
+    out: dict[str, Any] = {
+        "engine_latency_top": top_engine_latency(engine_latency, top_n),
+    }
+    kinds = failure_kinds(engine_outcomes)
+    if kinds:
+        out["failure_kinds"] = kinds
+    return out
+
+
+# 合成引擎名（只存在于基准/混沌测试的 fake combo）。它们出现在 engines_used
+# 里就说明这一跑不是真实检索；写进生产 usage_log 会污染慢源排行与总量统计
+# （2026-10-21 实测 "hedge bench" 32 条，dead_primary/fast_backup 进了慢源榜）。
+_SYNTHETIC_ENGINES: frozenset[str] = frozenset({
+    "dead_primary", "dead_backup", "fast_backup", "slow_backup",
+    "slow_primary", "quick_primary", "fast_primary",
+})
+
+
+def is_synthetic_run(engines: Iterable[str] | None) -> bool:
+    """这组引擎是否来自基准/测试的合成组合（有一个即判合成）。"""
+    return any(str(e) in _SYNTHETIC_ENGINES for e in (engines or []))
+
+
+# 「源被跳过/没资格调用」的状态：空结果时要把它们与「查询没有召回」分开。
+# 只收持续性状态（配额/缺 env/鉴权），不含 timeout/error——后者是本次
+# 真的失败了，原表述已够用。
+SKIPPED_SOURCE_STATUSES: frozenset[str] = frozenset({
+    "skipped-quota-exhausted", "skipped-missing-env",
+    "quota-exhausted", "auth-failed",
+})
+
+
+def skipped_sources(engine_outcomes: Iterable[dict[str, Any]] | None,
+                    limit: int = 4) -> list[str]:
+    """空结果时被跳过/鉴权失败的引擎名（去重、保序、限量）。"""
+    out: list[str] = []
+    seen: set[str] = set()
+    for o in (engine_outcomes or []):
+        if not isinstance(o, dict):
+            continue
+        if str(o.get("status") or "") not in SKIPPED_SOURCE_STATUSES:
+            continue
+        name = str(o.get("engine") or "?")
+        if name not in seen:
+            seen.add(name)
+            out.append(name)
+        if len(out) >= max(0, int(limit)):
+            break
+    return out
+
+
+def zero_result_recovery_note(recovery: Any,
+                              engine_outcomes: Iterable[dict[str, Any]] | None
+                              ) -> str | None:
+    """恢复链触发但没救回来时的局限声明；不需要声明时返回 None。
+
+    「没有召回」与「源被跳过/鉴权失败」处置完全不同：前者改写查询，
+    后者看 failures 或补凭证。此前一律写成 no recall，实测 bocha 配额
+    耗尽（403 not enough money）被报成「查询无召回」，调用方白跑一轮。
     """
-    return {"engine_latency_top": top_engine_latency(engine_latency, top_n)}
+    if not isinstance(recovery, dict) or not recovery.get("triggered") \
+            or recovery.get("recovered"):
+        return None
+    note = recovery.get("note") or "no note"
+    skipped = skipped_sources(engine_outcomes)
+    if skipped:
+        return (
+            "recovery triggered but no usable strategy ("
+            f"{note}); empty results came from skipped/failed sources "
+            f"({', '.join(skipped)}) — see failures; this is not necessarily "
+            "a no-recall query"
+        )
+    return (
+        "recovery triggered but no usable strategy ("
+        f"{note}); empty results likely mean the query had no recall — "
+        "try rephrasing"
+    )
+
+
+def failure_kinds(engine_outcomes: Iterable[dict[str, Any]] | None,
+                  limit: int = 6) -> list[str]:
+    """本次调用的失败类别（去重、稳定排序），写进 usage_log 供长期归因。
+
+    errors 只记「几条」，回答不了「哪类失败在反复出现」；类别来自
+    output_transparency.build_failures（与 agent 档 failures 同一口径），
+    不在日志侧另写一份分类。
+    """
+    try:
+        from output_transparency import build_failures
+    except ImportError:  # pragma: no cover - 单文件分发时的降级
+        return []
+    rows = build_failures({"engine_outcomes": list(engine_outcomes or [])},
+                          limit=limit)
+    return sorted({str(r.get("category") or "unknown") for r in rows})
 
 
 def aggregate_slow_engines(rows: Iterable[dict[str, Any]],

package/scripts/search_cli.py

@@ -328,6 +328,27 @@ def _format_engine_summary(summary: dict[str, Any]) -> str:
     return "\n".join(lines)
 
 
+def _merge_verify_timing(timing: dict[str, Any], verify_ms: float) -> None:
+    """把 verify 的墙钟并回 timing 的三个总数，保持互相自洽。
+
+    why：verify 发生在主搜索快照之后。此前只并回 stages_ms/process_ms，
+    elapsed_ms 仍是主搜索的数（实测 1173 vs 10967），调用方最先读的总账
+    比它的分项之和还小 8 倍。三个数必须一起走，否则「这次为什么慢」会被
+    带偏到主搜索上。
+    """
+    total = float(timing.get("stages_ms") or 0) + verify_ms
+    timing.setdefault("stages", []).append({
+        "stage": "verify",
+        "ms": round(verify_ms, 1),
+        "pct": round(verify_ms * 100.0 / total, 1) if total > 0 else 0.0,
+    })
+    timing["stages_ms"] = round(total, 1)
+    timing["process_ms"] = round(
+        float(timing.get("process_ms") or 0) + verify_ms, 1)
+    timing["elapsed_ms"] = round(
+        max(float(timing.get("elapsed_ms") or 0), total), 1)
+
+
 def main():
     # 入口第一件事：钉住 stdout/stderr 编码（实现唯一，见 cli_io）。
     # 放在这里而不是 import 期：本模块被 search.py 与 bin/argo 两条路调用，
@@ -579,19 +600,11 @@ def main():
     # （process_ms 定格处）之后，净增 280–1160ms 完全不进任何账——实测
     # wall 776–1746ms vs process_ms 494–701ms，「这次为什么慢」归因指错
     # 方向。快照后移做不到（verify 是装配后的可选后处理），补一个 stage
-    # 并把耗时并回 stages_ms / process_ms，两个总数保持自洽。
+    # 并把耗时并回三个总数（stages_ms / process_ms / elapsed_ms），
+    # 三者保持自洽（2026-10-22 补 elapsed_ms）。
     if _timing is not None and "timing" in results and args.verify:
         _verify_ms = (time.perf_counter() - _t_verify0) * 1000.0
-        _t = results["timing"]
-        _total = float(_t.get("stages_ms") or 0) + _verify_ms
-        _t.setdefault("stages", []).append({
-            "stage": "verify",
-            "ms": round(_verify_ms, 1),
-            "pct": round(_verify_ms * 100.0 / _total, 1) if _total > 0 else 0.0,
-        })
-        _t["stages_ms"] = round(_total, 1)
-        _t["process_ms"] = round(
-            float(_t.get("process_ms") or 0) + _verify_ms, 1)
+        _merge_verify_timing(results["timing"], _verify_ms)
 
     if args.json_output:
         public = {k: v for k, v in results.items() if not k.startswith("_")}

package/scripts/search_entry.py

@@ -28,7 +28,7 @@ engine_dispatch。
 from __future__ import annotations
 
 import time
-from dataclasses import dataclass, field, replace
+from search_types import slot_record as dataclass, slot_field as field, slot_replace as replace
 from typing import Any, Callable, Optional
 
 from engine_dispatch import run_dispatch
@@ -361,6 +361,11 @@ def dispatch(req: _SearchRequest, run: _SearchRun, hooks: _SearchHooks) -> _Sear
     engine_latency = _dispatch.engine_latency
     wasted_ms = _dispatch.wasted_ms
     useful_ms = _dispatch.useful_ms
+    dispatch_tail = {
+        "first_sufficient_ms": _dispatch.first_sufficient_ms,
+        "tail_wait_ms": _dispatch.tail_wait_ms,
+        "abandoned_engine_ms": _dispatch.abandoned_engine_ms,
+    }
     early_stopped = _dispatch.early_stopped
     budget_used_ms = _dispatch.budget_used_ms
     budget_total_ms = _dispatch.budget_total_ms
@@ -378,6 +383,7 @@ def dispatch(req: _SearchRequest, run: _SearchRun, hooks: _SearchHooks) -> _Sear
         engine_latency=engine_latency,
         wasted_ms=wasted_ms,
         useful_ms=useful_ms,
+        dispatch_tail=dispatch_tail,
         early_stopped=early_stopped,
         budget_used_ms=budget_used_ms,
         budget_total_ms=budget_total_ms,
@@ -386,4 +392,5 @@ def dispatch(req: _SearchRequest, run: _SearchRun, hooks: _SearchHooks) -> _Sear
         quota_batch=quota_batch,
         run_one=_run_one,
         ingest=_ingest,
+        stranded=_dispatch.stranded,
     )