argo-search 2.9.7 → 2.9.9

package/scripts/ci_drift_gate.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""漂移阈值判定：把夜间「重录 vs 基线」的比较结果变成退出码。
+
+## 为什么单独成文件
+
+判定逻辑原来写在 nightly.yml 的 heredoc 里：语法对错只能在推上去之后知道，
+阈值改松改紧也没人测。抽出来后有两个好处——本地能跑同一套判定，用例能锁住
+「跌多少算跌」这条契约（tests/test_ci_workflows.py）。
+
+## 判什么、为什么只判这两样
+
+- **结果条数**：少 1 条允许（工具源单条抖动很常见），少 2 条以上算漂移；
+- **输出体积**：超过基线 20% 算漂移（体积是 Agent 真金白银付的上下文）。
+
+`not_recorded`（重放时要了一个当时没调过的引擎）**不计入**：录制只保留真正
+被调到的引擎，而重放是瞬时完成，早停时机与真跑不同，这是录制机制的正常边界，
+当成回归报会制造长期噪音。它仍然会打印出来，供人看。
+
+用法：
+    python3 scripts/ci_drift_gate.py --baseline 基线报告.json --current 本次报告.json
+退出码：0 通过；1 有漂移；2 输入缺失/格式不对（这两件事必须分开，混在一起
+会让人以为「红了=质量掉了」）。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+KEPT_SLACK = 1          # 允许少 1 条
+BYTES_GROWTH = 1.2      # 体积上限 = 基线 × 1.2
+
+
+def _load(path: Path) -> dict[str, Any]:
+    doc = json.loads(path.read_text(encoding="utf-8"))
+    # save_baseline 存的是 {"_meta":…, "report":{…}}；evaluate_all 直接给报告本体
+    return doc.get("report", doc)
+
+
+def violations(base: dict[str, Any], cur: dict[str, Any]) -> list[str]:
+    by_id = {c.get("id"): c for c in (base.get("cases") or [])}
+    cur_ids = {c.get("id") for c in (cur.get("cases") or [])}
+    out: list[str] = []
+    for case in cur.get("cases") or []:
+        old = by_id.get(case.get("id"))
+        if not old:
+            continue  # 新增的用例没有基线，不算漂移
+        cid = case.get("id")
+        kept, old_kept = case.get("kept", 0), old.get("kept", 0)
+        if kept < old_kept - KEPT_SLACK:
+            out.append(f"{cid}: 结果 {kept} 条，基线 {old_kept} 条")
+        old_bytes = old.get("bytes", 0)
+        if old_bytes and case.get("bytes", 0) > old_bytes * BYTES_GROWTH:
+            out.append(
+                f"{cid}: 输出 {case.get('bytes')}B，超过基线 {old_bytes}B×{BYTES_GROWTH}")
+    # 基线里有、本次没有：不是「通过」，是这条根本没被录到（查询集被改、
+    # 或录制整条失败）。2026-10-22 本地实跑踩过：只剩 1 条时判定照样退 0。
+    for cid in by_id:
+        if cid and cid not in cur_ids:
+            out.append(f"{cid}: 本次报告里没有这条（查询集被改了，还是录制失败？）")
+    return out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="夜间漂移阈值判定")
+    ap.add_argument("--baseline", required=True)
+    ap.add_argument("--current", required=True)
+    args = ap.parse_args()
+
+    try:
+        base = _load(Path(args.baseline))
+        cur = _load(Path(args.current))
+    except (OSError, json.JSONDecodeError) as e:
+        print(f"读不到报告：{type(e).__name__}: {e}", file=sys.stderr)
+        return 2
+
+    bad = violations(base, cur)
+    if bad:
+        print("\n".join(bad), file=sys.stderr)
+        return 1
+    print(f"通过：{len(cur.get('cases') or [])} 条，漏录 "
+          f"{cur.get('total_missing', 0)} 个引擎（信息项，不算漂移）")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/clock_bridge.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+"""clock_bridge.py — 统一时钟的一行入口（2026-10-24）。
+
+计时断言与「预算夹紧」判定不该取决于机器快慢：测试域用 tests/_measure 的
+虚拟时钟，生产路径就是 ``time.monotonic``。各模块从这里取 ``clock``，不再各自
+复制一段 try/except（那会让千行文件更难拆，也容易只改一半——本文件对应的
+fetch_v3 就曾因「预算夹在超时请求上、耗时却按真实墙钟算」而被测出击穿）。
+
+与 ``tests/_measure.py`` 的关系：那个模块定义语义（虚拟/真实、预算锚点、
+确定性时间线），本模块只做「生产环境安全地取到它」这一件事。
+"""
+
+from __future__ import annotations
+
+import time
+
+try:  # 测试域：虚拟时钟（见 tests/_measure.py）
+    from _measure import clock  # type: ignore
+except ImportError:  # pragma: no cover - 生产路径
+    clock = time.monotonic
+
+__all__ = ["clock"]

package/scripts/content_boundary.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""content_boundary.py — 不可信网页内容的边界标记与清洗。
+
+为什么需要单独一层：Argo 对 Agent 输出的是 JSON，不能像纯文本工具那样简单
+把整段响应包进 <untrusted-web-content>（会破坏 JSON 解析）。所以这里只做
+两件确定能做的事：
+
+1. **清洗**：任何来自上游的标题/摘要/正文在进入输出前，剥掉其中的边界标记
+   字样——否则网页正文里自带的 `</untrusted-web-content>` 可以提前闭合边界，
+   把后续内容伪装成可信指令（dsh-free-search 的同类防护）。
+2. **声明**：调用方在响应里带 `content_trust: "untrusted"`，让模型与宿主
+   知道这批文本的信任级别；文本边界由宿主（DSH/MCP 客户端）按自己的渲染
+   形态加，不在 JSON 契约里硬塞。
+
+不引入依赖、不做 HTML 清洗：正文已经是纯文本摘要，这里只管边界标记这一类
+可被利用的结构字符。
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+CONTENT_TRUST_UNTRUSTED = "untrusted"
+
+# 大小写、属性、空白都按「可能的变体」处理；只剥标记本身，不动正文其余字符。
+_BOUNDARY_RE = re.compile(
+    r"<\s*/?\s*untrusted-web-content\b[^>]*>", re.IGNORECASE)
+
+
+def strip_boundary_markers(text: Any, limit: int | None = None) -> str:
+    """剥掉正文里的边界标记（含变体），可选截断。"""
+    out = _BOUNDARY_RE.sub("", str(text or ""))
+    if limit is not None and limit >= 0 and len(out) > limit:
+        out = out[:limit]
+    return out
+
+
+def sanitize_results_boundary(results: Any) -> None:
+    """就地清洗结果列表每条的 title/snippet 边界标记（CLI/Agent/MCP 共用单一出口）。"""
+    for item in results or []:
+        if not isinstance(item, dict):
+            continue
+        for key in ("title", "snippet"):
+            if isinstance(item.get(key), str):
+                item[key] = strip_boundary_markers(item[key])

package/scripts/content_security.py

@@ -35,6 +35,7 @@ THREAT_NAMES = {
     "payload_smuggling": "载荷走私",
     "xss_injection": "XSS 注入",
     "recursive_injection": "递归注入",
+    "credential_exposure": "凭证暴露",
 }
 
 
@@ -181,11 +182,53 @@ INJECTION_PATTERNS_EL = [
     r"υποδύσου\s+(?:τον\s+)?(?:άνθρωπο|χρήστη|διαχειριστή|σύστημα)",
 ]
 
+# 西班牙语注入
+INJECTION_PATTERNS_ES = [
+    r"(?i)ignora\s+(?:todas\s+)?(?:las\s+)?(?:instrucciones|órdenes|ordenes|reglas|indicaciones)\s+(?:anteriores|previas)",
+    r"(?i)olvida\s+(?:todas\s+)?(?:las\s+)?(?:instrucciones|órdenes|reglas)",
+    r"(?i)(?:muéstrame|muestrame|enséñame|ensename|dime|revela|imprime|exhibe)\s+(?:tu\s+)?(?:prompt\s+del\s+sistema|prompt|instrucciones|configuración|configuracion)",
+    r"(?i)ya\s+no\s+(?:eres|es)\s+(?:un\s+)?(?:asistente|bot|ia|agente)",
+    r"(?i)(?:eres|ahora\s+eres)\s+(?:una\s+)?(?:persona|humano|usuario|administrador|sistema)",
+    r"(?i)(?:actúa|actua|comporta|finge|simula)\s+(?:como|de\s+que)\s+(?:una\s+)?(?:persona|humano|usuario|administrador|sistema)",
+    r"(?i)(?:elude|evita|ignora)\s+(?:todas\s+)?(?:las\s+)?(?:restricciones|limitaciones|protecciones|reglas)",
+    r"(?i)te\s+llamas\s+(?:ChatGPT|Claude|GPT|asistente\s+de\s+ia)",
+]
+
+# 法语注入
+INJECTION_PATTERNS_FR = [
+    r"(?i)ignore\s+(?:toutes\s+)?(?:les\s+)?(?:instructions|consignes|règles|regles|ordres)\s+(?:précédentes|precedentes)",
+    r"(?i)oublie\s+(?:toutes\s+)?(?:les\s+)?(?:instructions|consignes|règles|regles)",
+    r"(?i)(?:montre|affiche|dis|révèle|revel|imprime)\s+(?:ton|votre|ta)?\s*(?:prompt\s+système|prompt|instructions|configuration)",
+    r"(?i)tu\s+n'es\s+plus\s+(?:un\s+)?(?:assistant|bot|ia|agent)",
+    r"(?i)tu\s+es\s+(?:désormais|desormais\s+)?(?:une\s+)?(?:personne|humain|utilisateur|administrateur|système|systeme)",
+    r"(?i)(?:fais\s+semblant|joue|agis)\s+(?:comme|en\s+tant\s+que)\s+(?:une\s+)?(?:personne|humain|utilisateur|administrateur|système|systeme)",
+    r"(?i)(?:contourne|évite|evite)\s+(?:toutes\s+)?(?:les\s+)?(?:restrictions|limitations|protections|règles|regles)",
+    r"(?i)ton\s+nom\s+est\s+(?:ChatGPT|Claude|GPT|assistant\s+ia)",
+]
+
+# 德语注入
+INJECTION_PATTERNS_DE = [
+    r"(?i)ignoriere\s+(?:alle\s+)?(?:vorherigen\s+)?(?:Anweisungen|Regeln|Instruktionen|Befehle)",
+    r"(?i)vergiss\s+(?:alle\s+)?(?:vorherigen\s+)?(?:Anweisungen|Regeln|Instruktionen)",
+    r"(?i)(?:zeig|zeige|erzähl|erzahl|gib\s+preis|offenbare|drucke)\s+(?:mir\s+)?(?:deinen\s+)?(?:System-?Prompt|Systemprompt|Anweisungen|Einstellungen)",
+    r"(?i)du\s+bist\s+(?:nicht\s+mehr|kein\s+mehr)\s+(?:ein\s+)?(?:Assistent|Bot|KI|Agent)",
+    r"(?i)du\s+bist\s+(?:nun\s+)?(?:ein\s+)?(?:Mensch|Benutzer|Administrator|System)",
+    r"(?i)(?:tu|gib\s+vor|verhalte\s+dich)\s+(?:als|wie)\s+(?:ein\s+)?(?:Mensch|Benutzer|Administrator|System)",
+    r"(?i)(?:umgehe|ignoriere)\s+(?:alle\s+)?(?:Einschränkungen|Einschrankungen|Beschränkungen|Beschrankungen|Schutzmaßnahmen|Schutzmassnahmen|Regeln)",
+    r"(?i)dein\s+Name\s+ist\s+(?:ChatGPT|Claude|GPT|KI-Assistent)",
+]
+
+# 拉丁语系专用表（不含英语通用，避免 en/latin 两条路重复匹配）
+INJECTION_PATTERNS_LATIN = (
+    INJECTION_PATTERNS_ES + INJECTION_PATTERNS_FR + INJECTION_PATTERNS_DE
+)
+
 # 按语系分类的注入模式表（lang_detect 主语言标签 → 模式列表）
 LANG_INJECTION_PATTERNS: dict[str, list[str]] = {
     "zh": INJECTION_PATTERNS_ZH,
     "ja": INJECTION_PATTERNS_JA,
     "ko": INJECTION_PATTERNS_KO,
+    "latin": INJECTION_PATTERNS_LATIN,
     "cyrillic": INJECTION_PATTERNS_RU,
     "arabic": INJECTION_PATTERNS_AR,
     "hebrew": INJECTION_PATTERNS_HE,
@@ -259,6 +302,21 @@ XSS_PATTERNS = [
     r"(?i)window\.location",
 ]
 
+# 凭证形态：出现在抓取正文里的密钥形状串——可能是页面自身的示例，也可能是
+# 被注入/外泄的凭证。标 credential_exposure（权重 0.5，单独命中不触发隔离，
+# 但进 threat_types 供上层判断）。
+SECRET_FORM_PATTERNS = [
+    r"sk-[A-Za-z0-9_\-]{16,}",
+    r"sk-ant-[A-Za-z0-9_\-]{16,}",
+    r"ghp_[A-Za-z0-9]{20,}",
+    r"github_pat_[A-Za-z0-9_]{20,}",
+    r"AKIA[0-9A-Z]{16}",
+    r"ASIA[0-9A-Z]{16}",
+    r"xox[baprs]-[A-Za-z0-9\-]{10,}",
+    r"AIza[0-9A-Za-z_\-]{35}",
+    r"-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----",
+]
+
 # 检测但不过度脱敏的文件路径类模式
 _NO_REDACT_PATTERNS: frozenset = frozenset({
     r"(?i)/etc/passwd",
@@ -317,6 +375,7 @@ WEIGHTS = {
     "payload_smuggling": 0.9,
     "xss_injection": 0.9,
     "recursive_injection": 1.0,
+    "credential_exposure": 0.5,
 }
 
 
@@ -348,6 +407,7 @@ class ContentScrubber:
         threats.extend(self._detect_exfiltration(normalized))
         threats.extend(self._detect_impersonation(normalized))
         threats.extend(self._detect_xss(normalized))
+        threats.extend(self._detect_secret_forms(normalized))
 
         # 阶段 3：语义意图分析
         threats.extend(self._semantic_analysis(normalized))
@@ -467,9 +527,10 @@ class ContentScrubber:
         if lang == "zh" or lang == "mixed":
             patterns.extend(INJECTION_PATTERNS_ZH)
         for key, plist in LANG_INJECTION_PATTERNS.items():
-            if lang == key:
+            # en 与 latin 共享拉丁模式：ES/FR/DE 注入多为 ASCII 或带扩展字符，
+            # 纯 ASCII 时 lang_detect 判 en，漏掉它们等于给拉丁注入留门
+            if lang == key or (lang == "en" and key == "latin"):
                 patterns.extend(plist)
-        # en/latin 落到英文通用（已有）
         return tuple(patterns)
 
     def _detect_injections(self, text: str, lang: str = "other") -> list[ThreatDetection]:
@@ -485,6 +546,11 @@ class ContentScrubber:
     def _detect_xss(self, text: str) -> list[ThreatDetection]:
         return self._match_patterns(text, XSS_PATTERNS, "xss_injection", 0.9)
 
+    def _detect_secret_forms(self, text: str) -> list[ThreatDetection]:
+        """凭证形态检测（输出侧防护）：正文里的密钥形状串。"""
+        return self._match_patterns(text, SECRET_FORM_PATTERNS,
+                                    "credential_exposure", 0.7)
+
     @staticmethod
     def _match_patterns(text: str, patterns: list[str],
                         threat_type: str, confidence: float) -> list[ThreatDetection]:
@@ -629,10 +695,51 @@ def scrub_content(content: str) -> ScrubResult:
     return get_scrubber().scrub(content)
 
 
+# ── 风险门禁（v2.9.8）──────────────────────────────────────────────────────
+#
+# 此前 scrub_to_dict 只回传元数据（risk_score 等），**清洗后的正文被丢弃**——
+# 安全引擎只「评分」不「门禁」，高风险内容照样进证据流水线与 Agent 上下文。
+# 门禁把「评分」变成「动作」：risk_score ≥ 阈值时，fetch 层用清洗后正文替换
+# 原始正文并标 content_quarantined，使被注入污染的正文不进证据分、不进上下文。
+#
+# 开关与阈值都可配（见 references/usage.md 功能开关总表）：
+#   ARGO_CONTENT_RISK_GATE        默认开；关掉 = 放行高风险内容，仅应急用
+#   ARGO_CONTENT_RISK_THRESHOLD   默认 0.5，与历史 content_clean 阈值一致
+RISK_GATE_THRESHOLD = 0.5
+
+
+def risk_gate_enabled() -> bool:
+    """内容风险门禁总开关（默认开）。"""
+    try:
+        from engine_env import env_flag
+        return env_flag("ARGO_CONTENT_RISK_GATE", default=True)
+    except Exception:
+        return True
+
+
+def risk_gate_threshold() -> float:
+    """门禁阈值：risk_score ≥ 此值即隔离。默认 0.5，越界回落默认。"""
+    try:
+        from engine_env import get_env
+        val = float(str(get_env(["ARGO_CONTENT_RISK_THRESHOLD"])).strip())
+    except (TypeError, ValueError):
+        return RISK_GATE_THRESHOLD
+    if val <= 0.0 or val > 1.0:
+        return RISK_GATE_THRESHOLD
+    return val
+
+
 def scrub_to_dict(content: str) -> dict:
-    """清洗入口（dict 形态，供 fetch 层直接合并）。"""
+    """清洗入口（dict 形态，供 fetch 层直接合并）。
+
+    除历史字段外，回传门禁三件套：gate_applied（门禁是否生效）、
+    quarantined（是否隔离）、cleaned_content（仅隔离时回传，供替换原始正文）。
+    """
     r = scrub_content(content)
-    return {
+    gate_on = risk_gate_enabled()
+    threshold = risk_gate_threshold()
+    quarantined = gate_on and r.risk_score >= threshold
+    out = {
         "content_clean": r.clean,
         "risk_score": r.risk_score,
         "threat_count": len(r.threats),
@@ -640,7 +747,15 @@ def scrub_to_dict(content: str) -> dict:
         "redactions": r.redactions,
         "encoding_layers_stripped": r.encoding_layers_stripped,
         "content_lang": r.content_lang,
+        "gate_applied": gate_on,
+        "gate_threshold": threshold,
+        "quarantined": quarantined,
     }
+    # 只有被隔离时才回传清洗后正文：它替换原始正文，是门禁的「动作」部分；
+    # 未命中时多带一份正文副本只是白占内存。
+    if quarantined:
+        out["cleaned_content"] = r.content
+    return out
 
 
 # ── CLI ────────────────────────────────────────────────────────────────────

package/scripts/content_signals.py

@@ -492,9 +492,16 @@ def score_clickbait(title: str) -> dict:
         score += 0.08
         hits.append("year_prefix")
     # 利益承诺：「看完…你就会」「建议收藏」「一篇搞懂」
-    if re.search(r"(看完|建议收藏|建议收藏|一篇(?:讲|说|搞懂)|全解析|必看|建议收藏)", t):
+    if re.search(r"(看完|建议收藏|一篇(?:讲|说|搞懂)|全解析|必看)", t):
         score += 0.10
         hits.append("benefit_promise")
+    # 虚假实测 / 承诺尾钩
+    if re.search(r"自费\s*\d+\s*元?实测", t):
+        score += 0.25
+        hits.append("fake_testimony")
+    if re.search(r"看完.*(?:你就懂了|你就会)", t):
+        score += 0.15
+        hits.append("clickbait_promise")
 
     # 标点：仅在已有命中时作**放大器**（PACLIC 的误杀教训）
     if score > 0:
@@ -595,13 +602,27 @@ def score_template_repetition(content: str) -> dict:
     这里是接入点，且标定集能立刻给出 before/after。
     """
     text = (content or "").strip()
-    if len(text) < 120:
+    # ── 序数连接词与流水线套话检测（对抗现代批量模板/AI农场）──
+    connectors = ("首先", "其次", "然后", "接下来", "最后", "综上所述")
+    hit_conn = sum(1 for w in connectors if w in text)
+    ai_phrases = ("业内人士表示", "专家分析", "消费者认为", "数据显示", "有望成为")
+    hit_ai = sum(1 for w in ai_phrases if w in text)
+    conn_boost = 0.0
+    if hit_conn >= 4:
+        conn_boost = 0.85
+    elif hit_conn >= 3 and hit_ai >= 1:
+        conn_boost = 0.80
+    elif hit_ai >= 3:
+        conn_boost = 0.78
+
+    if len(text) < 120 and conn_boost == 0.0:
         return {"score": 0.0, "templates": 0, "sentences": 0, "repetition": 0.0}
     # 分句：中英标点 + 换行
     sents = [s.strip() for s in re.split(r"[。！？!?；;\n]+", text) if len(s.strip()) >= 6]
     if len(sents) < 4:
-        return {"score": 0.0, "templates": len(sents), "sentences": len(sents),
-                "repetition": 0.0}
+        base_rep = conn_boost
+        return {"score": round(base_rep, 3), "templates": len(sents), "sentences": len(sents),
+                "repetition": round(base_rep, 3)}
     sigs: list[str] = []
     for s in sents:
         head = s[:2]
@@ -610,7 +631,7 @@ def score_template_repetition(content: str) -> dict:
         bucket = "S" if len(s) < 25 else ("M" if len(s) < 60 else "L")
         sigs.append(f"{head}|{tail}|{bucket}")
     uniq = len(set(sigs))
-    repetition = 1.0 - uniq / len(sigs)
+    repetition = max(1.0 - uniq / len(sigs), conn_boost)
     return {
         "score": round(min(repetition, 1.0), 3),
         "templates": uniq,