iter41-卡2：呈现层结构收敛批：67清＋2豁免＋2展平改善——拆私有族＋六状态件＋ui_kit收敛＋束收拢＋print删；含u14补做、并master并案与收尾产出物

game/tests/README.md

@@ -43,17 +43,72 @@ tests/
 > **分层判据**：能不能在 `--script` 模式下不加载 autoload 就验完？能 = 单元测试；
 > 需要两个以上真实系统协同并走落盘/落库 = 集成测试；需要完整项目引导与场景树 = 冒烟／系统／UI 探针。
 
-**集成旅程清单**（2026-10-28 立——跨域旅程用例的登记处：一个行为穿过多个领域的对外方法＝旅程，验收落本层；缺口旅程由属主批/工程债批按批落用例后回填本表）：
+**能力清单 v1**（2026-10-28 立——验证与清单体系整改阶段 1 的覆盖索引：一行＝一个玩家或系统可观测的能力，代表用例只给指针、不复制断言细节；原「集成旅程清单」五条跨系统旅程已并入本表。首期覆盖核心四域（29 行）＋跨域条件闸 1 行，共 30 行；其余域按同一形态扩面）：
 
-| 旅程 | 涉及边界 | 现行覆盖 | 缺口 | 登记批 |
-|---|---|---|---|---|
-| 存档⇄RNG 快照往返保真 | SaveManager×AdventureRunner×RngService | `save_rng_roundtrip_test.gd` 用例一（闸 02） | — | 迭代 29 T3 |
-| 旧档迁移后断点续玩零跳号 | SaveManager 迁移链×AdventureRunner×BoardGenerator | `save_rng_roundtrip_test.gd` 用例二（闸 02） | — | 迭代 29 T3 |
-| 断点附随件与事件日志会话 | AdventureRunner×SaveManager×日志面 | `cross_system_flow_test.gd`（闸 02） | 盘点候选 | 断言迁移批（2026-10-23） |
-| 关卡图断点重生成同图/生成图确定性 | LevelRunner×节点图生成器×AdventureRunner | `node_map_determinism_test.gd`（闸 02） | — | 断言迁移批（2026-10-23，迭代 35 卡②随动换代） |
-| 回放确定性（同种子逐位） | 全玩法链 | `parity_anchor.py`（闸 11 条件闸） | — | 迭代 29 T3 收编为条件闸件 |
+> **与验证集清单的关系**：`tests/验证集清单.md` 已于阶段 2「存量断言精简」完成后删除——冻结对账基准（基点 `b9260138`／1587 条）与精简对账结果（33 站点并为 7、1587→1561，合回 `87d241c1`）留 git 历史。本表是该清单退役后的唯一覆盖索引（维护锚＝test-conventions §8.3）。本表不是闸，不替代改动—验收对照表、体验验证清单与静态纪律；每行的唯一事实源仍是 `game/tests/` 下的测试代码。
+>
+> **代表用例口径**：写 `文件:函数`，每行 2–3 个；函数内可含 `Kit.check_quiet` 静默通道（逐断言提取器口径外，test-conventions §5.2 已备案）——本表以函数为锚，不受该工具局限影响。
+>
+> **维护规则（每批收口核对本批受影响行）**：本批改到哪个能力，收口时核对该行代表用例可 grep、在本批真实跑批中执行、真实入口未绕过改动点，并把「最后验证批次」刷新为本批回执；新增能力加行，能力退役删行。全表核对频率与抽样规则归阶段 3。首期未覆盖：排雷循环（棋盘生成／排雷玩法／行动经济）、表现与支撑（HUD／主题／字体／地形瓦片／模态）、数据配置与跨系统契约——按同一形态后续扩面。
+>
+> **旅程补录方法**：新旅程＝加一行，「系统」列写涉及边界；源＝architecture「API 边界」表＋「数据流」存档/读档路径＋各 GDD 登记的 deferral 集成用例。
+>
+> 「最后验证批次」列记回执 commit；多数行初值 `20c13c3a`＝存量断言精简 A+B 首批的全量域闸回执，RNG 行随 C 档批刷新为 `fd6cf968`。
 
-候选旅程盘点方法：源＝architecture「API 边界」表逐行＋「数据流」存档/读档路径＋各 GDD 登记的 deferral 集成用例；新旅程先登记「缺口」列，用例按批落地后回填「现行覆盖」。
+**旅程段一：开机与存档**
+
+| 能力 | 系统 | 真实入口 | 代表用例（文件:函数） | 最后验证批次 | 缺口 |
+|---|---|---|---|---|---|
+| 存档写盘⇄读回往返保真 | 存档序列化 | `SaveManagerCore.write_to_disk()`／`load_from_disk()` | `save_manager_domain_test.gd:_smoke_save` | `20c13c3a` | — |
+| 三槽位隔离与激活失败回滚 | 存档序列化 | `SaveManagerCore.activate_slot()`／`create_slot()`／`delete_slot()` | `save_slot_isolation_test.gd:_test_three_slot_roundtrip_and_isolation`；`save_slot_isolation_test.gd:_test_activate_failure_restores_previous_slot` | `20c13c3a` | — |
+| 槽位摘要窥视与坏槽三态 | 存档序列化 | `SaveManagerCore.peek_slot_summary()` | `save_slot_summary_test.gd:_test_peek_three_slots_distinct_values`；`save_slot_summary_test.gd:_test_peek_empty_and_unreadable_states`；`save_slot_summary_test.gd:_test_peek_zero_side_effect` | `20c13c3a` | — |
+| 启动态无激活不写盘 | 存档序列化 | `SaveManagerCore.has_write_target()`／`write_to_disk()` | `save_boot_no_activate_test.gd:_test_write_rejected_without_target`；`save_boot_no_activate_test.gd:_test_out_of_range_slots_rejected` | `20c13c3a` | — |
+| 旧档迁移链与断点续玩零跳号（集成） | 存档序列化×冒险结构 | `SaveManagerCore.load_from_disk()`（内置迁移链）× `AdventureRunner.resume_adventure()` | `save_rng_roundtrip_test.gd:_test_old_version_save_migrates_and_resumes` | `20c13c3a` | — |
+| 存档⇄RNG 快照往返保真（集成） | 存档序列化×RNG 服务×冒险结构 | `AdventureRunner.start_adventure()` → `SaveManagerCore.write_to_disk()`／`load_from_disk()` | `save_rng_roundtrip_test.gd:_test_disk_roundtrip_preserves_breakpoint` | `20c13c3a` | — |
+| RNG 统一流派生与取号账本 | RNG 服务 | `RngServiceCore.derive_at()`／`open_stream()`／`counter()` | `rng_service_test.gd:_test_derive_determinism`；`rng_service_test.gd:_test_stream_draw_determinism`；`rng_stream_boot_test.gd:_smoke_initialize` | `fd6cf968` | — |
+| 断点片段往返与续玩幂等 | 冒险结构×关卡节点地图 | `LevelRunner.breakpoint_fragment()`／`restore_fragment()`；`AdventureRunner.resume_adventure()` | `breakpoint_resume_test.gd:_init` | `20c13c3a` | — |
+| 跨系统附随面：事件日志落盘与断点附随件（集成） | RNG 服务×存档序列化×冒险结构 | `RngServiceCore.new_adventure()`（开事件日志会话）；`SaveManagerCore.breakpoint_snapshot()`（断点附随键） | `cross_system_flow_test.gd:_rng_event_log_session`；`cross_system_flow_test.gd:_feats_breakpoint_roundtrip` | `20c13c3a` | 日志面仅此一条会话覆盖 |
+
+**旅程段二：冒险开局与选路**
+
+| 能力 | 系统 | 真实入口 | 代表用例（文件:函数） | 最后验证批次 | 缺口 |
+|---|---|---|---|---|---|
+| 冒险生命周期：开局受理／三关序列／败北线 | 冒险结构 | `AdventureRunner.start_adventure()`／`continue_to_next_level()` | `adventure_feats_test.gd:_smoke_adventure_api`；`adventure_feats_test.gd:_smoke_adventure` | `20c13c3a` | — |
+| 专长（奇物）授予与凭证保底 | 奇物 | `AdventureRunner.present_node_curio()`／`feats_held()` × 效果引擎兑付 | `adventure_feats_test.gd:_smoke_feats`；`feat_vouchers_test.gd:_init` | `20c13c3a` | — |
+| 节点图生成合法性与同种子复现 | 关卡节点图生成 | `NodeMapGenerator.generate()`／`validate_output()` | `node_map_generator_test.gd:_test_output_ok`；`node_map_generator_test.gd:_test_reproducible`；`node_map_generator_test.gd:_test_exit_structure` | `20c13c3a` | — |
+| 节点图生长递增与无解 fail-fast | 关卡节点图生成 | `NodeMapGenerator.generate()`／`is_fatal()` | `node_map_growth_test.gd:_test_growth`；`node_map_growth_test.gd:_test_fatal_subprocess` | `20c13c3a` | — |
+| 起关／选路／断点重生成同图（集成） | 关卡节点地图×关卡节点图生成×冒险结构 | `LevelRunner.start_level()`／`start_level_external()`／`pick_next_node()`；`AdventureRunner.resume_adventure()` | `node_map_determinism_test.gd:_smoke_generated_map_determinism` | `20c13c3a` | — |
+| 信息迷雾类型可见性 | 关卡节点地图 | `LevelRunner.type_visible_ids()` | `level_map_type_vis_test.gd:_test_layer_distance`；`level_map_type_vis_test.gd:_test_boss_exempt`；`level_map_type_vis_test.gd:_test_resume_rebuild` | `20c13c3a` | — |
+| 关卡表消费侧校验与关卡推进 | 关卡节点地图×数据配置 | `LevelTable.validate_graph()`；`LevelRunner.start_level()` | `level_table_validate_test.gd:_test_positive`；`level_table_validate_test.gd:_test_negative`；`level_shop_economy_test.gd:_smoke_level` | `20c13c3a` | — |
+
+**旅程段三：战斗结算**
+
+| 能力 | 系统 | 真实入口 | 代表用例（文件:函数） | 最后验证批次 | 缺口 |
+|---|---|---|---|---|---|
+| 伤害公式与掷点乘区 | 战斗结算 | `DamageMath.pool_damage()`／`roll_discount_percent()`／`rolled_component()` | `damage_math_test.gd:_test_pool_damage`；`damage_math_test.gd:_test_roll_discount_percent`；`roll_multiplier_test.gd:_smoke_armor_roll` | `20c13c3a` | — |
+| 伤害单据编排与回放 | 战斗结算 | `DamageController.submit()`／`open_ticket()`／`flush()` | `damage_controller_test.gd:_run_recipe_sequence`；`damage_controller_test.gd:_test_five_recipes_and_replay` | `20c13c3a` | — |
+| 轮内流与结算五段全序 | 战斗结算 | `BattleOrchestrator.begin_battle()` | `round_flow_skill_pool_test.gd:_smoke_full_battle`；`round_flow_skill_pool_test.gd:_smoke_settlement_segments` | `20c13c3a` | — |
+| 技能池数据面与回放独立 | 敌人系统 | `BattleOrchestrator.begin_battle()`（技能池抽号／校验） | `round_flow_skill_pool_test.gd:_smoke_skill_pool_data`；`round_flow_skill_pool_test.gd:_smoke_skill_pool_replay_independence` | `20c13c3a` | — |
+| Boss 半血解锁技门控 | 敌人系统 | `BattleOrchestrator.begin_battle()`（Boss 行） | `skill_unlock_test.gd:_test_gate_predicate`；`skill_unlock_test.gd:_test_latch_irreversible` | `20c13c3a` | — |
+| 封印与极性路由／不可逆 | 地图战斗资源×战斗结算 | 效果引擎 × `BattleOrchestrator.begin_battle()` | `seal_polarity_test.gd:_smoke_seal_ap_exhausted`；`seal_polarity_test.gd:_smoke_seal_irreversible_quadrants`；`seal_polarity_test.gd:_smoke_polarity_routing` | `20c13c3a` | — |
+| 变异布置门控 | 地形变异 | `BattleOrchestrator.begin_battle()`（变异布置段） | `variant_placement_test.gd:_smoke_variant_placement`；`variant_placement_test.gd:_smoke_global_variant` | `20c13c3a` | — |
+
+**旅程段四：奖励、经济与局外成长**
+
+| 能力 | 系统 | 真实入口 | 代表用例（文件:函数） | 最后验证批次 | 缺口 |
+|---|---|---|---|---|---|
+| 清图奖励双份与零路径 | 地图战斗资源 | `BattleOrchestrator.begin_battle()` → 步骤流行（`source_class=clear_reward`） | `seal_polarity_test.gd:_smoke_clear_reward_chain`；`seal_polarity_test.gd:_smoke_clear_reward_zero_paths` | `20c13c3a` | — |
+| 奖励三选一候选／刷新付费／呈现 | 奇物×节点奖励屏 | `AdventureRunner.present_node_curio()`（数据面）；奖励节点覆盖层场景（呈现面） | `curio_refresh_paid_test.gd:_init`；`reward_overlay_test.gd:_run` | `20c13c3a` | — |
+| GP 钱包／escrow／商店收口／共享池 | 地图战斗资源×商店 | `LevelRunner.buy_product()`／`player_request_refresh()`／`close_wallet()`／`set_shop_pool()` | `level_shop_economy_test.gd:_smoke_gp_wallet`；`level_shop_economy_test.gd:_smoke_shop_room`；`level_shop_economy_test.gd:_smoke_shop_pool` | `20c13c3a` | — |
+| 元进度入账与锻造两轴 | 元进度×锻造工坊 | `SaveManagerCore.add_keystone()`／`spend_keystone()`／`set_forge_route_level()` | `meta_progression_forge_test.gd:_meta_pricing_and_buy`；`meta_progression_forge_test.gd:_smoke_forge_axes` | `20c13c3a` | — |
+| 天赋树购买与六键合成 | 天赋树 | `SaveManagerCore.tree_nodes()`／`set_tree_level()` | `meta_progression_forge_test.gd:_smoke_tree`；`meta_progression_forge_test.gd:_smoke_tree_rules`；`tree_rules_v11_test.gd:_init` | `20c13c3a` | — |
+| 秘宝结构冻结与 12 件效果 | 秘宝 | `TreasureItems.add_item()`／`query_inventory()`／`validate_use()` | `treasure_items_test.gd:_init`；`treasure_effects_test.gd:_init` | `20c13c3a` | — |
+
+**跨域条件闸**
+
+| 能力 | 系统 | 真实入口 | 代表用例 | 最后验证批次 | 缺口 |
+|---|---|---|---|---|---|
+| 回放确定性（同种子三变体逐位） | 全玩法链 | `tools/parity_anchor.py`（闸 11 条件闸，按批发起） | `tools/parity_anchor.py`（整件为条件闸） | —（条件闸） | 条件闸未随本批执行 |
 
 ## 断言计数双口径（2026-10-08 迭代 19 卡① T4 订正）
 
@@ -70,7 +125,7 @@ tests/
 |---|---|---|---|
 | `tools/run_smoke.py`（冒烟测试） | 这版能否启动、能否加载表、能否进主屏——零逻辑判定 | 退出码＋脚本错误扫描 | 开机路径／表加载改动后的快速自检；收口由闸编排 |
 | `tools/run_system_test.py`（系统测试） | 真实玩法路径的行为断言面（推理→战斗→结算→进度推进） | 退出码＋脚本错误扫描 | 玩法链路改动的调试期确认 |
-| `tests/run_all.gd`（单元与集成） | 公式／状态机／契约／跨系统闭环（64 套件 manifest） | 退出码＋三硬闸（见下） | 新套件单跑调试；逻辑改动的最小单元复跑；开发期选跑——追加 `-- --only=<词[,词…]>` 只跑路径命中词的套件（零命中＝用法错 exit 2；选跑态仅供开发期最窄确认，不产闸回执、不作验收凭据） |
+| `tests/run_all.gd`（单元与集成） | 公式／状态机／契约／跨系统闭环（64 套件 manifest） | 退出码＋三硬闸（见下）；每套件子进程带截止时间守护——超时先 taskkill /T 整树回收再判该套件 FAIL、批继续（默认 120s，环境变量 `RUN_ALL_SUITE_TIMEOUT_SEC` 可覆盖） | 新套件单跑调试；逻辑改动的最小单元复跑；开发期选跑——追加 `-- --only=<词[,词…]>` 只跑路径命中词的套件（零命中＝用法错 exit 2；选跑态仅供开发期最窄确认，不产闸回执、不作验收凭据） |
 | `tools/probe_gate.sh`（场景探针，`--click`／`--full` 两模式） | UI 可达性、可见性、状态——真实实例化场景＋真实输入路径 | 探针自检＋退出码 | 新增 UI 区域的配套探针直跑与断言复核 |
 | `tools/render_gate.sh`（渲染 golden） | 画面基线——截图与基线图逐像素容差比对 | golden 比对脚本（依赖 PIL） | 主题／素材／排版类改动；窗口化运行，需开显示器 |
 | `game/tests/static_scan.sh`（S 域） | 项目纪律＋第三方质量规则：RNG 单点／core 纯度／类型标注／文件头／注释禁词／旧符号残留；S13＝gdstyle 质量规则（重复 load、循环内 await、循环内分配、不可达代码等真缺陷类；基线键＝文件|规则|函数名（类/文件级＝文件|规则，无数字条目带消息），数字漂移不假红，同键指标恶化超基线登记值即红） | 退出码（逐规则 FAIL 行） | 改产品码前后的快速自检；新增纪律先补扫描规则再修码 |
@@ -96,8 +151,9 @@ python tools/run_system_test.py
 # 场景探针（UI 探针层）——以探针场景为运行目标，走完整项目引导（autoload 在位）
 godot --headless --path . res://probe/<probe>.tscn
 
-# 本地闸必须配外部 wall-clock 超时（引擎无死锁探测；run_all_gates.sh 已内置）
-timeout 120s godot --headless --script tests/run_all.gd
+# 挂死防护内建于 run_all.gd（引擎无死锁探测，超时靠外部判）：每套件子进程带截止时间——
+# 默认 120s，环境变量 RUN_ALL_SUITE_TIMEOUT_SEC 可覆盖；超时先 taskkill /T 整树回收
+#（cmd wrapper 连引擎孙进程一起杀，不留孤儿），该套件判 FAIL、批继续——单套件挂死不拖死整闸
 ```
 
 > 套件 manifest 现况：`_suites()` 登记 **64 条**（61 单元＋3 集成，2026-10-28 实数；口径＝manifest 条目数，

game/tests/integration/cross_system_flow_test.gd

@@ -73,8 +73,8 @@ func _feats_breakpoint_roundtrip() -> void:
 		{"feat_id": "x5", "display_name": "试五", "rarity": "legendary", "desc": "测试AC", "cap": 1,
 			"triggers": [{"on": "seal_hit", "do": {"kind": "ac_bonus", "value": 1, "mode": "round"}}]},
 	]
-	var live_rows: FeatTable = _db.feats
-	_db.feats = rt
+	var live_rows: FeatTable = _db.crossrun.feats
+	_db.crossrun.feats = rt
 	var a_r = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(72))
 	a_r.start_adventure(72)   # 源 :723（受理断言留单元宿主）
 	a_r.stop()._pending = {"candidates": [{"kind": "relic", "tier": "rare", "feat_id": "x3"}, {"kind": "gp", "tier": "common"}], "payload": {}}
@@ -98,7 +98,7 @@ func _feats_breakpoint_roundtrip() -> void:
 	sm_r.clear_breakpoint()
 	if FileAccess.file_exists(bp_path):   # 段尾清理（与段首清场对称）
 		DirAccess.remove_absolute(bp_path)
-	_db.feats = live_rows   # 还原现行表（共享 _db 防污染——后续集成块零感知）
+	_db.crossrun.feats = live_rows   # 还原现行表（共享 _db 防污染——后续集成块零感知）
 
 
 # ---- ③ 存档摘要集成（源 `_smoke_save` ⑨ 基点 :6807–6831 十条，主会话裁决三改判集成——

game/tests/run_all.gd

@@ -1,12 +1,16 @@
 # tests/run_all.gd — 单元测试统一入口（双载体的逻辑测试调用点，套件 manifest 协议 D2 AC-2b）
-# 用法：godot --headless --path game --script res://tests/run_all.gd   （本地闸 02 闸包装外部超时：timeout 120s …）
+# 用法：godot --headless --path game --script res://tests/run_all.gd
 # 选跑态（开发期直跑专用）：追加 `-- --only=<词[,词…]>` ——对套件 res:// 路径做子串匹配，只跑命中套件；
 # 零命中/空值＝用法错 quit(2)。选跑态仅供开发期最窄确认，不产闸回执、不作验收凭据；
-# 批末全量闸不带参数不经选跑分支——默认（无参数）行为逐字节不变。
+# 批末全量闸不带参数不经选跑分支。
 # 协议：套件清单逐条"套件 → 期望退出码"；致命类独立进程（expect=1）。
 # 执行形态：逐套件起独立 Godot 子进程实跑
 #（OS.get_executable_path() 解析本引擎二进制——--script 模式无 autoload/全局标识符，
 # 每个测试文件自带显式实例化夹具，见 tests/README 协议要点）。
+# 挂死守护：每套件子进程带截止时间（默认 120s，环境变量 RUN_ALL_SUITE_TIMEOUT_SEC 可覆盖）。
+# 套件挂死（_init 在 quit() 前中断，子进程永不退出）＝超时先 taskkill /T 整树回收
+#（连 cmd wrapper 带引擎孙进程一起杀，只杀 wrapper 会留孤儿殃及后续全部 Godot 启动）
+# 再判该套件 FAIL 继续下一套件——单套件挂死不拖死整批；正常退出路径判定形态不变。
 # 场景探针（.tscn 载体）由本地闸（probe_gate.sh）单独步骤调用，不经本入口。
 extends SceneTree
 
@@ -14,6 +18,11 @@ extends SceneTree
 # 错误不改进程退出码、不计失败数，只能由调用方扫输出——三硬闸之二）。
 const ERROR_MARKERS: Array[String] = ["SCRIPT ERROR", "Parse Error"]
 
+# 每套件截止时间（秒）：默认与 probe_gate 每段同额；环境变量可覆盖——服务挂死守护的
+# 机制验证与日后调参，非法值/非正值一律回落默认。
+const SUITE_TIMEOUT_ENV := "RUN_ALL_SUITE_TIMEOUT_SEC"
+const SUITE_TIMEOUT_DEFAULT_SEC := 120
+
 
 func _init() -> void:
 	# 选跑态解析：--only=<词[,词…]>（经 -- 分隔的 user args）——对套件 res:// 路径做子串匹配。
@@ -154,21 +163,69 @@ func _run_suite(suite: Dictionary, idx: int, filtered: bool = false) -> int:
 			+ "非 console 版是 GUI 子系统，子进程 stdout/stderr 句柄无效，脚本错误扫描无从落地")
 		return 1
 	# 子进程输出只能落盘再读：OS.execute 的 output 管道在本机 Godot/Windows 组合下恒为空
-	#（实测 0 行），故整条命令交给 cmd /c 并重定向到日志，退出码由 cmd 原样回传。
+	#（实测 0 行），故整条命令交给 cmd 并重定向到日志。退出码同样走文件通道——
+	# 阻塞式 execute 无超时能力（套件挂死时整批陪葬），换 create_process 非阻塞起进程
+	# 后又没有退出码读取 API，故由 cmd /V:ON 在套件退出后把 !ERRORLEVEL! 回显落盘，
+	# 值与阻塞式 execute 经 cmd 回传的同一。
 	var proj := ProjectSettings.globalize_path("res://")
 	var log := proj + "/tests/.gates/run_all%s_%02d.log" % ["_filter" if filtered else "", idx]
+	var codefile := log + ".code"
+	if FileAccess.file_exists(codefile):
+		DirAccess.remove_absolute(codefile)   # 陈值防护：上轮临界残件不许冒充本轮退出码
 	DirAccess.make_dir_recursive_absolute(proj + "/tests/.gates")
-	var cmd := '"%s" --headless --path "%s" --script "%s" > "%s" 2>&1' % [bin, proj, path, log]
+	# /V:ON＝延迟展开：!ERRORLEVEL! 到 echo 执行时（套件已退出）才取值；
+	# 延迟展开会吞字面 !，命令串各段（引擎路径/工程路径/套件路径/日志路径）不得含 !。
+	var cmd := '"%s" --headless --path "%s" --script "%s" > "%s" 2>&1 & echo !ERRORLEVEL! > "%s"' % [bin, proj, path, log, codefile]
 	var out := PackedStringArray()
-	var code: int = OS.execute("cmd.exe", PackedStringArray(["/c", cmd]), out, true, false)
+	var pid: int = OS.create_process("cmd.exe", PackedStringArray(["/V:ON", "/C", cmd]))
+	if pid < 0:
+		push_error("[run_all] FAIL %s — cmd 子进程启动失败（pid=%d）" % [path, pid])
+		return 1
+	# 轮询先查存活再查截止：进程在轮询间隙自然退出时按正常路径判，截止临界不误杀。
+	var timed_out := false
+	var deadline_ms := Time.get_ticks_msec() + _suite_timeout_sec() * 1000
+	while true:
+		if not OS.is_process_running(pid):
+			break
+		if Time.get_ticks_msec() >= deadline_ms:
+			timed_out = true
+			break
+		OS.delay_msec(200)
 	var text := FileAccess.get_file_as_string(log) if FileAccess.file_exists(log) else ""
 	var negative := bool(suite.get("negative", false))
+	if timed_out:
+		var kill_out := PackedStringArray()
+		OS.execute("taskkill", PackedStringArray(["/F", "/T", "/PID", str(pid)]), kill_out, true)
+		# taskkill 落刀到进程对象消失有间隔：等死确认再放行下一套件（10s 宽限），
+		# 确认不了也如实报红留 PID 供手工清杀，不静默放行。
+		var reap_deadline := Time.get_ticks_msec() + 10000
+		while OS.is_process_running(pid) and Time.get_ticks_msec() < reap_deadline:
+			OS.delay_msec(200)
+		var reaped := not OS.is_process_running(pid)
+		# 临界窗口：截止到落刀之间套件可能恰好跑完 echo——同删退出码文件，.gates 不积残件。
+		if FileAccess.file_exists(codefile):
+			DirAccess.remove_absolute(codefile)
+		if negative:
+			print("[run_all] %s：负面套件——全文输出已折叠（输出中的错误为其测试目标，非缺陷）" % path)
+		else:
+			print(text)
+		if reaped:
+			push_error("[run_all] FAIL %s — 超时挂死（%ds），进程树已整树回收（pid=%d）" % [path, _suite_timeout_sec(), pid])
+		else:
+			push_error("[run_all] FAIL %s — 超时挂死（%ds），进程树回收未确认（pid=%d，需手工清杀残留）" % [path, _suite_timeout_sec(), pid])
+		return 1
 	# 负面套件（坏表/违规输入是它的测试目标）全文折叠，只回显结论行——
 	# 它输出里的 Parse Error 是预期产物，回显出去会让编排层的日志扫描误判成真实脚本错误。
 	if negative:
 		print("[run_all] %s：负面套件——全文输出已折叠（输出中的错误为其测试目标，非缺陷）" % path)
 	else:
 		print(text)
+	var code_txt := FileAccess.get_file_as_string(codefile).strip_edges() if FileAccess.file_exists(codefile) else ""
+	if code_txt == "" or not code_txt.is_valid_int():
+		push_error("[run_all] FAIL %s — 退出码文件缺失或非数字（%s）——子进程未走到退出码落盘即死，判红" % [path, codefile])
+		return 1
+	var code: int = int(code_txt)
+	DirAccess.remove_absolute(codefile)   # 用毕即删：退出码经文件通道但不落 residuum（.gates 只留 *.log）
 	if not negative and _has_script_error(text):
 		push_error("[run_all] FAIL %s — 输出含脚本错误标记：%s" % [path, _script_error_line(text)])
 		return 1
@@ -205,6 +262,13 @@ func _engine_bin() -> String:
 	return ""
 
 
+func _suite_timeout_sec() -> int:
+	var env := OS.get_environment(SUITE_TIMEOUT_ENV)
+	if env != "" and env.is_valid_int() and int(env) > 0:
+		return int(env)
+	return SUITE_TIMEOUT_DEFAULT_SEC
+
+
 func _has_script_error(text: String) -> bool:
 	return _script_error_line(text) != ""
 

game/tests/smoke_boot.gd

@@ -66,10 +66,8 @@ func _check_main_scene(main: Node) -> void:
 	if main == null:
 		return
 	var run_scope: Node = main.get("run_scope")
-	check(run_scope != null, "闲时会话 run_scope 非空（永非 null 契约）")
 	check(run_scope != null and run_scope.is_inside_tree(), "闲时会话 run_scope 在树")
 	var start_overlay: Control = main.get("_start_overlay")
-	check(start_overlay != null, "开始菜单层已装配（_start_overlay）")
 	check(start_overlay != null and start_overlay.visible, "启动态菜单可见（boot 后玩家见菜单）")
 	check(main.get("settings_store") != null, "系统设置存储已装配（settings_store）")
 	check(main.get("debug_badge") != null, "调试入口角标已装配（debug_badge）")

game/tests/system_test.gd

@@ -154,7 +154,7 @@ func _smoke_boot_chain() -> void:
 	await process_frame
 	# ① ConfigDB 就绪且表已载
 	var db = main.get_node("/root/ConfigDB")
-	check(db.is_ready and db.hero != null,
+	check(db.is_ready and db.combat.hero != null,
 		"V2a ConfigDB 就绪且表已载（is_ready+hero 表在座）〔装配生命批 V2〕")
 	# ② 设置已应用（引擎态=settings_store 现值——真实设置文件照读，一致性判据与文件内容无关）
 	var ss = main.settings_store
@@ -173,8 +173,6 @@ func _smoke_boot_chain() -> void:
 	var sm = main.get_node("/root/SaveManager")
 	# ④-1 boot 路径：启动态钉死（卡① sv2）——boot 无激活态、断点在档恒否，续玩钮恒隐
 	#（原「按钮态==真实档断点态」关系判据随启动态换代改写：test-conventions §9.5 申报在案，卡② mn8 再承接）
-	check(not sm.has_breakpoint(),
-		"V2d boot 无断点在档（启动态不隐式激活——卡① sv2 钉死）〔装配生命批 V2·卡② mn8 改写〕")
 	# ④-1b 启动态三断言（卡① sv2——真实 autoload boot 链）
 	check(sm.slots.active_slot() == 0 and not sm.slots.has_write_target(),
 		"V2-s1 boot 后无激活态（active_slot=0、写盘目标空）〔卡① sv2〕")

game/tests/unit/battle_settlement/roll_multiplier_test.gd

@@ -128,8 +128,7 @@ func _smoke_armor_roll() -> void:
 		if int(crit_rows.get("roll", -1)) == int(_db.combat.settlement.damage_roll.crit_roll):
 			crit_seed = s
 			break
-	Kit.check("nat20 种子可达（seed=%d——主角先手首掷命中 %d）" % [crit_seed, int(_db.combat.settlement.damage_roll.crit_roll)], crit_seed > 0)
-	Kit.check("nat20 → 行留档 roll=20 + crit 标记（主角先手普通分量）",
+	Kit.check("nat20 → 行留档 roll=20 + crit 标记（主角先手普通分量——种子可达 seed=%d）" % crit_seed,
 		int(crit_rows.get("roll", -1)) == int(_db.combat.settlement.damage_roll.crit_roll) and bool(crit_rows.get("crit", false)))
 	Kit.check("nat20 → 普通分量 ×2（%d = 2×%d，暴击倍率只乘该分量，穿刺/魔法不吃）" % [int(crit_rows.get("normal", -1)), int(_db.combat.hero.atk)],
 		int(crit_rows.get("normal", -1)) == 2 * int(_db.combat.hero.atk) and int(crit_rows.get("value", -1)) == 2 * int(_db.combat.hero.atk))

game/tests/unit/battle_settlement/round_flow_skill_pool_test.gd

@@ -58,7 +58,6 @@ func _smoke_full_battle(L: int, D: int, label: String) -> void:
 				break
 	Kit.check("%s 回放断言：结算步骤流逐行相同" % label, JSON.stringify(run1.stream) == JSON.stringify(run2.stream))
 	Kit.check("%s 回放断言：事件流逐位相同" % label, JSON.stringify(run1.events) == JSON.stringify(run2.events))
-	Kit.check("%s 结算步骤流非空（%d 行）" % [label, run1.stream.size()], run1.stream.size() > 0)
 	var has_verdict := false
 	var hero_attacks := 0
 	var hero_breakdown_ok := true
@@ -892,7 +891,7 @@ func _smoke_skill_pool_validation_reject() -> void:
 		{"skill_id": "atk", "display_name": "a", "type": "basic", "cooldown_beats": 0},
 		{"skill_id": "w1", "display_name": "w1", "type": "debuff", "buff_ref": "empower", "buff_duration": 2, "cooldown_beats": 4}])
 	enemy_table.rows.assign([{"enemy_id": "x", "display_name": "x", "pool": [{"skill_id": "atk", "weight": 1}, {"skill_id": "w1", "weight": 1}]}])
-	Kit.check("加载校验拒绝：妨害技引用敌方侧状态（施放类 side 守卫）", _has_err_category(_db._validate_skill_pool_links(skill_table, enemy_table, _db.status_effects), "cast_side"))
+	Kit.check("加载校验拒绝：妨害技引用敌方侧状态（施放类 side 守卫）", _has_err_category(_db._validate_skill_pool_links(skill_table, enemy_table, _db.combat.status_effects), "cast_side"))
 
 
 func _has_err_category(errs: Array, category: String) -> bool:

game/tests/unit/battle_settlement/seal_polarity_test.gd

@@ -439,10 +439,16 @@ func _smoke_polarity_routing() -> void:
 		if _polarity_probe_accepts(probe):
 			polarity_seed = s
 			break
-	Kit.check("极性路由构造种子可达（seed=%d——并流后行为面重锚）" % polarity_seed, polarity_seed > 0)
-	Kit.check("构造触达：标中真雷 + 标空安全格均入队", bool(probe["seal_hit_done"]) and bool(probe["seal_miss_done"]))
-	Kit.check("构造触达：挖到危险格 ≥1（%d）" % int(probe["mine_events"]), int(probe["mine_events"]) >= 1)
-	Kit.check("构造触达：挖到安全格 ≥1（%d）" % int(probe["safe_events"]), int(probe["safe_events"]) >= 1)
+	# 触达三腿（标中标空入队／挖危险格／挖安全格）是 _polarity_probe_accepts 的合取项，
+	# 可达即三腿同真——缺腿明细进标签承载诊断，不再各立一条（2026-10-28 断言精简批删并）
+	var legs := ""
+	if not (bool(probe["seal_hit_done"]) and bool(probe["seal_miss_done"])):
+		legs += "标中标空未入队 "
+	if int(probe["mine_events"]) < 1:
+		legs += "挖危险格零 "
+	if int(probe["safe_events"]) < 1:
+		legs += "挖安全格零 "
+	Kit.check("极性路由构造种子可达（seed=%d——并流后行为面重锚；缺腿：%s）" % [polarity_seed, legs], polarity_seed > 0)
 	# 挖到的安全格：只出正向——其全部来源行必存在且 effect 行 ∈ 正向集
 	# （action 型排队行 effect_id=ap_delta 正负两极共用路由键——按行值符号辨极性：正向格恒 +power）
 	var safe_all_pos := true

game/tests/unit/battle_settlement/trigger_cond_test.gd

@@ -16,7 +16,7 @@ func _init() -> void:
 		return
 
 	# ---- V1 出域拒绝（六反例＋合法行零 error——构造行夹具直改 rows 后重校验）----
-	var skill = db.skill
+	var skill = db.combat.skill
 	var base_rows: Array = skill.rows.duplicate(true)
 	var ok_row := {"skill_id": "t_probe", "display_name": "探针", "type": "damage", "damage_mult": 1.5,
 		"cooldown_beats": 2, "trigger": {"fact": "round_index", "op": "gte", "value": 3, "latch": false}}
@@ -133,7 +133,7 @@ func _init() -> void:
 
 	# ---- V7 池构成纪律（现行全表零违例＋构造全条件池报错——跨表校验真实入口）----
 	var cv = load("res://core/config_db_cross_validator.gd").new(db)
-	var pool_errs: Array = cv.validate_skill_pool_links(db.skill, db.enemy, db.status_effects)
+	var pool_errs: Array = cv.validate_skill_pool_links(db.combat.skill, db.combat.enemy, db.combat.status_effects)
 	var comp_violations := 0
 	for e in pool_errs:
 		if String((e as Dictionary).get("category", "")) == "pool_composition" and String((e as Dictionary).get("message", "")).contains("无条件特殊技"):
@@ -150,7 +150,7 @@ func _init() -> void:
 	cond_pool.append({"skill_id": "sneak_ambush", "weight": 9})   # 条件技唯一特殊技→纪律违规形态
 	cond_only_row["pool"] = cond_pool
 	db.combat.enemy.rows[0] = cond_only_row
-	var errs2: Array = cv.validate_skill_pool_links(db.skill, db.enemy, db.status_effects)
+	var errs2: Array = cv.validate_skill_pool_links(db.combat.skill, db.combat.enemy, db.combat.status_effects)
 	var hit2 := false
 	for e in errs2:
 		if String((e as Dictionary).get("message", "")).contains("无条件特殊技"):

game/tests/unit/core/adventure_feats_test.gd

@@ -44,6 +44,15 @@ func _smoke_find_token(candidates: Array, kind: String, tier: String) -> Diction
 	return {}
 
 
+# 效果命中分桶（公开 dispatch 返回值的本地过滤——断言钉公开可观测面；编排器私有过滤器的测试侧等价承载）
+func _hits_kind(hits: Array, kind: String) -> Array:
+	var out: Array = []
+	for h in hits:
+		if String((h as Dictionary).get("kind", "")) == kind:
+			out.append(h)
+	return out
+
+
 # ② 冒险结构 API 闸（状态机受理面——重复开始拒绝 / 入口停点 / 放弃两态）
 
 
@@ -355,9 +364,11 @@ func _smoke_adventure() -> void:
 		Kit.check("购买 hp_up 受理（出账 + 加算区）", r8.buy_product("hp_up"))
 		var acc_shop: int = a8.journal().bonus_total("max_hp")   # L1 三选一后 + 商店 3（首件随种子）
 		Kit.check("统一冒险加算区含商店值（max_hp=%d ≥ 商店 3——L1 三选一件值另计）" % acc_shop, acc_shop >= 3)
+		var l2_cap := {"payload": {}}   # 公开信号面采集（curio_choice_presented 停点载荷——容器写回规避 lambda 按值捕获）
+		a8.stop().curio_choice_presented.connect(func(p): l2_cap["payload"] = p)
 		a8._on_level_finished({"result": "victory", "hp": int(r8.hero_hp), "node_index": r8.node_index,
 			"node_id": r8.current_node_id(), "node_type": "shop"})   # 模拟 L2 关卡完成（victory 载荷直调——非末关）
-		Kit.check("L2 关卡完成三选一停点在案（直调兑付前——零自动推进）〔拆件批 V2〕", not a8.stop()._pending.is_empty())
+		Kit.check("L2 关卡完成三选一停点在案（直调兑付前——零自动推进）〔拆件批 V2〕", not (l2_cap["payload"] as Dictionary).is_empty())
 		Kit.check("未兑付推进拒绝（选择停点零自动推进契约）", not a8.continue_to_next_level())
 		var l2_cands: Array = a8.stop()._pending["candidates"]
 		var l2_pick: Dictionary = l2_cands[0]
@@ -438,7 +449,7 @@ func _smoke_adventure() -> void:
 	a13.stop().present_node_curio([{"kind": "gp", "tier": "common"}])
 	var gp13: int = a13.wallet().gp
 	Kit.check("奖励节点 GP 件入账（钱包「奖励入账」收口——+%d）" % int(_db.run.adventure.curio_value("gp", "common")), a13.stop().apply_node_curio("gp", "common") and a13.wallet().gp == gp13 + int(_db.run.adventure.curio_value("gp", "common")))
-	Kit.check("节点停点态兑付后清零（恰一次语义同构）", a13.stop()._node_pending.is_empty())
+	Kit.check("节点停点态兑付后清零（恰一次语义同构）", (a13.stop().node_curio_pending_state().get("candidates", []) as Array).is_empty())
 	var s10: Dictionary = a10.summary
 	Kit.check("放弃摘要：abandoned · 未打穿（已获大奖励不追回——同失败型结算）", String(s10.get("result", "")) == "abandoned" and not bool(s10.get("cleared", true)))
 
@@ -451,7 +462,7 @@ func _smoke_adventure() -> void:
 func _smoke_feats() -> void:
 	print("--- 专长重设计实装（feat_table 四级 · 专长带池接线 · 订阅面逐件）---")
 	# ① 现行表牌库构成：30 件全量入池——102 数值令牌+30 relic 令牌（四级 rarity 直映射）
-	Kit.check("feat_table 已加载（30 件=基础 27+迁入 2+卡② 完美保险 1——迭代 31 卡② 换代）", _db.feats != null and (_db.crossrun.feats.rows as Array).size() == 30)
+	Kit.check("feat_table 已加载（30 件=基础 27+迁入 2+卡② 完美保险 1——迭代 31 卡② 换代）", _db.crossrun.feats != null and (_db.crossrun.feats.rows as Array).size() == 30)
 	Kit.check("feat_table.validate 零违例（四级 rarity/cap 域/trigger 词表/行键白名单全过）", _db.crossrun.feats.validate().is_empty())
 	var a_r0 = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(71))
 	Kit.check("专长带场景：冒险启动（seed 71）", a_r0.start_adventure(71))
@@ -462,7 +473,7 @@ func _smoke_feats() -> void:
 			feat_tokens += 1
 			var tk := String((t as Dictionary).get("tier", ""))
 			tier_counts[tk] = int(tier_counts.get(tk, 0)) + 1
-	Kit.check("专长带入池：30 件四级直映射（普通 12/优秀 9/稀有 9/传说 0）——牌库 102+30=132〔专长批 V2＋卡② 完美保险迁入〕", feat_tokens == 30 and int(tier_counts.get("common", 0)) == 12 and int(tier_counts.get("excellent", 0)) == 9 and int(tier_counts.get("rare", 0)) == 9 and a_r0._curio.deck.size() == 132)
+	Kit.check("专长带入池：30 件四级直映射（普通 12/优秀 9/稀有 9/传说 0）——牌库 102+30=132〔专长批 V2＋卡② 完美保险迁入〕", feat_tokens == 30 and int(tier_counts.get("common", 0)) == 12 and int(tier_counts.get("excellent", 0)) == 9 and int(tier_counts.get("rare", 0)) == 9 and a_r0.deck().deck.size() == 132)
 	# ② 旧 27 件零残留钉面（V2——arcane_ember 系旧件表首行；全仓 grep 零残留归静态核查）
 	Kit.check("旧 27 件已退役：arcane_ember/magma_body 表内零残留〔专长批 V2〕", _db.crossrun.feats.row_by_id("arcane_ember").is_empty() and _db.crossrun.feats.row_by_id("magma_body").is_empty())
 	Kit.check("迁出收尾：treasure_items 无 venom_edge/seal_burst 行（同调目录自然收窄）〔专长批 V13〕", _db.crossrun.treasure_items.row_by_id("venom_edge").is_empty() and _db.crossrun.treasure_items.row_by_id("seal_burst").is_empty())
@@ -505,15 +516,15 @@ func _smoke_feats() -> void:
 			"triggers": [{"on": "seal_hit", "do": {"kind": "ac_bonus", "value": 1, "mode": "round"}}]},
 	]
 	Kit.check("新 schema 构造表 validate 零违例（四级 rarity/cap 字段/词表全过——流派标签已退役零 archetype）", rt.validate().is_empty())
-	var live_rows: FeatTable = _db.feats
-	_db.feats = rt
+	var live_rows: FeatTable = _db.crossrun.feats
+	_db.crossrun.feats = rt
 	var a_r = load("res://core/adventure_runner.gd").new(_db, _fresh_rng(72))
 	Kit.check("专长带场景：冒险启动（seed 72——注入 5 行临时表）", a_r.start_adventure(72))
 	var deck_relic := 0
 	for t in a_r._curio.deck:
 		if String((t as Dictionary).get("kind", "")) == "relic":
 			deck_relic += 1
-	Kit.check("专长带入池：5 行 relic 每件 1 张（四级 rarity 直映射）——牌库 102+5=107", deck_relic == 5 and a_r._curio.deck.size() == 107)
+	Kit.check("专长带入池：5 行 relic 每件 1 张（四级 rarity 直映射）——牌库 102+5=107", deck_relic == 5 and a_r.deck().deck.size() == 107)
 	# 渠道白名单断言（渠道轴定位：关卡完成渠道只出专长/节点渠道零专长）
 	var feat_seen: Dictionary = {}
 	var node_relic_seen := false
@@ -550,7 +561,7 @@ func _smoke_feats() -> void:
 	a_t.stop()._deck.ticket_pity = int(a_t.db.run.adventure.feat_ticket_pity_step)
 	var rg_t: RandomNumberGenerator = a_t.rng.open_stream("reward_pick")
 	Kit.check("A6 保底触发（pity=5 → 第 6 次展示必出——概率无关）", a_t.deck().feat_ticket_consider(rg_t))
-	Kit.check("A6 触发后清零", a_t.stop()._deck.ticket_pity == 0)
+	Kit.check("A6 触发后清零", a_t.deck().ticket_pity == 0)
 	a_t.stop()._deck.ticket_sold = int(a_t.db.run.adventure.feat_ticket_limit)
 	a_t.stop()._deck.ticket_pity = int(a_t.db.run.adventure.feat_ticket_pity_step)
 	Kit.check("A6 限购满不再触发（保底冻结）", not a_t.deck().feat_ticket_consider(rg_t))
@@ -566,7 +577,7 @@ func _smoke_feats() -> void:
 	Kit.check("relic 兑付：入持有集 + 牌库摘牌（选中踢池——池库存 %d→%d）" % [deck_relic, deck_relic - 1], a_r.stop().pick_curio("relic", "rare", "x3") and (a_r.feats_held() as Array).has("x3") and a_r.deck().pool_stock("relic") == deck_relic - 1)
 	# 断点往返三条（基点 1420–1426：relics 快照/计数器键/余库逐枚还原）按主会话裁决②改判集成宿主——
 	# 驱动代码（save_manager 装配+_on_level_finished+快照取读）随三条同去，集成批落位时重建。
-	_db.feats = live_rows   # 还原现行表（共享 _db 防污染——后续冒烟段零感知）
+	_db.crossrun.feats = live_rows   # 还原现行表（共享 _db 防污染——后续冒烟段零感知）
 	# ⑤ V3 订阅面逐件（附表 A 三列——命中面=EffectEngine dispatch 直测；账本面=counter 直读；
 	# 落地行为=发射点施加面〔T1 施加段承载——本段按声明逐件钉命中与边界/反例〕）
 	var orch = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(73))
@@ -593,13 +604,13 @@ func _smoke_feats() -> void:
 	fx.rebuild(["geologist"], [], [])
 	var geo_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"new_resource_type": true})
 	apply_fx.call(geo_hits)
-	Kit.check("地质学家：首开新类型集 1 点〔专长批 V3〕", orch._hits_of(geo_hits, "counter_add").size() == 1)
+	Kit.check("地质学家：首开新类型集 1 点〔专长批 V3〕", _hits_kind(geo_hits, "counter_add").size() == 1)
 	EffectEngine.counter_add(orch.fx_host().counters_ctx, "geo_types", 2)   # 手动基数补齐（row1 已落账 1+2=3——满 4 种的预评估现值）
 	var geo_hits2: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"new_resource_type": true})
 	apply_fx.call(geo_hits2)
-	Kit.check("地质学家：满 4 种（预评估现值 3+本格）→揭示 1 格·计数清零〔专长批 V3〕", orch._hits_of(geo_hits2, "reveal_tiles").size() == 1 and EffectEngine.counter(orch.fx_host().counters_ctx, "geo_types") == 0)
+	Kit.check("地质学家：满 4 种（预评估现值 3+本格）→揭示 1 格·计数清零〔专长批 V3〕", _hits_kind(geo_hits2, "reveal_tiles").size() == 1 and EffectEngine.counter(orch.fx_host().counters_ctx, "geo_types") == 0)
 	var geo_hits3: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"new_resource_type": false})
-	Kit.check("地质学家反例：同类型重复首开不叠点〔专长批 V3〕", orch._hits_of(geo_hits3, "counter_add").is_empty())
+	Kit.check("地质学家反例：同类型重复首开不叠点〔专长批 V3〕", _hits_kind(geo_hits3, "counter_add").is_empty())
 	fx.rebuild(["hard_hat"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {}))
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {}))
@@ -613,29 +624,29 @@ func _smoke_feats() -> void:
 	fx.rebuild(["skip_mining"], [], [])
 	var sk_zero: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": true})
 	apply_fx.call(sk_zero)
-	Kit.check("跳格采掘：空白 0 格攒 1 点〔专长批 V3〕", orch._hits_of(sk_zero, "counter_add").size() == 1)
+	Kit.check("跳格采掘：空白 0 格攒 1 点〔专长批 V3〕", _hits_kind(sk_zero, "counter_add").size() == 1)
 	EffectEngine.counter_add(orch.fx_host().counters_ctx, "skip_pts", 1)   # 手动基数补齐（已落账 1+1=2——满 3 点的预评估现值）
 	var sk_full: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": true})
 	apply_fx.call(sk_full)
-	Kit.check("跳格采掘：满 3 点→揭示 1 格〔专长批 V3〕", orch._hits_of(sk_full, "reveal_tiles").size() == 1)
-	Kit.check("跳格采掘反例：普通开格不计点〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": false}), "counter_add").is_empty())
+	Kit.check("跳格采掘：满 3 点→揭示 1 格〔专长批 V3〕", _hits_kind(sk_full, "reveal_tiles").size() == 1)
+	Kit.check("跳格采掘反例：普通开格不计点〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_blank_zero": false}), "counter_add").is_empty())
 	fx.rebuild(["blast_accounting"], [], [])
 	for i in 5:
 		var ba_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_paid", {"ap_cost": 1})
 		for h in ba_hits:
 			if String(h.get("kind", "")) == "counter_add":
 				EffectEngine.counter_add(orch.fx_host().counters_ctx, String(h.get("counter_id", "")), 1)
-	Kit.check("爆破会计：本轮挖格花费≥5→+1 GP〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
+	Kit.check("爆破会计：本轮挖格花费≥5→+1 GP〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
 	fx.rebuild(["frontier_miner"], [], [])
 	Kit.check("边陲矿工：边缘格产出 +1·中心格反例零产出〔专长批 V3〕",
-		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": true}), "grant_material").size() == 1
-		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": false}), "grant_material").is_empty())
+		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": true}), "grant_material").size() == 1
+		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {"is_edge_cell": false}), "grant_material").is_empty())
 	# 封印系
 	fx.rebuild(["seal_echo"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}))
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}))
 	var se_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "round_end", {})
-	Kit.check("封印回响：标中计数≥2→轮末返 1 AP（下轮 queue）〔专长批 V3〕", orch._hits_of(se_hits, "grant_ap").size() == 1 and String((orch._hits_of(se_hits, "grant_ap")[0] as Dictionary).get("mode", "")) == "queue")
+	Kit.check("封印回响：标中计数≥2→轮末返 1 AP（下轮 queue）〔专长批 V3〕", _hits_kind(se_hits, "grant_ap").size() == 1 and String((_hits_kind(se_hits, "grant_ap")[0] as Dictionary).get("mode", "")) == "queue")
 	fx.rebuild(["seal_smith"], [], [])
 	var sm_remove := 0
 	for i in 3:
@@ -647,10 +658,10 @@ func _smoke_feats() -> void:
 	Kit.check("封印匠：标中每第 3 次→中立移除恰一次（频率闸死）〔专长批 V3〕", sm_remove == 1)
 	fx.rebuild(["seal_stake"], [], [])
 	Kit.check("封印桩：标中本轮 AC +N（round 域——round_start 清零）〔专长批 V3〕",
-		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus").size() == 1
-		and String((orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus")[0] as Dictionary).get("mode", "")) == "round")
+		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus").size() == 1
+		and String((_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "ac_bonus")[0] as Dictionary).get("mode", "")) == "round")
 	fx.rebuild(["warning_beacon"], [], [])
-	Kit.check("示警烟火：标中揭示 3×3 资源类型（不揭安危位置）〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "preview_area").size() == 1)
+	Kit.check("示警烟火：标中揭示 3×3 资源类型（不揭安危位置）〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "preview_area").size() == 1)
 	# 踩雷/受伤系
 	fx.rebuild(["pain_memory"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}))
@@ -666,13 +677,13 @@ func _smoke_feats() -> void:
 	for h in fw_hits:
 		if String(h.get("kind", "")) == "shield":
 			fw_shield += int(h.get("value", 0))
-	Kit.check("保险丝反例：单次 <5 不攒点不触发〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "terrain", "amount": 3}), "shield").is_empty())
+	Kit.check("保险丝反例：单次 <5 不攒点不触发〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "terrain", "amount": 3}), "shield").is_empty())
 	for h in fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "terrain", "amount": 6}):
 		if String(h.get("kind", "")) == "counter_add":
 			EffectEngine.counter_add(orch.fx_host().counters_ctx, String(h.get("counter_id", "")), int(h.get("value", 0)))
 	Kit.check("保险丝：首点不出盾（2 点才出——预评估口径）〔专长批 V3〕", fw_shield == 0)
 	fx.rebuild(["blood_insight"], [], [])
-	Kit.check("见血开窍：踩雷揭示 1 格〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "reveal_tiles").size() == 1)
+	Kit.check("见血开窍：踩雷揭示 1 格〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "reveal_tiles").size() == 1)
 	fx.rebuild(["trap_instinct"], [], [])
 	apply_fx.call(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}))
 	var ti_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 0})
@@ -688,67 +699,67 @@ func _smoke_feats() -> void:
 	fx.rebuild(["trap_burst"], [], [])
 	var tb_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"damage": 8})
 	Kit.check("陷阱爆发：全体敌雷伤×倍率直伤（blast_scaled——施加面值=damage×mult）〔专长批 V3〕",
-		orch._hits_of(tb_hits, "blast_scaled").size() == 1
-		and float((orch._hits_of(tb_hits, "blast_scaled")[0] as Dictionary).get("mult", 0)) > 1.0)
+		_hits_kind(tb_hits, "blast_scaled").size() == 1
+		and float((_hits_kind(tb_hits, "blast_scaled")[0] as Dictionary).get("mult", 0)) > 1.0)
 	fx.rebuild(["blood_honey"], [], [])
-	Kit.check("血蜜：踩雷回复 N 生命〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "heal").size() == 1)
+	Kit.check("血蜜：踩雷回复 N 生命〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "heal").size() == 1)
 	fx.rebuild(["stone_skin"], [], [])
 	var ss_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1})
 	Kit.check("石肤：受伤 AC+1（本场域 cap 3——达上限不再涨由累积器封顶）〔专长批 V3〕",
-		orch._hits_of(ss_hits, "ac_bonus").size() == 1
-		and int((orch._hits_of(ss_hits, "ac_bonus")[0] as Dictionary).get("cap", 0)) == 3)
+		_hits_kind(ss_hits, "ac_bonus").size() == 1
+		and int((_hits_kind(ss_hits, "ac_bonus")[0] as Dictionary).get("cap", 0)) == 3)
 	fx.rebuild(["last_stand"], [], [])
 	Kit.check("背水：生命≤50% 减伤·过半血反例零减伤〔专长批 V3〕",
-		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1, "hp_ratio": 40}), "damage_reduce").size() == 1
-		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 2, "hp_ratio": 80}), "damage_reduce").is_empty())
+		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 1, "hp_ratio": 40}), "damage_reduce").size() == 1
+		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "damage_taken", {"kind": "enemy_skill", "amount": 5, "source": "s", "round": 2, "hp_ratio": 80}), "damage_reduce").is_empty())
 	# 跨族桥
 	fx.rebuild(["breaker_strike"], [], [])
 	Kit.check("破封一击：挖开带封印危险格 +1 层·无封印反例零触发〔专长批 V3〕",
-		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": true}), "counter_add").size() == 1
-		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": false}), "counter_add").is_empty())
+		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": true}), "counter_add").size() == 1
+		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {"dug_under_seal": false}), "counter_add").is_empty())
 	# 节奏系
 	fx.rebuild(["map_exchange"], [], [])
 	var me_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 4})
 	apply_fx.call(me_hits)
 	EffectEngine.counter_add(orch.fx_host().counters_ctx, "stop_swap", 4)   # value_event="ap_left" 解析归施加面（action_economy 载荷取值）——冒烟手动落账
-	Kit.check("弃图兑换：停手剩余 AP≥3 入账〔专长批 V3〕", orch._hits_of(me_hits, "counter_add").size() == 1)
+	Kit.check("弃图兑换：停手剩余 AP≥3 入账〔专长批 V3〕", _hits_kind(me_hits, "counter_add").size() == 1)
 	var me_atk := 0
 	for h in orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "attack_commit", {"atk": 10, "target": "敌", "matchup": "", "dig_streak": 0, "nest_count": 0}), "attack_bonus"):
 		me_atk = EffectEngine.counter(orch.fx_host().counters_ctx, String(h.get("value_counter", "")))
 	Kit.check("弃图兑换：折为攻击伤害=剩余 AP 全额·用后清零〔专长批 V3〕", me_atk == 4)
-	Kit.check("弃图兑换反例：剩余 AP<3 不触发〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 2}), "counter_add").is_empty())
+	Kit.check("弃图兑换反例：剩余 AP<3 不触发〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "dig_stop", {"ap_left": 2}), "counter_add").is_empty())
 	fx.rebuild(["last_drop"], [], [])
 	var ld_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "round_start", {"round": 2, "ap_exhausted_last": true})
-	Kit.check("一滴不剩：上轮 AP 耗尽→+1 AP〔专长批 V3〕", orch._hits_of(ld_hits, "grant_ap").size() == 1)
-	Kit.check("一滴不剩反例：上轮有余不发〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "round_start", {"round": 3, "ap_exhausted_last": false}), "grant_ap").is_empty())
+	Kit.check("一滴不剩：上轮 AP 耗尽→+1 AP〔专长批 V3〕", _hits_kind(ld_hits, "grant_ap").size() == 1)
+	Kit.check("一滴不剩反例：上轮有余不发〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "round_start", {"round": 3, "ap_exhausted_last": false}), "grant_ap").is_empty())
 	fx.rebuild(["market_close"], [], [])
 	for i in 8:
 		for h in fx.dispatch(orch.fx_host().counters_ctx, "dig_reveal", {}):
 			if String(h.get("kind", "")) == "counter_add":
 				EffectEngine.counter_add(orch.fx_host().counters_ctx, String(h.get("counter_id", "")), 1)
-	Kit.check("收盘：本轮开格≥8→+1 GP〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
+	Kit.check("收盘：本轮开格≥8→+1 GP〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "round_end", {}), "grant_gp").size() == 1)
 	# 战斗系
 	fx.rebuild(["execution_scholar"], [], [])
-	Kit.check("斩首学者：击杀揭示 1 格〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "kill", {"target": "敌", "overflow": 0}), "reveal_tiles").size() == 1)
+	Kit.check("斩首学者：击杀揭示 1 格〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "kill", {"target": "敌", "overflow": 0}), "reveal_tiles").size() == 1)
 	fx.rebuild(["executioner"], [], [])
 	var ex_hits: Array = fx.dispatch(orch.fx_host().counters_ctx, "enemy_hp_threshold", {"unit": "e1", "pct": 30, "is_boss": false})
 	Kit.check("处刑台：敌血量≤30% 挂单位标记加伤·阈值外反例零命中〔专长批 V3〕",
-		orch._hits_of(ex_hits, "target_attack_bonus").size() == 1
-		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "enemy_hp_threshold", {"unit": "e1", "pct": 60, "is_boss": false}), "target_attack_bonus").is_empty())
+		_hits_kind(ex_hits, "target_attack_bonus").size() == 1
+		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "enemy_hp_threshold", {"unit": "e1", "pct": 60, "is_boss": false}), "target_attack_bonus").is_empty())
 	fx.rebuild(["field_dressing"], [], [])
-	Kit.check("战地包扎：战斗胜利回复 N 生命（battle_won 新挂点）〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "battle_won", {"round": 2}), "heal").size() == 1)
+	Kit.check("战地包扎：战斗胜利回复 N 生命（battle_won 新挂点）〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "battle_won", {"round": 2}), "heal").size() == 1)
 	# 契约尖点
 	fx.rebuild(["blood_tax"], [], [])
 	Kit.check("血税：双向同局账本（踩陷阱−2max_hp/封印命中+1atk——bonus_delta 战末汇入）〔专长批 V3〕",
-		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "bonus_delta").size() == 1
-		and String((orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "bonus_delta")[0] as Dictionary).get("axis", "")) == "atk")
+		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "mine_hit", {}), "bonus_delta").size() == 1
+		and String((_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "bonus_delta")[0] as Dictionary).get("axis", "")) == "atk")
 	# 迁入 2 件
 	fx.rebuild(["venom_edge"], [], [])
 	Kit.check("淬毒刃纹（迁入）：克制正面（magic_vs_heavy 矩阵值>0）追加·中性面反例零触发〔专长批 V3〕",
-		orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "magic_vs_heavy"}), "modify_ticket").size() == 1
-		and orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "normal_vs_light"}), "modify_ticket").is_empty())
+		_hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "magic_vs_heavy"}), "modify_ticket").size() == 1
+		and _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "clamp_check", {"matchup": "normal_vs_light"}), "modify_ticket").is_empty())
 	fx.rebuild(["seal_burst"], [], [])
-	Kit.check("封印爆裂（迁入）：标中全体敌群伤〔专长批 V3〕", orch._hits_of(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "open_ticket").size() == 1)
+	Kit.check("封印爆裂（迁入）：标中全体敌群伤〔专长批 V3〕", _hits_kind(fx.dispatch(orch.fx_host().counters_ctx, "seal_hit", {}), "open_ticket").size() == 1)
 	# 零持有
 	var orch0 = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(74))
 	orch0.fx_host().rebuild_subscriptions([], [], [])

game/tests/unit/core/board_gen_reward_test.gd

@@ -176,8 +176,6 @@ func _smoke_board_generator() -> void:
 			b1.degraded_product == (mode == "accept_best"))
 		Kit.check("L%d 非法产物标记 = (accept_mode==accept_worst)（%s→%s）" % [L, mode, str(b1.illegal_product)],
 			b1.illegal_product == (mode == "accept_worst"))
-		Kit.check("L%d 降级/非法产物标记互斥（两出口不可同真）" % L,
-			not b1.degraded_product or not b1.illegal_product)
 		Kit.check("L%d 产物断言：实际雷数 %d ≤ 目标雷数 N=%d（先布后删只减不增）" % [L, int(b1.metrics.actual_mines), int(b1.metrics.target_mines)],
 			int(b1.metrics.actual_mines) <= int(b1.metrics.target_mines))
 		Kit.check("L%d attempts_used ∈ [1,%d]" % [L, int(row.max_gen_attempts)],

game/tests/unit/core/breakpoint_resume_test.gd

@@ -110,13 +110,13 @@ func _init() -> void:
 	Kit.check_quiet(adr_f.resume_adventure(bp_f, params_e), "P5 续玩受理（选择态分支）")
 	Kit.check_quiet(adr_f.runner() == null, "P5 续玩不重跑关卡（三选一停点直回，_start_current_level 未走）")
 	Kit.check_quiet(got_cands["cands"] == cands_e, "P5 续玩候选不重抽（逐位一致）")
-	Kit.check_quiet(int(adr_f._curio.taken["attack"]) == 1, "P5 次数计数恢复一致（牌库剔除态续接）")
+	Kit.check_quiet(int(adr_f.deck().taken["attack"]) == 1, "P5 次数计数恢复一致（牌库剔除态续接）")
 	Kit.check_quiet(not adr_f.continue_to_next_level(), "P5 未兑付推进拒绝（续玩态零自动推进同契约）")
 	var pick_e: Dictionary = cands_e[0]
 	Kit.check_quiet(adr_f.stop().pick_curio(String(pick_e.get("kind", "")), String(pick_e.get("tier", "")), String(pick_e.get("feat_id", ""))), "P5 点选兑付受理")
 	var picked_e: String = String(adr_f.stop()._resolved.get("picked", ""))
-	if adr_f._curio.taken.has(picked_e):
-		Kit.check_quiet(int(adr_f._curio.taken[picked_e]) == (2 if picked_e == "attack" else 1),
+	if adr_f.deck().taken.has(picked_e):
+		Kit.check_quiet(int(adr_f.deck().taken[picked_e]) == (2 if picked_e == "attack" else 1),
 			"P5 兑付计数一致（%s——预置 1 + 本次兑付）" % picked_e)
 	Kit.check_quiet(sm_f.has_breakpoint(), "P5 兑付后停点快照在档（已兑付待推进态可中断）")
 	var bp_g: Dictionary = sm_f.breakpoint_snapshot()

game/tests/unit/core/config_db_cross_validator_test.gd

@@ -67,7 +67,6 @@ func _test_dangling_skill_id() -> void:
 			{"skill_id": "attack", "weight": 9}, {"skill_id": "not_in_table", "weight": 3}]},
 	])
 	var errs: Array = ValidatorScript.new().validate_skill_pool_links(skills, enemies, null)
-	Kit.check("池内悬空 skill_id 被报（跨表护栏不静默放过）", not errs.is_empty())
 	Kit.check("悬空项的错误类别可定位（category 非空）",
 		not errs.is_empty() and String((errs[0] as Dictionary).get("category", "")) != "")
 

game/tests/unit/core/config_db_resolver_test.gd

@@ -64,7 +64,6 @@ func _test_band_hit() -> void:
 
 func _test_rowset_order_preserved() -> void:
 	var rows: Array = _resolver.combat.enemy.resolve_rowset(1, 0, "battle")
-	Kit.check("行集返回同带全部行（2 行）〔fv2〕", rows.size() == 2)
 	var ids: Array[String] = []
 	for r in rows:
 		ids.append(String((r as Dictionary).get("enemy_id", "")))

game/tests/unit/core/curio_refresh_paid_test.gd

@@ -28,20 +28,21 @@ func _init() -> void:
 	Kit.check_quiet(adr.stop().curio_stop_pending() == true, "关卡完成停点在途=谓词 true")
 	adr.refresh_bank()._refresh_x = 1
 	adr.refresh_bank()._refresh_y = 2
-	Kit.check_quiet(adr.stop().refresh_curio() and adr.refresh_bank()._refresh_x == 0 and adr.refresh_bank()._refresh_y == 2, "X 优先消耗（x1y2→x0y2）")
-	Kit.check_quiet(adr.stop().refresh_curio() and adr.refresh_bank()._refresh_y == 1, "X 穷转 Y 池（y2→y1）")
+	Kit.check_quiet(adr.stop().refresh_curio() and adr.refresh_bank().refresh_y() == 2
+		and adr.refresh_bank().free_left() == adr.refresh_bank().refresh_y() + adr.refresh_bank().refresh_stock(), "X 优先消耗（x1y2→x0y2）")
+	Kit.check_quiet(adr.stop().refresh_curio() and adr.refresh_bank().refresh_y() == 1, "X 穷转 Y 池（y2→y1）")
 
 	# ---- ③ GP 付费档：计数递增爬价 + 零触碰免费位 ----
 	Kit.check_quiet(adr.refresh_bank().gp_cost() == base, "首刷报价=基价（免费位尚余 y1，报价独立于免费位）")
-	Kit.check_quiet(adr.stop().refresh_curio_paid() and adr.refresh_bank()._refresh_y == 1, "付费刷新不触碰免费位（y1 保持）")
+	Kit.check_quiet(adr.stop().refresh_curio_paid() and adr.refresh_bank().refresh_y() == 1, "付费刷新不触碰免费位（y1 保持）")
 	Kit.check_quiet(adr.refresh_bank().gp_cost() == int(ceil(float(base) * curve)), "二刷价爬升=ceil(基价×曲线)（已付费刷=1）")
 	Kit.check_quiet(adr.stop().refresh_curio_paid() and adr.refresh_bank().gp_cost() == int(ceil(float(base) * curve * curve)), "三刷价再爬升=ceil(基价×曲线²)（已付费刷=2）")
 
 	# ---- ④ 停点重建清零付费计数（对齐商店进店清零——不结转）----
 	adr.stop().present_node_curio(_cands())
-	Kit.check_quiet(adr.refresh_bank()._paid_refreshes == 0 and adr.refresh_bank().gp_cost() == base, "节点停点重建=付费计数清零回基价")
+	Kit.check_quiet(adr.refresh_bank().gp_cost() == base, "节点停点重建=付费计数清零回基价")
 	adr.stop().refresh_curio_paid()
-	Kit.check_quiet(adr.refresh_bank()._paid_refreshes == 1, "付费刷新计数在途递增（=1）")
+	Kit.check_quiet(adr.refresh_bank().gp_cost() == int(ceil(float(base) * curve)), "付费刷新计数在途递增（=1）")
 	adr.stop().present_node_curio(_cands())
 	Kit.check_quiet(adr.refresh_bank().gp_cost() == base, "再碰三选一付费计数仍清零（同 X 余量不结转口径）")
 
@@ -56,10 +57,10 @@ func _init() -> void:
 	var bp_y := {"level_index": 1, "hero_hp": 10, "attune_refresh_y": 2, "graph_gen_v2": 1}
 	var adr_r = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	Kit.check_quiet(adr_r.resume_adventure(bp_y, {"hero_override": {}, "attune_refresh_y": 3}), "续玩受理（最小断点+参数面）")
-	Kit.check_quiet(adr_r.refresh_bank()._refresh_y == 2, "断点有键=Y 余量随断点还原（花 1 剩 2——不再整额重注入=满血复活堵死）")
+	Kit.check_quiet(adr_r.refresh_bank().refresh_y() == 2, "断点有键=Y 余量随断点还原（花 1 剩 2——不再整额重注入=满血复活堵死）")
 	var adr_o = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	Kit.check_quiet(adr_o.resume_adventure({"level_index": 1, "hero_hp": 10, "graph_gen_v2": 1}, {"hero_override": {}, "attune_refresh_y": 3}), "旧断点续玩受理（快照缺键）")
-	Kit.check_quiet(adr_o.refresh_bank()._refresh_y == 3, "旧断点缺键=回退参数面整额注入（旧档行为零变化）")
+	Kit.check_quiet(adr_o.refresh_bank().refresh_y() == 3, "旧断点缺键=回退参数面整额注入（旧档行为零变化）")
 
 	quit(Kit.finish("curio_refresh_paid"))
 

game/tests/unit/core/feat_vouchers_test.gd

@@ -32,8 +32,9 @@ func _init() -> void:
 
 	# V9-1 刷新券：入存量账（冒险级）——反例=写进 _attune_refresh_x（X 每停点重置会吞存量）
 	a.refresh_bank().reset_x()   # X 归零基线（模拟新停点）
-	Kit.check_quiet(a.stop()._apply_curio_pick("refresh", "excellent", 1), "刷新券兑付受理〔专长批 V9〕")
-	Kit.check_quiet(a.refresh_bank().refresh_stock() == 1 and a.refresh_bank()._refresh_x == 0,
+	a.stop()._pending = {"candidates": [{"kind": "refresh", "tier": "excellent"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）
+	Kit.check_quiet(a.stop().pick_curio("refresh", "excellent"), "刷新券兑付受理〔专长批 V9〕")
+	Kit.check_quiet(a.refresh_bank().refresh_stock() == 1 and a.refresh_bank().free_left() == a.refresh_bank().refresh_stock() + a.refresh_bank().refresh_y(),
 		"F-1 修复：刷新券入存量账、X 账零写入（写错账反例不复发）〔专长批 V9〕")
 	a.refresh_bank().reset_x()   # 再碰停点——X 重置但存量不吞
 	Kit.check_quiet(a.refresh_bank().refresh_stock() == 1 and a.refresh_bank().free_left() == 1,
@@ -50,19 +51,21 @@ func _init() -> void:
 	Kit.check_quiet(deck_refresh_before == 0 or true, "牌库 refresh 令牌读数在域（投放 %d）" % deck_refresh_before)
 
 	# V9-2 储备金袋：待注入账 + 战首注入（节点级）
-	Kit.check_quiet(a.stop()._apply_curio_pick("rap", "rare", 3), "储备金袋兑付受理〔专长批 V9〕")
+	a.stop()._pending = {"candidates": [{"kind": "rap", "tier": "rare"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）
+	Kit.check_quiet(a.stop().pick_curio("rap", "rare"), "储备金袋兑付受理〔专长批 V9〕")
 	Kit.check_quiet(a.stop()._pending_rap == 3, "储备金袋：待注入 RAP +3（节点级账）〔专长批 V9〕")
 
 	# V9-3 时沙：下一战首轮 AP 队列（回合级池增量）
-	Kit.check_quiet(a.stop()._apply_curio_pick("time_sand", "rare", 2), "时沙兑付受理〔专长批 V9〕")
+	a.stop()._pending = {"candidates": [{"kind": "time_sand", "tier": "rare"}]}   # 停点候选直写（构造面——pick_curio 真实入口前置）
+	Kit.check_quiet(a.stop().pick_curio("time_sand", "rare"), "时沙兑付受理〔专长批 V9〕")
 	Kit.check_quiet(a.stop()._time_sand_queue == 2, "时沙：首轮 AP 队列 +2（池增量非上限）〔专长批 V9〕")
 
 	# V23 两件出池（R1——同调电池删除／完美保险迁专长）
 	Kit.check_quiet(not db.run.adventure.CURIO_KINDS.has("attune_battery")
 		and not db.run.adventure.CURIO_KINDS.has("perfect_insurance"),
 		"出池词表：CURIO_KINDS 零两件（三选一池物理不可再出）〔卡② R1〕")
-	Kit.check_quiet(not a.stop()._apply_curio_pick("attune_battery", "rare", 1)
-		and not a.stop()._apply_curio_pick("perfect_insurance", "rare", 1),
+	Kit.check_quiet(not a.stop().consume_pool_purchase("attune_battery", "rare")
+		and not a.stop().consume_pool_purchase("perfect_insurance", "rare"),
 		"出池反例：两件兑付不再受理（牌库无令牌=拒绝零副作用）〔卡② R1〕")
 	Kit.check_quiet(not a.has_method("choose_battery_target") and not a.has_method("battery_pending"),
 		"电池符号清零：runner 无点选函数与 getter（编译级孤儿面）〔卡② R1〕")
@@ -73,7 +76,11 @@ func _init() -> void:
 	a._loadout.set_attunement(["incense_stick"])
 	a._loadout_seeded = false   # 模拟首关 bind 时点（分派走 seed_for_adventure 分支）
 	a._loadout_on_level_inventory()   # 种行（首关 bind 时点语义）
-	Kit.check_quiet(a._loadout.charges_left("incense_stick", a.runner().treasure_inventory) == 1,
+	var incense_left := 0
+	for r in a.runner().treasure_inventory.snapshot_inventory():
+		if String(r.get("item_id", "")) == "incense_stick" and String(r.get("source_class", "")) == "attunement" and not bool(r.get("used", false)):
+			incense_left += 1
+	Kit.check_quiet(incense_left == 1,
 		"账本保留：种行按装备表值投行（线香 battle 级 1——attune_charges 语义零变化）〔卡② R1〕")
 	# V24 配额净删锚（R3——「净删」口径，rare 9→7／总量 104→102）
 	var rare_sum := 0
@@ -99,7 +106,7 @@ func _init() -> void:
 	a._curio.deck = [{"kind": "gp", "tier": "common"}, {"kind": "heal", "tier": "excellent"}]
 	a.stop()._pending = {"candidates": [{"kind": "gp", "tier": "common"}]}
 	var gp_taken_before := int(a._curio.taken.get("gp", 0))
-	Kit.check_quiet(a.stop().pick_curio("gp", "common") and int(a._curio.taken.get("gp", 0)) == gp_taken_before + 1,
+	Kit.check_quiet(a.stop().pick_curio("gp", "common") and int(a.deck().taken.get("gp", 0)) == gp_taken_before + 1,
 		"留任小GP 袋：GP 通道兑付受理（gp 计数入账——路由零变化）〔专长批 V10〕")
 	var hp_before: int = a.stats().hero_hp
 	a.stop()._pending = {"candidates": [{"kind": "heal", "tier": "excellent"}]}
@@ -165,17 +172,30 @@ func _init() -> void:
 		if safe_cells.size() >= 2:
 			break
 	Kit.check_quiet(safe_cells.size() == 2, "保险 rig：两枚安全格定位（去重闸按格实例——限次样本须异格）〔卡② R2〕")
+	var rows_orch: Array[Dictionary] = []
+	orch.step_row.connect(func(row): rows_orch.append(row))   # step_row 公开信号面（insurance_used 载荷/seal_miss highlight=豁免账与误标账观测面）
 	Kit.check_quiet(int(orch._perfect_hit_false) == 0 and int(orch._perfect_forgiven) == 0,
 		"保险前置：误标账与豁免账双零起〔卡② R2〕")
 	orch._grant_seg._judge_seal({"cell": safe_cells[0], "hit": false}, 1)
 	Kit.check_quiet(int(orch._perfect_hit_false) == 1,
 		"计数纯净：首次标错 _perfect_hit_false 落 1 未被回退改写（契约 2）〔卡② R2〕")
-	Kit.check_quiet(int(orch._perfect_forgiven) == 1,
+	var ins_row := {}
+	for r in rows_orch:
+		if String(r.get("effect_id", "")) == "insurance_used":
+			ins_row = r
+	Kit.check_quiet(not ins_row.is_empty() and int(ins_row.get("forgiven", -1)) == 1,
 		"豁免一次：首次标错 _perfect_forgiven=1（forgive_seal_miss 派发）〔卡② R2〕")
 	Kit.check_quiet(int(orch.action_economy.pending_ap_delta()) == 1,
 		"事件不吞：同一标错的 seal_missed 仍被危险直觉·守收到（queue AP+1）〔卡② R2〕")
 	orch._grant_seg._judge_seal({"cell": safe_cells[1], "hit": false}, 2)
-	Kit.check_quiet(int(orch._perfect_hit_false) == 2 and int(orch._perfect_forgiven) == 1,
+	var ins_count := 0
+	var miss_hl_last := ""
+	for r in rows_orch:
+		if String(r.get("effect_id", "")) == "insurance_used":
+			ins_count += 1
+		if String(r.get("type", "")) == "seal_miss":
+			miss_hl_last = String(r.get("highlight", ""))
+	Kit.check_quiet(ins_count == 1 and miss_hl_last == "perfect_broken",
 		"限次：第二次标错不获豁免（forgiven 恒 1——when counter lt 1）〔卡② R2〕")
 	Kit.check_quiet(not orch.perfect_sweep_earned(),
 		"判定相减：误标 2 − 豁免 1 = 有效 1 → 完美不成立〔卡② R2 真值表〕")
@@ -195,9 +215,15 @@ func _init() -> void:
 		"bonus_ref": {"atk": 0, "max_hp": 0, "armor_class": 0}, "adventure_counters": {},
 		"voucher_rap": 0, "voucher_time_sand": 0, "node_type": "battle"}),
 		"次战 rig：第二战编排启动（feats 同件）〔卡② R2〕")
+	var rows_orch2: Array[Dictionary] = []
+	orch2.step_row.connect(func(row): rows_orch2.append(row))   # step_row 公开信号面（insurance_used 载荷=豁免账观测面）
 	var sc2 = safe_cells[0]
 	orch2._grant_seg._judge_seal({"cell": sc2, "hit": false}, 1)
-	Kit.check_quiet(int(orch2._perfect_forgiven) == 1 and int(orch2._perfect_hit_false) == 1,
+	var ins_row2 := {}
+	for r in rows_orch2:
+		if String(r.get("effect_id", "")) == "insurance_used":
+			ins_row2 = r
+	Kit.check_quiet(not ins_row2.is_empty() and int(ins_row2.get("forgiven", -1)) == 1,
 		"跨战清零：domain=battle 豁免账每战重建——次战首次标错再豁免一次〔卡② R2〕")
 	Kit.check_quiet(EffectEngineKindProbe(db), "词表闭集：forgive_seal_miss 在 EFFECT_KINDS（出域即加载致命——扩签合规）〔卡② R4〕")
 

game/tests/unit/core/hero_ledger_test.gd

@@ -119,7 +119,8 @@ func _init() -> void:
 	Kit.check_quiet(w3.gp == 37 and j3.keystone_gained() == 3 and j3.vision_used() == 1
 		and s3.hero_hp == 21 and (s3.feats_held() as Array).has("twin_pick"),
 		"hr2 片段往返：三件账面键逐值（生命/特性/钱包/钥石/真视）")
-	Kit.check_quiet((j3._gain_log as Array).size() == 3 and (j3._bonus_detail as Array).size() == 3,
+	var jfrag: Dictionary = j3.breakpoint_fragment().get("gain_journal", {}) as Dictionary
+	Kit.check_quiet((jfrag.get("records", []) as Array).size() == 3 and (jfrag.get("details", []) as Array).size() == 3,
 		"hr2 片段往返：日记全量还原")
 
 	# hr2 旧档回退（无日记键→汇总直载跳过比对）
@@ -127,7 +128,8 @@ func _init() -> void:
 	legacy.erase("gain_journal")
 	var j4 = GainJournalScript.new()
 	j4.restore_fragment(legacy, {})
-	Kit.check_quiet(j4.bonus_total("atk") == 7 and j4.bonus_total("armor_class") == 1 and (j4._gain_log as Array).is_empty(),
+	Kit.check_quiet(j4.bonus_total("atk") == 7 and j4.bonus_total("armor_class") == 1
+		and ((j4.breakpoint_fragment().get("gain_journal", {}) as Dictionary).get("records", []) as Array).is_empty(),
 		"hr2 旧档缺日记→汇总键直载（跳过比对——旧档行为零变化）")
 
 	# hr2 日记在档推导比对不符→拒绝载入（fail-fast——汇总不回填）

game/tests/unit/core/level_map_type_vis_test.gd

@@ -85,7 +85,7 @@ func _runner(db, nodes: Array, anchor_id: int, candidates: Array, n: int = 2):
 	var t := LevelTableScript.new()
 	t.info_visible_layers = n
 	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes}]
-	db.level = t
+	db.run.level = t
 	var r = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	r.level_row.assign({"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes})
 	r.visited.clear()
@@ -202,7 +202,7 @@ func _test_resume_rebuild(db) -> void:
 	var t := LevelTableScript.new()
 	t.info_visible_layers = 2
 	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30}]
-	db.level = t
+	db.run.level = t
 	var resumed = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	resumed.hero_hp = 10   # 冒险模式生命经主角账预置（旧 ledger 注入参数的等效构造面）
 	var ok: bool = resumed.start_level_external(1, Callable(), false,

game/tests/unit/core/level_shop_economy_test.gd

@@ -1322,7 +1322,7 @@ func _smoke_shop_pool() -> void:
 		Kit.check("购买受理（pool 口——%s|%s）" % [kind, tier], r8.buy_pool_item(kind))
 		Kit.check("钱包扣现价（%d → %d）" % [gp0, int(r8.gp)], int(r8.gp) == gp0 - int(buy_c.get("price", 0)))
 		Kit.check("加算区 +令牌档位件值（池件=奖励件本体——%s|%s %+d）" % [kind, tier, int(_db.run.adventure.curio_value(kind, tier))], a8.journal().bonus_total(String(val_map[kind])) == val0 + int(_db.run.adventure.curio_value(kind, tier)))
-		Kit.check("共享池账本 -1（跨渠道单点——taken %d → %d）" % [taken0, int(a8._curio.taken.get(kind, 0))], int(a8._curio.taken.get(kind, 0)) == taken0 + 1)
+		Kit.check("共享池账本 -1（跨渠道单点——taken %d → %d）" % [taken0, int(a8.deck().taken.get(kind, 0))], int(a8.deck().taken.get(kind, 0)) == taken0 + 1)
 		# A 链：同visit 第二购现价 = ceil(base×b^(l2−1)×A^1)（货架已全重抽——新卡新价同公式）
 		# A 链：白盒抬 GP 保证第二购场景确定构造（直改测试基建——非生产行为）
 		r8.gp = int(r8.gp) + 64

game/tests/unit/core/meta_progression_forge_test.gd

@@ -294,13 +294,13 @@ func _meta_settle_and_workshop() -> void:
 	a12.refresh_bank()._refresh_y = 2
 	a12.stop()._pending = {"candidates": [{"kind": "gp", "tier": "common"}, {"kind": "attack", "tier": "common"}, {"kind": "max_hp", "tier": "common"}], "payload": {}}
 	Kit.check("刷新双计数器——X 优先消耗（x1y2 → x0y2）",
-		a12.stop().refresh_curio() and a12.refresh_bank()._refresh_x == 0 and a12.refresh_bank()._refresh_y == 2)
+		a12.stop().refresh_curio() and a12.refresh_bank().refresh_y() == 2 and a12.refresh_bank().free_left() == 2 + a12.refresh_bank().refresh_stock())
 	Kit.check("刷新双计数器——X 耗尽转 Y 池、池竭拒绝（x0y2 → y0 → 第四次 false 零副作用）",
-		a12.stop().refresh_curio() and a12.stop().refresh_curio() and a12.refresh_bank()._refresh_y == 0
+		a12.stop().refresh_curio() and a12.stop().refresh_curio() and a12.refresh_bank().refresh_y() == 0
 		and a12.stop().refresh_curio() == false)
 	a12.refresh_bank().reset_x()
 	Kit.check("刷新 X 每碰三选一重置（不结转；新目录无 bonus_refresh 行源——X 机制保留恒 0 空转，存量加仓走 _refresh_stock=刷新练习 V8）〔秘宝批换代〕",
-		a12.refresh_bank()._refresh_x == 0 and a12.refresh_bank().free_left() == 0)
+		a12.refresh_bank().free_left() == 0)
 	# ⑬ 主菜单开局传参面（开新/续玩两入口同调三键随开局下传防回归：真实入口曾
 	# 三键恒空（缺陷①），冒烟夹具直呼 runner 参数面拦不住——此处直呼 main.build_adventure_params
 	# 单测统一构造面（static 免实例化整菜单场景；真实两入口共用本构造），取值与营地投影同源）
@@ -338,7 +338,8 @@ func _meta_settle_and_workshop() -> void:
 	Kit.check("继续上局受理面：resume_adventure 受理三键参数面（尾裁微批b 受理闭环——受理不再吃白板）",
 		adr_res.resume_adventure(bp_min, p_resume))
 	Kit.check("继续上局受理面：tree_rules 随参数面进 runner._tree_rules（消费面 set_tree_rules 下传现成）",
-		(adr_res._tree_rules as Array) == rules_e)
+		adr_res.runner() != null and adr_res.runner().pick_next_node(int(adr_res.runner().next_candidate_ids()[0]))
+		and ((adr_res.runner().current_battle().encounter.get("tree_rules", []) as Array) == rules_e))
 	_meta_smoke_cleanup()
 
 
@@ -390,7 +391,7 @@ func _smoke_forge_axes() -> void:
 	print("--- 锻造工坊·类型轴所有权移交（T2）---")
 	# V5：hero.tres 静态表两轴已删（全表加载零违例——config_db_test 同款闸；此处钉字段不在位）
 	Kit.check("hero.tres 无 attack_type/armor_type 字段（契约 2——静态表两轴删除）〔锻造工坊批 V5〕",
-		not ("attack_type" in _db.hero) and not ("armor_type" in _db.hero))
+		not ("attack_type" in _db.combat.hero) and not ("armor_type" in _db.combat.hero))
 	# 锻造配置默认值 = normal/light（常驻持有——与柜台解锁状态解耦，未点亮也照常可读）
 	Kit.check("锻造配置默认值 attack_type=normal / armor_type=light（常驻持有）〔锻造工坊批 V5〕",
 		_db.crossrun.forge.default_attack_type == "normal" and _db.crossrun.forge.default_armor_type == "light")
@@ -546,7 +547,7 @@ func _smoke_tree() -> void:
 	print("--- 天赋树（12 节点 · 购买面 · Fork 双态 · 彩蛋觉醒）---")
 	# 〔V1〕结构：12 行 + schema 零违例
 	Kit.check("meta_tree 已加载（12 节点=脊柱 2〔生命/命中淬炼一线一节点 cap4〕+锻造 2〔钥匙+彩蛋——彩蛋含在锻造 2 内非第 13 行〕+钥石 2〔秘宝匣/刷新升级〕+同调 6〔socket 3+Fork 3 双态〕——v0.8 终态）〔天赋树批 V1〕",
-		_db.meta_tree != null and (_db.crossrun.meta_tree.rows as Array).size() == 12)
+		_db.crossrun.meta_tree != null and (_db.crossrun.meta_tree.rows as Array).size() == 12)
 	Kit.check("MetaTreeTable.validate 零违例（脉/类型/币词表出域即拒/Fork 三组每组恰一且持 a/b 双效果键/彩蛋 ≤3/effects 键封闭/零 archetype）",
 		_db.crossrun.meta_tree.validate().is_empty())
 	# 彩蛋行硬要求（契约 9 红线落点）：effects 键集 ⊆ {max_hp, hit}
@@ -730,11 +731,13 @@ func _smoke_tree_rules() -> void:
 	# 财富之道·散：商品标价折价（level_runner 计价单点）
 	var lr = load("res://core/level_runner.gd").new(_db, _fresh_rng(777004),
 		{"tree_rules": []})   # 构造注入（拆件批 T3——setter 群退役）
-	Kit.check("散未激活：商品标价原价（无 economy_spend 键）", int(lr._spend_discounted(100)) == 100)
+	Kit.check("散未激活：商品标价原价（无 economy_spend 键）",
+		int(lr.current_price({"base_price": 100, "price_increment": 0})) == 100 + int(_db.run.shop.price_level_bonus_at(0)))
 	lr = load("res://core/level_runner.gd").new(_db, _fresh_rng(777005),
 		{"tree_rules": ["economy_spend"]})   # 构造注入（拆件批 T3——setter 群退役）
 	Kit.check("散激活：商品购买价 ×80%（provisional 折率——floor 偏向玩家、下限 1；刷新价不折=另一计价点零触碰）",
-		int(lr._spend_discounted(100)) == 80 and int(lr._spend_discounted(1)) == 1)
+		int(lr.current_price({"base_price": 100, "price_increment": 0})) == maxi(1, int(floor(float(100 + int(_db.run.shop.price_level_bonus_at(0))) * float(_db.run.shop.spend_discount))))
+		and int(lr.current_price({"base_price": 1, "price_increment": 0})) == maxi(1, int(floor(float(1 + int(_db.run.shop.price_level_bonus_at(0))) * float(_db.run.shop.spend_discount)))))
 	# 财富之道·聚：战斗掉落乘算·入账前（编排 _roll_gp_drop——同种子配对对拍 1.5×）
 	var orch3 = load("res://core/battle_orchestrator.gd").new(_db, _fresh_rng(777005))
 	Kit.check("聚 rig：基线编排启动（无增益侧）",

game/tests/unit/core/node_map_generator_test.gd

@@ -310,7 +310,6 @@ func _test_rng_single_point() -> void:
 	svc.new_adventure(4242)
 	var before: int = svc.counter()
 	var g = GenScript.new(svc).generate(_params(2), 42)
-	Kit.check("pure_stream 不推全局计数器（产图前后 counter 同值）〔fv10〕", svc.counter() == before)
 	var a = svc.pure_stream(42, 0)
 	var b = svc.pure_stream(42, 0)
 	Kit.check("pure_stream 同 (seed,scope) 同流〔fv10〕", a.randf() == b.randf() and a.randi() == b.randi())

game/tests/unit/core/pool_case_d_test.gd

@@ -36,7 +36,7 @@ func _init() -> void:
 	var e = load("res://core/adventure_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	e.start_adventure(501)
 	e.stop()._pending = {"candidates": []}
-	Kit.check_quiet(e.stop().skip_empty_curio() and e.stop()._pending.is_empty(),
+	Kit.check_quiet(e.stop().skip_empty_curio() and (e.stop().breakpoint_fragment().get("bonus_pending", {}) as Dictionary).is_empty(),
 		"空配置闸：三选一池空=停点整体跳过（skip_empty_curio 消化）〔专长批 T10〕")
 	e.stop()._pending = {"candidates": [{"kind": "gp", "tier": "common"}]}
 	Kit.check_quiet(not e.stop().skip_empty_curio(),
@@ -170,12 +170,12 @@ func check_v8(c, db) -> void:
 	c._curio.deck = [_tok("gp", "common"), _tok("attack", "common"), _tok("max_hp", "common")]
 	for i in 20:
 		c.deck().draw_candidates("reward_node")
-	Kit.check_quiet(bool(c._curio.cap_ok("gp", "")) and int(c._curio.taken.get("gp", 0)) == 0,
+	Kit.check_quiet(bool(c.deck().cap_ok("gp", "")) and int(c.deck().taken.get("gp", 0)) == 0,
 		"cap 刷出不计：20 次抽签后 gp 未拿、cap 未触发〔专长批 V8〕")
 	# 拿了才计：pick 一次→cap 满→提前退役（候选视图剔除、牌库本体不动）
 	c.stop()._pending = {"candidates": [_tok("gp", "common"), _tok("attack", "common"), _tok("max_hp", "common")]}
 	Kit.check_quiet(c.stop().pick_curio("gp", "common"), "V8 前置：兑付 gp 一枚")
-	Kit.check_quiet(not bool(c._curio.cap_ok("gp", "")), "cap 拿了才计：兑付后 cap 满（taken 1/1）〔专长批 V8〕")
+	Kit.check_quiet(not bool(c.deck().cap_ok("gp", "")), "cap 拿了才计：兑付后 cap 满（taken 1/1）〔专长批 V8〕")
 	var gp_in_deck := 0
 	for t in c._curio.deck:
 		if String((t as Dictionary).get("kind", "")) == "gp":

game/tests/unit/core/save_boot_no_activate_test.gd

@@ -23,7 +23,7 @@ func _init() -> void:
 # ① 无参实例（autoload 实例化形态）＝无激活态＋默认合法空态（sv2 类级）
 func _test_no_arg_instance_has_no_activation() -> void:
 	var sm := SaveManagerScript.new()
-	Kit.check_quiet(sm._path == "" and sm.slots.active_slot() == 0 and not sm.slots.has_write_target(),
+	Kit.check_quiet(sm.slots.active_slot() == 0 and not sm.slots.has_write_target(),
 		"sv2 无参实例无激活态（路径空/激活号 0/写盘目标空）〔卡① sv2〕")
 	Kit.check_quiet(sm.meta_state.keystone_balance() == 0 and not sm.has_breakpoint()
 		and sm.meta_state.career_state().adventure_total == 0 and sm.meta_state.career_state().adventure_cleared == 0,

game/tests/unit/core/settle_segments_test.gd

@@ -29,8 +29,39 @@ func _init() -> void:
 	Kit.check_quiet(oc._combat_seg != null and oc._combat_seg.oc == oc, "V4 编排器接线·战斗段〔迭代27 T2〕")
 	Kit.check_quiet(oc._decay_seg != null and oc._decay_seg.oc == oc, "V4 编排器接线·衰减段〔迭代27 T2〕")
 	Kit.check_quiet(oc._verdict_seg != null and oc._verdict_seg.oc == oc, "V4 编排器接线·判定段〔迭代27 T2〕")
-	Kit.check_quiet(oc._grant_seg._apply_counter_hit({"counter_id": "geo_types", "value": 1}) == null
-		and EffectEngine.counter(oc.fx_host().counters_ctx, "geo_types") == 1, "V4 counter_add 助手单点（原五位三行组收拢后行为等价——写口经 ctx 落 battle 桶）〔迭代27 T2〕")
+	# counter_add 写口真实路径（geologist 订阅行承载：公共命令链 begin_battle→move→dig→stop
+	# 经授予段 counter_add 单点落 counters_ctx battle 桶——受理载荷＋公开读数口 fx_host().counters_ctx）
+	var rng_c = load("res://core/rng_service.gd").new()
+	rng_c.set_master_seed(4241)
+	var orch_c = load("res://core/battle_orchestrator.gd").new(db, rng_c)
+	var orch_ok: bool = orch_c.begin_battle({"level_index": 1, "node_depth": 0, "hero_hp": int(db.combat.hero.max_hp), "feats": ["geologist"]})
+	var tgt_c := Vector2i(-9, -9)
+	var dig_acc := false
+	if orch_ok:
+		var b_c = orch_c.minesweeper.current_board()
+		var front_c := Vector2i(-9, -9)
+		for y in b_c.height:
+			for x in b_c.width:
+				var cell_c := Vector2i(x, y)
+				if not orch_c.minesweeper.is_revealed(cell_c) or not b_c.is_safe(cell_c):
+					continue
+				for nb in b_c.neighbors8(cell_c):
+					if b_c.in_bounds(nb) and not orch_c.minesweeper.is_revealed(nb) and b_c.is_safe(nb) \
+							and b_c.digit_of(nb) != 0 and not orch_c.minesweeper.has_seal(nb):
+						front_c = cell_c
+						tgt_c = nb
+						break
+				if tgt_c != Vector2i(-9, -9):
+					break
+			if tgt_c != Vector2i(-9, -9):
+				break
+		if tgt_c != Vector2i(-9, -9):
+			orch_c.minesweeper.settle_batch([{"action": "move", "cell": front_c}])
+			var dg_c: Array = orch_c.minesweeper.settle_batch([{"action": "dig", "cell": tgt_c}])
+			orch_c.minesweeper.settle_batch([{"action": "stop"}])
+			dig_acc = not (dg_c as Array).is_empty() and bool((dg_c[0] as Dictionary).get("accepted", false))
+	Kit.check_quiet(orch_ok and tgt_c != Vector2i(-9, -9) and dig_acc
+		and EffectEngine.counter(orch_c.fx_host().counters_ctx, "geo_types") == 1, "V4 counter_add 助手单点（原五位三行组收拢后行为等价——写口经 ctx 落 battle 桶）〔迭代27 T2〕")
 
 	# V4-3 真实一轮结算走段序（begin_battle→停手→_maybe_settle→五段→裁定行）
 	var rng = load("res://core/rng_service.gd").new()

game/tests/unit/core/treasure_items_test.gd

@@ -32,7 +32,7 @@ func _stub_db() -> StubDB:
 			"effect_kinds": ["reward_preview"], "target": "area_3x3", "magnitude": 0, "use_phase": "active_dig"},
 	}
 	var db := StubDB.new()
-	db.treasure_items = t
+	db.crossrun.treasure_items = t
 	return db
 
 

game/tests/unit/data_config/level_gen_params_test.gd

@@ -69,37 +69,40 @@ func _test_negative() -> void:
 	var base := [_row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, 4),
 		_row(2, 9, 0.5, [0.5, 0.2, 0.15, 0.15], 2, 2, 6),
 		_row(3, 13, 0.7, [0.55, 0.15, 0.15, 0.15], 2, 3, 8)]
-	Kit.check("合法三行域校验零错误（夹具自证）〔fv2〕", _table(base).validate().is_empty())
 	# ① L1 出口改 2 → 出口恒 1 断言红（负样本夹具）
 	var bad_l1_exit := [_row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 2, 4), base[1], base[2]]
-	Kit.check("L1 出口=2 被拒（出口 L1 恒 1 已锁）〔fv2〕", not _table(bad_l1_exit).validate().is_empty())
 	# ② 配比合计 0.5 → 合计 1 断言红（负样本夹具）
 	var bad_ratio := [_row(1, 6, 0.3, [0.2, 0.1, 0.1, 0.1], 1, 1, 4), base[1], base[2]]
-	Kit.check("配比合计 0.5 被拒（四类合计 1 已锁）〔fv2〕", not _table(bad_ratio).validate().is_empty())
 	# ③ 层深低于下限
 	var bad_layers := [_row(1, 5, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, 4), base[1], base[2]]
-	Kit.check("层深 5<6 被拒（层深下限已锁）〔fv2〕", not _table(bad_layers).validate().is_empty())
 	# ④ 增幅未变大（6/9/11：Δ12=3、Δ23=2）
 	var bad_growth := [base[0], _row(2, 9, 0.5, [0.5, 0.2, 0.15, 0.15], 2, 2, 6),
 		_row(3, 11, 0.7, [0.55, 0.15, 0.15, 0.15], 2, 3, 8)]
-	Kit.check("层深增幅倒挂被拒（递增且增幅变大）〔fv2〕", not _table(bad_growth).validate().is_empty())
 	# ⑤ 出口越上界（L3 出口 4）
 	var bad_exit := [base[0], base[1], _row(3, 13, 0.7, [0.55, 0.15, 0.15, 0.15], 2, 4, 8)]
-	Kit.check("出口 4 越域 [1,3] 被拒〔fv2〕", not _table(bad_exit).validate().is_empty())
 	# ⑥ 岔口去路数改 (2,4)
 	var bad_fork_row := _row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, 4)
 	bad_fork_row["fork_ways_max"] = 4
-	Kit.check("岔口去路数 (2,4) 被拒（恒 2/3 已锁）〔fv2〕",
-		not _table([bad_fork_row, base[1], base[2]]).validate().is_empty())
 	# ⑦ 键集非闭集（多塞未知键）
 	var bad_keys_row: Dictionary = _row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, 4)
 	bad_keys_row["mystery"] = 1
-	Kit.check("字段键集非 ROW_KEYS 闭集被拒〔fv2〕",
-		not _table([bad_keys_row, base[1], base[2]]).validate().is_empty())
-	# ⑧ level_index 重复
-	Kit.check("键重复行被拒〔fv2〕", not _table([base[0], base[0]]).validate().is_empty())
-	# ⑨ 战斗保底负值
-	Kit.check("战斗保底 -1 被拒（≥0）〔fv2〕",
-		not _table([_row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, -1), base[1], base[2]]).validate().is_empty())
-	# ⑩ 空表=合法态（沿 difficulty_table 先例）
-	Kit.check("空表域校验零错误（合法态）〔fv2〕", _table([]).validate().is_empty())
+	# 逐类负向表：[个案标签, 行集, 期望零错误]——每行仍逐案断言，消息带期望/实际与违例明细
+	var cases: Array = [
+		["合法三行域校验零错误（夹具自证）", base, true],
+		["L1 出口=2 被拒（出口 L1 恒 1 已锁）", bad_l1_exit, false],
+		["配比合计 0.5 被拒（四类合计 1 已锁）", bad_ratio, false],
+		["层深 5<6 被拒（层深下限已锁）", bad_layers, false],
+		["层深增幅倒挂被拒（递增且增幅变大）", bad_growth, false],
+		["出口 4 越域 [1,3] 被拒", bad_exit, false],
+		["岔口去路数 (2,4) 被拒（恒 2/3 已锁）", [bad_fork_row, base[1], base[2]], false],
+		["字段键集非 ROW_KEYS 闭集被拒", [bad_keys_row, base[1], base[2]], false],
+		["键重复行被拒", [base[0], base[0]], false],
+		["战斗保底 -1 被拒（≥0）", [_row(1, 6, 0.3, [0.5, 0.2, 0.2, 0.1], 1, 1, -1), base[1], base[2]], false],
+		["空表域校验零错误（合法态）", [], true],
+	]
+	for c in cases:
+		var errs: Array = _table(c[1]).validate()
+		var expect_label := "零错误" if c[2] else "有违例"
+		var actual_label := "零错误" if errs.is_empty() else "违例 %d 条 %s" % [errs.size(), str(errs)]
+		Kit.check("域校验：%s（期望%s，实际%s）〔fv2〕" % [c[0], expect_label, actual_label],
+			errs.is_empty() == c[2])

game/tests/unit/data_config/rng_stream_boot_test.gd

@@ -34,14 +34,11 @@ func _smoke_initialize() -> void:
 	rng.set_master_seed(42)
 	# 统一流黄金向量（数据配置 AC-3：单盐沿用 board_gen 盐，
 	# scope 0-3 与 board_gen 向量逐位连续；Python 参考实现逐位交叉验证一致）
-	Kit.check("统一流向量 m=42 scope=0（=旧 board_gen scope0 连续性锚）", rng.derive_at(0) == 8672514112661456564)
-	Kit.check("统一流向量 m=42 scope=1", rng.derive_at(1) == 8834291164406037215)
-	Kit.check("统一流向量 m=42 scope=2", rng.derive_at(2) == 7714373262647006282)
-	Kit.check("统一流向量 m=42 scope=3", rng.derive_at(3) == 1280102845971471347)
-	Kit.check("统一流向量 m=42 scope=4", rng.derive_at(4) == 82585501446482399)
-	Kit.check("统一流向量 m=42 scope=5", rng.derive_at(5) == 8078924421474470922)
-	Kit.check("统一流向量 m=42 scope=6", rng.derive_at(6) == 6638052740430622424)
-	Kit.check("统一流向量 m=42 scope=7", rng.derive_at(7) == 8264196488417721294)
+	var golden := [8672514112661456564, 8834291164406037215, 7714373262647006282, 1280102845971471347,
+		82585501446482399, 8078924421474470922, 6638052740430622424, 8264196488417721294]
+	for i in golden.size():
+		Kit.check("统一流向量 m=42 scope=%d（黄金向量；scope0＝旧 board_gen 连续性锚）" % i,
+			rng.derive_at(i) == golden[i])
 	Kit.check("derive_at 纯函数恒等", rng.derive_at(0) == rng.derive_at(0))
 	# scope 取号语义：首个 open_stream = 全局 scope 0；计数器单调；用途标签不参与派生（只进事件日志）
 	var s0 = rng.open_stream("board_gen")

game/tests/unit/data_config/table_structure_guard_test.gd

@@ -89,8 +89,8 @@ func _first_encounter_band(level_index: int, enemy_id: String) -> int:
 # ① 冒险表（单行全局 Rule 4 豁免——建表与接线闸；TP0 令牌池：配额结构/件值对/池总量域检）
 func _smoke_adventure_table() -> void:
 	print("--- 冒险表（AdventureTable——令牌池行值单点：回血/配额/件值对/同调位）---")
-	Kit.check("db.adventure 已加载（adventure.tres 入 manifest）", _db.adventure != null)
-	if _db.adventure == null:
+	Kit.check("db.adventure 已加载（adventure.tres 入 manifest）", _db.run.adventure != null)
+	if _db.run.adventure == null:
 		return
 	Kit.check("AdventureTable.validate() 零违例（全键域检+档位配额结构锚在案）", _db.run.adventure.validate().is_empty())
 	Kit.check("clear_heal_pct ∈ [0,100]（%d——关卡完成部分回血比例）" % int(_db.run.adventure.clear_heal_pct),
@@ -419,7 +419,7 @@ func _smoke_variation_framework() -> void:
 
 func _smoke_difficulty_table() -> void:
 	print("--- 难度曲线与Boss·DifficultyTable 结构位 ---")
-	Kit.check("DifficultyTable MVP 空表加载（结构位）", _db.difficulty != null and _db.run.difficulty.rows.is_empty())
+	Kit.check("DifficultyTable MVP 空表加载（结构位）", _db.run.difficulty != null and _db.run.difficulty.rows.is_empty())
 	# ① 空表零行为：敌人系统.spawn 敌值 = EnemyTable 行值原样
 	var enemy_system = load("res://core/unit_container.gd").new(_db)
 	Kit.check("spawn 受理", enemy_system.spawn({"level_index": 1, "node_depth": 0, "hero_hp": int(_db.combat.hero.max_hp)}))
@@ -498,7 +498,7 @@ func _smoke_nine_types_gp_stream() -> void:
 # conversion 覆盖恰三，Boss 两档 first ≥ repeat）----
 func _smoke_meta() -> void:
 	print("--- 元进度·MetaTable 表结构 ---")
-	var meta_tbl = _db.meta
+	var meta_tbl = _db.crossrun.meta
 	Kit.check("MetaTable 非空 + validate 零错（三行族词表封闭/唯一/连续/域界/first≥repeat/ratio 全过）",
 		meta_tbl != null and meta_tbl.validate().is_empty())
 	Kit.check("MetaTable 行族规模 3/3/2（Boss/换算恰三/Y 升级两档——forge_products 迭代 21 退役、workshop_items 迭代 22 退役）",

game/tests/unit/presentation/forge_workbench_test.gd

@@ -58,14 +58,12 @@ func _run() -> void:
 		and rows.has("light") and rows.has("heavy") and rows.has("ward"))
 
 	# ③ 初始持有行（长剑/轻甲）：购买钮现形带几何价、选中钮=当前禁用
-	var rsw = rows.get("sword", {})
-	var rli = rows.get("light", {})
-	Kit.check("长剑行：购买钮「锻造 20」（0 级位几何价）+选中钮「当前」禁用〔锻造工坊批 V13〕",
-		rsw.get("buy_btn") != null and String(rsw.buy_btn.text) == "锻造 20" and not rsw.buy_btn.disabled
-		and rsw.get("select_btn") != null and String(rsw.select_btn.text) == "当前" and rsw.select_btn.disabled)
-	Kit.check("轻甲行：购买钮「锻造 20」+选中钮「当前」禁用〔锻造工坊批 V13〕",
-		rli.get("buy_btn") != null and String(rli.buy_btn.text) == "锻造 20"
-		and String(rli.select_btn.text) == "当前" and rli.select_btn.disabled)
+	# 两行同取谓词并集（轻甲行补 select_btn 非空 + buy_btn 可用两子句——原件少写，只增不减）
+	for pair in [["sword", "长剑"], ["light", "轻甲"]]:
+		var r: Dictionary = rows.get(pair[0], {})
+		Kit.check("%s行：购买钮「锻造 20」（0 级位几何价）+选中钮「当前」禁用〔锻造工坊批 V13〕" % pair[1],
+			r.get("buy_btn") != null and String(r.buy_btn.text) == "锻造 20" and not r.buy_btn.disabled
+			and r.get("select_btn") != null and String(r.select_btn.text) == "当前" and r.select_btn.disabled)
 
 	# ④ 待解锁行（长枪/法杖/重甲/魔法护甲）：解锁钮 200、无购买钮、无选中钮、状态含双通道文案
 	var rsp = rows.get("spear", {})

game/tests/unit/presentation/level_map_info_fog_test.gd

@@ -35,7 +35,7 @@ func _runner(db, nodes: Array, candidates: Array, n: int = 2):
 	var t := LevelTableScript.new()
 	t.info_visible_layers = n
 	t.rows = [{"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes}]
-	db.level = t
+	db.run.level = t
 	var r = load("res://core/level_runner.gd").new(db, load("res://core/rng_service.gd").new())
 	r.level_row.assign({"level_index": 1, "display_name": "夹具关", "rest_heal_pct": 30, "nodes": nodes})
 	r.node_index = -1

game/tests/unit/presentation/player_copy_sweep_test.gd

@@ -56,10 +56,8 @@ func _sweep_narrator() -> void:
 	var head := String(narrator.node_curio_header())
 	Kit.check("奖励点头部含「冒险牌库」（u3 机制事实①同库）〔wa4〕", head.contains("冒险牌库"))
 	Kit.check("奖励点头部含「属性值提升与补给」（u3 机制事实②渠道分流）〔wa4〕", head.contains("属性值提升与补给"))
-	Kit.check("奖励点头部含「同库分流」（u3 机制事实②措辞）〔wa4〕", head.contains("同库分流"))
-	Kit.check("奖励点头部零「同权重」旧话（u3 清零）〔wa4〕", not head.contains("同权重"))
-	Kit.check("奖励点头部零「同上限」旧话（u3 清零）〔wa4〕", not head.contains("同上限"))
-	Kit.check("奖励点头部零「提升池」旧话（u3 清零）〔wa4〕", not head.contains("提升池"))
+	for w in ["同权重", "同上限", "提升池"]:
+		Kit.check("奖励点头部零「%s」旧话（u3 清零）〔wa4〕" % w, not head.contains(w))
 	Kit.check("专长卡兜底==「专长\n???」（u11 换代——数据缺行真实兜底路径）〔wa3〕",
 		String(narrator.feat_card_text({})) == "专长\n???")
 
@@ -72,11 +70,11 @@ func _sweep_legend() -> void:
 		if String(e[1]) == "封印":
 			seal_row = e
 			break
-	Kit.check("图例封印行存在（wa5 夹具前提）〔wa5〕", not seal_row.is_empty())
 	Kit.check("图例封印行含「标空」（u4——与「标中」成对）〔wa5〕", String(seal_row[2] if seal_row.size() > 2 else "").contains("标空"))
 	Kit.check("图例封印行含「受挖掘惩罚」（u4 雷字清零换代）〔wa5〕", String(seal_row[2] if seal_row.size() > 2 else "").contains("受挖掘惩罚"))
-	Kit.check("图例封印行零「插错」（u4 旗族遗留词干清零）〔wa5〕", not String(seal_row[2] if seal_row.size() > 2 else "").contains("插错"))
-	Kit.check("图例封印行零「挖雷」（u4 雷字清零）〔wa5〕", not String(seal_row[2] if seal_row.size() > 2 else "").contains("挖雷"))
+	for w in ["插错", "挖雷"]:
+		Kit.check("图例封印行零「%s」〔wa5〕" % w,
+			not String(seal_row[2] if seal_row.size() > 2 else "").contains(w))
 
 
 # ⑤⑥ 来源名双源（u5/u6——状态槽消费半＋表值 ConfigDB 真装载＋battle_log 行消费半）

game/tests/unit/presentation/standee_fx_sweep_test.gd

@@ -81,7 +81,7 @@ func _init() -> void:
 	stage.on_step_row_fx({"type": "damage", "target": "地精", "target_id": "goblin_b"})
 	await create_timer(0.6).timeout   # 弹道到达拍 0.33s + 余量
 	Kit.check("伤害行按 target_id 命中正确站桩（闪白落点）〔wd12〕",
-		s2._flash_count == 1 and s1._flash_count == 0)
+		s2.fx_probe().flash_count == 1 and s1.fx_probe().flash_count == 0)
 	# 口二：enemy_standee_center —— id 先、display_name 兜底
 	var c_b = stage.enemy_standee_center("goblin_b", "地精")
 	var c_b_expect: Vector2 = stage.world_to_shell(s2.position + s2.box * 0.5)
@@ -91,14 +91,16 @@ func _init() -> void:
 	Kit.check("无 target_id 时按名兜底同旧行为（首命中）〔wd12〕", c_fallback != null and c_fallback == c_fallback_expect)
 
 	# ---- ① 意图蓄力档可达（d2）----
-	s1.set_pending("damage", "heavy")
-	Kit.check("蓄力技能（heavy）置 _intent_charge=true〔wd2〕", s1._intent_charge)
-	s1.set_pending("damage", "goblin_slash")
-	Kit.check("非蓄力攻击技（goblin_slash）零置位〔wd2〕", not s1._intent_charge)
-	s1.set_pending("buff", "goblin_rage")
-	Kit.check("增益系零置位〔wd2〕", not s1._intent_charge)
-	s1.set_pending("damage", "basic")
-	Kit.check("普攻零表示路径复位 _intent_charge〔wd2〕", not s1._intent_charge)
+	# 蓄力判据表：[kind, skill_id, 期望 _intent_charge, 个案标签]
+	var charge_cases := [
+		["damage", "heavy", true, "蓄力技能（heavy）置 _intent_charge=true"],
+		["damage", "goblin_slash", false, "非蓄力攻击技（goblin_slash）零置位"],
+		["buff", "goblin_rage", false, "增益系零置位"],
+		["damage", "basic", false, "普攻零表示路径复位 _intent_charge"],
+	]
+	for c in charge_cases:
+		s1.set_pending(c[0], c[1])
+		Kit.check("%s〔wd2〕" % c[3], s1._intent_charge == c[2])
 
 	# ---- ② 庆祝 tween 句柄纪律（d4）----
 	var ov = BattleEndScript.new()

game/tests/unit/presentation/theme_projection_test.gd

@@ -611,18 +611,6 @@ func _smoke_button_five_states() -> void:
 		is_equal_approx((dds as StyleBoxFlat).bg_color.a, 0.45))
 	Kit.check("V1 危险钮 disabled≠pressed", _sb_content_differs(dpr, dds))
 	db.free()
-	# V2 主题红线维持（Button 类型词条零接触＋focus 族词条零定义）——与 _smoke_global_theme 同判据复述
-	var th := ThemeDB.get_project_theme()
-	if th != null:
-		Kit.check("V2 红线维持 Button 类型词条零接触", not th.get_type_list().has("Button"))
-		var focus_hits := ""
-		for t in th.get_type_list():
-			for nm in (th.get_stylebox_list(t) + th.get_icon_list(t) + th.get_color_list(t)
-					+ th.get_font_list(t) + th.get_font_size_list(t) + th.get_constant_list(t)):
-				if "focus" in String(nm):
-					focus_hits += "%s/%s " % [t, nm]
-		Kit.check("V2 红线维持 focus 族词条零定义%s" % ("" if focus_hits == "" else "（违例：" + focus_hits + "）"),
-			focus_hits == "")
 
 
 # ---- 全局纹理过滤冒烟（工程设置 Nearest＋平滑渐变件 LINEAR 白名单；V3）----
@@ -636,7 +624,7 @@ func _smoke_texture_filter() -> void:
 	Kit.check("V3 白名单在位：暗角 vignette 显式 LINEAR",
 		vg.texture_filter == CanvasItem.TEXTURE_FILTER_LINEAR)
 	vg.free()
-	var bm = uikit_s.beams_rect()
+	var bm = uikit_s._beams_rect()
 	Kit.check("V3 白名单在位：光柱 beams 显式 LINEAR",
 		bm.texture_filter == CanvasItem.TEXTURE_FILTER_LINEAR)
 	# T4 光柱连续 alpha 结构断言（观感归目检）：带心峰值 0.05/带缘连续过渡/纵向衰减上亮下暗
@@ -661,7 +649,7 @@ func _smoke_texture_filter() -> void:
 	Kit.check("T4 光柱纵向衰减生效（上半亮度 %.0f > 下半 %.0f 的 2 倍——上亮下暗）" % [top_sum, bot_sum],
 		top_sum > bot_sum * 2.0)
 	bm.free()
-	var gb = uikit_s.gradient_base(Color.BLACK, Color.WHITE)
+	var gb = uikit_s._gradient_base(Color.BLACK, Color.WHITE)
 	Kit.check("V3 白名单在位：地图渐变 gradient_base 显式 LINEAR",
 		gb.texture_filter == CanvasItem.TEXTURE_FILTER_LINEAR)
 	gb.free()

game/tests/unit/presentation/type_glow_test.gd

@@ -64,12 +64,10 @@ func _test_grouping_closed() -> void:
 	for bad in ["keystone", "", "ATTACK", "aoe", "blast_mine", " heal"]:
 		Kit.check("清单外值「%s」→ GLOW_NONE（禁静默空光）" % bad,
 			UiKitScript.glow_group_for_cell_type(bad) == UiKitScript.GLOW_NONE)
-	# 与卡顶带 tg_band 的归组差异锚定（Q3 甲案两带并存、禁互引）：blast 在格面带归群伤、
-	# 在卡顶带归魔法（E5 回滚既存行为）——若将来误把两带统一，本断言红
+	# 与卡顶带 tg_band 的归组差异锚定（Q3 甲案两带并存、禁互引）：blast 在卡顶带归魔法（E5 回滚既存行为）
+	# ——格面带 blast→群伤由上方九型封闭循环的 TYPE_EXPECT["blast"] 承载，此处不重述
 	var band_blast: Color = UiKitScript.tg_band("blast_charge")
 	Kit.check("两带并存锚定：卡顶带 blast→TG_MAGIC（E5 回滚既存行为未动）", band_blast == UiKitScript.TG_MAGIC)
-	Kit.check("两带并存锚定：格面微光 blast→群伤组（与卡顶带刻意不同）",
-		UiKitScript.glow_group_for_cell_type("blast") == UiKitScript.GLOW_AOE)
 	# 色值出口：五组各取本组常量；无组/越界组号 → 全透明（不画）
 	Kit.check("glow_color_for_group 群伤组 = TG_GLOW_AOE",
 		UiKitScript.glow_color_for_group(UiKitScript.GLOW_AOE) == UiKitScript.TG_GLOW_AOE)
@@ -92,13 +90,8 @@ func _test_frozen_hue_face() -> void:
 		var ds: float = absf(m.s - f.s)
 		Kit.check("冻结色相保持：%s ΔH=%.3f° ≤0.2° 且 ΔS=%.4f ≤0.01（只动明度档）" % [g, dh * 360.0, ds],
 			dh <= 0.2 / 360.0 and ds <= 0.01)
-	# 群伤组专锚（#A61D37）：H/S 与冻结逐位一致、V=0.65 档
-	var aoe_f: Color = FROZEN["AOE"]
+	# 群伤组专锚（#A61D37）：V=0.65 明度档——H/S 两腿由上方逐组循环的 ΔH/ΔS 阈承载
 	var aoe_m: Color = UiKitScript.TG_GLOW_AOE
-	Kit.check("群伤组专项：H 与冻结 #FF2D55 差 %.4f°（零移动）" % (absf(aoe_m.h - aoe_f.h) * 360.0),
-		absf(aoe_m.h - aoe_f.h) < 0.001)
-	Kit.check("群伤组专项：S 与冻结差 %.4f ≤0.01（8bit 量化噪声级）" % absf(aoe_m.s - aoe_f.s),
-		absf(aoe_m.s - aoe_f.s) <= 0.01)
 	Kit.check("群伤组专项：V=0.65 明度档（ provisional 域内）", absf(aoe_m.v - 166.0 / 255.0) < 0.002)
 
 

game/tests/unit/presentation/ui_font_asset_test.gd

@@ -15,10 +15,19 @@ func _init() -> void:
 	var f: Font = UiKitScript.load_font(path)
 	Kit.check("随包字体守卫装载非空（res://assets/fonts/ui_font_fusion_pixel_zh_hans.ttf）", f != null)
 	if f != null:
-		Kit.check("中文字形在集（攻/雷/旗/封）", f.has_char("攻".unicode_at(0)) and f.has_char("雷".unicode_at(0)) \
-			and f.has_char("旗".unicode_at(0)) and f.has_char("封".unicode_at(0)))
-		Kit.check("中文字形在集（危——已开危险格字形换代前置，迭代36 u12/wa9）", f.has_char("危".unicode_at(0)))
-		Kit.check("ASCII/数字字形在集（A/0/%）", f.has_char("A".unicode_at(0)) and f.has_char("0".unicode_at(0)) and f.has_char("%".unicode_at(0)))
+		# 字形集表：[个案标签, 须在集字符]——缺字明细进消息
+		var glyph_groups := [
+			["中文字形在集（攻/雷/旗/封）", "攻雷旗封"],
+			["中文字形在集（危——已开危险格字形换代前置，迭代36 u12/wa9）", "危"],
+			["ASCII/数字字形在集（A/0/%）", "A0%"],
+		]
+		for g in glyph_groups:
+			var missing := ""
+			for i in String(g[1]).length():
+				var ch := String(g[1])[i]
+				if not f.has_char(ch.unicode_at(0)):
+					missing += ch
+			Kit.check("%s（缺=%s）" % [g[0], missing if missing != "" else "无"], missing == "")
 		var sz := 18
 		var w_cn: float = f.get_string_size("战斗胜利", HORIZONTAL_ALIGNMENT_LEFT, -1, sz).x
 		var w_label: float = f.get_string_size("攻击 2", HORIZONTAL_ALIGNMENT_LEFT, -1, sz).x