# -*- coding: utf-8 -*-
"""md_cg · issue50-d 守卫：落盘=裁决值 + 保护位只认显式声明 + 文案分叉

缺陷（编排侧改前基线实测，非推断）
----------------------------------
遗忘闸门 `forgetting.assess` 的重要度一问存在一对同源缺陷：
  ① 审计面文案声称未发生的事——启发式路径（不传 hint）裁决走
     「imp≥0.70 → ACCEPT，reason=『重要度 0.84≥0.7（触发不可遗忘保护）』」，
     但落盘面 importance=0.5（默认）且无保护位（隔离沙箱直读 frontmatter
     实证：u_heur_new 裁决 0.837/落盘 0.5；t_heur 裁决 0.711/落盘 0.5）。
  ② 落盘重要度是常数——启发式路径全落 0.5、插件通道（hint=0.6 透传）全落
     0.6 ⇒ 落盘重要度不携带任何区分信息；门禁算出的 0.84/0.71/0.52 在落盘
     时全部丢弃。

本批修复（使用者裁定 2026-10-02，三件套一次收口）
--------------------------------------------------
  1. 落盘=裁决值：remember_gated ACCEPT 分支无条件落 `imp["score"]`（mdcos），
     并落 `importance_source`（"hint"|"heuristic"）进 fm 与索引条目（_node_entry
     与 add 的 _stage 两处同口径，免读文件可判）。
  2. 保护位只认显式声明：add 的自动保护（importance≥0.7 → protected 位）加
     source 闸——`importance_source != "heuristic"` 才打位；启发式过线只落分、
     不打位。add 缺省 None ⇒ 全部既有调用方（约 40 处生产点，逐一面核对均
     不传该键）保护行为逐位不变，零回归由构造保证。
  3. 文案分叉：assess 保护分支 reason 按 `imp["from"]` 分叉——hint 维持
     「触发不可遗忘保护」；heuristic 改「启发式 …（未落保护——保护须显式声明）」。

改前/改后对拍表（E 组；同一组用例两棵树各跑一遍的实测读数，2026-10-02）
------------------------------------------------------------------------
  本表是**实施期一次性实测的字面量**，不是 git HEAD 引用（基线绑提交即失效，
  本仓已有两次教训）——改前树用临时探针跑出，改后由本守卫的 E 组断言钉住。

  | 用例                       | verdict      | 裁决imp        | fm.importance      | importance_source | protected | reason                                    |
  |----------------------------|--------------|----------------|--------------------|-------------------|-----------|-------------------------------------------|
  | A role=tool-output 无hint  | ACCEPT→不变  | 0.775/heuristic→不变 | 0.5→0.775【变】| 无→heuristic【新增】| 无→无不变 | 「重要度…触发不可遗忘保护」→「启发式…未落保护」【变】|
  | A2 role=None 无hint        | ACCEPT→不变  | 0.88/heuristic→不变  | 0.5→0.88【变】 | 无→heuristic【新增】| 无→无不变 | 同上【变】                                 |
  | B hint=0.9                 | ACCEPT→不变  | 0.9/hint→不变        | 0.9→0.9【不变】| 无→hint【新增】    | True→True不变 | 「触发不可遗忘保护」不变                    |
  | C hint=0.6                 | ACCEPT→不变  | 0.6/hint→不变        | 0.6→0.6【不变】| 无→hint【新增】    | 无→无不变 | 「重要度 0.60≥0.3」不变                    |
  （source 列改前四行恒无——键不存在；「变」以 fm.importance/protected/reason 三列为判。）

F 组（待验证假设的只读验证，只取事实、不改检索面、不许诺改善）
--------------------------------------------------------------
  假设：重要度→排序→下游使用是一条功能链。事实结论（代码读数 + 隔离库实测）：
  · 代码读数：`MdCG._score` 的主分**不消费** importance（词法 sim + tag_bonus
    ± 语义 max / 池乘数 / freshness 乘子 / S4 层加成）；importance 的消费面在
    **排序的次级键**，共三处——`cut_by_relevance`（候选截断+排序，键=(-score,
    -importance,-created_at,nid)）、S3 扩散合并排序、`_emit` 终排（键=(-score,
    -importance,id)）。即：**排序消费落盘 importance，但只在相关度平分时作
    破缺**。改前落盘恒 0.5/0.6 ⇒ 平分破缺键全库常数、重要度轴死；改后启发式
    真分落盘 ⇒ 该轴带电。下游另有一个消费面：`protect.is_protected` 的读时
    「重要性保护」（importance≥0.7 → 覆写/遗忘闸拦），启发式节点落 0.7x 分后
    会被它按分拦截——这是「只落分」的直接后果，protect.py 本批未改。
  · 实测读数：隔离库同内容两节点（importance 0.3 vs 0.9）→ 主分同（1.0），
    两种写入序下 0.9 者都排前（F2/F3）——排序消费落盘 importance 成立。

定点变异自证（--mutate）
------------------------
每一处判据都配一个定点变异把它打红，且**恰好**命中预期红项数
（_SRC_MUTATIONS 的 expected 列；实测计数不符即判 FAIL——照
test_i50a_half_dup_defer.py / test_neg_condition_hits.py 同口径）。锚点漂移
（实现改了却没同步本表）→ 报 ANCHOR-MISS 并 **exit 2**（fail-closed）；默认
模式同样先做锚点自检。**不以 git HEAD 为基线源**——变异一律作用在当前盘的
实现上（inspect.getsource + 字面替换 + exec，不落盘不改源文件）。

运行：python -X utf8 -m md_cg.test_i50d_importance_source
      python -X utf8 -m md_cg.test_i50d_importance_source --mutate
"""
from __future__ import annotations

import contextlib
import inspect
import io
import os
import shutil
import subprocess
import sys
import tempfile
import textwrap

# 三档自治批次②（2026-10-02）**夹具隔离**：本守卫考的不是档位面（档位守卫 =
# md_cg/test_autonomy_modes.py），故显式置 full 档——回到改动前「动作直落」的
# 行为，使本文件的断言意图（合并/覆写/软删真的发生）逐条不变；env 键名从唯一
# 真源表取（本文件不构成第二处字面量）。
from . import autonomy_modes as _autonomy_modes          # noqa: E402
os.environ[_autonomy_modes.AUTONOMY_ENV_KEYS["mode"]] = "full"

from . import forgetting, mdcg, mdcos, nodefile
from .mdcg import MdCG
from .mdcos import MdCGOS

_PASS = []
_FAIL = []


def ok(cond, msg, extra=""):
    (_PASS if cond else _FAIL).append(msg)
    print(("  PASS " if cond else "  FAIL ") + msg
          + (("  ← " + str(extra)) if (extra and not cond) else ""))


# ---------------------------------------------------------------- 夹具
# 正文长度 >200 字 ⇒ lf=1：role=tool-output（internal_deterministic，权 0.25）
# 的启发式 = 0.5·1 + 0.3·0.25 + 0.2·1 = 0.775 —— 恰好过保护线（≥0.7）且落在
# 「0.7x 量级」；role=None（unknown，权 0.6）= 0.88。两路都走保护分支，
# 文案分叉与「只落分不打位」都在这条线上验。
BODY = ("写入闸门重要度轴守卫正文。" + "这是一段足够长的全新合成正文，" * 12
        + "结尾标记 i50dGUARD。")


def _doc(title, body):
    return ("# 功能名：%s\n# 生效条件：任意情境\n# 子功能：验收\n"
            "# 执行：直接调用\n# 验证方式：test\n# 不适用条件：无\n%s\n"
            % (title, body))


def _run_case(nid, **kw):
    """隔离临时根上真跑 remember_gated，返回 (返回体, fm, 盘面fm, 索引条目)。

    三层读数缺一不可：返回体（裁决面）/ 索引条目（免读判面）/ 盘面直读
    （单一真相源——防索引遮蔽）。临时根 finally 删除，绝不触在役数据根。
    """
    root = tempfile.mkdtemp(prefix="i50d_")
    try:
        cg = MdCGOS(root)
        out = cg.remember_gated(nid, _doc("守卫节点", BODY),
                                layer="contextual", **kw)
        gate = out.get("gate") or {}
        fm = (cg.get(nid) or {}).get("frontmatter") or {}
        entry = cg.index["nodes"].get(nid) or {}
        path = os.path.join(root, entry.get("path") or "")
        disk = None
        if path and os.path.isfile(path):
            with open(path, encoding="utf-8") as f:
                disk, _c = nodefile.loads(f.read())
        return {"out": out, "gate": gate, "fm": fm, "disk": disk or {},
                "entry": entry}
    finally:
        try:
            cg.close()
        except Exception:
            pass
        shutil.rmtree(root, ignore_errors=True)


# ---------------------------------------------------------------- F0 夹具自检
def g_f0():
    print("== F0 夹具自检（用例确实落在保护分支上）==")
    r = _run_case("f0_a", role="tool-output")
    sc = (r["gate"].get("importance") or {}).get("score")
    ok(r["gate"].get("importance", {}).get("from") == "heuristic"
       and 0.7 <= (sc or 0) < 0.8,
       "F0-1 A 用例裁决 from=heuristic 且 0.7x 量级（%.4f，确实走保护分支）"
       % (sc or -1), r["gate"])
    r2 = _run_case("f0_b", importance_hint=0.9)
    ok((r2["gate"].get("importance") or {}).get("from") == "hint"
       and (r2["gate"].get("importance") or {}).get("score") == 0.9,
       "F0-2 B 用例裁决 from=hint 且 score=0.9", r2["gate"])


# ---------------------------------------------------------------- A 启发式面
def g_a():
    print("== A 启发式全新：落盘=裁决值、source=heuristic、无保护位、文案如实 ==")
    r = _run_case("a_heur", role="tool-output")
    sc = (r["gate"].get("importance") or {}).get("score")
    ok(r["out"].get("verdict") == "ACCEPT",
       "A1 全新启发式过保护线 → verdict ACCEPT（裁决面不变）",
       r["out"].get("verdict"))
    ok(r["fm"].get("importance") == sc,
       "A2 落盘 fm.importance == 裁决值 %s（改前恒 0.5）" % sc,
       r["fm"].get("importance"))
    ok(r["entry"].get("importance") == sc,
       "A3 索引条目 importance == 裁决值（免读文件可判）",
       r["entry"].get("importance"))
    ok(r["disk"].get("importance") == sc and r["disk"].get("importance_source") == "heuristic",
       "A4 盘面直读 importance==裁决值 且 source==heuristic（单一真相源）",
       (r["disk"].get("importance"), r["disk"].get("importance_source")))
    ok(r["fm"].get("importance_source") == "heuristic",
       "A5 fm.importance_source == 'heuristic'", r["fm"].get("importance_source"))
    ok(r["entry"].get("importance_source") == "heuristic",
       "A6 索引条目 importance_source == 'heuristic'",
       r["entry"].get("importance_source"))
    ok(r["fm"].get("protected") is None and r["disk"].get("protected") is None,
       "A7 启发式过线不打保护位（fm 与盘面均无 protected）",
       (r["fm"].get("protected"), r["disk"].get("protected")))
    why = r["gate"].get("reason") or ""
    ok("触发不可遗忘保护" not in why,
       "A8 文案不再声称「触发不可遗忘保护」（改前启发式也这么声称）", why)
    ok("启发式" in why and "未落保护" in why and "显式声明" in why,
       "A9 文案如实：启发式/未落保护/保护须显式声明", why)
    # 对照：role=None（unknown 来源）启发式 0.88 量级——同族第二路
    r2 = _run_case("a_heur_none")
    sc2 = (r2["gate"].get("importance") or {}).get("score")
    ok(r2["fm"].get("importance") == sc2
       and r2["fm"].get("importance_source") == "heuristic"
       and r2["fm"].get("protected") is None
       and "未落保护" in (r2["gate"].get("reason") or ""),
       "A10 对照 role=None：0.5→裁决值 %s、source=heuristic、无保护、文案如实"
       % sc2, (r2["fm"].get("importance"), r2["fm"].get("importance_source"),
               r2["fm"].get("protected"), r2["gate"].get("reason")))


# ---------------------------------------------------------------- B 显式面
def g_b():
    print("== B 显式 hint=0.9：保护位与文案零回归 ==")
    r = _run_case("b_hint09", importance_hint=0.9)
    ok(r["fm"].get("importance") == 0.9,
       "B1 落盘 importance == 0.9（显式面零回归）", r["fm"].get("importance"))
    ok(r["fm"].get("importance_source") == "hint",
       "B2 fm.importance_source == 'hint'", r["fm"].get("importance_source"))
    ok(r["fm"].get("protected") is True,
       "B3 显式声明过线 → protected=True（自动保护位保留）",
       r["fm"].get("protected"))
    ok("importance=0.90" in str(r["fm"].get("protection_reason") or ""),
       "B4 protection_reason 逐字维持（importance=0.90≥0.7）",
       r["fm"].get("protection_reason"))
    ok("触发不可遗忘保护" in (r["gate"].get("reason") or ""),
       "B5 保护文案维持（「触发不可遗忘保护」不因分叉而丢失）",
       r["gate"].get("reason"))
    ok(r["disk"].get("protected") is True
       and r["entry"].get("protected") is True,
       "B6 盘面与索引条目同步 protected=True",
       (r["disk"].get("protected"), r["entry"].get("protected")))


# ---------------------------------------------------------------- C 插件缺省面
def g_c():
    print("== C 插件缺省 hint=0.6：落盘值与无保护状态零回归 ==")
    r = _run_case("c_hint06", importance_hint=0.6)
    ok(r["fm"].get("importance") == 0.6,
       "C1 落盘 importance == 0.6（与改前一致）", r["fm"].get("importance"))
    ok(r["fm"].get("importance_source") == "hint",
       "C2 source == 'hint'（0.6 是插件显式缺省声明）",
       r["fm"].get("importance_source"))
    ok(r["fm"].get("protected") is None,
       "C3 0.6<0.7 无保护位（与改前一致）", r["fm"].get("protected"))
    ok((r["gate"].get("reason") or "") == "重要度 0.60≥0.3",
       "C4 reason 逐字同改前（走⑤重要度分支，不经保护分支）",
       r["gate"].get("reason"))


# ---------------------------------------------------------------- E 对拍锚
_BEFORE_TABLE = {
    # 改前树实测（2026-10-02 临时探针；docstring 对拍表的字面量形态）
    "A": {"verdict": "ACCEPT", "gate_score": 0.775, "gate_from": "heuristic",
          "fm_importance": 0.5, "fm_protected": None,
          "reason": "重要度 0.78≥0.7（触发不可遗忘保护）"},
    "B": {"fm_importance": 0.9, "fm_protected": True,
          "reason": "重要度 0.90≥0.7（触发不可遗忘保护）"},
    "C": {"fm_importance": 0.6, "fm_protected": None,
          "reason": "重要度 0.60≥0.3"},
}


def g_e():
    print("== E 改前/改后对拍锚（docstring 表的「不变」列逐列回归）==")
    r = _run_case("e_a", role="tool-output")
    b = _BEFORE_TABLE["A"]
    ok(r["out"].get("verdict") == b["verdict"]
       and (r["gate"].get("importance") or {}).get("score") == b["gate_score"]
       and r["fm"].get("protected") == b["fm_protected"],
       "E1 A 行不变列：verdict/裁决分/protected 与改前逐列相同",
       (r["out"].get("verdict"), (r["gate"].get("importance") or {}).get("score"),
        r["fm"].get("protected")))
    ok(r["fm"].get("importance") != b["fm_importance"],
       "E2 A 行变列：fm.importance 0.5→裁决值（确实变了，不是改前常数）",
       r["fm"].get("importance"))
    r2 = _run_case("e_b", importance_hint=0.9)
    b2 = _BEFORE_TABLE["B"]
    ok(r2["fm"].get("importance") == b2["fm_importance"]
       and r2["fm"].get("protected") == b2["fm_protected"]
       and (r2["gate"].get("reason") or "") == b2["reason"],
       "E3 B 行显式面逐列不变：importance/protected/reason 与改前相同",
       (r2["fm"].get("importance"), r2["fm"].get("protected"),
        r2["gate"].get("reason")))
    r3 = _run_case("e_c", importance_hint=0.6)
    b3 = _BEFORE_TABLE["C"]
    ok(r3["fm"].get("importance") == b3["fm_importance"]
       and r3["fm"].get("protected") == b3["fm_protected"]
       and (r3["gate"].get("reason") or "") == b3["reason"],
       "E4 C 行显式面逐列不变：importance/protected/reason 与改前相同",
       (r3["fm"].get("importance"), r3["fm"].get("protected"),
        r3["gate"].get("reason")))


# ---------------------------------------------------------------- F 假设链（只读）
def g_f():
    print("== F 假设链只读验证：排序是否消费落盘 importance（只取事实）==")
    # 代码读数①：主分面 _score 不消费 importance
    score_src = inspect.getsource(MdCG._score)
    ok("importance" not in score_src,
       "F1 代码读数：_score 主分不消费 importance（词法+标签±语义/乘子）")
    # 代码读数②：消费面在排序次级键（三处，钉两处代表 + 终排）
    cut_src = inspect.getsource(mdcg.cut_by_relevance)
    ok('frontmatter"].get("importance"' in cut_src,
       "F2 代码读数：cut_by_relevance 的排序键含 importance（次级破缺）")
    emit_src = inspect.getsource(MdCG._emit)
    ok('frontmatter"].get("importance"' in emit_src,
       "F3 代码读数：_emit 终排的排序键含 importance")
    # 实测读数：隔离库同内容 0.3 vs 0.9，两种写入序
    def _rank(low_first):
        root = tempfile.mkdtemp(prefix="i50d_rank_")
        try:
            cg = MdCGOS(root)
            doc = _doc("排序验证", "芙蓉峰下灵枢阁的排序消费面独特词 XQV700。")
            first_imp, second_imp = (0.3, 0.9) if low_first else (0.9, 0.3)
            with contextlib.redirect_stdout(io.StringIO()):
                cg.add("n_first", doc, layer="knowledge",
                       importance=first_imp, verification_basis="test")
                cg.add("n_second", doc, layer="knowledge",
                       importance=second_imp, verification_basis="test")
            results, stat = cg.search("排序消费面独特词 XQV700", k=5)
            rows = [(r[0]["id"], float(r[1]),
                     (r[0]["frontmatter"] or {}).get("importance"))
                    for r in results]
            return {"rows": rows, "tier": stat.get("tier"),
                    "cut": stat.get("cut_order")}
        finally:
            try:
                cg.close()
            except Exception:
                pass
            shutil.rmtree(root, ignore_errors=True)

    a = _rank(True)
    b = _rank(False)
    ok(len(a["rows"]) == 2 and a["rows"][0][1] == a["rows"][1][1],
       "F4 实测：同内容两节点主分相等（%.4f==%.4f，tier=%s cut=%s）"
       % (a["rows"][0][1], a["rows"][1][1], a["tier"], a["cut"]), a["rows"])
    ok(a["rows"][0][2] == 0.9 and b["rows"][0][2] == 0.9,
       "F5 实测：平分时 0.9 者排前（两种写入序一致——排除 id/写入序效应）",
       (a["rows"], b["rows"]))
    print("     （事实结论：排序消费落盘 importance，作同分破缺次级键；"
          "只取事实，不改检索面、不许诺改善。）")


# ---------------------------------------------------------------- D 既有守卫
def g_d():
    print("== D 既有守卫不改断言跑通（子进程实跑，退出码判据）==")
    env = dict(os.environ)
    env["PYTHONUTF8"] = "1"
    proc = subprocess.run(
        [sys.executable, "-X", "utf8", "-m", "md_cg.test_p9_forget_protect"],
        capture_output=True, text=True, encoding="utf-8", errors="replace",
        cwd=os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
        env=env, timeout=300)
    ok(proc.returncode == 0,
       "D1 test_p9_forget_protect 不改断言跑通（importance_hint≥0.7→ACCEPT"
       " 等既有用例 rc=0）", proc.stdout[-400:] + proc.stderr[-200:])


_GROUPS = (g_f0, g_a, g_b, g_c, g_e, g_f, g_d)


def _run_groups():
    """跑全部断言组（静默），返回失败数——供变异自证复用。"""
    _PASS.clear()
    _FAIL.clear()
    for g in _GROUPS:
        g()
    return len(_FAIL)


# ---------------------------------------------------------------- 定点变异自证
# 表内每项 = (说明, 目标, 锚点原文, 替换文, 预期红项数)。锚点必须**逐字**出现
# 在当前实现的对应函数源码里；漂移即 ANCHOR-MISS（fail-closed，exit 2）。
#   目标 "remember_gated" → patch MdCGOS.remember_gated（类方法，exec 于
#   mdcos 模块 globals 副本）；"add" → patch MdCG.add；"assess" → 换
#   forgetting.assess（i50a 同款）。
_SRC_MUTATIONS = (
    # 契约 G①：去掉 source 落盘 → A 组 source 断言红。红 8：A4/A5/A6/A10
    # （source 面）+ A7/E1（source 缺席 ⇒ add 的保护闸看不见 heuristic ⇒
    # 启发式 0.775 也被打保护位——恰是缺陷形态的联动复现）+ B2/C2（显式面
    # 的 source 键同样消失）。
    ("source 落盘整条删除（m1）", "remember_gated",
     'kw["importance_source"] = verdict["importance"]["from"]',
     'pass',
     8),
    # 契约 G 之外的本批核心判据增强：落盘改回「hint 非 None 才透传」的缺陷
    # 形态 → 启发式 A 用例落盘回 0.5。红 5：A2/A3/A4/A10（importance 面）
    # + E2（A 行变列锚——「确实变了」被改回常数即红）。
    ("落盘改回 hint-only 透传（m2，缺陷形态）", "remember_gated",
     'kw["importance"] = verdict["importance"]["score"]',
     'kw["importance"] = (0.5 if hint is None else hint)',
     5),
    # 契约 G②：启发式也打保护（删掉 source 闸）→ A 组无保护位断言红。
    # 红 3：A7 + A10 + E1（改前对拍锚的 protected 不变列）。
    ("启发式也打保护位（m3）", "add",
     '                and importance_source != "heuristic"):',
     '                ):',
     3),
    # 契约 G③：文案不分叉（heuristic 分支换回旧声称）→ A 组文案断言红。
    # 红 3：A8 + A9 + A10（对照行文案半边）。
    ("文案不分叉（m4）", "assess",
     '（未落保护——保护须显式声明）',
     '（触发不可遗忘保护）',
     3),
)

# 静态锚点（默认模式也自检，fail-closed）：
#   · 改前缺陷形态**不得**回归出现在对应函数的可执行源码里
#   · 本批三个新判据的锚点必须在位
_ANCHORS_BANNED = (
    ("remember_gated", 'if hint is not None and "importance" not in kw'),
)
_ANCHORS_REQUIRED = (
    ("remember_gated", 'kw["importance"] = verdict["importance"]["score"]'),
    ("remember_gated", 'kw["importance_source"] = verdict["importance"]["from"]'),
    ("add", 'and importance_source != "heuristic"'),
    ("assess", '未落保护——保护须显式声明'),
)


def _fn_src(target):
    if target == "assess":
        return inspect.getsource(forgetting.assess)
    if target == "remember_gated":
        return inspect.getsource(MdCGOS.remember_gated)
    if target == "add":
        return inspect.getsource(MdCG.add)
    raise KeyError(target)


def _anchor_check():
    """返回 ANCHOR-MISS 说明列表（空 = 全部在位）。"""
    bad = []
    for _name, target, old, _new, _n in _SRC_MUTATIONS:
        if old not in _fn_src(target):
            bad.append("变异锚点缺失：%r @%s" % (old, target))
    for target, s in _ANCHORS_BANNED:
        if s in _fn_src(target):
            bad.append("缺陷形态回归：%s 可执行源码里仍有 %r" % (target, s))
    for target, s in _ANCHORS_REQUIRED:
        if s not in _fn_src(target):
            bad.append("新判据锚点缺失：%s 找不到 %r" % (target, s))
    return bad


def _patched(target, old, new):
    """把目标函数按字面替换变异后返回「安装/还原」对（不落盘不改源文件）。"""
    src = _fn_src(target)
    mutated = src.replace(old, new)
    if target == "assess":
        ns = dict(vars(forgetting))
        exec(compile(mutated, "i50d_mut.py", "exec"), ns)
        fn = ns["assess"]
        return ("forgetting.assess", fn)
    if target == "remember_gated":
        ns = dict(vars(mdcos))
        exec(compile(textwrap.dedent(mutated), "i50d_mut.py", "exec"), ns)
        return ("MdCGOS.remember_gated", ns["remember_gated"])
    ns = dict(vars(mdcg))
    exec(compile(textwrap.dedent(mutated), "i50d_mut.py", "exec"), ns)
    return ("MdCG.add", ns["add"])


@contextlib.contextmanager
def _patched_ctx(target, old, new):
    attr, fn = _patched(target, old, new)
    if attr == "forgetting.assess":
        live = forgetting.assess
        forgetting.assess = fn
        try:
            yield
        finally:
            forgetting.assess = live
    elif attr == "MdCGOS.remember_gated":
        live = MdCGOS.remember_gated
        MdCGOS.remember_gated = fn
        try:
            yield
        finally:
            MdCGOS.remember_gated = live
    else:
        live = MdCG.add
        MdCG.add = fn
        try:
            yield
        finally:
            MdCG.add = live


def _mutate_mode():
    bad = []
    anchor_bad = _anchor_check()
    if anchor_bad:
        for b in anchor_bad:
            print("  ANCHOR-MISS " + b)
        print("\n锚点自检：FAIL（fail-closed，exit 2）")
        return 2
    with contextlib.redirect_stdout(io.StringIO()):
        clean = _run_groups()
    print("  未变异基线：红项=%d%s"
          % (clean, "" if clean == 0 else "  ← 基线即红，变异核验无意义"))
    if clean:
        bad.append("未变异基线即失败")
    for name, target, old, new, expect in _SRC_MUTATIONS:
        with _patched_ctx(target, old, new), \
                contextlib.redirect_stdout(io.StringIO()):
            fails = _run_groups()
        verdict = ("命中预期" if fails == expect
                   else "**红项数不符（预期 %d）**" % expect)
        print("  变异「%s」→ 红项=%d  %s" % (name, fails, verdict))
        if fails != expect:
            bad.append(name)
    print("\n定点变异自证：%s"
          % ("PASS（每处判据都有变异钉死，且红项数逐处吻合）" if not bad
             else "FAIL —— " + "、".join(bad)))
    return 0 if not bad else 1


def main() -> int:
    src = os.path.basename(os.path.abspath(__file__))
    if "--mutate" in sys.argv:
        print("!! 定点变异模式：逐个变异判据，套件应转红且红项数吻合\n")
        return _mutate_mode()
    anchor_bad = _anchor_check()
    if anchor_bad:
        for b in anchor_bad:
            print("  ANCHOR-MISS " + b)
        print("\n锚点自检：FAIL（fail-closed，exit 2）——实现改了请同步变异表/文案")
        return 2
    print("锚点自检：PASS（%s；不以 git HEAD 为基线源）" % src)
    for g in _GROUPS:
        g()
    print("\nissue50-d 守卫：%d 通过，%d 失败" % (len(_PASS), len(_FAIL)))
    if _FAIL:
        print("失败项：" + "、".join(_FAIL))
    return 0 if not _FAIL else 1


if __name__ == "__main__":
    sys.exit(main())