argo-search 2.9.8 → 2.9.9

package/scripts/fetch_v3.py

@@ -53,7 +53,7 @@ if SCRIPT_DIR not in sys.path:
 
 # 渲染层（第二级A）：TinyFish 直连渲染，独立模块以保持本文件聚焦主链调度
 import fetch_render_tinyfish as _render_tinyfish
-
+from clock_bridge import clock  # 统一时钟（测试=虚拟；生产=monotonic）
 # 质量信号层（第三级）：来源分类 / 页面类型 / 质量分 / 内容安全
 import fetch_quality as _quality
 
@@ -1353,14 +1353,14 @@ def fetch_v3(url: str, max_chars: int = 8000, timeout: float = 8.0,
                 deadline_s = float(os.environ.get("ARGO_FETCH_DEADLINE_S", "60") or 60)
             except ValueError:
                 deadline_s = 60.0
-        t_chain0 = time.monotonic()
+        t_chain0 = clock()
         deadline_hit = {"flag": False}
 
         def _budget_left() -> float:
             """剩余降级预算；耗尽时置标记并返回 -1（调用方停止升级）。"""
             if deadline_s <= 0:
                 return 1.0
-            left = deadline_s - (time.monotonic() - t_chain0)
+            left = deadline_s - (clock() - t_chain0)
             if left <= 0:
                 deadline_hit["flag"] = True
                 return -1.0

package/scripts/http_client.py

@@ -36,11 +36,22 @@ from contextlib import contextmanager
 from typing import Any
 
 try:
-    from url_safety import check_url
+    from url_safety import check_url, check_redirect_target
+    from url_safety import max_redirects as _max_redirects
+    from url_safety import resolve_redirect_chain
 except ImportError:  # pragma: no cover
     def check_url(url: str) -> tuple[bool, str]:
         return True, ""
 
+    def check_redirect_target(url: str, start: float) -> dict | None:
+        return None
+
+    def _max_redirects() -> int:
+        return 5
+
+    def resolve_redirect_chain(url, headers, timeout, limit=None):
+        return None
+
 
 # ─── User-Agent 轮换池 ───────────────────────────────────────────────────────
 
@@ -525,7 +536,7 @@ class HttpClient:
         """实际执行 GET 请求（使用 http.client，不自动解压）。"""
         start = time.time()
         current_url = url
-        redirects_left = 5 if follow_redirects else 0
+        redirects_left = _max_redirects() if follow_redirects else 0
 
         while True:
             # 构建请求头
@@ -593,6 +604,11 @@ class HttpClient:
                         ch if ord(ch) < 128 else urllib.parse.quote(ch)
                         for ch in current_url
                     )
+                # 每跳重定向目标过 SSRF 校验（与 _safe_follow_redirects 对齐）：
+                # 旧实现只校验首跳，重定向到内网即可绕过（SSRF）
+                blocked = check_redirect_target(current_url, start)
+                if blocked:
+                    return blocked
                 redirects_left -= 1
                 continue
 
@@ -664,7 +680,7 @@ class HttpClient:
         start = time.time()
         headers = _random_headers(extra_headers)
 
-        final_url = self._safe_follow_redirects(url, headers)
+        final_url = resolve_redirect_chain(url, headers, self.timeout)
         if final_url is None:
             return {"status": 0, "headers": {}, "text": "", "url": url,
                     "elapsed_ms": int((time.time() - start) * 1000),
@@ -868,7 +884,7 @@ class HttpClient:
         """
         start = time.time()
         current_url = url
-        redirects_left = 5 if follow_redirects else 0
+        redirects_left = _max_redirects() if follow_redirects else 0
         while True:
             headers = _random_headers(extra_headers)
             cookie_str = self._cookies.get_cookie_header(current_url)
@@ -914,6 +930,10 @@ class HttpClient:
                 if not loc:
                     break
                 current_url = urllib.parse.urljoin(current_url, loc)
+                # 每跳重定向目标过 SSRF 校验（与 _do_get/_safe_follow_redirects 对齐）
+                blocked = check_redirect_target(current_url, start)
+                if blocked:
+                    return blocked
                 redirects_left -= 1
                 continue
             raw_body = resp.read()
@@ -978,40 +998,6 @@ class HttpClient:
             return {"status": 0, "headers": {}, "text": "", "url": url,
                     "elapsed_ms": 0, "error": str(e)[:200]}
 
-    def _safe_follow_redirects(self, url: str, headers: dict,
-                               max_redirects: int = 5) -> str | None:
-        """逐跳安全跟随重定向：每跳目标都过 SSRF 校验。
-
-        返回最终 URL；任一跳被拦截或超过跳数返回 None。
-        """
-        current = url
-        for _ in range(max_redirects):
-            ok, _reason = check_url(current)
-            if not ok:
-                return None
-            parsed = urllib.parse.urlparse(current)
-            if parsed.scheme not in ("http", "https"):
-                return None
-            try:
-                from net_proxy import open_connection, request_selector, resolve_proxy
-                proxy_url = resolve_proxy(current)
-                conn, via_proxy = open_connection(parsed, self.timeout, proxy_url)
-                path = parsed.path or "/"
-                if parsed.query:
-                    path += "?" + parsed.query
-                conn.request("HEAD", request_selector(parsed, path, via_proxy),
-                             headers=headers)
-                resp = conn.getresponse()
-                status = resp.status
-                location = resp.getheader("Location")
-                conn.close()
-            except Exception:
-                return None
-            if status not in (301, 302, 303, 307, 308) or not location:
-                return current
-            current = urllib.parse.urljoin(current, location)
-        return None
-
 
 # ─── 便捷函数 ────────────────────────────────────────────────────────────────
 

package/scripts/local_engines.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""本地个性化引擎插件 — 不随公开仓库提交。
+
+包含漏洞查询类引擎（OSV.dev + CISA KEV），因启发式杀毒检测
+（HEUR:HackTool/VulnScan）从公开构建器中移出。
+本地文件，不提交 git；删除后对应引擎自动消失，不影响其他功能。
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+import urllib.request
+from typing import Any
+
+from engines_base import safe_search, rank_score, http_open, note_failure
+
+
+# ── OSV.dev 开源漏洞库（免 key，必须 POST）─────────────────────────────────
+
+_OSV_ECOSYSTEM_PREFIX: dict[str, str] = {
+    "pypi": "PyPI", "npm": "npm", "go": "Go", "crates": "crates.io",
+    "cargo": "crates.io", "maven": "Maven", "nuget": "NuGet",
+    "packagist": "Packagist", "composer": "Packagist",
+    "rubygems": "RubyGems", "gem": "RubyGems", "hex": "Hex",
+}
+
+_OSV_NPM_HINTS: frozenset[str] = frozenset({
+    "lodash", "react", "vue", "express", "axios", "next", "webpack",
+    "typescript", "eslint", "vite", "jest", "moment", "jquery", "angular",
+    "svelte", "nuxt", "rollup", "babel", "prettier", "cheerio", "socket.io",
+})
+
+_OSV_GO_HINTS: frozenset[str] = frozenset({
+    "golang.org/x/net", "golang.org/x/crypto", "golang.org/x/text",
+    "github.com/gin-gonic/gin", "github.com/gorilla/websocket",
+})
+
+
+def _osv_resolve_ecosystem(query: str) -> tuple[str, str]:
+    q = (query or "").strip()
+    if ":" in q:
+        head, _, tail = q.partition(":")
+        eco = _OSV_ECOSYSTEM_PREFIX.get(head.strip().lower())
+        if eco and tail.strip():
+            return tail.strip(), eco
+    name = q
+    if name.startswith("@") or "/" in name:
+        if name.startswith("@"):
+            return name, "npm"
+        if name.startswith(("github.com/", "gitlab.com/", "golang.org/")):
+            return name, "Go"
+        return name, "npm"
+    if name.lower() in _OSV_NPM_HINTS:
+        return name, "npm"
+    if name.lower() in _OSV_GO_HINTS:
+        return name, "Go"
+    return name, "PyPI"
+
+
+def _build_osv_engine(spec: dict[str, Any]) -> Any:
+    """OSV.dev 漏洞查询（按包名，POST /v1/query；免 key、免限次）。"""
+    timeout = spec.get("timeout", 15)
+
+    @safe_search
+    def _engine(query: str, n: int = 5, _timeout: float | None = None,
+                **kwargs) -> list[dict[str, Any]]:
+        to = _timeout or timeout
+        q = (query or "").strip()
+        if not q:
+            return []
+        if re.match(r"^CVE-\d{4}-\d{4,}$", q, re.I):
+            return []
+        pkg, eco = _osv_resolve_ecosystem(q)
+        body = json.dumps({"package": {"name": pkg, "ecosystem": eco}}).encode("utf-8")
+        req = urllib.request.Request(
+            "https://api.osv.dev/v1/query", data=body,
+            headers={"Content-Type": "application/json"})
+        eng_name = spec.get("_name") or "osv"
+        try:
+            with http_open(req, timeout=to, engine=eng_name) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+        except Exception as e:
+            if isinstance(e, (json.JSONDecodeError, UnicodeDecodeError)):
+                note_failure(eng_name, "parse", "json_decode", str(e))
+            import logging
+            logging.getLogger("unified_search.engines").warning(f"OSV 失败: {e}")
+            return []
+        results = []
+        for i, v in enumerate((data.get("vulns") or [])[:n]):
+            vid = str(v.get("id") or "").strip()
+            if not vid:
+                continue
+            summary = str(v.get("summary") or "").strip()
+            affected_bits = []
+            for aff in (v.get("affected") or [])[:2]:
+                if not isinstance(aff, dict):
+                    continue
+                for rng in (aff.get("ranges") or [])[:2]:
+                    if not isinstance(rng, dict):
+                        continue
+                    events = rng.get("events") or []
+                    introduced = next((e.get("introduced") for e in events
+                                       if isinstance(e, dict) and e.get("introduced")), "")
+                    fixed = next((e.get("fixed") for e in events
+                                  if isinstance(e, dict) and e.get("fixed")), "")
+                    if introduced or fixed:
+                        affected_bits.append(
+                            f"{introduced or '?'} ≤ 受影响 < {fixed or '未修复'}")
+            aliases = [a for a in (v.get("aliases") or []) if a][:3]
+            snippet = " · ".join(p for p in (
+                summary, f"生态 {eco}",
+                affected_bits[0] if affected_bits else "",
+                " ".join(aliases),
+            ) if p)[:300]
+            results.append({
+                "title": f"{vid} [{eco}] {summary}"[:500] or vid,
+                "url": f"https://osv.dev/vulnerability/{vid}",
+                "snippet": snippet,
+                "source": "osv",
+                "published_at": str(v.get("published") or "")[:10],
+                "score": rank_score(0.85, i),
+            })
+        return results
+    return _engine
+
+
+# ── CISA KEV 已知在野利用漏洞（免 key，全量文件 + 本地过滤）──────────────
+
+_KEV_CACHE: dict[str, Any] = {"at": 0.0, "items": None}
+_KEV_TTL_S = 6 * 3600
+
+
+def _kev_disk_path():
+    try:
+        from argo_paths import state_path
+        return state_path("cisa_kev_cache.json")
+    except Exception:
+        return None
+
+
+def _kev_load(timeout: float) -> list[dict[str, Any]]:
+    now = time.time()
+    cached = _KEV_CACHE.get("items")
+    if cached and (now - float(_KEV_CACHE.get("at") or 0)) < _KEV_TTL_S:
+        return cached
+    disk_p = _kev_disk_path()
+    if disk_p is not None and disk_p.exists():
+        try:
+            st = disk_p.stat()
+            if (now - st.st_mtime) < _KEV_TTL_S:
+                disk_items = json.loads(disk_p.read_text(encoding="utf-8"))
+                if isinstance(disk_items, list) and disk_items:
+                    _KEV_CACHE["items"] = disk_items
+                    _KEV_CACHE["at"] = st.st_mtime
+                    return disk_items
+        except Exception:
+            pass
+    req = urllib.request.Request(
+        "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json",
+        headers={"User-Agent": "argo-search/1.0 (+cisa-kev)", "Accept": "application/json"})
+    try:
+        with http_open(req, timeout=timeout, engine="cisa_kev") as resp:
+            data = json.loads(resp.read().decode("utf-8", "replace"))
+    except Exception as e:
+        if isinstance(e, (json.JSONDecodeError, UnicodeDecodeError)):
+            note_failure("cisa_kev", "parse", "json_decode", str(e))
+        import logging
+        logging.getLogger("unified_search.engines").warning(f"CISA KEV 失败: {e}")
+        return cached or []
+    items = data.get("vulnerabilities") or []
+    if not isinstance(items, list):
+        return cached or []
+    _KEV_CACHE["items"] = items
+    _KEV_CACHE["at"] = now
+    if disk_p is not None and items:
+        try:
+            from argo_paths import atomic_write_json
+            atomic_write_json(disk_p, items)
+        except Exception:
+            pass
+    return items
+
+
+def _build_cisa_kev_engine(spec: dict[str, Any]) -> Any:
+    """CISA KEV 在野利用漏洞目录（本地过滤全量目录）。"""
+    timeout = spec.get("timeout", 30)
+
+    @safe_search
+    def _engine(query: str, n: int = 5, _timeout: float | None = None,
+                **kwargs) -> list[dict[str, Any]]:
+        to = _timeout or timeout
+        q = (query or "").strip()
+        if not q:
+            return []
+        items = _kev_load(to)
+        if not items:
+            return []
+        cve_q = q.upper() if re.match(r"^CVE-\d{4}-\d{4,}$", q.strip(), re.I) else ""
+        matched = []
+        for v in items:
+            if not isinstance(v, dict):
+                continue
+            if cve_q:
+                if str(v.get("cveID") or "").strip().upper() == cve_q:
+                    matched.append(v)
+                continue
+            terms = [t for t in re.split(r"[\s,]+", q.lower()) if t]
+            hay = " ".join(str(v.get(k) or "") for k in (
+                "cveID", "vendorProject", "product", "vulnerabilityName",
+                "shortDescription", "requiredAction", "cwes")).lower()
+            if all(t in hay for t in terms):
+                matched.append(v)
+        matched.sort(key=lambda x: str(x.get("dateAdded") or ""), reverse=True)
+        results = []
+        for i, v in enumerate(matched[:n]):
+            cve = str(v.get("cveID") or "").strip()
+            if not cve:
+                continue
+            vendor = str(v.get("vendorProject") or "").strip()
+            product = str(v.get("product") or "").strip()
+            name = str(v.get("vulnerabilityName") or "").strip()
+            desc = str(v.get("shortDescription") or "").strip()
+            due = str(v.get("dueDate") or "").strip()
+            ransom = str(v.get("knownRansomwareCampaignUse") or "").strip()
+            bits = [b for b in (
+                f"{vendor} {product}".strip(),
+                f"修复期限 {due}" if due else "",
+                "已知勒索软件利用" if ransom.lower() == "known" else "",
+                desc,
+            ) if b]
+            results.append({
+                "title": f"{cve} — {name or product or vendor}"[:500],
+                "url": "https://www.cisa.gov/known-exploited-vulnerabilities-catalog",
+                "snippet": " · ".join(bits)[:300],
+                "source": "cisa_kev",
+                "published_at": str(v.get("dateAdded") or "")[:10],
+                "score": rank_score(0.9, i),
+            })
+        return results
+    return _engine
+
+
+# ── 引擎声明（本地个性化配置，不提交公开仓库）────────────────────────────────
+#
+# 字段与原 engines/specs/osv.yaml、engines/specs/cisa_kev.yaml 逐项对齐——
+# 那两个声明已加 _ 前缀改名停用（公开仓每次启动刷两行「未知引擎类型」warning），
+# 元数据随之并入本文件，本机路由行为（explicit_only / family / priority / qps
+# 等）与改名前完全一致。
+
+_LOCAL_ENGINE_SPECS: dict[str, dict[str, Any]] = {
+    "osv": {
+        "type": "osv",
+        "enabled": True,
+        "explicit_only": True,
+        "cost_tier": "free",
+        "label": "OSV 开源漏洞库",
+        "family": "security",
+        "priority": 44,
+        "qps": 2,
+        "period": "second",
+        "cost_per_call": 0.0,
+        "cost_unit": "free",
+        "method": "POST",
+        "url": "https://api.osv.dev/v1/query",
+        "timeout": 15,
+        "canary_query": "requests",
+        "desc": "OSV.dev 开源软件漏洞库（按包查已知漏洞与影响版本区间，免 key；生态 PyPI/npm/Go/crates 等）",
+        "description": "OSV.dev 开源漏洞查询（按包名）",
+        "coverage": ["security", "package"],
+        "recommended": False,
+        "latency_ms": 1500,
+        "headers": {"Content-Type": "application/json"},
+        "quality_queries": [
+            {"query": "requests"},
+            {"query": "lodash"},
+            {"query": "log4j-core"},
+        ],
+    },
+    "cisa_kev": {
+        "type": "cisa_kev",
+        "enabled": True,
+        "explicit_only": True,
+        "cost_tier": "free",
+        "label": "CISA KEV 在野利用漏洞",
+        "family": "security",
+        "priority": 47,
+        "qps": 1,
+        "period": "second",
+        "cost_per_call": 0.0,
+        "cost_unit": "free",
+        "timeout": 30,
+        "canary_query": "chrome",
+        "desc": "CISA 已知被在野利用漏洞目录（官方确认已被实际攻击利用的 CVE；全量 1.35MB 本地过滤）",
+        "description": "CISA KEV 在野利用漏洞目录",
+        "coverage": ["security"],
+        "recommended": False,
+        "latency_ms": 4000,
+        "quality_queries": [
+            {"query": "chrome"},
+            {"query": "CVE-2021-44228"},
+        ],
+    },
+}
+
+
+def register(builders: dict[str, Any], engine_specs: dict[str, Any]) -> None:
+    """将本地引擎注册到全局 builders 和 engine_specs 中。
+
+    在 engines.py 的 _load_registry() 中、构建 registry 之前调用。
+    文件不存在时 engines.py 跳过 import，不影响公开仓库。
+    外置 spec（engines/specs/*.yaml）已有的字段保留，不抹除 explicit_only/family 等元数据。
+    """
+    builders["osv"] = _build_osv_engine
+    builders["cisa_kev"] = _build_cisa_kev_engine
+    for name, spec in _LOCAL_ENGINE_SPECS.items():
+        base = dict(engine_specs.get(name) or {})
+        for k, v in spec.items():
+            base.setdefault(k, v)
+        engine_specs[name] = base

package/scripts/matrix_search_eval.py

@@ -269,6 +269,50 @@ ROUTE_MATRIX: list[dict[str, Any]] = [
      "domain": "company_search", "primary": "opencorporates", "scenario": "company"},
     {"id": "R_zh_company_regcap", "q": "字节跳动 注册资本 变更", "lang": "zh",
      "domain": "company_search", "primary": "opencorporates", "scenario": "company"},
+    # 2026-10-25 补（企业主体查询 MECE 类目）：尽调风险（注销/经营异常）、开票
+    # （开票信息/税号）、人查公司（担任法定代表人/名下公司）三类此前落
+    # org_entity 的 wikidata 组合——wikidata 对中文企业 7 天空结果率 82%，
+    # company_search 的元宝才是交付源。config.yaml 两域词表成对改动
+    # （org_entity 让位 unless + company_search 收口 match/unless），改一处
+    # 必须同步另一处。企业名/人名一律合成名（对外脱敏纪律，v2.9.8 同款）。
+    {"id": "R_zh_company_risk", "q": "晨曦合成科技有限公司 注销了吗", "lang": "zh",
+     "domain": "company_search", "primary": "opencorporates", "scenario": "company"},
+    {"id": "R_zh_company_invoice", "q": "晨曦合成科技有限公司 开票信息 税号", "lang": "zh",
+     "domain": "company_search", "primary": "opencorporates", "scenario": "company"},
+    {"id": "R_zh_company_person", "q": "李合成 担任法定代表人的公司", "lang": "zh",
+     "domain": "company_search", "primary": "opencorporates", "scenario": "company"},
+    # 双向锁（v2.9.8 纪律）：新词表不得误吸非主体查询——办事指南是 howto、
+    # 招聘是求职，都不该进尽调域
+    {"id": "R_zh_company_not_howto", "q": "公司注销流程 怎么办", "lang": "zh",
+     "domain_not": ["company_search", "org_entity"], "scenario": "company"},
+    {"id": "R_zh_company_not_job", "q": "晨曦合成科技有限公司 招聘", "lang": "zh",
+     "domain_not": ["company_search"], "scenario": "company"},
+    # ── 2026-10-25 六族 MECE 扫描（学术/金融财务/法律/医药）──
+    # 全部为真实场景类目，企业名/人名保持合成名（脱敏纪律）。每处 config 改动
+    # 都有成对的 unless 让位，反例见 tests/test_domain_rule_schema.py。
+    {"id": "R_zh_stock_financials", "q": "贵州茅台 2025 年报 营收", "lang": "zh",
+     "domain": "stock_query", "primary": "sina_quote", "scenario": "finance"},
+    {"id": "R_zh_stock_valuation", "q": "贵州茅台 市盈率 估值", "lang": "zh",
+     "domain": "stock_query", "primary": "sina_quote", "scenario": "finance"},
+    # zh 财务词形不得落美股域（sec_companyfacts 只认 CIK，A 股全废）
+    {"id": "R_zh_usfund_yields_cn", "q": "宁德时代 毛利率 现金流", "lang": "zh",
+     "domain_not": ["us_fundamentals"], "scenario": "finance"},
+    # 民事实务（劳动/借贷）此前落 chinese_general，flk_law 才是交付源
+    {"id": "R_zh_legal_labor", "q": "劳动合同解除 赔偿 N+1", "lang": "zh",
+     "domain": "legal", "primary": "anysearch", "scenario": "legal"},
+    {"id": "R_zh_legal_lending", "q": "民间借贷 利率 司法保护上限", "lang": "zh",
+     "domain": "legal", "primary": "anysearch", "scenario": "legal"},
+    # 药品说明书此前被 code_search 的「用法」子串抢走（GitHub/MDN 答不了药）
+    {"id": "R_zh_medical_drug_label", "q": "布洛芬 说明书 用法用量", "lang": "zh",
+     "domain": "medical", "primary": "clinicaltrials", "scenario": "medical"},
+    # 综述语境不被模型目录抢（models_dev 答不了综述）
+    {"id": "R_zh_survey_not_modelcard", "q": "大模型 长上下文 综述", "lang": "zh",
+     "domain_not": ["ai_model"], "scenario": "academic"},
+    # 论文写作 howto / 年报模板 howto 不进学术域与行情域
+    {"id": "R_zh_academic_not_howto", "q": "怎么写论文 查重 降重", "lang": "zh",
+     "domain_not": ["academic"], "scenario": "academic"},
+    {"id": "R_zh_stock_not_howto", "q": "年报 模板 怎么写", "lang": "zh",
+     "domain_not": ["stock_query", "us_fundamentals"], "scenario": "finance"},
 
     # ── 媒体/音乐 ──
     {"id": "R_en_media", "q": "Taylor Swift album", "lang": "en",
@@ -449,7 +493,15 @@ ROUTE_MATRIX: list[dict[str, Any]] = [
     {"id": "R_stackoverflow_search", "q": "stackoverflow 编程问题 代码问题", "lang": "zh", "domain": "stackoverflow_search", "primary": "stackoverflow", "scenario": "code"},
     {"id": "R_standards", "q": "国家标准 国标 标准号", "lang": "zh", "domain": "standards", "primary": "std_samr", "scenario": "academic"},
     {"id": "R_tech_deep", "q": "deep dive 架构 实践", "lang": "zh", "domain": "tech_deep", "primary": "arxiv", "scenario": "tech"},
-    {"id": "R_us_fundamentals", "q": "营收 净利润 财务数据 苹果", "lang": "zh", "domain": "us_fundamentals", "primary": "sec_companyfacts", "scenario": "finance"},
+    # 2026-10-25 约定更新：zh 词形财务查询统一走 stock_query（sina/eastmoney
+    # 双地覆盖，与「XX 股价」分流同构）；本域收英文词形与美股语境。代价是
+    # zh 美股财务查询损失 sec 结构化精度，换来 A 股企业不再落只认 CIK 的
+    # sec_companyfacts 全空——两害取其轻，成对改动注释见 config us_fundamentals。
+    # 英文方向的域锁定另见 R_us_fundamentals_en。
+    {"id": "R_us_fundamentals", "q": "营收 净利润 财务数据 苹果", "lang": "zh",
+     "domain": "stock_query", "primary": "sina_quote", "scenario": "finance"},
+    {"id": "R_us_fundamentals_en", "q": "apple annual revenue net income", "lang": "en",
+     "domain": "us_fundamentals", "primary": "sec_companyfacts", "scenario": "finance"},
     {"id": "R_us_legal", "q": "supreme court 判例 precedent", "lang": "en", "domain": "us_legal", "primary": "federal_register", "scenario": "legal"},
     {"id": "R_web_archive", "q": "网页快照 历史网页 wayback", "lang": "zh", "domain": "web_archive", "primary": "wikipedia", "scenario": "general"},
     {"id": "R_web_docs", "q": "mozilla developer fetch 属性", "lang": "en", "domain": "web_docs", "primary": "mdn", "scenario": "code"},
@@ -1131,7 +1183,65 @@ def _summarize(c: Checker) -> dict[str, Any]:
     }
 
 
+def _reexec_with_yaml() -> bool:
+    """缺 PyYAML 时改用带依赖的解释器重入；exec 成功则不返回。
+
+    why：config 在无 yaml 时静默回落内置默认引擎集，route 段整片假红
+    （2026-10-25 实测：同机无 yaml 的解释器跑出 94 FAIL、带 yaml 的全绿）。
+    bin/argo 启动器的 _pick_python 会自动挑解释器，但分享场景里用户会直接
+    `python3 scripts/matrix_search_eval.py`——解释器版本不该卡住人。候选序：
+    ARGO_PYTHON（与启动器同一权威覆盖）→ PATH 上的 python3.14/3.13/3.15/
+    3.12 → python3；每个候选真跑一次 `import yaml` 验证（探测约 100ms，
+    评测不是热路径）。已重入过仍缺（_ARGO_MATRIX_REEXEC 标记）则放弃，
+    避免套娃。
+    """
+    import os
+    import shutil
+    import subprocess
+
+    if os.environ.get("_ARGO_MATRIX_REEXEC") == "1":
+        return False
+    cands = []
+    env_py = os.environ.get("ARGO_PYTHON", "").strip()
+    if env_py:
+        cands.append(env_py)
+    cands += [shutil.which("python3.%d" % m) or "" for m in (14, 13, 15, 12)]
+    cands.append(shutil.which("python3") or "")
+    for cand in cands:
+        if not cand:
+            continue
+        if os.path.realpath(cand) == os.path.realpath(sys.executable):
+            continue  # 当前解释器已证明缺 yaml，跳过
+        try:
+            probe = subprocess.run([cand, "-c", "import yaml"],
+                                   capture_output=True, timeout=30)
+        except Exception:
+            continue
+        if probe.returncode == 0:
+            os.environ["_ARGO_MATRIX_REEXEC"] = "1"
+            print("[matrix] 当前解释器缺 PyYAML，改用 %s 重入" % cand,
+                  file=sys.stderr)
+            os.execv(cand, [cand, sys.argv[0], *sys.argv[1:]])
+    return False
+
+
 def main() -> int:
+    # PyYAML 缺失时 config 会**静默**回落到内置默认引擎集（垂直域引擎全不在），
+    # route 段整片假红（2026-10-25 实测：无 yaml 的解释器跑出 94 FAIL，带 yaml
+    # 重跑 197 全绿——错误根因是解释器不是路由）。先自愈换解释器重入
+    # （3.15/3.14 等版本差异不再卡用户），换无可换才硬失败退出。
+    try:
+        import yaml  # noqa: F401
+    except ImportError as exc:
+        _reexec_with_yaml()
+        print(
+            f"[matrix] PyYAML 不可用（{exc}）且候选解释器（ARGO_PYTHON 与 PATH "
+            "上的 python3.x）均缺：config 将静默降级到内置默认引擎集，route 段"
+            "会整片假红。请 pip install pyyaml，或设 ARGO_PYTHON 指向带依赖的"
+            "解释器。",
+            file=sys.stderr,
+        )
+        return 2
     ap = argparse.ArgumentParser(description="多语言×引擎×场景 矩阵测试")
     ap.add_argument("--offline", action="store_true")
     ap.add_argument("--live", action="store_true")

package/scripts/mcp_transport.py

@@ -22,7 +22,7 @@ except Exception:  # pragma: no cover
 
 # 版本来源：与 package.json / SKILL.md 保持一致（发布时统一升版；
 # tests/test_consistency_gates.py 会四端对账，漂移即红）
-ARGO_MCP_VERSION = "2.9.8"
+ARGO_MCP_VERSION = "2.9.9"
 
 _response_format = "content-length"  # 根据客户端请求自动切换
 

package/scripts/net_proxy.py

@@ -217,6 +217,19 @@ def open_url(req: Any, timeout: float = 10.0):
     return opener.open(req, timeout=timeout)
 
 
+def _verified_tls_context():
+    """显式构造「校验开启」的 TLS 上下文（check_hostname + CERT_REQUIRED）。
+
+    默认 http.client 已用校验上下文；这里显式化，让「TLS 校验不可被静默关掉」
+    成为可测试的不变式（而不是依赖库默认）。
+    """
+    import ssl
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = True
+    ctx.verify_mode = ssl.CERT_REQUIRED
+    return ctx
+
+
 def open_connection(parsed: ParseResult, timeout: float,
                     proxy_url: str | None) -> tuple[HTTPConnection, bool]:
     """按是否走代理构造 http.client 连接。返回 (conn, via_proxy)。
@@ -224,12 +237,26 @@ def open_connection(parsed: ParseResult, timeout: float,
     https 目标 + 代理 → 到代理的 HTTPSConnection + set_tunnel（CONNECT 隧道）；
     http 目标 + 代理 → 到代理的 HTTPConnection，request 须用绝对 URL
     （见 request_selector）。
+
+    直连（无代理）：用「解析即锁定」的连接类（url_safety.Safe*Connection），
+    堵 check_url 与 connect 之间的 DNS 重绑定窗口；HTTPS 显式用校验上下文。
     """
     import http.client
     import urllib.parse
 
     target_port = parsed.port or (443 if parsed.scheme == "https" else 80)
     if not proxy_url:
+        # 直连：解析即锁定 + TLS 校验（详见 safe_conn 与 _verified_tls_context）
+        try:
+            from safe_conn import SafeHTTPConnection, SafeHTTPSConnection
+            if parsed.scheme == "https":
+                return SafeHTTPSConnection(
+                    parsed.hostname, target_port, timeout=timeout,
+                    context=_verified_tls_context()), False
+            return SafeHTTPConnection(parsed.hostname, target_port,
+                                      timeout=timeout), False
+        except ImportError:  # pragma: no cover
+            pass
         cls = (http.client.HTTPSConnection if parsed.scheme == "https"
                else http.client.HTTPConnection)
         return cls(parsed.hostname, target_port, timeout=timeout), False