幻觉（hallucination）指大模型生成了"看起来很合理、其实是编造"的内容。在本框架的场景里，典型幻觉有：

• 引用了一个根本不存在的证据 ID（比如凭空捏造一条 trace_id）；
• 结论过度自信（明明证据不足却说"确定就是它"）；
• 只引 1 个证据就下大结论、忽略反例；
• 对高风险动作（重启、回滚）不加"先验证"的提示。

对一个要给 SRE 做故障根因的 Agent 来说，幻觉是致命的——你不能让它把运维人员带到错误方向。所以框架专门设了 Critic 节点：在综合出结论后、返回给用户前，先自我审查一遍。代码在 packages/ai-trust-toolkit/src/ai_trust_toolkit/critic/。

Critic 的核心巧思是分两层，按"成本递增"顺序拦截——能用 0 成本代码解决的，绝不浪费 LLM 调用：

先看 L1 用到的数据结构和"标准答案表"——不理解它们，后面 4 项检查会看不懂。代码在 critic/layer1.py 开头（layer1.py:24-41）：

# layer1.py:24 —— 哪些 state 字段装着专家产出的 finding（业务可覆盖）
DEFAULT_SP_FIELDS: tuple[str, ...] = (
    "trace_finding", "metric_finding", "deploy_finding", "log_finding",
)

# layer1.py:31 —— 置信度 / 风险等级的"合法取值表"
VALID_CONFIDENCE_VALUES: frozenset[str] = frozenset({"高", "中", "低"})
VALID_RISK_LEVELS: frozenset[str] = frozenset({"high", "medium", "low"})

@dataclass  # layer1.py:35
class Layer1CheckResult:
    passed: bool
    violations: list[str] = field(default_factory=list)
    detail: dict[str, Any] = field(default_factory=dict)

4 项检查里最硬核的一项——抓编造 ID——依赖一个前置步骤：先把 4 位专家真实产出的证据 ID 全收集起来，组成"现场真有的材料清单"。这就是 collect_valid_evidence_ids()（layer1.py:44）：

def collect_valid_evidence_ids(state, sp_fields=DEFAULT_SP_FIELDS, id_extractor=None):
    if id_extractor is not None:          # 业务可自定义抽取逻辑
        return id_extractor(state)
    valid: set[str] = set()
    for field_name in sp_fields:          # 遍历 4 个专家字段
        finding = state.get(field_name)
        if not finding or not isinstance(finding, dict):
            continue                      # ← 边界：空 finding / 非 dict 直接跳过
        # 形态 1：finding["evidence_ids"] = ["ev-1", "ev-2"]
        for eid in finding.get("evidence_ids", []) or []:
            if isinstance(eid, str):
                valid.add(eid)
        # 形态 2：finding["evidences"] = [{"id": "ev-1"}, ...]
        for evidence in finding.get("evidences", []) or []:
            if isinstance(evidence, dict):
                eid = evidence.get("id")
                if isinstance(eid, str):
                    valid.add(eid)
    return valid

有了合法 ID 集合，现在逐个拆开 4 项检查。每项都是一个独立小函数，返回 (是否通过, 附加信息)——纯代码、0 成本、100% 确定。

① check_evidence_ids —— 抓编造证据 ID（layer1.py:75）

def check_evidence_ids(conclusion, valid_ids) -> tuple[bool, list[str]]:
    cited_ids: set[str] = set()
    for eid in conclusion.get("evidence_ids", []) or []:
        if isinstance(eid, str):
            cited_ids.add(eid)
    fabricated = cited_ids - valid_ids     # ← 核心：集合差集
    return (not fabricated, sorted(fabricated))

一句话：把结论引用的 ID 减去合法 ID，剩下的就是凭空编的。fabricated 非空 → 不通过。这就是"用代码 100% 抓幻觉"最漂亮的一行。

② check_min_specialists —— 至少 2 位专家印证（layer1.py:88）

def check_min_specialists(conclusion, state, min_count=2, sp_fields=DEFAULT_SP_FIELDS):
    actual = sum(
        1 for f in sp_fields
        if state.get(f) and isinstance(state[f], dict)
        and not state[f].get("fallback", False)   # ← 排除降级的假 finding
    )
    return (actual >= min_count, actual)

一句话：数一数几个专家真的出了结果。关键是 not ...get("fallback")——Day 08 兜底闸给的降级 finding 带 fallback:True，这里要排除掉，否则"4 个专家全挂、全是兜底占位"也会被误判成"证据充分"。默认要求 ≥2，防止单一证据下大结论。

③ check_schema —— 格式合法性（layer1.py:101）

def check_schema(conclusion) -> tuple[bool, list[str]]:
    violations = []
    confidence = conclusion.get("confidence")
    if confidence not in VALID_CONFIDENCE_VALUES:      # 用上 L03 的常量表
        violations.append(f"confidence={confidence!r} 不在 {VALID_CONFIDENCE_VALUES}")
    hypotheses = conclusion.get("hypotheses") or []
    if not isinstance(hypotheses, list):
        violations.append("hypotheses 必须是 list")
    else:
        for i, h in enumerate(hypotheses):
            if not isinstance(h, dict): continue
            risk = h.get("risk_level")
            if risk is not None and risk not in VALID_RISK_LEVELS:
                violations.append(f"hypotheses[{i}].risk_level={risk!r} 非法")
    return (not violations, violations)

一句话：置信度必须 ∈ {高,中,低}，每条假设的风险等级（若填了）必须 ∈ {high,medium,low}。注意 risk is not None——风险等级允许不填，但填了就必须合法（区分"没提供"和"提供了非法值"）。

④ check_high_risk_verify_first —— 高危动作必须先验证（layer1.py:121）

def check_high_risk_verify_first(conclusion) -> tuple[bool, list[str]]:
    violations = []
    for h in conclusion.get("hypotheses", []) or []:
        if not isinstance(h, dict): continue
        if h.get("risk_level") == "high":              # 只管高危假设
            for j, a in enumerate(h.get("actions") or []):
                if isinstance(a, dict) and not a.get("verify_first"):
                    violations.append(f"...actions[{j}] high-risk 缺少 verify_first")
    return (not violations, violations)

一句话：凡是标了 risk_level:"high" 的假设，它下面每个动作都必须带 verify_first:true。这是一条安全红线——不能让 Agent 直接叫人"重启/回滚"却不提示先核实。

4 项检查由总入口 run_layer1_checks()（layer1.py:135）串起来，顺序跑、攒违规、打包成 Layer1CheckResult：

def run_layer1_checks(state, valid_ids=None, *, min_specialists=2,
                      sp_fields=DEFAULT_SP_FIELDS, conclusion_field="conclusion"):
    conclusion = state.get(conclusion_field) or {}
    if valid_ids is None:                              # 没传就现场收集
        valid_ids = collect_valid_evidence_ids(state, sp_fields)
    violations = []
    detail = {"valid_ids_count": len(valid_ids)}

    ok, fab = check_evidence_ids(conclusion, valid_ids)          # ①
    if not ok: violations.append(f"① 编造 evidence_id: {fab}")
    detail["fabricated_ids"] = fab

    ok, n = check_min_specialists(conclusion, state, min_specialists, sp_fields)  # ②
    if not ok: violations.append(f"② 仅 {n} 位 Specialist 印证（需 ≥ {min_specialists}）")
    detail["actual_specialists"] = n

    ok, schema_v = check_schema(conclusion)                      # ③
    if not ok: violations.append(f"③ schema 违规: {schema_v}")

    ok, risk_v = check_high_risk_verify_first(conclusion)        # ④
    if not ok: violations.append(f"④ 高风险动作缺 verify_first: {risk_v}")

    return Layer1CheckResult(passed=not violations, violations=violations, detail=detail)

L1 全过了，才轮到 L2。代码在 critic/layer2.py。build_critic_node(config)（layer2.py:51）返回一个 async 节点，节点内部先跑 L1、L1 不过直接返回、根本不烧 LLM（layer2.py:59-71）：

async def critic_node(state):                       # layer2.py:59
    # ① Layer 1：代码层硬检查
    valid_ids = (config.valid_ids_extractor(state) if config.valid_ids_extractor
                 else collect_valid_evidence_ids(state))
    l1 = run_layer1_checks(state, valid_ids)
    if not l1.passed:
        return {"critique_passed": False,
                "critique_feedback": "Layer 1 failed: " + " | ".join(l1.violations),
                "critique_layer": 1,                # ← 标记：被代码层拦下
                "retry_count": 1}                   # 不调 LLM，直接返回！
    # ② Layer 2：只有 L1 过了才调 Haiku
    conclusion = state.get(config.conclusion_field) or {}
    try:
        llm = config.llm_factory()                  # 通常 get_llm("haiku")
        response = await llm.ainvoke([{"role":"system","content":config.system_prompt},
                                      {"role":"user","content": user_msg}])
        parsed = _parse_critic_response(getattr(response, "content", str(response)))
        return {"critique_passed": parsed["critique_passed"],
                "critique_layer": 2, "retry_count": 1, ...}
    except Exception as e:
        if config.soft_fail:                        # ← 边界：LLM 挂了怎么办
            return {"critique_passed": False, "critique_layer": 2,
                    "critique_feedback": f"Layer 2 error: {e}", "retry_count": 1}
        raise

CriticConfig（layer2.py:30）业务要提供：system_prompt（6 项铁律 prompt）、llm_factory、conclusion_field、valid_ids_extractor、soft_fail。

Haiku 返回的可能不是干净 JSON，所以有个三级兜底解析器 _parse_critic_response()（layer2.py:112）：

def _parse_critic_response(content):
    try:
        return json.loads(content)                  # ① 先当纯 JSON
    except (json.JSONDecodeError, TypeError):
        pass
    m = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", content, re.DOTALL)  # ② markdown 代码块
    if m:
        try: return json.loads(m.group(1))
        except json.JSONDecodeError: pass
    passed = "critique_passed: true" in content.lower() or "PASS" in content[:200]  # ③ 关键字兜底
    return {"critique_passed": passed, "critique_feedback": content[:500]}

三态路由：把审查结果变成"下一步走哪"

Critic 审完，critic_router（retry_router.py:35，工厂 build_critic_router 在 retry_router.py:12）把结果翻译成三种走向：

def critic_router(state) -> str:             # retry_router.py:35
    if state.get("critique_passed"):
        return pass_dest                     # "writeback"：通过
    if state.get("retry_count", 0) >= max_retries:
        return end_dest                      # END：触顶，诚实收尾
    return retry_dest                        # "synthesizer"：打回重做

@dataclass
class Rule:                                   # business_layer1.py:34
    name: str                                 # 出现在违规报告里，便于追踪
    predicate: Callable[[dict], bool]         # state -> 通过与否
    error_msg: str | Callable[[dict], str]    # 违规描述（可静态可动态）
    severity: str = "error"                   # error 计入违规 / warn 只记日志

async def critic_l1_node(state):              # business_layer1.py:81
    violations = []
    for rule in rules:
        try:
            ok = rule.predicate(state)
        except Exception as e:                # ← 边界：规则本身崩了
            violations.append(f"{rule.name}: 规则计算异常 {type(e).__name__}: {e}")
            continue                          # 视为违规，绝不放过
        if not ok and rule.severity == "error":
            msg = rule.error_msg(state) if callable(rule.error_msg) else rule.error_msg
            violations.append(f"{rule.name}: {msg}")
    return {"layer1_passed": len(violations) == 0, "layer1_violations": violations}

critic_l1 = build_business_critic_l1([
    rule_in_allowed_set("routing_decision", ALLOWED_DECISIONS),
    rule_conditional_field(                   # 决定"立即呼叫"就必须填业务影响
        when=lambda s: s["routing_decision"] == "page_immediately",
        require_field="business_impact"),
])
builder.add_node("critic", critic_l1)

框架并不强制每个 agent 都上"双层完整 Critic"。它按场景提供三档强度，本身就是很好的"权衡"教学案例：

✋ 动手

# 1. 看 critic 模块能力清单
sed -n '1,61p' packages/ai-trust-toolkit/src/ai_trust_toolkit/critic/__init__.py

# 2. 读 L1 的 4 项检查
sed -n '44,135p' packages/ai-trust-toolkit/src/ai_trust_toolkit/critic/layer1.py

# 3. 读 L2 的"先L1后LLM"短路逻辑
sed -n '51,110p' packages/ai-trust-toolkit/src/ai_trust_toolkit/critic/layer2.py

# 4. 读 sre-rca 的 critic-v1.md（6 项检查 + 三态 + few-shot）
sed -n '1,90p' apps/sre-rca-agent/prompts/critic-v1.md

# 5. 跑相关单测感受
uv run pytest packages/ai-trust-toolkit/tests/test_critic_layer1.py -q