argo-search 1.0.1 → 2.9.7

package/scripts/evidence_tier.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""evidence_tier.py — 证据分层系统
+
+四级证据分层（A/B/C/D），用于量化内容来源的可信度。
+A 级：官方当前公开来源或法律权威文件
+B 级：有明确日期的知名第三方报告或公开媒体
+C 级：品牌自述但缺乏运营细节
+D 级：未验证或市场特定边界项
+
+设计原则：
+  - 纯规则、零依赖、微秒级
+  - 与 content_signals.classify_source 互补：后者判域名类型，本模块判证据等级
+  - 输出可直接用于内容质量评分和来源账本
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import urlparse
+
+
+# ── 证据等级 ────────────────────────────────────────────────────────
+
+@dataclass(frozen=True)
+class EvidenceTier:
+    """证据等级常量"""
+    A = "official"      # 官方来源
+    B = "third_party"   # 知名第三方
+    C = "self_claim"    # 品牌自述
+    D = "unverified"    # 未验证
+
+
+# 等级权重（用于加权评分）
+TIER_WEIGHTS = {
+    EvidenceTier.A: 1.0,
+    EvidenceTier.B: 0.7,
+    EvidenceTier.C: 0.3,
+    EvidenceTier.D: 0.0,
+}
+
+# 等级排序（用于比较）
+TIER_RANK = {
+    EvidenceTier.A: 4,
+    EvidenceTier.B: 3,
+    EvidenceTier.C: 2,
+    EvidenceTier.D: 1,
+}
+
+
+# ── 域名 → 证据等级映射 ────────────────────────────────────────────
+
+# A 级：官方来源
+_A_DOMAINS = frozenset([
+    # 政府
+    "gov.cn", "gov.uk", "gov", "gob.mx", "go.jp", "go.kr",
+    # 教育
+    "edu", "edu.cn", "ac.uk", "ac.jp", "ac.kr",
+    # 官方文档
+    "docs.microsoft.com", "developer.apple.com", "developers.google.com",
+    "docs.python.org", "readthedocs.io",
+    # 官方标准
+    "w3.org", "ietf.org", "iso.org", "ieee.org",
+])
+
+# B 级：知名第三方
+_B_DOMAINS = frozenset([
+    # 新闻媒体
+    "nytimes.com", "bbc.com", "bbc.co.uk", "reuters.com", "theguardian.com",
+    "washingtonpost.com", "bloomberg.com", "apnews.com", "aljazeera.com",
+    "cnbc.com", "ft.com", "economist.com", "techcrunch.com", "theverge.com",
+    "arstechnica.com", "wired.com", "nature.com", "science.org",
+    # 中文媒体
+    "xinhuanet.com", "people.com.cn", "chinanews.com.cn", "cctv.com",
+    "caixin.com", "163.com", "sohu.com", "sina.com.cn", "qq.com",
+    "36kr.com", "huxiu.com", "tmtpost.com", "leiphone.com",
+    # 研究机构
+    "mckinsey.com", "bcg.com", "bain.com", "deloitte.com", "pwc.com",
+    "ey.com", "kpmg.com", "accenture.com", "gartner.com", "forrester.com",
+    "idc.com", "statista.com", "pewresearch.org", "brookings.edu",
+    # 开源社区
+    "github.com", "gitlab.com", "stackoverflow.com", "stackexchange.com",
+    "medium.com", "substack.com", "wordpress.com",
+    # 百科
+    "wikipedia.org", "baike.baidu.com", "zhihu.com",
+])
+
+# C 级：品牌自述（需要进一步判断是否有运营细节）
+_C_PATTERNS = [
+    r"^blog\.",           # 企业博客
+    r"^news\.",           # 企业新闻
+    r"^press\.",          # 企业公关
+    r"^about\.",          # 企业介绍
+    r"^company\.",        # 企业信息
+]
+
+
+@dataclass
+class EvidenceAssessment:
+    """证据评估结果"""
+    tier: str                    # 证据等级 A/B/C/D
+    tier_weight: float           # 等级权重
+    source_type: str             # 来源类型
+    is_official: bool            # 是否官方
+    has_date: bool = False       # 是否有明确日期
+    has_author: bool = False     # 是否有明确作者
+    has_citation: bool = False   # 是否有引用/参考
+    notes: list[str] = field(default_factory=list)  # 评估说明
+
+
+def assess_evidence_tier(
+    url: str,
+    source_type: str = "",
+    is_official: bool = False,
+    has_date: bool = False,
+    has_author: bool = False,
+    has_citation: bool = False,
+    content: str = "",
+) -> EvidenceAssessment:
+    """评估内容的证据等级。
+
+    参数:
+        url: 内容 URL
+        source_type: 来源类型（来自 classify_source）
+        is_official: 是否官方来源
+        has_date: 是否有明确发布日期
+        has_author: 是否有明确作者
+        has_citation: 是否有引用/参考来源
+        content: 内容文本（用于进一步判断）
+
+    返回:
+        EvidenceAssessment 对象
+    """
+    host = _extract_host(url)
+    notes = []
+
+    # 1. 域名匹配
+    if _is_a_tier_domain(host):
+        tier = EvidenceTier.A
+        notes.append(f"官方域名: {host}")
+    elif _is_b_tier_domain(host):
+        tier = EvidenceTier.B
+        notes.append(f"知名第三方域名: {host}")
+    elif _is_c_tier_pattern(host):
+        tier = EvidenceTier.C
+        notes.append(f"企业自述域名: {host}")
+    else:
+        tier = EvidenceTier.D
+        notes.append(f"未知域名: {host}")
+
+    # 2. 内容信号修正
+    # 有明确日期 + 有作者 + 有引用 → 升级
+    if tier == EvidenceTier.C and has_date and has_author and has_citation:
+        tier = EvidenceTier.B
+        notes.append("企业自述但有完整证据链（日期+作者+引用），升级为 B 级")
+
+    # 无日期 + 无作者 → 降级
+    if tier == EvidenceTier.B and not has_date and not has_author:
+        tier = EvidenceTier.C
+        notes.append("第三方来源但缺乏日期和作者，降级为 C 级")
+
+    # 3. 内容质量信号
+    if content:
+        content_signals = _assess_content_signals(content)
+        if content_signals["has_data"] and content_signals["has_citation"]:
+            if tier == EvidenceTier.C:
+                tier = EvidenceTier.B
+                notes.append("内容含数据和引用，升级为 B 级")
+        elif content_signals["is_thin"]:
+            if tier == EvidenceTier.B:
+                tier = EvidenceTier.C
+                notes.append("内容单薄，降级为 C 级")
+
+    return EvidenceAssessment(
+        tier=tier,
+        tier_weight=TIER_WEIGHTS[tier],
+        source_type=source_type,
+        is_official=is_official,
+        has_date=has_date,
+        has_author=has_author,
+        has_citation=has_citation,
+        notes=notes,
+    )
+
+
+def _extract_host(url: str) -> str:
+    """提取主机名"""
+    if not url:
+        return ""
+    try:
+        host = urlparse(url).netloc.lower()
+        if "@" in host:
+            host = host.rsplit("@", 1)[1]
+        if ":" in host:
+            host = host.split(":", 1)[0]
+        return host
+    except Exception:
+        return ""
+
+
+def _is_a_tier_domain(host: str) -> bool:
+    """判断是否 A 级域名"""
+    if not host:
+        return False
+    # 精确匹配
+    if host in _A_DOMAINS:
+        return True
+    # 后缀匹配
+    for domain in _A_DOMAINS:
+        if host.endswith("." + domain):
+            return True
+    # 特殊后缀
+    if host.endswith(".gov") or host.endswith(".edu") or host.endswith(".ac.uk"):
+        return True
+    return False
+
+
+def _is_b_tier_domain(host: str) -> bool:
+    """判断是否 B 级域名"""
+    if not host:
+        return False
+    if host in _B_DOMAINS:
+        return True
+    # 支持子域名匹配（如 www.reuters.com 匹配 reuters.com）
+    for domain in _B_DOMAINS:
+        if host.endswith("." + domain):
+            return True
+    return False
+
+
+def _is_c_tier_pattern(host: str) -> bool:
+    """判断是否 C 级模式（企业自述）"""
+    if not host:
+        return False
+    for pattern in _C_PATTERNS:
+        if re.search(pattern, host):
+            return True
+    return False
+
+
+def _assess_content_signals(content: str) -> dict:
+    """评估内容信号"""
+    if not content:
+        return {"has_data": False, "has_citation": False, "is_thin": True}
+
+    # 是否有数据（数字、百分比、日期）
+    has_data = bool(re.search(r"\d+[\d,\.]*[%％]?", content))
+    # 是否有引用（URL、参考文献标记）
+    has_citation = bool(re.search(r"(https?://|参考文献|references|资料来源)", content, re.IGNORECASE))
+    # 是否单薄（字数少、句子少）
+    word_count = len(content)
+    # 计算句子数（按标点符号分割）
+    sentence_count = len(re.findall(r'[.!?。！？]', content))
+    # 单薄判定：字数少于 200 或句子数少于 3
+    is_thin = word_count < 200 or sentence_count < 3
+
+    return {
+        "has_data": has_data,
+        "has_citation": has_citation,
+        "is_thin": is_thin,
+    }
+
+
+def compute_weighted_score(assessments: list[EvidenceAssessment]) -> dict:
+    """计算加权证据评分
+
+    参数:
+        assessments: 证据评估结果列表
+
+    返回:
+        包含加权平均分、等级分布、总体评级的字典
+    """
+    if not assessments:
+        return {
+            "weighted_score": 0.0,
+            "tier_distribution": {},
+            "overall_tier": EvidenceTier.D,
+            "assessment_count": 0,
+        }
+
+    total_weight = sum(a.tier_weight for a in assessments)
+    weighted_score = total_weight / len(assessments)
+
+    # 等级分布
+    tier_dist = {}
+    for a in assessments:
+        tier_dist[a.tier] = tier_dist.get(a.tier, 0) + 1
+
+    # 总体评级：取最低等级（短板效应）
+    min_tier = min(assessments, key=lambda a: TIER_RANK[a.tier]).tier
+
+    return {
+        "weighted_score": round(weighted_score, 3),
+        "tier_distribution": tier_dist,
+        "overall_tier": min_tier,
+        "assessment_count": len(assessments),
+    }

package/scripts/except_sets.py

@@ -0,0 +1,25 @@
+"""except 收窄的具名词汇表——收窄从这里的命名集合里选，不许在调用点现编。
+
+把 20+ 处裸 `except Exception` 逐处收窄时产出过两类事故：元组里引用了
+未导入的名字（F821，异常发生时才求值元组 → NameError）；收窄过深
+（quota 侧信道放进 RuntimeError，直接打断搜索主流程）。本模块把
+「允许收窄成什么」收口成具名集合 + 一条判定规则：ruff F821 负责抓
+「名字写错」，这里的规则负责抓「语义选错」。
+
+判定规则——选哪种看 **try 块失败的代价**，不看它可能抛什么：
+
+- 侧信道（失败只影响观测/记账/加速提示，不得影响主流程）：
+  保持 `except Exception` 不收窄，调用点加一行注释说明为什么。
+- IO_BENIGN：文件/网络系统调用，失败语义是「这次没读到/没写成」。
+- SHAPE_BENIGN：数据形状不符，失败语义是「这份数据不可用」。
+- OPT_IMPORT：可选模块缺失，走降级路径（`except ImportError` 直接写即可，
+  本集合只在与其他集合拼接时使用）。
+
+集合之间可以拼接（如 `IO_BENIGN + SHAPE_BENIGN`）。要收窄的异常不在任何
+集合里时，先把失败语义想清楚再改这里，不要在调用点现编一个新元组。
+"""
+
+IO_BENIGN: tuple[type[Exception], ...] = (OSError,)
+SHAPE_BENIGN: tuple[type[Exception], ...] = (
+    AttributeError, IndexError, KeyError, TypeError, ValueError)
+OPT_IMPORT: tuple[type[Exception], ...] = (ImportError,)

package/scripts/extract.py

@@ -1,30 +1,56 @@
 #!/usr/bin/env python3
-"""extract.py — 结构化数据提取"""
+"""extract.py — 结构化数据提取（抓取走 fetch_v3 降级链）"""
 import json, re, sys
 from html.parser import HTMLParser
-from fetch import fetch_page
+from cli_io import dumps, dumps_pretty
+# fetch_v3：UA 轮换 + TLS 指纹 + Wayback/浏览器降级，反爬站可抓。
+# 单页场景保留浏览器降级（use_browser_fallback=True 默认）。
+from fetch_v3 import fetch_v3 as _fetch3
+
+
+def _extract_fetch(url: str, max_chars: int, timeout: int, raw: bool = True) -> dict:
+    """兼容旧 fetch_page 签名：返回 {success, html, content, url, error}。
+
+    need_html=raw：结构化提取（表格 / Meta / JSON-LD）全部依赖原始 HTML，
+    而 fetch_v3 默认会把 html 字段剥掉。此前这里没传，于是 `argo extract`
+    恒拿不到 HTML、tables/metadata/jsonld 永远是空的——参数叫 raw 却只影响
+    出参、不影响取数，正是「开关看着接上了、其实没接」的形态。
+    另：need_html=True 时内容协商自动停用，该路径不会拿到 Markdown。
+    """
+    r = _fetch3(url, max_chars=max_chars, timeout=float(timeout),
+                need_html=raw)
+    out = {"url": r["url"], "content": r.get("content", ""),
+           "success": r["success"], "error": r.get("error", "")}
+    if raw:
+        out["html"] = r.get("html", "")
+    return out
 
 class TableExtractor(HTMLParser):
     def __init__(self):
         super().__init__()
         self.tables = []
-        self._in_table = False
+        self._table_depth = 0
         self._rows = []
         self._row = []
         self._cell = []
         self._in_cell = False
     def handle_starttag(self, tag, attrs):
-        if tag == 'table': self._in_table = True; self._rows = []
-        elif tag in ('td','th') and self._in_table: self._in_cell = True; self._cell = []
-        elif tag == 'tr' and self._in_table: self._row = []
+        if tag == 'table':
+            self._table_depth += 1
+            if self._table_depth == 1:
+                self._rows = []
+        elif self._table_depth == 1 and tag in ('td','th'):
+            self._in_cell = True; self._cell = []
+        elif self._table_depth == 1 and tag == 'tr':
+            self._row = []
     def handle_endtag(self, tag):
         if tag in ('td','th') and self._in_cell:
             self._in_cell = False; self._row.append(''.join(self._cell).strip())
-        elif tag == 'tr' and self._in_table and self._row:
+        elif tag == 'tr' and self._table_depth == 1 and self._row:
             self._rows.append(self._row)
-        elif tag == 'table' and self._in_table:
-            self._in_table = False
-            if self._rows:
+        elif tag == 'table' and self._table_depth:
+            self._table_depth -= 1
+            if self._table_depth == 0 and self._rows:
                 headers = self._rows[0]
                 table = [{headers[i]: row[i] if i < len(row) else '' for i in range(len(headers))} for row in self._rows[1:]]
                 self.tables.append(table)
@@ -50,20 +76,33 @@ def extract_jsonld(html):
     results = []
     for m in re.finditer(r'<script[^>]*type=["\']application/ld\+json["\'][^>]*>(.*?)</script>', html, re.S|re.I):
         try: results.append(json.loads(m.group(1)))
-        except: pass
+        except Exception: pass  # 非 JSON 的 ld+json 块跳过；裸 except 会连 Ctrl-C 一起吞
     return results
 
 if __name__ == '__main__':
     import argparse
     p = argparse.ArgumentParser()
-    p.add_argument('--url', required=True)
+    # 位置参数与 --url 等价：bin/argo 的 usage 写的是 `argo extract "url"`，
+    # 而入口原先只认 --url —— 照文档敲直接报「--url required」（2026-09-15
+    # 实测）。保留 --url 兼容既有调用，两者都接受。
+    p.add_argument('target', nargs='?', metavar='URL')
+    p.add_argument('--url')
     p.add_argument('--mode', default='all', choices=['tables','metadata','jsonld','all'])
+    # 同 crawl：bin/argo 的 usage 承诺 Common flags「--json」，此前 parser 里
+    # 没有它，照文档传参报 unrecognized arguments。默认 3000 字符截断预览，
+    # --json 输出完整可解析 JSON。
+    p.add_argument('--json', action='store_true',
+                   help='输出完整 JSON（默认为 3000 字符截断预览）')
     args = p.parse_args()
-    result = fetch_page(args.url, 50000)
-    if not result['success']: print(json.dumps({'error': result.get('error')})); sys.exit(1)
-    html = result['content']
+    url = args.url or args.target
+    if not url:
+        p.error('需要 URL：argo extract <url>，或 --url <url>')
+    result = _extract_fetch(url, 50000, 15)
+    if not result['success']: print(dumps({'error': result.get('error')})); sys.exit(1)
+    html = result.get('html') or result.get('content') or ''
     output = {}
     if args.mode in ('tables','all'): output['tables'] = extract_tables(html)
     if args.mode in ('metadata','all'): output['metadata'] = extract_metadata(html)
     if args.mode in ('jsonld','all'): output['jsonld'] = extract_jsonld(html)
-    print(json.dumps(output, ensure_ascii=False, indent=2)[:3000])
+    out = dumps(output)
+    print(out if args.json else out[:3000])

package/scripts/fact_align.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+fact_align.py — 关键事实交叉标记（P0-004）
+
+第一性原理：
+  多源检索的价值不止「更多结果」，而是「可交叉验证的事实」。
+  从 title+snippet 抽取结构化事实（版本/百分比/金额/日期/法规号），
+  按 (type, value) 聚合：
+    - 同 type 不同 value → 冲突（fact_conflicts）：提示 Agent 谨慎
+    - 同 value ≥2 域名   → 印证（fact_corroborated）：提升可信度
+
+MECE 事实类型（互不相干、可正则化）：
+  version    版本号     v?\\d+\\.\\d+(\\.\\d+)?
+  percent    百分比     \\d+(\\.\\d+)?%
+  money      金额       ￥/$/€ + 数字（含亿/万/billion/million 单位）
+  date       日期       YYYY-MM-DD / YYYY年MM月 / MM/DD/YYYY
+  law_code   法规号     《XX法》第N条 / 法释〔YYYY〕N号 等
+
+启用条件：仅 deep/auto 且结果 ≥3；fast 跳过（控制延迟）。
+输出：顶层 fact_alignment 字段。
+
+纯本地，仅 stdlib。
+"""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from typing import Any
+from urllib.parse import urlparse
+from cli_io import dumps
+
+
+# ── 事实抽取正则（每类捕获归一化 value）──────────────────────────────────────
+
+# 版本号：避免把裸小数（94.9 营收）误判为版本号。
+# 版本语义特征 = v 前缀 / 三段式 / 版本上下文词（version/ver/v/版本/版号）。
+# 裸 "94.9" 无这些特征 → 不当版本号。
+# 注意：\b 在 CJK 字符间不成立（「件版本」无单词边界），中文版本词单独处理。
+_FACT_PATTERNS: dict[str, re.Pattern] = {
+    "version": re.compile(
+        r"(?i)(?:"
+        # 1) 英文版本词 + 数字（version 3.12 / v3.12）
+        r"\b(?:version|ver|release|rel)\b[\s.]*(\d+(?:\.\d+){1,3})"
+        r"|"
+        # 2) 中文版本词 + 数字（版本3.12 / 版号3.12，前导非数字避免串扰）
+        r"(?<![\d.])(?:版本|版号)[\s.]*(\d+(?:\.\d+){1,3})"
+        r"|"
+        # 3) 单字符 v 前缀（v3.12，独立 token）
+        r"(?<![a-zA-Z\d.])v[\s.]*(\d+(?:\.\d+){1,3})(?![\d.])"
+        r"|"
+        # 4) 三段式版本号（3.12.4，无需上下文词）
+        r"(?<![\d.])(\d+\.\d+\.\d+)(?![\d.])"
+        r"|"
+        # 5) 明确软件语义词后的双段（Python 3.12 / react 18.2）
+        r"\b(?:python|node|java|kubernetes|k8s|docker|react|vue|angular|"
+        r"tensorflow|pytorch|django|flask|ubuntu|windows|macos|ios|android)"
+        r"[\s.]*(\d+(?:\.\d+){1,2})"
+        r")", re.I),
+    "percent": re.compile(r"(\d+(?:\.\d+)?)\s*%|(\d+(?:\.\d+)?)\s*percent", re.I),
+    "money": re.compile(
+        r"(?:[￥$€]|人民币|美元)\s*(\d+(?:\.\d+)?(?:\s*(?:亿|万|千|百万))?)"
+        r"|(\d+(?:\.\d+)?)\s*(?:亿元|万元|亿美元|billion|million)", re.I),
+    "date": re.compile(
+        r"(\d{4}-\d{1,2}-\d{1,2})"
+        r"|(\d{4}\s*年\s*\d{1,2}\s*月(?:\s*\d{1,2}\s*日)?)"
+        r"|(\d{1,2}/\d{1,2}/\d{4})"),
+    "law_code": re.compile(
+        r"(《[^》]{2,20}(?:法|条例|规定|办法|解释)》(?:第[\d一二三四五六七八九十百]+条)?)"
+        r"|(法释〔?\d{4}〕?\d+号)"),
+}
+
+
+def _normalize_value(fact_type: str, raw: str) -> str:
+    """归一化 value，便于跨源比较。"""
+    v = raw.strip()
+    if fact_type == "percent":
+        return v.replace(" ", "").rstrip("%") + "%"
+    if fact_type == "version":
+        return v.lower().lstrip("v")
+    if fact_type == "date":
+        # 统一分隔符与全角
+        return re.sub(r"\s+", "", v).replace("年", "-").replace("月", "-").replace("日", "").strip("-")
+    if fact_type == "money":
+        return re.sub(r"\s+", "", v)
+    return re.sub(r"\s+", "", v)
+
+
+def extract_facts(text: str) -> list[tuple[str, str]]:
+    """从文本抽取 (type, normalized_value) 列表。"""
+    facts: list[tuple[str, str]] = []
+    if not text:
+        return facts
+    for ftype, pat in _FACT_PATTERNS.items():
+        for m in pat.finditer(text):
+            # 取第一个非空捕获组
+            raw = next((g for g in m.groups() if g), None)
+            if not raw:
+                continue
+            val = _normalize_value(ftype, raw)
+            if val and (ftype, val) not in facts:
+                facts.append((ftype, val))
+    return facts
+
+
+def _domain_of(url: str) -> str:
+    """提取 URL 的注册域名（用于跨源判定）。"""
+    try:
+        host = urlparse(url).netloc.lower()
+    except Exception:
+        return ""
+    if host.startswith("www."):
+        host = host[4:]
+    return host
+
+
+def align_facts(results: list[dict[str, Any]], min_results: int = 3,
+                mode: str = "auto", depth: str = "balanced") -> dict[str, Any] | None:
+    """对多源结果做事实交叉标记。
+
+    Args:
+        results: 搜索结果列表（需含 title/snippet/url）。
+        min_results: 启用阈值（默认 3）。
+        mode: 预算模式；fast 直接跳过。
+        depth: 深度；fast 跳过。
+
+    Returns:
+        fact_alignment 字典，或 None（未启用/无事实）。
+        {
+          "enabled": True,
+          "fact_conflicts": [{"type","values":[{"value","domains"}]}],
+          "fact_corroborated": [{"type","value","domains"}],
+          "stats": {"facts_extracted","conflicts","corroborated"}
+        }
+    """
+    if mode == "fast" or depth == "fast":
+        return None
+    if not results or len(results) < min_results:
+        return None
+
+    # (type, value) → set(domains)
+    tv_domains: dict[tuple[str, str], set[str]] = defaultdict(set)
+    # type → set(values)
+    type_values: dict[str, set[str]] = defaultdict(set)
+
+    for r in results:
+        if not isinstance(r, dict):
+            continue
+        text = f"{r.get('title', '')} {r.get('snippet', '')}"
+        domain = _domain_of(r.get("url", "")) or (r.get("source", "") or "unknown")
+        for ftype, val in extract_facts(text):
+            tv_domains[(ftype, val)].add(domain)
+            type_values[ftype].add(val)
+
+    if not tv_domains:
+        return None
+
+    # 印证：同 (type,value) 出现在 ≥2 个域名
+    corroborated = []
+    for (ftype, val), domains in tv_domains.items():
+        if len(domains) >= 2:
+            corroborated.append({
+                "type": ftype, "value": val, "domains": sorted(domains),
+            })
+
+    # 冲突：同 type 出现 ≥2 个不同 value
+    conflicts = []
+    for ftype, values in type_values.items():
+        if len(values) >= 2:
+            value_entries = []
+            for val in sorted(values):
+                value_entries.append({
+                    "value": val,
+                    "domains": sorted(tv_domains[(ftype, val)]),
+                })
+            conflicts.append({"type": ftype, "values": value_entries})
+
+    return {
+        "enabled": True,
+        "fact_conflicts": conflicts,
+        "fact_corroborated": corroborated,
+        "stats": {
+            "facts_extracted": len(tv_domains),
+            "conflicts": len(conflicts),
+            "corroborated": len(corroborated),
+        },
+    }
+
+
+# ── CLI 测试 ──────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+
+    sample = [
+        {"title": "Python 3.12 发布", "snippet": "性能提升 5%，2023-10-02 正式发布",
+         "url": "https://python.org/news"},
+        {"title": "Python 3.12 新特性", "snippet": "官方称提速约 5% ，发布于 2023年10月",
+         "url": "https://realpython.com/py312"},
+        {"title": "Python 版本对比", "snippet": "3.11 相比 3.10 提速 25%",
+         "url": "https://blog.example.com/x"},
+        {"title": "营收报告", "snippet": "该公司营收 120亿元，同比增长 15%",
+         "url": "https://finance.a.com"},
+        {"title": "财报快讯", "snippet": "营收达 130亿元",
+         "url": "https://finance.b.com"},
+    ]
+    out = align_facts(sample, mode="auto", depth="deep")
+    print(dumps(out))