工程(对拍闸退役批): 删除回放确定性对拍闸及全部配套件——闸脚本6c段整删、PARITY_TOUCH_FACES改名CROSSCUT_TOUCH_FACES(02横切回落判定保留)、回执指纹NEED-APPROVAL分支清理、基线删11号条目、parity_anchor.py/parity_compare.py两件删除、evidence/parity锚删除、tests README能力行与工具行删行、adventure_monte_carlo台账行换代、架构文档闸清单删条件件与验收红线史句清理、待办清单数值窗口删对拍锚重锚句与触面粗粒度挂账行删、settle_segments_test头注去失指句——用户裁决:整局重放对拍代价不可承受,正确性由既有单测/集成/探针/渲染golden承载

tools/parity_anchor.py

@@ -1,203 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""parity_anchor.py — 「逐位一致对拍」锚工具（架构重构前后逐位一致验收；原需求卡已按「吸收即死」退役，凭据见 git 提交史）
-
-载体 = adventure_monte_carlo.gd 同种子批量完整局（SceneTree headless，自持 ConfigDB，零渲染）。
-三变体钉死（种子面错开，覆盖 base / 同调账 / 商店-GP 账三类 T2/T3 重构面）：
-  base   : -- 20 71000 both min off off off
-  attune : -- 20 72000 both min on  off off
-  shop   : -- 20 73000 both min off on  off
-
-锚双面：
-  A. RUNSUM 逐行块（stdout 局级摘要面，字符串列表原样入库 anchor.json——红灯时可打印首条差异行）；
-  B. playtest JSONL 全事件流（剔除带墙钟的 session/diagnosis 两类行；文件名本身带时间戳不入比对面）。
-比对口径 = 字节级逐位一致（同引擎二进制+同种子确定性，冻结前已实测两跑全同）。
-原始面不入库（体量 MB 级）：红灯取证用 dump 模式对重构前后各落一份原始数据再 diff——
-旧提交随时可重生成同字节原始面（确定性保证），锚只存 sha256 清单。
-
-用法:
-  python tools/parity_anchor.py freeze            # 冻结锚（重构前基线，写入 game/tests/evidence/parity/anchor.json）
-  python tools/parity_anchor.py check             # 对拍：重跑同参批，与锚逐位比对（全同退出 0，差异退出 1 并打印首差异）
-  python tools/parity_anchor.py dump --out DIR    # 只跑批落原始面到 DIR（红灯取证）
-  可选 --variants base,attune,shop / --quick（只跑 base）
-"""
-import argparse
-import hashlib
-import json
-import re
-import subprocess
-import sys
-import time
-from pathlib import Path
-
-from godot_user_dir import resolve_user_dir
-
-ROOT = Path(__file__).resolve().parent.parent
-GODOT = r"D:\code\godot\Godot_v4.7.2-stable_win64_console.exe"
-GAME_DIR = ROOT / "game"
-ANCHOR_PATH = ROOT / "game" / "tests" / "evidence" / "parity" / "anchor.json"
-USER_LOGS = resolve_user_dir(ROOT) / "logs"
-
-# 变体表：名字 → (seed0, attune, shop)。（N=20/策略 both/route min/feat off 全变体钉死。）
-VARIANTS = {
-    "base": (71000, "off", "off"),
-    "attune": (72000, "on", "off"),
-    "shop": (73000, "off", "on"),
-}
-N_RUNS = 20
-BATCH_RE = re.compile(r"^BATCH (\w+) N=(\d+) 终局计数=(.*) 日志=user://logs/(playtest_\d+_\S+\.jsonl)\s*$")
-TS_ROW_KINDS = ("session", "diagnosis")   # 带墙钟 ts 的两类行——剔出比对面
-
-
-def run_variant(name: str, seed0: int, attune: str, shop: str, timeout: int = 560):
-    """跑一个变体批，返回 (runsum_lines, {policy: jsonl绝对路径})。"""
-    before = set(p.name for p in USER_LOGS.glob("playtest_*.jsonl")) if USER_LOGS.is_dir() else set()
-    cmd = [GODOT, "--headless", "--path", str(GAME_DIR), "--script",
-           "res://sim/adventure_monte_carlo.gd", "--",
-           str(N_RUNS), str(seed0), "both", "min", attune, shop, "off"]
-    proc = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8",
-                          errors="replace", timeout=timeout)
-    out = (proc.stdout or "") + (proc.stderr or "")
-    runsum = [ln for ln in out.splitlines() if ln.startswith("RUNSUM ")]
-    logs = {}
-    for ln in out.splitlines():
-        m = BATCH_RE.match(ln)
-        if m:
-            logs[m.group(1)] = m.group(4)
-    after = set(p.name for p in USER_LOGS.glob("playtest_*.jsonl")) if USER_LOGS.is_dir() else set()
-    fresh = after - before
-    resolved = {}
-    for policy, fname in logs.items():
-        p = USER_LOGS / fname
-        if p.is_file():
-            resolved[policy] = p
-        else:
-            cand = [f for f in fresh if f.startswith("playtest_%d_" % seed0)]
-            if len(cand) == 1:
-                resolved[policy] = USER_LOGS / cand[0]
-            else:
-                print("[parity] FAIL：变体 %s 的 %s 日志文件定位失败（fresh=%s）" % (name, policy, cand))
-                sys.exit(2)
-    expected_policies = 2
-    if len(runsum) != N_RUNS * expected_policies or len(resolved) != expected_policies:
-        print("[parity] FAIL：变体 %s 产出不完整（RUNSUM %d 行 / 日志 %d 份）" % (name, len(runsum), len(resolved)))
-        print(out[-3000:])
-        sys.exit(2)
-    return runsum, resolved
-
-
-def filter_jsonl(path: Path) -> bytes:
-    """剔除带 ts 行，保留原始字节行序（bit-exact；不做任何再序列化）。"""
-    kept = []
-    with open(path, "rb") as f:
-        for raw in f.read().split(b"\n"):
-            if not raw.strip():
-                continue
-            head = raw[:48]
-            if any(('{"kind":"%s"' % k).encode() in head for k in TS_ROW_KINDS):
-                continue
-            kept.append(raw)
-    return b"\n".join(kept) + b"\n"
-
-
-def collect(variants, quick=False):
-    if quick:
-        variants = [v for v in variants if v == "base"] or ["base"]
-    data = {}
-    for v in variants:
-        seed0, attune, shop = VARIANTS[v]
-        t0 = time.time()
-        print("[parity] 跑批 %s（N=%d×2 策略，seed0=%d，attune=%s，shop=%s）…" % (v, N_RUNS, seed0, attune, shop))
-        runsum, logs = run_variant(v, seed0, attune, shop)
-        faces = {"runsum": runsum, "jsonl": {}}
-        for policy in sorted(logs):
-            body = filter_jsonl(logs[policy])
-            faces["jsonl"][policy] = {
-                "sha256": hashlib.sha256(body).hexdigest(),
-                "rows": body.count(b"\n"),
-            }
-        data[v] = faces
-        print("[parity]   %s 完成（%.0fs，RUNSUM %d 行，JSONL %s）" %
-              (v, time.time() - t0, len(runsum),
-               ", ".join("%s=%s" % (p, faces["jsonl"][p]["sha256"][:12]) for p in sorted(faces["jsonl"]))))
-    return data
-
-
-def dump_variant_raw(variants, outdir: Path):
-    outdir.mkdir(parents=True, exist_ok=True)
-    for v in variants:
-        seed0, attune, shop = VARIANTS[v]
-        runsum, logs = run_variant(v, seed0, attune, shop)
-        (outdir / ("%s_runsum.txt" % v)).write_text("\n".join(runsum) + "\n", encoding="utf-8", newline="\n")
-        for policy, p in logs.items():
-            (outdir / ("%s_%s.jsonl" % (v, policy))).write_bytes(filter_jsonl(p))
-        print("[parity] dump %s → %s" % (v, outdir))
-
-
-def main():
-    if hasattr(sys.stdout, "reconfigure"):
-        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-    ap = argparse.ArgumentParser(description="迭代27重构逐位一致对拍锚")
-    ap.add_argument("mode", choices=["freeze", "check", "dump"])
-    ap.add_argument("--variants", default="base,attune,shop")
-    ap.add_argument("--quick", action="store_true", help="只跑 base 变体")
-    ap.add_argument("--out", default="", help="dump 模式输出目录")
-    args = ap.parse_args()
-    variants = [v.strip() for v in args.variants.split(",") if v.strip() in VARIANTS]
-    if not variants:
-        print("[parity] FAIL：无有效变体（可选 %s）" % list(VARIANTS))
-        return 2
-
-    if args.mode == "dump":
-        dump_variant_raw(variants, Path(args.out if args.out else str(ROOT / "tools" / "parity_dump")))
-        return 0
-
-    data = collect(variants, quick=args.quick)
-
-    if args.mode == "freeze":
-        ANCHOR_PATH.parent.mkdir(parents=True, exist_ok=True)
-        anchor = {"variants": {v: data[v] for v in variants}}
-        ANCHOR_PATH.write_text(json.dumps(anchor, ensure_ascii=False, indent=1), encoding="utf-8", newline="\n")
-        print("[parity] 锚已冻结 → %s（变体 %s）" % (ANCHOR_PATH, variants))
-        return 0
-
-    # check
-    if not ANCHOR_PATH.is_file():
-        print("[parity] FAIL：锚不存在（先 freeze）→ %s" % ANCHOR_PATH)
-        return 2
-    anchor = json.loads(ANCHOR_PATH.read_text(encoding="utf-8"))
-    bad = 0
-    for v in variants:
-        if v not in anchor["variants"]:
-            print("[parity] FAIL：锚无变体 %s（锚含 %s）" % (v, list(anchor["variants"])))
-            bad += 1
-            continue
-        old = anchor["variants"][v]
-        new = data[v]
-        if old["runsum"] != new["runsum"]:
-            bad += 1
-            print("[parity] ✗ %s RUNSUM 漂移（%d 行 vs %d 行）" % (v, len(old["runsum"]), len(new["runsum"])))
-            for i, (a, b) in enumerate(zip(old["runsum"], new["runsum"])):
-                if a != b:
-                    print("[parity]   首差异第 %d 行：" % i)
-                    print("[parity]   锚: %s" % a[:600])
-                    print("[parity]   今: %s" % b[:600])
-                    break
-        for policy in sorted(old["jsonl"]):
-            o, n = old["jsonl"][policy], new["jsonl"].get(policy)
-            if n is None:
-                bad += 1
-                print("[parity] ✗ %s/%s 本次缺日志" % (v, policy))
-            elif o["sha256"] != n["sha256"]:
-                bad += 1
-                print("[parity] ✗ %s/%s JSONL 逐位漂移（锚 %s… 行数 %d vs 今 %s… 行数 %d）" %
-                      (v, policy, o["sha256"][:12], o["rows"], n["sha256"][:12], n["rows"]))
-    if bad:
-        print("[parity] 逐位一致对拍 ✗ 失败 %d 项——该波回炉（V1 红线）" % bad)
-        return 1
-    print("[parity] 逐位一致对拍 ✓ 全同（变体 %s，RUNSUM+JSONL 双面逐位一致）" % variants)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

tools/parity_compare.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""V12 同种子复放比对器（卡② 效果引擎无状态化批）：解析两次 MC 采集的 RUNSUM 行按 seed 配对判读。
-两判据模式——parity：整条记录逐位相等（off 组，未受影响路径须透明）；
-input-parity：输入面八字段 + 顶层字段集恒等、种子集与局数一致（formed/rules 组，输出面允许 RNG 级联位移）。
-退出码 0 绿 / 1 红 / 2 用法或解析错。字段集从基线文件推导，禁硬编码。"""
-import sys, json, argparse
-
-INPUT_KEYS = ["policy", "seed", "atk_pct", "hp_pct", "route", "attune", "equipped", "feat_mode"]
-
-
-def load(path):
-    recs = {}
-    with open(path, encoding="utf-8") as f:
-        for line in f:
-            line = line.strip()
-            if not line.startswith("RUNSUM "):
-                continue
-            try:
-                d = json.loads(line[len("RUNSUM "):])
-            except json.JSONDecodeError:
-                print("解析失败行:", line[:80])
-                sys.exit(2)
-            recs[d.get("seed")] = d
-    return recs
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--mode", choices=["parity", "input-parity"], required=True)
-    ap.add_argument("--base", required=True)
-    ap.add_argument("--post", required=True)
-    ap.add_argument("--expect", type=int, required=True)
-    a = ap.parse_args()
-    base, post = load(a.base), load(a.post)
-    if len(base) != a.expect or len(post) != a.expect:
-        print("局数不符：base=%d post=%d expect=%d" % (len(base), len(post), a.expect))
-        return 1
-    if set(base) != set(post):
-        print("种子集不一致")
-        return 1
-    red = False
-    if a.mode == "parity":
-        diff = [s for s in base if base[s] != post[s]]
-        if diff:
-            red = True
-            print("off 组逐位差异 %d 局: %s" % (len(diff), diff[:10]))
-            for s in diff[:3]:
-                k = [kk for kk in base[s] if base[s].get(kk) != post[s].get(kk)]
-                print("  seed", s, "差异字段:", k)
-    else:
-        bkeys = set(next(iter(base.values())).keys())
-        pkeys = set(next(iter(post.values())).keys())
-        if bkeys != pkeys:
-            red = True
-            print("顶层字段集不一致 base-p=%s post-b=%s" % (bkeys - pkeys, pkeys - bkeys))
-        for s in base:
-            for kk in INPUT_KEYS:
-                if base[s].get(kk) != post[s].get(kk):
-                    red = True
-                    print("输入面字段 %s 在 seed %s 不一致: %r vs %r" % (kk, s, base[s].get(kk), post[s].get(kk)))
-        # levels_cleared 直方图仅报告（方向不作判据）
-        lc = post[s].get("levels_cleared") if post else None
-    print("判读：%s" % ("FAIL" if red else "PASS"))
-    return 1 if red else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

tools/run_all_gates.sh

@@ -12,7 +12,7 @@
 #
 # 用法：tools/run_all_gates.sh [--code|--docs|--quick]
 #   --code  只跑代码域闸（00 冒烟测试／01 系统测试／02 单元与集成测试／03 探针 --click／
-#           04 探针 --full／05 渲染闸／09 静态扫描／11 回放确定性对拍＋10 熵增闸）
+#           04 探针 --full／05 渲染闸／09 静态扫描＋10 熵增闸）
 #           ——本批改动含 game/ 下非 .md 的行为载体（代码/测试脚本/探针/场景/数据表/素材）时用。
 #           关联档选闸（2026-10-29 用户裁，推广自 2026-10-28 影响面选闸）：00 冒烟／01 系统测试／
 #           09 静态扫描三件保险恒跑不降；03/04 探针与 05 渲染闸维持影响面口径（本批 game/ 改动
@@ -35,7 +35,7 @@
 #   基线红 + 现红且清单未变 → 「存量红·对基线零新增」，不判失败（但会在回执里留名）
 #   基线红 + 现红但清单新增 → 红（新增红项）
 #   任意闸 exit 与基线不符 → 红
-#   本次未跑的闸（--quick 跳过／条件闸件未触面）→ 不比闸况，只记进回执 not_run
+#   本次未跑的闸（--quick 跳过／影响面选闸 SKIP）→ 不比闸况，只记进回执 not_run
 # 基线文件首次自动生成（把当次结果当基线），此后每次跑批与之比。
 # 分域跑批只比本域跑过的闸——域外闸不入 NAMES，不产生「基线绿 → 现红」的假变化。
 #
@@ -157,8 +157,8 @@ fi
 declare -a NAMES=() EXITS=() LOGS=()
 FAILED=0
 
-# PARITY 触面表——gate 11 数值·存档·RNG·结算触面判定与关联档横切判定共用同一清单（单点定义，勿在别处复制）。
-PARITY_TOUCH_FACES="
+# 横切触面表——关联档选闸的横切回落判定清单（数值·存档·RNG·结算触面；单点定义，勿在别处复制）。
+CROSSCUT_TOUCH_FACES="
 game/data/tables/
 game/core/rng_service.gd
 game/core/save_manager.gd
@@ -173,7 +173,7 @@ game/sim/adventure_monte_carlo.gd
 # ── 套件族映射表（关联档·推导半边的唯一事实源）──
 # game/ 代码面文件 → tests/ 套件族词（--only 子串词，词＝套件目录名）。机械近似：同族内
 # 套件覆盖面仍可能宽于被测文件，保守方向＝宁多勿漏。横切判定（公共件前缀／project.godot／
-# PARITY 触面表）先于本表执行，故表中不收 damage_math／damage_controller／battle_orchestrator／
+# 横切触面表）先于本表执行，故表中不收 damage_math／damage_controller／battle_orchestrator／
 # settlement/** 等数值·存档·RNG·结算触面文件——它们恒走横切回落全量。映射不到的文件返回空＝横切处理。
 suite_terms_for() {   # suite_terms_for <仓库相对路径> → stdout: 套件族词（空格分隔，可空）
 	case "$1" in
@@ -217,7 +217,7 @@ suite_terms_for() {   # suite_terms_for <仓库相对路径> → stdout: 套件
 }
 
 # ── 关联档选闸（2026-10-29 用户裁，推广自 2026-10-28 影响面选闸）──
-# 三件保险恒跑不降：00 冒烟／01 系统测试／09 静态扫描（10 熵增闸照旧两域都跑，11 数值·存档·RNG·结算触面判定照旧）。
+# 三件保险恒跑不降：00 冒烟／01 系统测试／09 静态扫描（10 熵增闸照旧两域都跑）。
 # 03/04 探针与 05 渲染闸维持影响面口径：本批 diff 相对 master 分叉点的 game/ 改动若全部落在
 # 测量面（game/tests/**、game/sim/**——测试与模拟驱动件，不触场景树与渲染输出）则记 SKIP。
 # 02 单元与集成改「选套件跑」：套件集＝申报 ∪ 推导 取并集——
@@ -228,7 +228,7 @@ suite_terms_for() {   # suite_terms_for <仓库相对路径> → stdout: 套件
 #         映射不到的文件一律按横切处理。
 #   横切回落全量：diff 命中 game/data/tables/**、公共件前缀（config_db*/rng_service*/
 #         save_manager*/meta_progression*/main*——main* 覆盖组合根拆件与主场景）、
-#         autoload 注册面（game/project.godot）、或下方 PARITY 触面表任一 → 02 跑全部套件。
+#         autoload 注册面（game/project.godot）、或下方横切触面表任一 → 02 跑全部套件。
 # 测量面批（game/ 改动全在 tests/sim）：02 照旧全套件跑（不加过滤）。
 # 回执 scope 字段：full｜related（02 跑子集＝related）；映射表只在本脚本一处定义。
 NONBEHAVIOR=0
@@ -257,7 +257,7 @@ if in_domain code; then
 					CROSSCUT=1; break ;;
 			esac
 			[ "$_f" = "game/project.godot" ] && { CROSSCUT=1; break; }   # autoload 注册面
-			for _pat in $PARITY_TOUCH_FACES; do
+			for _pat in $CROSSCUT_TOUCH_FACES; do
 				case "$_f" in
 					"$_pat"*) CROSSCUT=1; break 2 ;;
 				esac
@@ -392,35 +392,6 @@ gate "08d 引用可核" "doc_ref.log" "$PY" "$REPO/tools/doc_ref_audit.py" --str
 # ── 8e. 能力审计（GDD 纯度＋能力清单与覆盖域表结构，判据=test-conventions §8.9＋doc-conventions §5）──
 gate "08e 能力审计" "capability.log" "$PY" "$REPO/tools/capability_audit.py" --strict
 fi
-# ── 6c. 回放确定性对拍（条件闸件；属代码域）──
-if in_domain code; then
-# 触面判定：本批 diff 相对 master 分叉点，命中 PARITY_TOUCH_FACES（脚本上部单点定义）之一即「触面」。
-# 触面也**不自动跑**——对拍调的是 MC 脚本，属「MC/统计类跑批发起前须用户批准」红线管辖；
-# 闸只负责每次跑批都把触面判定做一遍并显式要求批准，杜绝「该跑却没人记得」。
-# 用户批准后设 PARITY_APPROVED=1 重跑本脚本即实跑三变体对拍。
-_base="$(git -C "$REPO" merge-base master HEAD 2>/dev/null || true)"
-_changed_files="$(git -C "$REPO" diff --name-only "${_base:-HEAD}" HEAD 2>/dev/null || true)"
-_touch_hit=0
-for _f in $_changed_files; do
-	for _pat in $PARITY_TOUCH_FACES; do
-		case "$_f" in
-			"$_pat"*) _touch_hit=1 ;;
-		esac
-	done
-done
-_parity_name="11 回放确定性对拍"
-if [ "$_touch_hit" -eq 0 ]; then
-	NAMES+=("$_parity_name"); EXITS+=("SKIP"); LOGS+=("")
-	echo ""; echo "[gates] $_parity_name → SKIP（本批 diff 未触数值/存档/RNG/结算面）"
-elif [ "${PARITY_APPROVED:-0}" = "1" ]; then
-	gate "$_parity_name" "parity.log" "$PY" "$REPO/tools/parity_anchor.py" check
-else
-	NAMES+=("$_parity_name"); EXITS+=("NEED-APPROVAL"); LOGS+=("")
-	echo ""
-	echo "[gates] $_parity_name → 本批 diff 触及数值/存档/RNG/结算面，对拍需用户批准发起"
-	echo "         （批准后设 PARITY_APPROVED=1 重跑本脚本即实跑；不得借机重锚）"
-fi
-fi
 
 # ── 7. 静态扫描（代码域）+ 熵增闸（两域都跑：它查顶层目录/根文件/图像白名单/退役路径，
 #      文档批新增或挪动 design/ 下的文件同样会绊它；纯文本扫描，秒级）──
@@ -471,9 +442,9 @@ def fingerprint(exit_code, log):
     """红项指纹：只取 exit!=0 时的 FAIL 关键行集合，忽略时序/耗时噪声
     （超时挂死行的 pid=NNN 随跑批变化，归一化为 pid=N 后再入哈希——否则存量红指纹逐轮漂移）。
     绿闸一律记 'green'——绿闸日志里的「零红」「全绿」等字样不是红项，采进来只会造噪声。"""
-    # SKIP / NEED-APPROVAL 都属「本闸未实跑」状态，指纹一律记 skip——
-    # 两者互变不是闸况变化（同是没跑），只有「未跑 → 跑出结果」或「绿 → 红」才算变化。
-    if exit_code in ("0", "SKIP", "NEED-APPROVAL"):
+    # SKIP 属「本闸未实跑」状态（--quick／影响面选闸），指纹一律记 skip——
+    # 没跑不是闸况变化，只有「未跑 → 跑出结果」或「绿 → 红」才算变化。
+    if exit_code in ("0", "SKIP"):
         return "green" if exit_code == "0" else "skip"
     if not log:
         return "red-nolog"
@@ -514,7 +485,7 @@ for n in names:
     if b["exit"] == c["exit"] and b["fp"] == c["fp"]:
         continue
     if c["fp"] == "skip":
-        # 本闸这次没跑（--quick 跳过／条件闸件未触面）——没有结果可比，不判闸况变化。
+        # 本闸这次没跑（--quick 跳过／影响面选闸 SKIP）——没有结果可比，不判闸况变化。
         # SKIP 不得落进「基线绿 → 现红」分支——否则任何 --quick 回执都自带假红。
         not_run.append(n)
         continue