argo-search 2.9.7 → 2.9.8

package/scripts/serp_guard.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
-"""serp_guard — HTML SERP 垃圾结果守卫（判定规则单点）。
+"""serp_guard — SERP / 模糊搜索结果的垃圾结果守卫（判定规则单点）。
 
 事故背景（dsh-free-search issue #38/#35 同款事故，argo 的 local_* 引擎同样
 暴露）：html 引擎解析的是无 API 的网页 SERP，上游偶发把缓存 SERP / 与查询
-完全无关的结果页当正常页返回，解析层照常抽出标题摘要，垃圾条目静默混进
-聚合，调用方把「答非所问」当成「网上没有」——失败伪装成功是红线，这类
-混入是它的隐形变体。
+完全无关的结果页当正常页返回；模糊搜索 API（people_daily 的 isFuzzy=True）
+匹配不到时则回整页默认 feed。两种形态都是「答非所问但看起来正常」，解析层
+照常抽出标题摘要，垃圾条目静默混进聚合，调用方把「答非所问」当成「网上
+没有」——失败伪装成功是红线，这类混入是它的隐形变体。
 
 裁决口径（全部量化，无模糊地带）：
 
@@ -16,7 +17,13 @@
   2. results 只取前 5 条；每条取 title+snippet。URL 不参与：缓存/跳转
      链接的 URL 常回显 query 参数（uddg=、q=），会正好把垃圾页放行，
      标题+摘要才是「这页在答什么」的信号。
-  3. 前 5 条全部与 query token 零交集 → 整页判垃圾（True）。
+  3. 前 5 条里没有任何一条覆盖 query token 的 20% → 整页判垃圾（True）。
+     只判「有没有一个词命中」不够：实测「2026年新能源汽车销量数据」经
+     local_bing 返回的五条全是 2026 年节假日/维基页面，只命中「2026」一个
+     数字 token，旧判据（有交集即放行）把整页垃圾放了过去，而核心词
+     「新能源汽车销量数据」全部缺席。覆盖率 1/9 远低于门槛。
+     中文查询在存在 CJK 二元组时**不把纯数字 token 计入分母**：年份是最
+     容易被无关页面顺带命中的词，不能拿它当相关性证据。
 
 为什么调用方对判垃圾应整页丢弃而不是过滤后返回幸存者：前 5 条全无关说明
 这一页整体答非所问（缓存页/错路由），幸存的一两条是同一页的噪声，过滤
@@ -43,6 +50,7 @@ from urllib.parse import urlparse
 _RUN_RE = re.compile(r"[\u4e00-\u9fff]+|[a-z0-9]+")
 _GUARD_WINDOW = 5      # 只看前 5 条：SERP 的「答非所问」看头部即可下结论
 _MIN_QUERY_TOKENS = 2  # query token 少于此数 → 无裁决权，恒不拦
+_MIN_COVERAGE = 0.2    # 单条结果至少要覆盖 20% 的 query token 才算「在答这题」
 _SWITCH_ENV = "ARGO_SERP_GUARD"
 
 
@@ -69,6 +77,20 @@ def _result_text(item: object) -> str:
     return f"{item.get('title') or ''} {item.get('snippet') or ''}"
 
 
+def _query_tokens(query: str) -> set[str]:
+    """query token；中文查询里纯数字不参与（年份不是相关性证据）。
+
+    有 CJK 二元组说明查询主体是中文短语，此时「2026」这类数字是最容易被
+    无关页面顺带命中的 token（节假日表、维基年表都带年份），留在分母里会
+    把覆盖率算高、把垃圾页放行。纯拉丁查询（如「2026 GDP」）没有这个问题，
+    数字是有信息的，照常保留。
+    """
+    tokens = _extract_tokens(query)
+    if any("\u4e00" <= ch <= "\u9fff" for tok in tokens for ch in tok):
+        tokens = {tok for tok in tokens if not tok.isdigit()}
+    return tokens
+
+
 def is_junk_serp(query: str, results: list[dict]) -> bool:
     """判一页 SERP 结果是否整体答非所问（口径见模块 docstring）。
 
@@ -77,7 +99,7 @@ def is_junk_serp(query: str, results: list[dict]) -> bool:
     """
     if not guard_enabled():
         return False
-    q_tokens = _extract_tokens(query if isinstance(query, str) else "")
+    q_tokens = _query_tokens(query if isinstance(query, str) else "")
     if len(q_tokens) < _MIN_QUERY_TOKENS:
         return False
     if not isinstance(results, list):
@@ -86,7 +108,8 @@ def is_junk_serp(query: str, results: list[dict]) -> bool:
     if not head:
         return False
     for item in head:
-        if _extract_tokens(_result_text(item)) & q_tokens:
+        hit = _extract_tokens(_result_text(item)) & q_tokens
+        if len(hit) / len(q_tokens) >= _MIN_COVERAGE:
             return False
     return True
 
@@ -226,3 +249,88 @@ def drop_shell_urls(results: list) -> list:
             continue
         kept.append(r)
     return kept
+
+
+# ── 内容农场与 AI 机翻垃圾站判定（2026-10-23）─────────────────────────────
+#
+# 依据 source_types_cn.json 的 content_farm_markers 与结构化特征模式，
+# 识别并拦截低质搬运镜像、机翻爬虫站及流水线批量 AI 假稿。
+
+_FARM_CONNECTORS = ("首先", "其次", "然后", "接下来", "最后", "综上所述")
+_FARM_AI_PHRASES = ("业内人士表示", "专家分析", "消费者认为", "看完这篇你就懂了",
+                    "看完你就懂了", "建议收藏", "综上所述")
+
+
+def is_content_farm(url: str = "", title: str = "", snippet: str = "") -> bool:
+    """判定某条目是否属于内容农场 / 机翻爬虫 / 批量流水线 AI 废话。
+
+    2026-10-23 接线前用 5 条正例 + 4 条边界标定，修正两处：
+      - 序数连接词单独出现**不判农场**：正常安装指南同样含「首先/其次/然后/
+        接下来/最后」（实测 5 个），旧判据 `hit_conn >= 4` 把它误杀了。现在
+        要求同时出现 ≥1 个 AI 套话（流水线稿的伴生特征）。
+      - 「自费 N 元实测」不再要求标题带「最新」：实测真实的虚假实测标题是
+        「自费5000元实测10款耳机」，不带「最新」，旧判据漏召。
+    """
+    if not guard_enabled():
+        return False
+    cfg = _load_cn_source_types()
+    host = _normalize_domain(url)
+    host_bare = host[4:] if host.startswith("www.") else host
+    farm_markers = tuple(cfg.get("content_farm_markers") or ())
+    if any(host_bare == m or host == m or host_bare.endswith("." + m) or host.endswith("." + m)
+           for m in farm_markers):
+        return True
+
+    low_url = (url or "").lower()
+    for pat in cfg.get("content_farm_url_patterns") or []:
+        if pat.lower() in low_url:
+            # 仅在非白名单顶级域下生效
+            if any(host.endswith(tld) for tld in (".top", ".xyz", ".site", ".cc", ".icu", ".work")):
+                return True
+
+    # 标题模式：虚假实测 / 利益诱饵 + 年份刷新
+    t = (title or "").strip()
+    if t:
+        if re.search(r"自费\s*\d+\s*元?实测", t):
+            return True
+        if re.search(r"\d{4}\s*最新推荐\s*\d+\s*款.*看完这篇你就懂了", t):
+            return True
+
+    # 摘要/正文模式：高度僵化的模板流水线
+    body = f"{t} {snippet or ''}".strip()
+    if body:
+        hit_conn = sum(1 for w in _FARM_CONNECTORS if w in body)
+        hit_ai = sum(1 for w in _FARM_AI_PHRASES if w in body)
+        if hit_conn >= 4 and hit_ai >= 1:
+            return True
+        if hit_ai >= 2 and hit_conn >= 1:
+            return True
+        if hit_ai >= 3:
+            return True
+
+    return False
+
+
+def is_unusable_url(url: str, title: str = "", snippet: str = "") -> bool:
+    """是否为不可作为信源引用的条目（SERP壳 或 确凿内容农场）。"""
+    if is_serp_or_jump_url(url):
+        return True
+    return is_content_farm(url, title, snippet)
+
+
+def filter_content_farms(results: list) -> list:
+    """过滤结果列表里的内容农场条目。"""
+    if not results or not guard_enabled():
+        return results or []
+    kept = []
+    for r in results:
+        if not isinstance(r, dict):
+            continue
+        u = r.get("url") or ""
+        t = r.get("title") or ""
+        s = r.get("snippet") or ""
+        if is_content_farm(u, t, s):
+            continue
+        kept.append(r)
+    return kept
+

package/scripts/serp_kill_log.py

@@ -16,9 +16,11 @@ import threading
 from typing import Any
 
 # 判定规则与逃生门（ARGO_SERP_GUARD=0）在 serp_guard 单点；这里只登记
-# 哪些引擎接了守卫（解析上游 HTML 页最易被缓存 SERP 静默命中）。
+# 哪些引擎接了守卫（解析上游 HTML 页 / 模糊搜索接口最易被缓存 SERP 或
+# 默认 feed 静默命中）。people_daily 的 isFuzzy=True 在匹配不到时返回整页
+# 最新 feed（issue #18 复现 A），与 local_* 同属「答非所问但形态正常」。
 SERP_GUARD_ENGINES = frozenset({
-    "local_bing", "local_baidu", "local_sogou",
+    "local_bing", "local_baidu", "local_sogou", "people_daily",
 })
 
 # 进程级 + 锁。并发搜索下 drain 可能拿到彼此的条目——条目只含引擎名与
@@ -49,3 +51,24 @@ def drain_serp_guard_kills() -> list[dict[str, Any]]:
         kills = list(_KILLS)
         _KILLS.clear()
         return kills
+
+
+def clean_engine_lists(raw_results: dict[str, list[Any]],
+                       query: str) -> list[list[dict[str, Any]]]:
+    """raw_results{engine → results} → 去 error + SERP 守卫后的非空列表。
+
+    守卫必须同时覆盖缓存命中：per-engine 缓存走 engine_dispatch，不经过
+    engines.search，旧条目里的默认 feed/垃圾 SERP 会以 `ok-cached` 直接
+    返回（issue #18 的 14ms 复现）。融合前按引擎整页判定一次，缓存与网络
+    两条路径就收敛到同一口径；engines.search 里的守卫保留，因为它还要
+    阻止垃圾结果影响早停判定。
+    """
+    out: list[list[dict[str, Any]]] = []
+    for eng, res in (raw_results or {}).items():
+        goods = [r for r in (res or []) if isinstance(r, dict) and "error" not in r]
+        if not goods:
+            continue
+        goods = serp_guard_apply(eng, query, goods)
+        if goods:
+            out.append(goods)
+    return out

package/scripts/stats_cli.py

@@ -29,7 +29,19 @@ from search_attribution import aggregate_slow_engines  # noqa: E402
 def _query_summary(n: int) -> dict:
     rows = usage_log.tail("query", n)
     if not rows:
-        return {"samples": 0}
+        # 空日志（CI 全新 runner / 首次安装）也要给稳定的字段形状：夜间账本
+        # 直接读 avg_elapsed_ms，此前这里只回 {"samples": 0}，工作流每次
+        # 首次跑必炸 KeyError（issue #19）。指标用 None 而不是 0：0ms 会被
+        # 画成一条假曲线，None 才表示「没有样本」；调用方按 samples 判断。
+        return {
+            "samples": 0,
+            "result_rate": None,
+            "avg_elapsed_ms": None,
+            "recovered": 0,
+            "top_engines": [],
+            "slowest_engines": [],
+            "recent": [],
+        }
     counts = [r.get("count", 0) for r in rows]
     lat = [r.get("elapsed_ms") for r in rows if isinstance(r.get("elapsed_ms"), (int, float))]
     engines: Counter = Counter()

package/scripts/wide_research.py

@@ -113,6 +113,40 @@ def normalize_tracks(raw: Any, maximum: int = 9) -> list[dict[str, Any]]:
     return out
 
 
+def build_cross_lingual_tracks(question: str, maximum: int = 4) -> list[dict[str, Any]]:
+    """为溯源与多语言任务自动构建分阶段跨语言长程轨道。"""
+    q = (question or "").strip()
+    has_tracing = bool(re.search(
+        r"(?:溯源|起源|出处|最初|源头|提出者|发明|草案|历史沿革|origin|provenance|root cause|first proposed|specification|rfc|cve)",
+        q, re.I
+    ))
+    tracks = []
+    tracks.append({
+        "id": "track-primary-lang",
+        "title": "原语言背景与核心定义",
+        "question": f"{q} 背景 定义 现状",
+        "rationale": "Primary language overview and conceptual framing.",
+        "depends_on": [],
+    })
+    if has_tracing or len(tracks) < maximum:
+        tracks.append({
+            "id": "track-origin-trace",
+            "title": "源头出处与权威一手规范长程溯源",
+            "question": f"{q} original paper inception specification first proposed RFC official repository",
+            "rationale": "Cross-lingual long-range tracing for primary sources, papers, or official specifications.",
+            "depends_on": ["track-primary-lang"],
+        })
+        tracks.append({
+            "id": "track-cross-reconciliation",
+            "title": "多语言证据交叉对账与互补验证",
+            "question": f"{q} milestone benchmark evaluation comparison timeline",
+            "rationale": "Cross-lingual reconciliation of evidence, timeline differences, and complementary facts.",
+            "depends_on": ["track-origin-trace"],
+        })
+    return tracks[:maximum]
+
+
+
 def stage_tracks(tracks: list[dict[str, Any]]) -> tuple[list[list[dict[str, Any]]], list[str]]:
     """轨道分层。work package 的分层逻辑与轨道同构：id/question/depends_on。"""
     packages = [
@@ -255,6 +289,17 @@ def evaluate_gates(
     if len(caveats) + len(unanswered) >= max(3, (len(sources) + 1) // 2):
         warnings.append({"id": "high_uncertainty",
                          "detail": f"{len(caveats)} caveats and {len(unanswered)} unanswered questions exceed the evidence threshold."})
+
+    # 内容农场与镜像站占优检查
+    farm_markers = ("ctolib.com", "coder.work", "voidcn.com", "it1352.com", "oommake.com", "py4u.net",
+                    "wenku.zone", "chinadmd.com", "jb51.net", "pc6.com", "onlinedown.net")
+    farm_hits = [s for s in sources if any(m in str(s.get("url", "")).lower() for m in farm_markers)]
+    if farm_hits and len(farm_hits) >= (len(sources) + 1) // 2:
+        warnings.append({
+            "id": "content_farm_dominant",
+            "detail": f"{len(farm_hits)} sources originate from content farms or SEO scraper mirrors; evidence quality severely degraded.",
+        })
+
     cap = "low" if failures else ("medium" if warnings else "high")
     return {"passed": not failures, "conclusion_cap": cap, "failures": failures, "warnings": warnings}
 

package/scripts/zhihu_quota.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""zhihu_quota.py — 知乎开放平台额度查询（官方 `/api/v1/quota`）。
+
+为什么需要（2026-10-21）：知乎各能力的每日免费额度是**账号级**的，同一账号的
+多个 Access Secret 共用；本地按引擎计数会与真实额度漂移。官方额度查询不消耗
+业务额度，是唯一权威来源。本模块只做读取与缓存，不参与路由决策（路由仍用
+quota.py 的本地计数），避免每次搜索多一次外呼。
+
+用法：
+  argo quota            # 人读表
+  argo quota --json     # 机器读
+  argo quota --refresh  # 跳过 10 分钟缓存
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+import urllib.request
+
+from cli_io import dumps
+from engine_env import get_env
+from engines_base import http_open
+
+API_URL = "https://developer.zhihu.com/api/v1/quota"
+CACHE_TTL_S = 600
+
+# APIID → argo 引擎名（与 config.yaml / quota_profiles.json 对齐）
+API_TO_ENGINE = {
+    "global_search": "zhihu_global",
+    "zhihu_search": "zhihu",
+    "hot_list": "zhihu_hot",
+    "question_discovery": "zhihu_questions",
+    "zhida_openai": "zhida",
+    "tools": "zhihu_tools",
+    "knowledge": "zhihu_kb",
+    "user_data": "zhihu_user",
+    "creator": "zhihu_creator",
+}
+
+
+def _cache_path():
+    import argo_paths
+    return argo_paths.state_path("zhihu_quota.json")
+
+
+def _secret() -> str:
+    return get_env(["ARGO_ZHIHU_ACCESS_SECRET", "ZHIHU_ACCESS_SECRET"])
+
+
+def _load_cache() -> dict | None:
+    try:
+        raw = json.loads(_cache_path().read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    if not isinstance(raw, dict):
+        return None
+    if time.time() - float(raw.get("ts") or 0) > CACHE_TTL_S:
+        return None
+    return raw
+
+
+def _save_cache(items: list[dict]) -> None:
+    try:
+        import argo_paths
+        argo_paths.atomic_write_json(_cache_path(),
+                                     {"ts": time.time(), "items": items})
+    except Exception:
+        pass
+
+
+def fetch_quota(*, refresh: bool = False, timeout: float = 8.0) -> dict:
+    """返回 {ok, items, error, cached}；永不抛异常（观测层不阻断主路径）。"""
+    if not refresh:
+        cached = _load_cache()
+        if cached is not None:
+            return {"ok": True, "items": cached.get("items") or [], "cached": True}
+    secret = _secret()
+    if not secret:
+        return {"ok": False, "items": [], "cached": False,
+                "error": "缺少 ZHIHU_ACCESS_SECRET"}
+    req = urllib.request.Request(API_URL, headers={
+        "Authorization": f"Bearer {secret}",
+        "X-Request-Timestamp": str(int(time.time())),
+        "Content-Type": "application/json",
+        "User-Agent": "argo-search/2.6 (unified-search@local)",
+    })
+    try:
+        with http_open(req, timeout=timeout, engine="zhihu_quota") as resp:
+            data = json.loads(resp.read().decode("utf-8", "replace"))
+    except Exception as exc:
+        return {"ok": False, "items": [], "cached": False,
+                "error": f"{type(exc).__name__}: {exc}"}
+    if data.get("Code") not in (0, None):
+        return {"ok": False, "items": [], "cached": False,
+                "error": f"Code={data.get('Code')} {data.get('Message') or ''}"}
+    items = []
+    for row in data.get("Data") or []:
+        if not isinstance(row, dict):
+            continue
+        api_id = str(row.get("APIID") or "")
+        items.append({
+            "api_id": api_id,
+            "engine": API_TO_ENGINE.get(api_id, api_id),
+            "name": row.get("APIName") or api_id,
+            "total": row.get("TotalQuota"),
+            "used": row.get("TotalUsed"),
+            "remaining": row.get("RemainingQuota"),
+        })
+    _save_cache(items)
+    return {"ok": True, "items": items, "cached": False}
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="argo quota",
+                                 description="知乎开放平台当日额度（官方 API）")
+    ap.add_argument("--json", action="store_true")
+    ap.add_argument("--refresh", action="store_true")
+    args = ap.parse_args(argv)
+    out = fetch_quota(refresh=args.refresh)
+    if args.json:
+        print(dumps(out))
+        return 0 if out.get("ok") else 1
+    if not out.get("ok"):
+        print(f"额度查询失败：{out.get('error')}")
+        return 1
+    print("知乎开放平台当日额度（北京时间 00:00 重置）")
+    print(f"{'引擎':<18}{'额度项':<20}{'总额':>8}{'已用':>8}{'剩余':>8}")
+    for row in out["items"]:
+        print(f"{row['engine']:<18}{row['name']:<20}"
+              f"{str(row['total']):>8}{str(row['used']):>8}{str(row['remaining']):>8}")
+    if out.get("cached"):
+        print("（10 分钟内缓存；--refresh 强制刷新）")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/sub-skills/local-search/bm25.py

@@ -43,6 +43,7 @@ _CJK_RE = re.compile(r"[\u4e00-\u9fff]+")
 
 _K1 = 1.5
 _B = 0.75
+_DELTA = 0.5          # BM25+ 下界 (Lv & Zhai 2011)：长文档命中词保底，消除过惩罚
 # 混合权重：BM25 侧。位次先验占 1 - _W_BM25。
 _W_BM25 = 0.6
 # 旧位次衰减口径（max(0.7 - idx*0.05, 0.1)）——先验的归一化基准。
@@ -79,9 +80,10 @@ class BM25:
     引擎的 5 条结果上稳定得多——「含查询词的文档有多罕见」是跨源问题。
     """
 
-    def __init__(self, docs: list[list[str]], k1: float = _K1, b: float = _B):
+    def __init__(self, docs: list[list[str]], k1: float = _K1, b: float = _B, delta: float = _DELTA):
         self.k1 = k1
         self.b = b
+        self.delta = delta
         self.n_docs = len(docs)
         self.doc_len = [len(d) for d in docs]
         self.avgdl = (sum(self.doc_len) / self.n_docs) if self.n_docs else 0.0
@@ -113,10 +115,30 @@ class BM25:
             f = self.tf.get(t, {}).get(doc_idx, 0)
             if not f:
                 continue
-            total += self.idf(t) * (f * (self.k1 + 1.0)) / (f + denom_norm)
+            sat = (f * (self.k1 + 1.0)) / (f + denom_norm)
+            # BM25+ 饱和项下界增益（Lv & Zhai 2011）
+            total += self.idf(t) * (sat + self.delta)
         return total
 
 
+def _phrase_proximity_bonus(query: str, title: str, snippet: str) -> float:
+    """词邻近度与短语连续匹配加成（归一化为 0.0~1.0）。
+
+    当完整查询短语在标题或摘要逐字紧密出现时给予增益，提升复合词精准命中率。
+    """
+    q_low = (query or "").lower().strip()
+    if not q_low or len(q_low) < 2:
+        return 0.0
+    t_low = (title or "").lower()
+    s_low = (snippet or "").lower()
+    if q_low in t_low:
+        return 1.0  # 标题完整覆盖查询短语
+    if q_low in s_low:
+        return 0.5  # 摘要完整覆盖查询短语
+    return 0.0
+
+
+
 def _doc_text(r: dict[str, Any]) -> str:
     """参与相关度计算的文档文本：title 权重高于 snippet——做法是标题
     拼两遍（TF 加成），不引入第二套字段权重机制。"""
@@ -153,7 +175,9 @@ def rerank(by_engine: dict[str, list[dict[str, Any]]], query: str,
     for (eng, idx, r), bm in zip(flat, raw):
         bm25_norm = (bm / max_raw) if max_raw > 0 else 0.0
         prior_norm = _position_prior(idx) / _PRIOR_BASE
-        r["score"] = round(w_bm25 * bm25_norm + (1.0 - w_bm25) * prior_norm, 3)
+        prox_val = _phrase_proximity_bonus(query, r.get("title", ""), r.get("snippet", ""))
+        rel_score = min(bm25_norm * 0.80 + prox_val * 0.20, 1.0) if bm25_norm > 0 else 0.0
+        r["score"] = round(w_bm25 * rel_score + (1.0 - w_bm25) * prior_norm, 3)
 
     for eng in by_engine:
         by_engine[eng].sort(